aws-sdk 2.0.1 → 2.0.5

package/lib/request.js

@@ -3,14 +3,6 @@ var AcceptorStateMachine = require('./state_machine');
 var inherit = AWS.util.inherit;
 
 var hardErrorStates = {success:1, error:1, complete:1};
-var hardErrors = {
-  EvalError: 1,
-  RangeError: 1,
-  ReferenceError: 1,
-  SyntaxError: 1,
-  TypeError: 1,
-  URIError: 1
-};
 
 function isTerminalState(machine) {
   return hardErrorStates.hasOwnProperty(machine._asm.currentState);
@@ -23,37 +15,24 @@ fsm.setupStates = function() {
       var self = this;
       self.emit(self._asm.currentState, function() {
         var nextError = self.response.error;
-        if (nextError && isTerminalState(self)) {
-          var isHardError = hardErrors.hasOwnProperty(nextError.name);
-          if (!isHardError) nextError = null;
+        if (nextError && nextError !== err && isTerminalState(self)) {
+          throw nextError;
         }
 
         done(nextError);
       });
 
     } catch (e) {
-      err = e;
-      if (isTerminalState(self)) {
-        var isHardError = hardErrors.hasOwnProperty(err.name);
-        if (!isHardError) err = null;
+      if (e !== err && isTerminalState(self)) {
+        AWS.SequentialExecutor.prototype.unhandledErrorCallback.call(this, e);
+        done();
+      } else {
+        done(e);
       }
-      done(err);
     }
   };
 
   this.addState('validate', 'build', 'error', transition);
-  this.addState('restart', 'build', 'error', function(err, done) {
-    err = this.response.error;
-    if (!err) return done();
-    if (!err.retryable) return done(err);
-
-    if (this.response.retryCount < this.service.config.maxRetries) {
-      this.response.retryCount++;
-      done();
-    } else {
-      done(err);
-    }
-  });
   this.addState('build', 'afterBuild', 'restart', transition);
   this.addState('afterBuild', 'sign', 'restart', transition);
   this.addState('sign', 'send', 'retry', transition);
@@ -63,13 +42,10 @@ fsm.setupStates = function() {
   this.addState('validateResponse', 'extractData', 'extractError', transition);
   this.addState('extractError', 'extractData', 'retry', transition);
   this.addState('extractData', 'success', 'retry', transition);
+  this.addState('restart', 'build', 'error', transition);
   this.addState('success', 'complete', 'complete', transition);
   this.addState('error', 'complete', 'complete', transition);
-  this.addState('complete', null, 'uncaughtException', transition);
-  this.addState('uncaughtException', function(err, done) {
-    AWS.SequentialExecutor.prototype.unhandledErrorCallback.call(this, err);
-    done(err);
-  });
+  this.addState('complete', null, null, transition);
 };
 fsm.setupStates();
 
@@ -322,7 +298,7 @@ AWS.Request = inherit({
     var region = service.config.region;
 
     // global endpoints sign as us-east-1
-    if (service.hasGlobalEndpoint()) region = 'us-east-1';
+    if (service.isGlobalEndpoint) region = 'us-east-1';
 
     this.service = service;
     this.operation = operation;
@@ -331,7 +307,6 @@ AWS.Request = inherit({
     this.startTime = AWS.util.date.getDate();
 
     this.response = new AWS.Response(this);
-    this.restartCount = 0;
     this._asm = new AcceptorStateMachine(fsm.states, 'validate');
 
     AWS.SequentialExecutor.call(this);
@@ -437,30 +412,46 @@ AWS.Request = inherit({
    *     console.log("Page", pages++);
    *     console.log(data);
    *   });
-   * @callback callback function(err, data)
-   *   Called with each page of resulting data from the request.
+   * @example Iterating over multiple pages with an asynchronous callback
+   *   s3.listObjects(params).eachPage(function(err, data, done) {
+   *     doSomethingAsyncAndOrExpensive(function() {
+   *       // The next page of results isn't fetched until done is called
+   *       done();
+   *     });
+   *   });
+   * @callback callback function(err, data, [doneCallback])
+   *   Called with each page of resulting data from the request. If the
+   *   optional `doneCallback` is provided in the function, it must be called
+   *   when the callback is complete.
    *
    *   @param err [Error] an error object, if an error occurred.
    *   @param data [Object] a single page of response data. If there is no
    *     more data, this object will be `null`.
+   *   @param doneCallback [Function] an optional done callback. If this
+   *     argument is defined in the function declaration, it should be called
+   *     when the next page is ready to be retrieved. This is useful for
+   *     controlling serial pagination across asynchronous operations.
    *   @return [Boolean] if the callback returns `false`, pagination will
    *     stop.
    *
-   * @api experimental
    * @see AWS.Request.eachItem
    * @see AWS.Response.nextPage
    * @since v1.4.0
    */
   eachPage: function eachPage(callback) {
+    // Make all callbacks async-ish
+    callback = AWS.util.fn.makeAsync(callback, 3);
+
     function wrappedCallback(response) {
-      var result = callback.call(response, response.error, response.data);
-      if (result === false) return;
+      callback.call(response, response.error, response.data, function (result) {
+        if (result === false) return;
 
-      if (response.hasNextPage()) {
-        response.nextPage().on('complete', wrappedCallback).send();
-      } else {
-        callback.call(response, null, null);
-      }
+        if (response.hasNextPage()) {
+          response.nextPage().on('complete', wrappedCallback).send();
+        } else {
+          callback.call(response, null, null, AWS.util.fn.noop);
+        }
+      });
     }
 
     this.on('complete', wrappedCallback).send();
@@ -601,6 +592,7 @@ AWS.Request = inherit({
    */
   eventParameters: function eventParameters(eventName) {
     switch (eventName) {
+      case 'restart':
       case 'validate':
       case 'sign':
       case 'build':

package/lib/sequential_executor.js

@@ -73,9 +73,6 @@ AWS.SequentialExecutor = AWS.util.inherit({
    */
   emit: function emit(eventName, eventArgs, doneCallback) {
     if (!doneCallback) doneCallback = this.unhandledErrorCallback;
-    if (domain && this.domain instanceof domain.Domain)
-      this.domain.enter();
-
     var listeners = this.listeners(eventName);
     var count = listeners.length;
     this.callListeners(listeners, eventArgs, doneCallback);
@@ -88,39 +85,25 @@ AWS.SequentialExecutor = AWS.util.inherit({
   callListeners: function callListeners(listeners, args, doneCallback) {
     if (listeners.length === 0) {
       doneCallback.call(this);
-      if (domain && this.domain instanceof domain.Domain)
-        this.domain.exit();
-    } else {
-      var listener = listeners.shift();
-      if (listener._isAsync) {
-
-        // asynchronous listener
-        var self = this;
-        var callNextListener = function(err) {
-          if (err) {
-            doneCallback.call(self, err);
-            if (domain && self.domain instanceof domain.Domain)
-              self.domain.exit();
-          } else {
-            self.callListeners(listeners, args, doneCallback);
-          }
-        };
-        listener.apply(this, args.concat([callNextListener]));
-
-      } else {
-
-        // synchronous listener
-        try {
-          listener.apply(this, args);
-          this.callListeners(listeners, args, doneCallback);
-        } catch (err) {
-          if (err._hardError) throw err;
+      return;
+    }
 
-          doneCallback.call(this, err);
-          if (domain && this.domain instanceof domain.Domain)
-            this.domain.exit();
+    var self = this, listener = listeners.shift();
+    if (listener._isAsync) { // asynchronous listener
+      var callNextListener = function(err) {
+        if (err) {
+          doneCallback.call(self, err);
+        } else {
+          self.callListeners(listeners, args, doneCallback);
         }
-
+      };
+      listener.apply(self, args.concat([callNextListener]));
+    } else { // synchronous listener
+      try {
+        listener.apply(self, args);
+        self.callListeners(listeners, args, doneCallback);
+      } catch (err) {
+        doneCallback.call(self, err);
       }
     }
   },

package/lib/service.js

@@ -1,5 +1,6 @@
 var AWS = require('./core');
 var Api = require('./model/api');
+var regionConfig = require('./region_config');
 var inherit = AWS.util.inherit;
 
 /**
@@ -34,10 +35,19 @@ AWS.Service = inherit({
     this.config = new AWS.Config(AWS.config);
     if (config) this.config.update(config, true);
 
+    this.validateService();
+    regionConfig(this);
+
     this.config.endpoint = this.endpointFromTemplate(this.config.endpoint);
     this.setEndpoint(this.config.endpoint);
   },
 
+  /**
+   * @api private
+   */
+  validateService: function validateService() {
+  },
+
   /**
    * @api private
    */
@@ -236,9 +246,12 @@ AWS.Service = inherit({
    * @api private
    */
   getSignerClass: function getSignerClass() {
-    var version = this.api.signatureVersion;
-    if (this.config.signatureVersion) version = this.config.signatureVersion;
-    else if (this.isRegionV4()) version = 'v4';
+    var version;
+    if (this.config.signatureVersion) {
+      version = this.config.signatureVersion;
+    } else {
+      version = this.api.signatureVersion;
+    }
     return AWS.Signers.RequestSigner.getVersion(version);
   },
 
@@ -342,47 +355,7 @@ AWS.Service = inherit({
    * @api private
    */
   setEndpoint: function setEndpoint(endpoint) {
-    if (endpoint) {
-      this.endpoint = new AWS.Endpoint(endpoint, this.config);
-    } else if (this.hasGlobalEndpoint()) {
-      this.endpoint = new AWS.Endpoint(this.api.globalEndpoint, this.config);
-    } else {
-      var host = this.api.endpointPrefix + '.' + this.config.region +
-                 this.endpointSuffix();
-      this.endpoint = new AWS.Endpoint(host, this.config);
-    }
-  },
-
-  /**
-   * @api private
-   */
-  hasGlobalEndpoint: function hasGlobalEndpoint() {
-    if (this.isRegionV4()) return false;
-    return this.api.globalEndpoint;
-  },
-
-  /**
-   * @api private
-   */
-  endpointSuffix: function endpointSuffix() {
-    var suffix = '.amazonaws.com';
-    if (this.isRegionCN()) return suffix + '.cn';
-    else return suffix;
-  },
-
-  /**
-   * @api private
-   */
-  isRegionCN: function isRegionCN() {
-    if (!this.config.region) return false;
-    return this.config.region.match(/^cn-/) ? true : false;
-  },
-
-  /**
-   * @api private
-   */
-  isRegionV4: function isRegionV4() {
-    return this.isRegionCN();
+    this.endpoint = new AWS.Endpoint(endpoint, this.config);
   },
 
   /**

package/lib/services/cloudsearchdomain.js

@@ -0,0 +1,69 @@
+var AWS = require('../core');
+
+/**
+ * Constructs a service interface object. Each API operation is exposed as a
+ * function on service.
+ *
+ * ### Sending a Request Using CloudSearchDomain
+ *
+ * ```javascript
+ * var csd = new AWS.CloudSearchDomain({endpoint: 'my.host.tld'});
+ * csd.search(params, function (err, data) {
+ *   if (err) console.log(err, err.stack); // an error occurred
+ *   else     console.log(data);           // successful response
+ * });
+ * ```
+ *
+ * ### Locking the API Version
+ *
+ * In order to ensure that the CloudSearchDomain object uses this specific API,
+ * you can construct the object by passing the `apiVersion` option to the
+ * constructor:
+ *
+ * ```javascript
+ * var csd = new AWS.CloudSearchDomain({
+ *   endpoint: 'my.host.tld',
+ *   apiVersion: '2013-01-01'
+ * });
+ * ```
+ *
+ * You can also set the API version globally in `AWS.config.apiVersions` using
+ * the **cloudsearchdomain** service identifier:
+ *
+ * ```javascript
+ * AWS.config.apiVersions = {
+ *   cloudsearchdomain: '2013-01-01',
+ *   // other service API versions
+ * };
+ *
+ * var csd = new AWS.CloudSearchDomain({endpoint: 'my.host.tld'});
+ * ```
+ *
+ * @note You *must* provide an `endpoint` configuration parameter when
+ *   constructing this service. See {constructor} for more information.
+ *
+ * @!method constructor(options = {})
+ *   Constructs a service object. This object has one method for each
+ *   API operation.
+ *
+ *   @example Constructing a CloudSearchDomain object
+ *     var csd = new AWS.CloudSearchDomain({endpoint: 'my.host.tld'});
+ *   @note You *must* provide an `endpoint` when constructing this service.
+ *   @option (see AWS.Config.constructor)
+ *
+ * @service cloudsearchdomain
+ * @version 2013-01-01
+ */
+AWS.util.update(AWS.CloudSearchDomain.prototype, {
+  /**
+   * @api private
+   */
+  validateService: function validateService() {
+    if (!this.config.endpoint || this.config.endpoint.indexOf('{') >= 0) {
+      var msg = 'AWS.CloudSearchDomain requires an explicit ' +
+                '`endpoint\' configuration option.';
+      throw AWS.util.error(new Error(),
+        {name: 'InvalidEndpoint', message: msg});
+    }
+  }
+});

package/lib/services/route53.js

@@ -14,17 +14,5 @@ AWS.util.update(AWS.Route53.prototype, {
   sanitizeUrl: function sanitizeUrl(request) {
     var path = request.httpRequest.path;
     request.httpRequest.path = path.replace(/\/%2F\w+%2F/, '/');
-  },
-
-  /**
-   * @api private
-   */
-  setEndpoint: function setEndpoint(endpoint) {
-    if (endpoint) {
-      AWS.Service.prototype.setEndpoint(endpoint);
-    } else {
-      var opts = {sslEnabled: true}; // SSL is always enabled for Route53
-      this.endpoint = new AWS.Endpoint(this.api.globalEndpoint, opts);
-    }
   }
 });

package/lib/services/s3.js

@@ -4,9 +4,9 @@ AWS.util.update(AWS.S3.prototype, {
   /**
    * @api private
    */
-  initialize: function initialize(options) {
-    AWS.Service.prototype.initialize.call(this, options);
-    this.setEndpoint(this.config.endpoint, options);
+  validateService: function validateService() {
+    // default to us-east-1 when no region is provided
+    if (!this.config.region) this.config.region = 'us-east-1';
   },
 
   /**
@@ -287,22 +287,6 @@ AWS.util.update(AWS.S3.prototype, {
     }
   },
 
-  /**
-   * @api private
-   */
-  setEndpoint: function setEndpoint(endpoint) {
-    if (endpoint) {
-      this.endpoint = new AWS.Endpoint(endpoint, this.config);
-    } else if (this.config.region && this.config.region !== 'us-east-1') {
-      var sep = '-';
-      if (this.isRegionV4()) sep = '.';
-      var hostname = 's3' + sep + this.config.region + this.endpointSuffix();
-      this.endpoint = new AWS.Endpoint(hostname);
-    } else {
-      this.endpoint = new AWS.Endpoint(this.api.globalEndpoint, this.config);
-    }
-  },
-
   /**
    * Get a pre-signed URL for a given operation name.
    *

package/lib/signers/v4.js

@@ -195,9 +195,10 @@ AWS.Signers.V4 = inherit(AWS.Signers.RequestSigner, {
   },
 
   unsignableHeaders: ['authorization', 'content-type', 'content-length',
-    'user-agent', expiresHeader, 'x-amz-user-agent', 'x-amz-content-sha256'],
+                      'user-agent', expiresHeader],
 
   isSignableHeader: function isSignableHeader(key) {
+    if (key.toLowerCase().indexOf('x-amz-') === 0) return true;
     return this.unsignableHeaders.indexOf(key) < 0;
   },
 

package/lib/util.js

@@ -98,7 +98,7 @@ var util = {
 
   readFileSync: function readFileSync(path) {
     if (typeof window !== 'undefined') return null;
-    return require('fs').readFileSync(path, 'utf-8');
+    return util.nodeRequire('fs').readFileSync(path, 'utf-8');
   },
 
   base64: {
@@ -151,7 +151,7 @@ var util = {
       } else if (typeof string.size === 'number') {
         return string.size;
       } else if (typeof string.path === 'string') {
-        return require('fs').lstatSync(string.path).size;
+        return util.nodeRequire('fs').lstatSync(string.path).size;
       } else {
         throw util.error(new Error('Cannot determine length of ' + string),
           { object: string });
@@ -188,6 +188,29 @@ var util = {
     }
   },
 
+  fn: {
+    noop: function(){},
+
+    /**
+     * Turn a synchronous function into as "async" function by making it call
+     * a callback. The underlying function is called with all but the last argument,
+     * which is treated as the callback. The callback is passed passed a first argument
+     * of null on success to mimick standard node callbacks.
+     */
+    makeAsync: function makeAsync(fn, expectedArgs) {
+      if (expectedArgs && expectedArgs <= fn.length) {
+        return fn;
+      }
+
+      return function() {
+        var args = Array.prototype.slice.call(arguments, 0);
+        var callback = args.pop();
+        var result = fn.apply(null, args);
+        callback(result);
+      };
+    }
+  },
+
   jamespath: {
     query: function query(expression, data) {
       if (!data) return [];
@@ -310,7 +333,9 @@ var util = {
     },
 
     parseTimestamp: function parseTimestamp(value) {
-      if (value.match(/^\d+$/)) { // unix timestamp
+      if (typeof value === 'number') { // unix timestamp (number)
+        return new Date(value * 1000);
+      } else if (value.match(/^\d+$/)) { // unix timestamp
         return new Date(value * 1000);
       } else if (value.match(/^\d{4}/)) { // iso8601
         return new Date(value);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "aws-sdk",
     "description": "AWS SDK for JavaScript",
-    "version": "2.0.1",
+    "version": "2.0.5",
     "author": {
       "name":"Amazon Web Services",
       "email":"",
@@ -14,7 +14,8 @@
     ],
     "devDependencies": {
       "repl.history": "*",
-      "jasmine-node": "*",
+      "jasmine-node": "1.x",
+      "jasmine-reporters": "1.x",
       "semver": "*",
       "coffee-script": "1.6.3",
       "eslint": "*",
@@ -27,7 +28,6 @@
       "istanbul": "*"
     },
     "dependencies": {
-      "agentkeepalive": "0.2.2",
       "aws-sdk-apis": "3.x",
       "xml2js": "0.2.6",
       "xmlbuilder": "0.4.2"

package/scripts/console

@@ -2,7 +2,6 @@
 
 var repl = require('repl').start('aws-sdk> '),
     replEval = repl.eval,
-    replHistory = require('repl.history'),
     defaultOptions = {
       logger: process.stdout,
       region: process.env.AWS_REGION || 'us-east-1'
@@ -52,11 +51,20 @@ repl.context.request = null;
 repl.context.response = null;
 
 // setup REPL history
-replHistory(repl, process.env.HOME + '/.node_history');
+try {
+  var replHistory = require('repl.history');
+  replHistory(repl, process.env.HOME + '/.node_history');
+} catch (e) {
+  console.log("Missing repl.history package, history will not be supported.");
+  console.log("  Type `npm install repl.history` to enable history.");
+}
 
 // load services as defined instances
 for (var key in AWS) {
-  if (AWS[key].serviceIdentifier) {
+  var id = AWS[key].serviceIdentifier;
+  if (id) {
+    if (id === 'cloudsearchdomain') continue; // this required an explicit endpoint
+
     var svcClass = AWS[key];
     var svc = new svcClass(defaultOptions);
     svc.with = function(config) {