Removed RuntimeClient trait.

Author: David Barsky

lambda-runtime-client/src/client.rs

@@ -44,47 +44,6 @@ impl fmt::Display for LambdaHeaders {
     }
 }
 
-/// Trait that defines the methods that should be implemented by a Lambda Runtime API client.
-/// Events are returned as a `Vec<u8>` and output for the `event_response()` method should
-/// also be passed as a `Vec<u8>`. Serialization and deserialization are up to the runtime
-/// library. When returning an error to the `event_error()` or `fail_init()` methods the objects
-/// should implement the `error::RuntimeApiError` triat.
-pub trait RuntimeClient {
-    /// Should fetch the next event from the Runtime APIs.
-    ///
-    /// # Return
-    /// A tuple of the event raw bytes and the `EventContext` object extracted from the
-    /// Lambda Runtime API headers - see the `LambdaHeaders` enum.
-    fn next_event(&self) -> Result<(Vec<u8>, EventContext), ApiError>;
-    /// Should return the handler response to the Runtime APIs.
-    ///
-    /// # Arguments
-    ///
-    /// * `request_id` The original AWS request id received from the `poll_events()` method.
-    /// * `output` The object returned by the handler serialized to its raw bytes representation
-    ///            as a `Vec<u8>`.
-    ///
-    /// # Return
-    /// A `Result<(), RuntimeError>` signifying the API call's success or failure.
-    fn event_response(&self, request_id: &str, output: Vec<u8>) -> Result<(), ApiError>;
-    /// Should send an error response to the Runtime APIs.
-    ///
-    /// # Arguments
-    ///
-    /// * `request_id` The original AWS request id received from the `poll_events()` method.
-    /// * `e` The `errors::HandlerError` returned by the handler function.
-    ///
-    /// # Return
-    /// A `Result<(), RuntimeError>` signifying the API call's success or failure. A unit struct
-    /// signifies a lack of an error.
-    fn event_error(&self, request_id: &str, e: &RuntimeApiError) -> Result<(), ApiError>;
-    /// Should tell the Runtime APIs that the custom runtime has failed to initialize and the
-    /// execution environment should be terminated.
-    fn fail_init(&self, e: &RuntimeApiError);
-    /// Returns the endpoint this client is communicating with. Primarily used for debugging.
-    fn get_endpoint(&self) -> String;
-}
-
 /// AWS Moble SDK client properties
 #[derive(Deserialize, Clone)]
 pub struct ClientApplication {
@@ -150,13 +109,13 @@ pub struct EventContext {
 
 /// The client SDK for Lambda's Runtime APIs that implements the `RuntimeClient` trait.
 /// This object is used by the `RustRuntime` to communicate with the internal endpoint.
-pub struct HttpRuntimeClient {
+pub struct RuntimeClient {
     _runtime: Runtime,
     http_client: Client<HttpConnector, Body>,
     endpoint: String,
 }
 
-impl HttpRuntimeClient {
+impl RuntimeClient {
     /// Creates a new instance of the Runtime APIclient SDK. The http client has timeouts disabled and
     /// always send the `Connection: keep-alive` header.
     ///
@@ -177,20 +136,20 @@ impl HttpRuntimeClient {
 
         let http_client = Client::builder().executor(runtime.executor()).build_http();
 
-        Ok(HttpRuntimeClient {
+        Ok(RuntimeClient {
             _runtime: runtime,
             http_client,
             endpoint,
         })
     }
 }
 
-impl RuntimeClient for HttpRuntimeClient {
+impl RuntimeClient {
     /// Makes the HTTP call to poll for new events to the Runtime APIs.
     ///
     /// # Return
     /// A `Result` containing a tuple of the new event of type `E` and its `EventContext`.
-    fn next_event(&self) -> Result<(Vec<u8>, EventContext), ApiError> {
+    pub fn next_event(&self) -> Result<(Vec<u8>, EventContext), ApiError> {
         let uri = format!(
             "http://{}/{}/runtime/invocation/next",
             self.endpoint, RUNTIME_API_VERSION
@@ -252,7 +211,7 @@ impl RuntimeClient for HttpRuntimeClient {
     ///
     /// # Returns
     /// A `Result` object containing a bool return value for the call or an `error::ApiError` instance.
-    fn event_response(&self, request_id: &str, output: Vec<u8>) -> Result<(), ApiError> {
+    pub fn event_response(&self, request_id: &str, output: Vec<u8>) -> Result<(), ApiError> {
         let uri: Uri = format!(
             "http://{}/{}/runtime/invocation/{}/response",
             self.endpoint, RUNTIME_API_VERSION, request_id
@@ -299,7 +258,7 @@ impl RuntimeClient for HttpRuntimeClient {
     ///
     /// # Returns
     /// A `Result` object containing a bool return value for the call or an `error::ApiError` instance.
-    fn event_error(&self, request_id: &str, e: &RuntimeApiError) -> Result<(), ApiError> {
+    pub fn event_error(&self, request_id: &str, e: &RuntimeApiError) -> Result<(), ApiError> {
         let uri: Uri = format!(
             "http://{}/{}/runtime/invocation/{}/error",
             self.endpoint, RUNTIME_API_VERSION, request_id
@@ -346,7 +305,7 @@ impl RuntimeClient for HttpRuntimeClient {
     /// # Panics
     /// If it cannot send the init error. In this case we panic to force the runtime
     /// to restart.
-    fn fail_init(&self, e: &RuntimeApiError) {
+    pub fn fail_init(&self, e: &RuntimeApiError) {
         let uri: Uri = format!("http://{}/{}/runtime/init/error", self.endpoint, RUNTIME_API_VERSION)
             .parse()
             .expect("Could not generate Runtime API URI");
@@ -364,12 +323,12 @@ impl RuntimeClient for HttpRuntimeClient {
     }
 
     /// Returns the endpoint configured for this HTTP Runtime client.
-    fn get_endpoint(&self) -> String {
+    pub fn get_endpoint(&self) -> String {
         self.endpoint.clone()
     }
 }
 
-impl HttpRuntimeClient {
+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`.
     ///

lambda-runtime/src/env.rs

@@ -39,6 +39,12 @@ pub trait ConfigProvider {
 /// used by the `start()` method of this module.
 pub struct EnvConfigProvider;
 
+impl EnvConfigProvider {
+    pub fn new() -> Self {
+        EnvConfigProvider { }
+    }
+}
+
 impl ConfigProvider for EnvConfigProvider {
     /// Loads the function settings from the Lambda environment variables:
     /// https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html

lambda-runtime/src/runtime.rs

@@ -1,9 +1,9 @@
 use std::{error::Error, result};
 
-use lambda_runtime_client;
 use serde;
 use serde_json;
 
+use lambda_runtime_client::RuntimeClient;
 use context::Context;
 use env::{ConfigProvider, EnvConfigProvider, FunctionSettings};
 use error::{HandlerError, RuntimeError};
@@ -22,12 +22,12 @@ pub type Handler<E, O> = fn(E, Context) -> Result<O, HandlerError>;
 ///
 /// # Panics
 /// The function panics if the Lambda environment variables are not set.
-pub fn start<E: 'static, O: 'static>(f: Handler<E, O>, runtime: Option<TokioRuntime>)
+pub fn start<E, O>(f: Handler<E, O>, runtime: Option<TokioRuntime>)
 where
     for<'invocation> E: serde::Deserialize<'invocation>,
     O: serde::Serialize,
 {
-    start_with_config(f, &EnvConfigProvider {}, runtime)
+    start_with_config(f, EnvConfigProvider::new(), runtime)
 }
 
 #[macro_export]
@@ -53,13 +53,14 @@ macro_rules! lambda {
 /// The function panics if the `ConfigProvider` returns an error from the `get_runtime_api_endpoint()`
 /// or `get_function_settings()` methods. The panic forces AWS Lambda to terminate the environment
 /// and spin up a new one for the next invocation.
-pub(crate) fn start_with_config<E: 'static, O: 'static>(
+pub(crate) fn start_with_config<E, O, C>(
     f: Handler<E, O>,
-    config: &'static ConfigProvider,
+    config: C,
     runtime: Option<TokioRuntime>,
 ) where
     for<'invocation> E: serde::Deserialize<'invocation>,
     O: serde::Serialize,
+    C: ConfigProvider,
 {
     // if we cannot find the endpoint we panic, nothing else we can do.
     let endpoint: String;
@@ -81,10 +82,9 @@ pub(crate) fn start_with_config<E: 'static, O: 'static>(
         }
     }
 
-    match lambda_runtime_client::HttpRuntimeClient::new(endpoint, runtime) {
+    match RuntimeClient::new(endpoint, runtime) {
         Ok(client) => {
-            let trait_client: &lambda_runtime_client::RuntimeClient = &client;
-            start_with_runtime_client(f, function_config, trait_client);
+            start_with_runtime_client(f, function_config, client);
         }
         Err(e) => {
             panic!("Could not create runtime client SDK: {}", e);
@@ -103,10 +103,10 @@ pub(crate) fn start_with_config<E: 'static, O: 'static>(
 ///
 /// # Panics
 /// The function panics if we cannot instantiate a new `RustRuntime` object.
-pub(crate) fn start_with_runtime_client<'env, E: 'static, O: 'static>(
+pub(crate) fn start_with_runtime_client<E, O>(
     f: Handler<E, O>,
     func_settings: FunctionSettings,
-    client: &'env lambda_runtime_client::RuntimeClient,
+    client: RuntimeClient,
 ) where
     for<'invocation> E: serde::Deserialize<'invocation>,
     O: serde::Serialize,
@@ -125,15 +125,15 @@ pub(crate) fn start_with_runtime_client<'env, E: 'static, O: 'static>(
 
 /// Internal representation of the runtime object that polls for events and communicates
 /// with the Runtime APIs
-pub(super) struct Runtime<'env, E: 'static, O: 'static> {
-    runtime_client: &'env lambda_runtime_client::RuntimeClient,
+pub(super) struct Runtime<E, O> {
+    runtime_client: RuntimeClient,
     handler: Handler<E, O>,
     max_retries: i8,
     settings: FunctionSettings,
 }
 
 // generic methods implementation
-impl<'env, E, O> Runtime<'env, E, O> {
+impl<E, O> Runtime<E, O> {
     /// Creates a new instance of the `Runtime` object populated with the environment
     /// settings.
     ///
@@ -151,8 +151,8 @@ impl<'env, E, O> Runtime<'env, E, O> {
         f: Handler<E, O>,
         config: FunctionSettings,
         retries: i8,
-        client: &'env lambda_runtime_client::RuntimeClient,
-    ) -> result::Result<Runtime<'env, E, O>, RuntimeError> {
+        client: RuntimeClient,
+    ) -> result::Result<Runtime<E, O>, RuntimeError> {
         debug!(
             "Creating new runtime with {} max retries for endpoint {}",
             retries,
@@ -169,7 +169,7 @@ impl<'env, E, O> Runtime<'env, E, O> {
 
 // implementation of methods that require the Event and Output types
 // to be compatible with `serde`'s Deserialize/Serialize.
-impl<'env, E, O> Runtime<'env, E, O>
+impl<'env, E, O> Runtime<E, O>
 where
     for<'de> E: serde::Deserialize<'de>,
     O: serde::Serialize,
@@ -300,12 +300,12 @@ pub(crate) mod tests {
     use super::*;
     use context;
     use env;
-    use lambda_runtime_client as cli;
+    use lambda_runtime_client::RuntimeClient;
 
     #[test]
     fn runtime_invokes_handler() {
         let config: &env::ConfigProvider = &env::tests::MockConfigProvider { error: false };
-        let client: &lambda_runtime_client::RuntimeClient = &cli::HttpRuntimeClient::new(
+        let client = RuntimeClient::new(
             config
                 .get_runtime_api_endpoint()
                 .expect("Could not get runtime endpoint"),