Past week

Gone for most of last week on work-related travel to DC, and just now catching up:

  • My travel mojo is alive and well: I made it home without any interruptions or delays for a change, but awoke on the date of my scheduled departure to find a text message from Delta indicating my first leg had been canceled and that I had been rebooked on a different set of flights arriving (thankfully) very late the same day.
  • A new CFML server showed up last week: Lucee, a fork from Railo and which likely spells the end of Railo as a thing. I’ve deployed it via Tomcat on two of the systems where I do development so that I can play with it a bit.
  • 4,700 spam comments on various entries in my blog. Ugh.
  • TUAW is being shut down. Ugh. That’s a loss, as TUAW has been one of my go-to sites for keeping tab on all things Apple, Mac OS X, and iOS.

Setting Up a Fake SMTP Server

On my team’s various development boxes (which are almost always laptops and therefore not always connected to our corporate intranet and sometime not on any network), we have typically configured our ColdFusion and Railo application servers to use our internal mail servers. Many of our Web applications send user-composed, automated, or process-based email messages, in addition to security-related event notifications. We’ve been bitten a couple of times in developing this mail-related logic, with messages being generated and sent to real system users from our development servers which, as you can imagine, has significant potential for generating concern and/or confusion on the users’ part. This hasn’t happened recently, in part because we are collectively more careful and in part based on our approach to how email gets addressed depending on whether the app is running on a development, testing, or production server.

I’ve long believed that a safer approach would be to configure our non-production servers to use something other than a “real” mail server. I’m in the process of standing up a new development system for myself, and decided I was going to poke at this a bit. For this first foray, I wanted something

  • simple to set up, configure, start, and stop
  • free
  • preferably available cross-platform (my team develops on Mac OS, Linux, and Windows systems based on developer preference for platform)
  • completely local (because of the need to be able to run without being on a network)

A solution would need to support SMTP, as both the ColdFusion and Railo application servers are configured to talk to an SMTP server. Anything beyond that set of basic requirements would be a bonus.

After a bit of looking, I decided to use FakeSMTP. It ticks all of the above boxes, and is implemented as a single Java JAR compatible with Java 1.6 and above. It has a simple UI for watching activity and  “outbound” mail handed to it, and can easily be configured to store transmitted mail messages to disk as .eml files for review (making developing email-related content fairly straightforward).

I use a bash shell script to start and stop my Tomcat instances for ColdFusion and Railo, so I added logic to that script to optionally start and stop my local mail server, as follows (wrapped here only for presentation):

# Start our fake SMTP server:
if [ "${3}" = "mail" ]; then
  java -jar ~/opt/fakesmtp/fakesmtp-1.13.jar -s -b -p 2525 \
    -o ~/opt/fakesmtp/out/ -a 127.0.0.1 \
    >> ~/opt/fakesmtp/logs/fakesmtp-`date +%Y%m%d`.log &
fi

and

# Stop our fake SMTP server:
if [ "${3}" = "mail" ]; then
  kill `ps -a > /tmp/ps.out && grep -i fakesmtp /tmp/ps.out | \
    cut -f 2 -d ' ' -`
fi

The start logic runs the mail server in the background (as I really don’t intend to use the UI), listening on address 127.0.0.1 and port 2525 (to avoid needing to run with elevated privileges on the default SMTP port of 25). It dumps mail messages to a folder for review, and logging server activity to a log file with a date-based name. The stop logic finds the mail server process and kills it.

I’ve tested it with both ColdFusion and Railo application servers, and it works. I will probably add some shutdown-related logic to do a bit of cleanup to make sure neither the log files or the saved email files get out of control.

Final thought: If it weren’t for my desire to be able to run completely standalone at times where I either do not have access to or do not want to use a network connection, I probably would have gone with something like Debug Mail. I have not used it, but it looks excellent. Given Railo’s ability to configure multiple mail servers, I may still play with it a bit as part of my solution.

New Dev Boxes

It is time: I’m standing up a couple of new development systems, so I am going to use Tomcat 8 and Java 8 as the basis for deploying Railo and Adobe ColdFusion 10 on them. This is the first time I’ve done anything with either Tomcat 8 or Java 8 as the base for the application server stack but with Java 7 set for EOL this (I first wrote “next”) year, the timing for moving seemed appropriate.

I have Railo deployed and running without issue on the first of the two systems, and have encountered no issues at all to this point.

I will blog a bit in the near future to describe my approach and a couple of minor Tomcat differences I have found.

Updated 2014-01-02: Well, that didn’t take long to go sideways… I spent several hours this afternoon trying to deploy ColdFusion 10 on Tomcat 8, and so far have been unsuccessful. I can get the WAR to unpack, but the application simply refuses to start with a very non-specific error in the Catalina log file that (I’m guessing here) appears to indicate an incompatibility with Tomcat 8 in ColdFusion 10. More to come, but my next run at this will probably be to drop back a step or two and try deploying on Tomcat 7 and Java 8.

Updated 2014-01-03: Moving forward again. As of this morning, I now have both Railo 4 and ColdFusion 10 deployed against Tomcat 7 and Java 8.

Adobe ColdFusion Docs: A better way?

I’m not a fan of the structure the Adobe ColdFusion (ACF) team has moved to for documentation for the recent versions of their product.

A bit of background

