AndreaCfm

Something about bundler and gems dependencies

Sun, 05 Jun 2011 17:43:01 GMT

Since some months I have started to programm in Ruby and especially using the Rails framework. I have to say I find Rails so great that I realized, that after some months, that I can be quite productive knowing very little about Ruby itself. This tells you how powerfull can be a dsl written in Ruby and talks about the nice job Rails developers did but is not going to make me shine as a Ruby developer.

I have decided to step back and I am finally going to open a Programming Ruby book seriously. I will go throught my Ruby discovering writing here my tests and anything I will discover in my learning Ruby travel. This will help me to fix some concept in my mind and hopefully someone else will learn from my mistakes.

For the moment I discovered something about bundler I really didn't know before and I 'd like to share. I have just ended reading a post of Yehuda Katz about Bundler and Gems dependencies that really opened my eyes.

Something from Yehuda post:

Basic Versioning Rules for Apps

After bundling, always check your Gemfile.lock into version control. If you do this, you do not need to specify exact versions of gems in your Gemfile. Bundler will take care of ensuring that all systems use the same versions.
After updating your Gemfile, always run bundle install first. This will conservatively update your Gemfile.lock. This means that except for the gem that you changed in your Gemfile, no other gem will change.
If a conservative update is impossible, bundler will prompt you to run bundle update [somegem]. This will update the gem and any necessary dependencies. It will not update unrelated gems.
If you want to fully re-resolve all of your dependencies, run bundle update. This will re-resolve all dependencies from scratch.
When running an executable, ALWAYS use bundle exec [command]. Quoting from the bundler documentation: In some cases, running executables without bundle exec may work, if the executable happens to be installed in your system and does not pull in any gems that conflict with your bundle. However, this is unreliable and is the source of considerable pain. Even if it looks like it works, it may not work in the future or on another machine. See below, “Executables” for more information and advanced usage.
Remember that you can always go back to your old Gemfile.lock by using git checkout Gemfile.lock or the equivalent command in your version control.

Executables

When you install a gem to the system, Rubygems creates wrappers for every executable that the gem makes available. When you run an executable from the command line without bundle exec, this wrapper invokes Rubygems, which then uses the normal Rubygems activation mechanism to invoke the gem’s executable. This has changed in the past several months, but Rubygems will invoke the latest version of the gem installed in your system, even if your Gemfile.lock specifies a different version. In addition, it will activate the latest (compatible) installed version of dependencies of that gem, even if a different version is specified in your Gemfile.lock.

This means that invoking executables as normal system executables bypasses bundler’s locked dependencies. In many cases, this will not pose a problem, because developers of your app tend to have the right version of the system-installed executable. For a long time, the Rake gem was a good example of this phenomenon, as most Gemfile.locks declared Rake 0.8.7, and virtually all Ruby developers had Rake 0.8.7 installed in their system.

As a result, users fell into the unfortunate belief that running system executables was compatible with bundler’s locked dependencies. To work around some of the remaining cases, people often advocate the use of rvm gemsets. Combined with manually setting up application-specific gemsets, this can make sure that the “system executables” as provided via the gemset remain compatible with the Gemfile.lock.

Unfortunately, this kludge (and others) sufficiently reduced the pain that most people ignored the advice of the bundler documentation to always use bundle exec when running executables tied to gems in the application’s Gemfile.lock.

It’s worth noting that typing in rake foo (or anyexecutable foo) in the presence of a Gemfile.lock, and expecting it to execute in the bundler sandbox doesn’t make any sense, since you’re not invoking Bundler. Bundler’s sandbox relies on its ability to be present at the very beginning of the Ruby process, and to therefore have the ability to ensure that the versions of all loaded libraries will reflect the ones listed in the Gemfile.lock. By running a system executable, you are executing Ruby code before Bundler can modify the load path and replace the normal Rubygems loading mechanism, allowing arbitrary unmanaged gems to get loaded into memory. Once that happens, all bets are off.

I have to say I learn new things about Ruby every day and I really have to thank devs like Yehuda that keep posting so interesting topics.

Railo cfmap addEvent() support

Wed, 02 Mar 2011 09:30:18 GMT

A couple of weeks ago I was reading a post from Raymond Camden that remembered me I completely forgot to add support to addevent() in Railo cfmap implementation. The blog post was quite interesting and showed a way to add streetview to a google map, generated by cfmap, using the Coldfusion.Map.addEvent function. Read the post here.

Of course code was not running in Railo due to the lack of the method in the Railo js library.

I made a patch and support was added in Railo 3.2.1.005/3.3.0.005.

So following the Ray example (all credits to Ray for the following code) you can run the following code in Railo and adding a streeview to your cfmap using the addEvent() function.

Please note that in Railo js library are available both the Railo and Coldfusion namespaces so Railo.Map.addEvent() is equivalent as running Coldfusion.Map.addEvent().

Have fun!

MongoDb Cache Extension for Railo - New Update

