tchannel 3.6.14 → 3.6.24

package/stat-tags.js

@@ -58,7 +58,8 @@ module.exports = {
     ConnectionsErrorsTags: ConnectionsErrorsTags,
     ConnectionsClosedTags: ConnectionsClosedTags,
     RelayLatencyTags: RelayLatencyTags,
-    HTTPHanlderBuildLatencyTags: HTTPHanlderBuildLatencyTags
+    HTTPHanlderBuildLatencyTags: HTTPHanlderBuildLatencyTags,
+    ObjectPoolTags: ObjectPoolTags
 };
 
 function InboundCallsRecvdTags(cn, serviceName, endpoint) {
@@ -663,3 +664,25 @@ HTTPHanlderBuildLatencyTags.prototype.toStatKey = function toStatKey(prefix) {
         clean(this.targetService, 'no-target-service') + '.' +
         (this.streamed ? 'streamed' : 'unstreamed');
 };
+
+function ObjectPoolTags(poolName, statType) {
+    this.app = '';
+    this.host = '';
+    this.cluster = '';
+    this.version = '';
+
+    this.poolName = poolName;
+    this.statType = statType;
+
+    this._cachedPrefix = '';
+    this._key = '';
+}
+
+ObjectPoolTags.prototype.toStatKey = function toStatKey(prefix) {
+    // prefix should never change but we store it in _cachedPrefix just in case
+    if (!this._key || prefix !== this._cachedPrefix) {
+        this._key = prefix + '.' + this.poolName + '.' + this.statType;
+        this._cachedPrefix = prefix;
+    }
+    return this._key;
+};

package/sub_peers.js

@@ -27,13 +27,37 @@ var PeerHeap = require('./peer_heap.js');
 
 function TChannelSubPeers(channel, options) {
     TChannelPeersBase.call(this, channel, options);
+
+    var self = this;
     this.peerScoreThreshold = this.options.peerScoreThreshold || 0;
-    this._heap = new PeerHeap(channel.random);
     this.choosePeerWithHeap = channel.choosePeerWithHeap;
+
+    this.hasMinConnections = typeof options.minConnections === 'number';
+    this.minConnections = options.minConnections;
+
+    this.currentConnectedPeers = 0;
+    this._heap = new PeerHeap(this, channel.random);
+
+    this.boundOnOutConnectionDelta = boundOnOutConnectionDelta;
+
+    function boundOnOutConnectionDelta(delta, peer) {
+        self.onOutConnectionDelta(peer, delta);
+    }
 }
 
 inherits(TChannelSubPeers, TChannelPeersBase);
 
+TChannelSubPeers.prototype.onOutConnectionDelta =
+function onOutConnectionDelta(peer, delta) {
+    var connCount = peer.countConnections('out');
+
+    if (delta === 1 && connCount === 1) {
+        this.currentConnectedPeers++;
+    } else if (delta === -1 && connCount === 0) {
+        this.currentConnectedPeers--;
+    }
+};
+
 TChannelSubPeers.prototype.close = function close(callback) {
     var self = this;
 
@@ -55,6 +79,12 @@ TChannelSubPeers.prototype.add = function add(hostPort, options) {
     peer = topChannel.peers.add(hostPort, options);
     peer.setPreferConnectionDirection(self.preferConnectionDirection);
 
+    if (peer.countConnections('out') > 0) {
+        this.currentConnectedPeers++;
+    }
+
+    peer.deltaOutConnectionEvent.on(self.boundOnOutConnectionDelta);
+
     self._map[hostPort] = peer;
     self._keys.push(hostPort);
 
@@ -80,6 +110,13 @@ TChannelSubPeers.prototype._delete = function _del(peer) {
         return;
     }
 
+    if (peer.countConnections('out') > 0) {
+        this.currentConnectedPeers--;
+    }
+
+    peer.deltaOutConnectionEvent
+        .removeListener(self.boundOnOutConnectionDelta);
+
     delete self._map[peer.hostPort];
     popout(self._keys, index);
 
@@ -109,6 +146,7 @@ TChannelSubPeers.prototype.choosePeer = function choosePeer(req) {
     return self.chooseLinearPeer(req);
 };
 
+/*eslint max-statements: [2, 40]*/
 TChannelSubPeers.prototype.chooseLinearPeer = function chooseLinearPeer(req) {
     /* eslint complexity: [2, 15]*/
     var self = this;
@@ -121,11 +159,22 @@ TChannelSubPeers.prototype.chooseLinearPeer = function chooseLinearPeer(req) {
     var threshold = self.peerScoreThreshold;
 
     var selectedPeer = null;
+    var secondaryPeer = null;
     var selectedScore = 0;
+    var secondaryScore = 0;
+
+    var notEnoughPeers = false;
+    if (this.hasMinConnections) {
+        notEnoughPeers = this.currentConnectedPeers < this.minConnections;
+    }
+
     for (var i = 0; i < hosts.length; i++) {
         var hostPort = hosts[i];
         var peer = self._map[hostPort];
-        if (!req || !req.triedRemoteAddrs || !req.triedRemoteAddrs[hostPort]) {
+
+        var shouldSkip = req && req.triedRemoteAddrs && req.triedRemoteAddrs[hostPort];
+        if (!shouldSkip) {
+            var isSecondary = notEnoughPeers && peer.isConnected('out');
             var score = peer.getScore(req);
 
             if (self.channel.topChannel.peerScoredEvent) {
@@ -136,11 +185,24 @@ TChannelSubPeers.prototype.chooseLinearPeer = function chooseLinearPeer(req) {
                 });
             }
 
-            var want = score > threshold &&
-                       (selectedPeer === null || score > selectedScore);
+            var want;
+            if (isSecondary) {
+                want = score > threshold && (
+                    secondaryPeer === null || score > secondaryScore
+                );
+            } else {
+                want = score > threshold &&
+                    (selectedPeer === null || score > selectedScore);
+            }
+
             if (want) {
-                selectedPeer = peer;
-                selectedScore = score;
+                if (isSecondary) {
+                    secondaryPeer = peer;
+                    secondaryScore = score;
+                } else {
+                    selectedPeer = peer;
+                    selectedScore = score;
+                }
             }
         }
     }
@@ -152,14 +214,21 @@ TChannelSubPeers.prototype.chooseLinearPeer = function chooseLinearPeer(req) {
         });
     }
 
-    return selectedPeer;
+    if (secondaryScore > selectedScore && selectedPeer) {
+        selectedPeer.tryConnect(noop);
+        return secondaryPeer;
+    }
+
+    return selectedPeer || secondaryPeer;
 };
 
+function noop() {}
+
 TChannelSubPeers.prototype.chooseHeapPeer = function chooseHeapPeer(req) {
     var self = this;
 
     var peer;
-    if (req && req.triedRemoteAddrs) {
+    if ((req && req.triedRemoteAddrs)) {
         peer = self._choosePeerSkipTried(req);
     } else {
         peer = self._heap.choose(self.peerScoreThreshold);
@@ -182,7 +251,8 @@ function _choosePeerSkipTried(req) {
     return self._heap.choose(self.peerScoreThreshold, filterTriedPeers);
 
     function filterTriedPeers(peer) {
-        return !req.triedRemoteAddrs[peer.hostPort];
+        var shouldSkip = req.triedRemoteAddrs[peer.hostPort];
+        return !shouldSkip;
     }
 };
 

package/test/index.js

@@ -76,6 +76,8 @@ require('./peer_drain.js');
 require('./relay-clamps-the-ttl.js');
 require('./relay-under-timeouts.js');
 require('./relay-kills-socket-after-timeouts.js');
+require('./object_pool.js');
+require('./peer-to-peer-load-balance.js');
 
 require('./trace/basic_server.js');
 require('./trace/server_2_requests.js');

package/test/lazy_conn_handler.js

@@ -20,6 +20,8 @@
 
 'use strict';
 
+var ReadResult = require('bufrw').ReadResult;
+
 var v2 = require('../v2/index.js');
 var allocCluster = require('./lib/alloc-cluster.js');
 
@@ -45,16 +47,18 @@ allocCluster.test('connection.handler: lazy call handling', 2, function t(cluste
         conn.handler.handleCallLazily = handleCallLazily;
     }
 
+    var readRes = new ReadResult();
+
     function handleCallLazily(frame) {
         // this is conn.handler
 
-        var res = frame.bodyRW.lazy.readService(frame);
+        var res = frame.bodyRW.lazy.poolReadService(readRes, frame);
         if (res.err) {
             throw res.err;
         }
         assert.equal(res.value, 'bob', 'expected called service name');
 
-        res = frame.bodyRW.lazy.readArg1(frame);
+        res = frame.bodyRW.lazy.poolReadArg1(readRes, frame);
         if (res.err) {
             throw res.err;
         }

package/test/lazy_handler.js

@@ -23,6 +23,10 @@
 var v2 = require('../v2/index.js');
 var allocCluster = require('./lib/alloc-cluster.js');
 
+var ReadResult = require('bufrw').ReadResult;
+
+var readRes = new ReadResult();
+
 allocCluster.test('channel.handler: lazy call handling', 2, function t(cluster, assert) {
     var one = cluster.channels[0];
     var two = cluster.channels[1];
@@ -42,13 +46,13 @@ allocCluster.test('channel.handler: lazy call handling', 2, function t(cluster,
     server.handler.handleLazily = handleCallLazily;
 
     function handleCallLazily(conn, frame) {
-        var res = frame.bodyRW.lazy.readService(frame);
+        var res = frame.bodyRW.lazy.poolReadService(readRes, frame);
         if (res.err) {
             throw res.err;
         }
         assert.equal(res.value, 'bob', 'expected called service name');
 
-        res = frame.bodyRW.lazy.readArg1(frame);
+        res = frame.bodyRW.lazy.poolReadArg1(readRes, frame);
         if (res.err) {
             throw res.err;
         }

package/test/lib/alloc-cluster.js

@@ -29,6 +29,7 @@ var debugLogtron = require('debug-logtron');
 
 var TChannel = require('../../channel.js');
 var CollapsedAssert = require('./collapsed-assert.js');
+var ObjectPool = require('../../lib/object_pool');
 
 var loadConfig = require('./load_config.js');
 
@@ -77,7 +78,8 @@ function allocCluster(opts) {
     var channelOptions = extend({
         logger: logger,
         timeoutFuzz: 0,
-        traceSample: 1
+        traceSample: 1,
+        objectPoolDebug: true
     }, defaultChannelOptions, opts.channelOptions || opts);
 
     for (var i = 0; i < opts.numPeers; i++) {
@@ -217,6 +219,8 @@ function clusterTester(opts, t) {
 
                     cluster.assertEmptyState(collapsedAssert);
                     collapsedAssert.report(assert, 'cluster has an empty state');
+
+                    checkObjectPools(assert);
                 }
                 cluster.destroy();
             });
@@ -225,6 +229,24 @@ function clusterTester(opts, t) {
     }
 }
 
+function checkObjectPools(assert) {
+    var i;
+    var pool;
+    var length;
+    for (i = 0; i < ObjectPool.pools.length; i++) {
+        pool = ObjectPool.pools[i];
+        length = pool.outstandingList.length;
+        assert.ok(
+            length === 0,
+            'expected object pool ' + pool.name + ' to have no outstanding ' +
+            'instances, found ' + length + ' instances'
+        );
+        if (length) {
+            assert.comment(util.inspect(pool.outstandingList));
+        }
+    }
+}
+
 allocCluster.test = function testCluster(desc, opts, t) {
     if (opts === undefined) {
         return test(desc);
@@ -237,6 +259,10 @@ allocCluster.test.only = function testClusterOnly(desc, opts, t) {
     test.only(desc, clusterTester(opts, t));
 };
 
+allocCluster.test.skip = function testClusterSkip(desc, opts, t) {
+    test.skip(desc, clusterTester(opts, t));
+};
+
 function connectChannels(channels, callback) {
     return parallel(channels.map(function (channel) {
         return function connectChannelToHosts(callback) {

package/test/lib/batch-client.js

@@ -24,6 +24,19 @@ var parallel = require('run-parallel');
 var collectParallel = require('collect-parallel/array');
 var setTimeout = require('timers').setTimeout;
 
+/*
+    BatchClient takes a channel and a set of peers to talk
+    to.
+
+    It has a set of options including:
+        - totalRequests
+        - delay
+        - batchSize
+
+    If you want to do 100QPS you can set batchSize=1 and delay=10
+    If you want to do 1000QPS you can set batchSize=50 and delay=50
+
+*/
 module.exports = BatchClient;
 
 function BatchClient(channel, hosts, options) {
@@ -42,11 +55,12 @@ function BatchClient(channel, hosts, options) {
     self.serviceName = 'server';
     self.endpoint = options.endpoint || 'echo';
     self.body = 'foobar';
-    self.timeout = 500;
+    self.timeout = options.timeout || 500;
 
     self.subChannel = self.channel.makeSubChannel({
         serviceName: self.serviceName,
-        peers: self.hosts
+        peers: self.hosts,
+        minConnections: options.minConnections || null
     });
 
     self.requestOptions = {
@@ -54,6 +68,7 @@ function BatchClient(channel, hosts, options) {
         hasNoParent: true,
         timeout: self.timeout,
         retryFlags: options && options.retryFlags,
+        retryLimit: options && options.retryLimit ? options.retryLimit : 5,
         headers: {
             cn: 'client',
             as: 'raw'

package/test/object_pool.js

@@ -0,0 +1,119 @@
+// Copyright (c) 2015 Uber Technologies, Inc.
+//
+// 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.
+
+'use strict';
+
+var test = require('tape');
+var ObjectPool = require('../lib/object_pool');
+var Timer = require('time-mock');
+
+function Widget() {
+    this.type = null;
+    this.count = null;
+}
+
+Widget.prototype.reset = function reset(options) {
+    this.type = options.type;
+    this.count = options.count;
+};
+
+Widget.prototype.clear = function clear() {
+    this.type = null;
+    this.count = null;
+}
+
+ObjectPool.setup({
+    Type: Widget,
+    maxSize: 2
+});
+
+test('object pool happy', function t1(assert) {
+    var timers = Timer(0);
+    var stats = {};
+    var channel = {emitFastStat: fakeEmitFastStat};
+
+    function fakeEmitFastStat(name, type, val, tags) {
+        stats[name + tags.toStatKey('')] = val;
+    }
+
+    ObjectPool.bootstrap({
+        channel: channel,
+        timers: timers,
+        reportInterval: 500
+    });
+
+    var pool = ObjectPool.pools.filter(function (p) {
+        return p.name === 'Widget';
+    })[0];
+
+    var w = Widget.alloc();
+    w.reset({type: 'foo', count: 10});
+
+    assert.equal(pool.freeList.length, 0, 'no free instances yet');
+    assert.equal(pool.outstanding, 1, '1 outstanding instace');
+
+    var w2 = Widget.alloc();
+    w2.reset({type: 'foo', count: 10});
+
+    assert.equal(pool.freeList.length, 0, 'no free instances yet');
+    assert.equal(pool.outstanding, 2, '2 outstanding instace');
+
+    var w3 = Widget.alloc();
+    w3.reset({type: 'foo', count: 10});
+
+    assert.equal(pool.freeList.length, 0, 'no free instances yet');
+    assert.equal(pool.outstanding, 3, '3 outstanding instace');
+
+    w.free();
+    // after w.free() the free list is still 0 because maxSize of the pool is 2
+
+    assert.equal(pool.freeList.length, 0, 'no free instances');
+    assert.equal(pool.outstanding, 2, '2 outstanding instace');
+
+    w2.free();
+
+    assert.equal(pool.freeList.length, 1, '1 free instance');
+    assert.equal(pool.outstanding, 1, '1 outstanding instace');
+
+    timers.advance(500);
+    assert.equal(stats['tchannel.object-pool.Widget.free'], 1);
+    assert.equal(stats['tchannel.object-pool.Widget.outstanding'], 1);
+
+    w = Widget.alloc();
+
+    assert.ok(w2 === w, 'object was allocated from free list');
+    assert.equal(w2.type, null, 'object type field was cleared');
+    assert.equal(w2.count, null, 'object count field was cleared');
+
+    assert.equal(pool.freeList.length, 0, '0 free instances');
+    assert.equal(pool.outstanding, 2, '2 outstanding instace');
+
+    w.free();
+    w3.free();
+
+    assert.equal(pool.freeList.length, 2, '2 free instances');
+    assert.equal(pool.outstanding, 0, '0 outstanding instace');
+
+    timers.advance(500);
+    assert.equal(stats['tchannel.object-pool.Widget.free'], 2);
+    assert.equal(stats['tchannel.object-pool.Widget.outstanding'], 0);
+
+    assert.end();
+});