Merge branch 'rust-serverless:master' into master

jerusdp · web-flow · commit a6648d8eb848 · 2021-11-19T09:27:55.000Z
diff --git a/README.md b/README.md
@@ -1,9 +1,8 @@
 # AWS Lambda [Rust](https://www.rust-lang.org/) docker builder 🐑 🦀 🐳 [![Build Status](https://github.com/rust-serverless/lambda-rust/workflows/Main/badge.svg)](https://github.com/rust-serverless/lambda-rust/actions)
 
-
 ## 🤔 about
 
-This docker image extends AWS Lambda `provided.al2 runtime environment, and installs [rustup](https://rustup.rs/) and the *stable* rust toolchain.
+This docker image extends AWS Lambda `provided.al2` runtime environment, and installs [rustup](https://rustup.rs/) and the *stable* rust toolchain.
 
 This provides a build environment, consistent with your target execution environment for predictable results.
 
@@ -24,7 +23,7 @@ The default docker entrypoint will build a packaged release optimized version of
 isolate the lambda specific build artifacts from your host-local build artifacts.
 
 > **⚠️ Note:** you can switch from the `release` profile to a custom profile like `dev` by providing a `PROFILE` environment variable set to the name of the desired profile. i.e. `-e PROFILE=dev` in your docker run
-
+>
 > **⚠️ Note:** you can include debug symbols in optimized release build binaries by setting `DEBUGINFO`. By default, debug symbols will be stripped from the release binary and set aside in a separate .debug file.
 
 You will want to volume mount `/code` to the directory containing your cargo project.
@@ -40,15 +39,16 @@ A typical docker run might look like the following.
 
 ```sh
 $ docker run --rm \
-    -u $(id -u):$(id -g) \
+    -u "$(id -u)":"$(id -g)" \
     -v ${PWD}:/code \
     -v ${HOME}/.cargo/registry:/cargo/registry \
     -v ${HOME}/.cargo/git:/cargo/git \
     rustserverless/lambda-rust
 ```
+
 > 💡 The -v (volume mount) flags for `/cargo/{registry,git}` are optional but when supplied, provides a much faster turn around when doing iterative development
 
-Note that `-u $(id -u):$(id -g)` argument is crucial for the container to produce artifacts
+Note that `-u "$(id -u)":$(id -g)` argument is crucial for the container to produce artifacts
 owned by the current host user, otherwise you won't be able to `rm -rf target/lambda`
 or run `cargo update`, because the container will write artifacts owned by `root` docker user
 to `target/lambda` and `./cargo/{registry,git}` dirs which will break your dev and/or ci environment.
@@ -86,8 +86,9 @@ $ docker run --rm \
 
 ## ⚓ using hooks
 
-If you want to customize certain parts of the build process, you can leverage hooks that this image provides.
-Hooks are just shell scripts that are invoked in a specific order, so you can customize the process as you wish. The following hooks exist:
+You can leverage hooks provided in the image to customize certain parts of the build process.
+Hooks are shell scripts that are invoked if they exist, so you can customize the process. The following hooks exist:
+
 * `install`: run before `cargo build` - useful for installing native dependencies on the lambda environment
 * `build`: run after `cargo build`, but before packaging the executable into a zip - useful when modifying the executable after compilation
 * `package`: run after packaging the executable into a zip - useful for adding extra files into the zip file
@@ -121,56 +122,33 @@ docker run \
     -v ${HOME}/.cargo/git:/cargo/git \
     rustserverless/lambda-rust
 
-# start a one-off docker container replicating the "provided.al2" lambda runtime
-# awaiting an event to be provided via stdin
-$ docker run \
-    -i -e DOCKER_LAMBDA_USE_STDIN=1 \
-    --rm \
-    -v ${PWD}/target/lambda/release/output/{your-binary-name}:/var/task:ro,delegated \
-    public.ecr.aws/lambda/provided:al2
-
-# provide an event payload via stdin (typically a json blob)
+# Build a container with your binary as the runtime
 
-# Ctrl-D to yield control back to your function
-```
+$ docker build -t mylambda -f- . <<EOF
+FROM public.ecr.aws/lambda/provided:al2
+COPY bootstrap /var/runtime
+CMD [ "function.handler" ]
+EOF
 
-You may find the one-off container less than ideal if you wish to trigger your lambda multiple times. For these cases try using the "stay open" mode of execution.
-
-```sh
-# start a long running docker container replicating the "provided" lambda runtime
-# listening on port 9001
-$ unzip -o \
-    target/lambda/release/{your-binary-name}.zip \
-    -d /tmp/lambda && \
-  docker run \
-    --rm \
-    -v /tmp/lambda:/var/task:ro,delegated \
-    -e DOCKER_LAMBDA_STAY_OPEN=1 \
-    -p 9001:9001 \
-    public.ecr.aws/lambda/provided:al2
-```
+# start a container based on your image
+$ docker run \
+        --name lambda \
+        --rm \
+        -p 9000:8080 \
+        -d mylambda
 
