Function register

lambda-extension/src/extension.rs:561–606

Initialize and register the extension in the Extensions API

(
    client: &'a Client,
    extension_name: Option<&'a str>,
    events: Option<&'a [&'a str]>,
)

/// Initialize and register the extension in the Extensions API
async fn register<'a>(
    client: &'a Client,
    extension_name: Option<&'a str>,
    events: Option<&'a [&'a str]>,
) -> Result<RegisterResponse, Error> {
    let name = match extension_name {
        Some(name) => name.into(),
        None => {
            let args: Vec<String> = std::env::args().collect();
            PathBuf::from(args[0].clone())
                .file_name()
                .expect("unexpected executable name")
                .to_str()
                .expect("unexpect executable name")
                .to_string()
        }
    };

    let events = events.unwrap_or(&["INVOKE", "SHUTDOWN"]);

    let req = requests::register_request(&name, events)?;
    let res = client.call(req).await?;
    if !res.status().is_success() {
        let err = format!("unable to register the extension: {}", res.status());
        return Err(ExtensionError::boxed(err));
    }

    let header = res
        .headers()
        .get(requests::EXTENSION_ID_HEADER)
        .ok_or_else(|| ExtensionError::boxed("missing extension id header"))
        .map_err(|e| ExtensionError::boxed(e.to_string()))?;
    let extension_id = header.to_str()?.to_string();

    let (_, body) = res.into_parts();
    let body = body.collect().await?.to_bytes();
    let response: RegisterResponseBody = serde_json::from_slice(&body)?;

    Ok(RegisterResponse {
        extension_id,
        function_name: response.function_name,
        function_version: response.function_version,
        handler: response.handler,
        account_id: response.account_id,
    })
}