sumomo 0.5.2 → 0.6.0

data/data/sumomo/api_modules/node_modules/aws-sdk/lib/http.js

@@ -0,0 +1,226 @@
+var AWS = require('./core');
+var inherit = AWS.util.inherit;
+
+/**
+ * The endpoint that a service will talk to, for example,
+ * `'https://ec2.ap-southeast-1.amazonaws.com'`. If
+ * you need to override an endpoint for a service, you can
+ * set the endpoint on a service by passing the endpoint
+ * object with the `endpoint` option key:
+ *
+ * ```javascript
+ * var ep = new AWS.Endpoint('awsproxy.example.com');
+ * var s3 = new AWS.S3({endpoint: ep});
+ * s3.service.endpoint.hostname == 'awsproxy.example.com'
+ * ```
+ *
+ * Note that if you do not specify a protocol, the protocol will
+ * be selected based on your current {AWS.config} configuration.
+ *
+ * @!attribute protocol
+ *   @return [String] the protocol (http or https) of the endpoint
+ *     URL
+ * @!attribute hostname
+ *   @return [String] the host portion of the endpoint, e.g.,
+ *     example.com
+ * @!attribute host
+ *   @return [String] the host portion of the endpoint including
+ *     the port, e.g., example.com:80
+ * @!attribute port
+ *   @return [Integer] the port of the endpoint
+ * @!attribute href
+ *   @return [String] the full URL of the endpoint
+ */
+AWS.Endpoint = inherit({
+
+  /**
+   * @overload Endpoint(endpoint)
+   *   Constructs a new endpoint given an endpoint URL. If the
+   *   URL omits a protocol (http or https), the default protocol
+   *   set in the global {AWS.config} will be used.
+   *   @param endpoint [String] the URL to construct an endpoint from
+   */
+  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));
+
+    // Ensure the port property is set as an integer
+    if (this.port) {
+      this.port = parseInt(this.port, 10);
+    } else {
+      this.port = this.protocol === 'https:' ? 443 : 80;
+    }
+  }
+
+});
+
+/**
+ * The low level HTTP request object, encapsulating all HTTP header
+ * and body data sent by a service request.
+ *
+ * @!attribute method
+ *   @return [String] the HTTP method of the request
+ * @!attribute path
+ *   @return [String] the path portion of the URI, e.g.,
+ *     "/list/?start=5&num=10"
+ * @!attribute headers
+ *   @return [map<String,String>]
+ *     a map of header keys and their respective values
+ * @!attribute body
+ *   @return [String] the request body payload
+ * @!attribute endpoint
+ *   @return [AWS.Endpoint] the endpoint for the request
+ * @!attribute region
+ *   @api private
+ *   @return [String] the region, for signing purposes only.
+ */
+AWS.HttpRequest = inherit({
+
+  /**
+   * @api private
+   */
+  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._userAgent = '';
+    this.setUserAgent();
+  },
+
+  /**
+   * @api private
+   */
+  setUserAgent: function setUserAgent() {
+    this._userAgent = this.headers[this.getUserAgentHeaderName()] = AWS.util.userAgent();
+  },
+
+  getUserAgentHeaderName: function getUserAgentHeaderName() {
+    var prefix = AWS.util.isBrowser() ? 'X-Amz-' : '';
+    return prefix + 'User-Agent';
+  },
+
+  /**
+   * @api private
+   */
+  appendToUserAgent: function appendToUserAgent(agentPartial) {
+    if (typeof agentPartial === 'string' && agentPartial) {
+      this._userAgent += ' ' + agentPartial;
+    }
+    this.headers[this.getUserAgentHeaderName()] = this._userAgent;
+  },
+
+  /**
+   * @api private
+   */
+  getUserAgent: function getUserAgent() {
+    return this._userAgent;
+  },
+
+  /**
+   * @return [String] the part of the {path} excluding the
+   *   query string
+   */
+  pathname: function pathname() {
+    return this.path.split('?', 1)[0];
+  },
+
+  /**
+   * @return [String] the query string portion of the {path}
+   */
+  search: function search() {
+    var query = this.path.split('?', 2)[1];
+    if (query) {
+      query = AWS.util.queryStringParse(query);
+      return AWS.util.queryParamsToString(query);
+    }
+    return '';
+  }
+
+});
+
+/**
+ * The low level HTTP response object, encapsulating all HTTP header
+ * and body data returned from the request.
+ *
+ * @!attribute statusCode
+ *   @return [Integer] the HTTP status code of the response (e.g., 200, 404)
+ * @!attribute headers
+ *   @return [map<String,String>]
+ *      a map of response header keys and their respective values
+ * @!attribute body
+ *   @return [String] the response body payload
+ * @!attribute [r] streaming
+ *   @return [Boolean] whether this response is being streamed at a low-level.
+ *     Defaults to `false` (buffered reads). Do not modify this manually, use
+ *     {createUnbufferedStream} to convert the stream to unbuffered mode
+ *     instead.
+ */
+AWS.HttpResponse = inherit({
+
+  /**
+   * @api private
+   */
+  constructor: function HttpResponse() {
+    this.statusCode = undefined;
+    this.headers = {};
+    this.body = undefined;
+    this.streaming = false;
+    this.stream = null;
+  },
+
+  /**
+   * Disables buffering on the HTTP response and returns the stream for reading.
+   * @return [Stream, XMLHttpRequest, null] the underlying stream object.
+   *   Use this object to directly read data off of the stream.
+   * @note This object is only available after the {AWS.Request~httpHeaders}
+   *   event has fired. This method must be called prior to
+   *   {AWS.Request~httpData}.
+   * @example Taking control of a stream
+   *   request.on('httpHeaders', function(statusCode, headers) {
+   *     if (statusCode < 300) {
+   *       if (headers.etag === 'xyz') {
+   *         // pipe the stream, disabling buffering
+   *         var stream = this.response.httpResponse.createUnbufferedStream();
+   *         stream.pipe(process.stdout);
+   *       } else { // abort this request and set a better error message
+   *         this.abort();
+   *         this.response.error = new Error('Invalid ETag');
+   *       }
+   *     }
+   *   }).send(console.log);
+   */
+  createUnbufferedStream: function createUnbufferedStream() {
+    this.streaming = true;
+    return this.stream;
+  }
+});
+
+
+AWS.HttpClient = inherit({});
+
+/**
+ * @api private
+ */
+AWS.HttpClient.getInstance = function getInstance() {
+  if (this.singleton === undefined) {
+    this.singleton = new this();
+  }
+  return this.singleton;
+};

