---
schema_version: "1"
id: 18632467ac0ab2da8a0db31b019e59e346eb79b9570dc3d76606fd08ec5ee3b9
title: Stopping Request and Response Execution
collection: mulesoft
version: current
locale: en-us
portal_url: https://docs.salesforce.com/mulesoft/current/en-us/pdk/1.8/policies-pdk-configure-features-stop.md
canonical_url: https://docs.mulesoft.com/pdk/1.8/policies-pdk-configure-features-stop
source_site: docs.mulesoft.com
content_type: documentation
content_hash: 34b386733a926404f6e9541e2665b352544df37b06c3189d2b3179647f4c0d3c
description: MuleSoft Documentation Site
release: "1.8"
latest: false
---
---
product: Omni Gateway Policy Development Kit (PDK)
version: 1.8
---

# Stopping Request and Response Execution

> For the full documentation index, see: https://docs.mulesoft.com/llms.txt

Omni 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:

```Rust
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](#stop-request-execution)

- [Stop Response Execution](#stop-response-execution)

## 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:

```Rust
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"}"#))
    }
}
```

> [!IMPORTANT] 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](https://docs.mulesoft.com/pdk/1.8/policies-pdk-configure-features-share-data).

## 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:

```Rust
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:

```Rust
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

- [Implementing Your Custom Policy Features in Rust](https://docs.mulesoft.com/pdk/1.8/policies-pdk-configure-features)