@creative-realities/cutie 3.1.1

package/README.md

@@ -0,0 +1,101 @@
+# An AWS SQS package
+## Setting Up SQS
+First configure your SQS queue on AWs. Cutie is a minimalist package, so configure your queue's default values to what you want in the AWS interface (cutie does not provide an interface for this).
+#### Please note:
+- Cutie only processes one message at a time, so your queue should be set up for one message at a time.
+- Cutie does not have an interface for configuring credentials. You must set this up through AWS roles.
+- Cutie expects your queue to be configured with a Default Visibility Timeout of 2 minutes.
+
+## Setting up cutie
+```
+var Cutie = require("cutie");
+var options = {
+	verbose: true, // defaults to false
+};
+var cutie = new Cutie("http://queue.url.whatever"); // URL from AWS
+```
+## Adding tasks
+Messages sent to cutie require a task property. This tells cutie which previously added task to perform. The task callback receives the message object and a done callback.
+Task callbacks must always call the done method within 2 minutes, which it expects to be the Default Visibility Timeout of your queue. See the Changing the Timeout section if you need to extend the timeout.
+It is very important that every code path in your task always completes by calling the done callback. The done callback takes an error parameter. If you pass an error parameter to the done callback, 
+cutie will not remove the message from the SQS queue; it will remain in the queue to be reprocessed. 
+```
+cutie.addTask("userRegistrationNotification", function(message, done) {
+	// message is the object passed to send.
+	var user = message.user;
+	
+	// Do stuff in some async method...
+	asyncMethod(user, function(err) {
+    	if (err)
+        	return done(err); // message will NOT be removed from queue
+        
+        done(); // message will be removed from queue
+	});
+});
+```
+## Start polling
+```
+cutie.start();
+```
+## Sending messages to queue
+```
+// The send method will continue to retry up to 100 times if send fails when no callback is provided.
+cutie.send({
+	task: "userRegistrationNotification",
+	user: user
+});
+
+// If you provide a callback and optional context, cutie will not retry to send.
+cutie.send(message, function(error, data) { /* Do stuff */ }, this);
+```
+## Sending message batch to queue
+```
+cutie.send([
+	{
+		task: "userRegistrationNotification",
+		user: user1,
+	},
+	{
+		task: "userRegistrationNotification",
+		user: user2,
+	}
+	// ... etc.
+]);
+
+// When an array parameter is passed in, cutie acutally calls sendBatch(batch [, callback, context])
+```
+## Changing the Timeout
+Task callbacks will recieve a third object parameter that includes the changeTimeout method. Calling changeTimeout will extend the time that cuite and SQS allow for the task to complete.
+SQS will not make the message available again, until the new timeout interval has elapsed. This should be done at the very beginning of your callback.
+In the example, we'll give the task 10 minutes to complete which we pass in as seconds.
+```
+cutie.addTask("userRegistrationNotification", function(message, done, options) {
+	var taskTimeoutSeconds = 10 * 60;
+	options.changeTimeout(taskTimeoutSeconds);
+	// Do other stuff...
+});
+```
+## Multiple queues
+As of 3.0 cutie can be configured with multiple queues in order of priority. When ready to process a new message, cutie checks the queues in order of priority.
+### Configuring
+To configure cutie to check multiple queues in order of priority, pass an array of queue URLs sorted by priority where the highest priority is at index zero.
+```
+var cutie = new Cutie(["http://queue.url.priority", "http://queue.url.normal"]); // URL from AWS
+```
+### Sending
+The send method takes an optional priority parameter, which should match the index into the array of priority sorted queues.  Cutie will limit the range of the priority argument to valid array indices instead of giving an error, so if you pass in a priority `2` and the array only has one queue at index `0`, it will use index `0`.  If you omit the priority argument index `0` will always be used.
+```
+var priorityQueueIndex = 0;
+var normalQueueIndex = 1;
+
+cutie.send(normalQueueIndex, message);
+```
+## Task locking
+```
+// Assuming your callback parameter is named done, you may indicate that a task cannot be completed,
+// but needs to be tried later and is not a real error to be logged like this:
+
+if (taskIsLocked)
+	return done({cutieMessage: "Task Locked"});
+
+```

package/index.js

