appium-mac2-driver 4.5.1 → 4.6.1

package/node_modules/spdy/README.md

@@ -0,0 +1,267 @@
+# SPDY Server for node.js
+
+[![Build Status](https://travis-ci.org/spdy-http2/node-spdy.svg?branch=master)](http://travis-ci.org/spdy-http2/node-spdy)
+[![NPM version](https://badge.fury.io/js/spdy.svg)](http://badge.fury.io/js/spdy)
+[![dependencies Status](https://david-dm.org/spdy-http2/node-spdy/status.svg?style=flat-square)](https://david-dm.org/spdy-http2/node-spdy)
+[![Standard - JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg?style=flat-square)](http://standardjs.com/)
+[![Waffle](https://img.shields.io/badge/track-waffle-blue.svg?style=flat-square)](https://waffle.io/spdy-http2/node-spdy)
+
+With this module you can create [HTTP2][0] / [SPDY][1] servers
+in node.js with natural http module interface and fallback to regular https
+(for browsers that don't support neither HTTP2, nor SPDY yet).
+
+This module named `spdy` but it [provides](https://github.com/indutny/node-spdy/issues/269#issuecomment-239014184) support for both http/2 (h2) and spdy (2,3,3.1). Also, `spdy` is compatible with Express.
+
+## Usage
+
+### Examples
+
+Server:
+```javascript
+var spdy = require('spdy'),
+    fs = require('fs');
+
+var options = {
+  // Private key
+  key: fs.readFileSync(__dirname + '/keys/spdy-key.pem'),
+
+  // Fullchain file or cert file (prefer the former)
+  cert: fs.readFileSync(__dirname + '/keys/spdy-fullchain.pem'),
+
+  // **optional** SPDY-specific options
+  spdy: {
+    protocols: [ 'h2', 'spdy/3.1', ..., 'http/1.1' ],
+    plain: false,
+
+    // **optional**
+    // Parse first incoming X_FORWARDED_FOR frame and put it to the
+    // headers of every request.
+    // NOTE: Use with care! This should not be used without some proxy that
+    // will *always* send X_FORWARDED_FOR
+    'x-forwarded-for': true,
+
+    connection: {
+      windowSize: 1024 * 1024, // Server's window size
+
+      // **optional** if true - server will send 3.1 frames on 3.0 *plain* spdy
+      autoSpdy31: false
+    }
+  }
+};
+
+var server = spdy.createServer(options, function(req, res) {
+  res.writeHead(200);
+  res.end('hello world!');
+});
+
+server.listen(3000);
+```
+
+Client:
+```javascript
+var spdy = require('spdy');
+var https = require('https');
+
+var agent = spdy.createAgent({
+  host: 'www.google.com',
+  port: 443,
+
+  // Optional SPDY options
+  spdy: {
+    plain: false,
+    ssl: true,
+
+    // **optional** send X_FORWARDED_FOR
+    'x-forwarded-for': '127.0.0.1'
+  }
+});
+
+https.get({
+  host: 'www.google.com',
+  agent: agent
+}, function(response) {
+  console.log('yikes');
+  // Here it goes like with any other node.js HTTP request
+  // ...
+  // And once we're done - we may close TCP connection to server
+  // NOTE: All non-closed requests will die!
+  agent.close();
+}).end();
+```
+
+Please note that if you use a custom agent, by default all connection-level
+errors will result in an uncaught exception. To handle these errors subscribe
+to the `error` event and re-emit the captured error:
+
+```javascript
+var agent = spdy.createAgent({
+  host: 'www.google.com',
+  port: 443
+}).once('error', function (err) {
+  this.emit(err);
+});
+```
+
+#### Push streams
+
+It is possible to initiate [PUSH_PROMISE][5] to send content to clients _before_
+the client requests it.
+
+```javascript
+spdy.createServer(options, function(req, res) {
+  var stream = res.push('/main.js', {
+    status: 200, // optional
+    method: 'GET', // optional
+    request: {
+      accept: '*/*'
+    },
+    response: {
+      'content-type': 'application/javascript'
+    }
+  });
+  stream.on('error', function() {
+  });
+  stream.end('alert("hello from push stream!");');
+
+  res.end('<script src="/main.js"></script>');
+}).listen(3000);
+```
+
+[PUSH_PROMISE][5] may be sent using the `push()` method on the current response
+object.  The signature of the `push()` method is:
+
+`.push('/some/relative/url', { request: {...}, response: {...} }, callback)`
+
+Second argument contains headers for both PUSH_PROMISE and emulated response.
+`callback` will receive two arguments: `err` (if any error is happened) and a
+[Duplex][4] stream as the second argument.
+
+Client usage:
+```javascript
+var agent = spdy.createAgent({ /* ... */ });
+var req = http.get({
+  host: 'www.google.com',
+  agent: agent
+}, function(response) {
+});
+req.on('push', function(stream) {
+  stream.on('error', function(err) {
+    // Handle error
+  });
+  // Read data from stream
+});
+```
+
+NOTE: You're responsible for the `stream` object once given it in `.push()`
+callback or `push` event. Hence ignoring `error` event on it will result in
+uncaught exception and crash your program.
+
+#### Trailing headers
+
+Server usage:
+```javascript
+function (req, res) {
+  // Send trailing headers to client
+  res.addTrailers({ header1: 'value1', header2: 'value2' });
+
+  // On client's trailing headers
+  req.on('trailers', function(headers) {
+    // ...
+  });
+}
+```
+
+Client usage:
+```javascript
+var req = http.request({ agent: spdyAgent, /* ... */ }).function (res) {
+  // On server's trailing headers
+  res.on('trailers', function(headers) {
+    // ...
+  });
+});
+req.write('stuff');
+req.addTrailers({ /* ... */ });
+req.end();
+```
+
+#### Options
+
+All options supported by [tls][2] work with node-spdy.
+
+Additional options may be passed via `spdy` sub-object:
+
+* `plain` - if defined, server will ignore NPN and ALPN data and choose whether
+  to use spdy or plain http by looking at first data packet.
+* `ssl` - if `false` and `options.plain` is `true`, `http.Server` will be used
+  as a `base` class for created server.
+* `maxChunk` - if set and non-falsy, limits number of bytes sent in one DATA
+  chunk. Setting it to non-zero value is recommended if you care about
+  interleaving of outgoing data from multiple different streams.
+  (defaults to 8192)
+* `protocols` - list of NPN/ALPN protocols to use (default is:
+  `['h2','spdy/3.1', 'spdy/3', 'spdy/2','http/1.1', 'http/1.0']`)
+* `protocol` - use specific protocol if no NPN/ALPN ex In addition,
+* `maxStreams` - set "[maximum concurrent streams][3]" protocol option
+
+### API
+
+API is compatible with `http` and `https` module, but you can use another
+function as base class for SPDYServer.
+
+```javascript
+spdy.createServer(
+  [base class constructor, i.e. https.Server],
+  { /* keys and options */ }, // <- the only one required argument
+  [request listener]
+).listen([port], [host], [callback]);
+```
+
+Request listener will receive two arguments: `request` and `response`. They're
+both instances of `http`'s `IncomingMessage` and `OutgoingMessage`. But three
+custom properties are added to both of them: `isSpdy`, `spdyVersion`. `isSpdy`
+is `true` when the request was processed using HTTP2/SPDY protocols, it is
+`false` in case of HTTP/1.1 fallback. `spdyVersion` is either of: `2`, `3`,
+`3.1`, or `4` (for HTTP2).
+
+
+#### Contributors
+
+* [Fedor Indutny](https://github.com/indutny)
+* [Chris Strom](https://github.com/eee-c)
+* [François de Metz](https://github.com/francois2metz)
+* [Ilya Grigorik](https://github.com/igrigorik)
+* [Roberto Peon](https://github.com/grmocg)
+* [Tatsuhiro Tsujikawa](https://github.com/tatsuhiro-t)
+* [Jesse Cravens](https://github.com/jessecravens)
+
+#### LICENSE
+
+This software is licensed under the MIT License.
+
+Copyright Fedor Indutny, 2015.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+[0]: https://http2.github.io/
+[1]: http://www.chromium.org/spdy
+[2]: http://nodejs.org/docs/latest/api/tls.html#tls.createServer
+[3]: https://httpwg.github.io/specs/rfc7540.html#SETTINGS_MAX_CONCURRENT_STREAMS
+[4]: https://iojs.org/api/stream.html#stream_class_stream_duplex
+[5]: https://httpwg.github.io/specs/rfc7540.html#PUSH_PROMISE

package/node_modules/spdy/lib/spdy/agent.js

@@ -0,0 +1,295 @@
+'use strict'
+
+var assert = require('assert')
+var http = require('http')
+var https = require('https')
+var net = require('net')
+var util = require('util')
+var transport = require('spdy-transport')
+var debug = require('debug')('spdy:client')
+
+// Node.js 0.10 and 0.12 support
+Object.assign = process.versions.modules >= 46
+  ? Object.assign // eslint-disable-next-line
+  : util._extend
+
+var EventEmitter = require('events').EventEmitter
+
+var spdy = require('../spdy')
+
+var mode = /^v0\.8\./.test(process.version)
+  ? 'rusty'
+  : /^v0\.(9|10)\./.test(process.version)
+    ? 'old'
+    : /^v0\.12\./.test(process.version)
+      ? 'normal'
+      : 'modern'
+
+var proto = {}
+
+function instantiate (base) {
+  function Agent (options) {
+    this._init(base, options)
+  }
+  util.inherits(Agent, base)
+
+  Agent.create = function create (options) {
+    return new Agent(options)
+  }
+
+  Object.keys(proto).forEach(function (key) {
+    Agent.prototype[key] = proto[key]
+  })
+
+  return Agent
+}
+
+proto._init = function _init (base, options) {
+  base.call(this, options)
+
+  var state = {}
+  this._spdyState = state
+
+  state.host = options.host
+  state.options = options.spdy || {}
+  state.secure = this instanceof https.Agent
+  state.fallback = false
+  state.createSocket = this._getCreateSocket()
+  state.socket = null
+  state.connection = null
+
+  // No chunked encoding
+  this.keepAlive = false
+
+  var self = this
+  this._connect(options, function (err, connection) {
+    if (err) {
+      return self.emit('error', err)
+    }
+
+    state.connection = connection
+    self.emit('_connect')
+  })
+}
+
+proto._getCreateSocket = function _getCreateSocket () {
+  // Find super's `createSocket` method
+  var createSocket
+  var cons = this.constructor.super_
+  do {
+    createSocket = cons.prototype.createSocket
+
+    if (cons.super_ === EventEmitter || !cons.super_) {
+      break
+    }
+    cons = cons.super_
+  } while (!createSocket)
+  if (!createSocket) {
+    createSocket = http.Agent.prototype.createSocket
+  }
+
+  assert(createSocket, '.createSocket() method not found')
+
+  return createSocket
+}
+
+proto._connect = function _connect (options, callback) {
+  var self = this
+  var state = this._spdyState
+
+  var protocols = state.options.protocols || [
+    'h2',
+    'spdy/3.1', 'spdy/3', 'spdy/2',
+    'http/1.1', 'http/1.0'
+  ]
+
+  // TODO(indutny): reconnect automatically?
+  var socket = this.createConnection(Object.assign({
+    NPNProtocols: protocols,
+    ALPNProtocols: protocols,
+    servername: options.servername || options.host
+  }, options))
+  state.socket = socket
+
+  socket.setNoDelay(true)
+
+  function onError (err) {
+    return callback(err)
+  }
+  socket.on('error', onError)
+
+  socket.on(state.secure ? 'secureConnect' : 'connect', function () {
+    socket.removeListener('error', onError)
+
+    var protocol
+    if (state.secure) {
+      protocol = socket.npnProtocol ||
+                 socket.alpnProtocol ||
+                 state.options.protocol
+    } else {
+      protocol = state.options.protocol
+    }
+
+    // HTTP server - kill socket and switch to the fallback mode
+    if (!protocol || protocol === 'http/1.1' || protocol === 'http/1.0') {
+      debug('activating fallback')
+      socket.destroy()
+      state.fallback = true
+      return
+    }
+
+    debug('connected protocol=%j', protocol)
+    var connection = transport.connection.create(socket, Object.assign({
+      protocol: /spdy/.test(protocol) ? 'spdy' : 'http2',
+      isServer: false
+    }, state.options.connection || {}))
+
+    // Pass connection level errors are passed to the agent.
+    connection.on('error', function (err) {
+      self.emit('error', err)
+    })
+
+    // Set version when we are certain
+    if (protocol === 'h2') {
+      connection.start(4)
+    } else if (protocol === 'spdy/3.1') {
+      connection.start(3.1)
+    } else if (protocol === 'spdy/3') {
+      connection.start(3)
+    } else if (protocol === 'spdy/2') {
+      connection.start(2)
+    } else {
+      socket.destroy()
+      callback(new Error('Unexpected protocol: ' + protocol))
+      return
+    }
+
+    if (state.options['x-forwarded-for'] !== undefined) {
+      connection.sendXForwardedFor(state.options['x-forwarded-for'])
+    }
+
+    callback(null, connection)
+  })
+}
+
+proto._createSocket = function _createSocket (req, options, callback) {
+  var state = this._spdyState
+  if (state.fallback) { return state.createSocket(req, options) }
+
+  var handle = spdy.handle.create(null, null, state.socket)
+
+  var socketOptions = {
+    handle: handle,
+    allowHalfOpen: true
+  }
+
+  var socket
+  if (state.secure) {
+    socket = new spdy.Socket(state.socket, socketOptions)
+  } else {
+    socket = new net.Socket(socketOptions)
+  }
+
+  handle.assignSocket(socket)
+  handle.assignClientRequest(req)
+
+  // Create stream only once `req.end()` is called
+  var self = this
+  handle.once('needStream', function () {
+    if (state.connection === null) {
+      self.once('_connect', function () {
+        handle.setStream(self._createStream(req, handle))
+      })
+    } else {
+      handle.setStream(self._createStream(req, handle))
+    }
+  })
+
+  // Yes, it is in reverse
+  req.on('response', function (res) {
+    handle.assignRequest(res)
+  })
+  handle.assignResponse(req)
+
+  // Handle PUSH
+  req.addListener('newListener', spdy.request.onNewListener)
+
+  // For v0.8
+  socket.readable = true
+  socket.writable = true
+
+  if (callback) {
+    return callback(null, socket)
+  }
+
+  return socket
+}
+
+if (mode === 'modern' || mode === 'normal') {
+  proto.createSocket = proto._createSocket
+} else {
+  proto.createSocket = function createSocket (name, host, port, addr, req) {
+    var state = this._spdyState
+    if (state.fallback) {
+      return state.createSocket(name, host, port, addr, req)
+    }
+
+    return this._createSocket(req, {
+      host: host,
+      port: port
+    })
+  }
+}
+
+proto._createStream = function _createStream (req, handle) {
+  var state = this._spdyState
+
+  var self = this
+  return state.connection.reserveStream({
+    method: req.method,
+    path: req.path,
+    headers: req._headers,
+    host: state.host
+  }, function (err, stream) {
+    if (err) {
+      return self.emit('error', err)
+    }
+
+    stream.on('response', function (status, headers) {
+      handle.emitResponse(status, headers)
+    })
+  })
+}
+
+// Public APIs
+
+proto.close = function close (callback) {
+  var state = this._spdyState
+
+  if (state.connection === null) {
+    this.once('_connect', function () {
+      this.close(callback)
+    })
+    return
+  }
+
+  state.connection.end(callback)
+}
+
+exports.Agent = instantiate(https.Agent)
+exports.PlainAgent = instantiate(http.Agent)
+
+exports.create = function create (base, options) {
+  if (typeof base === 'object') {
+    options = base
+    base = null
+  }
+
+  if (base) {
+    return instantiate(base).create(options)
+  }
+
+  if (options.spdy && options.spdy.plain) {
+    return exports.PlainAgent.create(options)
+  } else { return exports.Agent.create(options) }
+}