mirror of https://gitee.com/bigwinds/arangodb
304 lines
9.4 KiB
JavaScript
304 lines
9.4 KiB
JavaScript
/*global require, applicationContext */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief A Foxx.Controller to show all Foxx Applications
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2010-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 triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Michael Hackstein
|
|
/// @author Copyright 2011-2013, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
(function() {
|
|
"use strict";
|
|
|
|
var FoxxController = require("org/arangodb/foxx").Controller;
|
|
var controller = new FoxxController(applicationContext);
|
|
var ArangoError = require("org/arangodb").ArangoError;
|
|
var FoxxManager = require("org/arangodb/foxx/manager");
|
|
var actions = require("org/arangodb/actions");
|
|
var joi = require("joi");
|
|
var docu = require("lib/swagger").Swagger;
|
|
var underscore = require("underscore");
|
|
var mountPoint = {
|
|
type: joi.string().required().description(
|
|
"The mount point of the app. Has to be url-encoded."
|
|
)
|
|
};
|
|
var fs = require("fs");
|
|
var defaultThumb = require("/lib/defaultThumbnail").defaultThumb;
|
|
|
|
controller.extend({
|
|
installer: function() {
|
|
this.queryParam("mount", mountPoint);
|
|
this.queryParam("upgrade", {type: joi.boolean().optional().description(
|
|
"Trigger to upgrade the app installed at the mountpoint. Triggers setup."
|
|
)});
|
|
this.queryParam("replace", {type: joi.boolean().optional().description(
|
|
"Trigger to replace the app installed at the mountpoint. Triggers teardown and setup."
|
|
)});
|
|
}
|
|
});
|
|
|
|
// ------------------------------------------------------------
|
|
// SECTION install
|
|
// ------------------------------------------------------------
|
|
|
|
var validateMount = function(req) {
|
|
var mount = req.params("mount");
|
|
// Validation
|
|
mount = decodeURIComponent(mount);
|
|
return mount;
|
|
};
|
|
|
|
var installApp = function(req, res, appInfo, options) {
|
|
var mount = validateMount(req);
|
|
var upgrade = req.params("upgrade") || false;
|
|
var replace = req.params("replace") || false;
|
|
try {
|
|
var app;
|
|
if (upgrade) {
|
|
app = FoxxManager.upgrade(appInfo, mount, options);
|
|
} else if (replace) {
|
|
app = FoxxManager.replace(appInfo, mount, options);
|
|
} else {
|
|
app = FoxxManager.install(appInfo, mount, options);
|
|
}
|
|
var config = FoxxManager.configuration(mount);
|
|
res.json({
|
|
error: false,
|
|
configuration: config,
|
|
name: app.name,
|
|
version: app.version
|
|
});
|
|
} catch (e) {
|
|
e.error = true;
|
|
res.json(e);
|
|
}
|
|
};
|
|
|
|
/** Install a Foxx from the store
|
|
*
|
|
* Downloads a Foxx from the store and installs it at the given mount
|
|
*/
|
|
controller.put("/store", function(req, res) {
|
|
var content = JSON.parse(req.requestBody),
|
|
name = content.name,
|
|
version = content.version;
|
|
installApp(req, res, name + ":" + version);
|
|
}).installer();
|
|
|
|
/** Install a Foxx from Github
|
|
*
|
|
* Install a Foxx with user/repository and version
|
|
*/
|
|
controller.put("/git", function (req, res) {
|
|
var content = JSON.parse(req.requestBody),
|
|
url = content.url,
|
|
version = content.version;
|
|
installApp(req, res, "git:" + url + ":" + (version || "master"));
|
|
}).installer();
|
|
|
|
/** Generate a new foxx
|
|
*
|
|
* Generate a new empty foxx on the given mount point
|
|
*/
|
|
controller.put("/generate", function (req, res) {
|
|
var info = JSON.parse(req.requestBody);
|
|
installApp(req, res, "EMPTY", info);
|
|
}).installer();
|
|
|
|
/** Install a Foxx from temporary zip file
|
|
*
|
|
* Install a Foxx from the given zip path.
|
|
* This path has to be created via _api/upload
|
|
*/
|
|
controller.put("/zip", function (req, res) {
|
|
var content = JSON.parse(req.requestBody),
|
|
file = content.zipFile,
|
|
path = fs.join(fs.getTempPath(), file);
|
|
installApp(req, res, path);
|
|
}).installer();
|
|
|
|
|
|
/** Uninstall a Foxx
|
|
*
|
|
* Uninstall the Foxx at the given mount-point.
|
|
*/
|
|
controller.del("/", function (req, res) {
|
|
var mount = validateMount(req);
|
|
try {
|
|
var app = FoxxManager.uninstall(mount);
|
|
res.json({
|
|
error: false,
|
|
name: app.name,
|
|
version: app.version
|
|
});
|
|
} catch (e) {
|
|
res.json({
|
|
error: true,
|
|
message: e.message || String(e)
|
|
});
|
|
res.json(e);
|
|
res.status = actions.HTTP_SERVER_ERROR;
|
|
}
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
// ------------------------------------------------------------
|
|
// SECTION information
|
|
// ------------------------------------------------------------
|
|
|
|
/** List all Foxxes
|
|
*
|
|
* Get a List of all running foxxes
|
|
*/
|
|
controller.get('/', function (req, res) {
|
|
res.json(FoxxManager.listJson());
|
|
});
|
|
|
|
/** Get the thumbnail of a Foxx
|
|
*
|
|
* Used to request the thumbnail of the given Foxx in order to display it on the screen.
|
|
*/
|
|
controller.get("/thumbnail", function (req, res) {
|
|
res.transformations = [ "base64decode" ];
|
|
var mount = validateMount(req);
|
|
var app = FoxxManager.lookupApp(mount);
|
|
if (app.hasOwnProperty("_thumbnail")) {
|
|
res.body = app._thumbnail;
|
|
} else {
|
|
res.body = defaultThumb;
|
|
}
|
|
// evil mimetype detection attempt...
|
|
var start = require("internal").base64Decode(res.body.substr(0, 8));
|
|
if (start.indexOf("PNG") !== -1) {
|
|
res.contentType = "image/png";
|
|
}
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
/** Get the configuration for an app
|
|
*
|
|
* Used to request the configuration options for apps
|
|
*/
|
|
controller.get("/config", function(req, res) {
|
|
var mount = validateMount(req);
|
|
res.json(FoxxManager.configuration(mount));
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
/** Set the configuration for an app
|
|
*
|
|
* Used to overwrite the configuration options for apps
|
|
*/
|
|
controller.patch("/config", function(req, res) {
|
|
var mount = validateMount(req);
|
|
var data = req.body();
|
|
res.json(FoxxManager.configure(mount, data));
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
/** Trigger setup script for an app
|
|
*
|
|
* Used to trigger the setup script of an app
|
|
*/
|
|
controller.patch("/setup", function(req, res) {
|
|
var mount = validateMount(req);
|
|
res.json(FoxxManager.setup(mount));
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
/** Trigger teardown script for an app
|
|
*
|
|
* Used to trigger the teardown script of an app
|
|
*/
|
|
controller.patch("/teardown", function(req, res) {
|
|
var mount = validateMount(req);
|
|
res.json(FoxxManager.teardown(mount));
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
|
|
|
|
/** Activate/Deactivate development mode for an app
|
|
*
|
|
* Used to toggle between production and development mode
|
|
*/
|
|
controller.patch("/devel", function(req, res) {
|
|
var mount = validateMount(req);
|
|
var activate = Boolean(req.body());
|
|
if (activate) {
|
|
res.json(FoxxManager.development(mount));
|
|
} else {
|
|
res.json(FoxxManager.production(mount));
|
|
}
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
// ------------------------------------------------------------
|
|
// SECTION store
|
|
// ------------------------------------------------------------
|
|
|
|
/** List all Foxxes in Fishbowl
|
|
*
|
|
* Get the information for all Apps availbale in the Fishbowl and ready for download
|
|
*
|
|
*/
|
|
controller.get('/fishbowl', function (req, res) {
|
|
FoxxManager.update();
|
|
res.json(FoxxManager.availableJson());
|
|
}).summary("List of all foxx apps submitted to the fishbowl store.")
|
|
.notes("This function contacts the fishbowl and reports which apps are available for install")
|
|
.errorResponse(ArangoError, 503, "Could not connect to store.");
|
|
|
|
|
|
|
|
// ------------------------------------------------------------
|
|
// SECTION documentation
|
|
// ------------------------------------------------------------
|
|
|
|
/** Returns the billboard URL for swagger
|
|
*
|
|
* Returns the billboard URL for the application mounted
|
|
* at the given mountpoint
|
|
*/
|
|
controller.get('/billboard', function(req, res) {
|
|
var mount = decodeURIComponent(decodeURIComponent(req.params("mount")));
|
|
var path = req.protocol + "://" + req.headers.host +
|
|
"/_db/" + encodeURIComponent(req.database) +
|
|
"/_admin/aardvark/foxxes/docu";
|
|
res.json({
|
|
swaggerVersion: "1.1",
|
|
basePath: path,
|
|
apis: [
|
|
{path: mount}
|
|
]
|
|
});
|
|
}).queryParam("mount", mountPoint);
|
|
|
|
/** Returns the generated Swagger JSON description for one foxx
|
|
*
|
|
* This function returns the Swagger JSON API description of the foxx
|
|
* installed under the given mount point.
|
|
*/
|
|
controller.get('/docu/*', function(req, res) {
|
|
var mount = "";
|
|
underscore.each(req.suffix, function(part) {
|
|
mount += "/" + part;
|
|
});
|
|
res.json(docu(mount));
|
|
});
|
|
|
|
}());
|