Method poll

aiscript-runtime/src/endpoint.rs:244–579

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

    type Output = Result<Response, Infallible>;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let config = Config::get();
        loop {
            match &mut self.state {
                ProcessingState::ValidatingAuth => {
                    if self.endpoint.annotation.is_jwt_auth() {
                        self.jwt_claim = {
                            let future = self
                                .request
                                .extract_parts::<TypedHeader<Authorization<Bearer>>>();
                            tokio::pin!(future);
                            match future.poll(cx) {
                                Poll::Pending => return Poll::Pending,
                                Poll::Ready(Ok(bearer)) => {
                                    let key =
                                        DecodingKey::from_secret(config.auth.jwt.secret.as_bytes());
                                    let validation = Validation::new(Algorithm::HS256);
                                    // Decode token
                                    let token_data: TokenData<Value> =
                                        decode(bearer.token(), &key, &validation).unwrap();
                                    Some(token_data.claims)
                                }
                                Poll::Ready(Err(e)) => {
                                    return Poll::Ready(Ok(ServerError::AuthenticationError {
                                        message: e.to_string(),
                                    }
                                    .into_response()));
                                }
                            }
                        };
                    } else {
                        // Baisc auth
                        // Extract the token from the authorization header
                        let future = self
                            .request
                            .extract_parts::<TypedHeader<Authorization<Basic>>>();
                        tokio::pin!(future);
                        match future.poll(cx) {
                            Poll::Pending => return Poll::Pending,
                            Poll::Ready(Ok(basic)) => {
                                if let Some(b) = config.auth.basic.as_ref() {
                                    if *b.username != basic.username()
                                        || *b.password != basic.password()
                                    {
                                        return Poll::Ready(Ok(ServerError::AuthenticationError {
                                            message: "Invalid username or password".to_string(),
                                        }
                                        .into_response()));
                                    }
                                } else {
                                    return Poll::Ready(Ok(ServerError::AuthenticationError {
                                        message: "Basic auth is not configured".to_string(),
                                    }
                                    .into_response()));
                                }
                            }
                            Poll::Ready(Err(e)) => {
                                return Poll::Ready(Ok(ServerError::AuthenticationError {