Method poll

lambda-runtime/src/layers/api_client.rs:71–131

(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>)

    type Output = Result<(), BoxError>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> task::Poll<Self::Output> {
        // NOTE: We loop here to directly poll the second future once the first has finished.
        task::Poll::Ready(loop {
            match self.as_mut().project() {
                RuntimeApiClientFutureProj::First(fut, client) => match ready!(fut.poll(cx)) {
                    Ok(ok) => {
                        // NOTE: We use 'client.call_boxed' here to obtain a future with static
                        // lifetime. Otherwise, this future would need to be self-referential...
                        let next_fut = client
                            .call(ok)
                            .map_err(|err| {
                                error!(error = ?err, "failed to send request to Lambda Runtime API");
                                err
                            })
                            .boxed();
                        self.set(RuntimeApiClientFuture::Second(next_fut));
                    }
                    Err(err) => {
                        log_or_print!(
                            tracing: tracing::error!(error = ?err, "failed to build Lambda Runtime API request"),
                            fallback: eprintln!("failed to build Lambda Runtime API request: {err:?}")
                        );
                        break Err(err);
                    }
                },
                RuntimeApiClientFutureProj::Second(fut) => match ready!(fut.poll(cx)) {
                    Ok(resp) if !resp.status().is_success() => {
                        let status = resp.status();

                        // TODO
                        // we should consume the response body of the call in order to give a more specific message.
                        // https://github.com/aws/aws-lambda-rust-runtime/issues/1110

                        log_or_print!(
                            tracing: tracing::error!(status = %status, "Lambda Runtime API returned non-200 response"),
                            fallback: eprintln!("Lambda Runtime API returned non-200 response: status={status}")
                        );

                        // Adding more information on top of 410 Gone, to make it more clear since we cannot access the body of the message
                        if status == 410 {
                            log_or_print!(
                                tracing: tracing::error!("Lambda function timeout!"),
                                fallback: eprintln!("Lambda function timeout!")
                            );
                        }

                        // Return Ok to maintain existing contract - runtime continues despite API errors
                        break Ok(());
                    }
                    Ok(_) => break Ok(()),
                    Err(err) => {
                        log_or_print!(
                            tracing: tracing::error!(error = ?err, "Lambda Runtime API request failed"),
                            fallback: eprintln!("Lambda Runtime API request failed: {err:?}")
                        );
                        break Err(err);
                    }
                },