function runSetup () {
'use strict';
var i;
internal.debugClearFailAt();
internal.wal.properties({ historicLogfiles: 0 });
db._drop("test");
db._create("test");
db._createDatabase("UnitTestsRecovery");
internal.wal.flush(true, true, true);
internal.wait(3, true);
db._useDatabase("UnitTestsRecovery");
db._create("test");
for (i = 0; i < 100; ++i) {
db.test.save({ _key: "test" + i, value: i });
}
db._useDatabase("_system");
db._dropDatabase("UnitTestsRecovery");
internal.wait(5, true);
db.test.save({ _key: "crashme" }, true);
internal.debugSegfault("crashing server");
}
function runSetup () {
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
var c = db._create("UnitTestsRecovery"), i;
internal.wal.flush(true, true);
internal.wal.properties({ throttleWait: 1000, throttleWhenPending: 1000 });
for (i = 0; i < 10000; ++i) {
c.save({ _key: "test" + i, value1: "test" + i, value2: i });
}
internal.debugSetFailAt("CollectorThreadProcessQueuedOperations");
internal.wal.flush(true, false);
// now let the write throttling become active
internal.wait(7);
try {
c.save({ _key: "foo" });
}
catch (err) {
}
internal.debugSegfault("crashing server");
}
function runSetup () {
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
db._create("UnitTestsRecovery");
internal.debugSetFailAt("CreateJournalDocumentCollection");
db._executeTransaction({
collections: {
write: "UnitTestsRecovery"
},
action: function () {
var db = require("org/arangodb").db;
var i, c = db._collection("UnitTestsRecovery");
for (i = 0; i < 100000; ++i) {
c.save({ _key: "test" + i, value1: "test" + i, value2: i }, true); // wait for sync
}
for (i = 0; i < 100000; i += 2) {
c.remove("test" + i, true);
}
}
});
internal.wal.flush();
internal.wait(5);
internal.debugSegfault("crashing server");
}
function put_api_cursor (req, res) {
if (req.suffix.length !== 1) {
actions.resultBad(req, res, arangodb.ERROR_HTTP_BAD_PARAMETER);
return;
}
var cursorId = decodeURIComponent(req.suffix[0]);
var cursor = CURSOR(cursorId);
if (! (cursor instanceof arangodb.ArangoCursor)) {
actions.resultBad(req, res, arangodb.ERROR_CURSOR_NOT_FOUND);
return;
}
try {
// note: this might dispose or persist the cursor
actions.resultCursor(req, res, cursor, actions.HTTP_OK);
}
catch (e) {
}
// force garbage-collection
cursor = null;
internal.wait(0.0);
}
upgradeActions.createSystemColls = function (dispatchers, cmd, isRelaunch,
username, password) {
// We wait another half second (we have already waited for all servers
// until they responded!), just to be on the safe side:
wait(0.5);
var hdrs = {
Authorization: getAuthorizationHeader(username, password)
// default username and passwd, this will work just after cluster creation
// for upgrade we document that this credentials have to work
};
console.info("Running upgrade script on whole cluster...");
var url = cmd.url + "/_admin/execute?returnAsJSON=true";
var body = 'load=require("internal").load;\n'+
'UPGRADE_ARGS=undefined;\n'+
'return load('+JSON.stringify(
fs.join(ArangoServerState.javaScriptPath(),
makePath("server/version-check.js")))+
');\n';
var o = { method: "POST", timeout: 90, headers: hdrs };
var r = download(url, body, o);
if (r.code === 200) {
r = JSON.parse(r.body);
r.isCreateSystemColls = true;
return r;
}
r.error = true;
r.isCreateSystemColls = true;
return r;
};
function RunCommandLineTests () {
var result = true;
var unitTests = internal.unitTests();
for (var i = 0; i < unitTests.length; ++i) {
var file = unitTests[i];
print();
print("running tests from file '" + file + "'");
try {
var ok = RunTest(file);
result = result && ok;
}
catch (err) {
print("cannot run test file '" + file + "': " + err);
print(err.stack);
result = false;
}
internal.wait(0); // force GC
}
internal.setUnitTestsResult(result);
}
_.each(tests, function (file) {
if (result) {
print("\n" + Date() + " " + runenvironment + ": Running JSUnity test from file '" + file + "'");
}
else {
print("\n" + Date() + " " + runenvironment +
": Skipping JSUnity test from file '" + file + "' due to previous errors");
}
try {
res = runTest(file, true);
allResults.push(res);
result = result && res.status;
if (! res.status) {
failed.push(file);
}
}
catch (err) {
print(runenvironment + ": cannot run test file '" + file + "': " + err);
print(err.stack);
print(err.message);
result = false;
}
internal.wait(0); // force GC
});
function runSetup () {
'use strict';
internal.debugClearFailAt();
var appPath = fs.join(FoxxService._appPath, "..");
try {
db._dropDatabase("UnitTestsRecovery1");
}
catch (err) {
}
db._createDatabase("UnitTestsRecovery1");
fs.write(fs.join(appPath, "UnitTestsRecovery1", "foo.json"), "test");
try {
db._dropDatabase("UnitTestsRecovery2");
}
catch (err) {
}
db._createDatabase("UnitTestsRecovery2");
fs.write(fs.join(appPath, "UnitTestsRecovery2", "bar.json"), "test");
db._dropDatabase("UnitTestsRecovery2");
internal.wait(1);
internal.debugSegfault("crashing server");
}
function runSetup () {
'use strict';
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
var c = db._create("UnitTestsRecovery");
internal.wal.flush(true, true);
internal.debugSetFailAt("CreateDatafile1");
internal.debugSetFailAt("LogfileManagerGetWriteableLogfile");
c.insert({ value: 1 });
try {
internal.wal.flush();
fail();
}
catch (err) {
}
internal.wait(3);
try {
c.save({ _key: "crashme" }, true); // wait for sync
fail();
}
catch (err) {
}
internal.debugSegfault("crashing server");
}
shutdownActions.startServers = function (dispatchers, cmd, run) {
var i;
var url;
var r;
for (i = 0;i < run.endpoints.length;i++) {
console.info("Using API to shutdown %s", JSON.stringify(run.pids[i]));
url = endpointToURL(run.endpoints[i])+"/_admin/shutdown";
// We use the cluster-internal authentication:
var hdrs = { Authorization : ArangoServerState.getClusterAuthentication() };
r = download(url,"",{method:"GET", headers: hdrs});
if (r.code !== 200) {
console.info("Shutdown API result:"+JSON.stringify(r));
}
}
for (i = 0;i < run.endpoints.length;i++) {
waitForServerDown(run.endpoints[i], 30);
// we cannot do much with the result...
}
console.info("Waiting 8 seconds for servers to shutdown gracefully...");
wait(8);
for (i = 0;i < run.pids.length;i++) {
var s = statusExternal(run.pids[i]);
if (s.status !== "TERMINATED") {
console.info("Shutting down %s the hard way...",
JSON.stringify(run.pids[i]));
killExternal(run.pids[i]);
console.info("done.");
}
}
return {"error": false, "isStartServers": true};
};
function sendToAgency (agencyURL, path, obj) {
var res;
var body;
console.info("Sending %s to agency...", path);
if (typeof obj === "string") {
var count = 0;
while (count++ <= 2) {
body = "value="+encodeURIComponent(obj);
res = download(agencyURL+path,body,
{"method":"PUT", "followRedirects": true,
"headers": { "Content-Type": "application/x-www-form-urlencoded"}});
if (res.code === 201 || res.code === 200) {
return true;
}
wait(3); // wait 3 seconds before trying again
}
return res;
}
if (typeof obj !== "object") {
return "Strange object found: not a string or object";
}
var keys = Object.keys(obj);
var i;
if (keys.length !== 0) {
for (i = 0; i < keys.length; i++) {
res = sendToAgency (agencyURL, path+"/"+encode(keys[i]), obj[keys[i]]);
if (res !== true) {
return res;
}
}
return true;
}
// Create a directory
var count2 = 0;
while (count2++ <= 2) {
body = "dir=true";
res = download(agencyURL+path,body,
{"method": "PUT", "followRedirects": true,
"headers": { "Content-Type": "application/x-www-form-urlencoded"}});
if (res.code === 201 || res.code === 200) {
return true;
}
wait(3); // wait 3 seconds before trying again
}
return res;
}
callback : function (req, res) {
var time = parseFloat(req.parameters.duration);
if (isNaN(time)) {
time = 3.0;
}
internal.wait(time);
actions.resultOk(req, res, actions.HTTP_OK, { duration : time });
}
function runSetup () {
'use strict';
internal.debugClearFailAt();
var c, i, j;
for (i = 0 ; i < 10; ++i) {
db._drop("UnitTestsRecovery" + i);
// use fake collection ids
c = db._create("UnitTestsRecovery" + i, { "id" : 9999990 + i });
for (j = 0; j < 10; ++j) {
c.save({ _key: "test" + j, value: j });
}
}
// drop 'em all
for (i = 0; i < 10; ++i) {
db._drop("UnitTestsRecovery" + i);
}
internal.wait(5);
for (i = 0; i < 10; ++i) {
c = db._create("UnitTestsRecoveryX" + i, { "id" : 9999990 + i });
for (j = 0; j < 10; ++j) {
c.save({ _key: "test" + j, value: "X" + j });
}
}
// drop 'em all
for (i = 0; i < 10; ++i) {
db._drop("UnitTestsRecoveryX" + i);
}
internal.wait(5);
for (i = 0; i < 10; ++i) {
c = db._create("UnitTestsRecoveryY" + i, { "id" : 9999990 + i });
for (j = 0; j < 10; ++j) {
c.save({ _key: "test" + j, value: "peterY" + j });
}
}
db._drop("test");
c = db._create("test");
c.save({ _key: "crashme" }, true);
internal.debugSegfault("crashing server");
}
function runSetup () {
"use strict";
internal.debugClearFailAt();
var i, paths = [ ];
for (i = 0; i < 3; ++i) {
db._useDatabase("_system");
try {
db._dropDatabase("UnitTestsRecovery" + i);
}
catch (err) {
}
db._createDatabase("UnitTestsRecovery" + i);
db._useDatabase("UnitTestsRecovery" + i);
paths[i] = db._path();
db._useDatabase("_system");
db._dropDatabase("UnitTestsRecovery" + i);
}
db._drop("test");
var c = db._create("test");
c.save({ _key: "crashme" }, true);
internal.wait(3, true);
for (i = 0; i < 3; ++i) {
// re-create database directory
try {
fs.makeDirectory(paths[i]);
}
catch (err2) {
}
fs.write(fs.join(paths[i], "parameter.json"), "");
fs.write(fs.join(paths[i], "parameter.json.tmp"), "");
// create some collection directory
fs.makeDirectory(fs.join(paths[i], "collection-123"));
if (i < 2) {
// create a leftover parameter.json.tmp file
fs.write(fs.join(paths[i], "collection-123", "parameter.json.tmp"), "");
}
else {
// create an empty parameter.json file
fs.write(fs.join(paths[i], "collection-123", "parameter.json"), "");
// create some other file
fs.write(fs.join(paths[i], "collection-123", "foobar"), "foobar");
}
}
internal.debugSegfault("crashing server");
}
function shutdownInstance (instanceInfo, options) {
if (options.cluster) {
instanceInfo.kickstarter.shutdown();
instanceInfo.kickstarter.cleanup();
}
else {
download(instanceInfo.url+"/_admin/shutdown","",
makeAuthorisationHeaders(options));
wait(10);
killExternal(instanceInfo.pid);
}
fs.removeDirectoryRecursive(instanceInfo.tmpDataDir);
}
testCollectionUnload : function () {
var c = db._collection("UnitTestsRecovery");
c.unload();
internal.wait(5);
c = null;
c = db._collection("UnitTestsRecovery");
assertTrue(1, c.count());
var doc = c.toArray()[0];
assertEqual("foo", doc._key);
assertEqual(1, doc.value1);
assertEqual("test", doc.value2);
}
launchActions.sendConfiguration = function (dispatchers, cmd, isRelaunch) {
if (isRelaunch) {
// nothing to do here
console.info("Waiting 1 second for agency to come alive...");
wait(1);
return {"error":false, "isSendConfiguration": true};
}
var url = endpointToURL(cmd.agency.endpoints[0])+"/v2/keys";
var res = sendToAgency(url, "", cmd.data);
if (res === true) {
return {"error":false, "isSendConfiguration": true};
}
return {"error":true, "isSendConfiguration": true, "suberror": res};
};
function runSetup () {
'use strict';
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
var c = db._create("UnitTestsRecovery");
c.ensureHashIndex("foo", "bar");
c.save({ _key: "test", "foo": 1, "bar": 2 }, true);
internal.wal.flush(true, true);
internal.wal.flush(true, false);
internal.wait(2);
internal.debugSegfault("crashing server");
}
function runSetup () {
"use strict";
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
var c = db._create("UnitTestsRecovery"), i;
for (i = 0; i < 10000; ++i) {
c.save({ _key: "test" + i, value1: "test" + i, value2: i });
}
internal.debugSetFailAt("CollectorThreadProcessQueuedOperations");
internal.wal.flush(true, false);
internal.wait(5);
internal.debugSegfault("crashing server");
}
function delete_api_cursor(req, res) {
if (req.suffix.length !== 1) {
actions.resultBad(req, res, arangodb.ERROR_HTTP_BAD_PARAMETER);
return;
}
var cursorId = decodeURIComponent(req.suffix[0]);
if (! DELETE_CURSOR(cursorId)) {
actions.resultNotFound(req, res, arangodb.ERROR_CURSOR_NOT_FOUND);
return;
}
actions.resultOk(req, res, actions.HTTP_ACCEPTED, { id : cursorId });
// we want the garbage collection to clean unused cursors immediately
internal.wait(0.0);
}
function waitForServerUp (endpoint, timeout) {
var url = endpointToURL(endpoint) + "/_api/version";
var time = 0;
while (true) {
var r = download(url, "", {});
if (r.code === 200 || r.code === 401) {
console.info("Could talk to "+endpoint+" .");
return true;
}
if (time >= timeout) {
console.info("Could not talk to endpoint "+endpoint+", giving up.");
return false;
}
wait(0.5);
time += 0.5;
}
}
_.each(tests, function (file) {
if (result) {
print("\nRunning JSUnity test from file '" + file + "'");
} else {
print("\nSkipping JSUnity test from file '" + file + "' due to previous errors");
}
try {
result = result && runTest(file).status;
} catch (err) {
print("cannot run test file '" + file + "': " + err);
print(err.stack);
result = false;
}
internal.wait(0); // force GC
});
function waitForServerDown (endpoint, timeout) {
var url = endpointToURL(endpoint) + "/_api/version";
var time = 0;
while (true) {
var r = download(url, "", {});
if (r.code === 500 || r.code === 401) {
console.info("Server at "+endpoint+" does not answer any more.");
return true;
}
if (time >= timeout) {
console.info("After timeout, server at "+endpoint+
"is still there, giving up.");
return false;
}
wait(0.5);
time += 0.5;
}
}
function runSetup () {
"use strict";
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
var c = db._create("UnitTestsRecovery"), i;
c.ensureHashIndex("value1");
c.ensureSkiplist("value2");
for (i = 0; i < 100; ++i) {
c.save({ value1: i, value2: i });
}
c.drop();
internal.wait(3);
internal.debugSegfault("crashing server");
}
function runSetup () {
internal.debugClearFailAt();
var c;
db._drop("footest");
c = db._create("footest", { id: 99999999 });
c.save({ foo: "bar" });
c.save({ foo: "bart" });
db._drop("footest");
internal.wait(2);
c = db._create("footest", { id: 99999999 });
c.save({ foo: "baz" });
db._drop("test");
c = db._create("test");
c.save({ _key: "crashme" }, true);
internal.debugSegfault("crashing server");
}
function runSetup () {
'use strict';
internal.debugClearFailAt();
internal.wal.flush();
db._drop("test");
db._create("test");
db._createDatabase("UnitTestsRecovery");
internal.wal.flush(true, true, true);
db._dropDatabase("UnitTestsRecovery");
db._useDatabase("_system");
internal.wait(3, true);
db.test.save({ _key: "crashme" }, true);
internal.debugSegfault("crashing server");
}
function RunCommandLineTests () {
var result = true;
for (var i = 0; i < SYS_UNIT_TESTS.length; ++i) {
var file = SYS_UNIT_TESTS[i];
try {
var ok = RunTest(file);
result = result && ok;
}
catch (err) {
print("cannot run test file '" + file + "': " + err);
print(err.stack);
result = false;
}
internal.wait(0); // force GC
}
SYS_UNIT_TESTS_RESULT = result;
}
rotate: function (collection) {
var internal = require("internal");
internal.wal.flush(true, true);
var fig = collection.figures();
var files = fig.datafiles.count + fig.journals.count;
// wait for at most 10 seconds
var end = internal.time() + 10;
collection.rotate();
while (internal.time() < end) {
// wait until the figures change
fig = collection.figures();
if (fig.datafiles.count + fig.journals.count !== files) {
break;
}
internal.wait(1);
}
}
waitUnload: function (collection, waitForCollector) {
var arangodb = require("org/arangodb");
var internal = require("internal");
collection.unload();
internal.wal.flush(true, waitForCollector || false);
var iterations = 0;
while (collection.status() !== arangodb.ArangoCollection.STATUS_UNLOADED) {
collection.unload();
internal.wait(0.25);
++iterations;
if (iterations === 20) {
require("console").log("waiting for collection " + collection.name() + " to unload");
}
else if (iterations === 400) {
throw "waited too long for unload of collection " + collection.name();
}
}
},
launchActions.startAgent = function (dispatchers, cmd, isRelaunch) {
console.info("Starting agent...");
var dataPath = fs.makeAbsolute(cmd.dataPath);
if (dataPath !== cmd.dataPath) { // path was relative
dataPath = fs.normalize(fs.join(ArangoServerState.dataPath(),cmd.dataPath));
}
var agentDataDir = fs.join(dataPath, "agent"+cmd.agencyPrefix+cmd.extPort);
if (!isRelaunch) {
if (fs.exists(agentDataDir)) {
fs.removeDirectoryRecursive(agentDataDir,true);
}
}
var extEndpoint = getAddrPort(
exchangePort(dispatchers[cmd.dispatcher].endpoint,
cmd.extPort));
var args = ["-data-dir", agentDataDir,
"-name", "agent"+cmd.agencyPrefix+cmd.extPort,
"-bind-addr", (cmd.onlyLocalhost ? "127.0.0.1:"
: "0.0.0.0:")+cmd.extPort,
"-addr", extEndpoint,
"-peer-bind-addr", (cmd.onlyLocalhost ? "127.0.0.1:"
: "0.0.0.0:")+cmd.intPort,
"-peer-addr", getAddrPort(
exchangePort(dispatchers[cmd.dispatcher].endpoint,
cmd.intPort))
// the following might speed up etcd, but it might also
// make it more unstable:
// ,"-peer-heartbeat-timeout=10",
// "-peer-election-timeout=20"
];
var i;
if (cmd.peers.length > 0) {
args.push("-peers");
var st = getAddrPort(cmd.peers[0]);
for (i = 1; i < cmd.peers.length; i++) {
st = st + "," + getAddrPort(cmd.peers[i]);
}
args.push(st);
}
var agentPath = cmd.agentPath;
if (agentPath === "") {
agentPath = ArangoServerState.agentPath();
}
if (! fs.exists(agentPath)) {
return {"error":true, "isStartAgent": true,
"errorMessage": "agency binary not found at '" + agentPath + "'"};
}
var pid = executeExternal(agentPath, args);
var res;
var count = 0;
while (++count < 20) {
wait(0.5); // Wait a bit to give it time to startup
res = download("http://localhost:"+cmd.extPort+"/v2/keys/");
if (res.code === 200) {
return {"error":false, "isStartAgent": true, "pid": pid,
"endpoint": "tcp://"+extEndpoint};
}
}
return {"error":true, "isStartAgent": true,
"errorMessage": "agency did not come alive"};
};