Source: lib/commands/install.js

  1. /*!
  2.  * Copyright (C) 2010-2015 by Revolution Analytics Inc.
  3.  *
  4.  * This program is licensed to you under the terms of Version 2.0 of the
  5.  * Apache License. This program is distributed WITHOUT
  6.  * ANY EXPRESS OR IMPLIED WARRANTY, INCLUDING THOSE OF NON-INFRINGEMENT,
  7.  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Please refer to the
  8.  * Apache License 2.0 (http://www.apache.org/licenses/LICENSE-2.0) for more
  9.  * details.
  10.  */
  12. 'use strict';
  14. var path     = require('path'),
  15.     fs       = require('fs'),
  16.     deployr  = require('deployr'),
  17.     request  = require('request'),
  18.     opn      = require('opn'),
  19.     shell    = require('shelljs'),
  20.     Download = require('download'),
  21.     progress = require('download-status'),
  22.     spinner  = require('char-spinner'),
  23.     LangType = require('../util/lang-type'),
  24.     di       = require('../../di'),
  25.     conf     = di.config,
  26.     // --- color aliases ---
  27.     ul       = di.chalk.underline,
  28.     dim      = di.chalk.dim,
  29.     red      = di.chalk.red,
  30.     gray     = di.chalk.gray,
  31.     green    = di.chalk.green,
  32.     yellow   = di.chalk.yellow,
  33.     magenta  = di.chalk.magenta;
  35. /**
  36.  * Commands for installing and deploying starter examples.
  37.  * @mixin
  38.  * @alias commands/install
  39.  */   
  40. var install = exports;
  42. /** 
  43.  * Usage for the _di install *_ commands which allow you install and deploy
  44.  * starter examples.
  45.  * 
  46.  * - di install example
  47.  * - di install example <example name>
  48.  */
  49. install.usage = [
  50.     'The `di install` command installs pre-built DeployR examples locally',
  51.     '',
  52.     'Example usages:',
  53.     'di install example',
  54.     'di install example <example name>'
  55. ];
  57. /**
  58.  * Installs a starter example.
  59.  *
  60.  * @param {String} exName - The example to install.
  61.  * @param {Function} callback - Continuation to pass control when complete.
  62.  */
  63. install.example = function(exName, callback) {    
  64.     var exConfig = {};
  66.     //
  67.     // Allows arbitrary amount of arguments
  68.     //
  69.     if (arguments.length) {
  70.         var args = Array.prototype.slice.call([arguments], 0)[0];
  71.         callback = args[arguments.length - 1];
  72.         exName = args[0] || null;
  73.     }
  74.     
  75.     function listExamples() {
  76.         var interval   = spinner(),
  77.             separator  = di.prompt.separator,
  78.             jsList     = [],
  79.             javaList   = [],
  80.             dotNETList = [];
  82.         request.get({
  83.                 url: conf.get('git').repos,
  84.                 headers: {
  85.                     'User-Agent': 'Awesome-Octocat-App'
  86.                 }
  87.             },
  88.             function(err, res, body) {
  89.                 var found = false, choices = [];
  91.                 clearInterval(interval);
  93.                 if (err || res.statusCode != 200) {
  94.                     return callback(err);
  95.                 }                
  97.                 try {
  98.                     JSON.parse(body).forEach(function(repo, i) {
  99.                         var name = repo.name;
  100.                         if (name.indexOf('example') > -1) {
  101.                             found = name === exName ? true : found;
  102.                             switch (LangType.parse(name)) {
  103.                                 case LangType.JS:
  104.                                     jsList.push({ name: '  ' + name });
  105.                                     break;
  107.                                 case LangType.JAVA:
  108.                                     javaList.push('  ' + name);
  109.                                     break;
  111.                                 case LangType.DOTNET:
  112.                                     dotNETList.push('  ' + name);
  113.                                     break;
  114.                             }
  115.                         }
  116.                     });
  118.                     if (found) {
  119.                         console.log('Installing example ' + ul(exName) + '\n');
  120.                         installExample(exName, di.noop);
  121.                         return;
  122.                     }                    
  124.                     if (jsList.length > 0) {
  125.                         choices.push(separator('JavaScript Examples '));
  126.                         choices.push(jsList);
  127.                     }
  129.                     if (javaList.length > 0) {
  130.                         choices.push(separator());
  131.                         choices.push(separator('Java Examples '));
  132.                         choices.push(javaList);
  133.                     }
  135.                     if (dotNETList.length > 0) {
  136.                         choices.push(separator('.NET Examples '));
  137.                         choices.push(dotNETList);
  138.                     }
  140.                     choices.push(separator());
  141.                     choices.push({
  142.                         name: 'Take me back home!',
  143.                         value: {
  144.                             method: 'home'
  145.                         }
  146.                     });
  148.                     di.prompt.inquirer([{
  149.                         name: 'example',
  150.                         type: 'list',
  151.                         message: 'What example would you like to install?',
  152.                         choices: di._.flatten(choices)
  153.                     }], function(answer) {
  154.                         if (!answer.example.method) {
  155.                             installExample(answer.example.trim(), di.noop);
  156.                         } else {
  157.                             di.home();
  158.                         }
  159.                     }.bind(di));
  161.                 } catch (err) {
  162.                     return callback(new Error(chalk.bold(
  163.                         'A problem occurred installing the example from Github.' +
  164.                         '\nUnable to parse response: not valid JSON.'
  165.                     )));
  166.                 }
  167.             }); 
  168.     }
  170.     function installExample(example) {        
  171.         var download = new Download({
  172.                 extract: true,
  173.                 strip: 1,
  174.                 mode: '755'
  175.             })
  176.             .get(conf.get('git').example.replace('{{example}}', example))
  177.             .dest(example)
  178.             .use(progress());
  180.         download.run(function(err, files, stream) {
  181.             if (err) { callback(new Error(err)); }
  183.             console.log(green.bold('✓ download complete.\n'));
  184.             console.log(ul(example));
  186.             var installer;
  188.             switch (LangType.parse(example)) {
  189.                 case LangType.JS:
  190.                     installer = function(next) {
  191.                         console.log(yellow('\nResolving npm dependencies, this might take a while...\n'));
  192.                         di.spawnCommand('npm', ['install', '--production', '--silent'])
  193.                             .on('error', next)
  194.                             .on('exit', next);
  195.                     };
  196.                     break;
  198.                 case LangType.JAVA:
  199.                 case LangType.DOTNET:
  200.                     installer = function(next) { next(); }
  201.                     break;
  202.             }
  204.             // be in the example dir for installation and running
  205.             shell.cd(example);
  207.             installer(function() {
  208.                 fs.exists(path.resolve('di-config.json'), function(exists) {
  209.                     if (exists) {
  210.                         agent();
  212.                         deployr.io('/r/user/about')
  213.                             .error(function() {
  214.                                 var end = !conf.get('endpoint') ?
  215.                                     ' First identify your DeployR server endpoint.' : '';
  216.                                 console.log(yellow('\nAuthentication required to install.' + end + '\n'));
  218.                                 di.commands.login(function(err) {
  219.                                     if (err) { return callback(err); }
  221.                                     installation();                                    
  222.                                 }); 
  223.                             })
  224.                             .end(function() { installation(); });
  225.                     } else { 
  226.                         // no `di-config` file given, just the launch example
  227.                         console.log('no di-config.json');
  228.                         run();
  229.                     }
  230.                 });
  231.             });
  232.         });
  234.         function installation() {
  235.             var config  = require(path.resolve('di-config.json')) || {},
  236.                 repos   = (config['app-install'] || {}).repository || [],
  237.                 dirs    = di._.uniq(repos, 'directory'),
  238.                 last    = dirs.length,
  239.                 success = 0;            
  241.             exConfig = {
  242.                 example: example,
  243.                 repos: repos,
  244.                 auth: (config['app-run'] || {}).requireAuthentication || false,
  245.                 tutorial: (config['app-run'] || {}).tutorial || {}
  246.             };
  248.             if (repos.length > 0) {
  249.                 console.log(yellow('\nInstalling example analytics dependencies onto DeployR...\n'));
  250.                 agent();
  252.                 repos.forEach(function(item, index) {
  253.                     console.log((index + 1) + '. ' +
  254.                         ul(item.file.filename) + ' in directory ' +
  255.                         ul(item.file.directory || 'root'));
  256.                 });
  257.                 console.log('');
  259.                 //
  260.                 // create directories for the dependencies, when done start the
  261.                 // upload/install of the analytic dependencies into DeployR
  262.                 //
  263.                 dirs.forEach(function(item) {
  264.                     deployr.io('/r/repository/directory/create')
  265.                         .data({ directory: item.file.directory })
  266.                         .end(function() { success++; })
  267.                         .ensure(function() {
  268.                             if (success === last) { analytics(repos); }
  269.                          });
  270.                 });
  271.             } else { // othwise no dependencies just run the example            
  272.                 candidateToRun();
  273.             }
  274.         }
  276.         function analytics(repos) {
  277.             var last    = repos.length,
  278.                 success = 0,
  279.                 retry   = [];
  281.             repos.forEach(function(item) {
  282.                 var file = item.file,
  283.                     perm = item.permissions;                    
  285.                 deployr.io('/r/repository/file/upload')
  286.                     .data({
  287.                         filename: file.filename,
  288.                         directory: file.directory || 'root',
  289.                         restricted: perm.restricted || null,
  290.                         shared: perm.shared || true,
  291.                         published: perm.published || true,
  292.                         newversion: true,
  293.                         newversionmsg: 'DeployR CLI (examples) upload.'
  294.                     })
  295.                     .attach(path.resolve('analytics', file.filename))
  296.                     .error(function(err) { callback(err); })
  297.                     .end(function(res) {
  298.                         var file = res.get('repository').file;
  300.                         console.log(green.bold('✓ upload complete.\n'));
  301.                         console.log(ul(file.filename) +
  302.                             ' uploaded to directory ' +
  303.                             ul(file.directory) +
  304.                             ' for ' + dim(conf.get('username') + '@' + conf.get('endpoint')) +
  305.                             '\n');
  306.                         success++;
  307.                     })
  308.                     .ensure(function() {
  309.                         if (success === last) {
  310.                             console.log(green.bold('✓ installation complete.\n'));
  311.                             candidateToRun();
  312.                         }
  313.                     });
  314.             }); // foreach
  315.         }
  317.     } // end installExample
  319.     function candidateToRun() {
  320.         di.prompt.inquirer([{
  321.             name: 'run',
  322.             type: 'confirm',
  323.             message: 'Would you like to run the example:'
  324.         }], function(result) {
  325.             if (result.run) {
  326.                 if (exConfig.auth) {
  327.                     console.log('\nThis example requires ' +
  328.                         magenta(conf.get('username')) +
  329.                         '\'s password to run.\n');
  331.                     verifyPassword(targets);
  332.                 } else {
  333.                     targets();
  334.                 }
  335.             }
  336.         });
  337.     }
  339.     function verifyPassword(cb) {
  340.         di.prompt.inquirer([{
  341.             name: 'password',
  342.             type: 'password',
  343.             message: 'Password:',
  344.             validate: function(input) {
  345.                 return input.length > 0 || 'Please enter a valid password.';
  346.             }
  347.         }], function(answer) {
  348.             // confirm password
  349.             di.prompt.inquirer([{
  350.                 name: 'password',
  351.                 type: 'password',
  352.                 message: 'Verify Password:'
  353.             }], function(confirm) {
  354.                 if (answer.password === confirm.password) {
  355.                     cb(confirm.password);
  356.                 } else {
  357.                     console.log(red('>>') + ' Passwords do not match.\n');
  358.                     verifyPassword(cb);
  359.                 }
  360.             });
  361.         });
  362.     }
  364.     function targets(pw) {
  365.         var separator = di.prompt.separator;
  367.         di.clearScreen();
  369.         // tutorial type examples
  370.         if (exConfig.tutorial.topics) {
  371.             var choices = [separator()];
  373.             choices.push({
  374.                 name: 'Example Documentation',
  375.                 value: {
  376.                     help: exConfig.tutorial.help,
  377.                 }
  378.             });
  380.             exConfig.tutorial.topics.forEach(function(obj) {
  381.                 choices.push({
  382.                     name: obj.topic,
  383.                     value: {
  384.                         menu: obj.menu
  385.                     }
  386.                 });
  387.             });
  389.             choices.push(separator());
  391.             choices.push({
  392.                 name: 'Take me back home!',
  393.                 value: 'home'
  394.             });
  396.             di.prompt.inquirer([{
  397.                 name: 'topic',
  398.                 type: 'list',
  399.                 message: 'Examples',
  400.                 choices: choices
  401.             }], function(answer) {
  402.                 if (answer.topic === 'home') {
  403.                     di.home();
  404.                 } else if (answer.topic.help) {
  405.                     opn(answer.topic.help);
  406.                     targets(pw);
  407.                 } else {
  408.                     tutorialChoice(answer.topic.menu, pw);
  409.                 }
  410.             });
  411.         } else { // standalone example apps
  412.             run({
  413.                 pw: pw
  414.             });
  415.         }
  416.     }
  418.     function tutorialChoice(menu, pw) {
  419.         var separator = di.prompt.separator,
  420.             choices   = [separator()].concat(menu.map(function(obj) {
  421.                 return {
  422.                     name: obj.item,
  423.                     value: {
  424.                         test: obj.args
  425.                     }
  426.                 };
  427.             }));
  429.         di.prompt.inquirer([{
  430.             name: 'item',
  431.             type: 'list',
  432.             message: 'Examples to run?',
  433.             choices: choices.concat([
  434.                 separator(), {
  435.                     name: 'Take me back',
  436.                     value: 'back'
  437.                 }
  438.             ])
  439.         }], function(answer) {
  440.             if (answer.item === 'back') {
  441.                 return targets(pw);
  442.             }
  443.             run({
  444.                 pw: pw,
  445.                 tutorial: {
  446.                     menu: menu,
  447.                     example: answer.item.test
  448.                 }
  449.             });
  450.         });
  451.     }
  453.     function run(optArgs) {
  454.         var args    = [],
  455.             options = [],
  456.             sep     = dim(ul('                                                           ')),
  457.             cmd;
  459.         optArgs = optArgs || {};        
  461.         switch (LangType.parse(exConfig.example)) {
  462.             case LangType.JS:
  463.                 cmd = 'npm';
  464.                 args = ['start'];
  466.                 process.env.endpoint = conf.get('endpoint');
  467.                 process.env.username = conf.get('username');
  468.                 process.env.password = optArgs.pw || '';
  469.                 process.env.testmod  = (optArgs.tutorial || {}).example;
  470.                 options = { env: process.env };
  472.                 break;
  474.             case LangType.JAVA:
  475.                 cmd = (process.platform === 'win32' ? 'gradlew.bat' : './gradlew');
  476.                 args = [
  477.                     'run',
  478.                     '-Pendpoint=' + conf.get('endpoint') + '/deployr',
  479.                     '-Pusername=' + conf.get('username'),
  480.                     '-Ppassword=' + optArgs.pw || '',
  481.                     '-DtestClass=' + (optArgs.tutorial || {}).example
  482.                 ];
  484.                 break;
  486.             case LangType.DOTNET:
  487.                 break;
  488.         }
  490.         di.clearScreen();
  491.         
  492.         console.log(sep);
  494.         di.spawnCommand(cmd, args, options)
  495.             .on('error', function(err) {
  496.                 callback(err);
  497.             })
  498.             .on('close', function(err) {
  499.                 console.log(sep + '\n');
  500.                 di.prompt.inquirer([{
  501.                     name: 'post',
  502.                     type: 'list',
  503.                     message: 'What do you want to do?',
  504.                     choices: [{
  505.                         name: 'Take me back',
  506.                         value: 'back'
  507.                     }, {
  508.                         name: 'Run more examples',
  509.                         value: 'more'
  510.                     }]
  511.                 }], function(answer) {
  512.                     di.clearScreen();
  514.                     if (answer.post === 'back') {
  515.                         tutorialChoice(optArgs.tutorial.menu, optArgs.pw);
  516.                     } else {
  517.                         targets(optArgs.pw);
  518.                     }
  519.                 });
  520.             });
  521.     }
  523.     //
  524.     // Start to example installation workflow
  525.     //
  526.     listExamples();
  527. };
  529. /**
  530.  * Output usage information describing commands for installing and deploying 
  531.  * starter examples.
  532.  */
  533. install.example.usage = [
  534.     'The `di install` command installs pre-built DeployR examples locally',
  535.     '',
  536.     'Example usages:',
  537.     'di install example',
  538.     'di install example <example name>'
  539. ];
  541. function agent() {
  542.     deployr.configure({
  543.         host: conf.get('endpoint'),
  544.         cookies: ['JSESSIONID=' + conf.get('cookie')],
  545.         sticky: true
  546.     });
  547. }