aws-sdk 2.0.1 → 2.0.5

package/features/sns/step_definitions/sns.js

@@ -0,0 +1,33 @@
+module.exports = function() {
+  this.Before("@sns", function (callback) {
+    this.service = new this.AWS.SNS();
+    callback();
+  });
+
+  this.Given(/^I create an SNS topic with name "([^"]*)"$/, function(name, callback) {
+    var world = this;
+    this.request(null, 'createTopic', {Name: name}, callback, function (resp) {
+      world.topicArn = resp.data.TopicArn;
+    });
+  });
+
+  this.Given(/^I list the SNS topics$/, function(callback) {
+    this.request(null, 'listTopics', {}, callback);
+  });
+
+  this.Then(/^the list should contain the topic ARN$/, function(callback) {
+    var arn = this.topicArn;
+    this.assert.contains(this.data.Topics, function(topic) {
+      return topic.TopicArn === arn;
+    });
+    callback();
+  });
+
+  this.Then(/^I delete the SNS topic$/, function(callback) {
+    this.request(null, 'deleteTopic', {TopicArn: this.topicArn}, callback);
+  });
+
+  this.Given(/^I get SNS topic attributes with an invalid ARN$/, function(callback) {
+    this.request(null, 'getTopicAttributes', {TopicArn:'INVALID'}, callback, false);
+  });
+};

package/features/sqs/messages.feature

@@ -0,0 +1,21 @@
+# language: en
+@sqs @messages
+Feature: SQS Messages
+
+  I want to be able to send and process messages.
+
+  Scenario: Send an SQS message
+    Given I create a queue with the prefix name "aws-js-sdk"
+    When I send the message "HELLO"
+    Then the result should include a message ID
+    And the result should have an MD5 digest of "eb61eead90e3b899c6bcbe27ac581660"
+    And I should eventually be able to receive "HELLO" from the queue
+    Then I delete the SQS queue
+
+  Scenario: Binary payloads
+    Given I create a queue with the prefix name "aws-js-sdk"
+    When I send the message "HELLO" with a binary attribute
+    Then the result should include a message ID
+    And the result should have an MD5 digest of "eb61eead90e3b899c6bcbe27ac581660"
+    And I should eventually be able to receive "HELLO" from the queue with a binary attribute
+    Then I delete the SQS queue

package/features/sqs/queues.feature

@@ -0,0 +1,18 @@
+# language: en
+@sqs @queues
+Feature: SQS Queues
+
+  I want to be able to create, list and delete queues.
+
+  Scenario: Creating and deleting queues
+    Given I create a queue with the prefix name "aws-js-sdk"
+    And I create a queue with the prefix name "aws-js-sdk"
+    Then list queues should eventually return the queue urls
+    Then I delete the SQS queue
+    Then I delete the SQS queue
+
+  Scenario: Making a queue request across regions
+    Given I have a "SQS" service in the "us-west-1" region
+    And I create a queue with the prefix name "aws-js-sdk"
+    When I have a "SQS" service in the "us-east-1" region
+    Then I delete the SQS queue

package/features/sqs/step_definitions/messages.js

@@ -0,0 +1,46 @@
+module.exports = function () {
+
+  this.When(/^I send the message "([^"]*)"$/, function(message, callback) {
+    this.request(null, 'sendMessage', {QueueUrl:this.queueUrl,MessageBody:message}, callback);
+  });
+
+  this.Then(/^the result should include a message ID$/, function(callback) {
+    this.assert.compare(this.data.MessageId.length, '>', 0);
+    callback();
+  });
+
+  this.Then(/^the result should have an MD5 digest of "([^"]*)"$/, function(digest, callback) {
+    this.assert.equal(this.data.MD5OfMessageBody, digest);
+    callback();
+  });
+
+  this.Then(/^I should eventually be able to receive "([^"]*)" from the queue$/, function(message, callback) {
+    this.eventually(callback, function (next) {
+      next.condition = function() {
+        return this.data.Messages[0].Body === message;
+      };
+      this.request(null, 'receiveMessage', {QueueUrl:this.queueUrl}, next);
+    });
+  });
+
+  this.When(/^I send the message "([^"]*)" with a binary attribute$/, function (message, callback) {
+    var params = {
+      QueueUrl: this.queueUrl,
+      MessageBody: message,
+      MessageAttributes: {
+        binary: { DataType: 'Binary', BinaryValue: new Buffer([1,2,3]) }
+      }
+    };
+    this.request(null, 'sendMessage', params, callback);
+  });
+
+  this.Then(/^I should eventually be able to receive "([^"]*)" from the queue with a binary attribute$/, function (message, callback) {
+    this.eventually(callback, function (next) {
+      next.condition = function() {
+        return this.data.Messages[0].MessageAttributes.binary.BinaryValue.toString() === '\u0001\u0002\u0003';
+      };
+      var params = {QueueUrl:this.queueUrl,MessageAttributeNames:['binary']};
+      this.request(null, 'receiveMessage', params, next);
+    });
+  });
+};