Sun, 13 Feb 2011 18:35:58 GMT

A new update the the MongoDB Cache extension for Railo is on the extension provider.

Some bug was fixed and performance improved by a better tuning of the query that respects the cache expiration timeout. In my tests I could reach 400 interactions ( put and get of 400 items ) in in average time of 1200ms. Pretty awesome!!!!

Railo WebSockets Gateway Extension

Mon, 24 Jan 2011 19:44:17 GMT

I have just uploaded the Railo WebSockets Gateway Extension to the Railo preview extension provider.

This extension enables you to launch a server that is capable to manage messaging from HTML WebSockets.

The server runs on a dedicated port. Railo will receive notifications when a connection is opened, closed and any time a message is sent invoking a cfc listener class. The gateway can also being invoked via SendGatewayMessage so to allow your app to push message to all the connected clients.

While only few browsers natively support WebSockets up to now exists many libraries that mange the failover to flash sockets or other technologies like ajax long polling etc... WebSockets are a great way to implement messaging and data pushing using well known technologies like javascript. The gateway just makes it a breeze pushing data from your Railo application to any connected client.

You can find docs about the extension in the Railo wiki and some sample code cloning the following github repo https://github.com/andreacfm/websockets_example_apps.

Please post any feedback in the Railo Google Group and any bug in the Railo Jira bugtraker.

Railo MongoDB cache extension updated

Sat, 13 Nov 2010 09:20:12 GMT

I have uploaded yesterday a main update of the MongoDB Cache extension for Railo. See installation details here

I have improved the management of timespan and timeidle expiring using some incredible feature that MongoDB offers.

1) Any time you ask for a key the plugin attempts to delete it running a MongoDB query ( optimized using index on any relevant field ) and then fetch it. If key is still there means that is a still valid entry.

2) Any 20 seconds a clean process is runned so to keep the db more updated as possible and making the the flush operation on cacheGet() more efficient.

In my test this has improved speed of about 30% delegating more operation to the db itself.

The following code makes 2000 read/write operation in an average of 1500/1600 ms.

<cfset start = gettickcount()>
<cfloop from="1" to="1000" index="i">
    <cfcache action="put" id="a#i#" value="#i#">
    <cfcache action="get" id="a#i#" name="v">
    <cfcache action="put" id="b#i#" value="#{value = i}#">
    <cfcache action="get" id="b#i#" name="v">
</cfloop>
<cfset end = gettickcount()>
<cfoutput>#end - start# millis</cfoutput>

Amazing !!!!!

Railo Membase Cache Extension available for beta testing.

Sat, 09 Oct 2010 18:14:50 GMT

NorthScale Membase Server is an elastic key-value database that stores web application data far more efficiently and cost effectively than it can be stored in a relational database. With NorthScale Membase Server, organizations can deploy a highly available, cloud-friendly data layer that expands dynamically as application needs change, delivering performance exceeding that of any other NoSQL solution. API compatible with memcached, the de facto standard web caching software, Membase is easy to use and supported by virtually every programming language and application framework.

Membase gives you an easy way to access and use memcached as a key-value database. Membase is a very powerfull solution if you need a reliable, fast and distribuited cache engine.

The Extension allows you to use Membase as a key/value cache for your Objects (components), Templates, Queries and Resources (such as files etc).

More info can be found in the Railo wiki : http://wiki.getrailo.org/wiki/extensions:membase

Railo MongoDB Cache Extension on Beta Test

Thu, 30 Sep 2010 19:17:13 GMT

In these days I am really interested in nosql tools and especially in the MongoDB document databse.

What amazes me about mongo is that is much more than a key value pair storage while it expose a quite complete query api, a full indexes support and an atomic Fast-In-Place data update.

Over this MongoDB supports asynchronous replication of data between servers for failover and redundancy. This makes really easy to share and replicate data between a cluster.

The result is that Mongodb is an incredibly fast and flexible document database.

Following what Mark Drew was doing for CouchDb I thought was a good idea to implement a Railo Cache plugin that bring into Railo world the power of MongoDB used as cache engine.

The extension implements the Railo Cache interface at 100%. This means that you can switch from any other cache that Railo support to MongoDb cache with safety. The driver serialize any object ( or queries or templates etc... ) you want to cache and will reinflate them up when you need to read them. An index is created over the key of your cache objects so that reading them will be a breeze. The plugin also support the mongodb replica Sets ( cluster ) and makes your application wait if a failover is in place.

Many thanks to Mark Drew that made the installation docs over the Railo wiki. You can find more info, installation step by step and details here:

http://wiki.getrailo.com/wiki/extensions:mongodb

RailoAjax is going to close

Sat, 21 Aug 2010 17:12:09 GMT

While this can looks like a bad new .... well it is not.

Latest Railo BER ( 3.1.2.019 ) has included also the missing part of RailoAjax project into the Railo core distribution. From this point the development and maintenanace of the tags will be made directly from the Railo project itself.

As per today Railo included the following tags:

