mirror of
https://github.com/zyycn/codex-proxy-rs.git
synced 2026-11-20 08:01:46 +00:00
Expose bounded usage readers through Admin, Store, Runtime, and SDK. Preserve snapshot consistency, coverage metadata, cancellation, and parent-call cleanup. Co-authored-by: Zyy <zyycn@users.noreply.github.com> Co-authored-by: Codex <noreply@openai.com>
648 lines
31 KiB
Rust
648 lines
31 KiB
Rust
//! 中间件测试插件子进程入口及异常退出清理辅助
|
|
|
|
mod http_resources;
|
|
mod outbound;
|
|
mod usage_data;
|
|
|
|
use gateway_plugin_sdk::{
|
|
Capability, ContributionDeclaration, Contributions, Stage,
|
|
client::{MiddlewarePlugin, PluginSession, RequestCall, SessionConfig},
|
|
};
|
|
|
|
#[tokio::main(flavor = "current_thread")]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
let mut session = PluginSession::accept(
|
|
tokio::io::stdin(),
|
|
tokio::io::stdout(),
|
|
SessionConfig::default(),
|
|
)
|
|
.await?;
|
|
let mode = session.handshake().configuration["mode"]
|
|
.as_str()
|
|
.unwrap_or("map")
|
|
.to_owned();
|
|
let configuration = session.handshake().configuration.clone();
|
|
if let Some(budgets) = configuration.get("call_budgets_ms") {
|
|
session.set_call_budgets(serde_json::from_value(budgets.clone())?)?;
|
|
}
|
|
if mode == "mixed_mounts" {
|
|
let contributes = Contributions::from([(
|
|
Capability::Middleware,
|
|
ContributionDeclaration {
|
|
id: "test.example.middleware".into(),
|
|
version: 6,
|
|
stages: vec![
|
|
Stage::Http,
|
|
Stage::WebSocket,
|
|
Stage::Service,
|
|
Stage::Request,
|
|
Stage::Attempt,
|
|
],
|
|
input_formats: vec![
|
|
"http".into(),
|
|
"websocket".into(),
|
|
"service".into(),
|
|
"openai".into(),
|
|
],
|
|
output_formats: vec![
|
|
"http".into(),
|
|
"websocket".into(),
|
|
"service".into(),
|
|
"openai".into(),
|
|
],
|
|
},
|
|
)]);
|
|
let plugin = MiddlewarePlugin::new(
|
|
&contributes,
|
|
move |call: gateway_plugin_sdk::client::MiddlewareCall| {
|
|
let records = configuration["records"].as_str().unwrap().to_owned();
|
|
async move {
|
|
use std::io::Write as _;
|
|
let context = call.context().clone();
|
|
let request = context.request.as_ref().expect("entry request snapshot");
|
|
assert_eq!(request.method, "POST");
|
|
assert_eq!(request.uri, "/v1/responses?fixture=1");
|
|
assert_eq!(request.http_version, "HTTP/2.0");
|
|
assert_eq!(request.peer_addr.as_deref(), Some("192.0.2.1:42000"));
|
|
assert_eq!(request.client_ip.as_deref(), Some("203.0.113.7"));
|
|
assert_eq!(request.headers.len(), 2);
|
|
assert_eq!(request.headers[1].value, b"two");
|
|
let record = |phase| {
|
|
let mut file = std::fs::OpenOptions::new()
|
|
.create(true)
|
|
.append(true)
|
|
.open(&records)
|
|
.unwrap();
|
|
writeln!(file, "{phase}:{:?}:{}", context.stage, context.instance_id)
|
|
.unwrap();
|
|
};
|
|
record("enter");
|
|
let result = call.forward().await;
|
|
record("exit");
|
|
result
|
|
}
|
|
},
|
|
)?;
|
|
session.run(plugin).await?;
|
|
return Ok(());
|
|
}
|
|
let contributes = Contributions::from([(
|
|
Capability::Middleware,
|
|
ContributionDeclaration {
|
|
id: "test.example.middleware".into(),
|
|
version: configuration["middleware_version"]
|
|
.as_u64()
|
|
.unwrap_or(6)
|
|
.try_into()?,
|
|
stages: vec![if configuration["service"] == true {
|
|
Stage::Service
|
|
} else if configuration["http"] == true {
|
|
Stage::Http
|
|
} else if configuration["websocket"] == true {
|
|
Stage::WebSocket
|
|
} else if configuration["attempt"] == true {
|
|
Stage::Attempt
|
|
} else if configuration["outbound"] == true {
|
|
Stage::Outbound
|
|
} else {
|
|
Stage::Request
|
|
}],
|
|
input_formats: vec![if configuration["service"] == true {
|
|
"service".into()
|
|
} else if configuration["http"] == true {
|
|
"http".into()
|
|
} else if configuration["websocket"] == true {
|
|
"websocket".into()
|
|
} else if configuration["outbound"] == true {
|
|
"outbound".into()
|
|
} else {
|
|
"openai".into()
|
|
}],
|
|
output_formats: vec![if configuration["service"] == true {
|
|
"service".into()
|
|
} else if configuration["http"] == true {
|
|
"http".into()
|
|
} else if configuration["websocket"] == true {
|
|
"websocket".into()
|
|
} else if configuration["outbound"] == true {
|
|
"outbound".into()
|
|
} else {
|
|
"openai".into()
|
|
}],
|
|
},
|
|
)]);
|
|
if configuration["outbound"] == true {
|
|
let plugin = MiddlewarePlugin::new(
|
|
&contributes,
|
|
move |call: gateway_plugin_sdk::client::OutboundCall| {
|
|
outbound::handle(call, configuration.clone())
|
|
},
|
|
)?;
|
|
session.run(plugin).await?;
|
|
return Ok(());
|
|
}
|
|
if configuration["service"] == true {
|
|
let plugin = MiddlewarePlugin::new(
|
|
&contributes,
|
|
move |call: gateway_plugin_sdk::client::ServiceCall| {
|
|
let mode = mode.clone();
|
|
let records = configuration["records"]
|
|
.as_str()
|
|
.map(std::path::PathBuf::from);
|
|
async move {
|
|
if mode == "onion" {
|
|
use std::io::Write as _;
|
|
let records = records.unwrap();
|
|
let mut event = serde_json::json!({
|
|
"instance":call.context.instance_id,
|
|
"operation":call.operation,
|
|
"request_id":call.request_id,
|
|
"call_id":call.call_id,
|
|
"parent_call_id":call.parent_call_id,
|
|
});
|
|
let mut record = |phase| {
|
|
event["phase"] = serde_json::json!(phase);
|
|
let mut file = std::fs::OpenOptions::new()
|
|
.create(true)
|
|
.append(true)
|
|
.open(&records)
|
|
.unwrap();
|
|
writeln!(file, "{event}").unwrap();
|
|
};
|
|
record("enter");
|
|
let result = call.forward().await;
|
|
record("exit");
|
|
return result;
|
|
}
|
|
if mode == "fault" {
|
|
let mut fault = gateway_plugin_sdk::PluginFault::new(
|
|
gateway_plugin_sdk::ErrorCode::Capacity,
|
|
"service plugin fixture error",
|
|
);
|
|
fault.details = Some(
|
|
serde_json::json!({"opaque":"unfiltered","empty":"","zero":0,"disabled":false,"missing":null}),
|
|
);
|
|
return Err(fault);
|
|
}
|
|
if let Some(records) = &records {
|
|
use std::io::Write as _;
|
|
let mut file = std::fs::OpenOptions::new()
|
|
.create(true)
|
|
.append(true)
|
|
.open(records)
|
|
.unwrap();
|
|
writeln!(file, "{}", serde_json::json!({"operation":call.operation,"request_id":call.request_id,"call_id":call.call_id,"parent_call_id":call.parent_call_id})).unwrap();
|
|
}
|
|
if mode == "block" {
|
|
struct Cleanup(std::path::PathBuf);
|
|
impl Drop for Cleanup {
|
|
fn drop(&mut self) {
|
|
std::fs::write(self.0.with_extension("closed"), b"closed").unwrap();
|
|
}
|
|
}
|
|
let _cleanup = Cleanup(records.unwrap());
|
|
call.cancellation.cancelled().await;
|
|
return Err(gateway_plugin_sdk::PluginFault::new(
|
|
gateway_plugin_sdk::ErrorCode::Cancelled,
|
|
"cancelled",
|
|
));
|
|
}
|
|
use gateway_plugin_sdk::{call::services::settings, client::ServiceResponse};
|
|
if mode == "usage_hold" && call.is::<settings::ApiKeyExists>() {
|
|
return usage_data::hold(call, records.unwrap()).await;
|
|
}
|
|
if mode == "usage_data" && call.is::<settings::ApiKeyExists>() {
|
|
return usage_data::exercise(call).await;
|
|
}
|
|
if call.is::<settings::ApiKeyExists>() && mode == "recover" {
|
|
return ServiceResponse::from_result::<settings::ApiKeyExists>(Ok(true));
|
|
}
|
|
if call.is::<settings::Load>() {
|
|
let call = call.into_typed::<settings::Load>()?;
|
|
// 同一插件再次读取服务不会递归调用自身;回调仍经过宿主服务端口
|
|
let nested = call.host.service::<settings::Load>(()).await.unwrap();
|
|
let mut output = call.next.run(()).await.unwrap();
|
|
assert_eq!(output.config_revision, nested.config_revision);
|
|
if mode == "rewrite" {
|
|
output.refresh_margin_seconds = 4321;
|
|
}
|
|
return ServiceResponse::from_result::<settings::Load>(Ok(output));
|
|
}
|
|
if call.is::<settings::Replace>() {
|
|
let mut call = call.into_typed::<settings::Replace>()?;
|
|
call.input.1.refresh_margin_seconds = 1234;
|
|
return ServiceResponse::from_result::<settings::Replace>(
|
|
call.next.run(call.input).await,
|
|
);
|
|
}
|
|
if call.is::<settings::PreviewClientProfile>() && mode == "recover" {
|
|
let call = call.into_typed::<settings::PreviewClientProfile>()?;
|
|
let error = call.next.run(call.input).await.unwrap_err();
|
|
assert_eq!(error.kind, "invalid");
|
|
assert!(!error.message.is_empty());
|
|
return ServiceResponse::from_result::<settings::PreviewClientProfile>(Ok(
|
|
serde_json::Map::new(),
|
|
));
|
|
}
|
|
call.forward().await
|
|
}
|
|
},
|
|
)?;
|
|
session.run(plugin).await?;
|
|
return Ok(());
|
|
}
|
|
if configuration["websocket"] == true {
|
|
let plugin = MiddlewarePlugin::new(
|
|
&contributes,
|
|
move |call: gateway_plugin_sdk::client::WebSocketCall| {
|
|
let mode = mode.clone();
|
|
async move {
|
|
use gateway_plugin_sdk::client::{WebSocketKind, WebSocketMessage};
|
|
assert!(
|
|
call.headers
|
|
.iter()
|
|
.any(|header| header.name == "authorization"
|
|
&& header.value == b"Bearer fixture-secret")
|
|
);
|
|
if mode == "control" {
|
|
assert_eq!(call.message.payload.collect().await?, b"custom.control");
|
|
call.sender
|
|
.send(WebSocketMessage::new(
|
|
WebSocketKind::Binary,
|
|
vec![0, 255, 1],
|
|
))
|
|
.await?;
|
|
return Ok(None);
|
|
}
|
|
let mut message = call.message;
|
|
if mode == "map" {
|
|
let bytes = message.payload.collect().await?.to_ascii_uppercase();
|
|
message = WebSocketMessage::new(message.kind, bytes);
|
|
}
|
|
let result = call.next.run(message).await?;
|
|
Ok(result)
|
|
}
|
|
},
|
|
)?;
|
|
session.run(plugin).await?;
|
|
return Ok(());
|
|
}
|
|
if configuration["http"] == true {
|
|
let plugin = MiddlewarePlugin::new(
|
|
&contributes,
|
|
move |mut call: gateway_plugin_sdk::client::HttpCall| {
|
|
let mode = mode.clone();
|
|
async move {
|
|
use gateway_plugin_sdk::client::{HttpBody, HttpFrame, HttpResponse};
|
|
if mode == "upload_resources" {
|
|
http_resources::check_upload_lifecycle(&call.host).await?;
|
|
return call.next.run(call.request).await;
|
|
}
|
|
if mode == "sequential_uploads" {
|
|
for index in 0_u32..40 {
|
|
let expected = index.to_be_bytes().to_vec();
|
|
let request = gateway_plugin_sdk::client::HttpRequest {
|
|
settings: call.request.settings.clone(),
|
|
method: "POST".into(),
|
|
uri: "/child".into(),
|
|
version: call.request.version,
|
|
headers: Vec::new(),
|
|
timeout_ms: call.request.timeout_ms,
|
|
body: HttpBody::from_bytes(expected.clone())
|
|
.map_frames(|frame| Ok(Some(frame))),
|
|
};
|
|
let mut response = call.host.dispatch_http(request).await?;
|
|
let mut bytes = Vec::new();
|
|
while let Some(frame) = response.body.read().await? {
|
|
match frame {
|
|
HttpFrame::Data(chunk) => bytes.extend(chunk),
|
|
HttpFrame::Trailers(_) => panic!("unexpected trailers"),
|
|
}
|
|
}
|
|
assert_eq!(bytes, expected);
|
|
assert!(response.body.read().await?.is_none());
|
|
response.body.close().await?;
|
|
}
|
|
return call.next.run(call.request).await;
|
|
}
|
|
if mode == "close_response_body" || mode == "read_response_body" {
|
|
let mut response = call.next.run(call.request).await?;
|
|
if mode == "read_response_body" {
|
|
assert!(
|
|
matches!(response.body.read().await?, Some(HttpFrame::Data(bytes)) if bytes == b"original")
|
|
);
|
|
assert!(response.body.read().await?.is_none());
|
|
return Ok(response);
|
|
}
|
|
response.body.close().await?;
|
|
response.body.close().await?;
|
|
response.body = HttpBody::from_bytes(b"replacement".to_vec());
|
|
return Ok(response);
|
|
}
|
|
if mode == "settings" {
|
|
if call.context.instance_id == "dispatch-a" {
|
|
assert_eq!(call.request.timeout_ms, Some(60_000));
|
|
call.request.timeout_ms = Some(90_000);
|
|
assert!(call.request.settings["min_codex_cli_version"].is_null());
|
|
call.request.settings["min_codex_cli_version"] =
|
|
serde_json::json!("0.40.0");
|
|
call.request.settings["max_account_rotations"] = serde_json::json!(0);
|
|
} else {
|
|
assert_eq!(call.request.timeout_ms, Some(90_000));
|
|
assert_eq!(
|
|
call.settings_sources["http_timeout"]["change"]["instance_id"],
|
|
"dispatch-a"
|
|
);
|
|
call.request.timeout_ms = None;
|
|
assert_eq!(call.request.settings["min_codex_cli_version"], "0.40.0");
|
|
assert_eq!(
|
|
call.settings_sources["overrides"]["min_codex_cli_version"]["instance_id"],
|
|
"dispatch-a"
|
|
);
|
|
call.request.settings["min_codex_cli_version"] =
|
|
serde_json::Value::Null;
|
|
call.request.settings["responses_max_decompressed_body_bytes"] =
|
|
serde_json::json!(8192);
|
|
}
|
|
return call.host.dispatch_http(call.request).await;
|
|
}
|
|
if mode == "session-error" || mode == "session-cancelled" {
|
|
use gateway_plugin_sdk::{ErrorCode, PluginFault};
|
|
let code = if mode == "session-error" {
|
|
ErrorCode::PermissionDenied
|
|
} else {
|
|
ErrorCode::Cancelled
|
|
};
|
|
return call
|
|
.upgrade(vec!["test-session".into()], move |_session| async move {
|
|
Err(PluginFault::new(
|
|
code,
|
|
"private-plugin-error-must-not-be-logged",
|
|
))
|
|
})
|
|
.await;
|
|
}
|
|
if mode == "callbacks" {
|
|
let host = call.host.clone();
|
|
return call.upgrade(vec!["test-session".into()], |mut session| async move {
|
|
use gateway_plugin_sdk::client::{WebSocketKind, WebSocketMessage, SessionError};
|
|
session.sender.send(WebSocketMessage::new(WebSocketKind::Text, b"ready".to_vec())).await?;
|
|
while let Some(message) = session.receive().await? {
|
|
let command: serde_json::Value = serde_json::from_slice(&message.payload.collect().await?).unwrap();
|
|
let payload = command.get("body").map(|body| serde_json::to_vec(body).unwrap()).unwrap_or_default();
|
|
let result = host.call(command["method"].as_str().unwrap(), command["params"].clone(), payload).await.map_err(SessionError::into_plugin_fault)?;
|
|
let reply = serde_json::json!({"result":result.result,"payload_bytes":result.payload.len()});
|
|
session.sender.send(WebSocketMessage::new(WebSocketKind::Text, serde_json::to_vec(&reply).unwrap())).await?;
|
|
}
|
|
Ok(())
|
|
}).await;
|
|
}
|
|
if mode == "upgrade" {
|
|
return call.upgrade(vec!["test-session".into()], |mut session| async move {
|
|
use gateway_plugin_sdk::client::{WebSocketKind, WebSocketMessage};
|
|
let sender = session.sender.clone();
|
|
for index in 0..3 {
|
|
let receive = session.receive();
|
|
tokio::pin!(receive);
|
|
tokio::select! {
|
|
message = &mut receive => panic!("receive must wait before greeting: {}", message.is_ok()),
|
|
() = tokio::time::sleep(std::time::Duration::from_millis(20)) => {},
|
|
}
|
|
if index == 0 {
|
|
sender.send(WebSocketMessage::new(WebSocketKind::Text, b"ready".to_vec())).await?;
|
|
}
|
|
// 模拟模型任务先完成导致 select 丢弃 receive;下一次等待必须继续取同一条消息
|
|
}
|
|
if let Some(message) = session.receive().await? { sender.send(message).await?; }
|
|
for index in 0..32 {
|
|
let Some(mut message) = session.receive().await? else { break; };
|
|
let payload = if index % 2 == 0 {
|
|
message.payload.collect().await?
|
|
} else {
|
|
let bytes = message.payload.read().await?.unwrap_or_default();
|
|
message.payload.close().await?;
|
|
bytes
|
|
};
|
|
sender.send(WebSocketMessage::new(message.kind, payload)).await?;
|
|
}
|
|
session.close(Some(1000), "done".into()).await
|
|
}).await;
|
|
}
|
|
if mode == "dispatch" || mode == "dispatch_upload" {
|
|
call.request.headers.push(
|
|
gateway_plugin_sdk::call::middleware::MiddlewareHeader {
|
|
name: "x-dispatch-instance".into(),
|
|
value: call.context.instance_id.as_bytes().to_vec(),
|
|
},
|
|
);
|
|
if mode == "dispatch_upload" {
|
|
call.request.body = call.request.body.map_frames(|frame| {
|
|
Ok(Some(match frame {
|
|
HttpFrame::Data(bytes) => {
|
|
HttpFrame::Data(bytes.to_ascii_uppercase())
|
|
}
|
|
HttpFrame::Trailers(headers) => HttpFrame::Trailers(headers),
|
|
}))
|
|
});
|
|
}
|
|
return call.host.dispatch_http(call.request).await;
|
|
}
|
|
if mode == "identity" {
|
|
return call.next.run(call.request).await;
|
|
}
|
|
if mode == "short" {
|
|
return Ok(HttpResponse::new(
|
|
418,
|
|
HttpBody::from_bytes(b"plugin route".to_vec()),
|
|
));
|
|
}
|
|
assert!(
|
|
call.request
|
|
.headers
|
|
.iter()
|
|
.any(|header| header.name == "authorization"
|
|
&& header.value == b"Bearer fixture-secret")
|
|
);
|
|
call.request.uri = "/rewritten?encoded=%2F".into();
|
|
call.request.method = "PATCH".into();
|
|
call.request.timeout_ms = None;
|
|
if mode == "upload" {
|
|
call.request.body = call.request.body.map_frames(|frame| {
|
|
Ok(Some(match frame {
|
|
HttpFrame::Data(bytes) => {
|
|
HttpFrame::Data(bytes.to_ascii_uppercase())
|
|
}
|
|
HttpFrame::Trailers(headers) => HttpFrame::Trailers(headers),
|
|
}))
|
|
});
|
|
}
|
|
let mut response = call.next.run(call.request).await?;
|
|
response
|
|
.headers
|
|
.push(gateway_plugin_sdk::call::middleware::MiddlewareHeader {
|
|
name: "x-http-plugin".into(),
|
|
value: b"active".to_vec(),
|
|
});
|
|
if mode == "map" {
|
|
response.body = response.body.map_frames(|frame| {
|
|
Ok(Some(match frame {
|
|
HttpFrame::Data(bytes) => {
|
|
HttpFrame::Data(bytes.to_ascii_uppercase())
|
|
}
|
|
HttpFrame::Trailers(headers) => HttpFrame::Trailers(headers),
|
|
}))
|
|
});
|
|
}
|
|
Ok(response)
|
|
}
|
|
},
|
|
)?;
|
|
session.run(plugin).await?;
|
|
return Ok(());
|
|
}
|
|
let plugin = MiddlewarePlugin::new(&contributes, move |mut call: RequestCall| {
|
|
let mode = mode.clone();
|
|
let configuration = configuration.clone();
|
|
async move {
|
|
if mode == "declare" {
|
|
call.request
|
|
.replace_body(serde_json::to_vec(&configuration["body"]).unwrap());
|
|
call.request.declare_capabilities(
|
|
serde_json::from_value(configuration["capabilities"].clone()).unwrap(),
|
|
);
|
|
}
|
|
if mode == "credentials" {
|
|
assert!(
|
|
call.request
|
|
.head
|
|
.headers
|
|
.iter()
|
|
.any(|header| header.name == "authorization"
|
|
&& header.value == b"Bearer private")
|
|
);
|
|
assert!(
|
|
call.request
|
|
.head
|
|
.headers
|
|
.iter()
|
|
.any(|header| header.name == "connection")
|
|
);
|
|
call.request.remove_header("authorization");
|
|
call.request
|
|
.append_header("authorization", b"Bearer rewritten".to_vec());
|
|
}
|
|
if mode == "headers" {
|
|
call.request
|
|
.append_header("x-sdk-request", b"active".to_vec());
|
|
}
|
|
if mode == "settings" {
|
|
assert_eq!(
|
|
call.request.head.settings,
|
|
configuration["expected_settings"]
|
|
);
|
|
if let Some(expected) = configuration.get("expected_fast_source") {
|
|
let sources = &call.request.head.settings_sources["execution"];
|
|
assert!(sources.get("disable_fast").is_none());
|
|
assert!(sources["input"].get("disable_fast").is_none());
|
|
assert_eq!(sources["input"]["fast_mode"], "default");
|
|
assert_eq!(&sources["fast_mode"], expected);
|
|
}
|
|
if let Some(settings) = configuration.get("settings") {
|
|
call.request.head.settings = settings.clone();
|
|
}
|
|
}
|
|
if mode == "inspect" && !call.request.body.is_empty() {
|
|
// 读取和解析只能作用于副本,不能把解析结果写回未改写的正文
|
|
assert!(serde_json::from_slice::<serde_json::Value>(&call.request.body).is_ok());
|
|
}
|
|
if mode == "rejected" {
|
|
let mut fault = gateway_plugin_sdk::PluginFault::new(
|
|
gateway_plugin_sdk::ErrorCode::Rejected,
|
|
"plugin rejection details",
|
|
);
|
|
fault.details = Some(serde_json::json!({"reason":"fixture","disabled":false}));
|
|
return Err(fault);
|
|
}
|
|
if mode == "downstream_error" {
|
|
let error = match call.next.run(call.request).await {
|
|
Ok(_) => panic!("expected downstream failure"),
|
|
Err(error) => error,
|
|
};
|
|
let fault = &error;
|
|
assert_eq!(
|
|
fault.message,
|
|
configuration["expected_message"].as_str().unwrap()
|
|
);
|
|
if configuration["remote_error"] == true {
|
|
assert_eq!(
|
|
fault.details.as_ref().unwrap(),
|
|
&configuration["expected_details"]
|
|
);
|
|
assert_eq!(fault.code, gateway_plugin_sdk::ErrorCode::Rejected);
|
|
} else {
|
|
assert_eq!(
|
|
fault.details.as_ref().unwrap()["provider"]["response"]["body"],
|
|
configuration["expected_body"]
|
|
);
|
|
assert_eq!(fault.http_status, Some(429));
|
|
assert_eq!(fault.send_state, gateway_plugin_sdk::SendState::Sent);
|
|
}
|
|
return Err(error);
|
|
}
|
|
let mut response = call.next.run(call.request).await?;
|
|
match mode.as_str() {
|
|
"facts" => {
|
|
let path = configuration["facts_marker"].as_str().unwrap().to_owned();
|
|
std::fs::write(
|
|
&path,
|
|
format!("{}\n", serde_json::to_string(&response.metadata).unwrap()),
|
|
)
|
|
.unwrap();
|
|
// 修改快照不能替换原执行的账号或费用
|
|
response.metadata.as_mut().unwrap().provider_account_id =
|
|
"changed-snapshot".into();
|
|
response.body = response.body.with_facts()?.map_frames(move |mut frame| {
|
|
use std::io::Write;
|
|
let facts = frame.facts.as_mut().unwrap();
|
|
let mut file = std::fs::OpenOptions::new()
|
|
.append(true)
|
|
.open(&path)
|
|
.unwrap();
|
|
writeln!(file, "{}", serde_json::to_string(facts).unwrap()).unwrap();
|
|
facts.host.as_mut().unwrap().costs.clear();
|
|
Ok(vec![frame])
|
|
})?;
|
|
}
|
|
"passthrough" | "declare" | "settings" | "parameters" => {}
|
|
"inspect" => {
|
|
response.body = response.body.inspect_frames(|frame| {
|
|
assert!(!frame.payload.is_empty());
|
|
})?;
|
|
}
|
|
"credentials" => {
|
|
assert!(
|
|
response
|
|
.headers
|
|
.iter()
|
|
.any(|header| header.name == "set-cookie"
|
|
&& header.value == b"test-hidden=kept")
|
|
);
|
|
response.remove_header("set-cookie");
|
|
response.append_header("set-cookie", b"rewritten=true".to_vec());
|
|
}
|
|
"headers" => response.append_header("x-sdk-response", b"active".to_vec()),
|
|
_ => {
|
|
response.append_header("x-sdk-plugin", b"active".to_vec());
|
|
response.body = response.body.map_frames(|mut frame| {
|
|
frame.payload.push(b' ');
|
|
Ok(vec![frame])
|
|
})?;
|
|
}
|
|
}
|
|
Ok(response)
|
|
}
|
|
})?;
|
|
session.run(plugin).await?;
|
|
Ok(())
|
|
}
|