Use Cargo Lambda (#8)

* Use Cargo Lambda

Remove directory structure generation, since that tools gives you
that for free.

Signed-off-by: David Calavera <david.calavera@gmail.com>

* Update name references

Signed-off-by: David Calavera <david.calavera@gmail.com>

Author: calavera

README.md

@@ -21,10 +21,10 @@
 
 This library provides a construct for a Rust Lambda function.
 
-It uses [`cargo-zigbuild`] under the hood, and follows best practices as outlined
+It uses [`cargo-lambda`] under the hood, and follows best practices as outlined
 in the [official AWS documentation].
 
-[`cargo-zigbuild`]: https://github.com/messense/cargo-zigbuild
+[`cargo-lambda`]: https://crates.io/crates/cargo-lambda
 [official aws documentation]: https://github.com/awslabs/aws-lambda-rust-runtime#building-and-deploying-your-lambda-functions
 
 ## Rust Function
@@ -33,10 +33,10 @@ The `RustFunction` construct creates a Lambda function with automatic bundling a
 
 ## Getting Started
 
-1. Install the [npm] package:
+1. Install this [npm] package, and [zig]:
 
     ```shell
-    $ npm i rust.aws-cdk-lambda
+    $ npm i rust.aws-cdk-lambda --save-optional
     ```
 
 2. Install the **aarch64-unknown-linux-gnu** toolchain with Rustup by running:
@@ -45,31 +45,16 @@ The `RustFunction` construct creates a Lambda function with automatic bundling a
     $ rustup target add aarch64-unknown-linux-gnu
     ```
 
-3)  Install [Zig], using the instructions in their [installation guide] or via one of the options below.
-
-    1. Using [pip] (Python 3 required):
-
-        ```shell
-        $ pip install ziglang
-        ```
-
-    2. Using [npm]:
-
-        ```shell
-        $ npm install -g @ziglang/cli
-        ```
-
-4)  Use [`cargo`] to install _messense/cargo-zigbuild_:
+4)  Use [`cargo`] to install _cargo-lambda_:
 
     ```shell
-    $ cargo install cargo-zigbuild
+    $ cargo install cargo-lambda
     ```
 
 [npm]: https://nodejs.org/
 [pip]: https://pip.pypa.io/en/stable/
 [`cargo`]: https://www.rust-lang.org/
 [zig]: https://ziglang.org/
-[installation guide]: https://ziglang.org/learn/getting-started/#installing-zig
 
 ## Examples
 
@@ -120,9 +105,7 @@ All other properties of `lambda.Function` are supported, see also the [AWS Lambd
 
 When bundling the code, the `RustFunction` runs the following steps in order:
 
--   First it runs `cargo zigbuild`, and passes in the `--release` and `--target` flags, so it compiles for a Lambda environment - which defaults to the **aarch64-unknown-linux-gnu** target, as mentioned above. Note that _zigbuild_ does initially confirm that the Rust code can compile.
-
--   Next, it copies the release app binary from the `target/` folder to a file named `bootstrap`, which the Lambda custom runtime environment looks for. It adds this new file under the _build directory_, which defaults to a `.build/` folder under the directory where `cdk` was invoked.
+-   First it runs `cargo lambda`, and passes in the `--release` and `--target` flags, so it compiles for a Lambda environment - which defaults to the **aarch64-unknown-linux-gnu** target, as mentioned above. Note that _cargo lambda_ does initially confirm that the Rust code can compile.
 
 -   The directory path to the executable is then passed in to `lambda.Code.fromAsset`, which creates a _zip file_ from the release binary asset.
 
@@ -132,7 +115,7 @@ If you instead prefer to use [Docker] and [`cross`] for deployment, as outlined
 in the [official AWS docs], you can install and use the [latest `v0.x`] release instead:
 
 ```shell
-$ npm i rust.aws-cdk-lambda@0.4.0
+$ npm i rust.aws-cdk-lambda@0.4.0 --save-optional
 ```
 
 [docker]: https://www.docker.com/get-started
@@ -294,8 +277,8 @@ Below lists some commonly used properties you can pass in to the `RustFunction`
 | `setupLogging`     | Determines whether we want to set up [library logging](https://rust-lang-nursery.github.io/rust-cookbook/development_tools/debugging/config_log.html) - i.e. set the `RUST_LOG` environment variable - for the lambda function.<br><br>The format defaults to `warn,module_name=debug`, which means that the default log level is `warn`, and the executable or library's log level is `debug`. |
 |                    |
 | `features`         | A list of features to activate when compiling Rust code. These must also be added to the `Cargo.toml` file.                                                                                                                                                                                                                                                                                     |
-| `buildEnvironment` | Key-value pairs that are passed in at compile time, i.e. to `cargo build` or `cargo zigbuild`. This differs from `environment`, which determines the environment variables which are set on the AWS Lambda function itself.                                                                                                                                                                     |
-| `extraBuildArgs`   | Additional arguments that are passed in at build time to `cargo zigbuild`. For example, [`--all-features`].                                                                                                                                                                                                                                                                                     |
+| `buildEnvironment` | Key-value pairs that are passed in at compile time, i.e. to `cargo build` or `cargo lambda`. This differs from `environment`, which determines the environment variables which are set on the AWS Lambda function itself.                                                                                                                                                                     |
+| `extraBuildArgs`   | Additional arguments that are passed in at build time to `cargo lambda`. For example, [`--all-features`].                                                                                                                                                                                                                                                                                     |
 
 ## Settings
 
@@ -314,5 +297,5 @@ Below are some useful _global_ defaults which can be set for all Rust Lambda Fun
 | `MODULE_LOG_LEVEL`   | Log Level for a module (i.e. the executable). Note that this value is only used when `RustFunctionProps.setupLogging` is enabled. Defaults to `debug`.                                                                                      |
 | `WORKSPACE_DIR`      | Sets the root workspace directory. By default, the workspace directory is assumed to be the directory where `cdk` was invoked.<br><br>This directory should contain at the minimum a `Cargo.toml` file which defines the workspace members. |
 | `FEATURES`           | A list of features to activate when compiling Rust code. These must also be added to the `Cargo.toml` file.                                                                                                                                 |
-| `BUILD_ENVIRONMENT`  | Key-value pairs that are passed in at compile time, i.e. to `cargo build` or `cargo zigbuild`. This differs from `environment`, which determines the environment variables which are set on the AWS Lambda function itself.                 |
-| `EXTRA_BUILD_ARGS`   | Additional arguments that are passed in at build time to both `cargo zigbuild`. For example, [`--all-features`].                                                                                                                            |
+| `BUILD_ENVIRONMENT`  | Key-value pairs that are passed in at compile time, i.e. to `cargo build` or `cargo lambda`. This differs from `environment`, which determines the environment variables which are set on the AWS Lambda function itself.                 |
+| `EXTRA_BUILD_ARGS`   | Additional arguments that are passed in at build time to both `cargo lambda`. For example, [`--all-features`].                                                                                                                            |

cdk-examples/README.md

@@ -17,12 +17,12 @@ cd my-app
 npm i
 ```
 
-Next, ensure that you have [`cargo-zigbuild`](https://github.com/messense/cargo-zigbuild) installed. You will need this to cross-compile Rust code for deployment via `cdk`.
-If you don't have `cargo-zigbuild` installed, refer to the [Getting Started](https://github.com/rnag/rust.aws-cdk-lambda#getting-started) section in docs for more info on getting set up.
+Next, ensure that you have [`cargo-lambda`](https://crates.io/crates/cargo-lambda) installed. You will need this to cross-compile Rust code for deployment via `cdk`.
+If you don't have `cargo-lambda` installed, refer to the [Getting Started](https://github.com/rnag/rust.aws-cdk-lambda#getting-started) section in docs for more info on getting set up.
 
 Now you can deploy the app with `cdk`:
 
-> Note: on an initial run, it may take a _really_ long time on the compilation step with `cargo-zigbuild`. In my case, it sometimes took up to _12 minutes_! But don't worry, any subsequent deployments should be overall faster.
+> Note: on an initial run, it may take a _really_ long time on the compilation step with `cargo-lambda`. In my case, it sometimes took up to _12 minutes_! But don't worry, any subsequent deployments should be overall faster.
 
 ```shell
 npx cdk deploy

lib/build.ts

@@ -1,6 +1,5 @@
 import { spawnSync } from 'child_process';
 import * as fs from 'fs';
-import * as path from 'path';
 import { Settings } from '.';
 
 let _builtWorkspaces = false,
@@ -18,7 +17,7 @@ export interface BaseBuildProps {
     readonly package?: string;
 
     /**
-     * The target to use `cargo-zigbuild` to compile to.
+     * The target to use `cargo lambda` to compile to.
      *
      * Normally you'll need to first add the target to your toolchain:
      *    $ rustup target add <target>
@@ -45,7 +44,7 @@ export interface BaseBuildProps {
     readonly buildEnvironment?: NodeJS.ProcessEnv;
 
     /**
-     * Additional arguments that are passed in at build time to `cargo-zigbuild`.
+     * Additional arguments that are passed in at build time to `cargo lambda`.
      *
      * ## Examples
      *
@@ -74,21 +73,14 @@ export interface BuildOptions extends BaseBuildProps {
 }
 
 /**
- * Build with `cargo-zigbuild zigbuild`
+ * Build with `cargo lambda`
  */
 export function build(options: BuildOptions): void {
     try {
         let outputName: string;
         let shouldCompile: boolean;
         let extra_args: string[] | undefined;
 
-        let targetReleaseDir = path.join(
-            options.entry,
-            'target',
-            options.target,
-            'release'
-        );
-
         // Build binary
         if (options.bin) {
             outputName = options.bin!;
@@ -123,9 +115,9 @@ export function build(options: BuildOptions): void {
 
         if (shouldCompile) {
             // Check if directory `./target/{{target}}/release` exists
-            const releaseDirExists = fs.existsSync(targetReleaseDir);
+            const releaseDirExists = fs.existsSync(options.outDir);
 
-            // Base arguments for `cargo-zigbuild`
+            // Base arguments for `cargo lambda`
 
             const buildArgs = ['--quiet', '--color', 'always'];
 
@@ -155,45 +147,43 @@ export function build(options: BuildOptions): void {
                 console.log(`🍺  Building Rust code...`);
             } else {
                 // The `release` directory doesn't exist for the specified
-                // target. This is most likely an initial run, so `cargo-zigbuild`
+                // target. This is most likely an initial run, so `cargo lambda`
                 // will take much longer than usual to cross-compile the code.
                 //
                 // Print out an informative message that the `build` step is
                 // expected to take longer than usual.
                 console.log(
-                    `🍺  Building Rust code with \`cargo-zigbuild\`. This may take a few minutes...`
+                    `🍺  Building Rust code with \`cargo lambda\`. This may take a few minutes...`
                 );
             }
 
             const args: string[] = [
-                'zigbuild',
+                'lambda',
+                'build',
+                '--lambda-dir',
+                options.outDir,
                 '--release',
                 '--target',
                 options.target,
                 ...buildArgs,
                 ...extra_args!,
             ];
 
-            const zigBuild = spawnSync('cargo-zigbuild', args, {
+            const cargo = spawnSync('cargo', args, {
                 cwd: options.entry,
                 env: buildEnv,
             });
 
-            if (zigBuild.status !== 0) {
-                console.error(zigBuild.stderr.toString().trim());
-                console.error(`💥  Run \`cargo zigbuild\` errored.`);
+            if (cargo.status !== 0) {
+                console.error(cargo.stderr.toString().trim());
+                console.error(`💥  Run \`cargo lambda\` errored.`);
                 process.exit(1);
                 // Note: I don't want to raise an error here, as that will clutter the
                 // output with the stack trace here. But maybe, there's a way to
                 // suppress that?
-                // throw new Error(zigBuild.stderr.toString().trim());
+                // throw new Error(cargo.stderr.toString().trim());
             }
         }
-
-        let from = path.join(targetReleaseDir, outputName);
-        let to = path.join(options.outDir, 'bootstrap');
-
-        fs.copyFileSync(from, to);
     } catch (err) {
         throw new Error(
             `Failed to build file at ${options.entry}: ${err}`

lib/function.ts

@@ -50,7 +50,7 @@ export interface RustFunctionProps
 }
 
 /**
- * A Rust Lambda function built using `cargo-zigbuild`
+ * A Rust Lambda function built using `cargo lambda`
  */
 export class RustFunction extends lambda.Function {
     constructor(
@@ -77,25 +77,18 @@ export class RustFunction extends lambda.Function {
 
         const handlerDir = path.join(
             buildDir,
-            // We need to generate a *unique* hash in case there are multiple
-            // executables, so use the `binName` here instead.
-            crypto
-                .createHash('sha256')
-                .update(executable)
-                .digest('hex')
+            executable
         );
-        createDirectory(buildDir);
-        createDirectory(handlerDir);
 
         let start = performance.now();
 
-        // Build with `cargo-zigbuild`
+        // Build with `cargo-lambda`
         build({
             ...props,
             entry,
             bin: binName,
             target: target,
-            outDir: handlerDir,
+            outDir: buildDir,
         });
 
         logTime(start, `🎯  Cross-compile \`${executable}\``);

lib/settings.ts

@@ -76,7 +76,7 @@ export const Settings = {
 
     /**
      * Key-value pairs that are passed in at compile time, i.e. to `cargo
-     * build` or `cargo-zigbuild`.
+     * build` or `cargo lambda`.
      *
      * Use environment variables to apply configuration changes, such
      * as test and production environment configurations, without changing your
@@ -87,7 +87,7 @@ export const Settings = {
     BUILD_ENVIRONMENT: undefined as NodeJS.ProcessEnv | undefined,
 
     /**
-     * Additional arguments that are passed in at build time to `cargo-zigbuild`.
+     * Additional arguments that are passed in at build time to `cargo lambda`.
      *
      * ## Examples
      *

package.json

@@ -42,6 +42,9 @@
         "aws-cdk-lib": "^2.0.0",
         "constructs": "^10.0.43"
     },
+    "optionalDependencies": {
+        "@ziglang/cli": "^0.0.8"
+    },
     "homepage": "https://github.com/rnag/rust.aws-cdk-lambda",
     "engines": {
         "node": ">= 10.3.0"