cfajaxproxy
cfajaximport
cfdiv
cfmap
cfmapitem
cfwindow
cflayout and cflayoutarea ( just for tabs )
ajaxonload function
the js library that support the previous tags

I am quite happy about this step. RailoAjax just started like a fun coding of the ajaxproxy and ended into the Railo core..... I really have to thanks all the Railo Team for the support received.

So please note the following:

If you have a RailoAjax extension installed into your server or we context please remove it before update to 3.1.2.019. Or if you have already updated just remove the extension and restart the Railo.
The RailoAjax website and the trac will be shutted down when Railo 3.2 will be delivered.
The RailoAjax extension provider http://railoajax.org/extensionProvider.cfc will be still available up to the 31 december 2010.

If you have any issues please contact me or raise a JIRA tickect.

If you want to help coding new functionalities the source code is available on github.

Mango Github Gists plugin

Mon, 16 Aug 2010 14:31:21 GMT

Something very cool about github services are gists.

Gists are a sort of snippets than you can create, share and embedd using a simple js script tag. I have started to use them very often and I think I will that more and more in the future. JUst think about that gists are also plain git repo and as any git repo can be cloned and shared between your team.

I have created a very simple Mango plugin ( mango in very easy when you want to create plugins !!! ) so that you can embed your gists in your mango posts.

Syntax is incredibly easy .... just have a look here.

The mango auto install url is : http://github.com/downloads/andreacfm/mango.gists/com.andreacfm.mango.gists_1.0.zip

You can also download the zip or clone the source form the same GitHub repo.

Have fun !

CfEclipse and script based cfcs

Wed, 11 Aug 2010 12:08:09 GMT

While the cfeclipse team is working on giving support to the new scripting syntax added recently in cfml I falled into something that can help someone to have a better feeeling in the meantime.

I was not aware, until yesterday, that this syntax is supported in a script based cfc:

<cfscript>
component{
   
    public String function getname(String name="Andrea"){
        return name;
    }
    public String function getlastname(String lastname="Campolonghi"){
        return lastname;
    }
}
</cfscript>

So while it does not really looks "amazing" this will give you code colouring and syntax highlighting. But, most important, the syntax is fully supported from ACF and Railo too ( did not test on OpenBD ).

Some of you will be asking why to do that ? Just use cfbuilder .... and I agree. Cfbuilder is a great tool also if , in my opinion , lack of linux support. But I am one of those who are convinced that cfml deserves an open and strong ide to attract more developers so ... if you think like me consider to donate something to cfeclipse project.

BlazeDS 3.2 integration in Railo

Tue, 27 Jul 2010 11:20:00 GMT

In the Railo mailing lists are often required informations about the settings needed to implement calls via the AMF protocol. If you use the Railo Installers ( thanks again Jordan for this !! ) anything should already being setted up and ready to use but in case of any needs there was a lack of public informations about this topic.

We have now a nice wiki section where you can find a very exhaustive explanations of many aspect of this topic ( credits to Roland Ringgenberg ) .

Have a nice Railo/Blaze Ds integration !!

Railo tip: cffile action touch

Wed, 30 Jun 2010 17:44:48 GMT

For linux/unix user is quite common to use the command touch (from the shell) to update the last modified date of a file (to the current time) or to create a new file.

You can do that as well from Railo :

<cffile action="touch" file="whatever.cfm">

StructNew takes arguments

Wed, 02 Jun 2010 18:22:19 GMT

During last Sotr I was talking with Mark Drew and Micheal Offner-Streit ( the Railo cto ) and we discovered one of the many gems hidden into Railo engine.

Any cf developer has always fight with the missing support for a linked hash map in cfml. This lack has made a task keeping a struct in a defined order. In railo you can simple do this:

<cfset str = structNew('linked') />

What you have now is a struct 100% similar to a normal struct that has the whole capabilities of a linked hash map. For example the map keep the elements into an ordered stack.

You can read more in the railo wiki docs.

Railo Amazon S3 extension included into core

Fri, 28 May 2010 09:27:38 GMT

As you can read from the official Railo Blog the Amazon S3 extension will now be free to download and will be soon moved into the Railo core package.
This is an amazing news from Railo and just one of the extra feature Railo will add in the next future.

So let's stay tuned!!!

Railo starts ajax support

Mon, 12 Apr 2010 18:39:44 GMT

I am a bit late blogging about this but I had a quite 'intense' maech.

Since version 3.1.2.009 Railo starts the ajax tags support . You can read more here.

Ok so what's teh big news? What make me proud is that I developed those tags and after a long debugging they are finally part of the Railo core engine. The tags comes from the RailoAjax project that will go on focusing on the remaining ajax tags to fill the gap with ACF ( that's the plan .... but it's a long road to do ....).

This is an example of how a community effort can really contribute to the main project. I am sure more efforts will come in the future ... so if you an idea .... some spare time ..... and you wish to contribute do not hesitate to contact me .... Railo needs you.