Merge pull request #14 from softprops/exp-provided-runtime

move to provided runtime

Author: softprops

CHANGELOG.md

@@ -1,3 +1,12 @@
+# ⚡ 0.2.0
+
+* Switch from supporting the Lambda `python3.6` runtime to a new ✨ `rust` runtime ✨ ( which runs on the `provided` runtime under the covers )
+* you can now deploy independent functions with `npx serverless deploy function -f func-name`
+* you no longer have to be explicit about function binary to include, this plugin generates and configures the artifact (zip) file for you
+* you no longer have to set default exclusion rules
+* you can deploy a `rust` runtime function side by side with other serverless runtime functions
+within the same service, to facilitate experimentation and learning.
+
 # ⚡ 0.1.7
 
 * bump [lambda-rust](https://hub.docker.com/r/softprops/lambda-rust/) docker version to 0.1.0-rust-1.30.1, to make the new default Rust 1.30.1 (the latest release of Rust at this time)

README.md

@@ -7,40 +7,32 @@
 
 Install the plugin with npm
 
-```bash
-$ npm install serverless-rust@0.1.7
+```sh
+$ npm install serverless-rust
 ```
 
-💡 This serverless plugin assumes you are building Rustlang lambdas using the [lando](https://github.com/softprops/lando) or [crowbar](https://github.com/ilianaw/rust-crowbar) rustlang crates.
+💡 This serverless plugin assumes you are building Rustlang lambdas targetting the AWS Lambda "provided" runtime. The [AWS Lambda Rust Runtime](https://github.com/awslabs/aws-lambda-rust-runtime) makes this easy.
 
 Add the following to your serverless project's `serverless.yml` file
 
 ```yaml
 service: demo
 provider:
   name: aws
-  # crowbar and lando integrate with aws lambda's python3.6 runtime
-  runtime: python3.6
+  runtime: rust
 plugins:
   # this adds informs servleress to use
   # the serverless-rust plugin
   - serverless-rust
-# the follow is recommended for small deployment sizes
-# (faster uploads)
+# creates one artifact for each function
 package:
   individually: true
-  exclude:
-    - ./**
 functions:
   test:
-    # liblambda.handler is the default function name when
-    # you follow lando/crowbar conventions
-    handler: liblambda.handler
-    # the following limits the function packaging
-    # to just the resulting binary
-    package:
-      include:
-        - liblambda.so
+    # handler value syntax is `{cargo-package}.{bin-name}`
+    # or `{bin-name}` for short when you are building a
+    # default bin for a given package.
+    handler: your-crate-name
     events:
       - http:
           path: /test
@@ -53,14 +45,13 @@ functions:
 You can optionally adjust the default settings of the dockerized build env using
 a custom section of your serverless.yaml configuration
 
-
 ```yaml
 custom:
-  # this section customizes the default
+  # this section allows for customization of the default
   # serverless-rust plugin settings
   rust:
     # flags passed to cargo
-    cargoFlags: '--features lando/python3-sys'
+    cargoFlags: '--features enable-awesome'
     # custom docker tag
     dockerTag: 'some-custom-tag'
 ```
@@ -77,15 +68,11 @@ functions:
   test:
     rust:
       # function specific flags passed to cargo
-      cargoFlags: '--features ...'
-    # liblambda.handler is the default function name when
-    # you follow lando/crowbar conventions
-    handler: liblambda.handler
-    # the following limits the function packaging
-    # to just the resulting binary
-    package:
-      include:
-        - liblambda.so
+      cargoFlags: '--features enable-awesome'
+    # handler value syntax is `{cargo-package}.{bin-name}`
+    # or `{bin-name}` for short when you are building a
+    # default bin for a given package.
+    handler: your-crate-name
     events:
       - http:
           path: /test
@@ -95,6 +82,16 @@ functions:
 
 ## 🏗️ serverless templates
 
+### 0.2.*
+
+* a minimal echo application - https://github.com/softprops/serverless-aws-rust
+
+### 0.1.*
+
+Older versions targeted the python 3.6 AWS Lambda runtime and [rust crowbar](https://github.com/ilianaw/rust-crowbar) and [lando](https://github.com/softprops/lando) applications
+
 * lando api gateway application - https://github.com/softprops/serverless-lando
 * multi function lando api gateway application - https://github.com/softprops/serverless-multi-lando
 * crowbar cloudwatch scheduled lambda application - https://github.com/softprops/serverless-crowbar
+
+Doug Tangren (softprops) 2018

index.js

@@ -2,28 +2,31 @@
 
 // https://serverless.com/blog/writing-serverless-plugins/
 // https://serverless.com/framework/docs/providers/aws/guide/plugins/
+// https://github.com/softprops/lambda-rust/
 
 const { spawnSync } = require('child_process');
-const { removeSync } = require('fs-extra');
-const copyFileSync = require('fs-copy-file-sync')
 const path = require('path');
 
+const DEFAULT_DOCKER_TAG = '0.2.0-rust-1.31.0';
+const RUST_RUNTIME = 'rust';
+const BASE_RUNTIME = 'provided';
 const NO_OUTPUT_CAPTURE = { stdio: ['ignore', process.stdout, process.stderr] };
 
 /** assumes docker is on the host's execution path */
-class ServerlessPlugin {
+class RustPlugin {
   constructor(serverless, options) {
+
     this.serverless = serverless;
     this.options = options;
     this.servicePath = this.serverless.config.servicePath || '';
     this.hooks = {
       'before:package:createDeploymentArtifacts': this.build.bind(this),
-      'after:package:createDeploymentArtifacts': this.clean.bind(this),
+      'before:deploy:function:packageFunction': this.build.bind(this),
     };
     this.custom = Object.assign(
       {
         cargoFlags: "",
-        dockerTag: "0.1.0-rust-1.30.1"
+        dockerTag: DEFAULT_DOCKER_TAG
       },
       this.serverless.service.custom && this.serverless.service.custom.rust || {}
     );
@@ -34,12 +37,9 @@ class ServerlessPlugin {
     // and this plugin being installed, it will be excluded anyway.
     // Therefore, the filtering can be disabled to speed up (~3.2s) the process.
     this.serverless.service.package.excludeDevDependencies = false;
-
-    // represented as an object for unique keys
-    this.artifacts = {};
   }
 
-  runDocker(funcArgs, captureOutput) {
+  runDocker(funcArgs, cargoPackage) {
     const defaultArgs = [
       'run',
       '--rm',
@@ -49,9 +49,16 @@ class ServerlessPlugin {
       `-v`, `${process.env['HOME']}/.cargo/git:/root/.cargo/git`,
     ];
     const customArgs = [];
-    const cargoFlags = (funcArgs || {}).cargoFlags || this.custom.cargoFlags;
+    let cargoFlags = (funcArgs || {}).cargoFlags || this.custom.cargoFlags;
+    if (cargoPackage != undefined) {
+      if (cargoFlags) {
+        cargoFlags = `${cargoFlags} -p ${cargoPackage}`
+      } else {
+        cargoFlags = ` -p ${cargoPackage}`;
+      }
+    }
     if (cargoFlags) {
-      // --features python3-sys, ect
+      // --features awesome-feature, ect
       customArgs.push('-e', `CARGO_FLAGS=${cargoFlags}`);
     };
     const dockerTag = (funcArgs || {}).dockerTag || this.custom.dockerTag;
@@ -62,32 +69,71 @@ class ServerlessPlugin {
         ...customArgs,
         `softprops/lambda-rust:${dockerTag}`
       ],
-      captureOutput ? {} : NO_OUTPUT_CAPTURE
+      NO_OUTPUT_CAPTURE
     );
   }
 
+  functions() {
+    if (this.options.function) {
+        return [this.options.function];
+    } else {
+        return this.serverless.service.getAllFunctions();
+    }
+  }
+
   build() {
     const service = this.serverless.service;
-    service.getAllFunctions().forEach(funcName => {
+    if (service.provider.name != 'aws') {
+      return;
+    }
+    let rustFunctionsFound = false
+    this.functions().forEach(funcName => {
       const func = service.getFunction(funcName);
-      const [crate, fn] = func.handler.split('.');
+      const runtime = func.runtime || service.provider.runtime;
+      if (runtime != RUST_RUNTIME) {
+        // skip functions which don't apply
+        return;
+      }
+      rustFunctionsFound = true;
+      let [cargoPackage, binary] = func.handler.split('.');
+      if (binary == undefined) {
+        binary = cargoPackage;
+      }
       this.serverless.cli.log(`Building native Rust ${func.handler} func...`);
-      const res = this.runDocker(func.rust);
+      const res = this.runDocker(func.rust, cargoPackage);
       if (res.error || res.status > 0) {
-        this.serverless.cli.log(`Dockerized Rust build encountered an error.`);
+        this.serverless.cli.log(`Dockerized Rust build encountered an error: ${res.error} ${res.status}.`);
         throw new Error(res.error);
       }
-      const executablePath = path.resolve('target/lambda/release', crate + '.so');
-      const targetPath = path.resolve(this.servicePath, crate + '.so');
-      copyFileSync(executablePath, targetPath);
-      // only the keys matters
-      this.artifacts[targetPath] = null;
-    })
-  }
+      // If all went well, we should now have find a packaged compiled binary under `target/lambda/release`.
+      //
+      // The AWS "provided" lambda runtime requires executables to be named
+      // "bootstrap" -- https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html
+      //
+      // To avoid artifact nameing conflicts when we potentially have more than one function
+      // we leverage the ability to declare a package artifact directly
+      // see https://serverless.com/framework/docs/providers/aws/guide/packaging/
+      // for more information
+      const artifactPath =  path.join('target/lambda/release', binary + ".zip")
+      func.package = func.package || {};
+      func.package.artifact = artifactPath;
 
-  clean() {
-    Object.keys(this.artifacts).forEach(removeSync);
+      // Ensure the runtime is set to a sane value for other plugins
+      if (func.runtime == RUST_RUNTIME) {
+        func.runtime = BASE_RUNTIME
+      }
+    })
+    if (service.provider.runtime === RUST_RUNTIME) {
+      service.provider.runtime = BASE_RUNTIME;
+    }
+    if (!rustFunctionsFound) {
+      throw new Error(
+        `Error: no Rust functions found. ` +
+        `Use 'runtime: ${RUST_RUNTIME}' in global or ` +
+        `function configuration to use this plugin.`
+      );
+    }
   }
 }
 
-module.exports = ServerlessPlugin;
+module.exports = RustPlugin;