vulcan 0.0.1 → 0.0.2

data/server/node_modules/knox/index.js

@@ -0,0 +1,2 @@
+
+module.exports = require('./lib/knox');

data/server/node_modules/knox/lib/knox/auth.js

@@ -0,0 +1,190 @@
+
+/*!
+ * knox - auth
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var crypto = require('crypto')
+  , parse = require('url').parse;
+
+/**
+ * Valid keys.
+ */
+
+var keys = [
+    'acl'
+  , 'location'
+  , 'logging'
+  , 'notification'
+  , 'partNumber'
+  , 'policy'
+  , 'requestPayment'
+  , 'torrent'
+  , 'uploadId'
+  , 'uploads'
+  , 'versionId'
+  , 'versioning'
+  , 'versions'
+  , 'website'
+];
+
+/**
+ * Return an "Authorization" header value with the given `options`
+ * in the form of "AWS <key>:<signature>"
+ *
+ * @param {Object} options
+ * @return {String}
+ * @api private
+ */
+
+exports.authorization = function(options){
+  return 'AWS ' + options.key + ':' + exports.sign(options);
+};
+
+/**
+ * Simple HMAC-SHA1 Wrapper
+ *
+ * @param {Object} options
+ * @return {String}
+ * @api private
+ */ 
+
+exports.hmacSha1 = function(options){
+  return crypto.createHmac('sha1', options.secret).update(options.message).digest('base64');
+};
+
+/**
+ * Create a base64 sha1 HMAC for `options`. 
+ * 
+ * @param {Object} options
+ * @return {String}
+ * @api private
+ */
+
+exports.sign = function(options){
+  options.message = exports.stringToSign(options);
+  return exports.hmacSha1(options);
+};
+
+/**
+ * Create a base64 sha1 HMAC for `options`. 
+ *
+ * Specifically to be used with S3 presigned URLs
+ * 
+ * @param {Object} options
+ * @return {String}
+ * @api private
+ */
+
+exports.signQuery = function(options){
+  options.message = exports.queryStringToSign(options);
+  return exports.hmacSha1(options);
+};
+
+/**
+ * Return a string for sign() with the given `options`.
+ *
+ * Spec:
+ * 
+ *    <verb>\n
+ *    <md5>\n
+ *    <content-type>\n
+ *    <date>\n
+ *    [headers\n]
+ *    <resource>
+ *
+ * @param {Object} options
+ * @return {String}
+ * @api private
+ */
+
+exports.stringToSign = function(options){
+  var headers = options.amazonHeaders || '';
+  if (headers) headers += '\n';
+  return [
+      options.verb
+    , options.md5
+    , options.contentType
+    , options.date.toUTCString()
+    , headers + options.resource
+  ].join('\n');
+};
+
+/**
+ * Return a string for sign() with the given `options`, but is meant exclusively
+ * for S3 presigned URLs
+ *
+ * Spec:
+ * 
+ *    <date>\n
+ *    <resource>
+ *
+ * @param {Object} options
+ * @return {String}
+ * @api private
+ */
+
+exports.queryStringToSign = function(options){
+  return 'GET\n\n\n' +
+    options.date + '\n' +
+    options.resource;
+};
+
+/**
+ * Perform the following:
+ *
+ *  - ignore non-amazon headers
+ *  - lowercase fields
+ *  - sort lexicographically
+ *  - trim whitespace between ":"
+ *  - join with newline
+ *
+ * @param {Object} headers
+ * @return {String}
+ * @api private
+ */
+
+exports.canonicalizeHeaders = function(headers){
+  var buf = []
+    , fields = Object.keys(headers);
+  for (var i = 0, len = fields.length; i < len; ++i) {
+    var field = fields[i]
+      , val = headers[field]
+      , field = field.toLowerCase();
+    if (0 !== field.indexOf('x-amz')) continue;
+    buf.push(field + ':' + val);
+  }
+  return buf.sort().join('\n');
+};
+
+/**
+ * Perform the following:
+ *
+ *  - ignore non sub-resources
+ *  - sort lexicographically
+ *
+ * @param {String} resource
+ * @return {String}
+ * @api private
+ */
+
+exports.canonicalizeResource = function(resource){
+  var url = parse(resource, true)
+    , path = url.pathname
+    , buf = [];
+
+  Object.keys(url.query).forEach(function(key){
+    if (!~keys.indexOf(key)) return;
+    var val = '' == url.query[key] ? '' : '=' + encodeURIComponent(url.query[key]);
+    buf.push(key + val);
+  });
+
+  return path + (buf.length
+    ? '?' + buf.sort().join('&')
+    : '');
+};

data/server/node_modules/knox/lib/knox/client.js