package/features/sqs/step_definitions/queues.js

@@ -0,0 +1,33 @@
+module.exports = function () {
+
+  this.Given(/^I create a queue with the prefix name "([^"]*)"$/, function(prefix, callback) {
+    var name = this.uniqueName(prefix);
+    this.request(null, 'createQueue', { QueueName: name }, callback, function() {
+      this.queueUrl = this.data.QueueUrl;
+      this.createdQueues.push(this.queueUrl);
+    });
+  });
+
+  this.Then(/^list queues should eventually return the queue urls$/, function(callback) {
+    this.eventually(callback, function (next) {
+      next.condition = function() {
+        var matchingCount = 0;
+        for (var i = 0; i < this.createdQueues.length; ++i) {
+          for (var j = 0; j < this.data.QueueUrls.length; ++j) {
+            if (this.createdQueues[i] == this.data.QueueUrls[j]) {
+              matchingCount++;
+            }
+          }
+        }
+        return matchingCount == this.createdQueues.length;
+      };
+      this.request(null, 'listQueues', {}, next);
+    }, { maxTime: 60 });
+  });
+
+  this.Then(/^I delete the SQS queue$/, function (callback) {
+    var url = this.createdQueues.pop();
+    this.request(null, 'deleteQueue', { QueueUrl: url }, callback);
+  });
+
+};

package/features/sqs/step_definitions/sqs.js

@@ -0,0 +1,7 @@
+module.exports = function() {
+  this.Before("@sqs", function (callback) {
+    this.service = new this.AWS.SQS({region: 'us-east-1'});
+    this.createdQueues = [];
+    callback();
+  });
+};

package/features/storagegateway/step_definitions/storagegateway.js

@@ -0,0 +1,16 @@
+module.exports = function() {
+  this.Before("@storagegateway", function (callback) {
+    this.service = new this.AWS.StorageGateway();
+    callback();
+  });
+
+  this.When(/^I try to activate a Storage Gateway$/, function(callback) {
+    var params = {
+      ActivationKey: 'INVALIDKEY',
+      GatewayName: this.uniqueName('aws-sdk-js'),
+      GatewayTimezone: 'GMT-5:00',
+      GatewayRegion: 'us-east-1'
+    };
+    this.request(null, 'activateGateway', params, callback, false);
+  });
+};

package/features/storagegateway/storagegateway.feature

@@ -0,0 +1,13 @@
+# language: en
+@storagegateway
+Feature: AWS Storage Gateway
+
+  I want to use AWS Storage Gateway
+
+  Scenario: Activating a Gateway
+    When I try to activate a Storage Gateway
+    Then the error code should be "InvalidGatewayRequestException"
+    Then the error message should be:
+    """
+    The specified activation key was not found.
+    """

package/features/sts/step_definitions/sts.js

