Here is the message I was seeing:

ERROR: Error cloning remote repo 'origin' : Could not clone https://username@github.com/username/repository.git
ERROR: Cause: Error performing git clone -o origin https://username@github.com/username/repository.git /srv/hudson/jobs/repository/workspace
Trying next repository
ERROR: Could not clone from a repository
FATAL: Could not clone
hudson.plugins.git.GitException: Could not clone
at hudson.plugins.git.GitSCM$2.invoke(GitSCM.java:587)
at hudson.plugins.git.GitSCM$2.invoke(GitSCM.java:535)
at hudson.FilePath.act(FilePath.java:753)
at hudson.FilePath.act(FilePath.java:735)
at hudson.plugins.git.GitSCM.checkout(GitSCM.java:535)
at hudson.model.AbstractProject.checkout(AbstractProject.java:1038)
at hudson.model.AbstractBuild$AbstractRunner.checkout(AbstractBuild.java:479)
at hudson.model.AbstractBuild$AbstractRunner.run(AbstractBuild.java:411)
at hudson.model.Run.run(Run.java:1257)
at hudson.model.FreeStyleBuild.run(FreeStyleBuild.java:46)
at hudson.model.ResourceController.execute(ResourceController.java:88)
at hudson.model.Executor.run(Executor.java:129)

To solve the problem we need to create an ssh key for the tomcat user so that it can access the repository.

cd /usr/share/tomcat6
sudo mkdir .ssh
cd .ssh/
sudo touch known_hosts
sudo ssh-keygen -t rsa -C "tomcat@forthedeveloper.com"

When creating the key pair save the key to /usr/share/tomcat6/.ssh/id_rsa.

I don’t know how to tell tomcat the passphrase for a ssh key, so I just left the passphrase blank.

Once the key has been created we need to add the github site to the known_hosts file. If you have already setup your normal account for working with github and have xclip installed you can run the following to copy the github ssh host information:

ssh-keygen -F github.com | xclip -sel clip

Edit the /usr/share/tomcat6/.ssh/known_hosts file and paste in the copied host information.

To finish things up:

sudo chown -R tomcat6:tomcat6 /usr/share/tomcat6/.ssh/
sudo /etc/init.d/tomcat6 restart

You can copy the new ssh key for tomcat to your clipboard if you have xclip installed with:

cat /usr/share/tomcat6/.ssh/id_rsa.pub | xclip -sel clip

