The module I wrote is called CoolBeans. (Thanks for the name, Mr. Chris Peterson). CoolBeans is an Inversion of Control (IOC) / Dependency Injection (DI) library for Node.js. CoolBeans is loosely based on ColdSpring for ColdFusion and Spring IOC for Java. It’s a single js file and currently appears to be quick and easy.

To install:

npm install CoolBeans

To use CoolBeans you simply create an instance of the CoolBeans and load the configuration file like this:

var cb = require("CoolBeans");
cb = new cb("./config/dev.json");

The above code is the only require function you should need in your entire application. Once you’ve required CoolBeans you need to create a new instance and pass in the path to its’ configuration. This is shown above.

Once you have the fully loaded CoolBeans you can use it to quickly create fully configured singleton objects based on its’ configuration. The config file for CoolBeans is a JSON file so the entire thing is wrapped in {}.

Each element in the root of the configuration file is a bean (bean = Java for object) that CoolBeans can create. Here’s an example:

{
     "fs": {"module": "fs"}
}

This is essentially the same as:

var fs = require("fs");

However, we now only need to define this one time for an application, rather than in each file that requires it.

You can also specify paths to modules that are not node_modules. For example:

{
     "Recipient": {"module": "./entities/recipient"}
}

At the most basic, the above means that CoolBeans will call require for the module and cache the results in a variable named Recipient.

As a relative newb to Node.js, I think I’ve handled this correctly. CoolBeans is a node module which means that NPM will install into ./node_modues/CoolBeans. The actual CoolBeans script is in the lib directory. That means, that from the perspective of CoolBeans your components are three directories above it. For this reason, CoolBeans looks three directories above it for the module specified. So, the Recipient module above actually turns into ../../.././entities/recipient. This has the effect of making the paths to modules specified in the configuration file relative to the root of your module or application. So, if you make a module that depends on CoolBeans and later publish it via NPM I think it should work correctly when used in other projects.

You can get any of the configured beans by calling cb.get(“beanName”) where beanName is the name of the bean you want to get. For example:

cb.get("Recipient");

The above will lazily create the Recipient bean, cache it as a singleton, and return it.

You can get a lot more complex with configuration too. For example, you can specify if CoolBeans should call a constructor and what arguments to pass into the constructor. For example:

"codeGenerator": {
     "module": "./util/codeGenerator",
     "constructorArgs": [
         "foo",
         123
    ]
}

What the above is saying is that when we get the codeGenerator bean, we need to load the module specified then call new on the module and pass in the values specified in the constructorArgs section to the constructor. The above means:

new codeGenerator("foo", 123);

You can also specify more complex values to pass into constructor arguments:

"codeGenerator": {
    "module": "./util/codeGenerator",
    "constructorArgs": [
        "foo",
        123,
        {"value": [1, 2, 3]},
        {"value":
            {
                "foo": "bar",
                "bar": "foo"
            }
        }
     ]
}

Note that while you can specify a string without indicating explicitly it’s a “value”, for arrays and anonymous objects you need to provide an object with a property named “value” whose value is the value you’re trying to pass in. The above could be written more explicitly as:

"codeGenerator": {
    "module": "./util/codeGenerator",
    "constructorArgs": [
         {"value": "foo"},
         {"value": 123},
         {"value": [1, 2, 3]},
         {"value":
             {
                  "foo": "bar",
                  "bar": "foo"
              }
         }
    ]
}

Strings, numbers, arrays, and anonymous objects are not the only things you can pass into constructors. You can also specify other beans that could be passed in. For example, let’s say we had a database configuration object you want to pass into any object that is used to access data you could do the following:

"mysql": {"module": "mysql"},
 
"dbConfig": {
    "properties": {
        "host": "server.hostname.com",
        "port": 3306,
        "user": "mysqlUser",
        "password": "password123",
        "database": "foobar"
    }
},
 
"recipientDao": {
    "module": "./db/recipientDao",
    "constructorArgs": [
        {"bean": "dbConfig"},
        {"bean": "mysql"}
    ]
}

