Support serverless invoke (#86)

* Add serverless invoke command

* Updating naming

Author: Shillaker

docs/tests.md

@@ -34,11 +34,15 @@ export SCW_URL=<url-to-functions-api>
 
 ### Run Tests
 
-We provided multiple test suites, as described above, with the following npm scripts:
+We provided multiple test suites, as described above, with the following `npm` scripts:
+
 - `npm run test`: Run all test suites
 - `npm run test:functions`: Run functions's test suite
 - `npm run test:containers`: Run containers's test suite
 - `npm run test:runtimes`: Run runtimes's test suite
+- `npm run test -- -t "Some test regex*"`: Runs all tests matching the regex
+
+These tests use [Jest](https://jestjs.io/docs/) under the hood.
 
 **Also, make sure that you did not install this repository inside a `node_modules` folder, otherwhise your npm commands won't work (`no tests found`)**.
 

index.js

@@ -3,6 +3,7 @@
 const ScalewayProvider = require('./provider/scalewayProvider');
 const ScalewayDeploy = require('./deploy/scalewayDeploy');
 const ScalewayRemove = require('./remove/scalewayRemove');
+const ScalewayInvoke = require('./invoke/scalewayInvoke');
 const ScalewayJwt = require('./jwt/scalewayJwt');
 const ScalewayLogs = require('./logs/scalewayLogs');
 const ScalewayInfo = require('./info/scalewayInfo');
@@ -15,6 +16,7 @@ class ScalewayIndex {
     this.serverless.pluginManager.addPlugin(ScalewayProvider);
     this.serverless.pluginManager.addPlugin(ScalewayDeploy);
     this.serverless.pluginManager.addPlugin(ScalewayRemove);
+    this.serverless.pluginManager.addPlugin(ScalewayInvoke);
     this.serverless.pluginManager.addPlugin(ScalewayJwt);
     this.serverless.pluginManager.addPlugin(ScalewayLogs);
     this.serverless.pluginManager.addPlugin(ScalewayInfo);

invoke/scalewayInvoke.js

@@ -0,0 +1,84 @@
+const BbPromise = require('bluebird');
+const axios = require('axios');
+const util = require('util');
+
+const scalewayApi = require('../shared/api/endpoint');
+const setUpDeployment = require('../shared/setUpDeployment');
+const validate = require('../shared/validate');
+
+class ScalewayInvoke {
+  constructor(serverless, options) {
+    this.serverless = serverless;
+    this.options = options || {};
+    this.provider = this.serverless.getProvider('scaleway');
+    this.provider.initialize(this.serverless, this.options);
+
+    const api = scalewayApi.getApi(this);
+
+    Object.assign(
+      this,
+      validate,
+      setUpDeployment,
+      api,
+    );
+
+    this.isContainer = false;
+    this.isFunction = false;
+
+    function validateFunctionOrContainer() {
+      // Check the user has specified a name, and that it's defined as either a function or container
+      if(!this.options.function) {
+        const msg = 'Function or container not specified';
+        this.serverless.cli.log(msg);
+        throw new Error(msg);
+      }
+
+      this.isContainer = this.isDefinedContainer(this.options.function);
+      this.isFunction = this.isDefinedFunction(this.options.function);
+
+      if(!this.isContainer && !this.isFunction) {
+        const msg = `Function or container ${this.options.function} not defined in servleress.yml`;
+        this.serverless.cli.log(msg);
+        throw new Error(msg);
+      }
+    }
+
+    function lookUpFunctionOrContainer(ns) {
+      // List containers/functions in the namespace
+      let found = null;
+      if(this.isContainer) {
+         return this.listContainers(ns.id);
+      } else {
+         return this.listFunctions(ns.id);
+      }
+    }
+
+    function doInvoke(found) {
+      // Filter on name
+      let func = found.find((f) => f.name === this.options.function);
+      const url = 'https://' + func.domain_name;
+
+      // Invoke
+      axios.get(url).then(res => {
+        // Make sure we write to stdout here to ensure we can capture output
+        process.stdout.write(JSON.stringify(res.data));
+      }).
+      catch(error => {
+        process.stderr.write(error);
+      });
+    }
+
+    this.hooks = {
+      'before:invoke:invoke': () => BbPromise.bind(this)
+        .then(this.setUpDeployment)
+        .then(this.validate),
+      'invoke:invoke': () => BbPromise.bind(this)
+        .then(validateFunctionOrContainer)
+        .then(() => this.getNamespaceFromList(this.namespaceName))
+        .then(lookUpFunctionOrContainer)
+        .then(doInvoke)
+    };
+  }
+}
+
+module.exports = ScalewayInvoke;

shared/child-process.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const child_process = require('child_process');
+
+function execSync(command, options = null) {
+  // Same as native but outputs std in case of error
+  try {
+    return child_process.execSync(command, options);
+  } catch (error) {
+    if (error.stdout) process.stdout.write(error.stdout);
+    if (error.stderr) process.stderr.write(error.stderr);
+    throw error;
+  }
+}
+
+function execCaptureOutput(command, args) {
+  let child = child_process.spawnSync(command, args, { encoding : 'utf8' });
+
+  if(child.error) {
+    if(child.stdout) process.stdout.write(child.stdout);
+    if(child.stderr) process.stderr.write(child.stderr);
+    throw child.error;
+  }
+
+  return child.stdout;
+}
+
+module.exports = { execSync, execCaptureOutput };

shared/validate.js

@@ -262,4 +262,36 @@ module.exports = {
 
     return errors;
   },
+
+  isDefinedContainer(containerName) {
+    // Check if given name is listed as a container
+    let res = false;
+    if(this.provider.serverless.service.custom
+      && this.provider.serverless.service.custom.containers) {
+
+      let foundKey = Object.keys(this.provider.serverless.service.custom.containers)
+        .find((k) => k == containerName);
+
+      if(foundKey) {
+        res = true;
+      }
+    }
+
+    return res;
+  },
+
+  isDefinedFunction(functionName) {
+    // Check if given name is listed as a function
+    let res = false;
+    if(this.provider.serverless.service.functions) {
+      let foundKey = Object.keys(this.provider.serverless.service.functions)
+        .find((k) => k == functionName);
+
+      if(foundKey) {
+        res = true;
+      }
+    }
+
+    return res;
+  },
 };

tests/containers/containers.test.js

@@ -4,11 +4,12 @@ const path = require('path');
 const fs = require('fs');
 const axios = require('axios');
 const { expect } = require('chai');
-const { execSync } = require('../utils/child-process');
+
 const { getTmpDirPath, replaceTextInFile } = require('../utils/fs');
 const { getServiceName, sleep } = require('../utils/misc');
 const { ContainerApi, RegistryApi } = require('../../shared/api');
 const { CONTAINERS_API_URL, REGISTRY_API_URL } = require('../../shared/constants');
+const { execSync, execCaptureOutput } = require('../../shared/child-process');
 
 const serverlessExec = path.join('serverless');
 
@@ -25,6 +26,7 @@ describe('Service Lifecyle Integration Test', () => {
   let api;
   let registryApi;
   let namespace;
+  let containerName;
 
   beforeAll(() => {
     oldCwd = process.cwd();
@@ -53,13 +55,15 @@ describe('Service Lifecyle Integration Test', () => {
     execSync(`${serverlessExec} deploy`);
     namespace = await api.getNamespaceFromList(serviceName);
     namespace.containers = await api.listContainers(namespace.id);
+    containerName = namespace.containers[0].name;
   });
 
   it('should invoke container from scaleway', async () => {
+    // TODO query function status instead of having an arbitrary sleep
     await sleep(30000);
-    const deployedContainer = namespace.containers[0];
-    const response = await axios.get(`https://${deployedContainer.domain_name}`);
-    expect(response.data.message).to.be.equal('Hello, World from Scaleway Container !');
+
+    let output = execCaptureOutput(serverlessExec, ['invoke', '--function', containerName]);
+    expect(output).to.be.equal('{"message":"Hello, World from Scaleway Container !"}');
   });
 
   it('should deploy updated service/container to scaleway', () => {
@@ -69,9 +73,9 @@ describe('Service Lifecyle Integration Test', () => {
 
   it('should invoke updated container from scaleway', async () => {
     await sleep(30000);
-    const deployedContainer = namespace.containers[0];
-    const response = await axios.get(`https://${deployedContainer.domain_name}`);
-    expect(response.data.message).to.be.equal('Container successfully updated');
+
+    let output = execCaptureOutput(serverlessExec, ['invoke', '--function', containerName]);
+    expect(output).to.be.equal('{"message":"Container successfully updated"}');
   });
 
   it('should remove service from scaleway', async () => {

tests/functions/functions.test.js

@@ -5,11 +5,12 @@ const fs = require('fs');
 const axios = require('axios');
 const { expect } = require('chai');
 const { expect: jestExpect } = require('@jest/globals');
-const { execSync } = require('../utils/child-process');
+
 const { getTmpDirPath, replaceTextInFile } = require('../utils/fs');
 const { getServiceName, sleep } = require('../utils/misc');
 const { FunctionApi, RegistryApi } = require('../../shared/api');
 const { FUNCTIONS_API_URL, REGISTRY_API_URL } = require('../../shared/constants');
+const { execSync, execCaptureOutput } = require('../../shared/child-process');
 const { validateRuntime } = require('../../deploy/lib/createFunctions');
 
 const serverlessExec = path.join('serverless');
@@ -27,6 +28,7 @@ describe('Service Lifecyle Integration Test', () => {
   let api;
   let registryApi;
   let namespace;
+  let functionName;
 
   beforeAll(() => {
     oldCwd = process.cwd();
@@ -55,35 +57,37 @@ describe('Service Lifecyle Integration Test', () => {
     execSync(`${serverlessExec} deploy`);
     namespace = await api.getNamespaceFromList(serviceName);
     namespace.functions = await api.listFunctions(namespace.id);
+    functionName = namespace.functions[0].name;
   });
 
   it('should invoke function from scaleway', async () => {
+    // TODO query function status instead of having an arbitrary sleep
     await sleep(30000);
-    const deployedFunction = namespace.functions[0];
-    const response = await axios.get(`https://${deployedFunction.domain_name}`);
-    expect(response.data.message).to.be.equal('Hello from Serverless Framework and Scaleway Functions :D');
+
+    let output = execCaptureOutput(serverlessExec, ['invoke', '--function', functionName]);
+    expect(output).to.be.equal('{"message":"Hello from Serverless Framework and Scaleway Functions :D"}');
   });
 
   it('should deploy updated service to scaleway', () => {
-    const newHandler = `
-        'use strict';
+    const newJsHandler = `
+'use strict';
 
-        module.exports.handle = (event, context, cb) => {
-          return {
-            body: { message: 'Serverless Update Succeeded' }
-          };
-        }
-      `;
+module.exports.handle = (event, context, cb) => {
+  return {
+    message: 'Serverless Update Succeeded',
+  };
+};
+`;
 
-    fs.writeFileSync(path.join(tmpDir, 'handler.js'), newHandler);
+    fs.writeFileSync(path.join(tmpDir, 'handler.js'), newJsHandler);
     execSync(`${serverlessExec} deploy`);
   });
 
   it('should invoke updated function from scaleway', async () => {
     await sleep(30000);
-    const deployedFunction = namespace.functions[0];
-    const response = await axios.get(`https://${deployedFunction.domain_name}`);
-    expect(response.data.body.message).to.be.equal('Serverless Update Succeeded');
+
+    let output = execCaptureOutput(serverlessExec, ['invoke', '--function', functionName]);
+    expect(output).to.be.equal('{"message":"Serverless Update Succeeded"}');
   });
 
   it('should deploy function with another available runtime', async () => {
@@ -100,16 +104,16 @@ def handle(event, context):
   return {
       "message": "Hello From Python310 runtime on Serverless Framework and Scaleway Functions"
   }
-    `;
+`;
     fs.writeFileSync(path.join(tmpDir, 'handler.py'), pythonHandler);
     execSync(`${serverlessExec} deploy`);
   });
 
   it('should invoke function with runtime updated from scaleway', async () => {
     await sleep(30000);
-    const deployedFunction = namespace.functions[0];
-    const response = await axios.get(`https://${deployedFunction.domain_name}`);
-    expect(response.data.message).to.be.equal('Hello From Python310 runtime on Serverless Framework and Scaleway Functions');
+
+    let output = execCaptureOutput(serverlessExec, ['invoke', '--function', functionName]);
+    expect(output).to.be.equal('{"message":"Hello From Python310 runtime on Serverless Framework and Scaleway Functions"}');
   });
 
   it('should remove service from scaleway', async () => {

tests/multi-region/multi_region.test.js

@@ -4,7 +4,7 @@ const path = require('path');
 const fs = require('fs');
 const axios = require('axios');
 const { expect } = require('chai');
-const { execSync } = require('../utils/child-process');
+const { execSync } = require('../../shared/child-process');
 const { getTmpDirPath, replaceTextInFile } = require('../utils/fs');
 const { getServiceName, sleep } = require('../utils/misc');
 const { FunctionApi, RegistryApi } = require('../../shared/api');

tests/runtimes/runtimes.test.js

@@ -4,7 +4,7 @@ const path = require('path');
 const fs = require('fs');
 const axios = require('axios');
 const { expect } = require('chai');
-const { execSync } = require('../utils/child-process');
+const { execSync } = require('../../shared/child-process');
 const { getTmpDirPath } = require('../utils/fs');
 const { getServiceName, createTestService, sleep } = require('../utils/misc');
 const { FunctionApi, RegistryApi, ContainerApi } = require('../../shared/api');

tests/shared/child-process.tests.js

@@ -0,0 +1,23 @@
+const { expect } = require('chai');
+const { expect: jestExpect } = require('@jest/globals');
+
+const { execSync, execCaptureOutput } = require('../../shared/child-process');
+
+describe('Synchronous command execution test', () => {
+  it('should execute a command synchronously', () => {
+    execSync('ls');
+  });
+
+  it('should throw an error for an invalid command', () => {
+    expect(() => {
+      execSync('blah');
+    }).to.throw();
+  });
+});
+
+describe('Synchronous output capture of command test', () => {
+  it('should capture the output of a command', () => {
+    let output = execCaptureOutput('echo', ['foo bar']);
+    expect(output).to.equal('foo bar\n');
+  });
+});