nodejs – put things down

Node.js: Break on Uncaught Exceptions

In the event the implemented error handling isn’t what it’s all cracked up to be, having the Node.js debugger break on uncaught exceptions is quite simple:

if ( global.v8debug ) {

global.v8debug.Debug.setBreakOnException(); // speaks for itself

}

Assume the following code, where bogus is undefined:

setTimeout(function() {

bogus(); // "`bogus` is not defined"

},2000);

Line 3 will terminate the application (normally), and log an exception in stdout (or the console, a log, etc.) — even when Node.js is in debug mode.

To debug this uncaught exception JIT, the implementation may be as follows:

if ( global.v8debug) {

global.v8debug.Debug.setBreakOnException(); // enable it, global.v8debug is only defined when the --debug or --debug-brk flag is set

}

setTimeout(function() {

bogus(); // should break here, "`bogus` is not defined"

},2000);

Run the above application (whose filename is “index.js”) as node --debug index.js and after 2 seconds (notice the timeout) the exception will be uncaught, but the process will break on line 5 for debugging.

See this gist for an auxiliary and shortened reference.

Node.js: Dynamic Event Listener Binding and Removal

Read this SO question first: Removing event listener which was added with bind

Now that we’re on the same page. I’m going to make this short’n’sweet by providing a premise and letting the code do the talking: The example provided in the SO post was all fine and dandy, but was for the case of single-use. I needed a way to clean up event listeners on a Node.js net.Server and associated socket connections.

/*
 * First, the setup:
 * 1. bring in deps
 * 2. create an object that will be an emitter
 * 3. inherit the core events emitter functionality
 * 4. register a method that will eventually emit an event
 * 5. staticDefinition is just some plain-old function we might use
 * 6. instantiate our custom event emitter class
 * The actual "ah-ha!" is after the setup.
 */
var events = require('events');
var util = require('util');

var EventClass = function() {};

util.inherits(EventClass,events.EventEmitter);

EventClass.prototype.emitSomething = function(name) {
	var t = process.hrtime();
	this.emit.apply(this,[name,t[0]*1e9+t[1],name].concat(Array.prototype.slice.call(arguments,1)));
};

function staticDefinition() {
	console.log.apply(console,['staticDefinition'].concat(Array.prototype.slice.call(arguments,0)));
}

var inst = new EventClass();

/* eventsTable is used to keep track of bound events within a specific scope/ns
 * notice this is a kvp table, i.e. { 'eventName': function eventHandler(){} }
 * so multiple listeners on a single event won't work
 * but this shows how something like this be implemented
 */
var eventsTable = {};

// first, let's show the typical way of doing things
inst.on('simple',staticDefinition); // register event listener
inst.emitSomething('simple',1,2); // do something to trigger the underlying emitter
console.log(inst.listeners('simple').length); // 1, we see that it has an emitter for our event
inst.removeListener('simple',staticDefinition); // usual way of removing it
console.log(inst.listeners('simple').length); // 0, works, the listener was removed

// this will dynamically attach a bunch of events with diff parameters that have been manipulated with bind
['one','two','three'].forEach(function(eventName,key) {
	var specificDefinition = staticDefinition.bind(inst,'custom'+key); // each definition is unique
	eventsTable[eventName] = specificDefinition; // register the event in the table
	inst.on(eventName,specificDefinition); // bind it
});

// try to remove the listener with the basic function definition
inst.emitSomething('one',3,4);
console.log(inst.listeners('one').length); // 1
inst.removeListener('one',staticDefinition); // doesn't work
console.log(inst.listeners('one').length); // 1

// try to remove the listener with the exact bind spec (new function definition)
inst.emitSomething('two',5,6);
console.log(inst.listeners('two').length); // 1
inst.removeListener('two',staticDefinition.bind(inst,'two')); // doesn't work
console.log(inst.listeners('two').length); // 1

inst.emitSomething('three',7,8);
console.log(inst.listeners('three').length); // 1
inst.removeListener('three',eventsTable['three']); // works
console.log(inst.listeners('three').length); // 0

* First, the setup:

* 1. bring in deps

* 2. create an object that will be an emitter

* 3. inherit the core events emitter functionality

* 4. register a method that will eventually emit an event

* 5. staticDefinition is just some plain-old function we might use

* 6. instantiate our custom event emitter class

* The actual "ah-ha!" is after the setup.

var events = require('events');

var util = require('util');

