Function query_remote_service_inspector

packages/server/src/api/routes.rs:5061–5119

(
    server_url: &str,
    access_token: &str,
    process_identifier: i64,
    method: &str,
    params: Value,
)

}

async fn query_remote_service_inspector(
    server_url: &str,
    access_token: &str,
    process_identifier: i64,
    method: &str,
    params: Value,
) -> Result<Value, String> {
    let endpoint = InspectorServiceEndpoint::parse(server_url)?;
    let body = json_value!({
        "processIdentifier": process_identifier,
        "method": method,
        "params": params,
    })
    .to_string();
    let request = format!(
        "POST /api/inspector/request HTTP/1.1\r\nHost: {}\r\nContent-Type: application/json\r\n{}: {}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
        endpoint.host_header(),
        crate::auth::ACCESS_TOKEN_HEADER,
        access_token,
        body.len(),
        body
    );
    let mut stream = timeout(
        INSPECTOR_AGENT_TIMEOUT,
        TcpStream::connect((endpoint.host.as_str(), endpoint.port)),
    )
    .await
    .map_err(|_| format!("Timed out connecting to published SimDeck service at {server_url}."))?
    .map_err(|error| {
        format!("Unable to connect to published SimDeck service at {server_url}: {error}")
    })?;
    stream
        .write_all(request.as_bytes())
        .await
        .map_err(|error| format!("Unable to write published inspector request: {error}"))?;

    let mut response = Vec::new();
    timeout(INSPECTOR_AGENT_TIMEOUT, stream.read_to_end(&mut response))
        .await
        .map_err(|_| format!("Timed out waiting for published inspector method {method}."))?
        .map_err(|error| format!("Unable to read published inspector response: {error}"))?;
    let response = String::from_utf8_lossy(&response);
    let (headers, body) = response
        .split_once("\r\n\r\n")
        .ok_or_else(|| "Published inspector returned malformed HTTP.".to_owned())?;
    let status_line = headers.lines().next().unwrap_or_default();
    if !status_line.contains(" 2") {
        return Err(format!(
            "Published inspector method {method} failed with {status_line}: {body}"
        ));
    }
    let value: Value = serde_json::from_str(body.trim()).map_err(|error| {
        format!("Published inspector returned malformed JSON for method {method}: {error}")
    })?;
    value
        .get("result")
        .cloned()
        .ok_or_else(|| format!("Published inspector method {method} did not include a result."))