Contact Us 1-800-596-4880
  1. Homepage
  2. Flex Gateway Policy Development Kit (PDK) (1.7)
  3. Developing Custom Policies
  4. Implementing Your Custom Policy Features in Rust

  5. Stopping Request and Response Execution

Stopping Request and Response Execution

Flex Gateway Policy Development Kit (PDK) enables you to send early responses during the request and response execution to terminate the execution flow.

To intercept and stop a request or response, return a Response object from your on_request or on_response wrapped functions:

Response::new(401)
    .with_headers(vec![("WWW-Authenticate".to_string(), "Bearer realm=\"oauth2\"".to_string())])
    .with_body(r#"{ "error": "token was not present"}"#)

To return the `Response`object, see:

Stop Request Execution

Block or allow requests to reach the upstream service using a Flow. A Flow in an enum value with two possible values:

  • Continue: Defines an object that is forwarded to the response.

  • Break: Aborts the request and returns the provided response.

Create a Flow as follows:

async fn request_filter(request_state: RequestState) -> Flow<()> {
    let header_state = request_state.into_headers_state().await;
    let handler = header_state.handler();
    if handler.header("authorization").is_some() {
        Flow::Continue(())
    } else {
        Flow::Break(Response::new(401)
        .with_headers(vec![("WWW-Authenticate".to_string(), "Bearer realm=\"oauth2\"".to_string())])
        .with_body(r#"{ "error": "token was not present"}"#))
    }
}

Due to the streaming nature of proxy wasm, it is possible for an early request to partially reach the upstream service while awaiting the headers_state.into_body_state function. Avoid this is by not awaiting the body. However, this is not possible for all policies. Configure your upstream to ignore partial requests if the policy must read the body.

To avoid early responses reaching the client, see Sharing Data Between Requests and Responses.

Stop Response Execution

To send an early response during the on_response phase, return a Response object using the send_response method of the ResponseHeadersState. You can’t send an early response from the body state:

pub fn send_response(self, response: Response) {

The send_response method enables you to add a body to responses that don’t already have one. Sending an early response using the send_response method terminates the execution flow. You can’t perform any other operation after sending an early response:

async fn response_filter(state: ResponseState) {
   let state = state.into_headers_state().await;

   state.send_response(
       Response::new(200)
           .with_headers(vec![("some".to_string(), "200".to_string())])
           .with_body("Some"),
   );
}

See Also