Monthly Archives: February 2010

YUICompressor CFC v0.1 Released

If you are looking for ways to minify, optimize, and compress your CSS and Javascript with ColdFusion, this is an all-in-one solution based on the YUI Compressor Java library.

It’s simple but powerful.

The project and code: YUICompressor CFC @ RIAForge

There is some sample code included with the download package.


project: YUICompressor CFC
author: Tom de Manincor
version: 0.1.1
date: 2/18/2010

-overview-
This CFC allows you to use the YUI Compressor Java library.

"The YUI Compressor is a JavaScript compressor which, in addition to removing
comments and white-spaces, obfuscates local variables using the smallest
possible variable name. This obfuscation is safe, even when using constructs
such as 'eval' or 'with' (although the compression is not optimal is those
cases) Compared to jsmin, the average savings is around 20%.
The YUI Compressor is also able to safely compress CSS files. The decision
on which compressor is being used is made on the file extension (js or css)"

This CFC adds some more flexibility. It accepts an input string or a file, as long as its valid JS or CSS.
You can also choose to return the compressed results back as a string or a file.

It is using the YUI components for both CSS and JS.
For more information on the YUI library visit:
http://developer.yahoo.com/yui/compressor/

-requirements-
ColdFusion 7 or Higher
JavaLoader (optional)
YUI Compressor Java Library (version 2.4.2 included)

-usage-
The constructor (init method) is required if using inheritance (ClassLoaderAdapter).

Since this is dependent upon the YUI Java library,
I have integrated a ClassLoaderAdapter that allows you to toggle between JavaLoader
or the CF native ClassLoader that will use libraries found in your CF class path.
Remember, if you are not going to use JavaLoader then make sure you put the yuicompressor-2.4.2.jar in your CF class path.
If this is the approach you choose you also have the option to discard the ClassLoaderAdapter.
Instead of using the YUICompressor.cfc and the ClassLoaderAdapter.cfc, rename and use the included YUICompressor_noinheritance.cfc.

-note-
Do not use the additional libraries that are bundled with the base jar. String Index out of range errors may occur.

-credits-
Joe Roberts

0.1 -INITIAL RELEASE- 2/18/2010
-JS and CSS compression supported
-auto detect input type
-allow input files or string
-output to file or string

Installing Railo 3.1.2 on Centos 5.4 with Apache and Virtual Hosts

I finally had the chance to install the latest Railo CFML Engine on my Centos 5.4 VirtualBox VM. I found a few good resources online, but still came across a few kinks, so I’d thought I would put together a recap including the work arounds.

Before you begin, you must have a Java 6 JDK installed. If you don’t already you can get it from the Sun Java Download Page

Note the installation path. For this example, I will be using:

/opt/jdk1.6.0_17

There are a few Linux dependencies. I never like to install things I don’t need, so I avoided the suggestion to install all ‘Development Tools’ from the Centos Add/Remove Software feature. Instead I used yum to install the noted packages. Later, adding to that list as I dealt with errors during the installation.

My compiled list so far:
automake
autoconf
binutils
gcc
libtool
httpd-devel
openssl-devel
lynx

I may have had others already installed, so if you find any that are not on the list, please post them.

Here is the command line to install them all:

yum install automake autoconf binutils gcc libtool httpd-devel openssl-devel lynx

Once yum has done it’s thing and all packages have been installed or updated, our system is prepared. Let’s get Railo installed.

First, we need to extract our installation package. If you haven’t downloaded one already, they are available at the Railo Download Page.

For this example, I have moved the tarball into the opt directory, where I will be installing Railo.

tar -xzf /opt/railo*.tar.gz

Clean up and remove the unused files:

rm railo*.tar.gz
cd railo
rm -rf httpd.exe install-service.bat remove-service.bat setup.exe win32
cd ..

The next part is a matter of preference. You can leave the Railo folder name as is, create a symbolic link, or just rename it.

In some situations, you may require multiple versions of Railo running but prefer one as the default. Symbolic links work nice there.


ln -s railo-3(hit tab to auto complete folder name) railo

#version specific
ln -s railo-3(hit tab to auto complete folder name) railo3

Another option is a Simple rename:

mv railo-3(hit tab to auto complete folder name) railo

#version specific
mv railo-3(hit tab to auto complete folder name) railo3

Railo is now unpacked, and just needs to be integrated with Apache Web Server.
It has a few scripts that do the heavy lifting. We need to configure and build the connector module Apache will use. This is where most of the earlier described linux dependencies are involved, so keep an eye out for any error messages.


cd railo3
./configure --with-java-home=/opt/jdk1.6.0_17 --with-apxs=/usr/sbin/apxs

It was mentioned to look for “checking for JNI in /opt/soft/java/include/linux … found”. That being an indicator of a successful build. Unfortunately, this is one of the areas, I had a number of errors, and even saw the correct JNI message. Hopefully, the list above of dependencies covers it, and you don’t see anything unexpected here. I was able to get away with a AC_PROG_LIBTOOL undefined error. I checked to make sure libtool was installed, and it was. Everything worked beyond this point, if you see this don’t be alarmed.

