cargo-lambda-watch 1.9.1

Cargo subcommand to work with AWS Lambda
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use axum::{
    body::Body,
    http::{Request, StatusCode},
};
use hyper::HeaderMap;
use serde::{Deserialize, Serialize};
use tokio::sync::oneshot::Sender;

pub(crate) const AWS_XRAY_TRACE_HEADER: &str = "x-amzn-trace-id";

/// LambdaResponse is the data that the Lambda function sends
/// as the response to an invocation. Because Lambda uses a push
/// model, this response is represented as a HTTP Request data object.
pub type LambdaResponse = Request<Body>;

#[allow(clippy::large_enum_variant)]
#[derive(Debug)]
pub enum Action {
    Invoke(InvokeRequest),
    Init,
}

#[derive(Debug)]
pub struct InvokeRequest {
    pub function_name: String,
    pub req: Request<Body>,
    pub resp_tx: Sender<LambdaResponse>,
}

#[derive(Debug, Deserialize)]
pub struct StreamingPrelude {
    #[serde(deserialize_with = "http_serde::status_code::deserialize")]
    #[serde(rename = "statusCode")]
    pub status_code: StatusCode,
    #[serde(deserialize_with = "http_serde::header_map::deserialize", default)]
    pub headers: HeaderMap,
    pub cookies: Vec<String>,
}

#[derive(Clone, Debug, Default, Deserialize)]
pub struct EventsRequest {
    pub events: Vec<String>,
}

/// Request tracing information
#[derive(Clone, Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Tracing {
    /// The type of tracing exposed to the extension
    pub r#type: String,
    /// The span value
    pub value: String,
}
/// Event received when there is a new Lambda invocation.
#[derive(Clone, Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct InvokeEvent {
    /// The time that the function times out
    pub deadline_ms: u64,
    /// The ID assigned to the Lambda request
    pub request_id: String,
    /// The function's Amazon Resource Name
    pub invoked_function_arn: String,
    /// The request tracing information
    pub tracing: Tracing,
}

/// Event received when a Lambda function shuts down.
#[derive(Clone, Debug, Default, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ShutdownEvent {
    /// The reason why the function terminates
    /// It can be SPINDOWN, TIMEOUT, or FAILURE
    pub shutdown_reason: String,
    /// The time that the function times out
    pub deadline_ms: u64,
}

/// Event that the extension receives in
/// either the INVOKE or SHUTDOWN phase
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "UPPERCASE", tag = "eventType")]
pub enum NextEvent {
    /// Payload when the event happens in the INVOKE phase
    Invoke(InvokeEvent),
    /// Payload when the event happens in the SHUTDOWN phase
    Shutdown(ShutdownEvent),
}

impl NextEvent {
    pub fn invoke(id: &str, event: &InvokeRequest) -> NextEvent {
        let tracing_id = event
            .req
            .headers()
            .get(AWS_XRAY_TRACE_HEADER)
            .and_then(|h| h.to_str().ok())
            .unwrap_or_default();

        let e = InvokeEvent {
            request_id: id.to_string(),
            invoked_function_arn: event.function_name.clone(),
            tracing: Tracing {
                r#type: AWS_XRAY_TRACE_HEADER.to_string(),
                value: tracing_id.to_string(),
            },
            ..Default::default()
        };

        NextEvent::Invoke(e)
    }

    pub fn shutdown(reason: &str) -> NextEvent {
        NextEvent::Shutdown(ShutdownEvent {
            shutdown_reason: reason.into(),
            ..Default::default()
        })
    }

    pub fn type_queue(&self) -> &str {
        match self {
            Self::Invoke(_) => "INVOKE",
            Self::Shutdown(_) => "SHUTDOWN",
        }
    }
}

#[allow(dead_code)]
#[derive(Clone, Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct LogBuffering {
    pub timeout_ms: usize,
    pub max_bytes: usize,
    pub max_items: usize,
}

#[allow(dead_code)]
#[derive(Clone, Debug, Deserialize)]
pub(crate) struct EventsDestination {
    pub protocol: String,
    #[serde(rename = "URI")]
    pub uri: String,
}

#[allow(dead_code)]
#[derive(Clone, Debug, Deserialize)]
pub(crate) struct SubcribeEvent {
    #[serde(rename = "schemaVersion")]
    pub schema_version: String,
    pub types: Vec<String>,
    pub buffering: Option<LogBuffering>,
    pub destination: EventsDestination,
}