data/data/sumomo/api_modules/node_modules/aws-sdk/lib/http/node.js

@@ -0,0 +1,196 @@
+var AWS = require('../core');
+var Stream = AWS.util.stream.Stream;
+var TransformStream = AWS.util.stream.Transform;
+var ReadableStream = AWS.util.stream.Readable;
+require('../http');
+
+/**
+ * @api private
+ */
+AWS.NodeHttpClient = AWS.util.inherit({
+  handleRequest: function handleRequest(httpRequest, httpOptions, callback, errCallback) {
+    var self = this;
+    var endpoint = httpRequest.endpoint;
+    var pathPrefix = '';
+    if (!httpOptions) httpOptions = {};
+    if (httpOptions.proxy) {
+      pathPrefix = endpoint.protocol + '//' + endpoint.hostname;
+      if (endpoint.port !== 80 && endpoint.port !== 443) {
+        pathPrefix += ':' + endpoint.port;
+      }
+      endpoint = new AWS.Endpoint(httpOptions.proxy);
+    }
+
+    var useSSL = endpoint.protocol === 'https:';
+    var http = useSSL ? require('https') : require('http');
+    var options = {
+      host: endpoint.hostname,
+      port: endpoint.port,
+      method: httpRequest.method,
+      headers: httpRequest.headers,
+      path: pathPrefix + httpRequest.path
+    };
+
+    if (useSSL && !httpOptions.agent) {
+      options.agent = this.sslAgent();
+    }
+
+    AWS.util.update(options, httpOptions);
+    delete options.proxy; // proxy isn't an HTTP option
+    delete options.timeout; // timeout isn't an HTTP option
+
+    var stream = http.request(options, function (httpResp) {
+      if (stream.didCallback) return;
+
+      callback(httpResp);
+      httpResp.emit(
+        'headers',
+        httpResp.statusCode,
+        httpResp.headers,
+        httpResp.statusMessage
+      );
+    });
+    httpRequest.stream = stream; // attach stream to httpRequest
+    stream.didCallback = false;
+
+    // connection timeout support
+    if (httpOptions.connectTimeout) {
+      stream.on('socket', function(socket) {
+        if (socket.connecting) {
+          var timeoutId = setTimeout(function connectTimeout() {
+            if (stream.didCallback) return; stream.didCallback = true;
+
+            stream.abort();
+            errCallback(AWS.util.error(
+              new Error('Socket timed out without establishing a connection'),
+              {code: 'TimeoutError'}
+            ));
+          }, httpOptions.connectTimeout);
+          socket.on('connect', (function(tId) {
+            return function () {
+              clearTimeout(tId);
+            };
+          })(timeoutId));
+        }
+      });
+    }
+
+    // timeout support
+    stream.setTimeout(httpOptions.timeout || 0, function() {
+      if (stream.didCallback) return; stream.didCallback = true;
+
+      var msg = 'Connection timed out after ' + httpOptions.timeout + 'ms';
+      errCallback(AWS.util.error(new Error(msg), {code: 'TimeoutError'}));
+      stream.abort();
+    });
+
+    stream.on('error', function() {
+      if (stream.didCallback) return; stream.didCallback = true;
+      errCallback.apply(stream, arguments);
+    });
+
+    var expect = httpRequest.headers.Expect || httpRequest.headers.expect;
+    if (expect === '100-continue') {
+      stream.on('continue', function() {
+        self.writeBody(stream, httpRequest);
+      });
+    } else {
+      this.writeBody(stream, httpRequest);
+    }
+
+    return stream;
+  },
+
+  writeBody: function writeBody(stream, httpRequest) {
+    var body = httpRequest.body;
+    var totalBytes = parseInt(httpRequest.headers['Content-Length'], 10);
+
+    if (body instanceof Stream) {
+      // For progress support of streaming content -
+      // pipe the data through a transform stream to emit 'sendProgress' events
+      var progressStream = this.progressStream(stream, totalBytes);
+      if (progressStream) {
+        body.pipe(progressStream).pipe(stream);
+      } else {
+        body.pipe(stream);
+      }
+    } else if (body) {
+      // The provided body is a buffer/string and is already fully available in memory -
+      // For performance it's best to send it as a whole by calling stream.end(body),
+      // Callers expect a 'sendProgress' event which is best emitted once
+      // the http request stream has been fully written and all data flushed.
+      // The use of totalBytes is important over body.length for strings where
+      // length is char length and not byte length.
+      stream.once('finish', function() {
+        stream.emit('sendProgress', {
+          loaded: totalBytes,
+          total: totalBytes
+        });
+      });
+      stream.end(body);
+    } else {
+      // no request body
+      stream.end();
+    }
+  },
+
+  sslAgent: function sslAgent() {
+    var https = require('https');
+
+    if (!AWS.NodeHttpClient.sslAgent) {
+      AWS.NodeHttpClient.sslAgent = new https.Agent({rejectUnauthorized: true});
+      AWS.NodeHttpClient.sslAgent.setMaxListeners(0);
+
+      // delegate maxSockets to globalAgent, set a default limit of 50 if current value is Infinity.
+      // Users can bypass this default by supplying their own Agent as part of SDK configuration.
+      Object.defineProperty(AWS.NodeHttpClient.sslAgent, 'maxSockets', {
+        enumerable: true,
+        get: function() {
+          var defaultMaxSockets = 50;
+          var globalAgent = https.globalAgent;
+          if (globalAgent && globalAgent.maxSockets !== Infinity && typeof globalAgent.maxSockets === 'number') {
+            return globalAgent.maxSockets;
+          }
+          return defaultMaxSockets;
+        }
+      });
+    }
+    return AWS.NodeHttpClient.sslAgent;
+  },
+
+  progressStream: function progressStream(stream, totalBytes) {
+    if (typeof TransformStream === 'undefined') {
+      // for node 0.8 there is no streaming progress
+      return;
+    }
+    var loadedBytes = 0;
+    var reporter = new TransformStream();
+    reporter._transform = function(chunk, encoding, callback) {
+      if (chunk) {
+        loadedBytes += chunk.length;
+        stream.emit('sendProgress', {
+          loaded: loadedBytes,
+          total: totalBytes
+        });
+      }
+      callback(null, chunk);
+    };
+    return reporter;
+  },
+
+  emitter: null
+});
+
+/**
+ * @!ignore
+ */
+
+/**
+ * @api private
+ */
+AWS.HttpClient.prototype = AWS.NodeHttpClient.prototype;
+
+/**
+ * @api private
+ */
+AWS.HttpClient.streamsApiVersion = ReadableStream ? 2 : 1;