@@ -0,0 +1,355 @@
+
+/*!
+ * knox - Client
+ * Copyright(c) 2010 LearnBoost <dev@learnboost.com>
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var utils = require('./utils')
+  , auth = require('./auth')
+  , http = require('http')
+  , url = require('url')
+  , join = require('path').join
+  , mime = require('./mime')
+  , fs = require('fs');
+
+/**
+ * Initialize a `Client` with the given `options`.
+ *
+ * Required:
+ *
+ *  - `key`     amazon api key
+ *  - `secret`  amazon secret
+ *  - `bucket`  bucket name string, ex: "learnboost"
+ *
+ * @param {Object} options
+ * @api public
+ */
+
+var Client = module.exports = exports = function Client(options) {
+  if (!options.key) throw new Error('aws "key" required');
+  if (!options.secret) throw new Error('aws "secret" required');
+  if (!options.bucket) throw new Error('aws "bucket" required');
+
+  this.endpoint = options.bucket + '.s3.amazonaws.com';
+  utils.merge(this, options);
+};
+
+/**
+ * Request with `filename` the given `method`, and optional `headers`.
+ *
+ * @param {String} method
+ * @param {String} filename
+ * @param {Object} headers
+ * @return {ClientRequest}
+ * @api private
+ */
+
+Client.prototype.request = function(method, filename, headers){
+  var options = { host: this.endpoint, port: 80 }
+    , date = new Date
+    , headers = headers || {};
+
+  // Default headers
+  utils.merge(headers, {
+      Date: date.toUTCString()
+    , Host: this.endpoint
+  });
+
+  // Authorization header
+  headers.Authorization = auth.authorization({
+      key: this.key
+    , secret: this.secret
+    , verb: method
+    , date: date
+    , resource: auth.canonicalizeResource(join('/', this.bucket, filename))
+    , contentType: headers['Content-Type']
+    , amazonHeaders: auth.canonicalizeHeaders(headers)
+  });
+
+  // Issue request
+  options.method = method;
+  options.path = join('/', filename);
+  options.headers = headers;
+  var req = http.request(options);
+  req.url = this.url(filename);
+
+  return req;
+};
+
+/**
+ * PUT data to `filename` with optional `headers`.
+ *
+ * Example:
+ *
+ *     // Fetch the size
+ *     fs.stat('Readme.md', function(err, stat){
+ *      // Create our request
+ *      var req = client.put('/test/Readme.md', {
+ *          'Content-Length': stat.size
+ *        , 'Content-Type': 'text/plain'
+ *      });
+ *      fs.readFile('Readme.md', function(err, buf){
+ *        // Output response
+ *        req.on('response', function(res){
+ *          console.log(res.statusCode);
+ *          console.log(res.headers);
+ *          res.on('data', function(chunk){
+ *            console.log(chunk.toString());
+ *          });
+ *        });
+ *        // Send the request with the file's Buffer obj
+ *        req.end(buf);
+ *      });
+ *     });
+ *
+ * @param {String} filename
+ * @param {Object} headers
+ * @return {ClientRequest}
+ * @api public
+ */
+
+Client.prototype.put = function(filename, headers){
+  headers = utils.merge({
+      Expect: '100-continue'
+    , 'x-amz-acl': 'public-read'
+  }, headers || {});
+  return this.request('PUT', filename, headers);
+};
+
+/**
+ * PUT the file at `src` to `filename`, with callback `fn`
+ * receiving a possible exception, and the response object.
+ *
+ * NOTE: this method reads the _entire_ file into memory using
+ * fs.readFile(), and is not recommended or large files.
+ *
+ * Example:
+ *
+ *    client
+ *     .putFile('package.json', '/test/package.json', function(err, res){
+ *       if (err) throw err;
+ *       console.log(res.statusCode);
+ *       console.log(res.headers);
+ *     });
+ *
+ * @param {String} src
+ * @param {String} filename
+ * @param {Object|Function} headers
+ * @param {Function} fn
+ * @api public
+ */
+
+Client.prototype.putFile = function(src, filename, headers, fn){
+  var self = this;
+  if ('function' == typeof headers) {
+    fn = headers;
+    headers = {};
+  };
+  fs.readFile(src, function(err, buf){
+    if (err) return fn(err);
+    headers = utils.merge({
+        'Content-Length': buf.length
+      , 'Content-Type': mime.lookup(src)
+    }, headers);
+    self.put(filename, headers).on('response', function(res){
+      fn(null, res);
+    }).end(buf);
+  });
+};
+
+/**
+ * PUT the given `stream` as `filename` with optional `headers`.
+ *
+ * @param {Stream} stream
+ * @param {String} filename
+ * @param {Object|Function} headers
+ * @param {Function} fn
+ * @api public
+ */
+
+Client.prototype.putStream = function(stream, filename, headers, fn){
+  var self = this;
+  if ('function' == typeof headers) {
+    fn = headers;
+    headers = {};
+  };
+  fs.stat(stream.path, function(err, stat){
+    if (err) return fn(err);
+    // TODO: sys.pump() wtf?
+    var req = self.put(filename, utils.merge({
+        'Content-Length': stat.size
+      , 'Content-Type': mime.lookup(stream.path)
+    }, headers));
+    req.on('response', function(res){
+      fn(null, res);
+    });
+    stream
+      .on('error', function(err){fn(null, err); })
+      .on('data', function(chunk){ req.write(chunk); })
+      .on('end', function(){ req.end(); });
+  });
+};
+
+/**
+ * GET `filename` with optional `headers`.
+ *
+ * @param {String} filename
+ * @param {Object} headers
+ * @return {ClientRequest}
+ * @api public
+ */
+
+Client.prototype.get = function(filename, headers){
+  return this.request('GET', filename, headers);
+};
+
+/**
+ * GET `filename` with optional `headers` and callback `fn`
+ * with a possible exception and the response.
+ *
+ * @param {String} filename
+ * @param {Object|Function} headers
+ * @param {Function} fn
+ * @api public
+ */
+
+Client.prototype.getFile = function(filename, headers, fn){
+  if ('function' == typeof headers) {
+    fn = headers;
+    headers = {};
+  }
+  return this.get(filename, headers).on('response', function(res){
+    fn(null, res);
+  }).end();
+};
+
+/**
+ * Issue a HEAD request on `filename` with optional `headers.
+ *
+ * @param {String} filename
+ * @param {Object} headers
+ * @return {ClientRequest}
+ * @api public
+ */
+
+Client.prototype.head = function(filename, headers){
+  return this.request('HEAD', filename, headers);
+};
+
+/**
+ * Issue a HEAD request on `filename` with optional `headers`
+ * and callback `fn` with a possible exception and the response.
+ *
+ * @param {String} filename
+ * @param {Object|Function} headers
+ * @param {Function} fn
+ * @api public
+ */
+
+Client.prototype.headFile = function(filename, headers, fn){
+  if ('function' == typeof headers) {
+    fn = headers;
+    headers = {};
+  }
+  return this.head(filename, headers).on('response', function(res){
+    fn(null, res);
+  }).end();
+};
+
+/**
+ * DELETE `filename` with optional `headers.
+ *
+ * @param {String} filename
+ * @param {Object} headers
+ * @return {ClientRequest}
+ * @api public
+ */
+
+Client.prototype.del = function(filename, headers){
+  return this.request('DELETE', filename, headers);
+};
+
+/**
+ * DELETE `filename` with optional `headers`
+ * and callback `fn` with a possible exception and the response.
+ *
+ * @param {String} filename
+ * @param {Object|Function} headers
+ * @param {Function} fn
+ * @api public
+ */
+
+Client.prototype.deleteFile = function(filename, headers, fn){
+  if ('function' == typeof headers) {
+    fn = headers;
+    headers = {};
+  }
+  return this.del(filename, headers).on('response', function(res){
+    fn(null, res);
+  }).end();
+};
+
+/**
+ * Return a url to the given `filename`.
+ *
+ * @param {String} filename
+ * @return {String}
+ * @api public
+ */
+
+Client.prototype.url =
+Client.prototype.http = function(filename){
+  return 'http://' + join(this.endpoint, filename);
+};
+
+/**
+ * Return an HTTPS url to the given `filename`.
+ *
+ * @param {String} filename
+ * @return {String}
+ * @api public
+ */
+
+Client.prototype.https = function(filename){
+  return 'https://' + join(this.endpoint, filename);
+};
+
+/**
+ * Return an S3 presigned url to the given `filename`.
+ *
+ * @param {String} filename
+ * @param {Date} expiration
+ * @return {String}
+ * @api public
+ */
+
+Client.prototype.signedUrl = function(filename, expiration){
+  var epoch = Math.floor(expiration.getTime()/1000);
+  var signature = auth.signQuery({
+    secret: this.secret,
+    date: epoch,
+    resource: '/' + this.bucket + url.parse(filename).pathname
+  });
+
+  return this.url(filename) +
+    '?Expires=' + epoch +
+    '&AWSAccessKeyId=' + this.key +
+    '&Signature=' + encodeURIComponent(signature);
+};
+
+/**
+ * Shortcut for `new Client()`.
+ *
+ * @param {Object} options
+ * @see Client()
+ * @api public
+ */
+
+exports.createClient = function(options){
+  return new Client(options);
+};