cloudcms-cli/lib/util.js

Cloud CMS Command-Line client

var fs = require('fs');
var path = require('path');

var archiver = require("archiver");
var extractZip = require("extract-zip");

var Gitana = require("gitana");
Gitana.loadDefaultConfig = function() {
    return {};
};

var exports = module.exports = function(basePath)
{
    // make sure basepath resolved to an absolute path
    basePath = path.resolve(basePath);

    var configDirectoryPath = path.join(basePath, ".cloudcms");

    ///////////////////////////////////////////////////////////////////////////////////////////////
    //
    // RESPONSE OBJECT
    //
    ///////////////////////////////////////////////////////////////////////////////////////////////

    var r = {};

    /**
     * Connects to Cloud CMS using a pre-established .cloudcms credentials file.
     *
     * @param credentials
     * @param callback
     */
    var connect = r.connect = function(credentials, callback)
    {
        if (typeof(credentials) === "function")
        {
            callback = credentials;
            credentials = null;
        }

        if (!credentials)
        {
            credentials = readCredentials();
        }
        if (!credentials)
        {
            callback({
                "message": "Unable to locate credentials.json file"
            });
            return;
        }

        Gitana.connect(credentials, function(err) {
            callback.call(this, err);
        });

    };

    /**
     * Connects and returns the deployed application instance on the Cloud CMS server using a
     * pre-established .cloudcms credentials file.
     *
     * @param command
     * @param callback
     */
    r.deployedApp = function(command, callback)
    {
        findCurrentDeploymentKey(function(err, deploymentKey, application) {

            if (err)
            {
                callback(err);
                return;
            }

            if (!deploymentKey)
            {
                callback({
                    "message": "Cannot find current deployment key"
                });

                return;
            }

            connect(function(err) {

                if (err) {
                    callback(err);
                    return;
                }

                var errHandler = function(err) {

                    callback(err);
                    return;
                };

                // this = platform
                application.findDeployedApplication(deploymentKey).then(function() {

                    this[command]().then(function() {
                        callback.call(this);
                    });

                });
            });

        });
    };

    /**
     * Executes on command line and returns output.
     *
     * @param commands
     * @param callback
     */
    r.executeCommands = function(commands, callback)
    {
        var terminal = require('child_process').spawn('bash');

        var text = "";

        terminal.stdout.on('data', function (data) {
            text = text + data;
        });

        terminal.on('exit', function (code) {

            var err = null;
            if (code != 0)
            {
                err = {
                    "commands": commands,
                    "message": text,
                    "code": code
                };
            }

            callback(err, text);
        });

        setTimeout(function() {
            for (var i = 0; i < commands.length; i++)
            {
                var command = commands[i];
                terminal.stdin.write(command + "\n");
            }

            terminal.stdin.end();

        }, 1000);
    };

    var executeCommandsEx = r.executeCommandsEx = function(commands, logMethod, callback)
    {
        var terminal = require('child_process').spawn('bash');

        logMethod("Running commands: " + JSON.stringify(commands));

        var text = "";

        terminal.stdout.on('data', function (data) {
            logMethod("" + data);
            text = text + data;
        });

        terminal.on('exit', function (code) {

            var err = null;
            if (code !== 0)
            {
                logMethod('child process exited with code ' + code + ' for commands: ' + commands);

                err = {
                    "commands": commands,
                    "message": text,
                    "code": code
                };
            }

            callback(err);
        });

        setTimeout(function() {
            //console.log('Sending stdin to terminal');

            for (var i = 0; i < commands.length; i++)
            {
                var command = commands[i];
                terminal.stdin.write(command + "\n");
            }

            terminal.stdin.end();

        }, 1000);
    };

    /**
     * Finds and hands back the credentials file.
     */
    var readCredentials = r.readCredentials = function()
    {
        var text = null;

        if (fs.existsSync(path.join(homeDirectory(), ".cloudcms", "credentials.json")))
        {
            text = fs.readFileSync(path.join(homeDirectory(), ".cloudcms", "credentials.json"));
        }

        var credentials = null;
        if (text)
        {
            credentials = JSON.parse(text);
        }

        if (credentials)
        {
            credentials.key = "credentials";
        }

        return credentials;
    };

    r.trim = function(text)
    {
        var trimmed = text;

        if (trimmed && typeof(text) == "string")
        {
            trimmed = trimmed.replace(/^\s+|\s+$/g, '');
        }

        return trimmed;
    };

    var homeDirectory = r.homeDirectory = function()
    {
        return process.env[(process.platform == 'win32') ? 'USERPROFILE' : 'HOME'];
    };

    var readGitanaJson = r.readGitanaJson = function(callback)
    {
        var gitanaJsonPath = path.join(basePath, "gitana.json");

        fs.readFile(gitanaJsonPath, function(err, text) {

            if (err) {
                callback(err);
                return;
            }

            var json = JSON.parse(text);

            json.key = "gitana.json";

            callback(null, json);
        });
    };

    var writeGitanaJson = r.writeGitanaJson = function(applicationId, clientKey, clientSecret, authGrantKey, authGrantSecret, callback)
    {
        var gitanaJsonPath = path.join(basePath, "gitana.json");

        // credentials
        var credentials = readCredentials();

        // json
        var json = {
            "application": applicationId
        };
        if (clientKey) {
            json.clientKey = clientKey;
        }
        if (clientSecret) {
            json.clientSecret = clientSecret;
        }
        if (authGrantKey) {
            json.username = authGrantKey;
        }
        if (authGrantSecret) {
            json.password = authGrantSecret;
        }
        if (credentials.baseURL) {
            json.baseURL = credentials.baseURL;
        }

        // write the file
        fs.writeFile(gitanaJsonPath, JSON.stringify(json, null, "  "), function(err) {
            callback(err);
        });
    };

    var findCurrentDeploymentKey = r.findCurrentDeploymentKey = function(callback)
    {
        var credentials = readCredentials();
        if (!credentials)
        {
            callback({
                "message": "Unable to find credentials file"
            });
            return;
        }

        readGitanaJson(function(err, gitanaJson) {

            var applicationId = gitanaJson.application;
            var clientId = gitanaJson.clientKey;
            var authGrantId = gitanaJson.username;

            // connect to Cloud CMS
            connect(function(err) {

                if (err) {
                    callback(err);
                    return;
                }

                var errHandler = function(err)
                {
                    callback(err);
                    return;
                };

                // this = platform
                this.trap(errHandler);

                // read the application
                var application = null;
                this.readApplication(applicationId).then(function() {
                    application = this;
                });
                var client = null;
                this.readClient(clientId).then(function() {
                    client = this;
                });
                var authGrant = null;
                this.readAuthenticationGrant(authGrantId).then(function() {
                    authGrant = this;
                });
                this.then(function() {

                    // find the deployment for the given client and auth grant
                    var dk = null;
                    for (var deploymentKey in application.deployments)
                    {
                        var deployment = application.deployments[deploymentKey];

                        if (deployment.clientId == client._doc || deployment.clientId == client.key)
                        {
                            if (deployment.authGrantId == authGrant._doc || deployment.authGrantId == authGrant.key)
                            {
                                dk = deploymentKey;
                                break;
                            }
                        }
                    }

                    callback(null, dk, application);
                });
            });
        });
    };

    r.isArray = function(a)
    {
        return (!!a) && (a.constructor === Array);
    };

    r.isObject = function(a)
    {
        return (!!a) && (a.constructor === Object);
    };

    r.isString = function(a)
    {
        return typeof(a) === "string";
    };

    var zip = r.zip = function(directoryPath, zipFilePath, callback)
    {
        var _err = null;

        var writableStream = fs.createWriteStream(zipFilePath);
        writableStream.on('close', function() {
            callback(_err);
        });

        var archive = archiver("zip");
        archive.on('error', function(err){
            _err = err;
        });

        archive.pipe(writableStream);

        archive.directory(directoryPath, false);

        archive.finalize();
    };

    var unzip = r.unzip = function(zipFilePath, destinationFolderPath, callback)
    {
        extractZip(zipFilePath, {dir: destinationFolderPath}, function (err) {
            callback(err);
        });
    };

    return r;
};