data/data/sumomo/api_modules/node_modules/aws-sdk/lib/http/xhr.js

@@ -0,0 +1,136 @@
+var AWS = require('../core');
+var EventEmitter = require('events').EventEmitter;
+require('../http');
+
+/**
+ * @api private
+ */
+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;
+
+    xhr.addEventListener('readystatechange', function() {
+      try {
+        if (xhr.status === 0) return; // 0 code is invalid
+      } catch (e) { return; }
+
+      if (this.readyState >= this.HEADERS_RECEIVED && !headersEmitted) {
+        emitter.statusCode = xhr.status;
+        emitter.headers = self.parseHeaders(xhr.getAllResponseHeaders());
+        emitter.emit(
+          'headers',
+          emitter.statusCode,
+          emitter.headers,
+          xhr.statusText
+        );
+        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);
+    xhr.addEventListener('abort', function () {
+      errCallback(AWS.util.error(new Error('Request aborted'), {
+        code: 'RequestAbortedError'
+      }));
+    }, 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 (httpOptions.timeout && httpOptions.xhrAsync !== false) {
+      xhr.timeout = httpOptions.timeout;
+    }
+
+    if (httpOptions.xhrWithCredentials) {
+      xhr.withCredentials = true;
+    }
+    try { xhr.responseType = 'arraybuffer'; } catch (e) {}
+
+    try {
+      if (httpRequest.body) {
+        xhr.send(httpRequest.body);
+      } else {
+        xhr.send();
+      }
+    } catch (err) {
+      if (httpRequest.body && typeof httpRequest.body.buffer === 'object') {
+        xhr.send(httpRequest.body.buffer); // send ArrayBuffer directly
+      } else {
+        throw err;
+      }
+    }
+
+    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.toLowerCase()] = 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');
+  }
+});
+
+/**
+ * @api private
+ */
+AWS.HttpClient.prototype = AWS.XHRClient.prototype;
+
+/**
+ * @api private
+ */
+AWS.HttpClient.streamsApiVersion = 1;