The mysql bean is simply the same as saying require(“mysql”). The dbConfig is an anonymous object with properties specified (more on this in a bit). When the recipientDao (dao = data access object) is created, CoolBeans will see the “bean” property and will create and pass into the constructor the fully-constructed dbConfig object and the mysql object. Here’s what that recipientDao might look like:

module.exports = function(dbConfig, mysql){
    this.listRecipients = function(userId, callback){
        var client = mysql.createClient(dbConfig);
        client.query(
        "SELECT id, name, addressLine1, IfNull(addressLine2, '') as addressLine2, city, state, zip, taxDeductible, created, updated, 0 as netDonations " +
        "FROM recipient " +
        "WHERE userId = ? AND deleted = 0 "+
        "ORDER BY name",
        [userId],
        function(err, results, fields){
            client.end();
            callback(results);
        });
    }
}

Note that there are no require statements. The object just gets its’ dependencies when it’s instantiated and can immediately use them. These dependencies are also automatically singletons.

Also note that if you want to use a transient object you would still create an instance of it the way you always have.

I also mentioned above that CoolBeans can be used to create create and populate anonymous objects. For example:

"dbConfig": {
    "properties": {
        "host": "server.hostname.com",
        "port": 3306,
        "user": "mysqlUser",
        "password": "password123",
        "database": "foobar"
    }
}

This is a somewhat long-winded way of saying

dbConfig = {
    "host": "server.hostname.com",
    "port": 3306,
    "user": "mysqlUser",
    "password": "password123",
    "database": "foobar"
};

However, once this object is configured in CoolBeans you can easily pass it into other objects when they are created.

You can also specify properties for not-anonymous objects. You can also mix and match constructorArgs and properties.

For example:

"creditCardDao": {
    "module": "./db/creditCardDao",
    "constructorArgs": [
        {"bean": "dbConfig"},
        {"bean": "authorize"},
        {"bean": "mysql"},
        {"bean": "CreditCard"}
    ],
    "properties": {
         "service": {"bean": "service"}
    }
}

When CoolBeans creates the creditCardDao it will first load all the beans specified in the constructorArgs. It will then create the creditCardDao and pass in the four already-created beans to the constructor. Once the object is constructed it will set the service property on the object to the specified service bean. Note, CoolBeans will look for a setter and use that if it can find it. For example, in the service property above, ColdBooks will first look for a function named setservice (note that this is case sensitive). If it can find it, it will pass in the service bean to that function. If not, it will simply set a public property on the object.

There are a few other interesting capabilities of CoolBeans:

Beans don’t have to be lazily loaded. You can set a bean to load when the container loads. For example:

"dateFormat": {
    "module": "./util/dateFormat",
    "lazy": false
}

Also, if you have a factory that is used to construct other objects, you can specify this using the factoryBean and factoryMethod properties. For example:

"knox": {"module": "knox"},
 
"s3client": {
    "factoryBean": "knox",
    "factoryMethod": "createClient",
    "constructorArgs": [
        {"value":
            {
                "key": "myKey",
                "secret": "mySecret",
                "bucket": "myBucket"
            }
        }
    ]
}

The above s3client bean is configured so CoolBeans uses Knox to create it. The constructor args are passed into the factoryMethod as if it were a constructor. The above essentially boils down to:

s3client = knox.createClient({
    "key": "myKey",
    "secret": "mySecret",
    "bucket": "myBucket"
});

The really nice thing about CoolBeans is that it lets the objects in your system stay focused on what they do best. It shouldn’t be your object’s responsibility to know what they need to work. They should simply get what they need to work when they’re created. CoolBeans also helps avoid situations in complex apps where you have dozens of lines of code just getting dependencies created just to create one object that otherwise happens to have a lot of dependencies. Lastly, CoolBeans allows you to easily change how your application is configured in different environments.

If you’re a Node.js developer I’d love to hear your thoughts on CoolBeans! Heck, I’d love to hear your thoughts even if you’re not.

A few weeks ago I posted a contest where entrants would make a word search generator in an unfamiliar language.  And, well, honestly, that went over like a lead balloon.  I had precisely zero entrants.  Maybe I made it a bit too complex?

