RUST-1253 Add AWS Lambda Examples

.evergreen/run-aws-tests.sh

@@ -45,3 +45,4 @@ set -o errexit
 source ./.evergreen/configure-rust.sh
 
 RUST_BACKTRACE=1 cargo test --features aws-auth auth_aws::auth_aws
+RUST_BACKTRACE=1 cargo test --features aws-auth lambda_examples::auth::test_handler

Cargo.toml

@@ -162,6 +162,7 @@ derive_more = "0.99.13"
 function_name = "0.2.1"
 futures = "0.3"
 home = "0.5"
+lambda_runtime = "0.6.0"
 pretty_assertions = "1.1.0"
 serde_json = "1.0.64"
 semver = "1.0.0"

src/test/lambda_examples.rs

@@ -0,0 +1,5 @@
+#![allow(dead_code)]
+
+#[cfg(feature = "aws-auth")]
+mod auth;
+mod no_auth;

src/test/lambda_examples/auth.rs

@@ -0,0 +1,71 @@
+use crate as mongodb;
+
+// begin lambda connection example 2
+use async_once::AsyncOnce;
+use lambda_runtime::{service_fn, LambdaEvent};
+use lazy_static::lazy_static;
+use mongodb::{
+    bson::doc,
+    options::{AuthMechanism, ClientOptions, Credential},
+    Client,
+};
+use serde_json::Value;
+
+// Initialize a global static MongoDB Client with AWS authentication. The following environment
+// variables should also be set: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and, optionally,
+// AWS_SESSION_TOKEN.
+//
+// The client can be accessed as follows:
+// let client = MONGODB_CLIENT.get().await;
+lazy_static! {
+    static ref MONGODB_CLIENT: AsyncOnce<Client> = AsyncOnce::new(async {
+        let uri = std::env::var("MONGODB_URI")
+            .expect("MONGODB_URI must be set to the URI of the MongoDB deployment");
+        let mut options = ClientOptions::parse(uri)
+            .await
+            .expect("Failed to parse options from URI");
+        let credential = Credential::builder()
+            .mechanism(AuthMechanism::MongoDbAws)
+            .build();
+        options.credential = Some(credential);
+        Client::with_options(options).expect("Failed to create MongoDB Client")
+    });
+}
+
+// Runs a ping operation on the "db" database and returns the response.
+async fn handler(_: LambdaEvent<Value>) -> Result<Value, lambda_runtime::Error> {
+    let client = MONGODB_CLIENT.get().await;
+    let response = client
+        .database("db")
+        .run_command(doc! { "ping": 1 }, None)
+        .await?;
+    let json = serde_json::to_value(response)?;
+    Ok(json)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), lambda_runtime::Error> {
+    let service = service_fn(handler);
+    lambda_runtime::run(service).await?;
+    Ok(())
+}
+// end lambda connection example 2
+
+// Runs a ping operation on the "db" database and returns the response.
+async fn handler_create_client(_: LambdaEvent<Value>) -> Result<Value, lambda_runtime::Error> {
+    let uri = std::env::var("MONGODB_URI").unwrap();
+    let client = Client::with_uri_str(uri).await.unwrap();
+    let response = client
+        .database("db")
+        .run_command(doc! { "ping": 1 }, None)
+        .await?;
+    let json = serde_json::to_value(response)?;
+    Ok(json)
+}
+
+#[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))]
+#[cfg_attr(feature = "async-std-runtime", async_std::test)]
+async fn test_handler() {
+    let event = LambdaEvent::new(Value::Null, Default::default());
+    handler_create_client(event).await.unwrap();
+}

src/test/lambda_examples/no_auth.rs

@@ -0,0 +1,51 @@
+use crate as mongodb;
+
+// begin lambda connection example 1
+use async_once::AsyncOnce;
+use lambda_runtime::{service_fn, LambdaEvent};
+use lazy_static::lazy_static;
+use mongodb::{bson::doc, Client};
+use serde_json::Value;
+
+// Initialize a global static MongoDB Client.
+//
+// The client can be accessed as follows:
+// let client = MONGODB_CLIENT.get().await;
+lazy_static! {
+    static ref MONGODB_CLIENT: AsyncOnce<Client> = AsyncOnce::new(async {
+        let uri = std::env::var("MONGODB_URI")
+            .expect("MONGODB_URI must be set to the URI of the MongoDB deployment");
+        Client::with_uri_str(uri)
+            .await
+            .expect("Failed to create MongoDB Client")
+    });
+}
+
+// Runs a ping operation on the "db" database and returns the response.
+async fn handler(_: LambdaEvent<Value>) -> Result<Value, lambda_runtime::Error> {
+    let client = MONGODB_CLIENT.get().await;
+    let response = client
+        .database("db")
+        .run_command(doc! { "ping": 1 }, None)
+        .await?;
+    let json = serde_json::to_value(response)?;
+    Ok(json)
+}
+
+#[tokio::main]
+async fn main() -> Result<(), lambda_runtime::Error> {
+    let service = service_fn(handler);
+    lambda_runtime::run(service).await?;
+    Ok(())
+}
+// end lambda connection example 1
+
+#[cfg_attr(feature = "tokio-runtime", tokio::test(flavor = "multi_thread"))]
+#[cfg_attr(feature = "async-std-runtime", async_std::test)]
+async fn test_handler() {
+    if std::env::var("MONGODB_API_VERSION").is_ok() {
+        return;
+    }
+    let event = LambdaEvent::new(Value::Null, Default::default());
+    handler(event).await.unwrap();
+}

src/test/mod.rs

@@ -10,6 +10,8 @@ mod db;
 #[cfg(all(not(feature = "sync"), not(feature = "tokio-sync")))]
 mod documentation_examples;
 mod index_management;
+#[cfg(all(not(feature = "sync"), not(feature = "tokio-sync")))]
+mod lambda_examples;
 pub mod spec;
 mod util;