mirror of
https://github.com/expo/rethinkdbdash.git
synced 2026-11-15 17:40:35 -10:00
619 lines
18 KiB
JavaScript
619 lines
18 KiB
JavaScript
var Server = require(__dirname+'/util/fake_server/index.js')
|
|
var config = require(__dirname+'/config.js');
|
|
var server1 = new Server({
|
|
host: 'localhost',
|
|
port: config.port+17
|
|
})
|
|
var server2 = new Server({
|
|
host: 'localhost',
|
|
port: config.port+18
|
|
})
|
|
var server3 = new Server({
|
|
host: 'localhost',
|
|
port: config.port+19
|
|
})
|
|
var assert = require('assert');
|
|
var util = require(__dirname+'/util/common.js');
|
|
var uuid = util.uuid;
|
|
var It = util.It;
|
|
|
|
var uuid = util.uuid;
|
|
var dbName, tableName, result, pks;
|
|
|
|
It('Test fake server', function* (done) {
|
|
var r = require(__dirname+'/../lib')({pool: false});
|
|
try {
|
|
var connection = yield r.connect({
|
|
host: server1.host,
|
|
port: server1.port
|
|
});
|
|
var expected = 200;
|
|
var start = Date.now();
|
|
//var result = yield r.expr(expected).run(connection);
|
|
var result = yield r.expr(expected).run(connection);
|
|
var end = Date.now();
|
|
assert(end-start >= expected);
|
|
assert(end-start < expected+100);
|
|
assert.equal(result, expected);
|
|
yield connection.close();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
|
|
It('Test pool no query with discovery: false', function* (done) {
|
|
server1.mockServersStatus([server1])
|
|
var r = require(__dirname+'/../lib')({
|
|
host: server1.host,
|
|
port: server1.port,
|
|
max: 10,
|
|
buffer: 5,
|
|
discovery: false
|
|
});
|
|
|
|
try {
|
|
var result = yield util.sleep(200);
|
|
// 5 connections are immediately created
|
|
assert.equal(r.getPool(0).getLength(), 5);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test pool no query with discovery: true', function* (done) {
|
|
server1.mockServersStatus([server1])
|
|
var r = require(__dirname+'/../lib')({
|
|
host: server1.host,
|
|
port: server1.port,
|
|
max: 10,
|
|
buffer: 5
|
|
});
|
|
|
|
try {
|
|
var result = yield util.sleep(200);
|
|
// 5 connections are immediately created
|
|
// 1 connection for fetchServer (via expandAll)
|
|
// 1 connection for fetchServer (via getConnection to refill the buffer)
|
|
assert.equal(r.getPool(0).getLength(), 7);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test expanding the pool with discovery: false', function* (done) {
|
|
server1.mockServersStatus([server1])
|
|
var r = require(__dirname+'/../lib')({
|
|
host: server1.host,
|
|
port: server1.port,
|
|
max: 9,
|
|
buffer: 5,
|
|
discovery: false
|
|
});
|
|
try {
|
|
yield util.sleep(1000);
|
|
assert.equal(r.getPool().getLength(), 5);
|
|
var result = yield [
|
|
r.expr(200).run(),
|
|
r.expr(200).run()
|
|
]
|
|
assert.equal(result.length, 2);
|
|
assert.equal(r.getPool().getLength(), 7);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test expanding the pool with discovery: true', function* (done) {
|
|
server1.mockServersStatus([server1])
|
|
var r = require(__dirname+'/../lib')({
|
|
host: server1.host,
|
|
port: server1.port,
|
|
max: 11,
|
|
buffer: 5
|
|
});
|
|
try {
|
|
yield util.sleep(300);
|
|
assert.equal(r.getPool().getLength(), 7);
|
|
var result = yield [
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run()
|
|
]
|
|
assert.equal(result.length, 3);
|
|
assert.equal(r.getPool().getLength(), 8);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test expanding the pool to max with discovery: false', function* (done) {
|
|
server1.mockServersStatus([server1])
|
|
var r = require(__dirname+'/../lib')({
|
|
host: server1.host,
|
|
port: server1.port,
|
|
max: 9,
|
|
buffer: 5,
|
|
discovery: false
|
|
});
|
|
try {
|
|
var result = yield [
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run()
|
|
]
|
|
assert.equal(result.length, 10);
|
|
assert.equal(r.getPool(0).getLength(), 9);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test expanding the pool to max with discovery: true', function* (done) {
|
|
server1.mockServersStatus([server1])
|
|
var r = require(__dirname+'/../lib')({
|
|
host: server1.host,
|
|
port: server1.port,
|
|
max: 9,
|
|
buffer: 5
|
|
});
|
|
try {
|
|
yield util.sleep(100);
|
|
assert.equal(r.getPool(0).getLength(), 7);
|
|
var result = yield [
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run(),
|
|
r.expr(200).run()
|
|
]
|
|
assert.equal(result.length, 11);
|
|
assert.equal(r.getPool(0).getLength(), 9);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test multiple pools with late start', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port},
|
|
{host: server2.host, port: server2.port},
|
|
{host: server3.host, port: server3.port}
|
|
],
|
|
max: 15*3,
|
|
buffer: 5*3
|
|
});
|
|
try {
|
|
yield util.sleep(500);
|
|
// all +1 for expandAll, and the first pool execute fetchServer
|
|
// and recrete a connection as the first 5 have not yet returned
|
|
var result = {6: 0, 7: 0};
|
|
var pools = r.getPoolMaster().getPools();
|
|
result[pools[0].getLength()]++;
|
|
result[pools[1].getLength()]++;
|
|
result[pools[2].getLength()]++;
|
|
|
|
assert.deepEqual(result, {6: 2, 7: 1});
|
|
var result = yield [
|
|
r.expr(400).run(),
|
|
r.expr(400).run(),
|
|
r.expr(400).run(),
|
|
r.expr(400).run(),
|
|
r.expr(400).run(),
|
|
r.expr(400).run(),
|
|
r.expr(400).run(),
|
|
r.expr(400).run(),
|
|
r.expr(400).run()
|
|
]
|
|
assert.equal(result.length, 9);
|
|
// 8 = 9/3+5
|
|
// 5 = buffer
|
|
assert.equal(r.getPool(0).getLength(), 8);
|
|
assert.equal(r.getPool(1).getLength(), 8);
|
|
assert.equal(r.getPool(2).getLength(), 8);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test multiple pools with early start', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port},
|
|
{host: server2.host, port: server2.port},
|
|
{host: server3.host, port: server3.port}
|
|
],
|
|
max: 15*3,
|
|
buffer: 5*3
|
|
});
|
|
try {
|
|
// All these queries are fired on an empty pool master,
|
|
// so they will each trigger expandAll
|
|
// There's also a fetchServer happening
|
|
var result = yield [
|
|
r.expr(1000).run(),
|
|
r.expr(1000).run()
|
|
]
|
|
|
|
// fetchServer: all -> +1
|
|
// queries: all +> + 1
|
|
// server1 returns connection first and execute all the queries
|
|
// +1 for each of them as getConnection will call expandBuffer with no available connection
|
|
yield util.sleep(100);
|
|
|
|
assert.equal(result.length, 2);
|
|
var result = {8: 0, 11: 0};
|
|
result[r.getPool(0).getLength()]++;
|
|
result[r.getPool(1).getLength()]++;
|
|
result[r.getPool(2).getLength()]++;
|
|
|
|
assert.deepEqual(result, {8: 2, 11: 1});
|
|
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test multiple pools - kill a server - check options', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port},
|
|
{host: server2.host, port: server2.port},
|
|
{host: server3.host, port: server3.port}
|
|
],
|
|
max: 10*3,
|
|
buffer: 4*3,
|
|
silent: true
|
|
});
|
|
try {
|
|
yield util.sleep(100);
|
|
server2.close();
|
|
|
|
yield util.sleep(4000);
|
|
assert.equal(r.getPool(0).options.max, 15);
|
|
assert.equal(r.getPool(1).options.max, 10);
|
|
assert.equal(r.getPool(2).options.max, 15);
|
|
assert.equal(r.getPool(0).options.buffer, 6);
|
|
assert.equal(r.getPool(1).options.buffer, 4);
|
|
assert.equal(r.getPool(2).options.buffer, 6);
|
|
|
|
yield r.getPoolMaster().drain();
|
|
// Restart server2 since we killed it
|
|
server2 = new Server({
|
|
host: 'localhost',
|
|
port: server2.port
|
|
})
|
|
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test multiple pools - kill a server while running queries', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port},
|
|
{host: server2.host, port: server2.port},
|
|
{host: server3.host, port: server3.port}
|
|
],
|
|
max: 10*3,
|
|
buffer: 4*3,
|
|
silent: true
|
|
});
|
|
try {
|
|
yield util.sleep(100);
|
|
var success = 0;
|
|
var error = 0;
|
|
for(var i=0; i<9; i++) {
|
|
r.expr(100).run().then(function() {
|
|
success++;
|
|
}).error(function() {
|
|
error++;
|
|
});
|
|
}
|
|
server2.destroy();
|
|
yield util.sleep(1000);
|
|
assert.equal(r.getPool(0).options.max, 15);
|
|
assert.equal(r.getPool(1).options.max, 10);
|
|
assert.equal(r.getPool(2).options.max, 15);
|
|
assert.equal(r.getPool(0).options.buffer, 6);
|
|
assert.equal(r.getPool(1).options.buffer, 4);
|
|
assert.equal(r.getPool(2).options.buffer, 6);
|
|
|
|
assert.equal(success, 6);
|
|
assert.equal(error, 3);
|
|
|
|
yield r.getPoolMaster().drain();
|
|
// Restart server2 since we killed it
|
|
server2 = new Server({
|
|
host: 'localhost',
|
|
port: server2.port
|
|
})
|
|
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test multiple pools - kill a server and restart it - discovery: true', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port},
|
|
{host: server2.host, port: server2.port},
|
|
{host: server3.host, port: server3.port}
|
|
],
|
|
max: 10*3,
|
|
buffer: 4*3,
|
|
silent: true
|
|
});
|
|
try {
|
|
yield util.sleep(100);
|
|
var success = 0;
|
|
var error = 0;
|
|
for(var i=0; i<9; i++) {
|
|
r.expr(100).run().then(function() {
|
|
success++;
|
|
}).error(function() {
|
|
error++;
|
|
});
|
|
}
|
|
server2.destroy();
|
|
yield util.sleep(1000);
|
|
// Attempt to fill the two remaining pools
|
|
for(var i=0; i<30; i++) {
|
|
r.expr(100).run().then(function() {
|
|
success++;
|
|
}).error(function() {
|
|
error++;
|
|
});
|
|
}
|
|
|
|
// Restart server2 since we killed it
|
|
server2 = new Server({
|
|
host: server2.host,
|
|
port: server2.port
|
|
})
|
|
|
|
yield util.sleep(2000);
|
|
assert.equal(r.getPool(0).options.max, 10);
|
|
assert.equal(r.getPool(1).options.max, 10);
|
|
assert.equal(r.getPool(2).options.max, 10);
|
|
assert.equal(r.getPool(0).options.buffer, 4);
|
|
assert.equal(r.getPool(1).options.buffer, 4);
|
|
assert.equal(r.getPool(2).options.buffer, 4);
|
|
|
|
assert.equal(success, 6+30);
|
|
assert.equal(error, 3);
|
|
|
|
var p = []
|
|
for(var i=0; i<40; i++) {
|
|
p.push(r.expr(100).run());
|
|
}
|
|
var result =yield p;
|
|
assert.equal(result.length, 40);
|
|
yield util.sleep(1000); // yield to let the connection some time to close
|
|
assert.equal(r.getPool(0).getLength(), 10);
|
|
assert.equal(r.getPool(1).getLength(), 10);
|
|
assert.equal(r.getPool(2).getLength(), 10);
|
|
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test multiple pools - kill a server and restart it - discovery: false', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port},
|
|
{host: server2.host, port: server2.port},
|
|
{host: server3.host, port: server3.port}
|
|
],
|
|
max: 10*3,
|
|
buffer: 4*3,
|
|
silent: true,
|
|
discovery: false
|
|
});
|
|
try {
|
|
yield util.sleep(100);
|
|
var success = 0;
|
|
var error = 0;
|
|
for(var i=0; i<9; i++) {
|
|
r.expr(300).run().then(function(result) {
|
|
success++;
|
|
}).error(function() {
|
|
error++;
|
|
});
|
|
}
|
|
server2.destroy();
|
|
yield util.sleep(1000);
|
|
server2 = new Server({
|
|
host: server2.host,
|
|
port: server2.port
|
|
})
|
|
|
|
yield util.sleep(2000);
|
|
assert.equal(r.getPool(0).options.max, 10);
|
|
assert.equal(r.getPool(1).options.max, 10);
|
|
assert.equal(r.getPool(2).options.max, 10);
|
|
assert.equal(r.getPool(0).options.buffer, 4);
|
|
assert.equal(r.getPool(1).options.buffer, 4);
|
|
assert.equal(r.getPool(2).options.buffer, 4);
|
|
|
|
assert.equal(success, 6);
|
|
assert.equal(error, 3);
|
|
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test adding a new server', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
server1.mockServersStatus([server1, server2])
|
|
server2.mockServersStatus([server1, server2])
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port}
|
|
],
|
|
max: 10*3,
|
|
buffer: 4*3,
|
|
silent: true,
|
|
discovery: true
|
|
});
|
|
try {
|
|
assert.equal(r.getPoolMaster().getPools().length, 1);
|
|
yield util.sleep(1000);
|
|
assert.equal(r.getPoolMaster().getPools().length, 2);
|
|
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
|
|
r.getPoolMaster().fetchServers();
|
|
yield util.sleep(1000);
|
|
assert.equal(r.getPoolMaster().getPools().length, 3);
|
|
yield r.getPoolMaster().drain();
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|
|
It('Test removing a new server', function* (done) {
|
|
server1.cleanMockServersStatus();
|
|
server2.cleanMockServersStatus();
|
|
server3.cleanMockServersStatus();
|
|
server1.mockServersStatus([server1, server2, server3])
|
|
server2.mockServersStatus([server1, server2, server3])
|
|
server3.mockServersStatus([server1, server2, server3])
|
|
|
|
server1.mockServersStatus([server1, server3])
|
|
server3.mockServersStatus([server1, server3])
|
|
|
|
var r = require(__dirname+'/../lib')({
|
|
hosts: [
|
|
{host: server1.host, port: server1.port}
|
|
],
|
|
max: 10*3,
|
|
buffer: 4*3,
|
|
silent: true,
|
|
discovery: true
|
|
});
|
|
try {
|
|
assert.equal(r.getPoolMaster().getPools().length, 1);
|
|
yield util.sleep(500);
|
|
assert.equal(r.getPoolMaster().getPools().length, 3);
|
|
|
|
yield util.sleep(500);
|
|
server1.mockServersStatus([server1, server3])
|
|
server3.mockServersStatus([server1, server3])
|
|
|
|
server2.close();
|
|
|
|
yield util.sleep(500);
|
|
assert.equal(r.getPoolMaster().getPools().length, 2);
|
|
done();
|
|
}
|
|
catch(e) {
|
|
done(e);
|
|
}
|
|
});
|