RSS feed for InstantSpot site Blog of Dave

Create SSL sites in Apache on Windows with OpenSSL

Fri, 13 Nov 2009 03:47:33 GMT

To get a secure SSL site up and running on Apache under Windows, there are a few hoops to jump through that are not very intuitive. To that end, I am going to document my approach to setting up SSL using OpenSSL. This approach assumes that you already have Apache up and running on your machine, so if you have not done that, head over to the HTTPD download page and set that up before continuing.

Setting up OpenSSL
First we need to get OpenSSL setup on our system, which is not included with the Apache Windows binaries. In fact the OpenSSL project doesn't even provide the binaries themselves, but you can find them at Shining Light Productions. For this example, I will be choosing the Win32 OpenSSL v0.9.8k Light version. If you see a message like the one below, you will need to install the Microsoft Visual C++ 2008 Redistributable Package and then attempt the OpenSSL installation again.

Once you have it installed, you can do a quick test to make sure that it is set up properly:
Creating Certificates
Next, we will use the OpenSSL terminal interface to create our self-signed certificates. To explain a bit about what is going on below, I have a site already existing on my system that can be reached at http://scribble. What we are doing is creating a secure subdomain of https://secure.scribble. Typically when I create certificates, I name the files with the host/domain obvious so that they can be easily identified later. Obviously you will want to replace the domain name to match your setup, but type the following in the terminal in the OpenSSL/bin directory:

[codeblock 433]

That will generate what you see below.

You may notice that I left a lot of the prompts blank. Considering this is a dummy certificate in a development environment, that approach makes sense. You may choose to be more explicit based on your needs.

If we were to use this key as it is, we would be prompted for the password every time that Apache starts. Since that is less than ideal, we will now generate a non-protected key from the one we created in the previous step by typing the following:

[codeblock 434]

You can see that I was prompted for a pass phrase. This is the same password that you created when we generated the certificate above.

Now we need to need to build the certificate that we will actually import into Apache. You can do so by typing:

[codeblock 435]

This will result in the following output:

You can see that we now have a .cert, .csr, .key, and .pem file for our domain. We will use a combination of the .key and the .cert
Configuring Apache
Now we need to make sure that your Apache server is ready to serve SSL requests.

First, let's put the .key and .cert files that we created above into a directory under Apache. In your "conf" directory, create a subdirectory named "ssl" and move secure.scribble.key and secure.scribble.cert into that new directory.

Next we need to make sure that the mod_ssl module is enabled. Open up the httpd.conf file for your Apache webserver. Search for "mod_ssl" and you should find a line that looks like this:

Yours will likely be commented out with a '#' sign in front of the line. You will want to delete that '#' so that it looks like the highlighted line above.

Next you will need to make sure that you have uncommented the line that includes the httpd-ssl.conf file like you see below:

The last thing we need to do is configure our site. Open up the conf/extra/httpd-ssl.conf file in an editor. You will see that there is an amazingly huge and complex site definition in there already that starts with and ends about 150 lines later with . We need to disable this site. If you are feeling bold, you can simply delete it. However, I take the approach of commenting it out entirely so that I still have it as a reference, which is my recommendation as well. Starting with the line , put a '#' at the start of every line that doesn't already have one and continue until you comment out the line.

Now it is finally time for us to create the site definition for our https://secure.scribble site. We will use some of the concepts in the example, but eliminate most of them. Here is what mine looks like after paring down all the excess:
[codeblock 436]

In that code you can see where we are pointing to the .key and .cert files that we created above.

Now, restart your Apache server and you are now serving up securely!

The Jungle Rockers

Mon, 09 Nov 2009 20:07:21 GMT

This past weekend I made a trip down to The Doublewide in Dallas and caught a really cool band called The Jungle Rockers (a few streamed tracks on there). They are Austin transplants from Cleveland but now hail from ATX, playing regularly around Texas. Their vibe is kind of a modern rockabilly sound with obvious influences from 50s rock and roll. They have a 6 track EP available that I bought at the show that is definitely a great listen, and if you get the chance to catch them live, I highly recommend it.

Here is a vid I found of them...

The Jungle Rockers "Shake It"

Talking through some current issues with ColdFusion Event Gateways

Mon, 09 Nov 2009 16:28:07 GMT

Normally on my blog I attempt to throw out some tip, trick, or nugget of some sort. This time? Not so! I am currently trying to find a solution to a problem at hand and am brainstorming the best way to handle a few things. I am really just talking this out for my own benefit, but I would love to hear thoughts from others that have perhaps solved similar issues.

On a project that I am currently engaged in I am leveraging ColdFusion Event Gateways which work as a subscriber to a SonicMQ JMS server. My gateway instance listens for messages on the ESB (Enterprise Service Bus) on a particular destination name (topic/queue). When it receives a message, it parses the XML that it received, and plays traffic cop pushing data into various services that need it. I have this working flawlessly in my small development environment. However, I have a couple of complexities ahead of me that I am having difficulty coming up with a good solution.

Running in the cloud - Our production environment will have any number of CF instances, not clustered, but rather running as isolated applications with a load balancer directing the requests using sticky sessions. Our system will be bringing new instances on/off line as traffic traffic dictates. I have yet to solve the issue of how to set up my JMS Event Gateway in this environment. I definitely don't want 20 different listeners out there all doing the same work. I have considered the idea of having some sort of a support database where a listener can insert a row with a specific JMS message ID and when any other server picks up a message with that ID it will see that it is already being acted upon and it can safely ignore it. There are a couple of negatives that I can see right off the bat. First is that every single subscribed instance will have to pull in the same message and test to see whether or not it should be acted upon. It just seems like a little bit of redundancy that shouldn't be there. Secondly, there is a chance that two servers could pick up the same request within milliseconds of each other and both could end up doing the work. Duplicate processing could not only be wasteful, but could also create some data integrity issues.
Different environments have different settings (dynamic config) - Right now in our development phase, we have a single config file with setting specific to our development JMS server (credentials, domain, URL, Initial Context Factory, etc). However, soon I will need to have this process support a number of different environments: multiple dev environments, multiple integration environments, multiple QA environments, and eventually production. Ideally it would be wonderful if I could find some way to load a specific config into the event gateway at server init time, but as of today I have _NO_ idea how to solve this one. First, there is no real intrinsic indicator at the server level that lets it know what environment is currently running (yet anyway...) and secondly, ColdFusion event gateway architecture isn't conducive in any way to dynamically loading a specific config.

So now I am counting on you CFML community. Help me brain storm on this! Do you have any thoughts/ideas that might help me here?

A linux guy's experience with Windows 7

Mon, 19 Oct 2009 13:58:00 GMT

Anyone who knows me well knows that I am typically somewhat of an anti-Windows guy. I absolutely love linux, and get very frustrated by Windows in general. The only thing that I really dislike about linux is the lack of application support by a number of companies (ahem…. Adobe). Before going to the Adobe MAX conference, I decided I should swap out OSes on my personal laptop so that I could run all the stuff I would need for labs without constantly cursing about being stuck in a VM, limited functionality, etc. A friend had just bought a package of Windows 7 licenses and sold me one for 5 bucks, which I considered to be a pretty reasonable risk. I opted for installing Windows 7 on my laptop.