@@ -0,0 +1,35 @@
+module.exports = function() {
+  this.Before("@sts", function (callback) {
+    this.service = new this.AWS.STS();
+    callback();
+  });
+
+  this.Given(/^I get an STS session token with a duration of (\d+) seconds$/, function(duration, callback) {
+    this.request(null, 'getSessionToken', {DurationSeconds:parseInt(duration)}, callback, false);
+  });
+
+  this.Then(/^the result should contain an access key ID and secret access key$/, function(callback) {
+    this.assert.compare(this.data.Credentials.AccessKeyId.length, '>', 0);
+    this.assert.compare(this.data.Credentials.SecretAccessKey.length, '>', 0);
+    callback();
+  });
+
+  this.Then(/^the TTL on the session token credentials should be less than (\d+)$/, function(duration, callback) {
+    var ttl = this.data.Credentials.Expiration.getTime();
+    ttl = (ttl - new Date().getTime()) / 1000;
+    this.assert.compare(ttl, '<', duration);
+    callback();
+  });
+
+  this.Given(/^I try to assume role with web identity$/, function(callback) {
+    var params = {RoleArn: 'arn:aws:iam::123456789:role/WebIdentity', RoleSessionName: 'name', WebIdentityToken: 'token'};
+    this.request(null, 'assumeRoleWithWebIdentity', params, callback, false);
+  });
+
+  this.Given(/^I try to assume role with SAML$/, function(callback) {
+    var arn = 'arn:aws:iam::123456789:role/Role';
+    var token = 'TOKENVALUETOKENVALUETOKENVALUETOKENVALUE';
+    var params = {RoleArn: arn, PrincipalArn: arn, SAMLAssertion: token};
+    this.request(null, 'assumeRoleWithSAML', params, callback, false);
+  });
+};

package/features/sts/sts.feature

@@ -0,0 +1,29 @@
+# language: en
+@sts
+Feature: AWS Security Token Service
+
+  I want to use AWS Security Token Service
+
+  @requiresakid
+  Scenario: Get a session token
+    Given I get an STS session token with a duration of 900 seconds
+    Then the result should contain an access key ID and secret access key
+    And the TTL on the session token credentials should be less than 900
+
+  Scenario: Web Identity Federation
+    Given I try to assume role with web identity
+    Then the error message should equal:
+    """
+    Not authorized to perform sts:AssumeRoleWithWebIdentity
+    """
+
+  Scenario: SAML Support
+    Given I try to assume role with SAML
+    Then the error message should equal:
+    """
+    Not authorized to perform sts:AssumeRoleWithSAML
+    """
+
+  Scenario: Error handling
+    Given I get an STS session token with a duration of 60 seconds
+    Then the error code should be "ValidationError"

package/features/support/step_definitions/support.js

@@ -0,0 +1,35 @@
+module.exports = function() {
+  this.Before("@support", function (callback) {
+    this.service = new this.AWS.Support();
+    callback();
+  });
+
+  this.Given(/^I describe Support services$/, function(callback) {
+    this.request(null, 'describeServices', {}, callback);
+  });
+
+  this.Then(/^the Supported services list should contain a service with code "([^"]*)"$/, function(code, callback) {
+    this.assert.contains(this.data.services, function (svc) {
+      return svc.code == code;
+    });
+    callback();
+  });
+
+  this.Then(/^the Supported services list should contain a service with name "([^"]*)"$/, function(name, callback) {
+    this.assert.contains(this.data.services, function (svc) {
+      return svc.name == name;
+    });
+    callback();
+  });
+
+  this.Given(/^I create a case with an invalid category$/, function(callback) {
+    var params = {
+      subject: "Subject",
+      serviceCode: "INVALID-CODE",
+      categoryCode: "INVALID-CATEGORY",
+      communicationBody: "Communication"
+    };
+
+    this.request(null, 'createCase', params, callback, false);
+  });
+};

package/features/support/support.feature

@@ -0,0 +1,18 @@
+# language: en
+@support
+Feature: AWS Support
+
+  I want to use AWS Support
+
+  Scenario: Describe Services
+    Given I describe Support services
+    Then the Supported services list should contain a service with code "amazon-dynamodb"
+    And the Supported services list should contain a service with name "DynamoDB"
+
+  Scenario: Error handling
+    Given I create a case with an invalid category
+    Then the error code should be "ValidationException"
+    And the error message should contain:
+    """
+    1 validation error detected: Value 'INVALID-CODE' at 'serviceCode' failed to satisfy constraint
+    """

package/features/swf/step_definitions/swf.js

