Add Serverless Run Plugin

lib/classes/CLI.js

@@ -120,24 +120,54 @@ class CLI {
   }
 
   generateMainHelp() {
+    let platformCommands;
+    let frameworkCommands;
+    if (this.loadedCommands) {
+      const commandKeys = Object.keys(this.loadedCommands);
+      const sortedCommandKeys = _.sortBy(commandKeys);
+      const partitionedCommandKeys = _.partition(sortedCommandKeys,
+        (key) => this.loadedCommands[key].platform);
+      platformCommands = _.fromPairs(
+        _.map(partitionedCommandKeys[0], key => [key, this.loadedCommands[key]])
+      );
+      frameworkCommands = _.fromPairs(
+        _.map(partitionedCommandKeys[1], key => [key, this.loadedCommands[key]])
+      );
+    }
+
     this.consoleLog('');
 
     this.consoleLog(chalk.yellow.underline('Commands'));
-    this.consoleLog(chalk.dim('* Serverless documentation: http://docs.serverless.com'));
     this.consoleLog(chalk.dim('* You can run commands with "serverless" or the shortcut "sls"'));
     this.consoleLog(chalk.dim('* Pass "--verbose" to this command to get in-depth plugin info'));
     this.consoleLog(chalk.dim('* Pass "--help" after any <command> for contextual help'));
 
     this.consoleLog('');
 
-    if (this.loadedCommands) {
-      const commandKeys = Object.keys(this.loadedCommands);
-      const sortedCommandKeys = _.sortBy(commandKeys);
-      const sortedCommands = _.fromPairs(
-        _.map(sortedCommandKeys, key => [key, this.loadedCommands[key]])
-      );
+    this.consoleLog(chalk.yellow.underline('Framework'));
+    this.consoleLog(chalk.dim('* Documentation: https://serverless.com/framework/docs/'));
+
+    this.consoleLog('');
+
+    if (!_.isEmpty(frameworkCommands)) {
+      _.forEach(frameworkCommands, (details, command) => {
+        this.displayCommandUsage(details, command);
+      });
+    } else {
+      this.consoleLog('No commands found');
+    }
+
+    this.consoleLog('');
+
+    this.consoleLog(chalk.yellow.underline('Platform (Beta)'));
+    // eslint-disable-next-line max-len
+    this.consoleLog(chalk.dim('* The Serverless Platform is currently in experimental beta. Follow the docs below to get started.'));
+    this.consoleLog(chalk.dim('* Documentation: https://serverless.com/platform/docs/'));
+
+    this.consoleLog('');
 
-      _.forEach(sortedCommands, (details, command) => {
+    if (!_.isEmpty(platformCommands)) {
+      _.forEach(platformCommands, (details, command) => {
         this.displayCommandUsage(details, command);
       });
     } else {

lib/plugins/Plugins.json

@@ -1,5 +1,6 @@
 {
   "plugins": [
+    "./run/index.js",
     "./config/config.js",
     "./create/create.js",
     "./install/install.js",

lib/plugins/emit/index.js

@@ -1,10 +1,26 @@
 'use strict';
 
+const os = require('os');
 const BbPromise = require('bluebird');
 const fdk = require('@serverless/fdk');
 const path = require('path');
 const stdin = require('get-stdin');
 const userStats = require('../../utils/userStats');
+const chalk = require('chalk');
+
+const spaceSmall = '    ';
+const spaceLarge = '                    ';
+const colorDim = chalk.hex('#777777');
+const colorPrefix = chalk.hex('#bdb018');
+const prefix = colorPrefix(` Serverless   ${spaceSmall}`);
+
+const prettifyValue = value => {
+  const prettified = JSON.stringify(value, null, 2).replace(
+    new RegExp('\\n', 'g'),
+    `\n${spaceLarge}`
+  );
+  return `${spaceLarge}${colorDim(prettified)}`;
+};
 
 class Emit {
   constructor(serverless, options) {
@@ -39,6 +55,7 @@ class Emit {
             shortcut: 't',
           },
         },
+        platform: true,
       },
     };
 
@@ -117,14 +134,14 @@ class Emit {
     return eventGateway
       .emit(emitParams)
       .then(() => {
-        const msg = `Successfully emitted the event ${name} as datatype ${emitParams.dataType ||
-          'application/json'} with:`;
-        this.serverless.cli.consoleLog(`${msg}\n${JSON.stringify(data)}`);
+        const msg = `${prefix}Emitted the event ${name} as datatype ${emitParams.dataType ||
+          'application/json'}:`;
+        this.serverless.cli.consoleLog(`${msg}${os.EOL}${prettifyValue(data)}`);
       })
       .catch(() => {
-        const msg = `Failed to emit the event ${name} as datatype ${emitParams.dataType ||
-          'application/json'} with:`;
-        this.serverless.cli.consoleLog(`${msg}\n${JSON.stringify(data)}`);
+        const msg = `${prefix}Failed to emit the event ${name} as datatype ${emitParams.dataType ||
+          'application/json'}:`;
+        this.serverless.cli.consoleLog(`${msg}${os.EOL}${prettifyValue(data)}`);
         throw new Error(`Failed to emit the event ${name}`);
       });
   }

lib/plugins/emit/index.test.js

@@ -141,11 +141,10 @@ describe('Emit', () => {
             data: emit.data,
           })
         ).to.equal(true);
-        expect(logStub.calledOnce).to.equal(true);
-        const msgPartOne = 'Successfully emitted the event userCreated as datatype';
-        expect(
-          logStub.calledWithExactly(`${msgPartOne} application/json with:\n{"key":"value"}`)
-        ).to.equal(true);
+        expect(logStub.getCall(0).args[0]).to.equal(
+          // eslint-disable-next-line max-len
+          ' Serverless       Emitted the event userCreated as datatype application/json:\n                    {\n                      "key": "value"\n                    }'
+        );
       });
     });
 
@@ -162,11 +161,10 @@ describe('Emit', () => {
             dataType: 'text/plain',
           })
         ).to.equal(true);
