Just in Time

Compass & Asset Pipeline Rant

Sun, 29 Jan 2012 10:26:55 -0500

Compass has moved into the area of asset management, stylesheet generation a long time ago. Yet asset pipeline is sort of interfering with Goodness that compass is. New compass 0.12 promises to integrate more fully into asset pipeline engine, but it isn’t fair for many of the compass crowd to be writing suboptimal code for older versions of rails while they evolve at ever increasing rate.

Releases of rails app come out faster and faster and it seems that many of the plugins and libraries fail to catch up at an acceptable rate. Perhaps moving forward DHH & Co, can put forth plans of what they will do instead of doing whole cowboy thing and whipping out versions of rails that behave quite differently from their earlier cousins in respect to plugins and extension gems.

Integrate nginx with upload , mogilefs and passenger module in MacPorts

Wed, 18 May 2011 06:17:00 -0400

At the end of the post there is Portfile bit that you find on your system like so:

find /opt -iname ‘Portfile’|grep nginx

This allows to install 3 modules at once via variants option in macports. Install command would be:

sudo port install nginx +passenger +mogilefs +upload

You may place this file however in your home directory: /Users/jondoe/macports/www/nginx/Portfile and it will take precedence over one that is placed in /opt/local/var/macports.

Portfile bit:

variant passenger description {Passenger Hack} {
    configure.args-append   —add-module=/usr/local/lib/ruby/gems/1.8/gems/passenger-3.0.4/ext/nginx
}

