Function fetch_metro_resource

packages/server/src/devtools.rs:914–990

Reverse-proxies a Metro HTTP path over the SimDeck origin. The upstream request omits the browser `Origin` so Metro's dev-middleware does not reject DevTools resources.

(
    port: u16,
    path: &str,
    query: Option<&str>,
    method: &str,
    body: Option<&[u8]>,
    content_type: Option<&str>,
)

/// request omits the browser `Origin` so Metro's dev-middleware does not reject
/// DevTools resources.
pub async fn fetch_metro_resource(
    port: u16,
    path: &str,
    query: Option<&str>,
    method: &str,
    body: Option<&[u8]>,
    content_type: Option<&str>,
) -> Result<ProxiedAsset, String> {
    if !is_metro_proxy_path(path) {
        return Err("Not a safe Metro proxy path.".to_owned());
    }
    if !is_metro_proxy_method(method) {
        return Err("Not an allowed Metro proxy method.".to_owned());
    }
    let target = match query {
        Some(query) => format!("{path}?{query}"),
        None => path.to_owned(),
    };
    let body = body.unwrap_or(&[]);
    let (address, mut stream) =
        connect_loopback_devtools_service(port, METRO_ASSET_TIMEOUT, "Metro").await?;
    let mut request = format!(
        "{method} {target} HTTP/1.1\r\nHost: {address}\r\nAccept: */*\r\nConnection: close\r\n"
    );
    if !body.is_empty() {
        request.push_str(&format!("Content-Length: {}\r\n", body.len()));
        if let Some(content_type) = content_type {
            request.push_str(&format!("Content-Type: {content_type}\r\n"));
        }
    }
    request.push_str("\r\n");
    timeout(METRO_ASSET_TIMEOUT, stream.write_all(request.as_bytes()))
        .await
        .map_err(|_| "Timed out requesting Metro asset.".to_owned())?
        .map_err(|error| format!("Unable to request Metro asset: {error}"))?;
    if !body.is_empty() {
        timeout(METRO_ASSET_TIMEOUT, stream.write_all(body))
            .await
            .map_err(|_| "Timed out writing Metro request body.".to_owned())?
            .map_err(|error| format!("Unable to write Metro request body: {error}"))?;
    }

    let mut response = Vec::new();
    let mut chunk = [0_u8; 16384];
    loop {
        let count = timeout(METRO_ASSET_TIMEOUT, stream.read(&mut chunk))
            .await
            .map_err(|_| "Timed out reading Metro asset.".to_owned())?
            .map_err(|error| format!("Unable to read Metro asset: {error}"))?;
        if count == 0 {
            break;
        }
        response.extend_from_slice(&chunk[..count]);
        if response.len() > METRO_ASSET_MAX_BYTES {
            return Err("Metro asset exceeded the size limit.".to_owned());
        }
        if response_has_complete_body(&response) {
            break;