mss-sdk
Version:
MSS SDK for JavaScript
1,731 lines (1,386 loc) • 355 kB
JavaScript
// AWS SDK for JavaScript v2.0.14
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// License at https://sdk.amazonaws.com/js/BUNDLE_LICENSE.txt
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
var AWS = require('./core');
AWS.XML.Parser = require('./xml/browser_parser');
require('./http/xhr');
if (typeof window !== 'undefined') window.AWS = AWS;
},{"./core":3,"./http/xhr":12,"./xml/browser_parser":44}],2:[function(require,module,exports){
var AWS = require('./core');
require('./credentials');
require('./credentials/credential_provider_chain');
AWS.Config = AWS.util.inherit({
constructor: function Config(options) {
if (options === undefined) options = {};
options = this.extractCredentials(options);
AWS.util.each.call(this, this.keys, function (key, value) {
this.set(key, options[key], value);
});
},
update: function update(options, allowUnknownKeys) {
allowUnknownKeys = allowUnknownKeys || false;
options = this.extractCredentials(options);
AWS.util.each.call(this, options, function (key, value) {
if (allowUnknownKeys || this.keys.hasOwnProperty(key)) this[key] = value;
});
},
getCredentials: function getCredentials(callback) {
var self = this;
function finish(err) {
callback(err, err ? null : self.credentials);
}
function credError(msg, err) {
return new AWS.util.error(err || new Error(), {
code: 'CredentialsError', message: msg
});
}
function getAsyncCredentials() {
self.credentials.get(function(err) {
if (err) {
var msg = 'Could not load credentials from ' +
self.credentials.constructor.name;
err = credError(msg, err);
}
finish(err);
});
}
function getStaticCredentials() {
var err = null;
if (!self.credentials.accessKeyId || !self.credentials.secretAccessKey) {
err = credError('Missing credentials');
}
finish(err);
}
if (self.credentials) {
if (typeof self.credentials.get === 'function') {
getAsyncCredentials();
} else { // static credentials
getStaticCredentials();
}
} else if (self.credentialProvider) {
self.credentialProvider.resolve(function(err, creds) {
if (err) {
err = credError('Could not load credentials from any providers', err);
}
self.credentials = creds;
finish(err);
});
} else {
finish(credError('No credentials to load'));
}
},
loadFromPath: function loadFromPath(path) {
this.clear();
var options = JSON.parse(AWS.util.readFileSync(path));
var fileSystemCreds = new AWS.FileSystemCredentials(path);
var chain = new AWS.CredentialProviderChain();
chain.providers.unshift(fileSystemCreds);
chain.resolve(function (err, creds) {
if (err) throw err;
else options.credentials = creds;
});
this.constructor(options);
return this;
},
clear: function clear() {
AWS.util.each.call(this, this.keys, function (key) {
delete this[key];
});
this.set('credentials', undefined);
this.set('credentialProvider', undefined);
},
set: function set(property, value, defaultValue) {
if (value === undefined) {
if (defaultValue === undefined) {
defaultValue = this.keys[property];
}
if (typeof defaultValue === 'function') {
this[property] = defaultValue.call(this);
} else {
this[property] = defaultValue;
}
} else {
this[property] = value;
}
},
keys: {
credentials: null,
credentialProvider: null,
region: null,
logger: null,
apiVersions: {},
apiVersion: null,
endpoint: undefined,
httpOptions: {},
maxRetries: undefined,
maxRedirects: 10,
paramValidation: true,
sslEnabled: true,
s3ForcePathStyle: false,
computeChecksums: true,
convertResponseTypes: true,
dynamoDbCrc32: true,
signatureVersion: null
},
extractCredentials: function extractCredentials(options) {
if (options.accessKeyId && options.secretAccessKey) {
options = AWS.util.copy(options);
options.credentials = new AWS.Credentials(options);
}
return options;
}
});
AWS.config = new AWS.Config();
},{"./core":3,"./credentials":4,"./credentials/credential_provider_chain":6}],3:[function(require,module,exports){
var AWS = { util: require('./util') };
var _hidden = {}; _hidden.toString(); // hack to parse macro
module.exports = AWS;
AWS.util.update(AWS, {
VERSION: '2.0.14',
Signers: {},
Protocol: {
Json: require('./protocol/json'),
Query: require('./protocol/query'),
Rest: require('./protocol/rest'),
RestJson: require('./protocol/rest_json'),
RestXml: require('./protocol/rest_xml')
},
XML: {
Builder: require('./xml/builder'),
Parser: null // conditionally set based on environment
},
JSON: {
Builder: require('./json/builder'),
Parser: require('./json/parser')
},
Model: {
Api: require('./model/api'),
Operation: require('./model/operation'),
Shape: require('./model/shape'),
Paginator: require('./model/paginator'),
ResourceWaiter: require('./model/resource_waiter')
},
util: require('./util')
});
require('./service');
require('./credentials');
require('./credentials/credential_provider_chain');
require('./credentials/temporary_credentials');
require('./credentials/web_identity_credentials');
require('./credentials/cognito_identity_credentials');
require('./credentials/saml_credentials');
require('./config');
require('./http');
require('./sequential_executor');
require('./event_listeners');
require('./request');
require('./response');
require('./resource_waiter');
require('./signers/request_signer');
require('./param_validator');
AWS.events = new AWS.SequentialExecutor();
},{"./config":2,"./credentials":4,"./credentials/cognito_identity_credentials":5,"./credentials/credential_provider_chain":6,"./credentials/saml_credentials":7,"./credentials/temporary_credentials":8,"./credentials/web_identity_credentials":9,"./event_listeners":10,"./http":11,"./json/builder":13,"./json/parser":14,"./model/api":15,"./model/operation":17,"./model/paginator":18,"./model/resource_waiter":19,"./model/shape":20,"./param_validator":21,"./protocol/json":22,"./protocol/query":23,"./protocol/rest":24,"./protocol/rest_json":25,"./protocol/rest_xml":26,"./request":30,"./resource_waiter":31,"./response":32,"./sequential_executor":33,"./service":34,"./signers/request_signer":36,"./util":43,"./xml/builder":45}],4:[function(require,module,exports){
var AWS = require('./core');
AWS.Credentials = AWS.util.inherit({
constructor: function Credentials() {
AWS.util.hideProperties(this, ['secretAccessKey']);
this.expired = false;
this.expireTime = null;
if (arguments.length === 1 && typeof arguments[0] === 'object') {
var creds = arguments[0].credentials || arguments[0];
this.accessKeyId = creds.accessKeyId;
this.secretAccessKey = creds.secretAccessKey;
this.sessionToken = creds.sessionToken;
} else {
this.accessKeyId = arguments[0];
this.secretAccessKey = arguments[1];
this.sessionToken = arguments[2];
}
},
expiryWindow: 15,
needsRefresh: function needsRefresh() {
var currentTime = AWS.util.date.getDate().getTime();
var adjustedTime = new Date(currentTime + this.expiryWindow * 1000);
if (this.expireTime && adjustedTime > this.expireTime) {
return true;
} else {
return this.expired || !this.accessKeyId || !this.secretAccessKey;
}
},
get: function get(callback) {
var self = this;
if (this.needsRefresh()) {
this.refresh(function(err) {
if (!err) self.expired = false; // reset expired flag
if (callback) callback(err);
});
} else if (callback) {
callback();
}
},
refresh: function refresh(callback) {
this.expired = false;
callback();
}
});
},{"./core":3}],5:[function(require,module,exports){
var AWS = require('../core');
AWS.CognitoIdentityCredentials = AWS.util.inherit(AWS.Credentials, {
localStorageKey: {
id: 'aws.cognito.identity-id',
providers: 'aws.cognito.identity-providers'
},
constructor: function CognitoIdentityCredentials(params) {
AWS.Credentials.call(this);
this.expired = true;
this.webIdentityCredentials = new AWS.WebIdentityCredentials(params);
this.cognito = new AWS.CognitoIdentity({params: params});
this.sts = new AWS.STS();
this.params = params;
this.data = null;
this.identityId = null;
this.loadCachedId();
},
refresh: function refresh(callback) {
var self = this;
self.data = null;
self.identityId = null;
self.getId(function(err) {
if (!err) {
self.cognito.getOpenIdToken(function(cogErr, data) {
if (!cogErr) {
self.cacheId(data);
self.params.WebIdentityToken = data.Token;
self.webIdentityCredentials.refresh(function(webErr) {
if (!webErr) {
self.data = self.webIdentityCredentials.data;
self.sts.credentialsFrom(self.data, self);
}
callback(webErr);
});
} else {
callback(cogErr);
}
});
} else {
callback(err);
}
});
},
getId: function getId(callback) {
var self = this;
if (typeof self.params.IdentityId === 'string') return callback();
self.cognito.getId(function(err, data) {
if (!err && data.IdentityId) {
self.params.IdentityId = data.IdentityId;
}
callback(err, data);
});
},
loadCachedId: function loadCachedId() {
var self = this;
if (AWS.util.isBrowser() && !self.params.IdentityId) {
var storage = window.localStorage;
var id = storage[self.localStorageKey.id];
if (id && self.params.Logins) {
var actualProviders = Object.keys(self.params.Logins);
var cachedProviders =
(storage[self.localStorageKey.providers] || '').split(',');
var intersect = cachedProviders.filter(function(n) {
return actualProviders.indexOf(n) !== -1;
});
if (intersect.length !== 0) {
self.params.IdentityId = id;
}
} else if (id) {
self.params.IdentityId = id;
}
}
},
cacheId: function cacheId(data) {
this.identityId = data.IdentityId;
this.params.IdentityId = this.identityId;
if (AWS.util.isBrowser()) {
var storage = window.localStorage;
storage[this.localStorageKey.id] = data.IdentityId;
if (this.params.Logins) {
storage[this.localStorageKey.providers] =
Object.keys(this.params.Logins).join(',');
}
}
}
});
},{"../core":3}],6:[function(require,module,exports){
var AWS = require('../core');
AWS.CredentialProviderChain = AWS.util.inherit(AWS.Credentials, {
constructor: function CredentialProviderChain(providers) {
if (providers) {
this.providers = providers;
} else {
this.providers = AWS.CredentialProviderChain.defaultProviders.slice(0);
}
},
resolve: function resolve(callback) {
if (this.providers.length === 0) {
callback(new Error('No providers'));
return this;
}
var index = 0;
var providers = this.providers.slice(0);
function resolveNext(err, creds) {
if ((!err && creds) || index === providers.length) {
callback(err, creds);
return;
}
var provider = providers[index++];
if (typeof provider === 'function') {
creds = provider.call();
} else {
creds = provider;
}
if (creds.get) {
creds.get(function(err) {
resolveNext(err, err ? null : creds);
});
} else {
resolveNext(null, creds);
}
}
resolveNext();
return this;
}
});
AWS.CredentialProviderChain.defaultProviders = [];
},{"../core":3}],7:[function(require,module,exports){
var AWS = require('../core');
AWS.SAMLCredentials = AWS.util.inherit(AWS.Credentials, {
constructor: function SAMLCredentials(params) {
AWS.Credentials.call(this);
this.expired = true;
this.params = params;
this.service = new AWS.STS({params: this.params});
},
refresh: function refresh(callback) {
var self = this;
if (!callback) callback = function(err) { if (err) throw err; };
self.service.assumeRoleWithSAML(function (err, data) {
if (!err) {
self.service.credentialsFrom(data, self);
}
callback(err);
});
}
});
},{"../core":3}],8:[function(require,module,exports){
var AWS = require('../core');
AWS.TemporaryCredentials = AWS.util.inherit(AWS.Credentials, {
constructor: function TemporaryCredentials(params) {
AWS.Credentials.call(this);
this.loadMasterCredentials();
this.expired = true;
this.params = params || {};
if (this.params.RoleArn) {
this.params.RoleSessionName =
this.params.RoleSessionName || 'temporary-credentials';
}
this.service = new AWS.STS({params: this.params});
},
refresh: function refresh(callback) {
var self = this;
if (!callback) callback = function(err) { if (err) throw err; };
self.service.config.credentials = self.masterCredentials;
var operation = self.params.RoleArn ?
self.service.assumeRole : self.service.getSessionToken;
operation.call(self.service, function (err, data) {
if (!err) {
self.service.credentialsFrom(data, self);
}
callback(err);
});
},
loadMasterCredentials: function loadMasterCredentials() {
this.masterCredentials = AWS.config.credentials;
while (this.masterCredentials.masterCredentials) {
this.masterCredentials = this.masterCredentials.masterCredentials;
}
}
});
},{"../core":3}],9:[function(require,module,exports){
var AWS = require('../core');
AWS.WebIdentityCredentials = AWS.util.inherit(AWS.Credentials, {
constructor: function WebIdentityCredentials(params) {
AWS.Credentials.call(this);
this.expired = true;
this.params = params;
this.params.RoleSessionName = this.params.RoleSessionName || 'web-identity';
this.service = new AWS.STS({params: this.params});
this.data = null;
},
refresh: function refresh(callback) {
var self = this;
if (!callback) callback = function(err) { if (err) throw err; };
self.service.assumeRoleWithWebIdentity(function (err, data) {
self.data = null;
if (!err) {
self.data = data;
self.service.credentialsFrom(data, self);
}
callback(err);
});
}
});
},{"../core":3}],10:[function(require,module,exports){
var AWS = require('./core');
var SequentialExecutor = require('./sequential_executor');
AWS.EventListeners = {
Core: {} /* doc hack */
};
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.error = AWS.util.error(err,
{code: 'CredentialsError', message: 'Missing credentials in config'});
}
done();
});
});
add('VALIDATE_REGION', 'validate', function VALIDATE_REGION(req) {
if (!req.service.config.region && !req.service.isGlobalEndpoint) {
req.response.error = AWS.util.error(new Error(),
{code: 'ConfigError', message: 'Missing region in config'});
}
});
add('VALIDATE_PARAMETERS', 'validate', function VALIDATE_PARAMETERS(req) {
var rules = req.service.api.operations[req.operation].input;
new AWS.ParamValidator().validate(rules, req.params);
});
add('SET_CONTENT_LENGTH', 'afterBuild', function SET_CONTENT_LENGTH(req) {
if (req.httpRequest.headers['Content-Length'] === undefined) {
var length = AWS.util.string.byteLength(req.httpRequest.body);
req.httpRequest.headers['Content-Length'] = length;
}
});
add('SET_HTTP_HOST', 'afterBuild', function SET_HTTP_HOST(req) {
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
req.service.config.getCredentials(function (err, credentials) {
if (err) {
req.response.error = err;
return done();
}
try {
var date = AWS.util.date.getDate();
var SignerClass = req.service.getSignerClass(req);
var signer = new SignerClass(req.httpRequest,
req.service.api.signingName || req.service.api.endpointPrefix);
delete req.httpRequest.headers['Authorization'];
delete req.httpRequest.headers['Date'];
delete req.httpRequest.headers['X-Amz-Date'];
signer.addAuthorization(credentials, date);
req.signedAt = date;
} catch (e) {
req.response.error = e;
}
done();
});
});
add('VALIDATE_RESPONSE', 'validateResponse', function VALIDATE_RESPONSE(resp) {
if (this.service.successfulResponse(resp, this)) {
resp.data = {};
resp.error = null;
} else {
resp.data = null;
resp.error = AWS.util.error(new Error(),
{code: 'UnknownError', message: 'An unknown error occurred.'});
}
});
addAsync('SEND', 'send', function SEND(resp, done) {
resp.httpResponse._abortCallback = done;
resp.error = null;
resp.data = null;
function callback(httpResp) {
resp.httpResponse.stream = httpResp;
httpResp.on('headers', function onHeaders(statusCode, headers) {
resp.request.emit('httpHeaders', [statusCode, headers, resp]);
if (!resp.request.httpRequest._streaming) {
if (AWS.HttpClient.streamsApiVersion === 2) { // streams2 API check
httpResp.on('readable', function onReadable() {
var data = httpResp.read();
if (data !== null) {
resp.request.emit('httpData', [data, resp]);
}
});
} else { // legacy streams API
httpResp.on('data', function onData(data) {
resp.request.emit('httpData', [data, resp]);
});
}
}
});
httpResp.on('end', function onEnd() {
resp.request.emit('httpDone');
done();
});
}
function progress(httpResp) {
httpResp.on('sendProgress', function onSendProgress(progress) {
resp.request.emit('httpUploadProgress', [progress, resp]);
});
httpResp.on('receiveProgress', function onReceiveProgress(progress) {
resp.request.emit('httpDownloadProgress', [progress, resp]);
});
}
function error(err) {
resp.error = AWS.util.error(err, {
code: 'NetworkingError',
region: resp.request.httpRequest.region,
hostname: resp.request.httpRequest.endpoint.hostname,
retryable: true
});
resp.request.emit('httpError', [resp.error, resp], function() {
done();
});
}
function executeSend() {
var http = AWS.HttpClient.getInstance();
var httpOptions = resp.request.service.config.httpOptions || {};
var stream = http.handleRequest(resp.request.httpRequest, httpOptions,
callback, error);
progress(stream);
}
var timeDiff = (AWS.util.date.getDate() - this.signedAt) / 1000;
if (timeDiff >= 60 * 10) { // if we signed 10min ago, re-sign
this.emit('sign', [this], function(err) {
if (err) done(err);
else executeSend();
});
} else {
executeSend();
}
});
add('HTTP_HEADERS', 'httpHeaders',
function HTTP_HEADERS(statusCode, headers, resp) {
resp.httpResponse.statusCode = statusCode;
resp.httpResponse.headers = headers;
resp.httpResponse.body = new AWS.util.Buffer('');
resp.httpResponse.buffers = [];
resp.httpResponse.numBytes = 0;
});
add('HTTP_DATA', 'httpData', function HTTP_DATA(chunk, resp) {
if (chunk) {
if (AWS.util.isNode()) {
resp.httpResponse.numBytes += chunk.length;
var total = resp.httpResponse.headers['content-length'];
var progress = { loaded: resp.httpResponse.numBytes, total: total };
resp.request.emit('httpDownloadProgress', [progress, resp]);
}
resp.httpResponse.buffers.push(new AWS.util.Buffer(chunk));
}
});
add('HTTP_DONE', 'httpDone', function HTTP_DONE(resp) {
if (resp.httpResponse.buffers && resp.httpResponse.buffers.length > 0) {
var body = AWS.util.buffer.concat(resp.httpResponse.buffers);
resp.httpResponse.body = body;
}
delete resp.httpResponse.numBytes;
delete resp.httpResponse.buffers;
});
add('FINALIZE_ERROR', 'retry', function FINALIZE_ERROR(resp) {
if (resp.httpResponse.statusCode) {
resp.error.statusCode = resp.httpResponse.statusCode;
if (resp.error.retryable === undefined) {
resp.error.retryable = this.service.retryableError(resp.error, this);
}
}
});
add('INVALIDATE_CREDENTIALS', 'retry', function INVALIDATE_CREDENTIALS(resp) {
if (!resp.error) return;
switch (resp.error.code) {
case 'RequestExpired': // EC2 only
case 'ExpiredTokenException':
case 'ExpiredToken':
resp.error.retryable = true;
resp.request.service.config.credentials.expired = true;
}
});
add('REDIRECT', 'retry', function REDIRECT(resp) {
if (resp.error && resp.error.statusCode >= 300 &&
resp.error.statusCode < 400 && resp.httpResponse.headers['location']) {
this.httpRequest.endpoint =
new AWS.Endpoint(resp.httpResponse.headers['location']);
resp.error.redirect = true;
resp.error.retryable = true;
}
});
add('RETRY_CHECK', 'retry', function RETRY_CHECK(resp) {
if (resp.error) {
if (resp.error.redirect && resp.redirectCount < resp.maxRedirects) {
resp.error.retryDelay = 0;
} else if (resp.error.retryable && resp.retryCount < resp.maxRetries) {
var delays = this.service.retryDelays();
resp.error.retryDelay = delays[resp.retryCount] || 0;
}
}
});
addAsync('RESET_RETRY_STATE', 'afterRetry', function RESET_RETRY_STATE(resp, done) {
var delay, willRetry = false;
if (resp.error) {
delay = resp.error.retryDelay || 0;
if (resp.error.retryable && resp.retryCount < resp.maxRetries) {
resp.retryCount++;
willRetry = true;
} else if (resp.error.redirect && resp.redirectCount < resp.maxRedirects) {
resp.redirectCount++;
willRetry = true;
}
}
if (willRetry) {
resp.error = null;
setTimeout(done, delay);
} else {
done();
}
});
}),
CorePost: new SequentialExecutor().addNamedListeners(function(add) {
add('EXTRACT_REQUEST_ID', 'extractData', function EXTRACT_REQUEST_ID(resp) {
resp.requestId = resp.httpResponse.headers['x-amz-request-id'] ||
resp.httpResponse.headers['x-amzn-requestid'];
if (!resp.requestId && resp.data && resp.data.ResponseMetadata) {
resp.requestId = resp.data.ResponseMetadata.RequestId;
}
});
}),
Logger: new SequentialExecutor().addNamedListeners(function(add) {
add('LOG_REQUEST', 'complete', function LOG_REQUEST(resp) {
var req = resp.request;
var logger = req.service.config.logger;
if (!logger) return;
function buildMessage() {
var time = AWS.util.date.getDate().getTime();
var delta = (time - req.startTime.getTime()) / 1000;
var ansi = logger.isTTY ? true : false;
var status = resp.httpResponse.statusCode;
var params = require('util').inspect(req.params, true, true);
var message = '';
if (ansi) message += '\x1B[33m';
message += '[AWS ' + req.service.serviceIdentifier + ' ' + status;
message += ' ' + delta.toString() + 's ' + resp.retryCount + ' retries]';
if (ansi) message += '\x1B[0;1m';
message += ' ' + AWS.util.string.lowerFirst(req.operation);
message += '(' + params + ')';
if (ansi) message += '\x1B[0m';
return message;
}
var line = buildMessage();
if (typeof logger.log === 'function') {
logger.log(line);
} else if (typeof logger.write === 'function') {
logger.write(line + '\n');
}
});
}),
Json: new SequentialExecutor().addNamedListeners(function(add) {
var svc = require('./protocol/json');
add('BUILD', 'build', svc.buildRequest);
add('EXTRACT_DATA', 'extractData', svc.extractData);
add('EXTRACT_ERROR', 'extractError', svc.extractError);
}),
Rest: new SequentialExecutor().addNamedListeners(function(add) {
var svc = require('./protocol/rest');
add('BUILD', 'build', svc.buildRequest);
add('EXTRACT_DATA', 'extractData', svc.extractData);
add('EXTRACT_ERROR', 'extractError', svc.extractError);
}),
RestJson: new SequentialExecutor().addNamedListeners(function(add) {
var svc = require('./protocol/rest_json');
add('BUILD', 'build', svc.buildRequest);
add('EXTRACT_DATA', 'extractData', svc.extractData);
add('EXTRACT_ERROR', 'extractError', svc.extractError);
}),
RestXml: new SequentialExecutor().addNamedListeners(function(add) {
var svc = require('./protocol/rest_xml');
add('BUILD', 'build', svc.buildRequest);
add('EXTRACT_DATA', 'extractData', svc.extractData);
add('EXTRACT_ERROR', 'extractError', svc.extractError);
}),
Query: new SequentialExecutor().addNamedListeners(function(add) {
var svc = require('./protocol/query');
add('BUILD', 'build', svc.buildRequest);
add('EXTRACT_DATA', 'extractData', svc.extractData);
add('EXTRACT_ERROR', 'extractError', svc.extractError);
})
};
},{"./core":3,"./protocol/json":22,"./protocol/query":23,"./protocol/rest":24,"./protocol/rest_json":25,"./protocol/rest_xml":26,"./sequential_executor":33,"util":64}],11:[function(require,module,exports){
var AWS = require('./core');
var inherit = AWS.util.inherit;
AWS.Endpoint = inherit({
constructor: function Endpoint(endpoint, config) {
AWS.util.hideProperties(this, ['slashes', 'auth', 'hash', 'search', 'query']);
if (typeof endpoint === 'undefined' || endpoint === null) {
throw new Error('Invalid endpoint: ' + endpoint);
} else if (typeof endpoint !== 'string') {
return AWS.util.copy(endpoint);
}
if (!endpoint.match(/^http/)) {
var useSSL = config && config.sslEnabled !== undefined ?
config.sslEnabled : AWS.config.sslEnabled;
endpoint = (useSSL ? 'https' : 'http') + '://' + endpoint;
}
AWS.util.update(this, AWS.util.urlParse(endpoint));
if (this.port) {
this.port = parseInt(this.port, 10);
} else {
this.port = this.protocol === 'https:' ? 443 : 80;
}
}
});
AWS.HttpRequest = inherit({
constructor: function HttpRequest(endpoint, region) {
endpoint = new AWS.Endpoint(endpoint);
this.method = 'POST';
this.path = endpoint.path || '/';
this.headers = {};
this.body = '';
this.endpoint = endpoint;
this.region = region;
this.setUserAgent();
},
setUserAgent: function setUserAgent() {
var prefix = AWS.util.isBrowser() ? 'X-Amz-' : '';
this.headers[prefix + 'User-Agent'] = AWS.util.userAgent();
},
pathname: function pathname() {
return this.path.split('?', 1)[0];
},
search: function search() {
return this.path.split('?', 2)[1] || '';
}
});
AWS.HttpResponse = inherit({
constructor: function HttpResponse() {
this.statusCode = undefined;
this.headers = {};
this.body = undefined;
}
});
AWS.HttpClient = inherit({});
AWS.HttpClient.getInstance = function getInstance() {
if (this.singleton === undefined) {
this.singleton = new this();
}
return this.singleton;
};
},{"./core":3}],12:[function(require,module,exports){
var AWS = require('../core');
var EventEmitter = require('events').EventEmitter;
require('../http');
AWS.XHRClient = AWS.util.inherit({
handleRequest: function handleRequest(httpRequest, httpOptions, callback, errCallback) {
var self = this;
var endpoint = httpRequest.endpoint;
var emitter = new EventEmitter();
var href = endpoint.protocol + '//' + endpoint.hostname;
if (endpoint.port !== 80 && endpoint.port !== 443) {
href += ':' + endpoint.port;
}
href += httpRequest.path;
var xhr = new XMLHttpRequest(), headersEmitted = false;
httpRequest.stream = xhr;
if (httpOptions.timeout) {
xhr.timeout = httpOptions.timeout;
}
if (httpOptions.xhrWithCredentials) {
xhr.withCredentials = true;
}
xhr.addEventListener('readystatechange', function() {
try {
if (xhr.status === 0) return; // 0 code is invalid
} catch (e) { return; }
if (this.readyState >= this.HEADERS_RECEIVED && !headersEmitted) {
try { xhr.responseType = 'arraybuffer'; } catch (e) {}
emitter.statusCode = xhr.status;
emitter.headers = self.parseHeaders(xhr.getAllResponseHeaders());
emitter.emit('headers', emitter.statusCode, emitter.headers);
headersEmitted = true;
}
if (this.readyState === this.DONE) {
self.finishRequest(xhr, emitter);
}
}, false);
xhr.upload.addEventListener('progress', function (evt) {
emitter.emit('sendProgress', evt);
});
xhr.addEventListener('progress', function (evt) {
emitter.emit('receiveProgress', evt);
}, false);
xhr.addEventListener('timeout', function () {
errCallback(AWS.util.error(new Error('Timeout'), {code: 'TimeoutError'}));
}, false);
xhr.addEventListener('error', function () {
errCallback(AWS.util.error(new Error('Network Failure'), {
code: 'NetworkingError'
}));
}, false);
callback(emitter);
xhr.open(httpRequest.method, href, httpOptions.xhrAsync !== false);
AWS.util.each(httpRequest.headers, function (key, value) {
if (key !== 'Content-Length' && key !== 'User-Agent' && key !== 'Host') {
xhr.setRequestHeader(key, value);
}
});
if (httpRequest.body && typeof httpRequest.body.buffer === 'object') {
xhr.send(httpRequest.body.buffer); // typed arrays sent as ArrayBuffer
} else {
xhr.send(httpRequest.body);
}
return emitter;
},
parseHeaders: function parseHeaders(rawHeaders) {
var headers = {};
AWS.util.arrayEach(rawHeaders.split(/\r?\n/), function (line) {
var key = line.split(':', 1)[0];
var value = line.substring(key.length + 2);
if (key.length > 0) headers[key] = value;
});
return headers;
},
finishRequest: function finishRequest(xhr, emitter) {
var buffer;
if (xhr.responseType === 'arraybuffer' && xhr.response) {
var ab = xhr.response;
buffer = new AWS.util.Buffer(ab.byteLength);
var view = new Uint8Array(ab);
for (var i = 0; i < buffer.length; ++i) {
buffer[i] = view[i];
}
}
try {
if (!buffer && typeof xhr.responseText === 'string') {
buffer = new AWS.util.Buffer(xhr.responseText);
}
} catch (e) {}
if (buffer) emitter.emit('data', buffer);
emitter.emit('end');
}
});
AWS.HttpClient.prototype = AWS.XHRClient.prototype;
AWS.HttpClient.streamsApiVersion = 1;
},{"../core":3,"../http":11,"events":55}],13:[function(require,module,exports){
var util = require('../util');
function JsonBuilder() { }
JsonBuilder.prototype.build = function(value, shape) {
return JSON.stringify(translate(value, shape));
};
function translate(value, shape) {
if (!shape || value === undefined || value === null) return undefined;
switch (shape.type) {
case 'structure': return translateStructure(value, shape);
case 'map': return translateMap(value, shape);
case 'list': return translateList(value, shape);
default: return translateScalar(value, shape);
}
}
function translateStructure(structure, shape) {
var struct = {};
util.each(structure, function(name, value) {
var memberShape = shape.members[name];
if (memberShape) {
if (memberShape.location !== 'body') return;
var result = translate(value, memberShape);
if (result !== undefined) struct[name] = result;
}
});
return struct;
}
function translateList(list, shape) {
var out = [];
util.arrayEach(list, function(value) {
var result = translate(value, shape.member);
if (result !== undefined) out.push(result);
});
return out;
}
function translateMap(map, shape) {
var out = {};
util.each(map, function(key, value) {
var result = translate(value, shape.value);
if (result !== undefined) out[key] = result;
});
return out;
}
function translateScalar(value, shape) {
return shape.toWireFormat(value);
}
module.exports = JsonBuilder;
},{"../util":43}],14:[function(require,module,exports){
var util = require('../util');
function JsonParser() { }
JsonParser.prototype.parse = function(value, shape) {
return translate(JSON.parse(value), shape);
};
function translate(value, shape) {
if (!shape || value === undefined || value === null) return undefined;
switch (shape.type) {
case 'structure': return translateStructure(value, shape);
case 'map': return translateMap(value, shape);
case 'list': return translateList(value, shape);
default: return translateScalar(value, shape);
}
}
function translateStructure(structure, shape) {
var struct = {};
util.each(structure, function(name, value) {
var memberShape = shape.members[name];
if (memberShape) {
var result = translate(value, memberShape);
if (result !== undefined) struct[name] = result;
}
});
return struct;
}
function translateList(list, shape) {
var out = [];
util.arrayEach(list, function(value) {
var result = translate(value, shape.member);
if (result !== undefined) out.push(result);
});
return out;
}
function translateMap(map, shape) {
var out = {};
util.each(map, function(key, value) {
var result = translate(value, shape.value);
if (result !== undefined) out[key] = result;
});
return out;
}
function translateScalar(value, shape) {
return shape.toType(value);
}
module.exports = JsonParser;
},{"../util":43}],15:[function(require,module,exports){
var Collection = require('./collection');
var Operation = require('./operation');
var Shape = require('./shape');
var Paginator = require('./paginator');
var ResourceWaiter = require('./resource_waiter');
var util = require('../util');
var property = util.property;
var memoizedProperty = util.memoizedProperty;
function Api(api, options) {
api = api || {};
options = options || {};
options.api = this;
api.metadata = api.metadata || {};
property(this, 'isApi', true, false);
property(this, 'apiVersion', api.metadata.apiVersion);
property(this, 'endpointPrefix', api.metadata.endpointPrefix);
property(this, 'signingName', api.metadata.signingName);
property(this, 'globalEndpoint', api.metadata.globalEndpoint);
property(this, 'signatureVersion', api.metadata.signatureVersion);
property(this, 'jsonVersion', api.metadata.jsonVersion);
property(this, 'targetPrefix', api.metadata.targetPrefix);
property(this, 'protocol', api.metadata.protocol);
property(this, 'timestampFormat', api.metadata.timestampFormat);
property(this, 'xmlNamespaceUri', api.metadata.xmlNamespace);
property(this, 'abbreviation', api.metadata.serviceAbbreviation);
property(this, 'fullName', api.metadata.serviceFullName);
memoizedProperty(this, 'className', function() {
var name = api.metadata.serviceAbbreviation || api.metadata.serviceFullName;
if (!name) return null;
name = name.replace(/^Amazon|AWS\s*|\(.*|\s+|\W+/g, '');
if (name === 'ElasticLoadBalancing') name = 'ELB';
return name;
});
property(this, 'operations', new Collection(api.operations, options, function(name, operation) {
return new Operation(name, operation, options);
}, util.string.lowerFirst));
property(this, 'shapes', new Collection(api.shapes, options, function(name, shape) {
return Shape.create(shape, options);
}));
property(this, 'paginators', new Collection(api.paginators, options, function(name, paginator) {
return new Paginator(name, paginator, options);
}));
property(this, 'waiters', new Collection(api.waiters, options, function(name, waiter) {
return new ResourceWaiter(name, waiter, options);
}, util.string.lowerFirst));
if (options.documentation) {
property(this, 'documentation', api.documentation);
property(this, 'documentationUrl', api.documentationUrl);
}
}
module.exports = Api;
},{"../util":43,"./collection":16,"./operation":17,"./paginator":18,"./resource_waiter":19,"./shape":20}],16:[function(require,module,exports){
var memoizedProperty = require('../util').memoizedProperty;
function Collection(iterable, options, fn, nameTr) {
nameTr = nameTr || String;
var self = this;
for (var id in iterable) {
if (iterable.hasOwnProperty(id)) {
(function(name) {
memoizedProperty(self, nameTr(name), function() {
return fn(name, iterable[name]);
});
})(id);
}
}
}
module.exports = Collection;
},{"../util":43}],17:[function(require,module,exports){
var Shape = require('./shape');
var util = require('../util');
var property = util.property;
var memoizedProperty = util.memoizedProperty;
function Operation(name, operation, options) {
options = options || {};
property(this, 'name', name);
property(this, 'api', options.api, false);
operation.http = operation.http || {};
property(this, 'httpMethod', operation.http.method || 'POST');
property(this, 'httpPath', operation.http.requestUri || '/');
memoizedProperty(this, 'input', function() {
if (!operation.input) {
return new Shape.create({type: 'structure'}, options);
}
return Shape.create(operation.input, options);
});
memoizedProperty(this, 'output', function() {
if (!operation.output) {
return new Shape.create({type: 'structure'}, options);
}
return Shape.create(operation.output, options);
});
memoizedProperty(this, 'errors', function() {
var list = [];
if (!operation.errors) return null;
for (var i = 0; i < operation.errors.length; i++) {
list.push(Shape.create(operation.errors[i], options));
}
return list;
});
memoizedProperty(this, 'paginator', function() {
return options.api.paginators[name];
});
if (options.documentation) {
property(this, 'documentation', operation.documentation);
property(this, 'documentationUrl', operation.documentationUrl);
}
}
module.exports = Operation;
},{"../util":43,"./shape":20}],18:[function(require,module,exports){
var property = require('../util').property;
function Paginator(name, paginator) {
property(this, 'inputToken', paginator.input_token);
property(this, 'limitKey', paginator.limit_key);
property(this, 'moreResults', paginator.more_results);
property(this, 'outputToken', paginator.output_token);
property(this, 'resultKey', paginator.result_key);
}
module.exports = Paginator;
},{"../util":43}],19:[function(require,module,exports){
var util = require('../util');
var property = util.property;
function ResourceWaiter(name, waiter, options) {
options = options || {};
function InnerResourceWaiter() {
property(this, 'name', name);
property(this, 'api', options.api, false);
if (waiter.operation) {
property(this, 'operation', util.string.lowerFirst(waiter.operation));
}
var self = this, map = {
ignoreErrors: 'ignore_errors',
successType: 'success_type',
successValue: 'success_value',
successPath: 'success_path',
acceptorType: 'acceptor_type',
acceptorValue: 'acceptor_value',
acceptorPath: 'acceptor_path',
failureType: 'failure_type',
failureValue: 'failure_value',
failurePath: 'success_path',
interval: 'interval',
maxAttempts: 'max_attempts'
};
Object.keys(map).forEach(function(key) {
var value = waiter[map[key]];
if (value) property(self, key, value);
});
}
if (options.api) {
var proto = null;
if (waiter['extends']) {
proto = options.api.waiters[waiter['extends']];
} else if (name !== '__default__') {
proto = options.api.waiters['__default__'];
}
if (proto) InnerResourceWaiter.prototype = proto;
}
return new InnerResourceWaiter();
}
module.exports = ResourceWaiter;
},{"../util":43}],20:[function(require,module,exports){
var Collection = require('./collection');
var util = require('../util');
function property(obj, name, value) {
if (value !== null && value !== undefined) {
util.property.apply(this, arguments);
}
}
function memoizedProperty(obj, name) {
if (!obj.constructor.prototype[name]) {
util.memoizedProperty.apply(this, arguments);
}
}
function Shape(shape, options, memberName) {
options = options || {};
property(this, 'shape', shape.shape);
property(this, 'api', options.api, false);
property(this, 'type', shape.type);
property(this, 'location', shape.location || 'body');
property(this, 'name', this.name || shape.xmlName || shape.locationName ||
memberName);
property(this, 'isStreaming', shape.streaming || false);
property(this, 'isComposite', shape.isComposite || false);
property(this, 'isShape', true, false);
if (options.documentation) {
property(this, 'documentation', shape.documentation);
property(this, 'documentationUrl', shape.documentationUrl);
}
if (shape.xmlAttribute) {
property(this, 'isXmlAttribute', shape.xmlAttribute || false);
}
property(this, 'defaultValue', null);
this.toWireFormat = function(value) {
if (value === null || value === undefined) return '';
return value;
};
this.toType = function(value) { return value; };
}
Shape.normalizedTypes = {
character: 'string',
double: 'float',
long: 'integer',
short: 'integer',
biginteger: 'integer',
bigdecimal: 'float',
blob: 'binary'
};
Shape.types = {
'structure': StructureShape,
'list': ListShape,
'map': MapShape,
'boolean': BooleanShape,
'timestamp': TimestampShape,
'float': FloatShape,
'integer': IntegerShape,
'string': StringShape,
'base64': Base64Shape,
'binary': BinaryShape
};
Shape.resolve = function resolve(shape, options) {
if (shape.shape) {
var refShape = options.api.shapes[shape.shape];
if (!refShape) {
throw new Error('Cannot find shape reference: ' + shape.shape);
}
return refShape;
} else {
return null;
}
};
Shape.create = function create(shape, options, memberName) {
if (shape.isShape) return shape;
var refShape = Shape.resolve(shape, options);
if (refShape) {
var filteredKeys = Object.keys(shape);
if (!options.documentation) {
filteredKeys = filteredKeys.filter(function(name) {
return !name.match(/documentation/);
});
}
if (filteredKeys === ['shape']) { // no inline customizations
return refShape;
}
var InlineShape = function() {
refShape.constructor.call(this, shape, options, memberName);
};
InlineShape.prototype = refShape;
return new InlineShape();
} else {
if (!shape.type) {
if (shape.members) shape.type = 'structure';
else if (shape.member) shape.type = 'list';
else if (shape.key) shape.type = 'map';
else shape.type = 'string';
}
var origType = shape.type;
if (Shape.normalizedTypes[shape.type]) {
shape.type = Shape.normalizedTypes[shape.type];
}
if (Shape.types[shape.type]) {
return new Shape.types[shape.type](shape, options, memberName);
} else {
throw new Error('Unrecognized shape type: ' + origType);
}
}
};
function CompositeShape(shape) {
Shape.apply(this, arguments);
property(this, 'isComposite', true);
if (shape.flattened) {
property(this, 'flattened', shape.flattened || false);
}
}
function StructureShape(shape, options) {
var requiredMap = null, firstInit = !this.isShape;
CompositeShape.apply(this, arguments);
if (firstInit) {
property(this, 'defaultValue', function() { return {}; });
property(this, 'members', {});
property(this, 'memberNames', []);
property(this, 'required', []);
property(this, 'isRequired', function(name) { return false; });
}
if (shape.members) {
property(this, 'members', new Collection(shape.members, options, function(name, member) {
return Shape.create(member, options, name);
}));
memoizedProperty(this, 'memberNames', function() {
return shape.xmlOrder || Object.keys(shape.members);
});
}
if (shape.required) {
property(this, 'required', shape.required);
property(this, 'isRequired', function(name) {
if (!requiredMap) {
requiredMap = {};
for (var i = 0; i < shape.required.length; i++) {
requiredMap[shape.required[i]] = true;
}
}
return requiredMap[name];
}, false, true);
}
property(this, 'resultWrapper', shape.resultWrapper || null);
if (shape.payload) {
property(this, 'payload', shape.payload);
}
if (typeof shape.xmlNamespace === 'string') {
property(this, 'xmlNamespaceUri', shape.xmlNamespace);
} else if (typeof shape.xmlNamespace === 'object') {
property(this, 'xmlNamespacePrefix', shape.xmlNamespace.prefix);
property(this, 'xmlNamespaceUri', shape.xmlNamespace.uri);
}
}
function ListShape(shape, options) {
var self = this, firstInit = !this.isShape;
CompositeShape.apply(this, arguments);
if (firstInit) {
property(this, 'defaultValue', function() { return []; });
}
if (shape.member) {
memoizedProperty(this, 'member', function() {
return Shape.create(shape.member, options);
});
}
if (this.flattened) {
var oldName = this.name;
memoizedProperty(this, 'name', function() {
return self.member.name || oldName;
});
}
}
function MapShape(shape, options) {
var firstInit = !this.isShape;
CompositeShape.apply(this, arguments);
if (firstInit) {
property(this, 'defaultValue', function() { return {}; });
property(this, 'key', Shape.create({type: 'string'}, options));
property(this, 'value', Shape.create({type: 'string'}, options));
}
if (shape.key) {
memoizedProperty(this, 'key', function() {
return Shape.create(shape.key, options);
});
}
if (shape.value) {
memoizedProperty(this, 'value', function() {
return Shape.create(shape.value, options);
});
}
}
function TimestampShape(shape) {
var self = this;
Shape.apply(this, arguments);
if (shape.timestampFormat) {
property(this, 'timestampFormat', shape.timestampFormat);
} else if (this.api) {
property(this, 'timestampFormat', this.api.timestampFormat);
}
this.toType = function(value) {
if (value === null || value === undefined) return null;
if (typeof value.toUTCString === 'function') return value;
return typeof value === 'string' || typeof value === 'number' ?
util.date.parseTimestamp(value) : null;
};
this.toWireFormat = function(value) {
return util.date.format(value, self.timestampFormat);
};
}
function StringShape() {
Shape.apply(this, arguments);
}
function FloatShape() {
Shape.apply(this, arguments);
this.toType = function(value) {
if (value === null || value === undefined) return null;
return parseFloat(value);
};
this.toWireFormat = this.toType;
}
function IntegerShape() {
Shape.apply(this, arguments);
this.toType = function(value) {
if (value === null || value === undefined) return null;
return parseInt(value, 10);
};
this.toWireFormat = this.toType;
}
function BinaryShape() {
Shape.apply(this, arguments);
this.toType = util.base64.decode;
this.toWireFormat = util.base64.encode;
}
function Base64Shape() {
BinaryShape.apply(this, arguments);
}
function BooleanShape() {
Shape.apply(this, arguments);
this.toType = function(value) {
if (typeof value === 'boolean') return value;
if (value === null || value === undefined) return null;
return value === 'true';
};
}
Shape.shapes = {
StructureShape: StructureShape,
ListShape: ListShape,
MapShape: