amqplib 0.10.2 → 0.10.4

package/lib/connection.js

@@ -13,7 +13,7 @@ var Mux = require('./mux').Mux;
 var Duplex =
   require('stream').Duplex ||
   require('readable-stream/duplex');
-var EventEmitter = require('events').EventEmitter;
+var EventEmitter = require('events');
 var Heart = require('./heartbeat').Heart;
 
 var methodName = require('./format').methodName;
@@ -21,7 +21,6 @@ var closeMsg = require('./format').closeMessage;
 var inspect = require('./format').inspect;
 
 var BitSet = require('./bitset').BitSet;
-var inherits = require('util').inherits;
 var fmt = require('util').format;
 var PassThrough = require('stream').PassThrough ||
   require('readable-stream/passthrough');
@@ -37,25 +36,545 @@ var DEFAULT_WRITE_HWM = 1024;
 // was greater, we might have to fragment the content.
 var SINGLE_CHUNK_THRESHOLD = 2048;
 
-function Connection(underlying) {
-  EventEmitter.call( this );
-  var stream = this.stream = wrapStream(underlying);
-  this.muxer = new Mux(stream);
-
-  // frames
-  this.rest = Buffer.alloc(0);
-  this.frameMax = constants.FRAME_MIN_SIZE;
-  this.sentSinceLastCheck = false;
-  this.recvSinceLastCheck = false;
-
-  this.expectSocketClose = false;
-  this.freeChannels = new BitSet();
-  this.channels = [{channel: {accept: channel0(this)},
-                    buffer: underlying}];
-}
-inherits(Connection, EventEmitter);
+class Connection extends EventEmitter {
+  constructor (underlying) {
+    super();
+
+    var stream = this.stream = wrapStream(underlying);
+    this.muxer = new Mux(stream);
+
+    // frames
+    this.rest = Buffer.alloc(0);
+    this.frameMax = constants.FRAME_MIN_SIZE;
+    this.sentSinceLastCheck = false;
+    this.recvSinceLastCheck = false;
+
+    this.expectSocketClose = false;
+    this.freeChannels = new BitSet();
+    this.channels = [{
+      channel: { accept: channel0(this) },
+      buffer: underlying
+    }];
+  }
+
+  // This changed between versions, as did the codec, methods, etc. AMQP
+  // 0-9-1 is fairly similar to 0.8, but better, and nothing implements
+  // 0.8 that doesn't implement 0-9-1. In other words, it doesn't make
+  // much sense to generalise here.
+  sendProtocolHeader () {
+    this.sendBytes(frame.PROTOCOL_HEADER);
+  }
+
+  /*
+    The frighteningly complicated opening protocol (spec section 2.2.4):
+
+       Client -> Server
+
+         protocol header ->
+           <- start
+         start-ok ->
+       .. next two zero or more times ..
+           <- secure
+         secure-ok ->
+           <- tune
+         tune-ok ->
+         open ->
+           <- open-ok
+
+  If I'm only supporting SASL's PLAIN mechanism (which I am for the time
+  being), it gets a bit easier since the server won't in general send
+  back a `secure`, it'll just send `tune` after the `start-ok`.
+  (SASL PLAIN: http://tools.ietf.org/html/rfc4616)
+
+  */
+  open (allFields, openCallback0) {
+    var self = this;
+    var openCallback = openCallback0 || function () { };
+
+    // This is where we'll put our negotiated values
+    var tunedOptions = Object.create(allFields);
+
+    function wait (k) {
+      self.step(function (err, frame) {
+        if (err !== null)
+          bail(err);
+        else if (frame.channel !== 0) {
+          bail(new Error(
+            fmt("Frame on channel != 0 during handshake: %s",
+              inspect(frame, false))));
+        }
+        else
+          k(frame);
+      });
+    }
+
+    function expect (Method, k) {
+      wait(function (frame) {
+        if (frame.id === Method)
+          k(frame);
+        else {
+          bail(new Error(
+            fmt("Expected %s; got %s",
+              methodName(Method), inspect(frame, false))));
+        }
+      });
+    }
+
+    function bail (err) {
+      openCallback(err);
+    }
+
+    function send (Method) {
+      // This can throw an exception if there's some problem with the
+      // options; e.g., something is a string instead of a number.
+      self.sendMethod(0, Method, tunedOptions);
+    }
+
+    function negotiate (server, desired) {
+      // We get sent values for channelMax, frameMax and heartbeat,
+      // which we may accept or lower (subject to a minimum for
+      // frameMax, but we'll leave that to the server to enforce). In
+      // all cases, `0` really means "no limit", or rather the highest
+      // value in the encoding, e.g., unsigned short for channelMax.
+      if (server === 0 || desired === 0) {
+        // i.e., whichever places a limit, if either
+        return Math.max(server, desired);
+      }
+      else {
+        return Math.min(server, desired);
+      }
+    }
+
+    function onStart (start) {
+      var mechanisms = start.fields.mechanisms.toString().split(' ');
+      if (mechanisms.indexOf(allFields.mechanism) < 0) {
+        bail(new Error(fmt('SASL mechanism %s is not provided by the server',
+          allFields.mechanism)));
+        return;
+      }
+      self.serverProperties = start.fields.serverProperties;
+      try {
+        send(defs.ConnectionStartOk);
+      } catch (err) {
+        bail(err);
+        return;
+      }
+      wait(afterStartOk);
+    }
+
+    function afterStartOk (reply) {
+      switch (reply.id) {
+        case defs.ConnectionSecure:
+          bail(new Error(
+            "Wasn't expecting to have to go through secure"));
+          break;
+        case defs.ConnectionClose:
+          bail(new Error(fmt("Handshake terminated by server: %s",
+            closeMsg(reply))));
+          break;
+        case defs.ConnectionTune:
+          var fields = reply.fields;
+          tunedOptions.frameMax =
+            negotiate(fields.frameMax, allFields.frameMax);
+          tunedOptions.channelMax =
+            negotiate(fields.channelMax, allFields.channelMax);
+          tunedOptions.heartbeat =
+            negotiate(fields.heartbeat, allFields.heartbeat);
+          try {
+            send(defs.ConnectionTuneOk);
+            send(defs.ConnectionOpen);
+          } catch (err) {
+            bail(err);
+            return;
+          }
+          expect(defs.ConnectionOpenOk, onOpenOk);
+          break;
+        default:
+          bail(new Error(
+            fmt("Expected connection.secure, connection.close, " +
+              "or connection.tune during handshake; got %s",
+              inspect(reply, false))));
+          break;
+      }
+    }
+
+    function onOpenOk (openOk) {
+      // Impose the maximum of the encoded value, if the negotiated
+      // value is zero, meaning "no, no limits"
+      self.channelMax = tunedOptions.channelMax || 0xffff;
+      self.frameMax = tunedOptions.frameMax || 0xffffffff;
+      // 0 means "no heartbeat", rather than "maximum period of
+      // heartbeating"
+      self.heartbeat = tunedOptions.heartbeat;
+      self.heartbeater = self.startHeartbeater();
+      self.accept = mainAccept;
+      succeed(openOk);
+    }
+
+    // If the server closes the connection, it's probably because of
+    // something we did
+    function endWhileOpening (err) {
+      bail(err || new Error('Socket closed abruptly ' +
+        'during opening handshake'));
+    }
+
+    this.stream.on('end', endWhileOpening);
+    this.stream.on('error', endWhileOpening);
+
+    function succeed (ok) {
+      self.stream.removeListener('end', endWhileOpening);
+      self.stream.removeListener('error', endWhileOpening);
+      self.stream.on('error', self.onSocketError.bind(self));
+      self.stream.on('end', self.onSocketError.bind(
+        self, new Error('Unexpected close')));
+      self.on('frameError', self.onSocketError.bind(self));
+      self.acceptLoop();
+      openCallback(null, ok);
+    }
+
+    // Now kick off the handshake by prompting the server
+    this.sendProtocolHeader();
+    expect(defs.ConnectionStart, onStart);
+  }
+
+  // Closing things: AMQP has a closing handshake that applies to
+  // closing both connects and channels. As the initiating party, I send
+  // Close, then ignore all frames until I see either CloseOK --
+  // which signifies that the other party has seen the Close and shut
+  // the connection or channel down, so it's fine to free resources; or
+  // Close, which means the other party also wanted to close the
+  // whatever, and I should send CloseOk so it can free resources,
+  // then go back to waiting for the CloseOk. If I receive a Close
+  // out of the blue, I should throw away any unsent frames (they will
+  // be ignored anyway) and send CloseOk, then clean up resources. In
+  // general, Close out of the blue signals an error (or a forced
+  // closure, which may as well be an error).
+  //
+  //  RUNNING [1] --- send Close ---> Closing [2] ---> recv Close --+
+  //     |                               |                         [3]
+  //     |                               +------ send CloseOk ------+
+  //  recv Close                   recv CloseOk
+  //     |                               |
+  //     V                               V
+  //  Ended [4] ---- send CloseOk ---> Closed [5]
+  //
+  // [1] All frames accepted; getting a Close frame from the server
+  // moves to Ended; client may initiate a close by sending Close
+  // itself.
+  // [2] Client has initiated a close; only CloseOk or (simulataneously
+  // sent) Close is accepted.
+  // [3] Simultaneous close
+  // [4] Server won't send any more frames; accept no more frames, send
+  // CloseOk.
+  // [5] Fully closed, client will send no more, server will send no
+  // more. Signal 'close' or 'error'.
+  //
+  // There are two signalling mechanisms used in the API. The first is
+  // that calling `close` will return a promise, that will either
+  // resolve once the connection or channel is cleanly shut down, or
+  // will reject if the shutdown times out.
+  //
+  // The second is the 'close' and 'error' events. These are
+  // emitted as above. The events will fire *before* promises are
+  // resolved.
+  // Close the connection without even giving a reason. Typical.
+  close (closeCallback) {
+    var k = closeCallback && function () { closeCallback(null); };
+    this.closeBecause("Cheers, thanks", constants.REPLY_SUCCESS, k);
+  }
+
+  // Close with a reason and a 'code'. I'm pretty sure RabbitMQ totally
+  // ignores these; maybe it logs them. The continuation will be invoked
+  // when the CloseOk has been received, and before the 'close' event.
+  closeBecause (reason, code, k) {
+    this.sendMethod(0, defs.ConnectionClose, {
+      replyText: reason,
+      replyCode: code,
+      methodId: 0, classId: 0
+    });
+    var s = stackCapture('closeBecause called: ' + reason);
+    this.toClosing(s, k);
+  }
+
+  closeWithError (reason, code, error) {
+    this.emit('error', error);
+    this.closeBecause(reason, code);
+  }
+
+  onSocketError (err) {
+    if (!this.expectSocketClose) {
+      // forestall any more calls to onSocketError, since we're signed
+      // up for `'error'` *and* `'end'`
+      this.expectSocketClose = true;
+      this.emit('error', err);
+      var s = stackCapture('Socket error');
+      this.toClosed(s, err);
+    }
+  }
+
+  // A close has been initiated. Repeat: a close has been initiated.
+  // This means we should not send more frames, anyway they will be
+  // ignored. We also have to shut down all the channels.
+  toClosing (capturedStack, k) {
+    var send = this.sendMethod.bind(this);
+
+    this.accept = function (f) {
+      if (f.id === defs.ConnectionCloseOk) {
+        if (k)
+          k();
+        var s = stackCapture('ConnectionCloseOk received');
+        this.toClosed(s, undefined);
+      }
+      else if (f.id === defs.ConnectionClose) {
+        send(0, defs.ConnectionCloseOk, {});
+      }
+      // else ignore frame
+    };
+    invalidateSend(this, 'Connection closing', capturedStack);
+  }
+
+  _closeChannels (capturedStack) {
+    for (var i = 1; i < this.channels.length; i++) {
+      var ch = this.channels[i];
+      if (ch !== null) {
+        ch.channel.toClosed(capturedStack); // %%% or with an error? not clear
+      }
+    }
+  }
+
+  // A close has been confirmed. Cease all communication.
+  toClosed (capturedStack, maybeErr) {
+    this._closeChannels(capturedStack);
+    var info = fmt('Connection closed (%s)',
+      (maybeErr) ? maybeErr.toString() : 'by client');
+    // Tidy up, invalidate enverything, dynamite the bridges.
+    invalidateSend(this, info, capturedStack);
+    this.accept = invalidOp(info, capturedStack);
+    this.close = function (cb) {
+      cb && cb(new IllegalOperationError(info, capturedStack));
+    };
+    if (this.heartbeater)
+      this.heartbeater.clear();
+    // This is certainly true now, if it wasn't before
+    this.expectSocketClose = true;
+    this.stream.end();
+    this.emit('close', maybeErr);
+  }
+
+  _updateSecret(newSecret, reason, cb) {
+    this.sendMethod(0, defs.ConnectionUpdateSecret, {
+      newSecret,
+      reason
+    });
+    this.once('update-secret-ok', cb);
+  }
+
+  // ===
+  startHeartbeater () {
+    if (this.heartbeat === 0)
+      return null;
+    else {
+      var self = this;
+      var hb = new Heart(this.heartbeat,
+        this.checkSend.bind(this),
+        this.checkRecv.bind(this));
+      hb.on('timeout', function () {
+        var hberr = new Error("Heartbeat timeout");
+        self.emit('error', hberr);
+        var s = stackCapture('Heartbeat timeout');
+        self.toClosed(s, hberr);
+      });
+      hb.on('beat', function () {
+        self.sendHeartbeat();
+      });
+      return hb;
+    }
+  }
+
+  // I use an array to keep track of the channels, rather than an
+  // object. The channel identifiers are numbers, and allocated by the
+  // connection. If I try to allocate low numbers when they are
+  // available (which I do, by looking from the start of the bitset),
+  // this ought to keep the array small, and out of 'sparse array
+  // storage'. I also set entries to null, rather than deleting them, in
+  // the expectation that the next channel allocation will fill the slot
+  // again rather than growing the array. See
+  // http://www.html5rocks.com/en/tutorials/speed/v8/
+  freshChannel (channel, options) {
+    var next = this.freeChannels.nextClearBit(1);
+    if (next < 0 || next > this.channelMax)
+      throw new Error("No channels left to allocate");
+    this.freeChannels.set(next);
+
+    var hwm = (options && options.highWaterMark) || DEFAULT_WRITE_HWM;
+    var writeBuffer = new PassThrough({
+      objectMode: true, highWaterMark: hwm
+    });
+    this.channels[next] = { channel: channel, buffer: writeBuffer };
+    writeBuffer.on('drain', function () {
+      channel.onBufferDrain();
+    });
+    this.muxer.pipeFrom(writeBuffer);
+    return next;
+  }
+
+  releaseChannel (channel) {
+    this.freeChannels.clear(channel);
+    var buffer = this.channels[channel].buffer;
+    buffer.end(); // will also cause it to be unpiped
+    this.channels[channel] = null;
+  }
+
+  acceptLoop () {
+    var self = this;
+
+    function go () {
+      try {
+        var f; while (f = self.recvFrame())
+          self.accept(f);
+      }
+      catch (e) {
+        self.emit('frameError', e);
+      }
+    }
+    self.stream.on('readable', go);
+    go();
+  }
+
+  step (cb) {
+    var self = this;
+    function recv () {
+      var f;
+      try {
+        f = self.recvFrame();
+      }
+      catch (e) {
+        cb(e, null);
+        return;
+      }
+      if (f)
+        cb(null, f);
+      else
+        self.stream.once('readable', recv);
+    }
+    recv();
+  }
+
+  checkSend () {
+    var check = this.sentSinceLastCheck;
+    this.sentSinceLastCheck = false;
+    return check;
+  }
+
+  checkRecv () {
+    var check = this.recvSinceLastCheck;
+    this.recvSinceLastCheck = false;
+    return check;
+  }
+
+  sendBytes (bytes) {
+    this.sentSinceLastCheck = true;
+    this.stream.write(bytes);
+  }
+
+  sendHeartbeat () {
+    return this.sendBytes(frame.HEARTBEAT_BUF);
+  }
+
+  sendMethod (channel, Method, fields) {
+    var frame = encodeMethod(Method, channel, fields);
+    this.sentSinceLastCheck = true;
+    var buffer = this.channels[channel].buffer;
+    return buffer.write(frame);
+  }
+
+  sendMessage (channel, Method, fields, Properties, props, content) {
+    if (!Buffer.isBuffer(content))
+      throw new TypeError('content is not a buffer');
+
+    var mframe = encodeMethod(Method, channel, fields);
+    var pframe = encodeProperties(Properties, channel,
+      content.length, props);
+    var buffer = this.channels[channel].buffer;
+    this.sentSinceLastCheck = true;
+
+    var methodHeaderLen = mframe.length + pframe.length;
+    var bodyLen = (content.length > 0) ?
+      content.length + FRAME_OVERHEAD : 0;
+    var allLen = methodHeaderLen + bodyLen;
+
+    if (allLen < SINGLE_CHUNK_THRESHOLD) {
+      // Use `allocUnsafe` to avoid excessive allocations and CPU usage
+      // from zeroing. The returned Buffer is not zeroed and so must be
+      // completely filled to be used safely.
+      // See https://github.com/amqp-node/amqplib/pull/695
+      var all = Buffer.allocUnsafe(allLen);
+      var offset = mframe.copy(all, 0);
+      offset += pframe.copy(all, offset);
+
+      if (bodyLen > 0)
+        makeBodyFrame(channel, content).copy(all, offset);
+      return buffer.write(all);
+    }
+    else {
+      if (methodHeaderLen < SINGLE_CHUNK_THRESHOLD) {
+        // Use `allocUnsafe` to avoid excessive allocations and CPU usage
+        // from zeroing. The returned Buffer is not zeroed and so must be
+        // completely filled to be used safely.
+        // See https://github.com/amqp-node/amqplib/pull/695
+        var both = Buffer.allocUnsafe(methodHeaderLen);
+        var offset = mframe.copy(both, 0);
+        pframe.copy(both, offset);
+        buffer.write(both);
+      }
+      else {
+        buffer.write(mframe);
+        buffer.write(pframe);
+      }
+      return this.sendContent(channel, content);
+    }
+  }
+
+  sendContent (channel, body) {
+    if (!Buffer.isBuffer(body)) {
+      throw new TypeError(fmt("Expected buffer; got %s", body));
+    }
+    var writeResult = true;
+    var buffer = this.channels[channel].buffer;
+
+    var maxBody = this.frameMax - FRAME_OVERHEAD;
 
-var C = Connection.prototype;
+    for (var offset = 0; offset < body.length; offset += maxBody) {
+      var end = offset + maxBody;
+      var slice = (end > body.length) ? body.subarray(offset) : body.subarray(offset, end);
+      var bodyFrame = makeBodyFrame(channel, slice);
+      writeResult = buffer.write(bodyFrame);
+    }
+    this.sentSinceLastCheck = true;
+    return writeResult;
+  }
+
+  recvFrame () {
+    // %%% identifying invariants might help here?
+    var frame = parseFrame(this.rest, this.frameMax);
+
+    if (!frame) {
+      var incoming = this.stream.read();
+      if (incoming === null) {
+        return false;
+      }
+      else {
+        this.recvSinceLastCheck = true;
+        this.rest = Buffer.concat([this.rest, incoming]);
+        return this.recvFrame();
+      }
+    }
+    else {
+      this.rest = frame.rest;
+      return decodeFrame(frame);
+    }
+  }
+}
 
 // Usual frame accept mode
 function mainAccept(frame) {
@@ -100,6 +619,9 @@ function channel0(connection) {
     else if (f.id === defs.ConnectionUnblocked) {
       connection.emit('unblocked');
     }
+    else if (f.id === defs.ConnectionUpdateSecretOk) {
+      connection.emit('update-secret-ok');
+    }
     else {
       connection.closeWithError(
         fmt("Unexpected frame on channel 0"),
@@ -110,260 +632,6 @@ function channel0(connection) {
   };
 }
 
-// This changed between versions, as did the codec, methods, etc. AMQP
-// 0-9-1 is fairly similar to 0.8, but better, and nothing implements
-// 0.8 that doesn't implement 0-9-1. In other words, it doesn't make
-// much sense to generalise here.
-C.sendProtocolHeader = function() {
-  this.sendBytes(frame.PROTOCOL_HEADER);
-};
-
-/*
-  The frighteningly complicated opening protocol (spec section 2.2.4):
-
-     Client -> Server
-
-       protocol header ->
-         <- start
-       start-ok ->
-     .. next two zero or more times ..
-         <- secure
-       secure-ok ->
-         <- tune
-       tune-ok ->
-       open ->
-         <- open-ok
-
-If I'm only supporting SASL's PLAIN mechanism (which I am for the time
-being), it gets a bit easier since the server won't in general send
-back a `secure`, it'll just send `tune` after the `start-ok`.
-(SASL PLAIN: http://tools.ietf.org/html/rfc4616)
-
-*/
-
-C.open = function(allFields, openCallback0) {
-  var self = this;
-  var openCallback = openCallback0 || function() {};
-
-  // This is where we'll put our negotiated values
-  var tunedOptions = Object.create(allFields);
-
-  function wait(k) {
-    self.step(function(err, frame) {
-      if (err !== null) bail(err);
-      else if (frame.channel !== 0) {
-        bail(new Error(
-          fmt("Frame on channel != 0 during handshake: %s",
-              inspect(frame, false))));
-      }
-      else k(frame);
-    });
-  }
-
-  function expect(Method, k) {
-    wait(function(frame) {
-      if (frame.id === Method) k(frame);
-      else {
-        bail(new Error(
-          fmt("Expected %s; got %s",
-              methodName(Method), inspect(frame, false))));
-      }
-    });
-  }
-
-  function bail(err) {
-    openCallback(err);
-  }
-
-  function send(Method) {
-    // This can throw an exception if there's some problem with the
-    // options; e.g., something is a string instead of a number.
-    self.sendMethod(0, Method, tunedOptions);
-  }
-
-  function negotiate(server, desired) {
-    // We get sent values for channelMax, frameMax and heartbeat,
-    // which we may accept or lower (subject to a minimum for
-    // frameMax, but we'll leave that to the server to enforce). In
-    // all cases, `0` really means "no limit", or rather the highest
-    // value in the encoding, e.g., unsigned short for channelMax.
-    if (server === 0 || desired === 0) {
-      // i.e., whichever places a limit, if either
-      return Math.max(server, desired);
-    }
-    else {
-      return Math.min(server, desired);
-    }
-  }
-
-  function onStart(start) {
-    var mechanisms = start.fields.mechanisms.toString().split(' ');
-    if (mechanisms.indexOf(allFields.mechanism) < 0) {
-      bail(new Error(fmt('SASL mechanism %s is not provided by the server',
-                         allFields.mechanism)));
-      return;
-    }
-    self.serverProperties = start.fields.serverProperties;
-    try {
-      send(defs.ConnectionStartOk);
-    } catch (err) {
-      bail(err);
-      return;
-    }
-    wait(afterStartOk);
-  }
-
-  function afterStartOk(reply) {
-    switch (reply.id) {
-    case defs.ConnectionSecure:
-      bail(new Error(
-        "Wasn't expecting to have to go through secure"));
-      break;
-    case defs.ConnectionClose:
-      bail(new Error(fmt("Handshake terminated by server: %s",
-                         closeMsg(reply))));
-      break;
-    case defs.ConnectionTune:
-      var fields = reply.fields;
-      tunedOptions.frameMax =
-        negotiate(fields.frameMax, allFields.frameMax);
-      tunedOptions.channelMax =
-        negotiate(fields.channelMax, allFields.channelMax);
-      tunedOptions.heartbeat =
-        negotiate(fields.heartbeat, allFields.heartbeat);
-      try {
-        send(defs.ConnectionTuneOk);
-        send(defs.ConnectionOpen);
-      } catch (err) {
-        bail(err);
-        return;
-      }
-      expect(defs.ConnectionOpenOk, onOpenOk);
-      break;
-    default:
-      bail(new Error(
-        fmt("Expected connection.secure, connection.close, " +
-            "or connection.tune during handshake; got %s",
-            inspect(reply, false))));
-      break;
-    }
-  }
-
-  function onOpenOk(openOk) {
-    // Impose the maximum of the encoded value, if the negotiated
-    // value is zero, meaning "no, no limits"
-    self.channelMax = tunedOptions.channelMax || 0xffff;
-    self.frameMax = tunedOptions.frameMax || 0xffffffff;
-    // 0 means "no heartbeat", rather than "maximum period of
-    // heartbeating"
-    self.heartbeat = tunedOptions.heartbeat;
-    self.heartbeater = self.startHeartbeater();
-    self.accept = mainAccept;
-    succeed(openOk);
-  }
-
-  // If the server closes the connection, it's probably because of
-  // something we did
-  function endWhileOpening(err) {
-    bail(err || new Error('Socket closed abruptly ' +
-                          'during opening handshake'));
-  }
-
-  this.stream.on('end', endWhileOpening);
-  this.stream.on('error', endWhileOpening);
-
-  function succeed(ok) {
-    self.stream.removeListener('end', endWhileOpening);
-    self.stream.removeListener('error', endWhileOpening);
-    self.stream.on('error', self.onSocketError.bind(self));
-    self.stream.on('end', self.onSocketError.bind(
-      self, new Error('Unexpected close')));
-    self.on('frameError', self.onSocketError.bind(self));
-    self.acceptLoop();
-    openCallback(null, ok);
-  }
-
-  // Now kick off the handshake by prompting the server
-  this.sendProtocolHeader();
-  expect(defs.ConnectionStart, onStart);
-};
-
-// Closing things: AMQP has a closing handshake that applies to
-// closing both connects and channels. As the initiating party, I send
-// Close, then ignore all frames until I see either CloseOK --
-// which signifies that the other party has seen the Close and shut
-// the connection or channel down, so it's fine to free resources; or
-// Close, which means the other party also wanted to close the
-// whatever, and I should send CloseOk so it can free resources,
-// then go back to waiting for the CloseOk. If I receive a Close
-// out of the blue, I should throw away any unsent frames (they will
-// be ignored anyway) and send CloseOk, then clean up resources. In
-// general, Close out of the blue signals an error (or a forced
-// closure, which may as well be an error).
-//
-//  RUNNING [1] --- send Close ---> Closing [2] ---> recv Close --+
-//     |                               |                         [3]
-//     |                               +------ send CloseOk ------+
-//  recv Close                   recv CloseOk
-//     |                               |
-//     V                               V
-//  Ended [4] ---- send CloseOk ---> Closed [5]
-//
-// [1] All frames accepted; getting a Close frame from the server
-// moves to Ended; client may initiate a close by sending Close
-// itself.
-// [2] Client has initiated a close; only CloseOk or (simulataneously
-// sent) Close is accepted.
-// [3] Simultaneous close
-// [4] Server won't send any more frames; accept no more frames, send
-// CloseOk.
-// [5] Fully closed, client will send no more, server will send no
-// more. Signal 'close' or 'error'.
-//
-// There are two signalling mechanisms used in the API. The first is
-// that calling `close` will return a promise, that will either
-// resolve once the connection or channel is cleanly shut down, or
-// will reject if the shutdown times out.
-//
-// The second is the 'close' and 'error' events. These are
-// emitted as above. The events will fire *before* promises are
-// resolved.
-
-// Close the connection without even giving a reason. Typical.
-C.close = function(closeCallback) {
-  var k = closeCallback && function() { closeCallback(null); };
-  this.closeBecause("Cheers, thanks", constants.REPLY_SUCCESS, k);
-};
-
-// Close with a reason and a 'code'. I'm pretty sure RabbitMQ totally
-// ignores these; maybe it logs them. The continuation will be invoked
-// when the CloseOk has been received, and before the 'close' event.
-C.closeBecause = function(reason, code, k) {
-  this.sendMethod(0, defs.ConnectionClose, {
-    replyText: reason,
-    replyCode: code,
-    methodId: 0, classId: 0
-  });
-  var s = stackCapture('closeBecause called: ' + reason);
-  this.toClosing(s, k);
-};
-
-C.closeWithError = function(reason, code, error) {
-  this.emit('error', error);
-  this.closeBecause(reason, code);
-};
-
-C.onSocketError = function(err) {
-  if (!this.expectSocketClose) {
-    // forestall any more calls to onSocketError, since we're signed
-    // up for `'error'` *and* `'end'`
-    this.expectSocketClose = true;
-    this.emit('error', err);
-    var s = stackCapture('Socket error');
-    this.toClosed(s, err);
-  }
-};
-
 function invalidOp(msg, stack) {
   return function() {
     throw new IllegalOperationError(msg, stack);
@@ -375,268 +643,15 @@ function invalidateSend(conn, msg, stack) {
     invalidOp(msg, stack);
 }
 
-// A close has been initiated. Repeat: a close has been initiated.
-// This means we should not send more frames, anyway they will be
-// ignored. We also have to shut down all the channels.
-C.toClosing = function(capturedStack, k) {
-  var send = this.sendMethod.bind(this);
-
-  this.accept = function(f) {
-    if (f.id === defs.ConnectionCloseOk) {
-      if (k) k();
-      var s = stackCapture('ConnectionCloseOk received');
-      this.toClosed(s, undefined);
-    }
-    else if (f.id === defs.ConnectionClose) {
-      send(0, defs.ConnectionCloseOk, {});
-    }
-    // else ignore frame
-  };
-  invalidateSend(this, 'Connection closing', capturedStack);
-};
-
-C._closeChannels = function(capturedStack) {
-  for (var i = 1; i < this.channels.length; i++) {
-    var ch = this.channels[i];
-    if (ch !== null) {
-      ch.channel.toClosed(capturedStack); // %%% or with an error? not clear
-    }
-  }
-};
-
-// A close has been confirmed. Cease all communication.
-C.toClosed = function(capturedStack, maybeErr) {
-  this._closeChannels(capturedStack);
-  var info = fmt('Connection closed (%s)',
-                 (maybeErr) ? maybeErr.toString() : 'by client');
-  // Tidy up, invalidate enverything, dynamite the bridges.
-  invalidateSend(this, info, capturedStack);
-  this.accept = invalidOp(info, capturedStack);
-  this.close = function(cb) {
-    cb && cb(new IllegalOperationError(info, capturedStack));
-  };
-  if (this.heartbeater) this.heartbeater.clear();
-  // This is certainly true now, if it wasn't before
-  this.expectSocketClose = true;
-  this.stream.end();
-  this.emit('close', maybeErr);
-};
-
-// ===
-
-C.startHeartbeater = function() {
-  if (this.heartbeat === 0) return null;
-  else {
-    var self = this;
-    var hb = new Heart(this.heartbeat,
-                       this.checkSend.bind(this),
-                       this.checkRecv.bind(this));
-    hb.on('timeout', function() {
-      var hberr = new Error("Heartbeat timeout");
-      self.emit('error', hberr);
-      var s = stackCapture('Heartbeat timeout');
-      self.toClosed(s, hberr);
-    });
-    hb.on('beat', function() {
-      self.sendHeartbeat();
-    });
-    return hb;
-  }
-};
-
-// I use an array to keep track of the channels, rather than an
-// object. The channel identifiers are numbers, and allocated by the
-// connection. If I try to allocate low numbers when they are
-// available (which I do, by looking from the start of the bitset),
-// this ought to keep the array small, and out of 'sparse array
-// storage'. I also set entries to null, rather than deleting them, in
-// the expectation that the next channel allocation will fill the slot
-// again rather than growing the array. See
-// http://www.html5rocks.com/en/tutorials/speed/v8/
-C.freshChannel = function(channel, options) {
-  var next = this.freeChannels.nextClearBit(1);
-  if (next < 0 || next > this.channelMax)
-    throw new Error("No channels left to allocate");
-  this.freeChannels.set(next);
-
-  var hwm = (options && options.highWaterMark) || DEFAULT_WRITE_HWM;
-  var writeBuffer = new PassThrough({
-    objectMode: true, highWaterMark: hwm
-  });
-  this.channels[next] = {channel: channel, buffer: writeBuffer};
-  writeBuffer.on('drain', function() {
-    channel.onBufferDrain();
-  });
-  this.muxer.pipeFrom(writeBuffer);
-  return next;
-};
-
-C.releaseChannel = function(channel) {
-  this.freeChannels.clear(channel);
-  var buffer = this.channels[channel].buffer;
-  buffer.end(); // will also cause it to be unpiped
-  this.channels[channel] = null;
-};
-
-C.acceptLoop = function() {
-  var self = this;
-
-  function go() {
-    try {
-      var f; while (f = self.recvFrame()) self.accept(f);
-    }
-    catch (e) {
-      self.emit('frameError', e);
-    }
-  }
-  self.stream.on('readable', go);
-  go();
-};
-
-C.step = function(cb) {
-  var self = this;
-  function recv() {
-    var f;
-    try {
-      f = self.recvFrame();
-    }
-    catch (e) {
-      cb(e, null);
-      return;
-    }
-    if (f) cb(null, f);
-    else self.stream.once('readable', recv);
-  }
-  recv();
-};
-
-C.checkSend = function() {
-  var check = this.sentSinceLastCheck;
-  this.sentSinceLastCheck = false;
-  return check;
-}
-
-C.checkRecv = function() {
-  var check = this.recvSinceLastCheck;
-  this.recvSinceLastCheck = false;
-  return check;
-}
-
-C.sendBytes = function(bytes) {
-  this.sentSinceLastCheck = true;
-  this.stream.write(bytes);
-};
-
-C.sendHeartbeat = function() {
-  return this.sendBytes(frame.HEARTBEAT_BUF);
-};
-
 var encodeMethod = defs.encodeMethod;
 var encodeProperties = defs.encodeProperties;
 
-C.sendMethod = function(channel, Method, fields) {
-  var frame = encodeMethod(Method, channel, fields);
-  this.sentSinceLastCheck = true;
-  var buffer = this.channels[channel].buffer;
-  return buffer.write(frame);
-};
-
-C.sendMessage = function(channel,
-                         Method, fields,
-                         Properties, props,
-                         content) {
-  if (!Buffer.isBuffer(content))
-    throw new TypeError('content is not a buffer');
-
-  var mframe = encodeMethod(Method, channel, fields);
-  var pframe = encodeProperties(Properties, channel,
-                                content.length, props);
-  var buffer = this.channels[channel].buffer;
-  this.sentSinceLastCheck = true;
-
-  var methodHeaderLen = mframe.length + pframe.length;
-  var bodyLen = (content.length > 0) ?
-    content.length + FRAME_OVERHEAD : 0;
-  var allLen = methodHeaderLen + bodyLen;
-
-  if (allLen < SINGLE_CHUNK_THRESHOLD) {
-    // Use `allocUnsafe` to avoid excessive allocations and CPU usage
-    // from zeroing. The returned Buffer is not zeroed and so must be
-    // completely filled to be used safely.
-    // See https://github.com/amqp-node/amqplib/pull/695
-    var all = Buffer.allocUnsafe(allLen);
-    var offset = mframe.copy(all, 0);
-    offset += pframe.copy(all, offset);
-
-    if (bodyLen > 0)
-      makeBodyFrame(channel, content).copy(all, offset);
-    return buffer.write(all);
-  }
-  else {
-    if (methodHeaderLen < SINGLE_CHUNK_THRESHOLD) {
-      // Use `allocUnsafe` to avoid excessive allocations and CPU usage
-      // from zeroing. The returned Buffer is not zeroed and so must be
-      // completely filled to be used safely.
-      // See https://github.com/amqp-node/amqplib/pull/695
-      var both = Buffer.allocUnsafe(methodHeaderLen);
-      var offset = mframe.copy(both, 0);
-      pframe.copy(both, offset);
-      buffer.write(both);
-    }
-    else {
-      buffer.write(mframe);
-      buffer.write(pframe);
-    }
-    return this.sendContent(channel, content);
-  }
-};
-
 var FRAME_OVERHEAD = defs.FRAME_OVERHEAD;
 var makeBodyFrame = frame.makeBodyFrame;
 
-C.sendContent = function(channel, body) {
-  if (!Buffer.isBuffer(body)) {
-    throw new TypeError(fmt("Expected buffer; got %s", body));
-  }
-  var writeResult = true;
-  var buffer = this.channels[channel].buffer;
-
-  var maxBody = this.frameMax - FRAME_OVERHEAD;
-
-  for (var offset = 0; offset < body.length; offset += maxBody) {
-    var end = offset + maxBody;
-    var slice = (end > body.length) ? body.slice(offset) : body.slice(offset, end);
-    var bodyFrame = makeBodyFrame(channel, slice);
-    writeResult = buffer.write(bodyFrame);
-  }
-  this.sentSinceLastCheck = true;
-  return writeResult;
-};
-
 var parseFrame = frame.parseFrame;
 var decodeFrame = frame.decodeFrame;
 
-C.recvFrame = function() {
-  // %%% identifying invariants might help here?
-  var frame = parseFrame(this.rest, this.frameMax);
-
-  if (!frame) {
-    var incoming = this.stream.read();
-    if (incoming === null) {
-      return false;
-    }
-    else {
-      this.recvSinceLastCheck = true;
-      this.rest = Buffer.concat([this.rest, incoming]);
-      return this.recvFrame();
-    }
-  }
-  else {
-    this.rest = frame.rest;
-    return decodeFrame(frame);
-  }
-};
-
 function wrapStream(s) {
   if (s instanceof Duplex) return s;
   else {