@@ -0,0 +1,591 @@
+"use strict";
+
+var aws = require("aws-sdk");
+var log = require("logger");
+var fs = require("fs");
+var path = require("path");
+var util = require("util");
+
+var initializing = true;
+
+class Cutie {
+	constructor(url, options) {
+		this.tasks = {};
+		this.verbose = !!(options || (options = {})).verbose; // @doc
+		this.logTasks = !!options.logTasks; // @doc
+		this.excludeLogTasks = options.excludeLogTasks || []; // @doc
+		
+		if (options.serverId) {
+			this._serverId = options.serverId;
+		}
+		else if (!initializing && process.env.NODE_APP_INSTANCE === "0") {
+			// The first instance in a pm2 cluster is responsible for writing the serverId.
+			var serverId = this.getServerId();
+			if (!serverId) {
+				// Create serverId file
+				try {
+					var uuid = require(path.resolve(__dirname, "uuid")).generate();
+					fs.writeFileSync(path.resolve(__dirname, "server-id.txt"), uuid, {encoding: "utf8"});
+				}
+				catch(error) {
+					log.e("Cutie error writing serverId file!!!", error);
+				}
+			}
+		}
+		
+		if (!url) {
+			if (!initializing)
+				log.w("Warning: Cutie url not configured: " + url);
+			
+			return;
+		}
+		
+		
+		var firstUrl;
+		var urlArray;
+		if (Object.prototype.toString.call(url) === "[object String]") {
+			urlArray = [url];
+		}
+		else if (Array.isArray(url)) {
+			urlArray = url;
+			
+			for (let urlString of urlArray) {
+				if (Object.prototype.toString.call(urlString) !== "[object String]") {
+					return log.e("Cutie error url array must only contain String. Received:", urlString);
+				}
+			}
+		}
+		else {
+			return log.e("Cutie error url parameter must be a String or an Array of String.  Received:", url);
+		}
+		this._queueCount = urlArray.length;
+		
+		var regex = /sqs\.([^.]+)\.amazonaws/;
+		var testUrl = urlArray[0];
+		var matches = testUrl.match(regex);
+		if (!matches || matches.length < 2) {
+			log.w("Warning: Cutie could not parse region from url: ", testUrl, url);
+			return;
+		}
+		var region = matches[1];
+		this.sqs = new aws.SQS({region: region});
+		this.queueUrls = urlArray;
+	}
+	
+	getServerId() {
+		if (!this._serverId) {
+			try {
+				this._serverId = fs.readFileSync(path.resolve(__dirname, "server-id.txt"), {encoding: "utf8"});
+			}
+			catch(error) {
+				// Do nothing
+			}
+		}
+		return this._serverId;
+	}
+	
+	send(/* [ priority, ] message, callback, context */) {
+		var priority;
+		var message;
+		var callback;
+		var context;
+		var sendUrl;
+		
+		[priority, message, callback, context] = _parseSendParameters.call(this, arguments);
+		
+		if (Object.prototype.toString.call(message) === "[object Array]")
+			return this.sendBatch.apply(this, arguments);
+		
+		sendUrl = this.queueUrls[priority || 0];
+		
+		if (!this.sqs) {
+			if (this.tasks[message.task]) {
+				var options = {changeTimeout: function() {}};
+				try {
+					message = JSON.parse(JSON.stringify(message));
+				}
+				catch(error) {
+					return callback(error);
+				}
+				if (this.logTasks && this.excludeLogTasks.indexOf(message.task) === -1)
+					log.i(message.task);
+				
+				this.tasks[message.task](message, (function(err, data) {
+					if (err)
+						log.e(err);
+					
+					if (this.verbose)
+						log.v(data);
+					
+					if (typeof callback === "function")
+						callback.apply(context || this, arguments); // no arrow function so we can have arguments here.
+					
+				}).bind(this), options);
+			}
+			else
+				log.d("Warning: SQS was not set up and task", message.task, "was not registered as a callback! Doing nothing.");
+			
+			return;
+		}
+		
+		if (typeof callback !== "function")
+			return _sendOrRetry.call(this, sendUrl, message);
+		
+		var sqsParameters = {
+			MessageBody: JSON.stringify(message),
+			QueueUrl: sendUrl
+		};
+		this.sqs.sendMessage(sqsParameters, function(err, data) {
+			if (err) {
+				err.sqsParameters = JSON.stringify(sqsParameters);
+				log.e("Cutie send message error.", err);
+			}
+			else if (this.verbose)
+				log.v("Cutie data:", data); // @todo: probably remove.
+			
+			callback(err, data);
+		});
+	}
+	
+	sendServer(/* [ priority, ] message, callback, context */) {
+		var priority;
+		var message;
+		var callback;
+		var context;
+		
+		[priority, message, callback, context] = _parseSendParameters.call(this, arguments);
+		
+		if (Object.prototype.toString.call(message) === "[object Array]")
+			return this.sendServerBatch.apply(this, arguments);
+			
+		message.__serverId = this.getServerId();
+		this.send.apply(this, arguments);
+	}
+	
+	sendBatch(/* [ priority, ] batch, callback, context */) {
+		var priority;
+		var batch;
+		var callback;
+		var context;
+		var sendUrl;
+		
+		[priority, batch, callback, context] = _parseSendParameters.call(this, arguments);
+		
+		if (Object.prototype.toString.call(batch) !== "[object Array]") {
+			return log.w("Warning: Cutie batch did not receive an array. Doing nothing.");
+		}
+		if (batch.length === 0) {
+			return log.w("Warning: Cutie batch was emtpy. Doing nothing.");
+		}
+		
+		sendUrl = this.queueUrls[priority || 0];
+		
+		if (!this.sqs) {
+			var length = batch.length;
+			var didError = false;
+			var dataArray = new Array(length);
+			var numberOfCallbacks = 0;
+			var callOnce = typeof callback !== "function" ? null : function(err, data, index) {
+				if (didError)
+					return;
+				
+				dataArray[index] = data;
+				if (err) {
+					didError = true;
+					return callback({index: index, error: err}, data);
+				}
+				
+				if (++numberOfCallbacks === length) {
+					callback(null, dataArray);
+				}
+			};
+			for (let i = 0; i < batch.length; i++) {
+				this.send(batch[i], callOnce, i);
+			}
+			return;
+		}
+		
+		// sendBatch is limited to 10, so split them up into chunks of 10.
+		var allEntries = [[]];
+		var message;
+		var btyeSum = 0;
+		var textEncoder = new util.TextEncoder();
+		for (var i = 0, j = 0, k = 0; i < batch.length; i++) {
+			message = batch[i];
+			let messageEntry = {
+				Id: message.task + "-" + i,
+				MessageBody: JSON.stringify(message)
+			};
+			
+			btyeSum += (textEncoder.encode(JSON.stringify(messageEntry))).length;
+			
+			if (k === 9 || (btyeSum > 260000 && k > 0) ) {
+				// we can only send 10 and max message size is 262144
+				k = 0;
+				btyeSum = 0;
+				allEntries[++j] = [];
+			}
+			
+			allEntries[j][k++] = messageEntry;
+			
+		}
+		
+		if (typeof callback !== "function")
+			return allEntries.forEach((entries) => { _sendBatchOrRetry.call(this, sendUrl, entries) });
+		
+		var errors = [];
+		var requests = 0;
+		allEntries.forEach((entries) => {
+			requests++;
+			var sqsParameters = {
+				Entries: entries,
+				QueueUrl: sendUrl
+			};
+			this.sqs.sendMessageBatch(sqsParameters, (err, data) => {
+				if (err) {
+					err.sqsParameters = JSON.stringify(sqsParameters);
+					errors.push(err);
+					log.e("Cutie send message error.", err);
+				}
+				else if (this.verbose)
+					log.v("Cutie data:", data); // @todo: probably remove.
+				
+				if (--requests === 0)
+					callback.call(context || this, errors.length ? (errors.length > 1 ? errors : errors[0]) : null);
+			});
+		});
+	}
+	
+	sendServerBatch(/* [ priority, ] batch, callback, context */) {
+		var priority;
+		var batch;
+		var callback;
+		var context;
+		var sendUrl;
+		
+		[priority, batch, callback, context] = _parseSendParameters.call(this, arguments);
+		
+		if (Object.prototype.toString.call(batch) !== "[object Array]") {
+			return log.w("Warning: Cutie server batch did not receive an array. Doing nothing.");
+		}
+		if (batch.length === 0) {
+			return log.w("Warning: Cutie server batch was emtpy. Doing nothing.");
+		}
+		
+		var serverId = this.getServerId();
+		batch.forEach(function(message) {
+			message.__serverId = serverId;
+		});
+		this.sendBatch.apply(this, arguments);
+	}
+	
+	addTask(name, callback) {
+		this.tasks[name] = callback;
+	}
+	
+	start() {
+		if (this._started)
+			return;
+		
+		_receiveMessage.call(this, true);
+		this._started = true;
+	}
+}
+
+//! Private instance methods
+function _receiveMessage(emptyReceive) {
+	if (!this.sqs) {
+		return log.d("Warning: SQS was not set up. Tasks will execute immediately and not be queued.");
+	}
+	
+	if (!emptyReceive) {
+		// we received a message so start from highest priority queue again
+		this._receiveQueueIndex = 0;
+	}
+	else if (this._receiveQueueIndex === undefined) {
+		// receiveing for the first time
+		this._receiveQueueIndex = 0;
+	}
+	else {
+		// we did not receive a message, so try the next priority level queue
+		this._receiveQueueIndex++;
+		
+		if (this._receiveQueueIndex > this.queueUrls.length - 1)
+			this._receiveQueueIndex = 0;
+	}
+	
+	this.currentQueueUrl = this.queueUrls[this._receiveQueueIndex];
+	
+	if (this.verbose)
+		log.v("Trying queue", this._receiveQueueIndex, this.currentQueueUrl);
+	
+	this.sqs.receiveMessage({QueueUrl: this.currentQueueUrl}, (err, data) => {
+		if (err) {
+			log.e("Cutie receiveMessage error. Will retry.", err);
+			_receiveMessage.call(this);
+		}
+		else if (data && data.Messages) {
+			var message = data.Messages[0];
+			try {
+				var body = JSON.parse(message.Body);
+				
+				// If this message came from SNS the message body will be wrapped in another message.
+				if (!body.task && body.MessageId && body.Message) {
+					body = JSON.parse(body.Message);
+				}
+			} catch(ex) {
+				log.e("Cutie JOSN parse error", ex);
+				return _removeMessage.call(this, message);
+			}
+			var messageServerId = body.__serverId;
+			if (messageServerId && messageServerId !== this.getServerId()) {
+				// This task is not for this server.
+				this.sqs.changeMessageVisibility({QueueUrl: this.currentQueueUrl, ReceiptHandle: message.ReceiptHandle, VisibilityTimeout: 0}, (err, data) => {
+					if (err)
+						log.e("cutie changeMessageVisibility", err);
+					
+					if (this.verbose)
+						log.v(data);
+					
+					_receiveMessage.call(this);
+				});
+				return;
+			}
+			
+			var task;
+			if (body.task && (task = this.tasks[body.task])) {
+				if (this.logTasks && this.excludeLogTasks.indexOf(body.task) === -1)
+					log.i(body.task);
+				
+				var timeoutCallback = (function() {
+					log.e("Error Cutie task timed out. ", body);
+					timeout = null;
+					_receiveMessage.call(this);
+				}).bind(this);
+				
+				var startTime = Date.now();
+				var timeout = setTimeout(timeoutCallback, 120000);
+				var changedTimeoutInterval = null;
+				
+				var changeTimeout = (function(newInterval, changeCallback) {
+					if (!newInterval || isNaN(parseInt(newInterval))) {
+						log.e("cutie changeTimeout called with invalid newInterval parameter", newInterval);
+						if (typeof changeCallback === "function")
+							changeCallback();
+						
+						return;
+					}
+					newInterval = parseInt(newInterval);
+					if (newInterval > 43200) {
+						log.e("cutie changeTimeout called with newInterval parameter out of range", newInterval);
+						if (typeof changeCallback === "function")
+							changeCallback();
+						
+						return;
+					}
+					
+					clearTimeout(timeout);  // Do not set to null, done(error) can still happen before response comes back.
+					var changeMessageVisibilityParameters = {
+						QueueUrl: this.currentQueueUrl,
+						ReceiptHandle: message.ReceiptHandle,
+						VisibilityTimeout: newInterval
+					};
+					this.sqs.changeMessageVisibility(changeMessageVisibilityParameters, (err) => {
+						if (err) {
+							log.e("Failed to change visibility timeout.", this.verbose ? err : "");
+							
+							if (timeout !== null)
+								timeout = setTimeout(timeoutCallback, 120000 - (Date.now() - startTime));
+							
+							if (typeof changeCallback === "function")
+								changeCallback();
+							
+							return;
+						}
+						
+						if (timeout !== null) {
+							timeout = setTimeout(timeoutCallback, newInterval * 1000);
+							changedTimeoutInterval = newInterval;
+						}
+						
+						if (typeof changeCallback === "function")
+							changeCallback();
+					});
+				}).bind(this);
+				
+				task(body, (err) => {
+					// @doc: if err.cutieMessage is set to "Task Locked", let the task time out and SQS will naturally requeue.
+					var taskLocked = Object.prototype.toString.call(err) === "[object Object]" && err.cutieMessage === "Task Locked";
+					if (timeout !== null) {
+						clearTimeout(timeout);
+						timeout = null;
+						if (err) {
+							if (!taskLocked)
+								log.e(err);
+							
+							if (changedTimeoutInterval) {
+								var newTimeoutOnError = parseInt(((changedTimeoutInterval * 1000) - (Date.now() - startTime) + 10000) / 1000); // 10 secands from now
+								changeTimeout(newTimeoutOnError, () => {
+									_receiveMessage.call(this);
+								});
+								return;
+							}
+							else
+								return _receiveMessage.call(this);
+						}
+						_removeMessage.call(this, message);
+					}
+					else if (err) {
+						// @doc: we timed out, but if there was an error we still log it.
+						log.e(err);
+					}
+				}, {changeTimeout: changeTimeout});
+			}
+			else {
+				log.e("Cutie doesn't know what to do with message:", message);
+				_removeMessage.call(this, message);
+			}
+		}
+		else {
+			if (this.verbose)
+				log.v("empty receive for ", this._receiveQueueIndex, this.currentQueueUrl);
+			
+			_receiveMessage.call(this, true);
+		}
+	});
+}
+
+function _removeMessage(message) {
+	this.sqs.deleteMessage({QueueUrl: this.currentQueueUrl, ReceiptHandle: message.ReceiptHandle}, (err, data) => {
+		if (err)
+			log.e(err);
+		
+		if (this.verbose)
+			log.v(data);
+		
+		_receiveMessage.call(this);
+	});
+}
+
+	
+// For tasks that need to be queued and can't be allowed to fail if the send fails, retry.
+// We will do this for any send that does not have a callback.
+const sendImmediateLimit = 10;
+const sendDelayedLimit = 1000;
+const sendDelay = 5000;
+
+function _sendOrRetry(sendUrl, message, depth) {
+	var sqsParameters = {
+		MessageBody: JSON.stringify(message),
+		QueueUrl: sendUrl
+	};
+	this.sqs.sendMessage(sqsParameters, (err, data) => {
+		if (err) {
+			err.sqsParameters = JSON.stringify(sqsParameters);
+			if (err.retryable == false) {
+				return log.e("Cutie send message error, not retryable:", err);
+			}
+			log.e("Cutie send message error, but will retry:", err);
+			depth = depth || 0;
+			if (depth < sendImmediateLimit) {
+				_sendOrRetry.call(this, sendUrl, message, depth + 1);
+			}
+			else if (depth < sendDelayedLimit) {
+				setTimeout(() => { _sendOrRetry.call(this, sendUrl, message, depth + 1) }, sendDelay);
+			}
+			else {
+				var errorMessage = [
+					"Cuite failed to queue message. Retried", sendDelayedLimit, "times, taking over",
+					(sendDelay * (sendDelayedLimit - sendImmediateLimit) / 60000).toFixed(1), "minutes.",
+					"There is likely a problem with SQS.  Skipping message:",
+				].join(" ");
+				log.e(errorMessage, message);
+			}
+		}
+		else if (this.verbose)
+			log.v("Cutie data:", data); // @todo: probably remove.
+	});
+}
+
+function _sendBatchOrRetry(sendUrl, entries, depth) {
+	var sqsParameters = {
+		Entries: entries,
+		QueueUrl: sendUrl
+	};
+	this.sqs.sendMessageBatch(sqsParameters, (err, data) => {
+		if (err) {
+			err.sqsParameters = JSON.stringify(sqsParameters);
+			if (err.retryable == false) {
+				return log.e("Cutie send message batch error, not retryable:", err);
+			}
+			log.e("Cutie send message batch error, but will retry:", err);
+			depth = depth || 0;
+			if (depth < sendImmediateLimit) {
+				_sendBatchOrRetry.call(this, sendUrl, entries, depth + 1);
+			}
+			else if (depth < sendDelayedLimit) {
+				setTimeout(() => { _sendBatchOrRetry.call(this, sendUrl, entries, depth + 1) }, sendDelay);
+			}
+			else {
+				var errorMessage = [
+					"Cuite failed to queue batch of messages. Retried", sendDelayedLimit, "times, taking over",
+					(sendDelay * (sendDelayedLimit - sendImmediateLimit) / 60000).toFixed(1), "minutes.",
+					"There is likely a problem with SQS.  Skipping message batch:",
+				].join(" ");
+				log.e(errorMessage, entries);
+			}
+		}
+		else if (this.verbose)
+			log.v("Cutie data:", data); // @todo: probably remove.
+	});
+}
+
+function _parseSendParameters(parameters) {
+	var priority = null;
+	var message;
+	var callback;
+	var context;
+	var sendUrl;
+	
+	if (Object.prototype.toString.call(parameters[0]) === "[object Number]") {
+		priority = Math.min(this._queueCount - 1, Math.max(0, parameters[0]));
+		message = parameters[1];
+		callback = parameters[2];
+		context = parameters[3];
+	}
+	else {
+		message = parameters[0];
+		callback = parameters[1];
+		context = parameters[2];
+	}
+	
+	return [priority, message, callback, context];
+}
+
+// Support older global instance methods
+// Initialize without URL, in case setUrl is not called.
+var instance = new Cutie();
+
+Cutie.setUrl = function() {
+	instance.setUrl.apply(instance, arguments);
+};
+
+Cutie.send = function() {
+	instance.send.apply(instance, arguments);
+};
+
+Cutie.sendBatch = function() {
+	instance.sendBatch.apply(instance, arguments);
+};
+
+Cutie.addTask = function() {
+	instance.addTask.apply(instance, arguments);
+};
+
+Cutie.start = function() {
+	instance.start();
+};
+
+module.exports = Cutie;
+
+initializing = false;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@creative-realities/cutie",
+  "version": "3.1.1",
+  "description": "Package for AWS SQS.",
+  "main": "index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "aws-sdk": "2.2.x",
+    "logger": "0.2.x"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@gitlab.reflect.systems:Reflect/cutie.git"
+  },
+  "keywords": [
+    "AWS",
+    "SQS",
+    "cutie"
+  ],
+  "author": "Adam Lockhart <alockhart@reflectsystems.com> (http://ec2-54-145-234-173.compute-1.amazonaws.com/u/alockhart)",
+  "maintainers":[
+  	{"name":"alockhart","email":"adam.lockhart@cri.com"}
+  ],
+  "license": "MIT"
+}

