mirror of https://gitee.com/bigwinds/arangodb
464 lines
13 KiB
JavaScript
464 lines
13 KiB
JavaScript
/* jshint globalstrict:false, strict:false, unused: false */
|
|
/* global assertEqual, assertTrue, assertFalse, arango, ARGUMENTS */
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief test the replication
|
|
// /
|
|
// / @file
|
|
// /
|
|
// / DISCLAIMER
|
|
// /
|
|
// / Copyright 2010-2012 triagens GmbH, Cologne, Germany
|
|
// /
|
|
// / Licensed under the Apache License, Version 2.0 (the "License");
|
|
// / you may not use this file except in compliance with the License.
|
|
// / You may obtain a copy of the License at
|
|
// /
|
|
// / http://www.apache.org/licenses/LICENSE-2.0
|
|
// /
|
|
// / Unless required by applicable law or agreed to in writing, software
|
|
// / distributed under the License is distributed on an "AS IS" BASIS,
|
|
// / WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// / See the License for the specific language governing permissions and
|
|
// / limitations under the License.
|
|
// /
|
|
// / Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
// /
|
|
// / @author Jan Steemann
|
|
// / @author Copyright 2013, triAGENS GmbH, Cologne, Germany
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
var jsunity = require('jsunity');
|
|
var arangodb = require('@arangodb');
|
|
var db = arangodb.db;
|
|
|
|
var replication = require('@arangodb/replication');
|
|
var deriveTestSuite = require('@arangodb/test-helper').deriveTestSuite;
|
|
let compareTicks = replication.compareTicks;
|
|
var console = require('console');
|
|
var internal = require('internal');
|
|
var masterEndpoint = arango.getEndpoint();
|
|
var slaveEndpoint = ARGUMENTS[0];
|
|
|
|
var cn = 'UnitTestsReplication';
|
|
var cn2 = 'UnitTestsReplication2';
|
|
|
|
var connectToMaster = function () {
|
|
arango.reconnect(masterEndpoint, db._name(), 'root', '');
|
|
db._flushCache();
|
|
};
|
|
|
|
var connectToSlave = function () {
|
|
arango.reconnect(slaveEndpoint, db._name(), 'root', '');
|
|
db._flushCache();
|
|
};
|
|
|
|
var collectionChecksum = function (name) {
|
|
var c = db._collection(name).checksum(true, true);
|
|
return c.checksum;
|
|
};
|
|
|
|
var collectionCount = function (name) {
|
|
return db._collection(name).count();
|
|
};
|
|
|
|
var compare = function (masterFunc, masterFunc2, slaveFuncOngoing, slaveFuncFinal, applierConfiguration) {
|
|
var state = {};
|
|
|
|
db._flushCache();
|
|
masterFunc(state);
|
|
|
|
connectToSlave();
|
|
replication.applier.stop();
|
|
replication.applier.forget();
|
|
|
|
while (replication.applier.state().state.running) {
|
|
internal.wait(0.1, false);
|
|
}
|
|
|
|
var includeSystem = true;
|
|
var restrictType = '';
|
|
var restrictCollections = [];
|
|
applierConfiguration = applierConfiguration || { };
|
|
|
|
if (typeof applierConfiguration === 'object') {
|
|
if (applierConfiguration.hasOwnProperty('includeSystem')) {
|
|
includeSystem = applierConfiguration.includeSystem;
|
|
}
|
|
if (applierConfiguration.hasOwnProperty('restrictType')) {
|
|
restrictType = applierConfiguration.restrictType;
|
|
}
|
|
if (applierConfiguration.hasOwnProperty('restrictCollections')) {
|
|
restrictCollections = applierConfiguration.restrictCollections;
|
|
}
|
|
}
|
|
|
|
var keepBarrier = false;
|
|
if (applierConfiguration.hasOwnProperty('keepBarrier')) {
|
|
keepBarrier = applierConfiguration.keepBarrier;
|
|
}
|
|
|
|
var syncResult = replication.sync({
|
|
endpoint: masterEndpoint,
|
|
username: 'root',
|
|
password: '',
|
|
verbose: true,
|
|
includeSystem,
|
|
restrictType,
|
|
restrictCollections,
|
|
keepBarrier
|
|
});
|
|
|
|
assertTrue(syncResult.hasOwnProperty('lastLogTick'));
|
|
|
|
connectToMaster();
|
|
masterFunc2(state);
|
|
|
|
// use lastLogTick as of now
|
|
state.lastLogTick = replication.logger.state().state.lastUncommittedLogTick;
|
|
|
|
applierConfiguration = applierConfiguration || {};
|
|
applierConfiguration.endpoint = masterEndpoint;
|
|
applierConfiguration.username = 'root';
|
|
applierConfiguration.password = '';
|
|
applierConfiguration.force32mode = false;
|
|
|
|
if (!applierConfiguration.hasOwnProperty('chunkSize')) {
|
|
applierConfiguration.chunkSize = 16384;
|
|
}
|
|
|
|
connectToSlave();
|
|
|
|
replication.applier.properties(applierConfiguration);
|
|
if (keepBarrier) {
|
|
replication.applier.start(syncResult.lastLogTick, syncResult.barrierId);
|
|
} else {
|
|
replication.applier.start(syncResult.lastLogTick);
|
|
}
|
|
|
|
var printed = false;
|
|
|
|
while (true) {
|
|
var r = slaveFuncOngoing(state);
|
|
if (r === 'wait') {
|
|
// special return code that tells us to hang on
|
|
internal.wait(0.5, false);
|
|
continue;
|
|
}
|
|
if (!r) {
|
|
break;
|
|
}
|
|
|
|
var slaveState = replication.applier.state();
|
|
|
|
if (slaveState.state.lastError.errorNum > 0) {
|
|
console.topic('replication=error', 'slave has errored:', JSON.stringify(slaveState.state.lastError));
|
|
break;
|
|
}
|
|
|
|
if (!slaveState.state.running) {
|
|
console.topic('replication=error', 'slave is not running');
|
|
break;
|
|
}
|
|
|
|
if (compareTicks(slaveState.state.lastAppliedContinuousTick, state.lastLogTick) >= 0 ||
|
|
compareTicks(slaveState.state.lastProcessedContinuousTick, state.lastLogTick) >= 0) {
|
|
console.topic('replication=debug',
|
|
'slave has caught up. syncResult.lastLogTick:', state.lastLogTick,
|
|
'slaveState.lastAppliedContinuousTick:', slaveState.state.lastAppliedContinuousTick,
|
|
'slaveState.lastProcessedContinuousTick:', slaveState.state.lastProcessedContinuousTick);
|
|
break;
|
|
}
|
|
|
|
if (!printed) {
|
|
console.topic('replication=debug', 'waiting for slave to catch up');
|
|
printed = true;
|
|
}
|
|
internal.wait(0.5, false);
|
|
}
|
|
|
|
db._flushCache();
|
|
slaveFuncFinal(state);
|
|
};
|
|
|
|
var stopApplier = function (dbName) {
|
|
connectToSlave();
|
|
try {
|
|
db._useDatabase(dbName);
|
|
|
|
replication.applier.stop();
|
|
replication.applier.forget();
|
|
} catch (err) {
|
|
}
|
|
};
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief Basic test definition
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
function BaseTestConfig () {
|
|
'use strict';
|
|
|
|
return {
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief test require from present
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRequireFromPresentFalse: function () {
|
|
connectToMaster();
|
|
|
|
compare(
|
|
function (state) {
|
|
db._create(cn);
|
|
},
|
|
|
|
function (state) {
|
|
// flush the wal logs on the master so the start tick is not available
|
|
// anymore when we start replicating
|
|
for (var i = 0; i < 30; ++i) {
|
|
db._collection(cn).save({
|
|
value: i
|
|
});
|
|
internal.wal.flush();
|
|
}
|
|
db._collection(cn).save({
|
|
value: i
|
|
});
|
|
internal.wal.flush(true, true);
|
|
internal.wait(6, false);
|
|
},
|
|
|
|
function (state) {
|
|
return true;
|
|
},
|
|
|
|
function (state) {
|
|
if (db._engine().name === 'rocksdb') {
|
|
// rocksdb keeps wal longer
|
|
let cc = db._collection(cn).count();
|
|
assertEqual(cc, 31, 'rocksdb must keep wal, documents not there');
|
|
} else {
|
|
// data loss on slave!
|
|
let cc = db._collection(cn).count();
|
|
assertTrue(cc < 25, 'Expected less than ' + cc);
|
|
}
|
|
}, {
|
|
requireFromPresent: false,
|
|
keepBarrier: false
|
|
}
|
|
);
|
|
},
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief test require from present
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRequireFromPresentTrue: function () {
|
|
connectToMaster();
|
|
|
|
compare(
|
|
function (state) {
|
|
db._create(cn);
|
|
},
|
|
|
|
function (state) {
|
|
// flush the wal logs on the master so the start tick is not available
|
|
// anymore when we start replicating
|
|
for (var i = 0; i < 30; ++i) {
|
|
db._collection(cn).save({
|
|
value: i
|
|
});
|
|
internal.wal.flush();
|
|
}
|
|
internal.wal.flush(true, true);
|
|
internal.wait(6, false);
|
|
|
|
state.checksum = collectionChecksum(cn);
|
|
state.count = collectionCount(cn);
|
|
assertEqual(30, state.count);
|
|
},
|
|
|
|
function (state) {
|
|
// wait for slave applier to have started and run
|
|
internal.wait(5, false);
|
|
|
|
// slave should not have stopped
|
|
assertTrue(replication.applier.state().state.running);
|
|
return true;
|
|
},
|
|
|
|
function (state) {
|
|
assertEqual(state.count, collectionCount(cn));
|
|
assertEqual(state.checksum, collectionChecksum(cn));
|
|
},
|
|
{
|
|
requireFromPresent: true,
|
|
keepBarrier: true
|
|
}
|
|
);
|
|
},
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief test require from present, no barrier
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
testRequireFromPresentTrueNoBarrier: function () {
|
|
connectToMaster();
|
|
|
|
compare(
|
|
function (state) {
|
|
db._create(cn);
|
|
},
|
|
|
|
function (state) {
|
|
// flush the wal logs on the master so the start tick is not available
|
|
// anymore when we start replicating
|
|
for (var i = 0; i < 30; ++i) {
|
|
db._collection(cn).save({
|
|
value: i
|
|
});
|
|
internal.wal.flush();
|
|
}
|
|
internal.wal.flush(true, true);
|
|
internal.wait(6, false);
|
|
},
|
|
|
|
function (state) {
|
|
// wait for slave applier to have started and detect the mess
|
|
return replication.applier.state().state.running;
|
|
},
|
|
|
|
function (state) {
|
|
if (db._engine().name === 'rocksdb') {
|
|
// rocksdb keeps wal longer
|
|
assertTrue(replication.applier.state().state.running, 'Applier should be running');
|
|
assertEqual(db._collection(cn).count(), 30, 'rocksdb must keep wal');
|
|
} else {
|
|
// slave should have failed
|
|
assertFalse(replication.applier.state().state.running);
|
|
// data loss on slave!
|
|
assertTrue(db._collection(cn).count() < 25);
|
|
}
|
|
},
|
|
{
|
|
requireFromPresent: true,
|
|
keepBarrier: false
|
|
}
|
|
);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief Test suite for _system database
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ReplicationSuite () {
|
|
let suite = {
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief set up
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp: function () {
|
|
stopApplier('_system');
|
|
|
|
connectToMaster();
|
|
|
|
db._drop(cn);
|
|
db._drop(cn2);
|
|
},
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief tear down
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown: function () {
|
|
stopApplier('_system');
|
|
|
|
connectToMaster();
|
|
db._drop(cn);
|
|
db._drop(cn2);
|
|
|
|
connectToSlave();
|
|
db._drop(cn);
|
|
db._drop(cn2);
|
|
}
|
|
};
|
|
deriveTestSuite(BaseTestConfig(), suite, '_Repl');
|
|
|
|
return suite;
|
|
}
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief Test suite for other database
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
function ReplicationOtherDBSuite () {
|
|
const dbName = 'UnitTestDB';
|
|
|
|
let suite = {
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief set up
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
setUp: function () {
|
|
stopApplier(dbName);
|
|
|
|
db._useDatabase('_system');
|
|
connectToSlave();
|
|
try {
|
|
db._dropDatabase(dbName);
|
|
} catch (e) {
|
|
}
|
|
|
|
db._createDatabase(dbName);
|
|
|
|
connectToMaster();
|
|
|
|
try {
|
|
db._dropDatabase(dbName);
|
|
} catch (e) {
|
|
}
|
|
db._createDatabase(dbName);
|
|
db._useDatabase(dbName);
|
|
},
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief tear down
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
tearDown: function () {
|
|
stopApplier(dbName);
|
|
|
|
db._useDatabase('_system');
|
|
connectToMaster();
|
|
try {
|
|
db._dropDatabase(dbName);
|
|
} catch (e) {
|
|
}
|
|
|
|
db._useDatabase('_system');
|
|
try {
|
|
db._dropDatabase(dbName);
|
|
} catch (e) {
|
|
}
|
|
}
|
|
};
|
|
|
|
deriveTestSuite(BaseTestConfig(), suite, '_OtherRepl');
|
|
return suite;
|
|
}
|
|
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
// / @brief executes the test suite
|
|
// //////////////////////////////////////////////////////////////////////////////
|
|
|
|
jsunity.run(ReplicationSuite);
|
|
jsunity.run(ReplicationOtherDBSuite);
|
|
|
|
return jsunity.done();
|