The next step, is to actually build the module file and have it installed with the other Apache modules. Before we can do this, we need to create a few symbolic links to take care of an installation bug.


cd /opt/railo3/modules/c/src
ln -s resin_os resin
ln -s resin_os resinssl
cd /opt/railo3

Now create the file using the distributed automake files:

make

The Apache integration is automated, as well:

make install

I had to make a few changes to my Apache configuration files, since I also have Adobe CF 8 and CF 9 running on the same machine. If you don’t this will still work, and is a good practice. It keeps Railo isolated, and the more familiar you are with Apache the more you will see how flexible this approach is.

Open the Apache conf file /etc/hettpd/conf/httpd.conf.
Look for the lines:

#
# mod_caucho Resin Configuration
#
LoadModule caucho_module /usr/lib/httpd/modules/mod_caucho.so
ResinConfigServer localhost 6800
CauchoConfigCacheDirectory /tmp
CauchoStatus yes

I created a virtual host for Railo and moved the added lines into it:


ServerName centos54r3
DocumentRoot /mnt/dev/src
LoadModule caucho_module /usr/lib/httpd/modules/mod_caucho.so
ResinConfigServer localhost 6800
CauchoConfigCacheDirectory /tmp
CauchoStatus yes

SetHandler caucho-status


Keep in mind, a few of these values are specific to my setup. The ServerName and the DocumentRoot will vary.

I also added the Caucho Status location. It’s a nice reference, and also a good test page.

Almost there…

Let’s update our Railo instance so that it is in sync with our virtual host.
Edit the /opt/railo3/conf/resin.conf. You can add your own host definitions in here, but for now I just updated the default host entry. It now points to the DocumentRoot of my Apache virtual host.




One last step before we can start up the resin server. We need to add a few values to the start up script. Open up /opt/railo3/bin/httpd.sh in a text editor and add your JAVA_HOME and RESIN_HOME paths after the initial comments or anywhere before the beginning of the script.


JAVA_HOME="/opt/jdk1.6.0_17"
RESIN_HOME="/opt/railo3"

Now it’s time to fire up the Resin server:

/opt/railo3/bin/httpd.sh start

To test your installation open the Admin URL from your client browser:
http://virtualhostname/railo-context/admin.cfm
For example, http://centos54r3/railo-context/admin.cfm

** Virtual hosts require entries in hosts file for the URLs to resolve. If you are not familiar with Virtual Hosts, please check the Apache docs.

Thanks to the Railo team for the initial resources:

Railo, Resin, Apache, and Linux PDF

Installing Railo on CentOS

Simultaneous CFML Engines using Apache HTTP Server on Linux or Windows

I wrote an article awhile back, No More WAR, demonstrating how to set up CF 7 and 8 without using the WAR files. Instead, I used CF in stand-alone mode and Apache’s Virtual Host configurations to create separate environments, that could run side by side.

I wanted to see if anything had changed with the JRun config that this technique depends on in CF 9. Fortunately, things remain the same in that department. The method is still applicable, and I am currently running: CF 7, 8, and 9 on both Linux and Windows platforms running Apache Web Server.

Why stop there? Let’s add Railo 3.1 to that list. For instructions on how to integrate Railo with Apache, check out this post.

DropIO CFC v0.1 Released – drop.io ColdFusion Library

Bringing the power of drop.io to ColdFusion.

drop.io is a handy cloud collaboration tool.

To quote drop.io:

“Use drop.io to privately share your files and collaborate in real time by web, email, phone, mobile, and more.”

“With the drop.io API, your app can leverage our core web-services to share what you want, with whom you want, how you want. Anything you can do with the drop.io interface, you can do via the API, so you can develop powerful extensions to the drop.io service, or cherry pick specific functionality from drop.io for your apps.”

Check out their web interface drop.io.

To use drop.io with ColdFusion, I’ve posted the project DropIO CFC @ RIAForge.

The download package includes a sample application, as well.

To find out more about working with drop.io check out the developer page.

Project ‘readme.txt’:

project: DropIO CFC
version: 0.1
date: 2/5/2010

-overview-
This CFC allows you to connect and work with drop.io's API.

-requirements-
ColdFusion 7 or Higher
drop.io API Key (free - http://api.drop.io/)

-usage-
The constructor (init method) is required.
There is a dependency on Javascript libraries for file transfers.
See the included js folder and code examples for integration.

To setup the code samples provided,
place your drop.io API Key in the createObject call in the onApplicationStart method of the Application.cfc
Follow the instructions on the page.

-note-
drop.io Developer Page: http://dev.drop.io/

0.1 -INITIAL RELEASE- 2/5/2010
-supports the following drop.io API methods:
createComment
createDrop
createFile
createLink
createNote
deleteAsset
deleteComment
deleteDrop
getAsset
getAssetEmbedCode
getAssetList
getComment
getCommentList
getDrop
getUpload
sendAsset
updateAsset
updateComment
updateDrop
uploadFile
uploadResponse