Given that background and my previous feelings about Windows, I have to say that it is a pretty dang nice operating system. It is by far the best offering to date by MS in my opinion. There are a few things that they still haven't managed to get right (native file copy still makes me want to stick forks in my eyes), but by and large they have done a great job with Windows 7. Other than having to track down a few drivers for my laptop, the installation was painless – if not fast. This is still an area that linux, and especially Ubuntu, wins hands down though. Apps run extremely stable, and with the addition of a new concept of "Libraries", directories that I need access to regularly are right at hand instead of having to tree down through big hierarchies. I am also not finding what I expected would be an immediate degradation of performance after installing all the servers and development tools that I use on a daily basis. Over all, so far so good.

A few things that I think are a *must* for the way that I use it.

I found a "sudo" program called Start++ that allows me to open applications from the terminal or start menu as Administrator by typing sudo notepad [or some other program]. It will prompt you for the UAC stuff and the program will open as administrator. I use this regularly for editing system files like hosts, apache configs, and use it to open a terminal to fire off j2ee servers.
Install Teracopy which is a replacement for the Windows copy program. While certainly not as fast/efficient as a linux terminal, it greatly increases file copy speed over the native windows GUI file copy. No more "preparing to copy" waits while your system bogs down.

Things that annoy me

I still wish I could have a real terminal and be able to use VI in sudo, but that is just something I will have to get over I guess.
I hate that I now have to be so careful with regard to viruses and spyware. I love the protection that linux offers in that area, and having to go out of my to stay protected seems a bit cumbersome.
I miss being able to easily try out software with the ease of the synaptic package manager. It seems foreign now to have to download an exe run an installer and have settings being obscurely written all over a "black box" registry.
I miss built-in networking tools. Even simply things like being able to run "whois" from the teminal.
My drive is getting fragmented far faster than with linux, and I find that I am running the defrag tool fairly often. Linux just manages this under the covers and I never have to worry about it.

All said, after using it for about the past 4 weeks, I can honestly say that I am surprised (and perhaps even a bit disappointed) that I like it as much as I do. I planned on just running it while I was at the Adobe MAX conference and going back to linux when I got home, but it looks like I will be keeping it for a while longer.

Strange behavior with ColdFusion ExpandPath() when using Symbolic Links

Wed, 23 Sep 2009 14:11:00 GMT

I was playing around with the Quicksilver framework last night, and for some reason it was unable to find and instantiate my CFCs properly. After digging into the framework a bit and determining where it was breaking, I discovered something strange about the way that ColdFusion interprets ExpandPath() when it exists in a directory that is defined as a symbolic link. I am not sure if the same behavior exists on Macs, but I would imagine it does. If someone could confirm that to be the case, I would be interested.

For starters, I usually have a 'www' directory in my user home directory. This way when I pass my user profile around from distro to distro, my development work is included in my home directory. For ease of configuration I typically have a symbolic link in my OS that points /www/ ---> /home/dshuck/www/. Then when I am creating a new web project called 'davescode', I would put it in /home/dshuck/www/davescode, but my Apache config would usually point to /www/davescode. For the past several years, this approach has worked will for me. That is until last night when experimenting with Quicksilver.

When Quicksilver loads, it creates a list of service CFCs in the the application in such a way that if I had Foo.cfc in a directory 'com' in the root of my davescode site, it would look like /home/dshuck/www/davescode/com/Foo.cfc. When I initted the application, I was getting an error that it couldn't find the CFC home/dshuckcom/Foo.cfc. Essentially what was happening is that it was getting the full path of the CFC and replacing the path to the root of the site with "". In a perfect world the value of the path after the string replace would have looked like com/Foo.cfc. Unfortunately that was not so. Here's why!

I put a test file called path.cfm in the root of my davescode site that considted of the following:

<cfoutput>#ExpandPath("./")#</cfoutput> <br/> <cfoutput>#ExpandPath("/")#</cfoutput>

The result was very surprising!

/home/dshuck/www/davescode/ /www/davescode/

For some reason when you do ExpandPath("/") it looks at the symbolic link path, but when you do ExpandPath("./"), it looks at the true file path. For the life of me, I can't think of why that would be. If anyone has an explanation, I would be all ears!

Photos from the Dallas Adobe User Group Tour event

Mon, 29 Jun 2009 21:13:00 GMT

We had a great time Friday night with around 170 in attendance! Terry did a great job and everyone left hungry for the new releases that he teased. Here are some pics from the night.

Solving java.lang.SecurityException: Seed must be between 20 and 64 bytes. Only 8 bytes supplied.

Fri, 08 May 2009 14:24:00 GMT

Recently I have began working with JMS and ColdFusion, in which we are building a system that subscribes to an enterprise JMS server and picks up messages relevant to its needs and acts on them. I had my proof of concept working with the open source Apache ActiveMQ server and was very pleased with the results. However, in our production environment, the powers that be decided to use the very non-free SonicMQ server.

As I tried to convert the event gateway over to the SonicMQ server, it failed on initialization with the following exception:

javax.naming.NamingException [Root exception is java.lang.SecurityException: Seed must be between 20 and 64 bytes. Only 8 bytes supplied.]  at com.sonicsw.jndi.mfcontext.MFConnectionManager.connect(Unknown Source)  at com.sonicsw.jndi.mfcontext.MFConnectionManager.<init>(Unknown Source)  at com.sonicsw.jndi.mfcontext.MFConnectionManager.getManager(Unknown Source)  at com.sonicsw.jndi.mfcontext.MFContext.<init>(Unknown Source)  at com.sonicsw.jndi.mfcontext.MFContextFactory.getInitialContext(Unknown Source)  at javax.naming.spi.NamingManager.getInitialContext(NamingManager.java:667)  at javax.naming.InitialContext.getDefaultInitCtx(InitialContext.java:288)  at javax.naming.InitialContext.init(InitialContext.java:223)  at javax.naming.InitialContext.<init>(InitialContext.java:197)  at examples.JMS.JMSConsumer.start(Unknown Source)  at examples.JMS.JMSGateway.startGateway(Unknown Source)  at coldfusion.eventgateway.GenericGateway.start(GenericGateway.java:118)  at coldfusion.eventgateway.EventServiceImpl$GatewayStarter.run(EventServiceImpl.java:1428)

In my research on this problem, I found several people reporting similar errors, each on CF8, and each talking to 3rd party tools. Eventually I found the solution through an email discussion between one of the developers in my company and an Adobe developer. Apparently in CF8, they added FIPS security, which disables the Sun JCE (encryption libraries). To solve this error, you need to add the following line to your java.args in your jvm.config file in JRun.

-Dcoldfusion.disablejsafe=true

Now restart your server and try again!

Making your application flow obvious in Mach-II with event-mappings

Sat, 11 Apr 2009 18:46:00 GMT

I recently joined a company that makes use of Mach-II in a few applications. Some of them were created as the developers were learning the framework and employ some obvious un-best practices. The team is made up of people from various skill levels, but I have noticed that about half of the team just absolutely cringes when they hear "Mach-II". They talk about how difficult it is to troubleshoot and how it is next to impossible to follow application flow. I was very surprised to hear that response, because I think one of the big benefits of using Mach-II is that I can look at a config XML and read the story of my application. I will touch on this in more detail in a bit.

So the other day I had my first experience digging in deeply into one of they apps to solve a problem... and it took me forever to figure out where the hell anything was. I started on the default home event, which only had a filter that announced other events, that had listeners that announced other events and so on until I was *EIGHT* events deep. In each one of these announcements, I had to go find the listener/filter, look into the methods, and search for where I might be going next. It suddenly became overtly clear why the other developers hate Mach-II.