-In a separate terminal, you can invoke your function with `curl`
+# provide an event payload (in event.json" by http POST to the container
 
-The `-d` flag is a means of providing your function's input.
+$ curl -X POST \
+        -H "Content-Type: application/json" \
+        -d "@event.json" \
+        "http://localhost:9000/2015-03-31/functions/function/invocations"
 
-```sh
-$ curl -d '{}' \
-    http://localhost:9001/2015-03-31/functions/myfunction/invocations
+# Stop the container
+$ docker container stop lambda
 ```
 
-You can also use the `aws` cli to invoke your function locally.  The `--payload` is a means of providing your function's input.
-
-```sh
-$ aws lambda invoke \
-    --endpoint http://localhost:9001 \
-    --cli-binary-format raw-in-base64-out \
-    --no-sign-request \
-    --function-name myfunction \
-    --payload '{}' out.json \
-    && cat out.json \
-    && rm -f out.json
-```
+You may submit multiple events to the same container.
 
 ## 🤸🤸 usage via cargo aws-lambda subcommand
 
@@ -184,17 +162,17 @@ $ cargo install cargo-aws-lambda
 ```
 
 To compile and deploy in your project directory
+
 ```sh
 $ cargo aws-lambda {your aws function's full ARN} {your-binary-name}
 ```
 
 To list all options
+
 ```sh
 $ cargo aws-lambda --help
 ```
 
 More instructions can be found [here](https://github.com/vvilhonen/cargo-aws-lambda).
 
-
 Doug Tangren ([softprops](https://github.com/softprops)) 2020, Alexander Zaitsev ([zamazan4ik](https://github.com/zamazan4ik)) 2021
-
diff --git a/latest.sh b/latest.sh
@@ -8,8 +8,9 @@ source /cargo/env
 
 rustup toolchain install stable --profile=minimal
 STABLE=$(rustup check | grep stable | grep -E "[0-9]+\.[0-9]+\.[0-9]+" -o)
-DEFAULT=$(rustup show | grep -m 1 default | grep -E "[0-9]+\.[0-9]+\.[0-9]+" -o)
+DEFAULT=$(rustup show | grep -m 1 rustc | grep -E "[0-9]+\.[0-9]+\.[0-9]+" -o)
 
 if [ "${STABLE}" == "${DEFAULT}" ]; then exit 0
     else exit 1
 fi
+
diff --git a/tests/test.sh b/tests/test.sh
@@ -2,8 +2,6 @@
 
 # Directory of the integration test
 HERE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
-# Root directory of the repository
-DIST=$(cd "$HERE"/..; pwd)
 : "${IMAGE:=rustserverless/lambda-rust}"
 
 source "${HERE}"/bashtest.sh
@@ -12,12 +10,12 @@ source "${HERE}"/bashtest.sh
 package_bin() {
     rm -rf target/lambda/release > /dev/null 2>&1
     docker run --rm \
-    -u $(id -u):$(id -g) \
+    -u "$(id -u)":"$(id -g)" \
     -e BIN="$1" \
     -v "${PWD}":/code \
     -v "${HOME}"/.cargo/registry:/cargo/registry \
     -v "${HOME}"/.cargo/git:/cargo/git \
-    ${IMAGE} && \
+    "${IMAGE}" && \
     ls target/lambda/release/"${1}".zip > /dev/null 2>&1 &&
     ls target/lambda/release/output/"${1}"/bootstrap 2>&1 &&
     ls target/lambda/release/output/"${1}"/bootstrap.debug 2>&1
@@ -27,11 +25,11 @@ package_bin() {
 package_all() {
     rm -rf target/lambda/release > /dev/null 2>&1
     docker run --rm \
-    -u $(id -u):$(id -g) \
+    -u "$(id -u)":"$(id -g)" \
     -v "${PWD}":/code \
     -v "${HOME}"/.cargo/registry:/cargo/registry \
     -v "${HOME}"/.cargo/git:/cargo/git \
-    ${IMAGE} && \
+    "${IMAGE}" && \
     ls target/lambda/release/"${1}".zip > /dev/null 2>&1 &&
     ls target/lambda/release/output/"${1}"/bootstrap 2>&1 &&
     ls target/lambda/release/output/"${1}"/bootstrap.debug 2>&1
@@ -41,13 +39,13 @@ package_all() {
 compile_without_packaging() {
     rm -rf target/lambda/release > /dev/null 2>&1
     docker run --rm \
-    -u $(id -u):$(id -g) \
+    -u "$(id -u)":"$(id -g)" \
     -e PACKAGE=false \
     -v "${PWD}":/code \
     -v "${HOME}"/.cargo/registry:/cargo/registry \
     -v "${HOME}"/.cargo/git:/cargo/git \
-    ${IMAGE} &&
-    !(ls target/lambda/release/"${1}".zip > /dev/null 2>&1) &&
+    "${IMAGE}" &&
+    ! (ls target/lambda/release/"${1}".zip > /dev/null 2>&1) &&
     ls target/lambda/release/output/"${1}"/bootstrap 2>&1 &&
     ls target/lambda/release/output/"${1}"/bootstrap.debug 2>&1
 }
@@ -56,19 +54,82 @@ compile_without_packaging() {
 package_all_dev_profile() {
     rm -rf target/lambda/debug > /dev/null 2>&1
     docker run --rm \
-    -u $(id -u):$(id -g) \
+    -u "$(id -u)":"$(id -g)" \
     -e PROFILE=dev \
     -v "${PWD}":/code \
     -v "${HOME}"/.cargo/registry:/cargo/registry \
     -v "${HOME}"/.cargo/git:/cargo/git \
-    ${IMAGE} && \
+    "${IMAGE}" && \
     ls target/lambda/debug/"${1}".zip > /dev/null 2>&1 &&
     ls target/lambda/release/output/"${1}"/bootstrap 2>&1 &&
     ls target/lambda/release/output/"${1}"/bootstrap.debug 2>&1
 }
 
+verify_packaged_application() {
+    LAMBDA_RUNTIME_DIR="/var/runtime"
+    LAMBDA_TASK_DIR="/var/task"
+    HOOKS="test-func-with-hooks"
+    TRY=1
+    MAX_TRY=10
+    TRIES_EXCEEDED=10
+    SLEEP=1
+    PACKAGE="${1}"
+    PROJECT="${2}"
+    TSFRACTION=$(date +%M%S)
+
+    clean_up() {
+        docker container stop lamb > /dev/null 2>&1
+        rm -f bootstrap > /dev/null 2>&1
+        rm -f output.log > /dev/null 2>&1
+    }
+
+    clean_up
+    rm -f test-out.log > /dev/null 2>&1
+
+    unzip -o \
+           target/lambda/release/"${PACKAGE}".zip
+
+    if [ "$PROJECT" = "${HOOKS}" ]; then
+        docker build -t mylambda:"${TSFRACTION}" -f- . <<EOF
+FROM public.ecr.aws/lambda/provided:al2
+COPY bootstrap ${LAMBDA_RUNTIME_DIR}
+COPY output.log ${LAMBDA_TASK_DIR}
+CMD [ "function.handler" ]
+EOF
+    else
+        docker build -t mylambda:"${TSFRACTION}" -f- . <<EOF
+FROM public.ecr.aws/lambda/provided:al2
+COPY bootstrap ${LAMBDA_RUNTIME_DIR}
+CMD [ "function.handler" ]
+EOF
+    fi
+    # rm -f bootstrap > /dev/null 2>&1
+    docker run \
+        --name lamb \
+        --rm \
+        -p 9000:8080 \
+        -d mylambda:"${TSFRACTION}"
+
+    until curl -X POST \
+        -H "Content-Type: application/json" \
+        -d "@test-event.json" \
+        "http://localhost:9000/2015-03-31/functions/function/invocations" | \
+        grep -v RequestId | \
+        grep -v '^\W*$' > test-out.log; do
+      >&2 echo "waiting for service to spin up"
+      sleep ${SLEEP}
+      if [ ${TRY} = ${MAX_TRY} ]; then
+        exit ${TRIES_EXCEEDED}
+        else
+        TRY=$((TRY + 1))
+        fi
+    done
+
+    clean_up
+}
+
 for project in test-func test-multi-func test-func-with-hooks; do
-    cd "${HERE}"/"${project}"
+    cd "${HERE}"/"${project}" || exit 2
     echo "👩‍🔬 Running tests for $project with image $IMAGE"
 
     if [[ "$project" == test-multi-func ]]; then
@@ -86,19 +147,8 @@ for project in test-func test-multi-func test-func-with-hooks; do
 
     assert "it packages all bins" package_all "${bin_name}"
 
-    # verify packaged artifact by invoking it using the lambdaci "provided.al2" docker image
-    rm -f output.log > /dev/null 2>&1
-    rm -f test-out.log > /dev/null 2>&1
-    rm -rf /tmp/lambda > /dev/null 2>&1
-    unzip -o \
-        target/lambda/release/"${bin_name}".zip \
-        -d /tmp/lambda > /dev/null 2>&1 && \
-    docker run \
-        -i -e DOCKER_LAMBDA_USE_STDIN=1 \
-        --rm \
-        -v /tmp/lambda:/var/task \
-        lambci/lambda:provided.al2 < test-event.json | grep -v RequestId | grep -v '^\W*$' > test-out.log
-
+    # verify packaged artifact by invoking it using the aws lambda "provided.al2" docker image
+    verify_packaged_application "${bin_name}" "${project}"
     assert "when invoked, it produces expected output" diff expected-output.json test-out.log
 done
 