With the recent (late May 2014) release of ACFv11, there are now three versions of ACF in which I have varying degrees of interest:

  • v9: we are in the final stages of moving our last app from a shared v9 server to one of our dedicated v10 servers,
  • v10: our entire dev environment is based on v10, and all of our apps with the noted exception above run on v10 in production, and
  • v11: the recent release we’ve watched from a distance as we weigh whether to continue with ACF in the future or shift to Railo as our CFML engine.

My team has used ColdFusion since its Allaire v4 days, and have historically had multiple versions in play across our development and production environments, so the above situation covering three versions is very typical for us. In fact, having all of our dev and production environments based on a single version of ACF as we (almost) do now represents the first time in at least 10 years we’ve been able to achieve this. I don’t believe we are unique in this: any developer moving between versions of the product (or even considering such a migration) will be working with at least two versions of the language and/or the documentation before and during their migration effort.

In addition, I built and continue to maintain a CFML language mode for ActiveState’s Komodo IDE and Edit editors, providing syntax highlighting and tag/tag attribute completion. The tag/tag attribute completion is specific to each CFML version, allowing the user to designate which version of the language is to be used as the basis for which tags and which attributes are to be provided as options to the user. I rely heavily on version-specific documentation to build each of these version-specific implementations.

The problem with the current wiki approach

In recent versions of ACF up through v9, each version had comprehensive documentation sets available both online and as downloadable PDFs. Each of these documentation sets were separate and distinct, and the online versions made it very straightforward to shift between versions. With v10, there is a downloadable PDF version of the documents (thanks to Adam Cameron for pointing me toward those) but the only references to it are not particularly easy to find (search the wiki for “archive” — how obvious is that if you are looking for v10 documentation?). Googling for “adobe coldfusion 10 documentation” does not yield that set of documents in the first page of results. Further, there does not seem to be an online version of some portions of the v10 (such as the tag/function reference). The current online version of the documentation is maintained as part of a wiki that does not contain discrete sections for different versions of the product or language, and for the most part appears to be focused on v11.

The old version-specific implementation of the online docs has the tremendous benefit to the user of being crystal clear as to what capabilities are available in a given version of the language (e.g., which attributes are available for a given tag, what functions/function arguments are available). If I am working on an app currently running on version “x” of ACF, I typically want to see only the version “x” documentation for that tag.

The current wiki-based documentation set, however, does not have that clear distinction between versions of the product or language. This makes differentiating between versions for tags, attributes, supported attribute values, functions, etc., in terms of what is valid and supported between versions far more challenging and error-prone than in previous versions. If I care about the v10 implementation of the cfzip tag, for instance, I have to either use the off-line version of the docs or make sure I look at the “history” portion of the relevant tag page and then mentally remove the new attributes added for v11 (“password” and “encryptionalgorithm”, in this particular case) as I scan down through the attribute documentation — particularly given that there is nothing within the description of the individual attributes indicating their recent addition in v11 (and in the case of the “password” attribute, it seems to be missing altogether from the attribute list).

A better approach?

It seems to me that a better approach would be for separate, discrete version-specific sections within the wiki. The language reference — along with the supporting documents identifying additions, removals, and deprecations — is one example of where this would make the documentation much easier to use. The v10 portion of the reference would always be specific to v10 and would not (should not?) need to contain any v11 content. The v11 portion of the reference would presumably start as a clone of the v10 portion of the documentation, and could evolve along with the language as v11 was developed. As work on v12 is started, the v11 portion would be cloned as a draft and evolve independently from the sections covering previous versions.

The current wiki approach is likely to get more and more unwieldy as additional versions of the product and the language are covered within the current wiki structure. Take the page listing deprecations and removals as an example. Besides being in drastic need of updates as of this writing for completeness and currency with v11, this page — based on its current structure — will get more and more unwieldy as additional versions have to be covered: more rows to cover features being deprecated or removed, and more columns for subsequent versions? The current approach just does not seem to scale for pages such as this.

Note that I am not taking issue with the use of a CMS or wiki for the documentation itself as much as what I see as a poor decision of how to structure the documentation within the tool the ACF team selected.

Finding documentation for earlier, but still-supported, versions of a product should not be difficult but in this case it is getting harder. I’d like to believe the ACF documentation team will recognize this and restructure the documentation set before it collapses under its own weight and degenerates even further in terms of being usable and useful.

And the off-line docs?

The current wiki structure — which seems to be focused mostly on the current language version — also raises the question for me as to whether a similar set of downloadable v11 references will be made available now that the product is available or as the wiki gets refocused on v12 (presumably in the near future, immediately after all of the existing v9/10/11 bugs have been resolved). That’s a separate but important and relevant question. I hope they do continue making that format available, as those downloadable PDFs have repeatedly proven valuable for me and my team at various times.

Komodo-CFML: minor updates

I’ve just pushed a couple of minor updates to Komodo-CFML:

  • Better highlighting for numerical HTML character entities to address some goofiness based on their inclusion of the “#” character (e.g., #)
  • Fix to the DTD for ACF10 to address an error in the Adobe tag documentation for the CFIMAGE tag

I’ve also updated the example configuration file for HTMLTidy that I use to let Komodo know which CFML tags are considered valid tags to include the new tags brought to the table by ACF10.

Both of these updates are available on the Komodo-CFML page.

I’m currently working on building a DTD specific to the Railo CFML engines, and hope to provide support for both their current v3.3.x and preliminary v4.x products at some point in the next couple weeks.