Now, back to why my config files tell a story... first of all, I can't think of many cases where an app needs to announce 8 events before it gets to a destination. However, troubleshooting this would have been so much simpler if only the developer had been clear in the XML using event-mappings. As a rule, if I ever alter the flow of my application from within a filter/listener, I always have an event-mapping that shows this in my config. That way I can quickly skim the XML and know what possible exits I have. In most cases, it should be pretty obvious where you are going based on that alone, and you don't even need to open the CFCs to figure it out. Although I certainly do use event-mapping for aliases, more often than not they will look like this:

<event-mapping event="SomeEvent" mapping="SomeEvent" />

It serves no actual functinal purpose other acting as a means to document the flow. Does anyone else use the practice? How do you keep the application flow obvious in your configuration files?

I was talking to Aaron Lynch about this (who uses the same practice) and from that conversation I decided I would open this up for conversation. What I would love to see is some type of optional setting in Mach-II that would enforce this so that all developer on a team had to use this methodology. Maybe something along the lines where when an event is announced from within a CFC and it hasn't been mapped in the XML it would barf up an exception?

I have no doubt that some people will hate this idea. However, in the bigger picture I would like to see less people hating frameworks, and if we can make things more clear from a troubleshooting/maintanence perspective, I think that there would be less FUD!

Any thoughts on this?

How to set JAVA_HOME environment variable in Ubuntu

Sat, 21 Mar 2009 01:02:00 GMT

I am actually creating this blog entry as a bookmark for myself, but since I know that I never remember how to do it, others might benefit as well!

One way that you can set your JAVA_HOME variable and add to your PATH, is be doing the folowing. As 'sudo' open up /etc/bash.bashrc and add the following to the end of the file. NOTE: Set the java path to whatever the actual path is on your environment if it does not match /usr/lib/jvm/java

JAVA_HOME=/usr/lib/jvm/java export JAVA_HOME PATH=$PATH:$JAVA_HOME/bin export PATH

When you reboot, try running the following:

$ echo $JAVA_HOME /usr/lib/jvm/java  echo $PATH [probably lots of paths]:/usr/lib/jvm/java/bin

Interfaces in ColdFusion - I think I have finally come around on CFINTERFACE

Fri, 06 Mar 2009 17:03:00 GMT

I will admit it...

When all the pre-ColdFusion 8 debate was swirling about whether or not to add interfaces into CFML, I didn't really get it. It's true. The only OOP I had ever really done was in CFML, ever having experienced how interfaces really come into play, and I think I fell into the the easy path of considering it worthless because I didn't take the time to understand it. So very quietly, I was in the "we don't need it!" camp.

Much has changed for me as a developer since that time. I have gotten quite comfortable in Flex development, and working with Flex made me realize that Java is not really all that difficult to grasp for me now, and I am pretty comfortable getting around there too. I have begun playing a bit with Groovy as well, so I have been exposed to much more since there actually *was* a debate about interfaces.

So now that debate has long since died, and the pro-interface crowd won - and then immediately decided that they didn't actually need interfaces after all - I realized yesterday that I finally get it!

Before I go any further, I would like to give my definition of an interface, because I am sure there are still plenty of CF developers who are where I was just a short time ago with just a very loose grasp, if any, on the concept. In fact, I am not sure that I am much beyond a loose grasp, but I will do my best to explain. For those who already know all this, just bear with me here.

In talking about interfaces with another developer on my team yesterday he asked how they are used. Half joking, I replied "They aren't! They don't *do* anything at all". What I meant by this is that you don't ever actually call an interface and your application never actually asks an interface to do anything. The interface exists simply to enfore rules in your data model. In essence it is a zero-tolerance "Object Gestapo" that makes sure that no one ever gets out of line. An interface is truly little more than a contract that says "Any object that implements me must contain the things I define". In essence, I suppose you could think of it as a shell CFC that defines methods, arguments, and return types, that you can't actually call. If I then define a CFC that implements that interface, it better damn well adhere to it strictly or the object gestapo comes down on you hard!

So why this extra work right? CF is a loosely typed language. Its status as an OOP language has been debated. However, the fact of the matter is that most of the top slice of CFML developers are writing some really amazing object oriented applications. Due to this, some of the more strict products from languages like Java might actually have some place in our work.

Let me give a real world solution that might help solidify my swirling thoughts on the matter. to give background on the environment I am working in, I recently began working for a relatively large insurance provider. Counting another 17 developers that are just being moved into ColdFusion from other languages, we have one of the larger ColdFusion development groups that I am aware of in my area. Many of the developers work remotely, and we have several that are in other states. Due to this, communication must be clear to keep everyone on the same page.

A current project that is in the works is to move our entire policy system off of one third-party vendor to another. The APIs between the two are vastly different, however, we still need the same data available to us in our applications. To make things more complicated, we will be moving one state at a time. So effectively there will be two distinctly different policy systems in play until the last state is converted.

My architectural approach to solving that problem is to use a PolicySystemFactory that returns the appropriate PolicySystem to me based on specific business rules. Any PolicySystem will actually serve as an adapter to the specific API of its third-party system, but the methods that the PolicySystem object exposes to the application *must* be consistent. The application shouldn't really care which system it is talking to as long as the system is giving it the right data and doing taking the right action on data that is passed in.

How do we ensure that we have the exact same API for not only the two current policy systems, but any future policy systems that we don't even know about yet?

Well, we could just make sure all developers know about it, and write it in some document hundreds of pages long that no one ever reads. Then after both of those things fail, the developers will eventually figure it out as the application pukes in different areas as it is getting data in different shapes than it is expecting, or as it tries to use methods differently than the PolicySystem is expecting. Eventually they will work this out.

Or... You could do both of the above items (communicate & document) and save everyone a lot of trouble by establishing that any PolicySystem *must* adhere to rules established in an interface. By taking this approach, there is no question whatsoever that the PolicySystem will not break your application by working differently than expected.

