• Railo 3.2 released

    Railo 3.2 has been released

    As a gift for christmas, today we have released Railo 3.2 final. It was more than one year of hard work and we are really excited about this cool release.

    Read more »

    Railo 3.2 releasedA christmas present from Railo

  • Find, fix and prevent server problems

    Monitor your Railo servers with the leading ColdFusion monitor - FusionReactor.  FusionReactor is designed to continuously monitor production servers and give you instant alerts of resource issues or server instability and even performs self healing actions when servers are in distress. 

    Read More

    Server Monitor for RailoFind, fix and prevent server problems.

  • Introducing Non-Intrusive Debugging

    Increase your ColdFusion development team's productivity with advanced CFML debugging! FusionDebug, the interactive step debugger for Railo, now supports IP Filtering.

    Read More

    Interactive Debugger for RailoIntroducing Non-Intrusive Debugging.

Services

Our expert consultants can help you get the most value out of projects. We offer support for all aspects of your project from installation to programming to maintenance and even training.

Consulting Training Support Contact Us
Products

Accelerate your CFML and Java development with Railo Server. Railo Server is the fastest CFML engine available and is 100% compatible with JBoss Application Server, Tomcat and the most popular Java Servlet engines.

Railo Enterprise Bundle Railo Open Source
Railo Server Monitoring

Enhance your Railo solution by adding professional Server Monitoring and ColdFusion Debugging capability - using FusionReactor and FusionDebug. Both tools are included when you purchase the Railo Enterprise Bundle.

Read More about Server Monitoring Read More about Debugging

Railo News

July 8, 2011
Railo 3.3 & Update Notification

For those of you that aren't on the mailing list and aren't following along on Twitter, Railo 3.3 is in RC. It's available via "preview" update in the Railo Admin and the latest RC candidate is on the "dev / Bleeding edge release."

Also, this slipped past me, but the Railo Team built an update notification service that emails you when a new version has been published.

We have introduced a new update notification service to keep you up to date about new releases of Railo Server. This notification service sends you an email as soon as a new version has been updated on any one of the three available update providers. In addition you can add certain keywords to your service subscription in order to have the service search the release notes for certain keywords. As soon as one of your keywords is found, a corresponding email is send to your address. This allows you easily to get notified as soon as a certain bug gets fixed. You can subscribe to this service on the��update notification��page.

Source: Railo Newsletter - July

July 7, 2011
Railo Administrator Training in Kansas City, 18/19th of July

Mark Drew will be heading to attend the D2WC conference in Kansas City next week (14-16th of July) and the team decided to take this opportunity to provide a training course to allow existing and new Railo Server users to get certified in the Railo Administrator course.

The course is two days long and covers areas such as installation, configuration and management of Railo Servers.

For more details and to sign up to the course, why not check out the announcement

June 15, 2011
Railo & Highcharts
For a client we decided to use Highcharts for several reasons. The look and feel was better than with the Railo CFCHART solution, the axes allowed several additional options and it offered very nice JS options with the graphics.

The only two things I see on the downside of this charting engine are:
  1. Highchart produces the charts on the client side with JQuery (which not necessarily is a downside) and you need to add additional functionality in order to generate a graphic out of it. Check out more about this in the Highsoft forum.
  2. The license. Highchart is not free by default and not open source. The license is quite reasonably priced, but still it's not free. See more about licensing of Highcharts on the Highcharts license page.
In order to get Railo to work with Highcharts I took a completely different approach and tried to just pass on the JSON formatted strings to Javascript and just display the chart. So I started by just passing on the options struct for Highcharts with the Railo serializeJSON() function. This was the first snag I hit since the keys in Railo are generated in CAPITAL LETTERS and Highcharts uses option variables camelCaseFormatted.
And due to the fact that the structs were nested I had to build a function that generates a corresponding JSON string out of a Railo struct. This function needed to know about the cases of the necessary variables. So I had to introduce a translation struct, which holds all the keys and replaces the Railo UPPERCASE key with the corresponding variable name in the correct camel case. Some things even needed more adjustment since JS functions cannot be passed as JSON values. So this JSON example from Highcharts in Railo would not work:
formatter:function() {
   var s;
   if (this.point.name) { // the pie chart
      s = ''+
      this.point.name +': '+ this.y +' fruits';
   } else {
      s = ''+
      this.x +': '+ this.y;
   }
   return s;
}

So I had to introduce optionTypes into the camelCase struct in order to find out how to treat such an entry. So the entry now looks like this (note the quotes):
formatter:"function() {
   var s;
   if (this.point.name) { // the pie chart
      s = ''+
      this.point.name +': '+ this.y +' fruits';
   } else {
      s = ''+
      this.x +': '+ this.y;
   }
   return s;
}"

and gets translated into the correct JS code. The translation struct looks something like this:

"align",type:"string"}>
"alignTicks",type:"boolean"}>

How to use it?

So all you have to do now is to call the tag with some options and that's it. The options are formatted nearly in the same way as the examples for Highcharts document it. The only exceptions are:
  1. You need to quote any direct javascript that you are using (like the functions mentioned above).
  2. null is not a valid value in Railo. So you need to quote "null".
  3. Colors need to be marked with double # signs.
So a normal call for highcharts looks like this:
            chart: {
               renderTo: 'container',
               plotBackgroundColor: "##FFFFFF",
               plotBorderWidth: "null",
               plotShadow: false
            },
            title: {
               text: 'Browser market shares at a specific website, 2010'
            },
            plotOptions: {
               pie: {
                  allowPointSelect: true,
                  cursor: 'pointer',
                  dataLabels: {
                     enabled: false
                  },
                  showInLegend: true
               }
            },
          series: [{
               type: 'pie',
               name: 'Browser share',
               data: [
                  ['Firefox', 45.0],
                  ['IE', 26.8],
                  {
                     name: 'Chrome',
                     y: 12.8,
                     sliced: true,
                     selected: true
                  },
                  ['Safari', 8.5],
                  ['Opera', 6.2],
                  ['Others', 0.7]
               ]
            }],
            tooltip: {
               formatter: "function() { return this.point.name }"
            }
         }>

   "#stOptions#" width="800" height="400">

