[Do not merge] Refactor to address RFCs

.gitignore

@@ -1,2 +1,3 @@
 /target
+/.cargo
 lambda-runtime/libtest.rmeta

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
     "lambda-runtime-client",
+    "lambda-runtime-core",
     "lambda-runtime",
     "lambda-http"
 ]

lambda-runtime-client/Cargo.toml

@@ -21,6 +21,6 @@ tokio = "0.1"
 http = "0.1"
 serde = "^1"
 serde_json = "^1"
-serde_derive = "^1"
+serde_derive = "^1" 
 log = "0.4"
 backtrace = "0.3"

lambda-runtime-client/src/client.rs

@@ -1,21 +1,22 @@
-use std::{collections::HashMap, fmt};
-
+use crate::error::{ApiError, ErrorResponse, ERROR_TYPE_UNHANDLED};
 use hyper::{
     client::HttpConnector,
     header::{self, HeaderMap, HeaderValue},
     rt::{Future, Stream},
     Body, Client, Method, Request, Uri,
 };
-use serde_derive::Deserialize;
+use log::*;
+use serde_derive::*;
 use serde_json;
+use std::{collections::HashMap, fmt};
 use tokio::runtime::Runtime;
 
-use crate::error::{ApiError, ErrorResponse, RuntimeApiError};
-
 const RUNTIME_API_VERSION: &str = "2018-06-01";
 const API_CONTENT_TYPE: &str = "application/json";
 const API_ERROR_CONTENT_TYPE: &str = "application/vnd.aws.lambda.error+json";
 const RUNTIME_ERROR_HEADER: &str = "Lambda-Runtime-Function-Error-Type";