How do you implement this approach? (really.. I didn't mean it as a pun)

First, we would want to figure out exactly how a PolicySystem should be shaped. In our ultra-simplified example, a PolicySystem must have three methods: getPolicy(id) returning a Policy object, getPolicyAgent(Policy) returning and Agent object, and getPoliciesByStatus(StatusId) returning a structure of Policy objects

This is what our Interface would look like:

PolicySystemInterface.cfc

<cfinterface>   <cffunction name="getPolicy" access="public" output="false" returntype="Policy">  <cfargument name="id" type="numeric" required="true" /> </cffunction>   <cffunction name="getPolicyAgent" access="public" output="false" returntype="Agent">  <cfargument name="Policy" type="Policy" required="true" /> </cffunction>   <cffunction name="getPoliciesByStatus" access="public" output="false" returntype="Policy{}">  <cfargument name="StatusId" type="numeric" required="true" /> </cffunction>   </cfinterface>

As you can see above, we use the <cfinterface /> tag to define this CFC as an interface. We then write our functions much like we would in a <cfcomponent /> keeping in mind that whatever we define must be used *exactly* the same way by any object that implements it. So what would one of those objects look like? Here is our old legacy policy system object. Take a look at what is going on in line #1 in the <cfcomponent /> tag.

OldLegacyPolicySystem.cfc

<cfcomponent name="OldLegacyPolicySystem" output="false" extends="AbstractPolicySystem" implements="PolicySystemInterface">  <cffunction name="init" access="public" output="false" returntype="AbstractPolicySystem">  <cfreturn super.init("OldLegacyPolicySystem") /> </cffunction>  <cffunction name="getPolicy" access="public" output="false" returntype="Policy">  <cfargument name="id" type="numeric" required="true" />  <!--- NOTE - In real life, we would use a service to create this bean, not instantiate it here!!! --->  <cfset var Policy = CreateObject("component","Policy").init() />    <!---   ########################################  In this area we would access policy info using the OldLegacyPolicySystem (however it does it!) and populate the Policy bean   ########################################  --->    <cfreturn Policy/> </cffunction>  <cffunction name="getPolicyAgent" access="public" output="false" returntype="Agent">  <cfargument name="Policy" type="Policy" required="true" />  <!--- NOTE - In real life, we would use a service to create this bean, not instantiate it here!!! --->  <cfset var Agent = CreateObject("component","Agent").init(arguments.Policy) />    <!---   ########################################  In this area we would access Agent info using the OldLegacyPolicySystem and populate the Agent bean   ########################################  --->    <cfreturn Policy/> </cffunction>  <cffunction name="getPoliciesByStatus" access="public" output="false" returntype="Policy{}">  <cfargument name="StatusId" type="numeric" required="true" />  <cfset var PolicyStruct = {} />  <!---   ########################################  In this area we would load Policies using the OldLegacyPolicySystem and build a structure of them   ########################################  --->   <cfreturn PolicyStruct /> </cffunction> </cfcomponent>

You should notice that we have:
extends="AbstractPolicySystem" implements="PolicySystemInterface"

Two things are happening there. First, we are extending an AbstractPolicySystem object that will hold common functionality among all PolicySystems. Ours looks like this:

<cfcomponent output="false"> <cffunction name="init" access="public" output="false" returntype="AbstractPolicySystem">  <cfargument name="SystemName" type="string" required="true" />  <cfset this.SystemName = arguments.SystemName />  <cfreturn this /> </cffunction> </cfcomponent>

For our test case, when we instantiate our PolicySystem we can quickly prove which one we are dealing with by looking at PolicySystem.SystemName. That said, your application shouldn't know or care.

By adding the implements attribute we are ensuring that this PolicySystem plays by the rules we defined in our PolicySystemInterface. No "ifs" "ands" or "but"s!

So, this is the exercise that brought me around on CFINTERFACE. What are your thoughts?

Setting up Apache, OpenBD, Railo and ColdFusion - Part 4 - Installing Railo under Tomcat with Apache webserver

Tue, 10 Feb 2009 04:31:00 GMT

This is Part 4 in an ongoing series demonstrating how to install OpenBlueDragon, ColdFusion, and Railo concurrently with all requests passing through the Apache webserver. You will find links to all parts of this series at the bottom under "Related Content"

In this post we will be building upon our existing environment in which we installed Apache webserver, Tomcat 6, OpenBlueDragon, and ColdFusion, by adding Railo to the mix. If you have been following along thus far, we are well past the hard stuff at this point. To install Railo, which is deployed as a java war file, we are going to repeat and slightly modify many of the steps that we took at the end of Part 2 when we installed OpenBD as a Tomcat web application.

Let's start by setting up our hosts entry so that our new site resolves to localhost.railo, and set up the Apache webserver to listen for the request. Open up /etc/hosts, and append 'localhost.railo' (without quotes!) to the line that begins with 127.0.0.1. Next we want to create a new virtual host file for the site under Apache. Do so like this:

$ cd /etc/apache2/sites-available   sudo gedit localhost.railo

Paste the following into that new file and save it.

<VirtualHost *>  ServerName localhost.railo  JKMount /* worker1 </VirtualHost>

As we learned in Part 2, the line "JKMount /* worker1" is instructing apache to pass everything to the worker we defined in /etc/apache2/workers.properties. That worker will then pass the request on to Tomcat port 8009, under which our application actually resides.

Now that we have defined this site, we want to make sure that it gets included on our next Apache restart. We do this by running the following:

$ sudo a2ensite localhost.railo  Site localhost.railo installed; run /etc/init.d/apache2 reload to enable.

At this point, we need to make sure there is a an application set up in Tomcat to receive our request. First, let's start by downloadingthe free Railo Server from their download page. Look toward the bottom of the page and download "Railo Custom" and download railo-3.0.2.001.war. (or newer version if it is there). Once we have the file downloaded, we will create a new directory for our application under Tomcat. We will then copy the Railo war file into it from our download directory. When we have the war file under /opt/tomcat6/webappas/localhost.railo/ we will extract it, and then safely delete the war file itself. These steps can be seen here:

$ sudo /opt/tomcat6/webapps/localhost.railo  sudo cp railo-3.0.2.001.war /opt/tomcat6/webapps/localhost.railo/  cd /opt/tomcat6/webapps/localhost.railo  sudo jar xvf railo-3.0.2.001.war   sudo rm railo-3.0.2.001.war

Since we now have the application in place, it is time to modify the Tomcat server config so that it knows to send the appropriate requests to it. Do the following:

$ sudo gedit /opt/tomcat6/conf/server.xml

Look for the section that we added previously for our OpenBlueDragon localhost site "localhost.bd". We are going to copy that section, modifying the "name" and "docBase" attributes to match our new application and paste it just below the localhost.bd site. When you are done they should look like this:

<Host name="localhost.bd"  appBase="webapps" unpackWARs="true"   autoDeploy="true" xmlValidation="true" xmlNamespaceAware="false">   <Context path="" docBase="localhost.bd/" reloadable="true" privileged="true" antiResourceLocking="false" anitJARLocking="false" /> </Host>  <Host name="localhost.railo"  appBase="webapps"  unpackWARs="true"   autoDeploy="true" xmlValidation="true" xmlNamespaceAware="false">   <Context path="" docBase="localhost.railo/" reloadable="true" privileged="true" antiResourceLocking="false" anitJARLocking="false" /> </Host>

With all that done, we are ready to restart (or start) Apache, Tomcat and our new Railo site will be available at http://localhost.railo

So with our original goal of being able to run the three CFML engines, it's time to see how we did....

Setting up Apache, OpenBD, Railo and ColdFusion - Part 3 - Installing ColdFusion and customizing the connector

Thu, 05 Feb 2009 04:35:00 GMT

This is the third part in a series of posts on setting up ColdFusion, OpenBlueDragon, and Railo all on the same machine using Apache webserver to listen for all requests and direct traffic. Part 2 can be found here. You will find links to all parts of this series at the bottom under "Related Content"

With that said, this part in the series focuses on installing ColdFusion and configuring the webserver adapter in such a way that only specific Virtual Hosts will be set up to pass requests to the ColdFusion server. First we want to start by creating a localhost site that is specific to ColdFusion 8 in Apache. I tend to keep all my sites under /www which is actually symlinked to a 'www' in my home directory. I find a few benefits in this. First, I usually keep my home partition in shape and carry it around with me from distro to distro, so I always have my sites in tact with me. Secondly since it is a symlink to my home and not in a system folder I don't need special permissions to write in it. I will be following along this path, but if you keep your sites elsewhere, then you can adjust as necessary.

$ mkdir /www/localhost.cf8

Now, we will want to create an Apache virtual host definition for this site. To do so, create a new configuration file like this:

$ sudo gedit /etc/apache2/sites-available/localhost.cf8

Paste the the following, then save and close.

<VirtualHost *>  ServerName localhost.cf8   <Directory /www/localhost.cf8/>   Options Indexes FollowSymLinks MultiViews   AllowOverride None   Order allow,deny   allow from all  </Directory>  DocumentRoot /www/localhost.cf8 </VirtualHost>

Now we need to make sure that file is included when Apache starts, so run the following command which will make a symlink to the sites-enabled directory.

$  sudo a2ensite localhost.cf8 Site localhost.cf8 installed; run /etc/init.d/apache2 reload to enable.

As you can see from the localhost.cf8 configuration file, we are expecting our ServerName to be localhost.cf8, so we now need to add that entry to our hosts file.

$ sudo gedit /etc/hosts

Append "localhost.cf8" (with no quotes!) to the line that begins with 127.0.0.1. Save the file and close. At this point you should be able to restart Apache and hit that empty site in your browser like this: Now that we have a site ready, it is time for us to install ColdFusion. Once you have downloaded the .bin installation file from Adobe, browse to that directory in a terminal window. You may need to chmod the file to be executable, then launch it like this:

$ chmod +x coldfusion-801-lin.bin  sudo ./coldfusion-801-lin.bin

Choose 1 for English. After the welcome screen, hit enter to continue. Next type "Y" and hit enter to agree to the terms and conditions. We are now faced with the installation type prompt. For this example of setting up a development environment, we will choose option 3 "Developer Edition" For our purposes we are going to choose the "Server configuration" option. However, it should be noted that you could quite easily choole the J2EE WAR file option and install into Tomcat as we did with OpenBlueDragon in Part 2 of thise series. Since we are installing from scratch, we will choose "No" (2) on the next option which is asking if there is an existing version of ColdFusion 8 installed on this machine. For this installation we do not want any of the extra options to install such as Documentation, LiveCycle, Search Services, nor do we want to start on system init since this is on my laptop and I may not always want ColdFusion to start at boot. So we will uncheck all options like you see in this image and continue. We are going to accept the default installation path of /opt/coldfusion8 Again, since this is a fresh installation, we are going to say "No" (2) to the prompt asking if there are earlier versions of ColdFusion on this computer. Now we start to work our way into the webserver configuration which will tie ColdFusion into Apache. To start, choose "Add Web Server Configuration" (1) when prompted, then choose "Apache" (1). In the following prompt asking for the Apache directory that contains your http.conf file, enter /etc/apache2 as you see in the picture below: For the location of the Apache program binary file, enter /usr/sbin/apache2. For the Start/Stop script, enter /etc/init.d/apache2. You will see both of these choices here: We now return to the first webserver configuration menu and this time choose "Continue with installation" (4). Then we will need to enter the location of the webroot. We are going to enter the directory of our new site /www/localhost.cf8 that we created above as you can see in the picture below. We will also be asked which user we would like ColdFusion to run as. I typically like to use my own user account for this so I don't end up with permissions issues where I have difficulty accessing files generated by ColdFusion Now enter your admin password, and if you choose to user RDS, enter the password for it as well. It will now show you the general options you have selected and you will hit enter to start the actual installation. Once it completes and prompts you to "Press Enter to exit the installer", do so and then start the server with this:

$ sudo /opt/coldfusion8/bin/coldfusion start

During this stage you should see messages that it is configuring the webserver successfully, assuming we entered everything properly above. Once you are returned to a prompt, it is time to go customize the Apache connector stuff just a bit. open the httpd.conf file like this:

$ sudo gedit /etc/apache2/httpd.conf

In that you will find the connector stuff that ColdFusion added starting with a line: #JRun Settings. Before we take the next steps, let me explain a bit what we are going to do. We are going to seperate this into two pieces: the module loader, and the actual connector declaration. As it stands right now, and request coming through the webserver would be handled by ColdFusion and we don't really want that. To make it more granular, we are going to create an include file that can be added to any site that will add the connector only to that particular site. With that said, let's walk through it. *Cut* (not copy!) these two lines of that connector info:

# JRun Settings LoadModule jrun_module /opt/coldfusion8/runtime/lib/wsconfig/1/mod_jrun22.so

Now we are going to paste those into a new file that will go in our mods-available directory. Click on the "New" button in gedit and paste that text in. Now save that file as /etc/apache2/mods-available/cf8.load. Now *cut* (not copy!) the remainder of the connector out that looks like this:

<IfModule mod_jrun22.c>     JRunConfig Verbose false     JRunConfig Apialloc false     JRunConfig Ignoresuffixmap false     JRunConfig Serverstore /opt/coldfusion8/runtime/lib/wsconfig/1/jrunserver.store     JRunConfig Bootstrap 127.0.0.1:51801     #JRunConfig Errorurl url <optionally redirect to this URL on errors>     #JRunConfig ProxyRetryInterval 600 <number of seconds to wait before trying to reconnect to unreachable clustered server>     #JRunConfig ConnectTimeout 15 <number of seconds to wait on a socket connect to a jrun server>     #JRunConfig RecvTimeout 300 <number of seconds to wait on a socket receive to a jrun server>     #JRunConfig SendTimeout 15 <number of seconds to wait on a socket send to a jrun server>     AddHandler jrun-handler .jsp .jws .cfm .cfml .cfc .cfr .cfswf </IfModule>

Create a new file named /etc/apache2/cf8connector. Pasted that text in and save the file. Lastly, you may not have this issue, but I found that the DirectoryIndex attribute of Apache was not adding index.cfm to the list of default files. Due to this I actually added it to my httpd.conf. After all of the steps above, my httpd.conf file only has a single line:

DirectoryIndex index.cfm

Now... it is time to do just a little more Apache config and we are ready to go! Rember that cf8.load mod file we created earlier? Let's turn that on:

$ sudo a2enmod cf8

Now, let's to add an include call to our localhost.cf8 virtual host configuration. Open up /etc/apache2/sites-available/localhost.cf8 and add the "Include c8connector" line that you see below:

<VirtualHost *>         ServerName localhost.cf8          <Directory /www/localhost.cf8/>                 Options Indexes FollowSymLinks MultiViews                 AllowOverride None                 Order allow,deny                 allow from all         </Directory>         DocumentRoot /www/localhost.cf8         Include cf8connector </VirtualHost>

Once you have saved that file, it is time to restart Apache and test out all of our hard work!

$ sudo /etc/init.d/apache2 restart

Now, using your browser, go to http://localhost.cf8/CFIDE/administrator/ and you will see the following: Now... if you are following along from earlier in this series, you should now be able to successfully connect to OpenBD at http://localhost.bd and ColdFusion 8 at http://localhost.cf8 On the next part of this series, we will bring Railo into the mix and finally have all three running on our system.

Next - Part 4 Installing Railo under Tomcat with Apache webserver

Setting up Apache, OpenBD, Railo and ColdFusion - Part 2 - Installing Tomcat/Apache/OpenBD

Sun, 01 Feb 2009 07:34:00 GMT

This is the second part in a series of posts on setting up ColdFusion, OpenBlueDragon, and Railo all on the same machine using Apache webserver to listen for all requests and direct traffic. Part 1 can be found here

Remember, the steps below have some commands specific to Linux, and more specifically to Debian/Ubuntu, but the concepts in general should have at least some similarites across any supported platform, especially you Mac folks.

To start out, we need to make sure that we have the Apache webserver installed with optional "dev" package. Additionally, later on we will need to be compiling, so let's make sure that you have the build-essential package as well $sudo apt-get install apache2 apache2-threaded-dev build-essential Next I installed the Sun Java 6 JDK $sudo apt-get install sun-java6-jdk

Next you want to go download Tomcat. I chose to use Tomcat 6, specifically v. 6.0.18, which the current release as of this posting. Now, using a terminal cd into the directory where you saved the dowloaded file and do the following: $ sudo cp apache-tomcat-6.0.18.tar.gz /opt/ $ cd /opt $ sudo tar xvzf apache-tomcat-6.0.18.tar.gz $ sudo mv apache-tomcat-6.0.18 tomcat6 $ sudo rm apache-tomcat-6.0.18.tar.gz

Next we will need to edit the Tomcat startup script, but to do so, we need to go get a little information first. We need to ensure that we know what the current Java home is on your machine. There are surely easier ways of accomplishing this, but here is the series of steps I took. ~$ which java /usr/bin/java $ ls -l /usr/bin/java lrwxrwxrwx 1 root root 22 2009-01-30 23:00 /usr/bin/java -> /etc/alternatives/java $ ls -l /etc/alternatives/java[return] lrwxrwxrwx 1 root root 36 2009-01-30 23:00 /etc/alternatives/java -> /usr/lib/jvm/java-6-sun/jre/bin/java

From that last line I can see that the default Java lives at /usr/lib/jvm/java-6-sun/ (which too is a sym link, but that's ok!). Now that we have our Java home we can edit the Tomcat startup script $sudo gedit /opt/tomcat6/bin/catalina.sh

Paste the following lines in just after the big comment block at the top. Make sure that if your Java path looked different than mine did, you will want to adjust accordingly. JAVA_HOME=/usr/lib/jvm/java-6-sun JRE_HOME=/usr/lib/jvm/java-6-sun/jre JAVA_OPTS="-server -Xms1024M -Xmx1024M -XX:PermSize=256m -XX:MaxPermSize=256m \ -Duser.language=en -Duser.country=US -Dfile.encoding=UTF-8 \ -Djavax.xml.transform.TransformerFactory=org.apache.xalan.processor.TransformerFactoryImpl"

Now we want to download the Apache Tomcat connector source so that we can pass requests from Apache webserver to Tomcat. This is the one I grabbed: http://apache.org/dist/tomcat/tomcat-connectors/jk/source/ Next you will want to browse to the directory that you downloaded that file into using in the terminal. Next run: $ tar xvzf tomcat-connectors-current-src.tar.gz $ cd tomcat-connectors-1.2.27-src/native $ ./configure --with-apxs=/usr/bin/apxs2 $ make $ sudo make install

Now we will need to create a jk mod file to be included by Apache so that it loads the adapter when Apache starts. In your terminal cd to /etc/apache2/mods-available. In this directory we will create a file named jk.load. $sudo gedit jk.load

In that file pasted the following, then save and exit: LoadModule jk_module /usr/lib/apache2/modules/mod_jk.so # Where to find workers.properties # Update this path to match your conf directory location (put workers.properties next to httpd.conf) JkWorkersFile /etc/apache2/workers.properties # Where to put jk shared memory # Update this path to match your local state directory or logs directory JkShmFile /var/log/apache2/mod_jk.shm # Where to put jk logs # Update this path to match your logs directory location (put mod_jk.log next to access_log) JkLogFile /var/log/apache2/mod_jk.log # Set the jk log level [debug/error/info] JkLogLevel info # Select the timestamp log format JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "

Now we want to create a symbolic link to this file in /etc/apache2/mods-enabled so that it is loaded when Apache starts. $ cd /etc/apache2/mods-enabled $ sudo ln -s ../mods-available/jk.load ./jk.load

Next we want to create a virtual host in Apache to catch the requests. We are going to create a new file in the sites-available directory. $ cd /etc/apache2/sites-available $ sudo gedit localhost.bd In that file, paste the following, save, and exit:

<VirtualHost *>  ServerName localhost.bd  JKMount /* worker1 </VirtualHost>

Now we need to create a symbolic link to that file from sites-enabled so that it is available when apache2 starts. $ cd /etc/apache2/sites-enabled $ sudo ln -s ../sites-available/localhost.bd ./001-localhost.bd

Next we want to make sure that we can get to that site in a browser, so we are going to add 'localhost.bd' to our hosts file. Open up /etc/hosts, and append 'localhost.bd' (without quotes!) to the line that begins with 127.0.0.1. Now we need to define that "worker1" that we just referenced above in the VirtualHost definition. We will do that by creating a workers.properties file in our apache2 directory. $ cd /etc/apache2 $ sudo gedit workers.properties

Insert the following. Then save and exit:

# Define 1 real worker using ajp13  worker.list=worker1  # Set properties for worker1 (ajp13)  worker.worker1.type=ajp13  worker.worker1.host=localhost.bd  worker.worker1.port=8009

Next we want to create a webapp in Tomcat for Apache to send to. sudo gedit /opt/tomcat6/conf/server.xml In that config, we need to define the localhost.bd site, or 'webapp'. Add the following:

<Host name="localhost.bd"  appBase="webapps"       unpackWARs="true" autoDeploy="true"       xmlValidation="true" xmlNamespaceAware="false">   <Context path="" docBase="localhost.bd/" reloadable="true" privileged="true" antiResourceLocking="false" anitJARLocking="false">  </Context> </Host>

Now we need to create the local.bd directory under Tomcat. Note: as you get more comfortable and adventurous, you may want this to be a symbolic link to another place on your machine where your source resides, but for now we are keeping it as simple as we can. Once the directory is created, we will download the OpenBlueDragon war file and extract it.

$ sudo mkdir /opt/tomcat6/webapps/localhost.bd $ cd /opt/tomcat6/webapps/localhost.bd  $ sudo wget http://openbd.viviotech.net/downloader.cfm/id/64/file/openbd.war  $ sudo jar xvf openbd.war

And with that step, and after restarting Apache, and starting Tomcat, OpenBlueDragon will now be available. $ sudo /etc/init.d/apache2 restart $ /opt/tomcat6/bin/catalina.sh start

Open up your browser and go to: http://localhost.bd/bluedragon/administrator

You should be created with your OpenBD admin page like this:

Next: Part 3 - Installing ColdFusion 8 and customizing the JRun connector

Setting up Apache, OpenBD, Railo, and ColdFusion - Part 1

Sun, 01 Feb 2009 07:33:00 GMT

This is Part 1 of a muilt-part blog post demonstrating how run OpenBlueDragon, Railo, and ColdFusion all on the same machine, and all using the Apache webserver with individual Virtual hosts using different CFML engines. But, before we get into it, here is a little background.

For the past several months now I have stepped over to Windows on my laptop after years of not using it regularly. It was actually the first time I had actually used Vista, actually and was quite an interesting experience. First, as much as I love the Linux environment, I really expected to loathe being in Windows daily. I was surprised at how much Vista *didn't* suck. With all the raging passion against it in general I suppose that I had low expectations, but nevertheless I really thought it was pretty decent in general. However it has a more sluggish, constricting feel to it in comparison to Linux, so I have decided I have paid my dues and it is time to go back to using an OS that is truly fun to use, rather than one that just wasn't as crappy as I thought it would be.

After lots of experimentation with various flavors, hands-down Ubuntu is the most painless and most comfortable Linux distros for me personally. My reasoning for that is vast and probably belongs in another blog entry, so I will attempt to keep from straying any further off the topic! That said, last night I decided to try gOS which is a really neat distro built off of Ubuntu. Although the UI is Gnome based, it has more of a Max 10.5.x feel to it. I think Mac folks would feel right at home taking this environment for a spin.

Immediately after the first boot of my shiny new OS I started trying to put my development environment back together. I decided that I wanted to have ColdFusion, Railo, and OpenBD all on from the beginning, with all requests first passing through Apache httpd. Quite some time ago, Aaron Lynch put together some steps to install Smith Project w/Tomcat/Apache, which we have used several times since, primarily setting up Railo. I am not sure I ever would have waded my way through it without his early experimentation and documentation. On this iteration, I loosely followed those instructions, opting for several packages from the repos, and updated versions of software, and have documented my steps as the are somewhat different in areas. For my current environment, I first installed OpenBD. I then followed this by installing ColdFusion and setting it up to user the default JRUN connector that is set up during the installation. Lastly, I installed Railo as another webapp in Tomcat and tied that into Apache as well.

In the following posts, you will see these steps in detail.

Next: Part 2 - Installing Tomcat/Apache/OpenBD

Customizing Illudium CFCGenerator XSL to fit your needs

Wed, 28 Jan 2009 19:18:00 GMT

Aaron and I are about to start work on a super-top-secret project (oops! Man I suck at secrets) in which we will be making use of Amazon ec2 and SimpleDB platforms using an Apache/Tomcat/OpenBD setup. Considering the fact that in spite of the coolness of amazon services in production, it seems to be somewhat of a problematic platform to develop on.

So, until we have a a somewhat functional alpha release, we probably will do all the development that we can on local setups. One of the immediate questions was in regards to how we would set up our CFC data model. We tend to be fans of the Service/Bean/DAO/Gateway approach, but things change a bit when it comes to using Amazon SimpleDB. We came to a decision that our best bet would be to have abstract DAO/Gateway classes that would in turn call the appropriate specific DAO/Gateway classes, so if we are working in development the path would be: Service--> AbstractDAO--> MySQL-DAO and in production it would be Service--> AbstractDAO--> Amazon-DAO. To make the change only need to alter a ColdSpring property "databasetype" from "mysql" to "amazonbd". Notice the "BD" at the end of Amazon? That is because this is not only an Amazon data object, but one that is actually designed for use with OpenBD to make use of the <cfquery dbtype="amazon" /> functionality! Down the line we may add other specific subclasses as well as we need.

One other approach that Aaron and I live and die by in our objects is to steer clear of custom code into our generated CFCs. If you ever make changes to your database or objects in general that require you to re-generate them, it can be a real pain in the ass to make sure that you don't overwrite custom code that you spent precious hours on. Our solution to this is to have all of our Bean/DAO/Gateway/Objects extend base classes so that if you have a UserDAO.cfc there would also be a BaseUserDAO.cfc which would be generated as an empty object. We can then safely stuff all sorts of custom functionality in that base object, such as hasMany relationships/methods, etc, and then later regenerate the DAO itself on a whim, typically without repercussions whatsoever.

With all of this functionality, we now end up with a ton of CFCs in each package, but the flexibility gained is well worth it. Just how many? Well in the example of a User, we would have:

User
BaseUser
UserService
BaseUserService
UserDAOAbstract
BaseUserDAO
UserDAOMySQL
UserDAOAmazonBD
UserGatewayAbstract
BaseUserGateway
UserGatewayMySQL
UserGatewayAmazonBD

For those that have used and know Illudium, you know that the templates it comes with don't fit these patterns! I decided that I would set out to *make* it fit.

Of course I took the first tool I could grab in my toolbox - my sledgehammer - and started hacking into the Flex code trying to figure out what exactly I could change to make this work. After more investigative work than I would like to admit, I realized I didn't need my sledgehammer at all!

Brian Rinaldi has written such a flexible tool that I needed to do no more than create a new set of XSL templates to fit my needs and the rest would all fall in place. If you look in the illudium code under cfcgenerator/xsl, you will find a folder named "projects". For some reason it never hit me previously what populated the "Template:" dropdown in the UI, but this list is generated from directories that lie under "projects". I then took a copy of the default XSL templates and put them in a new directory named "subclassed_data" since that is kind of the general goal of this. By adding new XSL docs, modifying the existing ones, and then making sure all the files I wanted to generate were listed in yac.xml, I easily acheived what I was after. Here is the end product of XSL...

Really the only limitation I came across is that I was never happy with the casing that I ended up with. We typically use camel casing in our objects like UserDaoMysql. Given the way that Illudium works it would come out as UserDaomysql. Considering that fact, I opted for making the end products of my CFCs all lower case. Thankfully with ColdSpring I never actually see the casing of my filenames, so I think I can live with that. To make this happen, I ended up changing the only line of the Illudium codebase so that it would force lowercase to the filenames that it saved.

At this point, the only remaining thing that I may do is alter the Illudium UI. Why? Take a look at this!

Some videos from Adobe Max 2008 in San Francisco

Thu, 20 Nov 2008 21:29:00 GMT

Adobe kicks off Day 1 in San Francisco (keynote highlights and commentary from attendees)
From Adobe Flash Catalyst to Adobe CS4, see highlights from Day 2 (keynote highlights and commentary from attendees)
What was your geek-out moment of the day? (Day 1)
What was your geek-out moment of the day (Day 2)

How to install KDE 4.1 on Ubuntu Hardy 8.01 and my impressions of it

Thu, 31 Jul 2008 03:02:00 GMT

With yesterday's announcement of the 4.1.0 release of KDE, my willpower did not allow me to go another day without giving KDE4 another shot. For a bit of history, I have been using Gnome for several years. In the past 3 months or so I began using KDE 3.5.9 long enough that I began to enjoy it and realize that it is a nice desktop environment as well. At this point I really have no favorite between the two and like different things about both of them.

When the first releases of KDE 4 started showing up several months ago, I gave it a shot but was extremely underwhelmed. While it came with all the warnings from the community that the 4.0 release was nothing more than the introduction of a new platform which developers would expand, some of the basic pieces of it just felt wrong. I can clearly say that after spending most of an afternoon using it, running my development environment, and doing basic daily functions, 4.1 is light years beyond the first peak I had of it. I am *really* enjoying it so far and I have a feeling it will be my desktop of choice for the immediate future.

One thing that seems to not be common knowledge to some people is that you can just install it and try it out without affecting your existing desktop environments, be it KDE 3.5.x or Gnome. For example, my current installation started out as Kubuntu 8.04 Hardy Heron. Shortly after installing I added Gnome by running:

sudo apt-get install ubuntu-desktop

Then in the GDM or KDM login window, I had options for either logging in using Gnome or the default KDE. Thankfully the two coexist without bothering each other, and I can switch back and forth at will. I took the same approach today when installing KDE 4.1, planning to keep both Gnome and KDE 3.5 as fallback positions or simply to use when I am in the mood.

If this type of setup sounds like something you want to try out, do the following. First, add the following repo into your /etc/apt/sources.list file:

deb http://ppa.launchpad.net/kubuntu-members-kde4/ubuntu hardy main

After adding that you will want to update your repos by running:

sudo apt-get update

Then to install KDE 4.1 you will run the following:

sudo apt-get install kubuntu-kde4-desktop kdeplasma-addons amarok-kde4 and kontact-kde4 kate-kde4 kmail-kde4

Notice that I am also updating several applications, such as kate, amaroK, kmail, and kontact. Kdeplasma-addons also brings you some extra goodies beyond the base install. During that installation you will be prompted to choose your login manager. KDE4 brings you yet another option beyond GDM and KDM. I chose it and it is a really nice clean look. I recommend giving it a look. Once the installation completes, restart X or reboot and have fun!

Dependent objects made even easier in Mach-II 1.6

Wed, 23 Jul 2008 14:39:00 GMT

In case you were wondering if Mach-II could get any cooler, the answer is *yes*!

For a few versions now, Mach-II has added the ability to inject ColdSpring beans in to your framework components (listeners, plugins, and filters) by use the parameter resolveMachIIDependencies when instantiating the ColdSpring plugin or property.

Take this example... Say that I have a LoginListener.cfc that is dependent on a ColdSpring bean LoginService that lives in our /com directory. I would first define that bean in our ColdSpring config like this: [codeblock 178]

Then, in our LoginListener we would need to create a setter that matched the Bean that we have defined in ColdSpring like so: [codeblock 179]

By taking these two actions, and insuring that your LoginService as an init() method as a constructor, when you initialize your application, variables.LoginService will automatically be available to you as an instance of your LoginService bean. That alone was pretty dang cool.

But wait there's more!

With Mach-II 1.6, this process has become even less cumbersome. In some CFML tags, you can add unexpected attributes without throwing exceptions and are in essence ignored to offer a better solution for managing dependent objects. By default, Mach-II will look for a "depends" attribute in your tags, which can contain a comma separated list of your dependencies. For our simple LoginListener, our tag would look like this: [codeblock 180]

Now, instead of repetitive getters/setters, just by merely having that attribute, our LoginListener will now contain the method getLoginService() which will return an instance of the LoginService. That is just ridiculously easy!

As I said, the attribute actually accepts a comma separated list, so as we add dependencies, our tag might look more like this: [codeblock 181]

If you have made it this far, you have probably deducted that we will now have access to getLoginService(), getUserService(), and getLoggingService().

As I mentioned earlier, Mach-II will look for the attribute "depends" by default, but you can customize it to use other attribute names if you wish. You can find that information and more on the Mach-II wiki.

Related checkbox validation with JQuery

Wed, 16 Jul 2008 14:41:00 GMT

I was given a problem yesterday where I needed to do the following client-side validation. If a user selects a checkbox that they wish to enable credit card transactions, I need to display a panel of specific credit card companies and they need to select at least one before submitting.

If you think about writing the JS to do this without a library it is a somewhat lengthy task. In essence, you would need to do some type of an onsubmit function on your form, check the value of the key checkbox. If it was checked, check the value of each credit card checkbox to see if the user had selected one of the children. After writing this in JQuery, I thought it might be worth demonstrating what an easy task this is.

Let's start with the specific part of my form that has my checkboxes:

<label for="RequireCCInfo">Require Credit Card Information?</label> <input name="RequireCCInfo" id="RequireCCInfo" value="1" type="checkbox"> <div id="CreditCardCompanyPanel">  <div>   <input id="ccAmex" class="ccCheckBox" value="1" type="checkbox">   <label for="ccAmex">American Express</label>  </div>  <div>   <input id="ccVisa" class="ccCheckBox" value="1" type="checkbox">   <label for="ccVisa">Visa</label>  </div>  <div>   <input id="ccDiscover" class="ccCheckBox" value="1" type="checkbox">   <label for="ccDiscover">Discover</label>  </div>  <div>   <input id="ccMc" class="ccCheckBox" value="1" type="checkbox">   <label for="ccMc">Master Card</label>        </div> </div>

There is nothing too notable in all of that other than the fact that you should notice that I have added a class "ccCheckBox" to all of my dependent checkboxes. I will explain more on that in a bit, but I wanted to point out that it is there. You will also notice that I am not doing anything in the way of hiding the "CreditCardCompanyPanel" div. We need to determine at request time whether that will be hidden or not based on whether the "RequireCCInfo" checkbox is checked.

Now, here is the fun part... I am including the JS that I use for this task below:

<script language="javascript">  (document).ready(function(){  $("#RequireCCInfo").change(function(){   toggleCreditCardCompanyPanel();  });    function toggleCreditCardCompanyPanel() {   if ($("#RequireCCInfo").attr("checked") == true)  $("#CreditCardCompanyPanel").show();    else $("#CreditCardCompanyPanel").hide();  }  $("#SaveButton").click(function(){   var pass = false;   if ($("#RequireCCInfo").attr("checked") == true){    $(".ccCheckBox").each(function() {                   if ($(this).attr("checked") == true) pass = true;               });   }   else pass = true;   if (pass) $("#frmMyForm").submit();   else alert('You must select at least on credit card company if "Require Credit Card Information" is checked.');  });   toggleCreditCardCompanyPanel(); }); </script>

First, by using the $(document).ready() function we are telling JQuery to run this JS once the DOM has been completely loaded. Let's look at each section within that ready() block...

The first thing you will see is the $("#RequireCCInfo").change() method. JQuery gives us the concept of binding a listener to an element. For our example, this listener says that anytime that an element with an ID of "RequireCCInfo" is changed, that we will run the code in its function(). You will see that anytime our "RequireCCInfo" checkbox is changed we are going to run a function called toggleCreditCardCompanyPanel(). As you can see we have that method defined immediately after our "RequireCCInfo" checkbox.

In our toggleCreditCardCompanyPanel() method, we are making the decision as to whether or not our "CreditCardCompanyPanel" will be displayed based on whether our user has decided to check the box labeled "Require Credit Card Information?". By using the JQuery selectors we are in essence saying: If a checkbox with an ID of "RequireCCInfo" is checked, display an element with the ID "CreditCardCompanyPanel". Otherwise we will hide this element.

Next comes our validation on form submit... and pretty cool stuff!

Basically I have added a listener which is bound to our submit button with the ID of "SaveButton" which will submit our form "frmMyForm". Anytime that this button is clicked, we will run the code in the function() block. We start this function by setting a value pass=false. We will use this variable to determine whether our form has passed validation. Next we get just a small taste of the magic of JQuery selectors. First, as we did in the toggleCreditCardCompanyPanel() function, we are determining if the element with the ID of "RequireCCInfo" is checked. If so, by using the each() function, we are going to loop through all elements on the page with the class "ccCheckBox" (remember that from above?). In each iteration of the loop we are going to determine if the element has been checked. If so, we are going to set pass=true since we know that our validation has passed.

Lastly, now that we have determined that our form is either going to pass/fail, we take the appropriate action. If pass==fail, we are simply going to alert a message telling the user that if they are going to enable credit cards that they have to choose at least one credit card company. Otherwise, we are going to call the submit() method on our form.

I almost took the time to write out the equivalent of this in POJS (plain old JavaScript) to show how much easier life is with JQuery, but I realized I didn't have the time, patience, or will. JQuery has spoiled me!

Sorry for the RSS Feed mishap!

Thu, 03 Jul 2008 16:06:52 GMT

OK, so the sleep-deprived minds behind InstantSpot hit the wrong switch this morning, and suddenly on AXNA, coldfusionbloggers.com, and God knows what else, I was being credited with a lot of blog entries that I never wrote. The issue was resolved almost immediately, however, the posts are probably going to continue to show up on the aggregators until they age off. Sorry for the feed spam everyone!

EDIT:
Here is a little more detail for those that were asking -

Bottom line... Aaron and I just completely goofed in a pre-coffee misstep this morning. In our logs we saw this continual 404 on a feed url that doesn't exist in our system. We thought "Hey, let's just point it to the main RSS and have it at least do *something*! Turns out this was a feed url from 3+ years ago when my blog used BlogFusion. So suddenly it started resolving for both AXNA and cfbloggers. As soon as we saw what happened we killed it, but it was too late unfortunately.