mirror of https://gitee.com/bigwinds/arangodb
474 lines
15 KiB
JavaScript
474 lines
15 KiB
JavaScript
/*jslint indent: 2, nomen: true, maxlen: 100, sloppy: true, vars: true, white: true, plusplus: true, stupid: true, continue: true, regexp: true */
|
|
/*global require, exports */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief version check at the start of the server, will optionally perform
|
|
/// necessary upgrades
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2004-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 2012, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- version check
|
|
// -----------------------------------------------------------------------------
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @addtogroup ArangoDB
|
|
/// @{
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief updates the database
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
(function() {
|
|
var internal = require("internal");
|
|
var console = require("console");
|
|
var userManager = require("org/arangodb/users");
|
|
var db = internal.db;
|
|
|
|
// path to the VERSION file
|
|
var versionFile = internal.DATABASEPATH + "/VERSION";
|
|
|
|
function runUpgrade (currentVersion) {
|
|
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 tasks
|
|
function addTask (name, description, code) {
|
|
// "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
|
|
var task = { name: name, description: description, code: code };
|
|
|
|
allTasks.push(task);
|
|
|
|
if (lastTasks[name] === undefined || lastTasks[name] === false) {
|
|
// task never executed or previous execution failed
|
|
activeTasks.push(task);
|
|
}
|
|
}
|
|
|
|
|
|
if (internal.exists(versionFile)) {
|
|
// VERSION file exists, read its contents
|
|
var versionInfo = internal.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 || { };
|
|
}
|
|
}
|
|
}
|
|
|
|
console.log("Starting upgrade from version " + (lastVersion || "unknown")
|
|
+ " to " + internal.db._version());
|
|
|
|
// --------------------------------------------------------------------------
|
|
// the actual upgrade tasks. all tasks defined here should be "re-entrant"
|
|
// --------------------------------------------------------------------------
|
|
|
|
// set up the collection _users
|
|
addTask("setupUsers", "setup _users collection", function () {
|
|
return createSystemCollection("_users", { waitForSync : true });
|
|
});
|
|
|
|
// 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;
|
|
});
|
|
|
|
// add a default root user with no passwd
|
|
addTask("addDefaultUser", "add default root user", function () {
|
|
var users = getCollection("_users");
|
|
if (! users) {
|
|
return false;
|
|
}
|
|
|
|
if (users.count() === 0) {
|
|
// only add account if user has not created his/her own accounts already
|
|
userManager.save("root", "", true);
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
// set up the collection _graphs
|
|
addTask("setupGraphs", "setup _graphs collection", function () {
|
|
return createSystemCollection("_graphs", { waitForSync : true });
|
|
});
|
|
|
|
// create a unique index on name attribute in _graphs
|
|
addTask("createGraphsIndex",
|
|
"create index on name attribute in _graphs collection",
|
|
function () {
|
|
var graphs = getCollection("_graphs");
|
|
|
|
if (! graphs) {
|
|
return false;
|
|
}
|
|
|
|
graphs.ensureUniqueConstraint("name");
|
|
|
|
return true;
|
|
});
|
|
|
|
// make distinction between document and edge collections
|
|
addTask("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);
|
|
console.log("made collection '" + collection.name() + " an edge collection");
|
|
}
|
|
}
|
|
collection.setAttribute("version", 2);
|
|
}
|
|
catch (e) {
|
|
console.error("could not upgrade collection '" + collection.name() + "'");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
// create the _modules collection
|
|
addTask("createModules", "setup _modules collection", function () {
|
|
return createSystemCollection("_modules");
|
|
});
|
|
|
|
// create the _routing collection
|
|
addTask("createRouting", "setup _routing collection", function () {
|
|
return createSystemCollection("_routing");
|
|
});
|
|
|
|
// create the default route in the _routing collection
|
|
addTask("insertDefaultRoute", "insert default route for the admin interface", function () {
|
|
var routing = getCollection("_routing");
|
|
|
|
if (! routing) {
|
|
return false;
|
|
}
|
|
|
|
if (routing.count() === 0) {
|
|
// only add route if no other route has been defined
|
|
routing.save({
|
|
url: "/",
|
|
action: {
|
|
"do": "org/arangodb/actions/redirectRequest",
|
|
options: {
|
|
permanently: true,
|
|
destination: "/_admin/html/index.html"
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
// update markers in all collection datafiles to key markers
|
|
addTask("upgradeMarkers12", "update markers in all collection datafiles", function () {
|
|
var collections = db._collections();
|
|
var i;
|
|
|
|
for (i in collections) {
|
|
if (collections.hasOwnProperty(i)) {
|
|
var collection = collections[i];
|
|
|
|
try {
|
|
if (collection.version() >= 3) {
|
|
// already upgraded
|
|
continue;
|
|
}
|
|
|
|
if (collection.upgrade()) {
|
|
// success
|
|
collection.setAttribute("version", 3);
|
|
}
|
|
else {
|
|
// fail
|
|
console.error("could not upgrade collection datafiles for '"
|
|
+ collection.name() + "'");
|
|
return false;
|
|
}
|
|
}
|
|
catch (e) {
|
|
console.error("could not upgrade collection datafiles for '"
|
|
+ collection.name() + "'");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
});
|
|
|
|
// set up the collection _structures
|
|
addTask("setupStructures", "setup _structures collection", function () {
|
|
return createSystemCollection("_structures", { waitForSync : true });
|
|
});
|
|
|
|
// create a unique index on collection attribute in _structures
|
|
addTask("createStructuresIndex",
|
|
"create index on collection attribute in _structures collection",
|
|
function () {
|
|
var structures = getCollection("_structures");
|
|
|
|
if (! structures) {
|
|
return false;
|
|
}
|
|
|
|
structures.ensureUniqueConstraint("collection");
|
|
|
|
return true;
|
|
});
|
|
|
|
// loop through all tasks and execute them
|
|
console.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];
|
|
|
|
console.log("Executing task #" + (++taskNumber)
|
|
+ " (" + task.name + "): " + task.description);
|
|
|
|
// assume failure
|
|
var result = false;
|
|
|
|
try {
|
|
// execute task
|
|
result = task.code();
|
|
}
|
|
catch (e) {
|
|
}
|
|
|
|
if (result) {
|
|
// success
|
|
lastTasks[task.name] = true;
|
|
|
|
// save/update version info
|
|
internal.write(versionFile,
|
|
JSON.stringify({ version: currentVersion, tasks: lastTasks }));
|
|
|
|
console.log("Task successful");
|
|
}
|
|
else {
|
|
console.error("Task failed. Aborting upgrade procedure.");
|
|
console.error("Please fix the problem and try starting the server again.");
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// save file so version gets saved even if there are no tasks
|
|
internal.write(versionFile, JSON.stringify({ version: currentVersion, tasks: lastTasks }));
|
|
|
|
console.log("Upgrade successfully finished");
|
|
|
|
// successfully finished
|
|
return true;
|
|
}
|
|
|
|
|
|
function applyFixes () {
|
|
// fixes we'll apply every time we start the server after an upgrade can go here...
|
|
try {
|
|
var users = db._collection("_users");
|
|
if (users) {
|
|
users.ensureUniqueConstraint("user");
|
|
}
|
|
}
|
|
catch (e) {
|
|
|
|
}
|
|
}
|
|
|
|
var lastVersion = null;
|
|
var currentServerVersion = internal.db._version().match(/^(\d+\.\d+).*$/);
|
|
|
|
if (! currentServerVersion) {
|
|
// server version is invalid for some reason
|
|
console.error("Unexpected ArangoDB server version: " + internal.db._version());
|
|
return false;
|
|
}
|
|
|
|
var currentVersion = parseFloat(currentServerVersion[1]);
|
|
|
|
if (! internal.exists(versionFile)) {
|
|
console.info("No version information file found in database directory.");
|
|
return runUpgrade(currentVersion);
|
|
}
|
|
|
|
// VERSION file exists, read its contents
|
|
var versionInfo = internal.read(versionFile);
|
|
if (versionInfo !== '') {
|
|
var versionValues = JSON.parse(versionInfo);
|
|
if (versionValues && versionValues.version && ! isNaN(versionValues.version)) {
|
|
lastVersion = parseFloat(versionValues.version);
|
|
}
|
|
}
|
|
|
|
if (lastVersion === null) {
|
|
console.info("No VERSION file found in database directory.");
|
|
return runUpgrade(currentVersion);
|
|
}
|
|
|
|
if (lastVersion === currentVersion) {
|
|
// version match!
|
|
applyFixes();
|
|
return true;
|
|
}
|
|
|
|
if (lastVersion > currentVersion) {
|
|
// downgrade??
|
|
console.error("Database directory version (" + lastVersion
|
|
+ ") is higher than server version (" + currentVersion + ").");
|
|
|
|
console.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;
|
|
}
|
|
|
|
if (lastVersion < currentVersion) {
|
|
// upgrade
|
|
if (internal.UPGRADE) {
|
|
return runUpgrade(currentVersion);
|
|
}
|
|
|
|
console.error("Database directory version (" + lastVersion
|
|
+ ") is lower than server version (" + currentVersion + ").");
|
|
|
|
console.error("It seems like you have upgraded the ArangoDB binary. If this is"
|
|
+" what you wanted to do, please restart with the --upgrade option"
|
|
+" to upgrade the data in the database directory.");
|
|
|
|
// do not start unless started with --upgrade
|
|
return false;
|
|
}
|
|
|
|
// we should never get here
|
|
return true;
|
|
}());
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// --SECTION-- END-OF-FILE
|
|
// -----------------------------------------------------------------------------
|
|
|
|
// Local Variables:
|
|
// mode: outline-minor
|
|
// outline-regexp: "^\\(/// @brief\\|/// @addtogroup\\|// --SECTION--\\|/// @page\\|/// @}\\)"
|
|
// End:
|