mirror of https://gitee.com/bigwinds/arangodb
874 lines
27 KiB
JavaScript
Executable File
874 lines
27 KiB
JavaScript
Executable File
/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true, stupid: true, continue: true, regexp: true nonpropdel: true*/
|
|
/*global require, exports, module, UPGRADE_ARGS, UPGRADE_STARTED: true */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief version check at the start of the server
|
|
///
|
|
/// @file
|
|
///
|
|
/// Version check at the start of the server, will optionally perform necessary
|
|
/// upgrades.
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2004-2014 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 2014, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- version check
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief updates the database
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
(function(args) {
|
|
delete UPGRADE_ARGS;
|
|
|
|
var internal = require("internal");
|
|
var fs = require("fs");
|
|
var console = require("console");
|
|
var userManager = require("org/arangodb/users");
|
|
var cluster = require("org/arangodb/cluster");
|
|
var db = internal.db;
|
|
|
|
// whether or not we are initialising an empty / a new database
|
|
var isInitialisation;
|
|
|
|
// set this global variable to inform the server we actually got until here...
|
|
UPGRADE_STARTED = true;
|
|
|
|
var logger = {
|
|
info: function (msg) {
|
|
console.log("In database '%s': %s", db._name(), msg);
|
|
},
|
|
error: function (msg) {
|
|
console.error("In database '%s': %s", db._name(), msg);
|
|
},
|
|
warn: function (msg) {
|
|
console.warn("In database '%s': %s", db._name(), msg);
|
|
},
|
|
log: function (msg) {
|
|
this.info(msg);
|
|
}
|
|
};
|
|
|
|
// path to the VERSION file
|
|
var versionFile = internal.db._path() + "/VERSION";
|
|
|
|
function runUpgrade (currentVersion, upgradeRun) {
|
|
var allTasks = [];
|
|
var activeTasks = [];
|
|
var lastVersion = null;
|
|
var lastTasks = {};
|
|
|
|
function getCollection (name) {
|
|
return db._collection(name);
|
|
}
|
|
|
|
function collectionExists (name) {
|
|
var collection = getCollection(name);
|
|
return (collection !== undefined) && (collection !== null) && (collection.name() === name);
|
|
}
|
|
|
|
function createSystemCollection (name, attributes) {
|
|
if (collectionExists(name)) {
|
|
return true;
|
|
}
|
|
|
|
var realAttributes = attributes || {};
|
|
realAttributes.isSystem = true;
|
|
|
|
if (db._create(name, realAttributes)) {
|
|
return true;
|
|
}
|
|
|
|
return collectionExists(name);
|
|
}
|
|
|
|
// helper function to define a task
|
|
function addTask (name, description, fn, always) {
|
|
// "description" is a textual description of the task that will be printed out on screen
|
|
// "maxVersion" is the maximum version number the task will be applied for
|
|
|
|
if (upgradeRun || always) {
|
|
var task = { name: name, description: description, func: fn };
|
|
|
|
allTasks.push(task);
|
|
|
|
if (lastTasks[name] === undefined || lastTasks[name] === false) {
|
|
// task never executed or previous execution failed
|
|
activeTasks.push(task);
|
|
}
|
|
}
|
|
}
|
|
|
|
// helper function to define a task that is run on upgrades only, but not on initialisation
|
|
// of a new empty database
|
|
function addUpgradeTask (name, description, fn, always) {
|
|
if (cluster.isCoordinator()) {
|
|
return;
|
|
}
|
|
|
|
if (upgradeRun || always) {
|
|
if (isInitialisation) {
|
|
// if we are initialising a new database, set the task to completed
|
|
// without executing it. this saves unnecessary migrations for empty
|
|
// databases
|
|
lastTasks[name] = true;
|
|
}
|
|
else {
|
|
// if we are upgrading, execute the task
|
|
addTask(name, description, fn);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (! cluster.isCoordinator() && fs.exists(versionFile)) {
|
|
// VERSION file exists, read its contents
|
|
var versionInfo = fs.read(versionFile);
|
|
|
|
if (versionInfo !== '') {
|
|
var versionValues = JSON.parse(versionInfo);
|
|
|
|
if (versionValues && versionValues.version && ! isNaN(versionValues.version)) {
|
|
lastVersion = parseFloat(versionValues.version);
|
|
}
|
|
|
|
if (versionValues && versionValues.tasks && typeof(versionValues.tasks) === 'object') {
|
|
lastTasks = versionValues.tasks || {};
|
|
}
|
|
}
|
|
|
|
isInitialisation = false;
|
|
}
|
|
else {
|
|
// VERSION file does not exist
|
|
// we assume that we are initialising a new, empty database
|
|
isInitialisation = true;
|
|
}
|
|
|
|
var procedure = isInitialisation ? "initialisation" : "upgrade";
|
|
|
|
if (upgradeRun) {
|
|
if (! isInitialisation) {
|
|
logger.log("starting upgrade from version " + (lastVersion || "unknown")
|
|
+ " to " + internal.db._version());
|
|
}
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// the actual upgrade tasks. all tasks defined here should be "re-entrant"
|
|
// --------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief moveProductionApps
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
addUpgradeTask("moveProductionApps", "move Foxx apps into per-database directory", function () {
|
|
var dir = module.appPath();
|
|
|
|
if (! fs.exists(dir)) {
|
|
logger.error("apps directory '" + dir + "' does not exist.");
|
|
return false;
|
|
}
|
|
|
|
// we only need to move apps in the _system database
|
|
if (db._name() !== '_system') {
|
|
return true;
|
|
}
|
|
|
|
if (! module.basePaths().appPath) {
|
|
logger.error("no app-path has been specified.");
|
|
return false;
|
|
}
|
|
|
|
var files = fs.list(module.basePaths().appPath), i, n = files.length;
|
|
|
|
for (i = 0; i < n; ++i) {
|
|
var found = files[i];
|
|
|
|
if (found === '' ||
|
|
found === 'system' ||
|
|
found === 'databases' ||
|
|
found === 'aardvark' ||
|
|
found[0] === '.') {
|
|
continue;
|
|
}
|
|
|
|
var src = fs.join(module.basePaths().appPath, found);
|
|
|
|
if (! fs.isDirectory(src)) {
|
|
continue;
|
|
}
|
|
|
|
// we found a directory, now move it
|
|
|
|
var dst = fs.join(dir, found);
|
|
logger.log("renaming directory '" + src + "' to '" + dst + "'");
|
|
// fs.move() will throw if moving doesn't work
|
|
fs.move(src, dst);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief moveDevApps
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
if (internal.developmentMode) {
|
|
addUpgradeTask("moveDevApps",
|
|
"move Foxx development apps into per-database directory", function () {
|
|
var dir = module.devAppPath();
|
|
|
|
if (! fs.exists(dir)) {
|
|
logger.error("dev apps directory '" + dir + "' does not exist.");
|
|
return false;
|
|
}
|
|
|
|
// we only need to move apps in the _system database
|
|
if (db._name() !== '_system') {
|
|
return true;
|
|
}
|
|
|
|
if (! module.basePaths().devAppPath) {
|
|
logger.error("no dev-app-path has been specified.");
|
|
return false;
|
|
}
|
|
|
|
var files = fs.list(module.basePaths().devAppPath), i, n = files.length;
|
|
for (i = 0; i < n; ++i) {
|
|
var found = files[i];
|
|
|
|
if (found === '' ||
|
|
found === 'system' ||
|
|
found === 'databases' ||
|
|
found === 'aardvark' ||
|
|
found[0] === '.') {
|
|
continue;
|
|
}
|
|
|
|
var src = fs.join(module.basePaths().devAppPath, found);
|
|
if (! fs.isDirectory(src)) {
|
|
continue;
|
|
}
|
|
|
|
// we found a directory, now move it
|
|
|
|
var dst = fs.join(dir, found);
|
|
logger.log("renaming directory '" + src + "' to '" + dst + "'");
|
|
// fs.move() will throw if moving doesn't work
|
|
fs.move(src, dst);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief setupUsers
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// set up the collection _users
|
|
addTask("setupUsers", "setup _users collection", function () {
|
|
return createSystemCollection("_users", { waitForSync : true, shardKeys: [ "user" ] });
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief createUsersIndex
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// create a unique index on "user" attribute in _users
|
|
addTask("createUsersIndex",
|
|
"create index on 'user' attribute in _users collection",
|
|
function () {
|
|
var users = getCollection("_users");
|
|
if (! users) {
|
|
return false;
|
|
}
|
|
|
|
users.ensureUniqueConstraint("user");
|
|
|
|
return true;
|
|
}
|
|
);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief addDefaultUser
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// add a default root user with no passwd
|
|
addTask("addDefaultUser", "add default root user", function () {
|
|
var users = getCollection("_users");
|
|
if (! users) {
|
|
return false;
|
|
}
|
|
|
|
var foundUser = false;
|
|
|
|
if (args && args.users) {
|
|
args.users.forEach(function(user) {
|
|
foundUser = true;
|
|
try {
|
|
userManager.save(user.username, user.passwd, user.active, user.extra || {});
|
|
} catch (err) {
|
|
logger.warn("could not add database user '" + user.username + "': " +
|
|
String(err.stack || err));
|
|
}
|
|
});
|
|
}
|
|
|
|
if (! foundUser && users.count() === 0) {
|
|
// only add account if user has not created his/her own accounts already
|
|
userManager.save("root", "", true);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief setupGraphs
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// set up the collection _graphs
|
|
addTask("setupGraphs", "setup _graphs collection", function () {
|
|
return createSystemCollection("_graphs", {
|
|
waitForSync : true,
|
|
journalSize: 1024 * 1024
|
|
});
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief addCollectionVersion
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// make distinction between document and edge collections
|
|
addUpgradeTask("addCollectionVersion",
|
|
"set new collection type for edge collections and update collection version",
|
|
function () {
|
|
var collections = db._collections();
|
|
var i;
|
|
|
|
for (i in collections) {
|
|
if (collections.hasOwnProperty(i)) {
|
|
var collection = collections[i];
|
|
|
|
try {
|
|
if (collection.version() > 1) {
|
|
// already upgraded
|
|
continue;
|
|
}
|
|
|
|
if (collection.type() === 3) {
|
|
// already an edge collection
|
|
collection.setAttribute("version", 2);
|
|
continue;
|
|
}
|
|
|
|
if (collection.count() > 0) {
|
|
var isEdge = true;
|
|
// check the 1st 50 documents from a collection
|
|
var documents = collection.ALL(0, 50);
|
|
var j;
|
|
|
|
for (j in documents) {
|
|
if (documents.hasOwnProperty(j)) {
|
|
var doc = documents[j];
|
|
|
|
// check if documents contain both _from and _to attributes
|
|
if (! doc.hasOwnProperty("_from") || ! doc.hasOwnProperty("_to")) {
|
|
isEdge = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isEdge) {
|
|
collection.setAttribute("type", 3);
|
|
logger.log("made collection '" + collection.name() + " an edge collection");
|
|
}
|
|
}
|
|
collection.setAttribute("version", 2);
|
|
}
|
|
catch (e) {
|
|
logger.error("could not upgrade collection '" + collection.name() + "'");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief createModules
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// create the _modules collection
|
|
addTask("createModules", "setup _modules collection", function () {
|
|
return createSystemCollection("_modules", {
|
|
journalSize: 1024 * 1024
|
|
});
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief _routing
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// create the _routing collection
|
|
addTask("createRouting", "setup _routing collection", function () {
|
|
// needs to be big enough for assets
|
|
return createSystemCollection("_routing", {
|
|
journalSize: 32 * 1024 * 1024
|
|
});
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief _cluster_kickstarter_plans
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// create the _routing collection
|
|
addTask("createKickstarterConfiguration",
|
|
"setup _cluster_kickstarter_plans collection", function () {
|
|
//TODO add check if this is the main dispatcher
|
|
return createSystemCollection("_cluster_kickstarter_plans", {
|
|
journalSize: 4 * 1024 * 1024
|
|
});
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief insertRedirectionsAll
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// create the default route in the _routing collection
|
|
addTask("insertRedirectionsAll", "insert default routes for admin interface", function () {
|
|
var routing = getCollection("_routing");
|
|
|
|
if (! routing) {
|
|
return false;
|
|
}
|
|
|
|
// first, check for "old" redirects
|
|
routing.toArray().forEach(function (doc) {
|
|
// check for specific redirects
|
|
if (doc.url && doc.action && doc.action.options && doc.action.options.destination) {
|
|
if (doc.url.match(/^\/(_admin\/(html|aardvark))?/) &&
|
|
doc.action.options.destination.match(/_admin\/(html|aardvark)/)) {
|
|
// remove old, non-working redirect
|
|
routing.remove(doc);
|
|
}
|
|
}
|
|
});
|
|
|
|
// add redirections to new location
|
|
[ "/", "/_admin/html", "/_admin/html/index.html" ].forEach (function (src) {
|
|
routing.save({
|
|
url: src,
|
|
action: {
|
|
"do": "org/arangodb/actions/redirectRequest",
|
|
options: {
|
|
permanently: true,
|
|
destination: "/_db/" + db._name() + "/_admin/aardvark/index.html"
|
|
}
|
|
},
|
|
priority: -1000000
|
|
});
|
|
});
|
|
|
|
return true;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief upgradeGraphs
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// update _graphs to new document stucture containing edgeDefinitions
|
|
addUpgradeTask("upgradeGraphs",
|
|
"update _graphs to new document stucture containing edgeDefinitions", function () {
|
|
try {
|
|
var graphs = db._graphs;
|
|
if (graphs === null || graphs === undefined) {
|
|
throw "_graphs collection does not exist.";
|
|
}
|
|
graphs.toArray().forEach(
|
|
function(graph) {
|
|
if (graph.edgeDefinitions) {
|
|
return;
|
|
}
|
|
var from = [graph.vertices];
|
|
var to = [graph.vertices];
|
|
var collection = graph.edges;
|
|
db._graphs.replace(
|
|
graph,
|
|
{
|
|
edgeDefinitions: [
|
|
{
|
|
"collection": collection,
|
|
"from" : from,
|
|
"to" : to
|
|
}
|
|
]
|
|
},
|
|
true
|
|
);
|
|
}
|
|
);
|
|
}
|
|
catch (e) {
|
|
logger.error("could not upgrade _graphs");
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief setupAal
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// set up the collection _aal
|
|
addTask("setupAal", "setup _aal collection", function () {
|
|
return createSystemCollection("_aal", {
|
|
waitForSync : true,
|
|
shardKeys: [ "name", "version" ]
|
|
});
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief createAalIndex
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// create a unique index on collection attribute in _aal
|
|
addTask("createAalIndex",
|
|
"create index on collection attribute in _aal collection",
|
|
function () {
|
|
var aal = getCollection("_aal");
|
|
|
|
if (! aal) {
|
|
return false;
|
|
}
|
|
|
|
aal.ensureUniqueConstraint("name", "version");
|
|
|
|
return true;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief setupAqlFunctions
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// set up the collection _aqlfunctions
|
|
addTask("setupAqlFunctions", "setup _aqlfunctions collection", function () {
|
|
return createSystemCollection("_aqlfunctions", {
|
|
journalSize: 4 * 1024 * 1024
|
|
});
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief migrateAqlFunctions
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// migration aql function names
|
|
addUpgradeTask("migrateAqlFunctions", "migrate _aqlfunctions name", function () {
|
|
var funcs = getCollection('_aqlfunctions');
|
|
|
|
if (! funcs) {
|
|
return false;
|
|
}
|
|
|
|
var result = true;
|
|
funcs.toArray().forEach(function(f) {
|
|
var oldKey = f._key;
|
|
var newKey = oldKey.replace(/:{1,}/g, '::');
|
|
|
|
if (oldKey !== newKey) {
|
|
try {
|
|
var doc = {
|
|
_key: newKey.toUpperCase(),
|
|
name: newKey,
|
|
code: f.code,
|
|
isDeterministic: f.isDeterministic
|
|
};
|
|
|
|
funcs.save(doc);
|
|
funcs.remove(oldKey);
|
|
}
|
|
catch (err) {
|
|
result = false;
|
|
}
|
|
}
|
|
});
|
|
|
|
return result;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief removeOldFoxxRoutes
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
addUpgradeTask("removeOldFoxxRoutes", "Remove all old Foxx Routes", function () {
|
|
var potentialFoxxes = getCollection('_routing');
|
|
|
|
potentialFoxxes.iterate(function (maybeFoxx) {
|
|
if (maybeFoxx.foxxMount) {
|
|
// This is a Foxx! Let's delete it
|
|
potentialFoxxes.remove(maybeFoxx._id);
|
|
}
|
|
});
|
|
|
|
return true;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief createStatistics
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var StatisticsNames = [ "_statisticsRaw", "_statistics", "_statistics15" ];
|
|
|
|
// create the _statistics collection
|
|
addTask("updateStatistics",
|
|
"clear statistics collections: " + JSON.stringify(StatisticsNames),
|
|
function () {
|
|
var i;
|
|
|
|
for (i = 0; i < StatisticsNames.length; ++i) {
|
|
var name = StatisticsNames[i];
|
|
|
|
try {
|
|
db._drop(name);
|
|
}
|
|
catch (err) {
|
|
}
|
|
}
|
|
|
|
return true;
|
|
},
|
|
true);
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief createConfiguration
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// create the _statistics collection
|
|
addTask("createConfiguration", "setup _configuration collection", function () {
|
|
var name = "_configuration";
|
|
var result = createSystemCollection(name, {
|
|
waitForSync: true,
|
|
journalSize: 1024 * 1024
|
|
});
|
|
|
|
return result;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief mount system apps on correct endpoints
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// move all _api apps to _api and all system apps to system
|
|
addTask("systemAppEndpoints", "mount system apps on correct endpoints", function () {
|
|
var aal = db._collection("_aal");
|
|
var didWork = true;
|
|
aal.byExample(
|
|
{
|
|
type: "mount",
|
|
isSystem: true
|
|
}
|
|
).toArray().forEach(function(app) {
|
|
try {
|
|
aal.remove(app._key);
|
|
} catch (e) {
|
|
didWork = false;
|
|
}
|
|
});
|
|
return didWork;
|
|
});
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief executes the upgrade tasks
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// loop through all tasks and execute them
|
|
if (upgradeRun || 0 < activeTasks.length) {
|
|
logger.log("Found " + allTasks.length + " defined task(s), "
|
|
+ activeTasks.length + " task(s) to run");
|
|
}
|
|
|
|
var taskNumber = 0;
|
|
var i;
|
|
|
|
for (i in activeTasks) {
|
|
if (activeTasks.hasOwnProperty(i)) {
|
|
var task = activeTasks[i];
|
|
|
|
++taskNumber;
|
|
var taskName = "task #" + taskNumber + " (" + task.name + ": " + task.description + ")";
|
|
|
|
// assume failure
|
|
var result = false;
|
|
|
|
try {
|
|
// execute task
|
|
result = task.func();
|
|
}
|
|
catch (err) {
|
|
logger.error("Executing " + taskName + " failed with exception: " +
|
|
String(err.stack || err));
|
|
}
|
|
|
|
if (result) {
|
|
// success
|
|
lastTasks[task.name] = true;
|
|
|
|
if (!cluster.isCoordinator()) {
|
|
// save/update version info
|
|
fs.write(
|
|
versionFile,
|
|
JSON.stringify({ version: currentVersion, tasks: lastTasks }));
|
|
}
|
|
|
|
// be less chatty
|
|
// logger.log("Task successful");
|
|
}
|
|
else {
|
|
logger.error("Executing " + taskName + " failed. Aborting " + procedure + " procedure.");
|
|
logger.error("Please fix the problem and try starting the server again.");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (! cluster.isCoordinator()) {
|
|
// save file so version gets saved even if there are no tasks
|
|
fs.write(
|
|
versionFile,
|
|
JSON.stringify({ version: currentVersion, tasks: lastTasks }));
|
|
}
|
|
|
|
if (upgradeRun || 0 < activeTasks.length) {
|
|
logger.log(procedure + " successfully finished");
|
|
}
|
|
|
|
// successfully finished
|
|
return true;
|
|
}
|
|
|
|
var lastVersion = null;
|
|
var currentServerVersion = internal.db._version().match(/^(\d+\.\d+).*$/);
|
|
|
|
if (! currentServerVersion) {
|
|
// server version is invalid for some reason
|
|
logger.error("Unexpected ArangoDB server version: " + internal.db._version());
|
|
return false;
|
|
}
|
|
|
|
var currentVersion = parseFloat(currentServerVersion[1]);
|
|
|
|
if (cluster.isCoordinator()) {
|
|
var result = runUpgrade(currentVersion, true);
|
|
internal.initializeFoxx();
|
|
|
|
return result;
|
|
}
|
|
|
|
if (! fs.exists(versionFile)) {
|
|
logger.info("No version information file found in database directory.");
|
|
return runUpgrade(currentVersion, true);
|
|
}
|
|
|
|
// VERSION file exists, read its contents
|
|
var versionInfo = fs.read(versionFile);
|
|
|
|
if (versionInfo !== '') {
|
|
var versionValues = JSON.parse(versionInfo);
|
|
if (versionValues && versionValues.version && ! isNaN(versionValues.version)) {
|
|
lastVersion = parseFloat(versionValues.version);
|
|
}
|
|
}
|
|
|
|
if (lastVersion === null) {
|
|
logger.info("No VERSION file found in database directory.");
|
|
return runUpgrade(currentVersion, true);
|
|
}
|
|
|
|
// version match!
|
|
if (lastVersion === currentVersion) {
|
|
if (args.upgrade) {
|
|
runUpgrade(currentVersion, true);
|
|
}
|
|
else {
|
|
runUpgrade(currentVersion, false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// downgrade??
|
|
if (lastVersion > currentVersion) {
|
|
logger.error("Database directory version (" + lastVersion
|
|
+ ") is higher than server version (" + currentVersion + ").");
|
|
|
|
logger.error("It seems like you are running ArangoDB on a database directory"
|
|
+ " that was created with a newer version of ArangoDB. Maybe this"
|
|
+" is what you wanted but it is not supported by ArangoDB.");
|
|
|
|
// still, allow the start
|
|
return true;
|
|
}
|
|
|
|
// upgrade
|
|
if (lastVersion < currentVersion) {
|
|
if (args.upgrade) {
|
|
return runUpgrade(currentVersion, true);
|
|
}
|
|
|
|
logger.error("Database directory version (" + lastVersion
|
|
+ ") is lower than server version (" + currentVersion + ").");
|
|
|
|
logger.error("----------------------------------------------------------------------");
|
|
logger.error("It seems like you have upgraded the ArangoDB binary.");
|
|
logger.error("If this is what you wanted to do, please restart with the");
|
|
logger.error(" --upgrade");
|
|
logger.error("option to upgrade the data in the database directory.");
|
|
|
|
logger.error("Normally you can use the control script to upgrade your database");
|
|
logger.error(" /etc/init.d/arangodb stop");
|
|
logger.error(" /etc/init.d/arangodb upgrade");
|
|
logger.error(" /etc/init.d/arangodb start");
|
|
logger.error("----------------------------------------------------------------------");
|
|
|
|
// do not start unless started with --upgrade
|
|
return false;
|
|
}
|
|
|
|
// we should never get here
|
|
return true;
|
|
}(UPGRADE_ARGS));
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "^\\(/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @}\\)"
|
|
// End:
|