function askNeighbor(neighbor, done) {
self._network._transport.send(neighbor, kad.Message({
method: 'FIND_TUNNEL',
params: {
contact: self._network._contact,
relayers: [self._network.contact].concat(relayers)
}
}), function(err, response) {
if (err || !Array.isArray(response.result.tunnels)) {
return done(false);
}
if (response.result.tunnels && response.result.tunnels.length) {
response.result.tunnels.forEach(function(tun) {
if (self._network._tunnelers.getSize() < kad.constants.K) {
self._network._tunnelers.addContact(
self._network._transport._createContact(tun)
);
}
});
return done(true);
}
done(false);
});
}
gateway.on('message/rpc', function(rpc) {
var resp = gateway.respond(kad.Message({
id: rpc.id,
result: { text: 'hello gateway friend' }
}));
expect(resp).to.equal(true);
});
it('should ask neighbors for tunnels if not offering any', function(done) {
var renter = renters[renters.length - 1];
var farmer = farmers[0];
renter._transport.send(farmer._contact, kad.Message({
method: 'FIND_TUNNEL',
params: { contact: renter._contact }
}), function(err, response) {
expect(err).to.equal(null);
expect(response.result.tunnels).to.have.lengthOf(2);
done();
});
});
it('should read the correct format for RPC messages', function(done) {
var time = Date.now();
tmuxer.once('data', function(data) {
expect(Buffer.compare(
data.slice(0, 1),
Buffer([constants.OPCODE_TUNRPC_PREFIX])
)).to.equal(0);
expect(kad.Message.fromBuffer(data.slice(1)).method).to.equal('PING');
expect(kad.Message.fromBuffer(data.slice(1)).params.t).to.equal(time);
done();
});
gateway.emit('message/rpc', kad.Message({
method: 'PING',
params: { t: time }
}));
});
TunnelGateway.prototype.respond = function(message) {
var response = kad.Message(message);
if (!this._responses[message.id]) {
return false;
}
try {
this._responses[message.id].end(response.serialize());
delete this._responses[message.id];
} catch (err) {
return false;
}
return true;
};
client.post('/', parsedMessage, (err, req, res, data) => {
if (err) {
self._log.warn('error returned from remote host: %s', err.message);
return self.receive(null);
}
let message;
try {
message = kad.Message(data);
} catch (err) {
return self.receive(null);
}
self.receive(message.serialize(), {});
});
function openTunnel(done) {
if (!tunnels.length) {
return done(new Error('No tunnelers were returned'));
}
var tun = new Contact(tunnels[0]);
var msg = kad.Message({
method: 'OPEN_TUNNEL',
params: { contact: self._contact }
});
tunnels.shift();
self._transport.send(tun, msg, function(err, resp) {
if (err) {
return done();
}
tunnel = resp.result.tunnel;
alias = resp.result.alias;
done();
});
}