I’d like to turn this into a game or a contest or something of the sort and have a little fun with it!  Furthermore, a little promotional activity can’t hurt since it looks like Alagad will be winding up their current contract in April.  (It’s never too early to be looking for the next gig.)  If possible, it’d be really nice to be able to help people learn something new or, perhaps, help out those who are less fortunate, especially durring this time of year.  Winners of these contests would get an Alagad backpack.

So, this time I’m having a contest to come up with ideas for contests, games, or whatever.  If you have an idea on what I should do to give away these backpacks post it in the comments below.  I’ll pick one or more of the ideas and run with them.  If your idea is picked, you’ll get a very nice backpack for your troubles!

So, how should I give away these backpacks?

So, finally I became frustrated enough to take this into my own hands.  I plan make my own ideal digital picture frame.  I’m currently working on an Air application that will run in full screen and provide access to a range of picture frame components.  Obviously, a part of this will display pictures.  Other components will display weather information, stats on Alagad, and pretty much anything else I want to wire into my picture frame.  Eventually, I’ll buy a nice, thin, touch screen tablet PC, configure it to run my air app on load, get it professionally framed and hang it on the wall.

Now, one of the components I want this picture frame to show is a video stream from my daughters baby monitor camera.  Actually, it’s not really a baby monitor camera it’s a more-or-less generic wireless surveillance camera.  I don’t have the model information any more and it’s not branded at all.  But, from research I’ve done there are a lot of these cameras which run the same software.

The camera runs a basic web server so I can pull up the camera and see either a still photo or a video stream in a Java Applet or ActiveX Control.  I did a little playing around with the camera and discovered that the still photo is returned from a file called “image.jpg”.  Any time you request this file you get the latest image from the camera.  So, my first attempt a hooking into the video camera was simply to request this photo over and over again and use that as the source for an Image object.  This worked to an extent, but the Image object wouldn’t refresh quickly enough and would as a result flicker.  Beyond that, I had to make a complete HTTP request for each frame of the video and it had a very slow refresh rate.  I was able to solve the flickering problem by having two images on my canvas and alternate setting the source of each image and hiding the other image.

I was happy to have accomplished that, but it just wasn’t very nice.  So I decided to do a little more research.  The Java Applet on the camera was called xplug.class.  Googling that revealed a few people who had decompiled the class and used that to discover that the camera actually streams video from a file named mjpeg.cgi.  If you access this file directly you’ll simply get a long stream of binary data which makes up the video feed from the camera.  Obviously the Java Applet and Active X Control could read this stream and use it to display the video feed.

A little more research revealed that, sadly, mjpeg is not a standard but more of a technique.   Mjpeg really is just a concatenated stream of jpeg images, one after another.  I’m familiar with the JPEG format (at least to some degree) from my work on the Image Component. At least, I knew enough to know the first few bytes that mark a JPEG image (FF D8).  So, I figured I’d look at the data in the video stream to see if I could figure it out.  I captured a few seconds of the video to disk using Curl and opened it up in a hex editor.  The first thing I noticed was that each frame of the video was denoted by an ascii string “–video boundary–”.  Looking a bit further into the file I discovered that I could find the markers that start an image.  I tested cutting the bytes from the beginning of where I thought the JPEG would start to the last byte before the video boundary into a new file and saved it as a jpeg, which I was subsequently able to read!

I knew that if I could read the feed by simply starting at the top of the feed, find the start of an image and the end, cutting out that image, displaying it and repeating the process forever.

Simeon Bateman filled in the last little piece of data I needed to know to make this work.  Namely, that you can simply provide binary data to the source property of an Image object and Flex will display the image.

So, after figuring out how to make a socket connection from Flex I was able to parse the video feed and display the video feed!  I did still have the flickering problem but I solved it in a similar manner.

Attached to this blog entry is a final Flex Component which connects to the camera by URL and streams the feed.  Anyone who has a use or it may use it, assuming your video feed is the same format as mine.  This is my first real bit of AS3/Flex development though so don’t be offended if I’m not doing things in the best way possible.

Here’s an example usage of the component:

You can also supply username and password properties to access password protected cameras.