-        expect(logStub.calledOnce).to.equal(true);
-        const msgPartOne = 'Successfully emitted the event userCreated as datatype';
-        expect(
-          logStub.calledWithExactly(`${msgPartOne} text/plain with:\n"This is a message"`)
-        ).to.equal(true);
+        expect(logStub.getCall(0).args[0]).to.equal(
+          // eslint-disable-next-line max-len
+          ' Serverless       Emitted the event userCreated as datatype text/plain:\n                    "This is a message"'
+        );
       });
     });
   });

lib/plugins/login/login.js

@@ -36,6 +36,7 @@ class Login {
         lifecycleEvents: [
           'login',
         ],
+        platform: true,
       },
     };
 

lib/plugins/logout/logout.js

@@ -3,7 +3,7 @@
 const userStats = require('../../utils/userStats');
 const configUtils = require('../../utils/config');
 
-class Login {
+class Logout {
   constructor(serverless, options) {
     this.serverless = serverless;
     this.options = options;
@@ -12,6 +12,7 @@ class Login {
       logout: {
         usage: 'Logout from the Serverless Platform',
         lifecycleEvents: ['logout'],
+        platform: true,
       },
     };
 
@@ -50,4 +51,4 @@ class Login {
   }
 }
 
-module.exports = Login;
+module.exports = Logout;

lib/plugins/run/index.js

@@ -0,0 +1,148 @@
+'use strict';
+
+const BbPromise = require('bluebird');
+
+const logServerless = require('./utils/logServerless');
+const getLocalRootUrl = require('./utils/getLocalRootUrl');
+
+const localEmulatorRunning = require('./utils/localEmulatorRunning');
+const eventGatewayRunning = require('./utils/eventGatewayRunning');
+
+const localEmulatorInstalled = require('./utils/localEmulatorInstalled');
+const eventGatewayInstalled = require('./utils/eventGatewayInstalled');
+
+const installLocalEmulator = require('./utils/installLocalEmulator');
+const installEventGateway = require('./utils/installEventGateway');
+
+const deployFunctionsToLocalEmulator = require('./utils/deployFunctionsToLocalEmulator');
+const registerFunctionsToEventGateway = require('./utils/registerFunctionsToEventGateway');
+
+const manageLocalEmulator = require('./utils/manageLocalEmulator');
+const manageEventGateway = require('./utils/manageEventGateway');
+
+class Run {
+  constructor(serverless, options) {
+    this.serverless = serverless;
+    this.options = options;
+    this.commands = {
+      run: {
+        usage: 'Runs the Event Gateway and the Emulator',
+        lifecycleEvents: [
+          'run',
+        ],
+        options: {
+          eport: {
+            usage: 'The Event Gateway API port',
+            shortcut: 'e',
+            default: '4000',
+          },
+          cport: {
+            usage: 'The Event Gateway configuration port',
+            shortcut: 'c',
+            default: '4001',
+          },
+          lport: {
+            usage: 'The Emulator port',
+            shortcut: 'l',
+            default: '4002',
+          },
+          debug: {
+            usage: 'Start the debugger',
+            shortcut: 'd',
+          },
+        },
+        platform: true,
+      },
+    };
+
+    this.hooks = {
+      'run:run': () => BbPromise.bind(this)
+        .then(this.run),
+    };
+  }
+
+  run() {
+    const EVENT_GATEWAY_VERSION = '0.5.14';
+    const LOCAL_EMULATOR_VERSION = '0.1.18';
+
+    let functionsDeployed = false;
+    let functionsRegistered = false;
+    if (!this.serverless.config.servicePath) {
+      throw new this.serverless.classes
+        .Error('This command can only run inside a service');
+    }
+
+    return localEmulatorRunning(getLocalRootUrl(this.options.lport))
+      .then(localEmulatorAlreadyRunning => {
+        if (localEmulatorAlreadyRunning) {
+          // logServerless('Emulator already running');
+          functionsDeployed = true;
+          return deployFunctionsToLocalEmulator(
+            this.serverless.service,
+            this.serverless.config.servicePath,
+            getLocalRootUrl(this.options.lport)
+          ).then(noFunctions => {
+            if (noFunctions) {
+              // eslint-disable-next-line max-len
+              logServerless('Service does not contain any functions to be loaded in your current "serverless run" session.');
+              return BbPromise.resolve();
+            }
+            // eslint-disable-next-line max-len
+            logServerless('Functions loaded successfully in your current "serverless run" session.');
+            return BbPromise.resolve();
+          });
+        }
+        return BbPromise.resolve();
+      })
+      .then(() => eventGatewayRunning(getLocalRootUrl(this.options.cport)))
+      .then(eventGatewayAlreadyRunning => {
+        if (eventGatewayAlreadyRunning) {
+          functionsRegistered = true;
+          // logServerless('Event Gateway already running');
+          return registerFunctionsToEventGateway(
+            this.serverless.service,
+            getLocalRootUrl(this.options.eport),
+            getLocalRootUrl(this.options.cport),
+            getLocalRootUrl(this.options.lport)
+          ).then(() => {
+            // eslint-disable-next-line max-len
+            // logServerless('Functions and subscriptions registered. For details please review the terminal running the Event Gateway.');
+          });
+        }
+        return BbPromise.resolve();
+      })
+      .then(() => {
+        if (!functionsDeployed && !localEmulatorInstalled(LOCAL_EMULATOR_VERSION)) {
+          logServerless('Installing Emulator');
+          installLocalEmulator(LOCAL_EMULATOR_VERSION);
+        }
+        return BbPromise.resolve();
+      })
+      .then(() => {
+        if (!eventGatewayInstalled(EVENT_GATEWAY_VERSION)) {
+          logServerless('Installing Event Gateway');
+          return installEventGateway(EVENT_GATEWAY_VERSION);
+        }
+        return BbPromise.resolve();
+      })
+      .then(() => {
+        if (!functionsDeployed) {
+          return manageLocalEmulator(this.serverless.service,
+            this.serverless.config.servicePath,
+            { port: this.options.lport, debug: this.options.debug });
+        }
+        return BbPromise.resolve();
+      })
+      .then(() => {
+        if (!functionsRegistered) {
+          return manageEventGateway(this.serverless.service,
+            this.options.eport,
+            this.options.cport,
+            this.options.lport);
+        }
+        return BbPromise.resolve();
+      });
+  }
+}
+
+module.exports = Run;

lib/plugins/run/utils/deployFunctionToLocalEmulator.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const fetch = require('node-fetch');
+
+function deployFunctionToLocalEmulator(functionId, functionConfig, emulatorUrl) {
+  const localEmulatorDeployEndpoint = `${emulatorUrl}/v0/emulator/api/functions/deploy`;
+
+  return fetch(localEmulatorDeployEndpoint, {
+    headers: {
+      'content-type': 'application/json',
+    },
+    method: 'POST',
+    timeout: 0, // NOTE using 0 so that deployments of large functions won't timeout
+    body: JSON.stringify({
+      functionId,
+      functionConfig,
+    }),
+  });
+}
+
+module.exports = deployFunctionToLocalEmulator;

lib/plugins/run/utils/deployFunctionsToLocalEmulator.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const _ = require('lodash');
+const BbPromise = require('bluebird');
+const getLocalEmulatorFunctionConfig = require('./getLocalEmulatorFunctionConfig');
+const deployFunctionToLocalEmulator = require('./deployFunctionToLocalEmulator');
+const logLocalEmulator = require('./logLocalEmulator');
+
+function deployFunctionsToLocalEmulator(service, servicePath, localEmulatorRootUrl) {
+  const functionDeploymentPromises = [];
+  let noFunctions = false;
+
+  _.each(service.functions, (functionConfig, functionName) => {
+    const localEmulatorFunctionConfig = getLocalEmulatorFunctionConfig(
+      functionConfig,
+      service.provider,
+      servicePath);
+
+    const deployFunctionToLocalEmulatorPromise = deployFunctionToLocalEmulator(
+      `${service.service}-${functionName}`,
+      localEmulatorFunctionConfig, localEmulatorRootUrl);
+    functionDeploymentPromises.push(deployFunctionToLocalEmulatorPromise);
+  });
+
+  if (functionDeploymentPromises.length === 0) {
+    noFunctions = true;
+    return BbPromise.resolve(noFunctions);
+  }
+
+  // NOTE important for UX since it takes a while to upload large functions
+  logLocalEmulator('Functions loading...');
+
+  return BbPromise.all(functionDeploymentPromises)
+    .then(() => noFunctions);
+}
+
+module.exports = deployFunctionsToLocalEmulator;