Add with_headers() method to RemoteHttpPlugin (#15651)

# Objective

- fulfill the needs presented in this issue, which requires the ability
to set custom HTTP headers for responses in the Bevy Remote Protocol
server. #15551

## Solution

- Created a `Headers` struct to store custom HTTP headers as key-value
pairs.
- Added a `headers` field to the `RemoteHttpPlugin` struct.
- Implemented a `with_headers` method in `RemoteHttpPlugin` to allow
users to set custom headers.
- Passed the headers into the processing chain.

## Testing

- I added cors_headers in example/remote/server.rs and tested it with a
static html
[file](https://github.com/spacemen0/bevy/blob/test_file/test.html)

---

crates/bevy_remote/src/http.rs

@@ -17,14 +17,15 @@ use bevy_ecs::system::{Res, Resource};
 use bevy_tasks::IoTaskPool;
 use core::net::{IpAddr, Ipv4Addr};
 use http_body_util::{BodyExt as _, Full};
+pub use hyper::header::{HeaderName, HeaderValue};
 use hyper::{
  body::{Bytes, Incoming},
- header::HeaderValue,
  server::conn::http1,
  service, Request, Response,
 };
 use serde_json::Value;
 use smol_hyper::rt::{FuturesIo, SmolTimer};
+use std::collections::HashMap;
 use std::net::TcpListener;
 use std::net::TcpStream;
 
@@ -36,6 +37,37 @@ pub const DEFAULT_PORT: u16 = 15702;
 /// The default host address that Bevy will use for its server.
 pub const DEFAULT_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
 
+/// A struct that holds a collection of HTTP headers.
+///
+/// This struct is used to store a set of HTTP headers as key-value pairs, where the keys are
+/// of type [`HeaderName`] and the values are of type [`HeaderValue`].
+///
+#[derive(Debug, Resource, Clone)]
+pub struct Headers {
+ headers: HashMap<HeaderName, HeaderValue>,
+}
+
+impl Headers {
+ /// Create a new instance of `Headers`.
+ pub fn new() -> Self {
+ Self {
+ headers: HashMap::new(),
+ }
+ }
+
+ /// Add a key value pair to the `Headers` instance.
+ pub fn add(mut self, key: HeaderName, value: HeaderValue) -> Self {
+ self.headers.insert(key, value);
+ self
+ }
+}
+
+impl Default for Headers {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+
 /// Add this plugin to your [`App`] to allow remote connections over HTTP to inspect and modify entities.
 /// It requires the [`RemotePlugin`](super::RemotePlugin).
 ///
@@ -44,18 +76,40 @@ pub const DEFAULT_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
 /// The defaults are:
 /// - [`DEFAULT_ADDR`] : 127.0.0.1.
 /// - [`DEFAULT_PORT`] : 15702.
+///
+/// /// # Example
+///
+/// ```ignore
+///
+/// // Create CORS headers
+/// let cors_headers = Headers::new()
+/// .add(HeaderName::from_static("Access-Control-Allow-Origin"), HeaderValue::from_static("*"))
+/// .add(HeaderName::from_static("Access-Control-Allow-Headers"), HeaderValue::from_static("Content-Type, Authorization"));
+///
+/// // Create the Bevy app and add the RemoteHttpPlugin with CORS headers
+/// fn main() {
+/// App::new()
+/// .add_plugins(DefaultPlugins)
+/// .add_plugins(RemoteHttpPlugin::default()
+/// .with_headers(cors_headers))
+/// .run();
+/// }
+/// ```
 pub struct RemoteHttpPlugin {
  /// The address that Bevy will bind to.
  address: IpAddr,
  /// The port that Bevy will listen on.
  port: u16,
+ /// The headers that Bevy will include in its HTTP responses
+ headers: Headers,
 }
 
 impl Default for RemoteHttpPlugin {
  fn default() -> Self {
  Self {
  address: DEFAULT_ADDR,
  port: DEFAULT_PORT,
+ headers: Headers::new(),
  }
  }
 }
@@ -64,6 +118,7 @@ impl Plugin for RemoteHttpPlugin {
  fn build(&self, app: &mut App) {
  app.insert_resource(HostAddress(self.address))
  .insert_resource(HostPort(self.port))
+ .insert_resource(HostHeaders(self.headers.clone()))
  .add_systems(Startup, start_http_server);
  }
 }
@@ -75,13 +130,34 @@ impl RemoteHttpPlugin {
  self.address = address.into();
  self
  }
-
  /// Set the remote port that the server will listen on.
  #[must_use]
  pub fn with_port(mut self, port: u16) -> Self {
  self.port = port;
  self
  }
+ /// Set the extra headers that the response will include.
+ #[must_use]
+ pub fn with_headers(mut self, headers: Headers) -> Self {
+ self.headers = headers;
+ self
+ }
+ /// Add a single header to the response headers.
+ #[must_use]
+ pub fn with_header(
+ mut self,
+ name: impl TryInto<HeaderName>,
+ value: impl TryInto<HeaderValue>,
+ ) -> Self {
+ let Ok(header_name) = name.try_into() else {
+ panic!("Invalid header name")
+ };
+ let Ok(header_value) = value.try_into() else {
+ panic!("Invalid header value")
+ };
+ self.headers = self.headers.add(header_name, header_value);
+ self
+ }
 }
 
 /// A resource containing the IP address that Bevy will host on.
@@ -98,17 +174,24 @@ pub struct HostAddress(pub IpAddr);
 #[derive(Debug, Resource)]
 pub struct HostPort(pub u16);
 
+/// A resource containing the headers that Bevy will include in its HTTP responses.
+///
+#[derive(Debug, Resource)]
+struct HostHeaders(pub Headers);
+
 /// A system that starts up the Bevy Remote Protocol HTTP server.
 fn start_http_server(
  request_sender: Res<BrpSender>,
  address: Res<HostAddress>,
  remote_port: Res<HostPort>,
+ headers: Res<HostHeaders>,
 ) {
  IoTaskPool::get()
  .spawn(server_main(
  address.0,
  remote_port.0,
  request_sender.clone(),
+ headers.0.clone(),
  ))
  .detach();
 }
@@ -118,25 +201,29 @@ async fn server_main(
  address: IpAddr,
  port: u16,
  request_sender: Sender<BrpMessage>,
+ headers: Headers,
 ) -> AnyhowResult<()> {
  listen(
  Async::<TcpListener>::bind((address, port))?,
  &request_sender,
+ &headers,
  )
  .await
 }
 
 async fn listen(
  listener: Async<TcpListener>,
  request_sender: &Sender<BrpMessage>,
+ headers: &Headers,
 ) -> AnyhowResult<()> {
  loop {
  let (client, _) = listener.accept().await?;
 
  let request_sender = request_sender.clone();
+ let headers = headers.clone();
  IoTaskPool::get()
  .spawn(async move {
- let _ = handle_client(client, request_sender).await;
+ let _ = handle_client(client, request_sender, headers).await;
  })
  .detach();
  }
@@ -145,12 +232,15 @@ async fn listen(
 async fn handle_client(
  client: Async<TcpStream>,
  request_sender: Sender<BrpMessage>,
+ headers: Headers,
 ) -> AnyhowResult<()> {
  http1::Builder::new()
  .timer(SmolTimer::new())
  .serve_connection(
  FuturesIo::new(client),
- service::service_fn(|request| process_request_batch(request, &request_sender)),
+ service::service_fn(|request| {
+ process_request_batch(request, &request_sender, &headers)
+ }),
  )
  .await?;
 
@@ -162,6 +252,7 @@ async fn handle_client(
 async fn process_request_batch(
  request: Request<Incoming>,
  request_sender: &Sender<BrpMessage>,
+ headers: &Headers,
 ) -> AnyhowResult<Response<Full<Bytes>>> {
  let batch_bytes = request.into_body().collect().await?.to_bytes();
  let batch: Result<BrpBatch, _> = serde_json::from_slice(&batch_bytes);
@@ -198,6 +289,9 @@ async fn process_request_batch(
  hyper::header::CONTENT_TYPE,
  HeaderValue::from_static("application/json"),
  );
+ for (key, value) in &headers.headers {
+ response.headers_mut().insert(key, value.clone());
+ }
  Ok(response)
 }