function runSetup () {
"use strict";
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
db._create("UnitTestsRecovery");
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.debugSegfault("crashing server");
}
testEdges : function () {
var v, e, doc, i;
v = db._collection("UnitTestsVertices");
assertEqual(1000, v.count());
for (i = 0; i < 1000; ++i) {
assertEqual("some-name" + i, v.document("node" + i).name);
}
e = db._collection("UnitTestsEdges");
for (i = 0; i < 1000; ++i) {
doc = e.document("edge" + i);
assertEqual("some-value" + i, doc.what);
assertEqual("UnitTestsVertices/node" + i, doc._from);
assertEqual("UnitTestsVertices/node" + (i % 10), doc._to);
}
for (i = 0; i < 1000; ++i) {
assertEqual(1, e.outEdges("UnitTestsVertices/node" + i).length);
if (i >= 10) {
assertEqual(0, e.inEdges("UnitTestsVertices/node" + i).length);
}
else {
assertEqual(100, e.inEdges("UnitTestsVertices/node" + i).length);
}
}
}
function runSetup () {
"use strict";
internal.debugClearFailAt();
var appPath = fs.join(module.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");
}
Graph.prototype.initialize = function (name, vertices, edges) {
var results;
if (is.notExisty(vertices) && is.notExisty(edges)) {
results = GraphAPI.getGraph(name);
} else {
if (typeof vertices === 'object' && typeof vertices.name === 'function') {
vertices = vertices.name();
}
if (typeof edges === 'object' && typeof edges.name === 'function') {
edges = edges.name();
}
results = GraphAPI.postGraph({
_key: name,
vertices: vertices,
edges: edges
});
}
this._properties = results.graph;
this._vertices = arangodb.db._collection(this._properties.edgeDefinitions[0].from[0]);
this._edges = arangodb.db._collection(this._properties.edgeDefinitions[0].collection);
// and dictionary for vertices and edges
this._verticesCache = {};
this._edgesCache = {};
// and store the cashes
this.predecessors = {};
this.distances = {};
return this;
};
function runSetup () {
internal.debugClearFailAt();
var c;
db._drop("UnitTestsRecovery");
c = db._create("UnitTestsRecovery");
c.save({ _key: "foo", value1: 1, value2: "test" }, true);
internal.debugSegfault("crashing server");
}
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);
}
function runSetup () {
internal.debugClearFailAt();
db._drop("UnitTestsRecovery");
var c = db._create("UnitTestsRecovery"), i;
c.save({ _key: "value", value: 42 });
for (i = 0; i < 200000; ++i) {
c.update("value", { value: i });
}
c.save({ _key: "crashme" }, true);
internal.debugSegfault("crashing server");
}
function runSetup () {
"use strict";
internal.debugClearFailAt();
db._drop("test");
db._create("test");
var i;
for (i = 0; i < 5; ++i) {
db._useDatabase("_system");
try {
db._dropDatabase("UnitTestsRecovery" + i);
}
catch (err) {
// ignore this error
}
db._createDatabase("UnitTestsRecovery" + i);
db._useDatabase("UnitTestsRecovery" + i);
db._create("test");
db.test.save({ value: i });
}
db._useDatabase("_system");
db.test.save({ _key: "crashme" }, true);
internal.debugSegfault("crashing server");
}
callback : function (req, res) {
try {
var body = actions.getJsonBody(req, res);
if (body === undefined) {
return;
}
if (req.requestType != actions.PUT) {
actions.resultUnsupported(req, res);
}
else {
var name = body.collection;
var id = parseInt(name) || name;
var collection = db._collection(id);
if (collection === null) {
actions.collectionNotFound(req, res, name);
}
else {
var result = { document: collection.any() };
actions.resultOk(req, res, actions.HTTP_OK, result);
}
}
}
catch (err) {
actions.resultException(req, res, err);
}
}
function delete_api_collection (req, res) {
if (req.suffix.length !== 1) {
actions.resultBad(req, res, actions.ERROR_HTTP_BAD_PARAMETER,
"expected DELETE /" + API + "/<collection-name>");
}
else {
var name = decodeURIComponent(req.suffix[0]);
var collection = arangodb.db._collection(name);
if (collection === null) {
actions.collectionNotFound(req, res, name);
}
else {
try {
var result = {
id : collection._id
};
collection.drop();
actions.resultOk(req, res, actions.HTTP_OK, result);
}
catch (err) {
actions.resultException(req, res, err);
}
}
}
}
_log: function (level, message, callee) {
if (!this._logLevels.hasOwnProperty(level)) {
throw new Error('Unknown log level: ' + level);
}
if (this._logLevels[level] < this._logLevel) {
// Don't log this.
return;
}
var doc = {
mount: this._mount,
level: level,
levelNum: this._logLevels[level],
time: Date.now(),
message: message
};
if (this._tracing) {
var e = new Error();
Error.captureStackTrace(e, callee || this._log);
e.stack = e.stack.replace(/\n+$/, '');
doc.stack = ErrorStackParser.parse(e).slice(1);
}
if (!db._foxxlog) {
db._create('_foxxlog', {isSystem: true});
db._foxxlog.ensureSkiplist('mount');
db._foxxlog.ensureSkiplist('mount', 'created');
db._foxxlog.ensureSkiplist('mount', 'created', 'levelNum');
}
db._foxxlog.save(doc);
},
callback : function (req, res) {
try {
var body = actions.getJsonBody(req, res);
if (body === undefined) {
return;
}
if (req.requestType != actions.PUT) {
actions.resultUnsupported(req, res);
}
else {
var example = body.example;
var name = body.collection;
var collection = db._collection(name);
var limit = body.limit || null;
if (collection === null) {
actions.collectionNotFound(req, res, name);
}
else if (typeof example !== "object" || Array.isArray(example)) {
actions.badParameter(req, res, "example");
}
else {
var result = collection.removeByExample(example, body.waitForSync, limit);
actions.resultOk(req, res, actions.HTTP_OK, { deleted: result });
}
}
}
catch (err) {
actions.resultException(req, res, err);
}
}
function get_api_collections (req, res) {
var i;
var list = [];
var names = {};
var excludeSystem;
var collections = arangodb.db._collections();
excludeSystem = false;
if (req.parameters.hasOwnProperty('excludeSystem')) {
var value = req.parameters.excludeSystem;
if (value === 'true' || value === 'yes' || value === 'on' || value === 'y' || value === '1') {
excludeSystem = true;
}
}
for (i = 0; i < collections.length; ++i) {
var collection = collections[i];
var rep = collectionRepresentation(collection);
// include system collections or exclude them?
if (! excludeSystem || rep.name.substr(0, 1) !== '_') {
list.push(rep);
names[rep.name] = rep;
}
}
var result = { collections : list, names : names };
actions.resultOk(req, res, actions.HTTP_OK, result);
}
Users.prototype.updateData = function (identifier, data) {
'use strict';
var c = this.storage();
identifier = this._validateIdentifier(identifier, true);
db._executeTransaction({
collections: {
write: c.name()
},
action: function (params) {
var c = db._collection(params.cn),
u = c.firstExample({ identifier: params.identifier });
if (u === null) {
throw new Error("user not found");
}
c.update(u._key, params.data, true, false);
},
params: {
cn: c.name(),
identifier: identifier,
data: data || {}
}
});
return true;
};
Sessions.prototype.teardown = function () {
'use strict';
var c = db._collection(this._collectionName);
if (c) {
c.drop();
}
};
action: function (params) {
var c = db._collection(params.cn),
u = c.firstExample({ identifier: params.identifier });
if (u === null) {
throw new Error("user not found");
}
c.update(u._key, params.data, true, false);
},
testCreateDatabases : function () {
var i;
for (i = 0; i < 5; ++i) {
db._useDatabase("UnitTestsRecovery" + i);
var docs = db.test.toArray();
assertEqual(1, docs.length);
assertEqual(i, docs[0].value);
}
}
exports.CURRENT_VERSION = (function() {
var v = db._version().replace(/-[a-zA-Z0-9_\-]*$/g, '').split('.');
var major = parseFloat(v[0], 10) || 0;
var minor = parseFloat(v[1], 10) || 0;
var patch = parseFloat(v[2], 10) || 0;
return (((major * 100) + minor) * 100) + patch;
}());
function runSetup () {
internal.debugClearFailAt();
var i, num = 9999999999;
for (i = 0; i < 4; ++i) {
var filename = fs.join(db._path(), "../../journals/logfile-" + num + ".db");
num++;
// save an empty file
fs.write(filename, "");
}
db._drop("UnitTestsRecovery");
var c = db._create("UnitTestsRecovery");
c.save({ _key: "crashme" }, true); // wait for sync
internal.debugSegfault("crashing server");
}
Sessions.prototype.setup = function (options) {
'use strict';
var journalSize,
createOptions;
if (typeof options === 'object' && options.hasOwnProperty('journalSize')) {
journalSize = options.journalSize;
}
createOptions = {
journalSize : journalSize || 4 * 1024 * 1024
};
if (!db._collection(this._collectionName)) {
db._create(this._collectionName, createOptions);
}
this.storage().ensureHashIndex("identifier");
};
action: function (params) {
var c = db._collection(params.cn),
u = c.firstExample({ identifier: params.user.identifier });
if (u === null) {
c.save(params.user);
} else {
c.replace(u._key, params.user);
}
},
.forEach(function (queue) {
var numBusy = db._jobs.byExample({
queue: queue._key,
status: 'progress'
}).count();
if (numBusy >= queue.maxWorkers) {
busy = true;
return;
}
var jobs = db._createStatement({
query: (
qb.for('job').in('_jobs')
.filter(
qb('pending').eq('job.status')
.and(qb.ref('@queue').eq('job.queue'))
.and(qb.ref('@now').gte('job.delayUntil'))
)
.sort('job.delayUntil', 'ASC')
.limit('@max')
.return('job')
),
bindVars: {
queue: queue._key,
now: Date.now(),
max: queue.maxWorkers - numBusy
}
}).execute().toArray();
if (jobs.length > 0) {
busy = true;
}
jobs.forEach(function (job) {
db._jobs.update(job._key, {status: 'progress'});
tasks.register({
command: function (cfg) {
var db = require('org/arangodb').db;
var initialDatabase = db._name();
db._useDatabase(cfg.db);
try {
require('org/arangodb/foxx/queues/worker').work(cfg.job);
} catch(e) {}
db._useDatabase(initialDatabase);
},
offset: 1,
isSystem: true,
params: {
job: _.extend({}, job, {status: 'progress'}),
db: db._name()
}
});
});
});
testResumeRecoverySimple : function () {
var c = db._collection("UnitTestsRecovery"), doc;
var idx = c.getIndexes()[1];
assertEqual(1, c.count());
doc = c.document("test");
assertEqual(1, doc.foo);
assertEqual(2, doc.bar);
assertEqual(1, c.byExampleHash(idx.id, { foo: 1, bar: 2 }).toArray().length);
}
action: function () {
var db = require("org/arangodb").db;
var i, c = db._collection("UnitTestsRecovery");
for (i = 0; i < 10000; ++i) {
c.save({ _key: "test" + i, value1: "test" + i, value2: i }, true); // wait for sync
}
for (i = 0; i < 10000; i += 2) {
c.remove("test" + i, true);
}
}
testCollectorOom : function () {
var i, c = db._collection("UnitTestsRecovery");
assertEqual(10000, c.count());
for (i = 0; i < 10000; ++i) {
var doc = c.document("test" + i);
assertEqual("test" + i, doc.value1);
assertEqual(i, doc.value2);
}
}
testCorruptWalMarkerSingle : function () {
var doc;
var c = db._collection("UnitTestsRecovery"), i;
assertEqual(100, c.count());
for (i = 0; i < 100; ++i) {
doc = c.document("test" + i);
assertEqual("test" + i, doc.value);
assertEqual("test" + i, doc._key);
}
}
var isExported = function(mount) {
var dbname = arangodb.db._name();
if (!exportCache.hasOwnProperty(dbname)) {
exportCache[dbname] = {};
return false;
}
if (!exportCache[dbname].hasOwnProperty(mount)) {
return false;
}
return true;
};
(function() {
"use strict";
var db = require("org/arangodb").db,
todos = applicationContext.collectionName("todos"),
collection = db._collection(todos);
if (collection !== null) {
collection.drop();
}
}());
testNoShutdownInfoMultipleLogs : function () {
var c = db._collection("UnitTestsRecovery");
assertEqual(200000, c.count());
var i;
for (i = 0; i < 200000; ++i) {
assertEqual(i, c.document("test" + i).value1);
assertEqual("foobarbaz" + i, c.document("test" + i).value2);
}
}
databases.forEach(function (database) {
try {
db._useDatabase(database);
global.KEYSPACE_CREATE('queue-control', 1, true);
var delayUntil = global.KEY_GET('queue-control', 'delayUntil') || 0;
if (delayUntil > Date.now() || delayUntil === -1) {
return;
}
var queues = db._collection('_queues');
var jobs = db._collection('_jobs');
if (!queues || !jobs || !queues.count() || !jobs.count()) {
global.KEY_SET('queue-control', 'delayUntil', -1);
} else {
runInDatabase();
}
} catch (e) {}
});