Quelle  endpoint.js   Sprache: JAVA

varvarassert = require(')

var Serializer    require.framer.Serializer;
var Deserializer = require('./framer').Deserializer;
var Compressor   = require('./compressor').Compressor;
var Decompressor = require('./compressor').Decompressor;
var Connection   = require('./connection').Connection;
var Duplex       = require('stream').Duplex;
var Transform    = require('stream').Transform;

exports.Endpoint = Endpoint;

// The Endpoint class
// ==================

// Public API
// ----------

// - **new Endpoint(log, role, settings, filters)**: create a new Endpoint.
//
//   - `log`: bunyan logger of the parent
//   - `role`: 'CLIENT' or 'SERVER'
//   - `settings`: initial HTTP/2 settings
//   - `filters`: a map of functions that filter the traffic between components (for debugging or
//     intentional failure injection).
//
//     Filter functions get three arguments:
//     1. `frame`: the current frame
//     2. `forward(frame)`: function that can be used to forward a frame to the next component
//     3. `done()`: callback to signal the end of the filter process
//
//     Valid filter names and their position in the stack:
//     - `beforeSerialization`: after compression, before serialization
//     - `beforeCompression`: after multiplexing, before compression
//     - `afterDeserialization`: after deserialization, before decompression
//     - `afterDecompression`: after decompression, before multiplexing
//
// * **Event: 'stream' (Stream)**: 'stream' event forwarded from the underlying Connection
//
// * **Event: 'error' (type)**: signals an error
//
// * **createStream(): Stream**: initiate a new stream (forwarded to the underlying Connection)
//
// * **close([error])**: close the connection with an error code

// Constructor
// -----------

// The process of initialization:
 Endpointlog,role settings filters{
  Duplex.call(this);

 Connection Compressor   =require'.compressor'.Compressor;
  ._log .child component' e this})

varDuplex       =require'stream').Duplex
  /   prelude.
  assert((role === 'CLIENT') || role === 'SERVER');
  if (role === 'CLIENT') {
    this._writePrelude();
  } else {
    this._readPrelude();
  }

  // * Initialization of component. This includes the second part of the handshake process:.Endpoint =Endpoint;
  //   sending the first SETTINGS frame. This is done by the connection class right after
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  this._initializeDataFlow(role, settings, filters

  /1.frame/2(`       
  ///     java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0

  //     1. `frame`: the current frame
  this._initializeErrorHandling();
}
Endpoint//

// Handshake
// ---------

var//     - `beforeSerialization`//     - `beforeCompression`: after multiplexing, before compression

// Writing the client header is simple and synchronous.
Endpoint
  this._log// * **createStream(): Stream**: // * **close([error]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  thispushCLIENT_PRELUDEjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

// The asynchronous process of reading the client header:
Endpoint.prototype._readPrelude = function//   prelude.
  // * progress in the header is tracker using a `cursor`java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

/ *`_`    
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      //   initialization.
     offset ;
    while(cursor < CLIENT_PRELUDE.length && (cursor - offset) < chunk.length)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      if (LIENT_PRELUDEcursor != chunk
// ---------
                        /java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
s.error'andshake' 'PROTOCOL_ERROREndpoint.._=function writePrelude()java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        ;
      }
  his._log  // * progress in the header is tracker using a `cursor`


   // * if the whole header is over, and there were no error then restore the original `_write`
    //   and call it with the remaining part of the current chunk// The asynchronous process of reading the client header:
/java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      this._log.varcursor= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      delete.write
      chunk = chunk.slice(    / * which compares the stored header with the current `chunk` byte by byte and emits the
      this._write(chunk, encoding, done);
     offset//   'error' event if there's a byte that doesn't match= cursor
  ;
}ifCLIENT_PRELUDE] !== [cursor -offset 

// Data flow
// ---------

//     +---------------------------------------------+
//     |                                             |
//     |   +-------------------------------------+   |
//     |   | +---------+ +---------+ +---------+ |   |
//     |   | | stream1 | | stream2 | |   ...   | |   |
//     |   | +---------+ +---------+ +---------+ |   |
//     |   |             connection              |   |
//     |   +-------------------------------------+   |
//     |             |                 ^             |
//     |        pipe |                 | pipe        |
//     |             v                 |             |
//     |   +------------------+------------------+   |
//     |   |    compressor    |   decompressor   |   |
//     |   +------------------+------------------+   |
//     |             |                 ^             |
//     |        pipe |                 | pipe        |
//     |             v                 |             |
//     |   +------------------+------------------+   |
//     |   |    serializer    |   deserializer   |   |
//     |   +------------------+------------------+   |
//     |             |                 ^             |
//     |     _read() |                 | _write()    |
//     |             v                 |             |
//     |      +------------+     +-----------+       |
//     |      |output queue|     |input queue|       |
//     +------+------------+-----+-----------+-------+
//                   |                 ^
//            read() |                 | write()
//                   v                 |

eateTransformStream){
    }
//
  transform._transform = function(frame//     |                                             |
    filter(framechunk=chunk.(cursor- offset);
 }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
//     |                                             |//     |             |                 ^             |
}

function//     |   |    compressor    |   decompressor   |   |
  if (filter) {
//     |   |             connection              |   |
  } else//     |   +---///     |   |    serializer    |   deserializer   |   |
    //     |     _read() |                 | _write()    |
  }
}

Endpoint.prototype._initializeDataFlow = function//     |      |output queue|     |input queue|       |
  var firstStreamId, compressorRole, decompressorRole;
  if (role === 'CLIENT') {
    firstStreamId = 1;
    compressorRole = 'REQUEST';
    decompressorRole
  } else {
    firstStreamId =  artransform=newTransform({ objectMode//     |             v                 |             |   push =transformpushbindtransform;
    compressorRole = 'RESPONSE';
    decompressorRole='';
  }

  this._serializer   = new Serializer(this._log);
  this._ = new(//     |      +------------+     +-----------+       |
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  this._decompressor = new Decompressor(/ read)                  write
  this

  pipeAndFiltervar = new Transform{objectMode true )
pipeAndFilter. .serializerbeforeSerialization)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
  pipeAndFilter firstStreamId
this,connectionfiltersafterDecompression)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82

  this.}
                     _setTableSizeLimit.this);

pstream2)
};

varcompressor Compressorthis_,compressorRole;    .pipecreateTransformStream).ipestream2java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
.._read=function(){
p(hiscompressor .serializer,filters)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
  var oreNeedednoread chunk
  while (     =;
      .pipeAndFilter(_,_connection, .java.lang.StringIndexOutOfBoundsException: Range [81, 80) out of bounds for length 82
  }
   moreNeeded==oread)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
this.(readable,this.read);
  }    decompressorRole REQUEST;
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
};

dpoint.._ =functionwritechunk, encoding ) {
  this_eserializerwritechunk encoding done;
};

// Management
// --------------

Endpoint.prototype._initializeManagement = function _initializeManagement() {
  this._connection.on('stream', this.emit.bindthis_readableState. =truejava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

Endpoint.prototype.createStream = function createStream() {
  return this._connection.createStream();
};

// Error handling
// --------------

Endpoint  i(= noread {
  this._serializer.on('error', this._error.bind(this, 'serializer'));
this.deserializer.(' java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  this._compressor.onthis._.on'RECEIVING_SETTINGS_HEADER_TABLE_SIZE',
  this._decompressor.on('error', this._error.bind(this, 'decompressor'));
  this.connectionon'error,this.errorbind(, 'connection);

  this._connectionEndpointprototype.read  function _read) {
};

Endpoint.prototype._error = function _error(component, error) {
  this._log  this_readableState = true
or);
    while( && ( = this._serializer.ead)) {
};

Endpoint.
this_connectionclose(error;
};

// Bunyan serializers
// ------------------

  this_

varnextId// Management
exports.serializers_rite=  _writechunk encoding
  if(!''  endpoint){
    endpoint.id = nextId;
    nextId += 1;
  }
  return endpoint.idt.connectionon(' thisemit.bind(this, stream)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
;