@@ -0,0 +1,38 @@
+module.exports = function() {
+  this.Before("@swf", function (callback) {
+    this.service = new this.AWS.SWF();
+    callback();
+  });
+
+  this.Given(/^I register a SWF domain with prefix "([^"]*)"$/, function(prefix, callback) {
+    this.swfDomain = prefix + '-' + new Date().getTime();
+    var params = {name:this.swfDomain, workflowExecutionRetentionPeriodInDays:'7'};
+    this.request(null, 'registerDomain', params, callback, false);
+  });
+
+  this.Given(/^I list SWF domains with status "([^"]*)"$/, function(status, callback) {
+    if (this.error.name === 'LimitExceededFault') return callback();
+    this.request(null, 'listDomains', {registrationStatus: status}, callback);
+  });
+
+  this.Then(/^the SWF domain should be in the list$/, function(callback) {
+    if (this.error.name === 'LimitExceededFault') return callback();
+
+    var items = {};
+    this.data.domainInfos.forEach(function (info) {
+      items[info.name] = info;
+    });
+    this.assert.ok(items[this.swfDomain]);
+    callback();
+  });
+
+  this.Then(/^I delete the SWF domain$/, function(callback) {
+    if (this.error.name === 'LimitExceededFault') return callback();
+    this.request(null, 'deprecateDomain', {name: this.swfDomain}, callback);
+  });
+
+  this.Given(/^I try to create a SWF domain with an empty name$/, function(callback) {
+    var params = {name: '', workflowExecutionRetentionPeriodInDays:'7'};
+    this.request(null, 'registerDomain', params, callback, false);
+  });
+};

package/features/swf/swf.feature

@@ -0,0 +1,15 @@
+# language: en
+@swf
+Feature: Amazon Simple Workflow Service
+
+  I want to use Amazon Simple Workflow Service
+
+  Scenario: Domains
+    Given I register a SWF domain with prefix "aws-js-sdk-integration"
+    And I list SWF domains with status "REGISTERED"
+    Then the SWF domain should be in the list
+    And I delete the SWF domain
+
+  Scenario: Error handling
+    Given I try to create a SWF domain with an empty name
+    Then the error code should be "ValidationException"

package/index.js

@@ -0,0 +1,2 @@
+// Convenience file to require the SDK from the root of the repository
+module.exports = require('./lib/aws');

package/lib/core.js

@@ -8,7 +8,7 @@ var AWS = { util: require('./util') };
  * @!macro [new] nobrowser
  *   @note This feature is not supported in the browser environment of the SDK.
  */
-var _hidden = {}; _hidden = {}; // hack to parse macro
+var _hidden = {}; _hidden.toString(); // hack to parse macro
 
 module.exports = AWS;
 