All the options can be generated by Railo or come from a DB or anything else and thus can be completely dynamic. The only things you need to worry about are the available options and the things I mentioned above.

I will create an extension for Highcharts support so that all the necessary actions to get things working will be made. These actions include:
  • install a CFC based custom tag named highcharts into the corresponding {railo-server-directory}
  • add the library necessary for image generation if the type seleced is server
  • add the necessary JS files to the {railo-server-directory}/library/tag/railo/core/ajax/js
For the moment you can have a look at the examples on our presentation platform. Check it out here: wow.getrailo.org/highcharts

Please let me know if things are not working properly. It might simply be that in the highchart.cfc a type might be wrong. Have fun with it...

Mark Drew's personal blog

April 1, 2011
Denny Valliant Joins Railo!

It has been two years today that I have been working at Railo Technologies and it gives me great pleasure to announce that Denny Valliant (@denstar) has just joined the team!

Denny is a great addition as he has been working with various packagers for Railo, and of course, he is the Lead Developer for the CFEclipse project!
How about that for a great combination eh?!
Welcome on board Denny! Hold on tight! It's gonna be a hell of a ride!
Check out the official announcement over that the Railo Blog

March 31, 2011
Railo Tip: Getting information about built in Tags and Functions

I am not sure people out there know this but Railo has four awesome functions that I use all the time, they are :

  • getFunctionList
  • getTagList
  • getFunctionData
  • getTagData

getFunctionList* and getTagList
These two functions will return a structure with all the functions or tags that are currently installed on the Railo server. For example, getFunctionList will return:

And getTagList will return:

getTagData and getFunctionData
Of course, this information in itself isn't amazing, since how do you know the arguments for each? This is where the getTagData and getFunctionData come in useful. For Example, if you want to get all the properties of say, the function ImageFilter (I created the FilterExplorer using this function), all you have to do is:

"#getFunctionData("imageFilter")#">

And you will get a nice struct with all the info:

The function getTagData is slightly different, in that you have to split out the namespace when calling it, so you have to call it as follows:

"#getTagData("cf", "dump")#">

Which gets you all the attributes and documentation for the tag:

Simply using those tags, I have started a little project using CloudBees, ColdBox and of course Railo, that I shall show off a bit later.

* getFunctionList is also available in CF9

March 30, 2011
Running Railo in CloudBees

A while ago I was playing with the Stax.net deployment system, since then they have been bought by CloudBees, a Platform as a Service for Java Web Apps and I wanted to see how easy it was to run Railo on it.

One of the advantages of running Railo in CloudBees (apart from scaling and versioning) is the ability to deploy incremental changes, rather than having to deploy the whole WAR as you have to do with AWS's BeanStalk. In this post I shall go through how to get a sample application running.

Requirements
Before we get started we need to do the following:

  • Sign up for an account at CloudBees: https://grandcentral.cloudbees.com/account/signup
  • Download the CloudBees SDK and install it: https://cloudbees.zendesk.com/entries/414109-cloudbees-sdk
  • Download Railo as a WAR: http://www.getrailo.org/index.cfm/download/

Once you have setup the CloudBees SDK as they have mentioned, you need to setup your API and Secret Keys, to do this you can go get your keys from your account page, and add them to the file that should have been created (if you are using OSX or a Linux OS ) in:

~/.bees/bees.conifg

Now that we have all that installed, let's go create a simple app through the CloudBees web interface, I have named my application "railo" (surprise, surprise!).
Once it has been created, click on the configure button so that you can get the ID of the application, in my case it is "markdrew/railo".

Now we have that application, we can go and download it, go to the folder you want to download the application to in the command line/terminal and type the following:

> mkdir markdrew_railo
> cd markdrew_railo
> bees getapp -a markdrew/railo


That was easy, if you setup your API and Secret keys you should get some XML and some other commands appearing and it should all be downloaded. Let's run it before adding Railo to the mix:

> bees run


After a few seconds you can head to http://localhost:8080/ and get something that looks like the following:

Now to add Railo to our application. You can stop the application by pressing Ctrl + C, and then rename the railo-3.2.2.000.war to railo-3.2.2.000.zip and uncompress it:

> mv railo-3.2.2.000.war railo-3.2.2.000.zip
> unzip -d railo railo-3.2.2.000.zip


Now that we have unzipped the WAR file into the railo directory we can copy the contents from the railo/ directory to the markdrew_railo/webapp directory.

> cp -r railo/ markdrew_railo/webapp/

To test this, we can run the "bees run" command again and after a while you can test your application at http://localhost:8080/, you should get the Railo start page! Awesome!
Stop the application using Ctrl + C and let's clean out some files that are left over that we don't need:

> rm -r webapp/WEB-INF/classes/
> rm webapp/index.jsp

Now that we have cleaned it up and tested it , let's go ahead and deploy it. This is as simple as typing:

> bees deploy

The upload will take a while since it will upload something like 55Mb as our initial upload. Once this is done you should be able to check out your application live at the url defined in your configuration, mine is: http://railo.markdrew.cloudbees.net/

Let's change the default homepage, so that we can see how much it has to upload next time. Change the contents of index.cfm to just display the current time:




</span>Changed!<span class="cc_normaltag">

"documentation" class="twoCol">
   
      #Now()#