variant mogilefs description {Enable mogilefs module\
        (http://www.grid.net.ru/nginx/mogilefs.ru.html)} {
    set mogilefs_filename nginx_mogilefs_module
    set mogilefs_version 1.0.4
    set mogilefs_distname ${mogilefs_filename}-${mogilefs_version}
    distfiles-append    ${mogilefs_distname}.tar.gz:mogilefs_module
    checksums-append    ${mogilefs_distname}.tar.gz \
                        md5   2466aa02b225ad2aa1af22e6e50a9d2f
    configure.args-append   —add-module=${workpath}/${mogilefs_distname}
}

variant upload description {Enable Valery Kholodkov’s upload module\
        (http://grid.net.ru/nginx/upload.en.html)} {
    set upload_filename nginx_upload_module
    set upload_version 2.2.0
    set upload_distname ${upload_filename}-${upload_version}
    distfiles-append    ${upload_distname}.tar.gz:upload_module
    checksums-append    ${upload_distname}.tar.gz \
                        md5     2681a6167551830a23336fa41bc539a1 \
                        sha1    93d6e83e613a0ce2ed057a434b344fa1b6609b47 \
                        rmd160 5734af837be3fe8ec444a7e5e7f6707118594098
    configure.args-append   —add-module=${workpath}/${upload_distname}
}

There is a helpful post for installing nginx with modules from OpenMyMind.

C2Go @ stanford

Wed, 11 May 2011 06:49:54 -0400

C has been the workhorse language for writing native code for projects likes of scripted language extensions, binding those to various libraries or just plain writing simple high performance systems utilities.

Go is the new kid on the block and I did come across an article that sort of makes clear how to transition (at least for me) from C to Go programming.

A quick skim might give you an idea wether you might use this language or not, thought Google being where it is, this language may well be the next step beyond C.

Not great error messages

Sun, 08 May 2011 06:30:01 -0400

Sometimes developers need to be a bit kinder to other developers. Such as telling them more about what is going on, if behaviour deviates from generally intended path of execution. Such as, when I have installed thinking-sphinx in rails 3 app, i have gotten a message:

found version:

and that was it. Having this plugin used in the past and knowing that I had done fresh system reinstall I’ve gone to check wether I have the binaries of the sphinx server - which I didn’t have. All was fixed in a few minutes, yet somehow I think this error should’ve been a bit more descriptive.

I think I’ve got to submit a patch.

Great weather

Wed, 27 Apr 2011 04:40:43 -0400

The spring finally came, and the summer seems to step on springs toes. People are out, and the office is empty.some went to usa some tuo europe. Traffic volume has dropped three fold…

nginx + upload + paperclip

Tue, 12 Apr 2011 08:00:00 -0400

Just recently I have tasked myself with supplementing image uploading mechanism with nginx’s upload module.

Rails is written in pure ruby, so naturally uploading which implies decoding hundreds if not thousands kilobytes from a multi-part text stream into binary form on the disk. As if image manipulation wasn’t taxing enough - so decision was made to accelerate it with a well known third party nginx upload module.

First thing you need to load and install nginx, preferably latest stable version. If you use MacOS X you can install it as easily as launching ports install comand like so:

port install nginx +upload

For from source install you would need to install nginx with specifying path the source of the upload module like so:

./configure —prefix=/usr/local —add-module=../nginx_upload-*.tar.gz
make && make install

Then you need to configure a location which will be responsible for receiving paths to decoded files. As it happens decoding gives you content-type for each of the file that has been decoded. It can be done like so:

server {
    client_max_body_size 100m;
    listen       80;

    # Upload form should be submitted to this location
    location /upload {
        # Pass altered request body to this location
        upload_pass   @test;

        # Store files to this directory
        # The directory is hashed, subdirectories 0 1 2 3 4 5 6 7 8 9 should exist
        upload_store /tmp 1;

        # Allow uploaded files to be read only by user
        upload_store_access user:r;

        # Set specified fields in request body
        upload_set_form_field $upload_field_name.name “$upload_file_name”;
        upload_set_form_field $upload_field_name.content_type “$upload_content_type”;
        upload_set_form_field $upload_field_name.path “$upload_tmp_path”;

        # Inform backend about hash and size of a file
        upload_aggregate_form_field “$upload_field_name.md5” “$upload_file_md5”;
        upload_aggregate_form_field “$upload_field_name.size” “$upload_file_size”;

        upload_pass_form_field “^submit$|^description$”;

        upload_cleanup 400 404 499 500-505;
    }

    # Pass altered request body to a backend
    location @test {
        proxy_pass   http://localhost:8080;
    }
}

This excerpt is taken from upload pugin doc page. I know this works like this: the plugin monitors incoming requests for them to have multipart encoded data. Once it has found such a connection that contains a file - it decodes the file on the the disk into a temporary location. It allows you to set one of the variables to contain a path to the decoded file. It passes then ‘compressed’ version of the request - sans data representing file data through to the proxy location specified.

If you application server is running on http://localhost:8080, you need to have it accept modified forms and paths to the files saved to the disk.

Upload module can conveniently remove tmp files for you, if you app generates some sort of errors via upload_cleanup directive, which specifies upon return of what HTTP status code it should remove the file from the disk, before letting nginx process next request.

Then you can add Rails Rack MiddleWare to open files, paths to which are passed in the form, replacing the form variable with a handle to an open file. You must delete uploaded files though.

Rails 3 & Railties

Sun, 10 Oct 2010 06:04:00 -0400

Rails 3 introduced a new package and a set of new conventions for plugin integration.

You will need to be familiar with writing a GEM and Api that Railtie GEM provides.

There is a number of excellent articles out there, I can recommend two of them one is GEM railscast and other is explaining Railties by example.

Django vs Rails Shootout

Sat, 03 Jul 2010 21:29:26 -0400

It is being delayed by one week, as real work takes precedence over software tomfoolery :)

scrollWidth & jQuery missing it

Fri, 25 Jun 2010 17:12:37 -0400

With animating certain parts UI, one comes to appreciate el.getScrollSize() in mooTools pretty fast.

jQuery is missing this function. How it looks in mooTools.

2432 getScrollSize: function(){

2433 var doc = getCompatElement(this), min = this.getSize();

2434 return {x: Math.max(doc.scrollWidth, min.x), y: Math.max(doc.scrollHeight, min.y)};

2435 },

There is a plugin for jQuery that does enable different sizing patterns. I would think it to be essential since javascript is enabling transition active web apps from Flash to HTML5.

Rails & Django

Fri, 25 Jun 2010 15:13:07 -0400

Over next week I will be picking up bits of Django. And writing comparing ORM, Template Engine, Url routing and other components of two of these popular frameworks.

node.js is pure awesome

Wed, 17 Feb 2010 12:22:11 -0500

node.js is catching attention of many web developers. It seems that it will primetime sometime this summer when market demand for Web 3.0 apps will materialize. Key selling point of node.js is brutal efficency in terms of small bits of data, short requests.

Alot of people seem to have varying ways of defining Web 3.0, node.js I think will be the kind of backing technology for such a beast. Plurk sort of showed us how it will all be, even though its a bit quirky. 3.0 with be defined by javascript heavy client side apps (utilizing HTML5 when it comes) or using crutches like JQuery & MooTools to provide crossbrowser platform. node.js couples wonderfully to with Javascript on client side, and can provide realtime data, by the time WebSockets will come around.

Because node.js is javascript and much of active pseudo-application like content (AJAX & more) is backed by javascript, it will allow to reduce costs & complexities as Java promised and JavaScript (dare I say ECMA Script ? ) has delivered. JSON is already the most popular format for many people, as XML is highly complex. Most just hate it. JSON format is essentially Javascript.

Node.js follows a paradigm change in web request processing, initiated with nginx a project written to replace Apache. Node.js uses event driven processing and non-blocking IO/Database access to achieve efficency that we could only dream of. V8 JIT technology boosts performance quite a bit as well. And performance is improved by an order of magnitude. Yes, that it is around 10 times faster then comparable solutions with Ruby or Java.

Check out http://nodejs.org/