+// TODO: Perhaps use a macro to generate this
+const CLIENT_USER_AGENT: &str = "AWS_Lambda_Rust/0.1.0";
 
 /// Enum of the headers returned by Lambda's `/next` API call.
 pub enum LambdaHeaders {
@@ -126,7 +127,7 @@ pub struct RuntimeClient {
     endpoint: String,
 }
 
-impl RuntimeClient {
+impl<'ev> RuntimeClient {
     /// Creates a new instance of the Runtime APIclient SDK. The http client has timeouts disabled and
     /// will always send a `Connection: keep-alive` header.
     pub fn new(endpoint: String, runtime: Option<Runtime>) -> Result<Self, ApiError> {
@@ -147,7 +148,7 @@ impl RuntimeClient {
     }
 }
 
-impl RuntimeClient {
+impl<'ev> RuntimeClient {
     /// Polls for new events to the Runtime APIs.
     pub fn next_event(&self) -> Result<(Vec<u8>, EventContext), ApiError> {
         let uri = format!(
@@ -184,7 +185,7 @@ impl RuntimeClient {
                 }
                 let ctx = self.get_event_context(&resp.headers())?;
                 let out = resp.into_body().concat2().wait()?;
-                let buf: Vec<u8> = out.into_bytes().to_vec();
+                let buf = out.into_bytes().to_vec();
 
                 trace!(
                     "Received new event for request id {}. Event length {} bytes",
@@ -212,7 +213,7 @@ impl RuntimeClient {
     ///
     /// # Returns
     /// A `Result` object containing a bool return value for the call or an `error::ApiError` instance.
-    pub fn event_response(&self, request_id: &str, output: Vec<u8>) -> Result<(), ApiError> {
+    pub fn event_response(&self, request_id: &str, output: &[u8]) -> Result<(), ApiError> {
         let uri: Uri = format!(
             "http://{}/{}/runtime/invocation/{}/response",
             self.endpoint, RUNTIME_API_VERSION, request_id
@@ -260,7 +261,7 @@ impl RuntimeClient {
     ///
     /// # Returns
     /// A `Result` object containing a bool return value for the call or an `error::ApiError` instance.
-    pub fn event_error(&self, request_id: &str, e: &dyn RuntimeApiError) -> Result<(), ApiError> {
+    pub fn event_error(&self, request_id: &str, e: &ErrorResponse) -> Result<(), ApiError> {
         let uri: Uri = format!(
             "http://{}/{}/runtime/invocation/{}/error",
             self.endpoint, RUNTIME_API_VERSION, request_id
@@ -269,9 +270,9 @@ impl RuntimeClient {
         trace!(
             "Posting error to runtime API for request {}: {}",
             request_id,
-            e.to_response().error_message
+            e.error_message
         );
-        let req = self.get_runtime_error_request(&uri, &e.to_response());
+        let req = self.get_runtime_error_request(&uri, &e);
 
         match self.http_client.request(req).wait() {
             Ok(resp) => {
@@ -307,12 +308,12 @@ impl RuntimeClient {
     /// # Panics
     /// If it cannot send the init error. In this case we panic to force the runtime
     /// to restart.
-    pub fn fail_init(&self, e: &dyn RuntimeApiError) {
+    pub fn fail_init(&self, e: &ErrorResponse) {
         let uri: Uri = format!("http://{}/{}/runtime/init/error", self.endpoint, RUNTIME_API_VERSION)
             .parse()
             .expect("Could not generate Runtime URI");
-        error!("Calling fail_init Runtime API: {}", e.to_response().error_message);
-        let req = self.get_runtime_error_request(&uri, &e.to_response());
+        error!("Calling fail_init Runtime API: {}", e.error_message);
+        let req = self.get_runtime_error_request(&uri, &e);
 
         self.http_client
             .request(req)
@@ -331,9 +332,7 @@ impl RuntimeClient {
     pub fn get_endpoint(&self) -> String {
         self.endpoint.clone()
     }
-}
 
-impl RuntimeClient {
     /// Creates a Hyper `Request` object for the given `Uri` and `Body`. Sets the
     /// HTTP method to `POST` and the `Content-Type` header value to `application/json`.
     ///
@@ -344,25 +343,27 @@ impl RuntimeClient {
     ///
     /// # Returns
     /// A Populated Hyper `Request` object.
-    fn get_runtime_post_request(&self, uri: &Uri, body: Vec<u8>) -> Request<Body> {
+    fn get_runtime_post_request(&self, uri: &Uri, body: &[u8]) -> Request<Body> {
         Request::builder()
             .method(Method::POST)
             .uri(uri.clone())
             .header(header::CONTENT_TYPE, header::HeaderValue::from_static(API_CONTENT_TYPE))
-            .body(Body::from(body))
+            .header(header::USER_AGENT, header::HeaderValue::from_static(CLIENT_USER_AGENT))
+            .body(Body::from(body.to_owned()))
             .unwrap()
     }
 
     fn get_runtime_error_request(&self, uri: &Uri, e: &ErrorResponse) -> Request<Body> {
-        let body = serde_json::to_vec(e).expect("Could not turn error object into response JSON");
+        let body = serde_json::to_vec(&e).expect("Could not turn error object into response JSON");
         Request::builder()
             .method(Method::POST)
             .uri(uri.clone())
             .header(
                 header::CONTENT_TYPE,
                 header::HeaderValue::from_static(API_ERROR_CONTENT_TYPE),
             )
-            .header(RUNTIME_ERROR_HEADER, HeaderValue::from_static("RuntimeError")) // TODO: We should add this code to the error object.
+            .header(header::USER_AGENT, header::HeaderValue::from_static(CLIENT_USER_AGENT))
+            .header(RUNTIME_ERROR_HEADER, HeaderValue::from_static(ERROR_TYPE_UNHANDLED))
             .body(Body::from(body))
             .unwrap()
     }

lambda-runtime-client/src/error.rs

@@ -1,20 +1,31 @@
 //! This module defines the `RuntimeApiError` trait that developers should implement
 //! to send their custom errors to the AWS Lambda Runtime Client SDK. The module also
 //! defines the `ApiError` type returned by the `RuntimeClient` implementations.
-use std::{env, error::Error, fmt, io, num::ParseIntError, option::Option};
-
 use backtrace;
 use http::{header::ToStrError, uri::InvalidUri};
 use hyper;
-use serde_derive::Serialize;
+use log::*;
+use serde_derive::*;
 use serde_json;
+use std::{
+    env,
+    error::Error,
+    fmt::{self, Display},
+    io,
+    num::ParseIntError,
+    option::Option,
+};
 
 /// Error type description for the `ErrorResponse` event. This type should be returned
 /// for errors that were handled by the function code or framework.
-pub const ERROR_TYPE_HANDLED: &str = "Handled";
+#[allow(dead_code)]
+pub(crate) const ERROR_TYPE_HANDLED: &str = "Handled";
 /// Error type description for the `ErrorResponse` event. This type is used for unhandled,
 /// unexpcted errors.
-pub const ERROR_TYPE_UNHANDLED: &str = "Unhandled";
+pub(crate) const ERROR_TYPE_UNHANDLED: &str = "Unhandled";
+/// Error type for the error responses to the Runtime APIs. In the future, this library
+/// should use a customer-generated error code
+pub const RUNTIME_ERROR_TYPE: &str = "RustRuntimeError";
 
 /// This object is used to generate requests to the Lambda Runtime APIs.
 /// It is used for both the error response APIs and fail init calls.
@@ -37,6 +48,38 @@ pub struct ErrorResponse {
 }
 
 impl ErrorResponse {
+    /// Creates a new instance of the `ErrorResponse` object with the given parameters. If the
+    /// `RUST_BACKTRACE` env variable is `1` the `ErrorResponse` is populated with the backtrace
+    /// collected through the [`backtrace` craete](https://crates.io/crates/backtrace).
+    ///
+    /// # Arguments
+    ///
+    /// * `message` The error message to be returned to the APIs. Normally the error description()
+    /// * `err_type` The error type. Use the `ERROR_TYPE_HANDLED` and `ERROR_TYPE_UNHANDLED`.
+    /// * `code` A custom error code
+    ///
+    /// # Return
+    /// A new instance of the `ErrorResponse` object.
+    fn new(message: String, err_type: String) -> ErrorResponse {
+        let mut err = ErrorResponse {
+            error_message: message,
+            error_type: err_type,
+            stack_trace: Option::default(),
+        };
+        let is_backtrace = env::var("RUST_BACKTRACE");
+        if is_backtrace.is_ok() && is_backtrace.unwrap() == "1" {
+            trace!("Begin backtrace collection");
+            let trace = Option::from(backtrace::Backtrace::new());
+            let trace_string = format!("{:?}", trace)
+                .lines()
+                .map(|s| s.to_string())
+                .collect::<Vec<String>>();
+            trace!("Completed backtrace collection");
+            err.stack_trace = Option::from(trace_string);
+        }
+        err
+    }
+
     /// Creates a new `RuntimeError` object with the handled error type.
     ///
     /// # Arguments
@@ -46,11 +89,7 @@ impl ErrorResponse {
     /// # Return
     /// A populated `RuntimeError` object that can be used with the Lambda Runtime API.
     pub fn handled(message: String) -> ErrorResponse {
-        ErrorResponse {
-            error_message: message,
-            error_type: String::from(ERROR_TYPE_HANDLED),
-            stack_trace: Option::default(),
-        }
+        ErrorResponse::new(message, RUNTIME_ERROR_TYPE.to_owned())
     }
 
     /// Creates a new `RuntimeError` object with the unhandled error type.
@@ -62,33 +101,20 @@ impl ErrorResponse {
     /// # Return
     /// A populated `RuntimeError` object that can be used with the Lambda Runtime API.
     pub fn unhandled(message: String) -> ErrorResponse {
-        ErrorResponse {
-            error_message: message,
-            error_type: String::from(ERROR_TYPE_UNHANDLED),
-            stack_trace: Option::default(),
-        }
+        ErrorResponse::new(message, RUNTIME_ERROR_TYPE.to_owned())
     }
 }
 
-/// Custom errors for the framework should implement this trait. The client calls
-/// the `to_response()` method automatically to produce an object that can be serialized
-/// and sent to the Lambda Runtime APIs.
-pub trait RuntimeApiError {
-    /// Creates a `RuntimeError` object for the current error. This is
-    /// then serialized and sent to the Lambda runtime APIs.
-    ///
-    /// # Returns
-    /// A populated `RuntimeError` object.
-    fn to_response(&self) -> ErrorResponse;
+impl<T: Display + Send + Sync> From<Box<T>> for ErrorResponse {
+    fn from(e: Box<T>) -> Self {
+        Self::handled(format!("{}", e))
+    }
 }
 
 /// Represents an error generated by the Lambda Runtime API client.
 #[derive(Debug, Clone)]
 pub struct ApiError {
     msg: String,
-    /// The `Backtrace` object from the `backtrace` crate used to store
-    /// the stack trace of the error.
-    pub backtrace: Option<backtrace::Backtrace>,
     /// Whether the current error is recoverable. If the error is not
     /// recoverable a runtime should panic to force the Lambda service
     /// to restart the execution environment.
@@ -97,16 +123,8 @@ pub struct ApiError {
 
 impl ApiError {
     pub(crate) fn new(description: &str) -> ApiError {
-        let mut trace: Option<backtrace::Backtrace> = None;
-        let is_backtrace = env::var("RUST_BACKTRACE");
-        if is_backtrace.is_ok() && is_backtrace.unwrap() == "1" {
-            trace!("Begin backtrace collection");
-            trace = Option::from(backtrace::Backtrace::new());
-            trace!("Completed backtrace collection");
-        }
         ApiError {
             msg: String::from(description),
-            backtrace: trace,
             recoverable: true,
         }
     }
@@ -135,6 +153,8 @@ impl Error for ApiError {
         None
     }
 }
+unsafe impl Send for ApiError {}
+unsafe impl Sync for ApiError {}
 
 impl From<serde_json::Error> for ApiError {
     fn from(e: serde_json::Error) -> Self {
@@ -171,14 +191,3 @@ impl From<io::Error> for ApiError {
         ApiError::new(e.description())
     }
 }
-
-impl RuntimeApiError for ApiError {
-    fn to_response(&self) -> ErrorResponse {
-        let backtrace = format!("{:?}", self.backtrace);
-        let trace_vec = backtrace.lines().map(|s| s.to_string()).collect::<Vec<String>>();
-        let mut err = ErrorResponse::unhandled(self.msg.clone());
-        err.stack_trace = Option::from(trace_vec);
-
-        err
-    }
-}

lambda-runtime-client/src/lib.rs

@@ -1,5 +1,6 @@
 #![warn(missing_docs)]
 #![deny(warnings)]
+#![allow(clippy::new_ret_no_self)]
 //! Rust client SDK for the AWS Lambda Runtime APIs. This crate defines
 //! a `RuntimeClient` that encapsulates interactions with AWS Lambda's Runtime
 //! APIs.
@@ -56,9 +57,7 @@
 //! }
 //! ```
 
-#[macro_use]
-extern crate log;
-
 mod client;
 pub mod error;
+
 pub use crate::client::*;

lambda-runtime-core/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "lambda_runtime_core"
+version = "0.1.0"
+authors = ["Stefano Buliani", "David Barsky"]
+description = "Rust runtime for AWS Lambda"
+keywords = ["AWS", "Lambda", "Runtime", "Rust"]
+license = "Apache-2.0"
+homepage = "https://github.com/awslabs/aws-lambda-rust-runtime"
+repository = "https://github.com/awslabs/aws-lambda-rust-runtime"
+documentation = "https://docs.rs/lambda_runtime"
+edition = "2018"
+
+[dependencies]
+log = "^0.4"
+hyper = "^0.12"
+tokio = "^0.1"
+backtrace = "^0.3"
+lambda_runtime_client = { path = "../lambda-runtime-client", version = "^0.1" }
+chrono = "^0.4"
+
+[dev-dependencies]
+failure = "^0.1"
+simple_logger = "^1"