var EventClass = function() {};

util.inherits(EventClass,events.EventEmitter);

EventClass.prototype.emitSomething = function(name) {

var t = process.hrtime();

this.emit.apply(this,[name,t[0]*1e9+t[1],name].concat(Array.prototype.slice.call(arguments,1)));

};

function staticDefinition() {

console.log.apply(console,['staticDefinition'].concat(Array.prototype.slice.call(arguments,0)));

}

var inst = new EventClass();

/* eventsTable is used to keep track of bound events within a specific scope/ns

* notice this is a kvp table, i.e. { 'eventName': function eventHandler(){} }

* so multiple listeners on a single event won't work

* but this shows how something like this be implemented

var eventsTable = {};

// first, let's show the typical way of doing things

inst.on('simple',staticDefinition); // register event listener

inst.emitSomething('simple',1,2); // do something to trigger the underlying emitter

console.log(inst.listeners('simple').length); // 1, we see that it has an emitter for our event

inst.removeListener('simple',staticDefinition); // usual way of removing it

console.log(inst.listeners('simple').length); // 0, works, the listener was removed

// this will dynamically attach a bunch of events with diff parameters that have been manipulated with bind

['one','two','three'].forEach(function(eventName,key) {

var specificDefinition = staticDefinition.bind(inst,'custom'+key); // each definition is unique

eventsTable[eventName] = specificDefinition; // register the event in the table

inst.on(eventName,specificDefinition); // bind it

});

// try to remove the listener with the basic function definition

inst.emitSomething('one',3,4);

console.log(inst.listeners('one').length); // 1

inst.removeListener('one',staticDefinition); // doesn't work

console.log(inst.listeners('one').length); // 1

// try to remove the listener with the exact bind spec (new function definition)

inst.emitSomething('two',5,6);

console.log(inst.listeners('two').length); // 1

inst.removeListener('two',staticDefinition.bind(inst,'two')); // doesn't work

console.log(inst.listeners('two').length); // 1

inst.emitSomething('three',7,8);

console.log(inst.listeners('three').length); // 1

inst.removeListener('three',eventsTable['three']); // works

console.log(inst.listeners('three').length); // 0

JavaScript Inheritance and Method Overriding

I’m always finding myself wanting to use JavaScript like a classical OOP language with class-based inheritance, even though I know it is prototypical. Anyways, I’m jotting down how to do this and also allow for overriding (not overloading) methods. Note, that if you’re using Node.js, then you don’t need to define the inherits function, it is already available in require('util').inherits.

var A = function() {
    this.x = 10;
    this.name = 'alpha';
    console.log('A.constructor');
};

A.prototype.method = function() {
    console.log('A.method',this.x);
};

A.prototype.uniqueA = function() {
    console.log('A.uniqueA',this.name);
};

var B = function() {
    B.super_.call(this); // call A's constructor
    this.x = 20;
    this.name = 'bravo';
    console.log('B.constructor');
};

inherits(B,A); // B now inherits/extends A

B.prototype.method = function() { // override A's method
    B.super_.prototype.method.call(this); // call A's `method` using B as the scope
    console.log('B.method',this.x);
};

B.prototype.uniqueB = function() {
    console.log('B.uniqueB',this.name);
};

var C = function() {
    C.super_.call(this); // call B's constructor
    this.x = 30;
    this.name = 'charlie';
    console.log('C.constructor');
};

inherits(C,B); // C now inherits/extends B (and thus A)

C.prototype.method = function() { // override B's method
    C.super_.prototype.method.call(this); // call B's `method` using C as the scope
    console.log('C.method',this.x);
}

C.prototype.uniqueC = function() {
    console.log('C.uniqueC',this.name);
};

console.log('start...');
var a = new A();
var b = new B();
var c = new C();
a.method();
a.uniqueA();
b.method();
b.uniqueB();
b.uniqueA();
c.method();
c.uniqueC();
c.uniqueB();
c.uniqueA();

var inherits = function(ctor, superCtor) { // took this right from requrie('util').inherits

ctor.super_ = superCtor;

ctor.prototype = Object.create(superCtor.prototype, {

constructor: {

value: ctor,

enumerable: false,

writable: true,

configurable: true

}

});

};

var A = function() {

this.x = 10;

this.name = 'alpha';

console.log('A.constructor');

};

A.prototype.method = function() {

console.log('A.method',this.x);

};

A.prototype.uniqueA = function() {

console.log('A.uniqueA',this.name);

};

var B = function() {

B.super_.call(this); // call A's constructor

this.x = 20;

this.name = 'bravo';

console.log('B.constructor');

};

inherits(B,A); // B now inherits/extends A

B.prototype.method = function() { // override A's method

B.super_.prototype.method.call(this); // call A's `method` using B as the scope

console.log('B.method',this.x);

};

B.prototype.uniqueB = function() {

console.log('B.uniqueB',this.name);

};

var C = function() {

C.super_.call(this); // call B's constructor

this.x = 30;

this.name = 'charlie';

console.log('C.constructor');

};

inherits(C,B); // C now inherits/extends B (and thus A)

C.prototype.method = function() { // override B's method

C.super_.prototype.method.call(this); // call B's `method` using C as the scope

console.log('C.method',this.x);

}

C.prototype.uniqueC = function() {

console.log('C.uniqueC',this.name);

};

console.log('start...');

var a = new A();

var b = new B();

var c = new C();

a.method();

a.uniqueA();

b.method();

b.uniqueB();

b.uniqueA();

c.method();

c.uniqueC();

c.uniqueB();

c.uniqueA();

Check the console:

start...

A.constructor

B.constructor

A.constructor

B.constructor

C.constructor

A.method 10

A.uniqueA alpha

A.method 20

B.method 20

B.uniqueB bravo

A.uniqueA bravo

A.method 30

B.method 30

C.method 30

C.uniqueC charlie

B.uniqueB charlie

A.uniqueA charlie

Node.js: Split/Count Number of Lines (Unicode Compatible)

The task was to read n number of a lines from a file in Node.js. The assumption is that the read buffer is UTF-8. The caveat is that there is more to just new lines in Unicode than “New Line (ASCII 10 or \n)” and “Carriage Return (ASCII 13 or \r)”. This SO comment put me in the right direction.

Unicode Technical Standard #18 § 1.6 describes the following rule regarding line boundaries, (PS and LS are defined in Unicode 6.1 § 16.2 Layout Controls):

RL1.6 Line Boundaries
To meet this requirement, if an implementation provides for line-boundary testing, it shall recognize not only CRLF, LF, CR, but also NEL (U+0085), PS (U+2029) and LS (U+2028).

To put it into practice, the number of lines can be tallied while the ReadStream has incoming data:

var numLines = 0;

fs.createReadStream(filePath).on('data', function readStreamOnData(chunk) {

numLines += chunk

.toString('utf8')

.split(/\r\n|[\n\r\u0085\u2028\u2029]/g)

.length-1;

});

The key is the regular expression, derived straight from RL1.6, /\r\n|[\n\r\u0085\u2028\u2029]/ , which looks for any of the possible new line characters with precedence to CRLF (greedy). Don’t forget to listen for the “end” event and also remove the “data” listener on “end” or “error!”

In the context of splitting incoming data by line, simply calling chunk.toString('utf8').split(/\r\n|[\n\r\u0085\u2028\u2029]/g) will do the trick. Note that if working with CSV files, parsing will require a bit more effort if escaped new-lines will need to be taken into consideration, and PS, LS and NEL are probably not characters that should act as line delimiters in that context anyway.

Node.js: Handling File Uploads without Express

I was working on a little project which does not utilize express. Part of the program needed to handle file uploads. In PHP this is easy with the $_FILES superglobal, and with express this is also just as easy with req.files. In pure node.js the developer doesn’t have this luxury because they’re just dealing with raw http requests and responses (I’m surprised node.js even parses the headers, it is a miracle!). Before I begin, this whole process should be optimally streamed to a file so large file uploads do not consume more RAM than their response chunk size, but I didn’t do this, shame on me.

First, capture the response body. Here I am assuming you have a HTTP server that is listening and responding to requests:

function requestHandler(req,res) {

var body,

dataHandler = function(chunk) {

body += chunk;

};

req.on('data',dataHandler);

req.once('end',function(){

req.removeListener('data',dataHandler);

// now you have the entire request body in var body :)

console.log(body);

});

}

Here, I’ll give you the entire source to my MultipartParser Node.js module. It requires nodeproxy.

var MultipartParser
	,proxy = require('nodeproxy')
	,NL = '\r\n' // RFC2046 S4.1.1
	,BOUNDARY_PREFIX = NL+'--' // RFC2046 S5.1.1
	,HEADER_PAIR_DELIM = ':'
	,HEADER_SUB_DELIM = '='
	;

module.exports = MultipartParser = function(contentType,data) {
	this.parts = {};
	this.fields = [];
	this.isMultipart = false;

if ( typeof contentType == 'string' ) {
		contentType = contentType.trim();
		this.isMultipart = contentType.indexOf('multipart/form-data') === 0;
		parse.call(this,contentType,data);
	}
};

function splitHeaderBody(data) {
	var sections = data.split(NL+NL,2);
	return {
		header: sections[0]||'',
		body: sections[1]||''
	};
}

var MultipartParser

,proxy = require('nodeproxy')

,NL = '\r\n' // RFC2046 S4.1.1

,BOUNDARY_PREFIX = NL+'--' // RFC2046 S5.1.1

,HEADER_PAIR_DELIM = ':'

,HEADER_SUB_DELIM = '='

;

module.exports = MultipartParser = function(contentType,data) {

this.parts = {};

this.fields = [];

this.isMultipart = false;

if ( typeof contentType == 'string' ) {

contentType = contentType.trim();

this.isMultipart = contentType.indexOf('multipart/form-data') === 0;

parse.call(this,contentType,data);

}

};

function parse(contentType,data) {

if ( !this.isMultipart ) {

return;

}

if ( data.substr(0,NL.length) != NL ) {

data = NL+data;

}

var params = parseHeaderValue(contentType);

if ( params.hasOwnProperty('boundary') ) {

var parts = data.split(BOUNDARY_PREFIX+params.boundary);

parts.forEach(proxy(function(chunk,i,arr) {

// split the headers and body for this chunk

var pieces = splitHeaderBody(chunk);

if ( pieces.header && pieces.body ) {

// build headers object

var headers = parseHeader(pieces.header);

// if nested multipart form-data, recurse

if ( headers.hasOwnProperty('content-type') && headers['content-type'].indexOf('multipart/form-data') === 0 ) {

parse.call(this,headers['content-type'],pieces.body);

} else if ( headers.hasOwnProperty('content-disposition') ) {

var disposition = parseHeaderValue(headers['content-disposition']);

if ( disposition.hasOwnProperty('name') ) {

this.fields.push(disposition.name);

this.parts[disposition.name] = {

headers: headers,

disposition: disposition,

mime: headers['content-type']||'',

body: pieces.body

};

}

},this));

}

function splitHeaderBody(data) {

var sections = data.split(NL+NL,2);

return {

header: sections[0]||'',

body: sections[1]||''

};

}

function parseHeader(header) {

var headers = {},

headersArr = header.split(NL)

.map(function(v){return v.trim();})

.filter(function(v){return !!v;})

headersArr.forEach(function(v){

var o = {},

t = v.split(HEADER_PAIR_DELIM,2);

if ( typeof t[1] == 'string' ) {

t[1] = t[1].trim();

}

headers[t[0].toLowerCase().trim()] = t[1];

});

return headers;

}

function parseHeaderValue(value) {

var params = {},

paramsArr = value.split(';')

.map(function(v){return v.trim();})

.filter(function(v){return !!(v||v.indexOf('='));});

paramsArr.forEach(function(v){

var o = {},

t = v.split(HEADER_SUB_DELIM,2);

if ( typeof t[1] == 'string' ) {

t[1] = t[1].replace(/^[\s'"]+|[\s'"]+$/g,'');

}

params[t[0].toLowerCase().trim()] = t[1];

});

return params;

}

And the implementation is as follows:

var LittleDiddy

,http = require('http')

,MultipartParser = require('./MultipartParser.js');

LittleDiddy = function(){

this.server = http.createServer(requestHandler);

this.server.listen(1337,'127.0.0.1');

};

function requestHandler(req,res) {

var body,

dataHandler = function(chunk) {

body += chunk;

};

req.on('data',dataHandler);

req.once('end',function(){

req.removeListener('data',dataHandler);

if ( req.headers.hasOwnProperty('content-type') ) {

var multipartData = new MultipartParser(req.headers['content-type'],body);

console.log(multipartData);

}

});

}

new LittleDiddy();

LittleDiddy does not have any path routing (e.g. it won’t actually show a form that uses enctype="multipart/form-data"), it simply accepts and parses a POST with “file” inputs. This “little diddy” (implementation example) is untested by the way, so good luck.

This article’s source is released under the MIT license; I don’t care what you do with it.