1
0
Fork 0
arangodb/js/server/tests/replication/replication-random.js

336 lines
10 KiB
JavaScript

/*jshint globalstrict:false, strict:false, unused: false */
/*global assertEqual, assertTrue, 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 2017, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
var jsunity = require("jsunity");
var arangodb = require("@arangodb");
var db = arangodb.db;
var replication = require("@arangodb/replication");
var console = require("console");
var internal = require("internal");
var masterEndpoint = arango.getEndpoint();
var slaveEndpoint = ARGUMENTS[0];
////////////////////////////////////////////////////////////////////////////////
/// @brief test suite
////////////////////////////////////////////////////////////////////////////////
function ReplicationSuite() {
'use strict';
var cn = "UnitTestsReplication";
var cn2 = "UnitTestsReplication2";
var cn3 = "UnitTestsReplication3";
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 compareTicks = function(l, r) {
var i;
if (l === null) {
l = "0";
}
if (r === null) {
r = "0";
}
if (l.length !== r.length) {
return l.length - r.length < 0 ? -1 : 1;
}
// length is equal
for (i = 0; i < l.length; ++i) {
if (l[i] !== r[i]) {
return l[i] < r[i] ? -1 : 1;
}
}
return 0;
};
var compare = function(masterFunc, masterFunc2, slaveFuncFinal) {
var state = {};
assertEqual(cn, db._name());
db._flushCache();
masterFunc(state);
connectToSlave();
assertEqual(cn, db._name());
var syncResult = replication.sync({
endpoint: masterEndpoint,
username: "root",
password: "",
verbose: true,
includeSystem: false,
keepBarrier: true,
requireFromPresent: true,
});
assertTrue(syncResult.hasOwnProperty('lastLogTick'));
connectToMaster();
masterFunc2(state);
// use lastLogTick as of now
state.lastLogTick = replication.logger.state().state.lastLogTick;
let applierConfiguration = {
endpoint: masterEndpoint,
username: "root",
password: ""
};
connectToSlave();
assertEqual(cn, db._name());
replication.applier.properties(applierConfiguration);
replication.applier.start(syncResult.lastLogTick, syncResult.barrierId);
var printed = false;
while (true) {
var slaveState = replication.applier.state();
if (slaveState.state.lastError.errorNum > 0) {
console.log("slave has errored:", JSON.stringify(slaveState.state.lastError));
break;
}
if (!slaveState.state.running) {
console.log("slave is not running");
break;
}
if (compareTicks(slaveState.state.lastAppliedContinuousTick, state.lastLogTick) >= 0 ||
compareTicks(slaveState.state.lastProcessedContinuousTick, state.lastLogTick) >= 0) { // ||
// compareTicks(slaveState.state.lastAvailableContinuousTick, syncResult.lastLogTick) > 0) {
console.log("slave has caught up. state.lastLogTick:", state.lastLogTick, "slaveState.lastAppliedContinuousTick:", slaveState.state.lastAppliedContinuousTick, "slaveState.lastProcessedContinuousTick:", slaveState.state.lastProcessedContinuousTick);
break;
}
if (!printed) {
console.log("waiting for slave to catch up");
printed = true;
}
internal.wait(0.5, false);
}
db._flushCache();
slaveFuncFinal(state);
};
return {
setUp: function() {
db._useDatabase("_system");
connectToMaster();
try {
db._dropDatabase(cn);
} catch (err) {}
db._createDatabase(cn);
db._useDatabase(cn);
db._create(cn);
db._create(cn2);
db._create(cn3);
db._useDatabase("_system");
connectToSlave();
try {
db._dropDatabase(cn);
} catch (err) {}
db._createDatabase(cn);
},
tearDown: function() {
db._useDatabase("_system");
connectToMaster();
db._useDatabase(cn);
connectToSlave();
replication.applier.stop();
replication.applier.forget();
db._useDatabase("_system");
db._dropDatabase(cn);
},
testRandomTransactions: function() {
let nextId = 0;
let keys = { [cn]: [], [cn2]: [], [cn3]: [] };
let nextKey = function() {
return "test" + (++nextId);
};
let generateInsert = function(collections) {
let c = collections[Math.floor(Math.random() * collections.length)];
let key = nextKey();
keys[c][key] = 1;
return "db[" + JSON.stringify(c) + "].insert({ _key: " + JSON.stringify(key) + ", value: \"thisIsSomeStringValue\" });";
};
let generateUpdate = function(collections) {
let c = collections[Math.floor(Math.random() * collections.length)];
let all = Object.keys(keys[c]);
if (all.length === 0) {
// still empty, turn into an insert first
return generateInsert(collections);
}
let key = all[Math.floor(Math.random() * all.length)];
return "db[" + JSON.stringify(c) + "].update(" + JSON.stringify(key) + ", { value: \"thisIsSomeUpdatedStringValue\" });";
};
let generateReplace = function(collections) {
let c = collections[Math.floor(Math.random() * collections.length)];
let all = Object.keys(keys[c]);
if (all.length === 0) {
// still empty, turn into an insert first
return generateInsert(collections);
}
let key = all[Math.floor(Math.random() * all.length)];
return "db[" + JSON.stringify(c) + "].replace(" + JSON.stringify(key) + ", { value: \"thisIsSomeReplacedStringValue\" });";
};
let generateRemove = function(collections) {
let c = collections[Math.floor(Math.random() * collections.length)];
let all = Object.keys(keys[c]);
if (all.length === 0) {
// still empty, turn into an insert first
return generateInsert(collections);
}
let key = all[Math.floor(Math.random() * all.length)];
delete keys[c][key];
return "db[" + JSON.stringify(c) + "].remove(" + JSON.stringify(key) + ");";
};
let generateTruncate = function(collections) {
let c = collections[Math.floor(Math.random() * collections.length)];
keys[c] = {};
return "db[" + JSON.stringify(c) + "].truncate();";
};
let allOps = [
{ name: "insert", generate: generateInsert },
{ name: "update", generate: generateUpdate },
{ name: "replace", generate: generateReplace },
{ name: "remove", generate: generateRemove },
// { name: "truncate", generate: generateTruncate }
];
let createTransaction = function(state) {
let trx = { collections: { read: [], write: [] } };
// determine collections
do {
if (Math.random() >= 0.5) {
trx.collections.write.push(cn);
}
if (Math.random() >= 0.5) {
trx.collections.write.push(cn2);
}
if (Math.random() >= 0.5) {
trx.collections.write.push(cn3);
}
} while (trx.collections.write.length === 0);
let n = Math.floor(Math.random() * 100) + 1;
let ops = "function() { let db = require('internal').db;\n";
for (let i = 0; i < n; ++i) {
ops += allOps[Math.floor(Math.random() * allOps.length)].generate(trx.collections.write) + "\n";
}
trx.action = ops + " }";
return trx;
};
db._useDatabase(cn);
connectToMaster();
compare(
function(state) {
},
function(state) {
for (let i = 0; i < 10000; ++i) {
let trx = createTransaction(state);
db._executeTransaction(trx);
}
state.checksum = collectionChecksum(cn);
state.checksum2 = collectionChecksum(cn2);
state.checksum3 = collectionChecksum(cn3);
state.count = collectionCount(cn);
state.count2 = collectionCount(cn2);
state.count3 = collectionCount(cn3);
},
function(state) {
assertEqual(state.checksum, collectionChecksum(cn));
assertEqual(state.checksum2, collectionChecksum(cn2));
assertEqual(state.checksum3, collectionChecksum(cn3));
assertEqual(state.count, collectionCount(cn));
assertEqual(state.count2, collectionCount(cn2));
assertEqual(state.count3, collectionCount(cn3));
}
);
}
};
}
////////////////////////////////////////////////////////////////////////////////
/// @brief executes the test suite
////////////////////////////////////////////////////////////////////////////////
jsunity.run(ReplicationSuite);
return jsunity.done();