package/uuid.js

@@ -0,0 +1,52 @@
+//
+// Loose interpretation of the specification DCE 1.1: Remote Procedure Call
+// described at http://www.opengroup.org/onlinepubs/009629399/apdxa.htm#tagtcjh_37
+// since JavaScript doesn't allow access to internal systems, the last 48 bits
+// of the node section is made up using a series of random numbers (6 octets long).
+//
+
+var UUID = function() {};
+
+UUID.rand = function(max) { return Math.floor(Math.random() * (max + 1)) };
+UUID.paddedHex = function(number, padding) {
+	var hex = number.toString(16).toUpperCase();
+	return padding.substr(0, padding.length - hex.length) + hex;
+};
+UUID.generateNode = function() {
+	return UUID.paddedHex(UUID.rand(0xFFFF), "0000") + UUID.paddedHex(UUID.rand(0xFFFF), "0000") + UUID.paddedHex(UUID.rand(0xFFFF), "0000");
+};
+
+UUID.generate = function(node) {
+	function rand(max) { return Math.floor(Math.random() * (max + 1)) }
+	function paddedHex(number, padding) {
+		var hex = number.toString(16).toUpperCase();
+		return padding.substr(0, padding.length - hex.length) + hex;
+	}
+	
+	var dg = new Date(1582, 10, 15, 0, 0, 0, 0);
+	var dc = new Date();
+	var t = (dc.getTime() - dg.getTime()) * 10000;	// convert milliseconds to 100-nanosecond units
+	var h = "-";
+	var hex = t.toString(16).toUpperCase();
+	hex = "1" + paddedHex(t, "000000000000000");	// pad the hex to 60 bits and set top quad to "1" for version.
+	var tl = hex.substr(8,8);
+	var tm = hex.substr(4,4);
+	var thv = hex.substr(0,4);
+	var cs = rand(0xFFFF) | 0x008000 & 0x00BFFF;	// mask first two bits as 10b for variant
+	var cshex = cs.toString(16).toUpperCase();
+ 
+	// since detection of anything about the machine/browser is far to buggy,
+	// include some more random numbers here
+	// if NIC or an IP can be obtained reliably, that should be put in
+	// here instead.
+	var n = node;
+	if (!n) {
+		n = UUID.generateNode();
+	}
+	else
+		n = n.toUpperCase();
+	return tl + h + tm + h + thv + h + cshex + h + n;
+};
+
+exports.generateNode = UUID.generateNode;
+exports.generate = UUID.generate;