mirror of https://gitee.com/bigwinds/arangodb
758 lines
23 KiB
JavaScript
758 lines
23 KiB
JavaScript
/*jshint unused: false */
|
|
'use strict';
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2016 ArangoDB GmbH, Cologne, Germany
|
|
/// Copyright 2013 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 ArangoDB GmbH, Cologne, Germany
|
|
///
|
|
/// @author Jan Steemann
|
|
/// @author Michael Hackstein
|
|
/// @author Dr. Frank Celler
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var arangodb = require("@arangodb");
|
|
var arangosh = require("@arangodb/arangosh");
|
|
var errors = arangodb.errors;
|
|
var ArangoError = arangodb.ArangoError;
|
|
var checkParameter = arangodb.checkParameter;
|
|
var arango = require("internal").arango;
|
|
var fs = require("fs");
|
|
|
|
var throwFileNotFound = arangodb.throwFileNotFound;
|
|
var throwBadParameter = arangodb.throwBadParameter;
|
|
|
|
var utils = require("@arangodb/foxx/manager-utils");
|
|
var store = require("@arangodb/foxx/store");
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief extracts command-line options
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var extractCommandLineOptions = function(args) {
|
|
|
|
var options = {};
|
|
var nargs = [];
|
|
var i;
|
|
|
|
var reOption = /^([\-_a-zA-Z0-9]*)=(.*)$/;
|
|
var reNumeric = /^(0|.0|([0-9]*(\.[0-9]*)?))$/;
|
|
var arg, match, key, value;
|
|
|
|
for (i = 0; i < args.length; ++i) {
|
|
arg = args[i];
|
|
match = reOption.exec(arg);
|
|
|
|
if (match !== null) {
|
|
key = match[1];
|
|
value = match[2];
|
|
|
|
if (reNumeric.test(value)) {
|
|
options[key] = parseFloat(value);
|
|
}
|
|
else {
|
|
options[key] = value;
|
|
}
|
|
}
|
|
else {
|
|
nargs.push(args[i]);
|
|
}
|
|
}
|
|
|
|
return { 'options': options, 'args': nargs };
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief extract options from CLI options
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
var extractOptions = function (args) {
|
|
var opts = extractCommandLineOptions(args);
|
|
if (3 < opts.args.length) {
|
|
var options = JSON.parse(opts.args[3]);
|
|
|
|
if (options.hasOwnProperty("configuration")) {
|
|
var key;
|
|
|
|
for (key in opts.options) {
|
|
if (opts.options.hasOwnProperty(key)) {
|
|
options.configuration[key] = opts.options[key];
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
options.configuration = opts.options;
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
return { configuration: opts.options };
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief prints out usage message for the command-line tool
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var cmdUsage = function () {
|
|
var printf = arangodb.printf;
|
|
var fm = "foxx-manager";
|
|
|
|
printf("Example usage:\n");
|
|
printf(" %s install <app-info> <mount-point> option1=value1\n", fm);
|
|
printf(" %s uninstall <mount-point>\n\n", fm);
|
|
|
|
printf("Further help:\n");
|
|
printf(" %s help for the list of foxx-manager commands\n", fm);
|
|
printf(" %s --help for the list of options\n", fm);
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief outputs the help
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var help = function () {
|
|
|
|
/*jshint maxlen: 200 */
|
|
var commands = {
|
|
"available" : "lists all Foxx applications available in the local repository",
|
|
"configuration" : "request the configuration information for the given mountpoint",
|
|
"configure" : "sets the configuration for the given mountpoint",
|
|
"updateDeps" : "links the dependencies in manifest to a mountpoint",
|
|
"dependencies" : "request the dependencies information for the given mountpoint",
|
|
"development" : "activates development mode for the given mountpoint",
|
|
"help" : "shows this help",
|
|
"info" : "displays information about a Foxx application",
|
|
"install" : "installs a foxx application identified by the given information to the given mountpoint",
|
|
"installed" : "alias for the 'list' command",
|
|
"list" : "lists all installed Foxx applications",
|
|
"production" : "activates production mode for the given mountpoint",
|
|
"replace" : ["replaces an installed Foxx application",
|
|
"WARNING: this action will remove application data if the application implements teardown!" ],
|
|
"run" : "runs the given script of a foxx app mounted at the given mountpoint",
|
|
"search" : "searches the local foxx-apps repository",
|
|
"set-dependencies": "sets the dependencies for the given mountpoint",
|
|
"setup" : "executes the setup script",
|
|
"teardown" : [ "executes the teardown script",
|
|
"WARNING: this action will remove application data if the application implements teardown!" ],
|
|
"tests" : "runs the tests of a foxx application mounted at the given mountpoint",
|
|
"uninstall" : ["uninstalls a Foxx application and calls its teardown method",
|
|
"WARNING: this will remove all data and code of the application!" ],
|
|
"update" : "updates the local foxx-apps repository with data from the central foxx-apps repository",
|
|
"upgrade" : ["upgrades an installed Foxx application",
|
|
"Note: this action will not call setup or teardown" ]
|
|
};
|
|
|
|
arangodb.print("\nThe following commands are available:\n");
|
|
var keys = Object.keys(commands).sort();
|
|
|
|
var i;
|
|
var pad, name, extra;
|
|
for (i = 0; i < keys.length; ++i) {
|
|
pad = " ";
|
|
name = keys[i] + pad;
|
|
extra = commands[keys[i]];
|
|
|
|
if (typeof extra !== 'string') {
|
|
// list of strings
|
|
extra = extra.join("\n " + pad) + "\n";
|
|
}
|
|
arangodb.printf(" %s %s\n", name.substr(0, pad.length), extra);
|
|
}
|
|
|
|
arangodb.print();
|
|
arangodb.print("Use foxx-manager --help to show a list of global options\n");
|
|
arangodb.print("There is also an online manual available at:");
|
|
arangodb.print("https://docs.arangodb.com/Foxx/Install/");
|
|
|
|
// additional newline
|
|
arangodb.print();
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief runs a script on a Foxx application
|
|
///
|
|
/// Input:
|
|
/// * name: the name of the script
|
|
/// * mount: the mount path starting with a "/"
|
|
///
|
|
/// Output:
|
|
/// -
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
var runScript = function(mount, name, options) {
|
|
checkParameter(
|
|
"run(<mount>, <name>, [<options>])",
|
|
[ [ "Mount path", "string" ], [ "Script name", "string" ] ],
|
|
[ mount, name ] );
|
|
var res;
|
|
var req = {
|
|
name: name,
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
res = arango.POST("/_admin/foxx/script", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return res;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Zips and copies a local app to the server.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var moveAppToServer = function(appInfo) {
|
|
if (! fs.exists(appInfo)) {
|
|
throwFileNotFound("Cannot find file: " + appInfo + ".");
|
|
}
|
|
var filePath;
|
|
var shouldDelete = false;
|
|
if (fs.isDirectory(appInfo)) {
|
|
filePath = utils.zipDirectory(appInfo);
|
|
shouldDelete = true;
|
|
}
|
|
if (fs.isFile(appInfo)) {
|
|
filePath = appInfo;
|
|
}
|
|
if (!filePath) {
|
|
throwBadParameter("Invalid file: " + appInfo + ". Has to be a direcotry or zip archive");
|
|
}
|
|
var response = arango.SEND_FILE("/_api/upload", filePath);
|
|
if (shouldDelete) {
|
|
try {
|
|
fs.remove(filePath);
|
|
}
|
|
catch (err2) {
|
|
arangodb.printf("Cannot remove temporary file '%s'\n", filePath);
|
|
}
|
|
}
|
|
if (! response.filename) {
|
|
throw new ArangoError({
|
|
errorNum: errors.ERROR_APPLICATION_UPLOAD_FAILED.code,
|
|
errorMessage: errors.ERROR_APPLICATION_UPLOAD_FAILED.message
|
|
+ ": " + String(response.errorMessage)
|
|
});
|
|
}
|
|
return response.filename;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Installs a new foxx application on the given mount point.
|
|
///
|
|
/// TODO: Long Documentation!
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var install = function(appInfo, mount, options) {
|
|
checkParameter(
|
|
"install(<appInfo>, <mount>, [<options>])",
|
|
[ [ "Install information", "string" ],
|
|
[ "Mount path", "string" ] ],
|
|
[ appInfo, mount ] );
|
|
|
|
utils.validateMount(mount);
|
|
if (fs.exists(appInfo)) {
|
|
appInfo = moveAppToServer(appInfo);
|
|
}
|
|
var res;
|
|
var req = {
|
|
appInfo: appInfo,
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
|
|
res = arango.POST("/_admin/foxx/install", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Uninstalls the foxx application on the given mount point.
|
|
///
|
|
/// TODO: Long Documentation!
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var uninstall = function(mount, options) {
|
|
checkParameter(
|
|
"uninstall(<mount>, [<options>])",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
var res;
|
|
var req = {
|
|
mount: mount,
|
|
options: options || {}
|
|
};
|
|
utils.validateMount(mount);
|
|
res = arango.POST("/_admin/foxx/uninstall", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Replaces a foxx application on the given mount point by an other one.
|
|
///
|
|
/// TODO: Long Documentation!
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var replace = function(appInfo, mount, options) {
|
|
checkParameter(
|
|
"replace(<appInfo>, <mount>, [<options>])",
|
|
[ [ "Install information", "string" ],
|
|
[ "Mount path", "string" ] ],
|
|
[ appInfo, mount ] );
|
|
|
|
utils.validateMount(mount);
|
|
if (fs.exists(appInfo)) {
|
|
appInfo = moveAppToServer(appInfo);
|
|
}
|
|
var res;
|
|
var req = {
|
|
appInfo: appInfo,
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
|
|
res = arango.POST("/_admin/foxx/replace", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Upgrade a foxx application on the given mount point by a new one.
|
|
///
|
|
/// TODO: Long Documentation!
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var upgrade = function(appInfo, mount, options) {
|
|
checkParameter(
|
|
"upgrade(<appInfo>, <mount>, [<options>])",
|
|
[ [ "Install information", "string" ],
|
|
[ "Mount path", "string" ] ],
|
|
[ appInfo, mount ] );
|
|
utils.validateMount(mount);
|
|
if (fs.exists(appInfo)) {
|
|
appInfo = moveAppToServer(appInfo);
|
|
}
|
|
var res;
|
|
var req = {
|
|
appInfo: appInfo,
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
|
|
res = arango.POST("/_admin/foxx/upgrade", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Activate the development mode for the application on the given mount point.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var development = function(mount) {
|
|
checkParameter(
|
|
"development(<mount>)",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
utils.validateMount(mount);
|
|
var res;
|
|
var req = {
|
|
mount: mount,
|
|
activate: true
|
|
};
|
|
res = arango.POST("/_admin/foxx/development", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Activate the production mode for the application on the given mount point.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var production = function(mount) {
|
|
checkParameter(
|
|
"production(<mount>)",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
utils.validateMount(mount);
|
|
var res;
|
|
var req = {
|
|
mount: mount,
|
|
activate: false
|
|
};
|
|
res = arango.POST("/_admin/foxx/development", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Configure the app at the mountpoint
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var configure = function(mount, options) {
|
|
checkParameter(
|
|
"configure(<mount>)",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
utils.validateMount(mount);
|
|
var req = {
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
var res = arango.POST("/_admin/foxx/configure", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Get the configuration for the app at the given mountpoint
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var configuration = function(mount) {
|
|
checkParameter(
|
|
"configuration(<mount>)",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
utils.validateMount(mount);
|
|
var req = {
|
|
mount: mount
|
|
};
|
|
var res = arango.POST("/_admin/foxx/configuration", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return res;
|
|
};
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Link Dependencies to the installed mountpoint the app at the mountpoint
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var updateDeps = function(mount, options) {
|
|
checkParameter(
|
|
"update(<mount>)",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
utils.validateMount(mount);
|
|
var req = {
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
var res = arango.POST("/_admin/foxx/updateDeps", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Configure the dependencies of the app at the mountpoint
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var setDependencies = function(mount, options) {
|
|
checkParameter(
|
|
"setDependencies(<mount>)",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
utils.validateMount(mount);
|
|
var req = {
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
var res = arango.POST("/_admin/foxx/set-dependencies", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return {
|
|
name: res.name,
|
|
version: res.version,
|
|
mount: res.mount
|
|
};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Get the dependencies of the app at the given mountpoint
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var dependencies = function(mount) {
|
|
checkParameter(
|
|
"dependencies(<mount>)",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ] );
|
|
utils.validateMount(mount);
|
|
var req = {
|
|
mount: mount
|
|
};
|
|
var res = arango.POST("/_admin/foxx/dependencies", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return res;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief run a Foxx application's tests
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var tests = function (mount, options) {
|
|
checkParameter(
|
|
"tests(<mount>, [<options>])",
|
|
[ [ "Mount path", "string" ] ],
|
|
[ mount ]
|
|
);
|
|
utils.validateMount(mount);
|
|
var req = {
|
|
mount: mount,
|
|
options: options
|
|
};
|
|
var res = arango.POST("/_admin/foxx/tests", JSON.stringify(req));
|
|
arangosh.checkRequestResult(res);
|
|
return res;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief command line dispatcher
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var run = function (args) {
|
|
if (args === undefined || args.length === 0) {
|
|
arangodb.print("Expecting a command, please try:\n");
|
|
cmdUsage();
|
|
return 0;
|
|
}
|
|
|
|
var type = args[0];
|
|
var printf = arangodb.printf;
|
|
var res;
|
|
var options;
|
|
|
|
|
|
try {
|
|
switch (type) {
|
|
case "setup":
|
|
runScript(args[1], "setup");
|
|
break;
|
|
case "teardown":
|
|
runScript(args[1], "teardown");
|
|
break;
|
|
case "run":
|
|
options = args.slice(3).map(function (arg) {
|
|
return JSON.parse(arg);
|
|
});
|
|
res = runScript(args[1], args[2], options);
|
|
printf(JSON.stringify(res, null, 2) + "\n");
|
|
break;
|
|
case "tests":
|
|
options = args[2] ? JSON.parse(args[2]) : undefined;
|
|
res = tests(args[1], options);
|
|
printf(JSON.stringify(res, null, 2) + "\n");
|
|
break;
|
|
case "install":
|
|
options = extractOptions(args);
|
|
res = install(args[1], args[2], options);
|
|
printf("Application %s version %s installed successfully at mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
printf("options used: %s\n", JSON.stringify(options));
|
|
break;
|
|
case "replace":
|
|
options = extractOptions(args);
|
|
res = replace(args[1], args[2], options);
|
|
printf("Application %s version %s replaced successfully at mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "upgrade":
|
|
options = extractOptions(args);
|
|
res = upgrade(args[1], args[2], options);
|
|
printf("Application %s version %s upgraded successfully at mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "uninstall":
|
|
options = extractOptions(args).configuration || {};
|
|
res = uninstall(args[1], options);
|
|
|
|
printf("Application %s version %s uninstalled successfully from mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "list":
|
|
case "installed":
|
|
if (1 < args.length && args[1] === "prefix") {
|
|
utils.list(true);
|
|
}
|
|
else {
|
|
utils.list();
|
|
}
|
|
break;
|
|
case "listDevelopment":
|
|
if (1 < args.length && args[1] === "prefix") {
|
|
utils.listDevelopment(true);
|
|
}
|
|
else {
|
|
utils.listDevelopment();
|
|
}
|
|
break;
|
|
case "available":
|
|
store.available();
|
|
break;
|
|
case "info":
|
|
store.info(args[1]);
|
|
break;
|
|
case "search":
|
|
store.search(args[1]);
|
|
break;
|
|
case "update":
|
|
store.update();
|
|
break;
|
|
case "help":
|
|
help();
|
|
break;
|
|
case "development":
|
|
res = development(args[1]);
|
|
printf("Activated development mode for Application %s version %s on mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "production":
|
|
res = production(args[1]);
|
|
printf("Activated production mode for Application %s version %s on mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "configure":
|
|
options = extractOptions(args).configuration || {};
|
|
res = configure(args[1], options);
|
|
printf("Reconfigured Application %s version %s on mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "configuration":
|
|
res = configuration(args[1]);
|
|
printf("Configuration options:\n%s\n", JSON.stringify(res, undefined, 2));
|
|
break;
|
|
case "updateDeps":
|
|
options = extractOptions(args).configuration || {};
|
|
res = updateDeps(args[1], options);
|
|
printf("Reconfigured Application %s version %s on mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "set-dependencies":
|
|
options = extractOptions(args).configuration || {};
|
|
res = setDependencies(args[1], options);
|
|
printf("Reconfigured dependencies of Application %s version %s on mount point %s\n",
|
|
res.name,
|
|
res.version,
|
|
res.mount);
|
|
break;
|
|
case "dependencies":
|
|
res = dependencies(args[1]);
|
|
printf("Dependencies:\n%s\n", JSON.stringify(res, undefined, 2));
|
|
break;
|
|
default:
|
|
printf("Unknown command '%s', please try:\n", type);
|
|
cmdUsage();
|
|
}
|
|
return 0;
|
|
}
|
|
catch (err) {
|
|
if (err instanceof ArangoError) {
|
|
printf("%s\n", err.errorMessage);
|
|
}
|
|
else {
|
|
printf("%s\n", err.message);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
};
|
|
|
|
|
|
exports.install = install;
|
|
exports.setup = function (mount, opts) {return runScript(mount, "setup", opts);};
|
|
exports.teardown = function (mount, opts) {return runScript(mount, "teardown", opts);};
|
|
exports.runScript = runScript;
|
|
exports.tests = tests;
|
|
exports.uninstall = uninstall;
|
|
exports.replace = replace;
|
|
exports.upgrade = upgrade;
|
|
exports.development = development;
|
|
exports.production = production;
|
|
exports.configure = configure;
|
|
exports.configuration = configuration;
|
|
exports.setDependencies = setDependencies;
|
|
exports.dependencies = dependencies;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Clientside only API
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
exports.run = run;
|
|
exports.help = help;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Exports from foxx utils module.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
exports.mountedApp = utils.mountedApp;
|
|
exports.list = utils.list;
|
|
exports.listJson = utils.listJson;
|
|
exports.listDevelopment = utils.listDevelopment;
|
|
exports.listDevelopmentJson = utils.listDevelopmentJson;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Exports from foxx store module.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
exports.available = store.available;
|
|
exports.availableJson = store.availableJson;
|
|
exports.search = store.search;
|
|
exports.searchJson = store.searchJson;
|
|
exports.update = store.update;
|
|
exports.info = store.info;
|