If you are only using hudson for one repository you can just add the public key to the one repository in the repository admin (ex: https://github.com/username/repository/edit) under the ‘Deploy Keys’ area. Otherwise you can add it to your account’s ‘SSH Public Keys’ to allow the tomcat server access to all of your repositories.

Now when you run hudson against your private github repository it should have the proper access.


Caused by: hudson.plugins.git.GitException: Command returned status code 128:
*** Please tell me who you are.

Run

git config --global user.email "you@example.com"
git config --global user.name "Your Name"


I was a little confused to see this message since I had already configured git to have my user name and email. Then I remembered that hudson is running on tomcat which is running with the tomcat6 user. I needed to configure the tomcat6 user to have the git configuration necessary to tag on the git repositories.

[UPDATE: 24 Jun 2010]

I was working on repeating this process on Ubuntu 10.04 and was getting permission errors running the command to set the git config for the tomcat6 user. Here is an updated method:

First we need to create a .gitconfig file for the tomcat6 user:


sudo touch /usr/share/tomcat6/.gitconfig
sudo chown tomcat6:tomcat6 /usr/share/tomcat6/.gitconfig
sudo nano /usr/share/tomcat6/.gitconfig


Place the following in the .gitconfig file:


[user]
name = Hudson
email = hudson@myDomain.com


Once the file is saved–you may need to restart Tomcat–it should pick up your git configuration.

[/UPDATE]

[ORIGINAL: see updated instructions above]

Setup the git configuration for the tomcat6 user by doing the following:


sudo -s -H -u tomcat6
git config --global user.name "Hudson"
git config --global user.email "hudson@mydomain.com"
exit


As a note, if you are using hudson to commit and push to another repository these configuration settings will be used for all commits done by Hudson.

The next step is to let hudson know where the HOME is for the tomcat6 user. On the hudson/configure page there is a checkbox for defining environment variables. Once it is checked you will be able to put in a key-value pair. Add the following pair and save your configuration:


name: HOME
value: /usr/share/tomcat6/


The next time a hudson project is built you should see the following line close to the top of the console output:

Env: HOME=/usr/share/tomcat6/

[/ORIGINAL]

The git plugin should now be able to successfully tag the repository and continue with the build.

Specifying a version of “1.8.2″ will select the obvious version. This is because a fully specified version was used. Specifying a version of “1.8″ would select version 1.8.4 since this is the highest versioned release in the 1.8 branch. For much the same reason, a request for “1″ will end up loading version 1.9.1.

Google AJAX Libraries API Developer’s Guide

For example, if I were linking to jQuery I would normally have used the following and updated semi-regularly:

http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js

But if I just want the latest for the “1.3″ version I could reference:

http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js

Or if I was feeling really risky and trust jQuery not to break between versions:

http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js

Hope its as useful to others as I found it!

For this example, we are going to add a virtual host for the snow.ftd host.

Jetty Setup

Jetty makes it really easy to configure virtual hosts for a context.

The configuration file in Railo Express at {railo-express-directory}/contexts/railo.xml already has the configuration setup to start us off:

<!-- virtual hosts
<Set name="virtualHosts">
	<Array type="String">
		<Item>www.myVirtualDomain.com</Item>
		<Item>localhost</Item>
		<Item>127.0.0.1</Item>
	</Array>
</Set>
-->

Uncomment the block of code and change the item to match the snow.ftd host name like so:

<!-- virtual hosts -->
<Set name="virtualHosts">
	<Array type="String">
		<Item>snow.ftd</Item>
	</Array>
</Set>

Local Host Setup

I already posted instructions for adding local hosts to your Snow Leopard. You can follow the directions there to setup your desired host. In linux you can modify your hosts file in a similar fashion. There may even be a way to change your hosts file on windows, although I have never done so.

Testing

Once the Jetty config and the local hosts have been updated, restart Railo—if it is running—and go to snow.ftd:8888 in your browser. You should see the same page available at localhost:8888.

And you are done! You can now add as many hosts as you need!

Using the dscl Utility

With the wonder of Google searching and the generous comments of others I found out about the dscl utility.

Listing Host Entries

To see what is listed for your hosts at any time just run this command:

dscl localhost -readall /Local/Default/Hosts

Adding a New Entry

In this example I am going to have the snow.ftd host point to my 127.0.0.1 IP address:

sudo dscl localhost -create /Local/Default/Hosts/snow.ftd IPAddress 127.0.0.1

You should now be able to ping snow.ftd and have it resolve to your local computer.

Removing an Existing Entry

If you decide you do not want an entry anymore just run this command to remove it:

sudo dscl localhost -delete /Local/Default/Hosts/snow.ftd

Reading the BSD Flat File

It was also noted that you can read the BSD flat file using this command:

dscl localhost -readall /BSD/local/Hosts

To me, the ternary operator is what the IIF() method call always wanted to be.

Unfortuately I was testing some CFML code, written and working on Railo, on a ColdFusion 9 server and had this error pop up:

Unable to find an operator implementation for coldfusion.compiler.ASToperator

Turns out the the ternary operator works great… unless you are using it in a default value for an argument. Fail.

Here is an example, that should run fine if the ternary operator was doing what it is supposed to:

<cffunction name="testing" access="public" returntype="void" output="false">
	<cfargument name="test" type="string" default="#(1 EQ 1 ? 'Hi' : 'Bye')#" />

	<!--- Anything --->
</cffunction>

I have filed it as a bug if you would like to vote on the issue.

Step 1: Download Needed Files

The first step is to download all the files you will need. Since the downloads usually take some time we’ll get them out of the way first.

For my installation I wanted to get more familiar with the Server edition of Ubuntu and to require fewer resources. You should be able to do a similar installation with the Desktop edition.

• Download VirtualBox – The official VirtualBox download page.
• Download Ubuntu – To download the Server edition you will need to find a mirror that hosts the installer images. Once you find a mirror navigate to the 9.10 directory and find the download link for the ubuntu-9.10-server-i386.iso file.
• Download ColdFusion – The official Developer Edition Download is available on the Adobe ColdFusion page. Download the Linux 32 bit installer.

Step 2: Install VirtualBox

Once you have downloaded all the files, run the VirtualBox installer.

If you would like to learn more about VirtualBox the installation comes with a user manual or you can download a pdf copy from their download page.

Step 3: Create an Ubuntu Virtual Machine

Click the New icon in VirtualBox to start the wizard for adding a new VM.

1. Click Next to start the wizard.
2. Enter Ubuntu CF for the Name of the VM.
3. Select Linux and Ubuntu in the OS Type drop downs.
4. Click Next.
5. Click Next to accept the default amount of RAM. (You can adjust if you want to…)
6. Click Next to create a new hard disk image to use for the VM.
   1. Click Next to start the wizard .
   2. Click Next to create a dynamically expanding storage.
   3. Click Next to accept the default name and size.
   4. Click Finish to accept the choices for the disk image.
7. Click Finish to end the wizard.

Step 4: Install Ubuntu

Now that there is a VM setup to hold the guest Ubuntu system we need to install Ubuntu on it.

In VirtualBox Double Click on the Ubuntu CF listed in the left column to start up the VM. Since this is the first time you are starting the VM it will bring a up a First Run Wizard to guide you in setting up the new VM.

1. Click Next to start the wizard.
2. Change the Media Source to Image File and click the Other... icon.
   1. Click the Add icon along the top.
   2. Select the ubuntu-9.10-server-i386.iso file we downloaded earlier.
   3. Click Select with the ubuntu-9.10-server-i386.iso item selected.
3. Click Next to continue.
4. Click Finish to end the wizard.

The VM should now startup and bring up the installation the Ubuntu. I’m not going to go into the details of installing Ubuntu here, so just continue with the next step once Ubuntu installation is complete. Also, since we are going to be using apache you may wish to have the setup create a LAMP server configuration when choosing features or you can install it manually afterwards.

Step 5: Setup Guest Additions

In order to have the Shared Folders work we will need to install the Guest Additions.

Before we install the Guest Additions we will need to install dkms:

sudo apt-get install dkms

To mount the Guest Additions disc image to the VM press Command + D or select Devices > Install Guest Additions... from the VM menu. Then install the Guest Additions by running:

cd /cdrom

sudo sh ./VBoxLinuxAdditions-x86.run

Step 6: Setup Shared Folders

One of the goals when creating the virtual machine was to be able to edit the files natively but run them on the guest operating system that reflects the production environment.

With shared folders we are able to use a local directory as a share on the guest VM.

Before we add the shared folder we need to have a folder to share. For this example I’m using the directory I created at /Users/randy/Documents/cf9/.

With the VM powered off edit the Settings and select the Shared Folder icon.

1. Click the Add a new shared folder definition icon on the right side.
2. Enter the Folder Path (/Users/randy/Documents/cf9/) or select Other... from the drop down and locate the directory.
3. Enter the name you would like the share to be referenced as in the Folder Name field. In this case I am going to call it cf9.

Now that we have the shared folder available to the VM we want it to mount the share each time the VM starts. To do this we startup the Ubuntu VM and edit the /etc/fstab file and add the following line at the end of the file (note that you will need to change the username to match your user):

cf9	/home/randy/Documents/cf9	vboxsf	uid=randy,gid=users	0	0

You will also need to create a blank directory at /home/randy/Documents/cf9 that the share will mount to.

The next time your VM is started it should have access to /Users/randy/Documents/cf9 on the host machine at /home/randy/Documents/cf9 on the guest machine.

Step 7: Enable Port Forwarding

To setup the port forwarding you will need to stop the VM. In the terminal run the following commands to setup the port forwarding. (Note that "Ubuntu CF" needs to match the name of the VM created above.)

VBoxManage setextradata "Ubuntu CF" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/guesthttp/Protocol" TCP
VBoxManage setextradata "Ubuntu CF" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/guesthttp/GuestPort" 80
VBoxManage setextradata "Ubuntu CF" "VBoxInternal/Devices/pcnet/0/LUN#0/Config/guesthttp/HostPort" 8580

This will change the VM settings to have the guest port of 80 (which is the default apache port) of the guest forwarded to port 8580 on the host. Without this you would not be able to talk to the guest operating system.

Step 8: Install ColdFusion

Since we already downloaded the installer for ColdFusion we just need to get that file to the VM. Luckily we already setup a shared folder so if you move the installer to the /Users/randy/Documents/cf9/ directory it will be available in the VM.

To run the ColdFusion installer:

cd /home/randy/Documents/cf9/

chmod +x ColdFusion_9_WWE_linux.bin

sudo ./ColdFusion_9_WWE_linux.bin

This should start the installer. During the installation, apache should be configured to run with ColdFusion.

Step 9: Test Environment

To test that the development environment is working correctly you should be able to place an index.cfm file in your /Users/randy/Documents/cf9/ directory. Make sure that you place some CFML in the file to test that ColdFusion is doing it’s thing. Then visit http://localhost:8580/ in a browser on your host to test out the new development environment!

I found out that it is quite simple to upgrade:

• Download and unarchive the version of Jetty you are upgrading to (ex: 6.1.20).
• Stop Railo Express.
• Delete the old jetty and jetty-util jars from the Railo Express /lib directory (ex: jetty-6.1.2.jar and jetty-util-6.1.2.jar).
• Copy the jetty-6.1.20.jar and the jetty-util-6.1.20.jar from the jetty lib/ directory to the Railo Express lib/ directory.
• Start Railo Express.

Not much too it, but it seems to be working just fine and the MXUnit ant tasks are now running as expected.

This is not a completely automated solution, there is more that you could do to improve the process, but it should save a lot of the time normally spent updating WordPress.

Note: the provided script will only work if you do the WordPress install using subversion and in the domain/sub-domain’s html/ directory.

Installing WordPress

Yes, there is a 1-click install for installing WordPress on the (gs), but I don’t use it. Here is how I install WordPress on a domain or sub-domain (ex: blog.site.org):

1. Ensure that you have an alternate domain or sub-domain created that has an empty html/ directory.
2. Find the latest tag listed in the WordPress repository. (ex: 2.8.3)
3. SSH into the (gs) as the serveradmin.
4. cd domains/blog.site.org/html
5. svn checkout http://svn.automattic.com/wordpress/tags/2.8.3/ ./ --force

Once the svn checkout is complete you should be able to visit the install page (ex: blog.site.org/wp-admin/install.php) and finish the installation of WordPress like normal.

I also suggest you take steps to harden your WordPress install.

Upgrading Many WordPress Installs at Once

When you learn of a new version of WordPress you can do the following to easily upgrade all of your installations at once.

1. SSH into the (gs) as the serveradmin.
2. You will need to upload the updateWP bash script to your serveradmin home directory (~/) if it does not already exist.
3. Run the bash script with the new version number: ./updateWP.sh 2.8.4
4. The script will look at each of your domains to see if you have WordPress installed. If it finds WordPress it will switch to the new tag.
5. After all the installs are updated you can view the updateWP.log to see all of the installations that were completed. On some tags you may need to go to each of the /wp-admin/ page and manually tell it to update the database. You can check if this is necessary by visiting one of your WordPress install’s /wp-admin/ directory.

Preparing for Updating

In the main mxml document I add a namespace for my ef-flex event maps (xmlns:efmaps="com.ef.air.maps.*") and the following line:

<!-- Automatic update event map -->
<efmaps:UpdateEventMap />

Once included, the Mate knows how to handle the update event and is listening for it. See the prosperonair main mxml for an example.

Automatic Update Checking

Using the event driven nature of Mate to check for an update–automatically or manually–is now as easy as dispatching an event. See the prosperonair event map for an example.

To automatically check for an update edit the application’s event map, add the import for the UpdateEvent, add an event handler for the AIREvent.WINDOW_COMPLETE event, and add the following (changed for your project):

<!-- Automatically check for newer version -->
<mate:EventAnnouncer generator="{UpdateEvent}" type="{UpdateEvent.CHECK}">
	<mate:Properties isAutomatic="true" versionURL="http://project.googlecode.com/svn/trunk/version.xml" />
</mate:EventAnnouncer>

Manual Update Checking

The process for checking for an update manually is almost identical to the automatic update check save for changing the isAutomatic property to false. This lets the updater know that the user should be notified when there is no update.

Version XML File

For the updater to work correctly you will need to have a XML file in your repository that the application will use to check if it has the latest version. You can read more about the format the xml file needs to use in the official documentation for the ApplicationUpdaterUI. Be sure that you pass the correct url of the XML file when doing an update check.

The Code

The code used in this post is available in the prosperonair and ef-flex projects. The main code of interest that performs the update can be seen in the UpdateManager.as file.

With the wonderful advances in the cloud I decided to see what it could do for me. After doing a little searching I found a post or two about it and I decided to try it out myself.

To use Amazon’s S3 for the vault I need to have it be mounted as a drive. I chose to use a product called Jungle Disk to mount and manage my S3 account. Jungle Disk has clients for all the operating systems and a version for portable drives that has all three clients.

Once I had setup a bucket with Jungle Disk I was ready to create my vault with Aperture. The way that Aperture is programmed it won’t allow you to directly setup the vault on a network drive. To get around that I create the vault onto the desktop. Once the vault is created you will notice that it has the locked symbol next to it. I closed Aperture and removed the locked status from the file. Then I moved the vault onto the S3 drive.

I had about 35GB library of photos when I created the vault. Since this is all going over the internet it is going to take a while for all the files to copy over, which is to be expected. I was luckly on a university connection so the wait wasn’t as long as it was for some.

After the files all successfully copied over to the S3 account load up Aperture. Right click on the vault that was just created and select the Update Vault Path… From there you should be able to browse to your S3 network drive and select your vault.

When I had taken some more pictures and went to update the vault I found the big reason that I probably would not use the S3 for anything but periodic (quarterly or semi-annually) backups. When I updated the vault it seemed to want to touch and/or copy every file. If you are on a local drive this wouldn’t be much of a problem, but since you are doing this over the internet it seemed to take about as long as the original move of the library. It might not have taken as long since I just left it working overnight I didn’t know for sure.

Just remember, if you do plan on using the S3 for aperture not only are you paying for the space, which is very inexpensive, but you are also paying for each request for a file so it does add a few dollars each time you do a vault update. Overall I would still use it as a periodic off-site backup but would not rely upon it for my day-to-day backups.

Something that I found out in the recent months and finding very useful is the reverse-i-search. By pressing ctrl + r in the terminal (works at least in ubuntu and OS X, probably all real terminals) you are given a console line like the following:

(reverse-i-search)`':

As you type the terminal will search through your terminal history and locate any commands that contain what you search.

For instance if you type ssh it will start searching through the history and show you the last one that you used that had ssh in the command. If the first result isn’t the one that you are looking for you can press ctrl + r to keep the search going and cycle back through your history.

I am still amazed by all the things that I am learning about *nux operating systems and I am only touching the surface.

But the problem, for me at least, was finding the urls to ping so that you are not waiting for the giants to get a sweet tooth and come looking for you. The page on informing giants talks about a magical searchengine_URL that can be replace by your supporting giant. The problem: the site never tells what searchengine_URLs exist for your giant companions.

After some searching I finally found the urls that I was looking for. Where did I find the mystical urls you ask? Well it wasn’t from a google search (returned a lot of non-helpful links), it was from a wordpress plugin. In my opinion it is not a very good way to promote a service that is supposed to make it easier for you to get your content into the giants’ mouths.

Without further ado here are the urls that should work for sending your updated Sitemap to the search giants:

• http://www.google.com/webmasters/sitemaps/ping?sitemap=<url>
• http://submissions.ask.com/ping?sitemap=<url>
• http://webmaster.live.com/ping.aspx?siteMap=<url>
• http://search.yahooapis.com/SiteExplorerService/V1/updateNotification?appid=<Yahoo! Developer Key>&url=<url>

I would also suggest reading the other options for informing the search engines, such as adding ‘Sitemap: <url>’ to your robots.txt file and actually visiting to the giants’ playground.

Using the Sun Java

I started off by doing your standard Google search and came up with this page listed promently on the Ubuntu community site:

https://help.ubuntu.com/community/EclipseIDE

I followed the instructions to get the Java 6 from Sun installed on the system. But I stopped after the install of Java 6 since my install is basically a download of eclipse it wasn’t going to have the /etc/eclipse/java_home that was described on the community page.

With a little more searching I came across this page which gave a brief description his installation. From his post I edited my ~/.bashrc file and added in the export JAVA_HOME=/usr/lib/jvm/java-6-sun/ so that my default JAVA_HOME would be the sun java.

Getting Eclipse

To get the latest eclipse distribution I went to the eclipse download page and downloaded the eclipse classic, my preferred base distro. Once I had the file I extracted the eclipse directory. I’m not a linux guru and didn’t know the ‘best’ place to put the eclipse directory so i put it in /opt/.

Running Eclipse

Once I had the application in the directory I decided to add it to my applications menu. I did so by right clicking on the ‘Applications’ menu and selecting the ‘Edit Menus’ option. From there I went into the Applications > Programming menu on the left side and created a ‘New Item’. I chose the type of ‘Application’ and a name of ‘Eclipse’. For the command I entered ‘/opt/eclipse/eclipse -vm /usr/lib/jvm/java-6-sun/bin/java’ just to make sure that eclipse was being loaded with the correct jvm.

Using Eclipse

So far I have not had any problems with any of the plugins that I commonly use (CFEclipse, Subclipse, etc) that aren’t found on all system.

That’s what I did to get Eclipse 3.4 Ganymede running on Ubuntu 8.04.1 Hardy Heron, so enjoy!

General Impressions

Overall, I was greatly impressed by what the Railo team has done to make their product a viable CFML solution. The presentation was great with a wealth of examples and content to go over. The end effect of the presentation and subsequent discussion left me with a very positive take-away.

It’s in the Name

This is something that was brought up during dinner that I didn’t know before about the origin of the name Railo. From their FAQ page:

Yes. Railo is the name of an alien dog, first appearing in the first season, episode 25 of the TV-series “Enterprise”.

Standardization

During the meeting Gert talked a little about his involvement with the advisory committee that was created to help direct the CFML language as it continues to evolve. With multiple companies producting CFML engines it is a temptation to start developing extra tags that make the company stand out. The downside is the harm it causes to the CFML language by confusing developers and/or locking them into one engine since the code becomes specialized.

Railo is not without it’s features (which I will talk about below) that are not standard, but they have been making an awesome effort to share what they have been working on and the ideas for the future with the advisory committee in an effort to help things become more of a standard. Railo distinguishes themselves by making it out-perform the competitors, which is the right way to do it.

One of the comments made by Gert that I really enjoyed was to this effect:

While presenting at Adobe an Adobe engineer commented that they hoped Railo wasn’t mad that they used some of their ideas for features in ColdFusion 8. Gert replied that Railo stole 95% of Adobe’s ideas, Adobe stole 5% of Railo’s features so they were about even.

Two Administrators

When dealing with applications running on Adobe’s ColdFusion you have one Administrator that runs everything on that installation. If you want to break up the server to use a different configuration you have to use the enterprise version which allows you to create separate instances but cost a lot of money to do so. With Railo there are two types of administrators that you can use to run your application: the global administrator and the context administrator.

The global administrator allows you to configure options that will be available on all the web contexts running on the server (or instance of the JVM, I think). Basically anything you define there will take effect across all web contexts, unless overridden by the context administrator.

With the context administrator you are able to define settings that affect only the web context itself. This includes settings such as mappings and datasources. Traditionally you would have to do something in the Application.cfc to get mappings dynamically that were not defined in the administrator.

Resources

There are a lot of different ways to access files. You have local filesystem files, files on network shares, files on ftp servers, files on Amazon’s S3 services, flicker, google docs, etc. Thanks to the folks at Railo we are able to access the files from different services through an abstracted layer in Railo. I don’t know if they do flicker and google docs but they showed examples of using ftp and the S3 service.  Essentially, you could reference anything with a file path. Of course, getting files from ftp is considerably slower than the local file system. What this abstraction allows is for the programmer to reference files from varied locations without having to worry about where it is coming from.

Even if they don’t have a flicker:// path it sounded like it would be up to developers to program additional resources if they chose so you can have a flicker resource. You have to love abstraction, it’s just cool.

Portability

With the ability to change settings the portability of the Railo engine is impressive. All of the information to run your Railo application resides within one directory so if you want to distribute or move your application, datasources, mapping, et al., you just move the directory. It also is nice that it doesn’t break encapsulation, you just move it and it all comes.

Clustering

I’ll admit right now that I am no server administrator, but I was impressed by the quickness and seeming ease it was for Gert to startup a cluster and show us how it runs. Granted we didn’t watch him create the cluster he showed that it was done using the underlying Java server and you just need to tell the servers where each other are and give them some private key goodness. That alone looked pretty neat, but when you couple it with the cluster scope it was amazing.

Cluster Scope

This is something which just makes sense. You have session scopes and applications scopes when working on a single box, why not expand that out to the next level and have a cluster scope? Well Railo has a cluster scope. How cool is that? You can have variables that are created on one node in the cluster which then get shared to all other nodes in the cluster. Even if a node of the cluster is unavailable it will be updated once it comes back online and automatically synced with the rest of the cluster. I believe that Gert said Railo was using the cfthread task to accomplish the syncing of the cluster scope.

cfthread Task

Not many developers are used to using threading in their applications, at least the programmers that I know don’t. But if you do use cfthread, and even if you don’t, the type=”task” was a very cool addition to the cfthread tag. The task type allows you to define a task that is run as a separate thread. If that thread fails for some reason you are able to define how often and how many times to retry it. I believe that this is how the cluster scope is managed – by way of a threaded task.

TDD

Test Driven Development (TDD) has been something that has interested me for quite some time but never actually implemented it. Railo is a very fine example of why you do implement TDD and the benefits it reaps. As we were talking I asked the Railo duo about their using TDD.  I had read something about them using it and it turns out they have about 60,000 tests currently. Each time they start working on a bug or a feature they create their test for it beforehand. Once they have written the fix or feature the test is run to make sure it is correct. They also noted that it takes about an hour to run the tests each time they do a build for release. Awesome work Railo!

Debugging

Not much to say on this one other than the duo report that turning on debugging in Railo doesn’t really affect the system. They have such a hard time measuring how much it slows it down that they just say 1% to be safe.

Multimedia Tags

Prevalent among web sites these days is a lot of rich and streaming videos. With the 3.0 release of Railo they have created cfvideo and cfvideoplayer tags that do video conversion, clipping, screengrabs, and playback. I haven’t done much with video content but it was quite cool to hear and see the examples of the tag and how simple it is.

To me it was more impressive to see the way they used Amazon’s EC2 along with Amazon’s S3 to convert and stream their videos. Along with the EC2 Railo is planning on having some public Railo templates(?) that can be copied and made private for those who want to use Railo on the cloud once it is open source.

Extensions

This was one of the things that has some of the greatest potential and would be awesome for developers. The idea of an extension is basically having a packaged version of an application, training module, network thingy, etc., available for people to download and install/upgrade from within their administrator. I kind of picture this like the Apple app store, only for ColdFusion applications and add-ons.

This extension feature is how they are planning to off the video tags and other Railo extensions that they can’t distribute freely because of licensing. In addition developers would be able to have their applications and extensions sold through the same manner. Or you could define your own server to distribute solely your applications.

This was an idea they had at the beginning of the year and are still exploring the options and functionality. They are also in talks with Adobe to have this be something that is not unique to Railo but used in CF 9 or CF 10 as well.

Shared Hosting

One area of the ColdFusion community that is lacking is the ability to have very powerful shared hosting solutions for ColdFusion. You can get dedicated hosting that works awesome, but it costs you a lot to do it. With the current availability for shared hosting I’ve only heard not-so-good things. Especially with respect to shared hosting and mappings. With the features that Railo brings to the table it clears away a lot of the problems that seem to run rampant among CF shared hosts.

Given the structure of Railo you could set it up so that each account has their own web context(s) that they control while the host controls the global administrator. Or, depending on the hosting solution (such as media temple’s grid server where this blog is hosted), they could give you a fully working set of the Railo Administrator where you can have your own global administrator along with web context administrators.

Cascading Scope

One of my pet peves is code that doesn’t use explicit scoping. To me it is very inefficient and confusing not to know where the variables are coming from. I was very happy to hear that there is a setting to turn off the cascading scope functionality in Railo. If your code doesn’t know what to do it dies and tells you it can’t find the variable. Go encapsulation!

In Review

To sum it all up, I am excited to try out and hopefully contribute to the Railo project when it is released into the open source world.  It’s definately something that has an awesome potential to help expand the ColdFusion community, along with Open Blue Dragon, to those who complain about ColdFusion not being free. I look forward to great things from Railo.