@@ -17,7 +17,7 @@ AWS.util.update(AWS, {
   /**
    * @constant
    */
-  VERSION: '2.0.0',
+  VERSION: '2.0.5',
 
   /**
    * @api private

package/lib/credentials/shared_ini_file_credentials.js

@@ -1,6 +1,5 @@
 var AWS = require('../core');
 var path = require('path');
-var fs = require('fs');
 
 /**
  * Represents credentials loaded from shared credentials file

package/lib/event_listeners.js

@@ -66,6 +66,7 @@ AWS.EventListeners = {
   Core: new SequentialExecutor().addNamedListeners(function(add, addAsync) {
     addAsync('VALIDATE_CREDENTIALS', 'validate',
         function VALIDATE_CREDENTIALS(req, done) {
+      if (!req.service.api.signatureVersion) return done(); // none
       req.service.config.getCredentials(function(err) {
         if (err) {
           req.response.err = AWS.util.error(err,
@@ -76,7 +77,7 @@ AWS.EventListeners = {
     });
 
     add('VALIDATE_REGION', 'validate', function VALIDATE_REGION(req) {
-      if (!req.service.config.region && !req.service.hasGlobalEndpoint()) {
+      if (!req.service.config.region && !req.service.isGlobalEndpoint) {
         req.response.error = AWS.util.error(new Error(),
           {code: 'SigningError', message: 'Missing region in config'});
       }
@@ -98,6 +99,17 @@ AWS.EventListeners = {
       req.httpRequest.headers['Host'] = req.httpRequest.endpoint.host;
     });
 
+    add('RESTART', 'restart', function RESTART(req) {
+      var err = this.response.error;
+      if (!err || !err.retryable) return;
+
+      if (this.response.retryCount < this.service.config.maxRetries) {
+        this.response.retryCount++;
+      } else {
+        this.response.error = null;
+      }
+    });
+
     addAsync('SIGN', 'sign', function SIGN(req, done) {
       if (!req.service.api.signatureVersion) return done(); // none
 

package/lib/http/node.js

@@ -2,7 +2,6 @@ var AWS = require('../core');
 var Stream = AWS.util.nodeRequire('stream').Stream;
 var WritableStream = AWS.util.nodeRequire('stream').Writable;
 var ReadableStream = AWS.util.nodeRequire('stream').Readable;
-var Agent = require('agentkeepalive');
 require('../http');
 
 /**
@@ -10,6 +9,7 @@ require('../http');
  */
 AWS.NodeHttpClient = AWS.util.inherit({
   handleRequest: function handleRequest(httpRequest, httpOptions, callback, errCallback) {
+    var cbAlreadyCalled = false;
     var endpoint = httpRequest.endpoint;
     var pathPrefix = '';
     if (!httpOptions) httpOptions = {};
@@ -31,8 +31,8 @@ AWS.NodeHttpClient = AWS.util.inherit({
       path: pathPrefix + httpRequest.path
     };
 
-    if (!httpOptions.agent) {
-      options.agent = useSSL ? this.httpsAgent() : this.httpAgent();
+    if (useSSL && !httpOptions.agent) {
+      options.agent = this.sslAgent();
     }
 
     AWS.util.update(options, httpOptions);
@@ -40,26 +40,27 @@ AWS.NodeHttpClient = AWS.util.inherit({
     delete options.timeout; // timeout isn't an HTTP option
 
     var stream = http.request(options, function (httpResp) {
+      if (cbAlreadyCalled) return; cbAlreadyCalled = true;
+
       callback(httpResp);
       httpResp.emit('headers', httpResp.statusCode, httpResp.headers);
     });
     httpRequest.stream = stream; // attach stream to httpRequest
 
     // timeout support
-    stream.setTimeout(httpOptions.timeout || 0);
-    stream.once('timeout', function() {
+    stream.setTimeout(httpOptions.timeout || 0, function() {
+      if (cbAlreadyCalled) return; cbAlreadyCalled = true;
+
       var msg = 'Connection timed out after ' + httpOptions.timeout + 'ms';
       errCallback(AWS.util.error(new Error(msg), {code: 'TimeoutError'}));
-
-      // HACK - abort the connection without tripping our error handler
-      // since we already raised our TimeoutError. Otherwise the connection
-      // comes back with ECONNRESET, which is not a helpful error message
-      stream.removeListener('error', errCallback);
-      stream.on('error', function() { });
       stream.abort();
     });
 
-    stream.on('error', errCallback);
+    stream.on('error', function() {
+      if (cbAlreadyCalled) return; cbAlreadyCalled = true;
+      errCallback.apply(this, arguments);
+    });
+
     this.writeBody(stream, httpRequest);
     return stream;
   },
@@ -81,34 +82,22 @@ AWS.NodeHttpClient = AWS.util.inherit({
     }
   },
 
-  httpsAgent: function httpsAgent() {
+  sslAgent: function sslAgent() {
+    var https = require('https');
+
     if (!AWS.NodeHttpClient.sslAgent) {
-      AWS.NodeHttpClient.sslAgent = new Agent.HttpsAgent({
-        rejectUnauthorized: true
-      });
+      AWS.NodeHttpClient.sslAgent = new https.Agent({rejectUnauthorized: true});
+      AWS.NodeHttpClient.sslAgent.setMaxListeners(0);
 
       // delegate maxSockets to globalAgent
       Object.defineProperty(AWS.NodeHttpClient.sslAgent, 'maxSockets', {
         enumerable: true,
-        get: function() { return require('https').globalAgent.maxSockets; }
+        get: function() { return https.globalAgent.maxSockets; }
       });
     }
     return AWS.NodeHttpClient.sslAgent;
   },
 
-  httpAgent: function httpAgent() {
-    if (!AWS.NodeHttpClient.httpAgent) {
-      AWS.NodeHttpClient.httpAgent = new Agent({rejectUnauthorized: true});
-
-      // delegate maxSockets to globalAgent
-      Object.defineProperty(AWS.NodeHttpClient.httpAgent, 'maxSockets', {
-        enumerable: true,
-        get: function() { return require('http').globalAgent.maxSockets; }
-      });
-    }
-    return AWS.NodeHttpClient.httpAgent;
-  },
-
   progressStream: function progressStream(stream, httpRequest) {
     var numBytes = 0;
     var totalBytes = httpRequest.headers['Content-Length'];

package/lib/model/resource_waiter.js

@@ -1,9 +1,5 @@
-var Shape = require('./shape');
-var StructureShape = Shape.shapes.StructureShape;
-
 var util = require('../util');
 var property = util.property;
-var memoizedProperty = util.memoizedProperty;
 
 function ResourceWaiter(name, waiter, options) {
   options = options || {};

package/lib/model/shape.js

@@ -243,7 +243,8 @@ function TimestampShape(shape) {
   this.toType = function(value) {
     if (value === null || value === undefined) return null;
     if (typeof value.toUTCString === 'function') return value;
-    return typeof value === 'string' ? util.date.parseTimestamp(value) : null;
+    return typeof value === 'string' || typeof value === 'number' ?
+           util.date.parseTimestamp(value) : null;
   };
 
   this.toWireFormat = function(value) {

package/lib/protocol/rest_xml.js

@@ -65,7 +65,7 @@ function extractData(resp) {
       resp.data[payload] = body;
     } else if (payloadMember.type === 'structure') {
       parser = new AWS.XML.Parser();
-      resp.data = parser.parse(body.toString(), payloadMember);
+      util.update(resp.data, parser.parse(body.toString(), payloadMember));
     } else {
       resp.data[payload] = body.toString();
     }

package/lib/region_config.js

@@ -0,0 +1,31 @@
+var util = require('./util');
+var config = require('./region_config.json');
+
+function regionConfig(service) {
+  var sId = service.serviceIdentifier || '';
+  var sRegion = service.config.region || '';
+  var finalConfig = {};
+
+  config.forEach(function(item) {
+    (item.regions || []).forEach(function(region) {
+      if (sRegion.match(new RegExp('^' + region.replace('*', '.*') + '$'))) {
+        (item.serviceConfigs || []).forEach(function(svcConfig) {
+          (svcConfig.services || []).forEach(function(svcName) {
+            if (sId.match(new RegExp('^' + svcName.replace('*', '.*') + '$'))) {
+              util.update(finalConfig, svcConfig.config);
+              service.isGlobalEndpoint = !!svcConfig.globalEndpoint;
+            }
+          });
+        });
+      }
+    });
+  });
+
+  util.each(finalConfig, function(key, value) {
+    if (service.config[key] === undefined || service.config[key] === null) {
+      service.config[key] = value;
+    }
+  });
+}
+
+module.exports = regionConfig;

package/lib/region_config.json

@@ -0,0 +1,56 @@
+[
+  {
+    "regions": ["*"],
+    "serviceConfigs": [
+      {
+        "services": ["*"],
+        "config": {
+          "endpoint": "{service}.{region}.amazonaws.com"
+        }
+      },
+      {
+        "services": ["cloudfront", "iam", "importexport", "sts"],
+        "config": {
+          "endpoint": "{service}.amazonaws.com"
+        },
+        "globalEndpoint": true
+      },
+      {
+        "services": ["s3"],
+        "config": {
+          "endpoint": "{service}-{region}.amazonaws.com"
+        }
+      },
+      {
+        "services": ["route53"],
+        "config": {
+          "endpoint": "https://{service}.amazonaws.com"
+        },
+        "globalEndpoint": true
+      }
+    ]
+  },
+  {
+    "regions": ["us-east-1"],
+    "serviceConfigs": [
+      {
+        "services": ["s3", "simpledb"],
+        "config": {
+          "endpoint": "{service}.amazonaws.com"
+        }
+      }
+    ]
+  },
+  {
+    "regions": ["cn-*"],
+    "serviceConfigs": [
+      {
+        "services": ["*"],
+        "config": {
+          "endpoint": "{service}.{region}.amazonaws.com.cn",
+          "signatureVersion": "v4"
+        }
+      }
+    ]
+  }
+]