mirror of
https://github.com/zyycn/codex-proxy-rs.git
synced 2026-11-20 08:01:46 +00:00
* feat(keys): add explicit budget windows with safe retries Add revision-checked daily and weekly windows across admission, settlement and queries. Reuse the existing budget ledger for atomic window updates, latest-operation replay and audit records. Expose typed SDK callbacks while keeping account associations and cycle decisions in plugins. Refs #658 Co-authored-by: Codex <noreply@openai.com> * fix(keys): preserve budget accounting across window changes Keep restored balances when historical charges are unavailable and reject window changes that would require those charges. Honor future start times after release and report actual spending windows to peers. Require an explicit null to release a window through the plugin SDK. Co-authored-by: Codex <noreply@openai.com> * fix(plugins): preserve budget window precision across SDK calls Co-authored-by: Codex <noreply@openai.com> --------- Co-authored-by: Zyy <zyycn@users.noreply.github.com> Co-authored-by: Codex <noreply@openai.com>
592 lines
23 KiB
Rust
592 lines
23 KiB
Rust
//! 验证插件 Key 预算回调复用宿主服务、权限与提交审计
|
|
|
|
use std::{sync::Arc, time::Duration};
|
|
|
|
use gateway_admin::{
|
|
PluginManagementService,
|
|
model::{
|
|
AdminError, MutationContext,
|
|
client_keys::ResetClientKeyBudget,
|
|
plugin_client_keys::{PluginClientKeyFacts, PluginClientKeyListQuery, PluginClientKeyPage},
|
|
plugin_resources::PluginResourceOwner,
|
|
plugins::management::PluginManagementRequest,
|
|
},
|
|
ports::plugin_client_keys::PluginClientKeyAccess,
|
|
};
|
|
use gateway_core::{
|
|
lifecycle::CancellationToken,
|
|
policy::ClientApiKeyId,
|
|
task::{WorkerContribution, WorkerDaemonContext, WorkerRunnable},
|
|
};
|
|
use serde_json::{Value, json};
|
|
use tokio::{sync::Notify, time::timeout};
|
|
|
|
use crate::support::{environment::Environment, native};
|
|
|
|
#[tokio::test]
|
|
async fn plugin_process_manages_native_budget_through_client_key_service() {
|
|
{
|
|
let Some(environment) = Environment::create().await else {
|
|
eprintln!("SKIP: plugin integration environment absent");
|
|
return;
|
|
};
|
|
let key = ClientApiKeyId::new("key_budget").unwrap();
|
|
let plaintext = format!("sk_{}", "a".repeat(43));
|
|
environment.client_key(key.as_str(), &plaintext).await;
|
|
environment.seed_client_key_budget(key.as_str()).await;
|
|
let store = environment.store.admin_ports().client_keys();
|
|
let before = store.get_client_key(&key).await.unwrap().unwrap();
|
|
environment.install_plugin(json!({
|
|
"management_registration":{"routes":[{"method":"POST","path":"reset","request_content_types":[],"response_content_types":["application/json"]}]},
|
|
"data_queries":[
|
|
{"method":"host.keys.list","query":{"limit":10}},
|
|
{"method":"host.keys.reset_budget","query":{"client_key_id":"key_budget","period":"weekly"}},
|
|
{"method":"host.keys.reset_budget","query":{"client_key_id":"key_budget"}},
|
|
{"method":"host.keys.reset_budget","query":{"client_key_id":"key_budget","period":"monthly"}},
|
|
{"method":"host.keys.reset_budget","query":{"client_key_id":"key_budget","period":"all","instance_id":"forged"}},
|
|
{"method":"host.keys.reset_budget","query":{"client_key_id":"missing","period":"all"}},
|
|
{"method":"host.keys.get_budget","query":{"client_key_id":"key_budget"}},
|
|
{"method":"host.keys.update_budget_limits","query":{"client_key_id":"key_budget","weekly_limit_usd":"25.5"}},
|
|
{"method":"host.keys.get_budget","query":{"client_key_id":"key_budget"}},
|
|
{"method":"host.keys.update_budget_limits","query":{"client_key_id":"key_budget"}},
|
|
{"method":"host.keys.update_budget_limits","query":{"client_key_id":"key_budget","daily_limit_usd":"-1"}},
|
|
{"method":"host.keys.get_budget","query":{"client_key_id":"missing"}},
|
|
{"method":"host.keys.update_budget_limits","query":{"client_key_id":"missing","weekly_limit_usd":"2"}},
|
|
{"method":"host.keys.update_budget_limits","query":{"client_key_id":"key_budget","max_concurrency":1}},
|
|
{"method":"host.keys.get_budget","query":{"client_key_id":"key_budget","instance_id":"forged"}}
|
|
]
|
|
})).await;
|
|
let (runtime, core) = environment.runtime().await;
|
|
let access = gateway_admin::initialize_plugin_client_keys(
|
|
native::admin_registry(),
|
|
store.clone(),
|
|
core.snapshot_control(),
|
|
);
|
|
runtime.bind_client_key_ports(&access).unwrap();
|
|
let service = PluginManagementService::new(
|
|
runtime.clone(),
|
|
environment.store.admin_ports().plugins(),
|
|
core.snapshots(),
|
|
);
|
|
let view = service.views().await.unwrap().remove(0);
|
|
let reply = service
|
|
.handle(
|
|
&view.target,
|
|
PluginManagementRequest {
|
|
request_context: None,
|
|
headers: Vec::new(),
|
|
method: "POST".into(),
|
|
path: "reset".into(),
|
|
query: String::new(),
|
|
content_type: None,
|
|
body: vec![],
|
|
request_id: "budget-fixture".into(),
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let results: Vec<Value> = serde_json::from_slice(&reply.body).unwrap();
|
|
let after = store.get_client_key(&key).await.unwrap().unwrap();
|
|
let audits = environment.audit_requests("reset_budget").await;
|
|
{
|
|
assert_eq!(
|
|
results[0],
|
|
json!({"keys":[{"id":"key_budget","name":"fixture key_budget","enabled":true}],"next_cursor":null})
|
|
);
|
|
assert_eq!(results[1], json!({"client_key_id":"key_budget"}));
|
|
for result in &results[2..5] {
|
|
assert_eq!(result, &json!({"error":"invalid_input"}));
|
|
}
|
|
assert_eq!(results[5], json!({"error":"rejected"}));
|
|
assert_eq!(after.budget.weekly_used_usd.canonical(), "0");
|
|
assert_eq!(after.budget.daily_used_usd, before.budget.daily_used_usd);
|
|
assert_eq!(
|
|
after.budget.limits.daily_usd,
|
|
before.budget.limits.daily_usd
|
|
);
|
|
assert_eq!(after.budget.limits.weekly_usd.canonical(), "25.5");
|
|
let mut expected = json!({
|
|
"client_key_id":"key_budget", "daily_limit_usd":"10", "weekly_limit_usd":"20",
|
|
"daily_used_usd":"3", "weekly_used_usd":"0",
|
|
"daily_resets_at_ms":before.budget.daily_resets_at().map(|time| chrono::DateTime::<chrono::Utc>::from(time).timestamp_millis()),
|
|
"weekly_resets_at_ms":null,
|
|
});
|
|
assert_eq!(results[6], expected);
|
|
assert_eq!(results[7], json!({"client_key_id":"key_budget"}));
|
|
expected["weekly_limit_usd"] = json!("25.5");
|
|
assert_eq!(results[8], expected);
|
|
for index in [9, 10, 13, 14] {
|
|
assert_eq!(results[index], json!({"error":"invalid_input"}));
|
|
}
|
|
for index in [11, 12] {
|
|
assert_eq!(results[index], json!({"error":"rejected"}));
|
|
}
|
|
assert_eq!(
|
|
environment
|
|
.audit_requests("update_budget_limits")
|
|
.await
|
|
.len(),
|
|
1
|
|
);
|
|
assert_eq!(
|
|
after.budget.daily_resets_at(),
|
|
before.budget.daily_resets_at()
|
|
);
|
|
assert_eq!(after.budget.weekly_resets_at(), None);
|
|
assert_eq!(audits.len(), 1);
|
|
assert!(audits[0].starts_with(&format!("plugin:{}:scope:", view.target.instance_id)));
|
|
}
|
|
assert_eq!(
|
|
store
|
|
.reveal_client_key(&key)
|
|
.await
|
|
.unwrap()
|
|
.unwrap()
|
|
.expose_for_response(),
|
|
plaintext
|
|
);
|
|
assert!(
|
|
!std::str::from_utf8(&reply.body)
|
|
.unwrap()
|
|
.contains(&plaintext)
|
|
);
|
|
drop(service);
|
|
drop(access);
|
|
environment.release_plugin_accounts(&runtime);
|
|
runtime.shutdown().await;
|
|
drop(core);
|
|
drop(runtime);
|
|
drop(store);
|
|
environment.close().await;
|
|
}
|
|
}
|
|
|
|
async fn seed_budget(environment: &Environment) -> ClientApiKeyId {
|
|
let key = ClientApiKeyId::new("key_budget").unwrap();
|
|
environment
|
|
.client_key(key.as_str(), "sk-budget-fixture")
|
|
.await;
|
|
environment.seed_client_key_budget(key.as_str()).await;
|
|
key
|
|
}
|
|
|
|
fn reset_queries() -> Value {
|
|
// 重置无需先查询目录;两个基础接口由测试插件自行选择调用顺序
|
|
json!([
|
|
{"method":"host.keys.reset_budget","query":{"client_key_id":"key_budget","period":"weekly"}},
|
|
{"method":"host.keys.list","query":{"limit":10}},
|
|
{"method":"host.keys.get_budget","query":{"client_key_id":"key_budget"}},
|
|
{"method":"host.keys.update_budget_limits","query":{"client_key_id":"key_budget","daily_limit_usd":"10"}}
|
|
])
|
|
}
|
|
|
|
fn assert_reset_results(results: &Value) {
|
|
assert_eq!(results[0], json!({"client_key_id":"key_budget"}));
|
|
assert_eq!(results[1]["keys"][0]["id"], "key_budget");
|
|
assert_eq!(results[2]["daily_used_usd"], "3");
|
|
assert_eq!(results[2]["weekly_used_usd"], "0");
|
|
assert_eq!(results[3], json!({"client_key_id":"key_budget"}));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn command_plane_resets_budget_with_only_budget_permission() {
|
|
let Some(mut environment) = Environment::create_command().await else {
|
|
eprintln!("SKIP: plugin integration environment absent");
|
|
return;
|
|
};
|
|
let key = seed_budget(&environment).await;
|
|
environment
|
|
.install_plugin(json!({
|
|
"command_registration":{"commands":[{"name":"reset","description":"预算接口测试"}]},
|
|
"data_queries":reset_queries()
|
|
}))
|
|
.await;
|
|
let (runtime, core) = environment.command_plane().await;
|
|
let store = environment.store.admin_ports().client_keys();
|
|
let before = store.get_client_key(&key).await.unwrap().unwrap();
|
|
let access = gateway_admin::initialize_plugin_client_keys(
|
|
native::admin_registry(),
|
|
store.clone(),
|
|
core.snapshot_control(),
|
|
);
|
|
runtime.bind_client_key_ports(&access).unwrap();
|
|
let instance = environment
|
|
.store
|
|
.admin_ports()
|
|
.plugins()
|
|
.load_instances()
|
|
.await
|
|
.unwrap()
|
|
.instances
|
|
.remove(0);
|
|
let commands = runtime.prepare_command_line().await.unwrap();
|
|
environment.store.start_command_line_writes().unwrap();
|
|
let reply = commands.execute(&instance.id, "reset", &[]).await.unwrap();
|
|
assert_eq!(reply.exit_code, 0);
|
|
assert_reset_results(&serde_json::from_str(&reply.stdout).unwrap());
|
|
let after = store.get_client_key(&key).await.unwrap().unwrap();
|
|
assert_eq!(after.budget.weekly_used_usd.canonical(), "0");
|
|
assert_eq!(after.budget.daily_used_usd, before.budget.daily_used_usd);
|
|
assert_eq!(environment.audit_requests("reset_budget").await.len(), 1);
|
|
|
|
commands.shutdown().await;
|
|
runtime.shutdown().await;
|
|
environment
|
|
.store
|
|
.shutdown_command_line_writes()
|
|
.await
|
|
.unwrap();
|
|
drop(access);
|
|
drop(core);
|
|
drop(runtime);
|
|
drop(store);
|
|
environment.close().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn published_maintenance_resets_budget_with_only_budget_permission() {
|
|
let Some(environment) = Environment::create().await else {
|
|
eprintln!("SKIP: plugin integration environment absent");
|
|
return;
|
|
};
|
|
let key = seed_budget(&environment).await;
|
|
let marker = environment
|
|
.directory
|
|
.path()
|
|
.join("budget-maintenance.jsonl");
|
|
environment
|
|
.install_plugin(json!({
|
|
"maintenance_fixture":true,
|
|
"maintenance_marker":marker,
|
|
"data_queries":reset_queries()
|
|
}))
|
|
.await;
|
|
let (runtime, core) = environment.runtime().await;
|
|
let store = environment.store.admin_ports().client_keys();
|
|
let before = store.get_client_key(&key).await.unwrap().unwrap();
|
|
let access = gateway_admin::initialize_plugin_client_keys(
|
|
native::admin_registry(),
|
|
store.clone(),
|
|
core.snapshot_control(),
|
|
);
|
|
runtime.bind_client_key_ports(&access).unwrap();
|
|
let WorkerContribution::Registration(registration) =
|
|
runtime.maintenance_worker(core.snapshots()).unwrap()
|
|
else {
|
|
panic!("maintenance registration")
|
|
};
|
|
let WorkerRunnable::Daemon { task, .. } = registration.runnable else {
|
|
panic!("maintenance daemon")
|
|
};
|
|
let stop = CancellationToken::new();
|
|
let cancellation = stop.clone();
|
|
let worker = tokio::spawn(async move {
|
|
task.run(WorkerDaemonContext::new(cancellation))
|
|
.await
|
|
.unwrap()
|
|
});
|
|
let result: Value = timeout(Duration::from_secs(15), async {
|
|
loop {
|
|
if let Ok(content) = std::fs::read_to_string(&marker)
|
|
&& let Some(result) = content
|
|
.lines()
|
|
.find_map(|line| serde_json::from_str(line).ok())
|
|
{
|
|
break result;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(20)).await;
|
|
}
|
|
})
|
|
.await
|
|
.expect("maintenance callback completed");
|
|
stop.cancel();
|
|
timeout(Duration::from_secs(5), worker)
|
|
.await
|
|
.unwrap()
|
|
.unwrap();
|
|
assert_reset_results(&result["results"]);
|
|
let after = store.get_client_key(&key).await.unwrap().unwrap();
|
|
assert_eq!(after.budget.weekly_used_usd.canonical(), "0");
|
|
assert_eq!(after.budget.daily_used_usd, before.budget.daily_used_usd);
|
|
assert_eq!(environment.audit_requests("reset_budget").await.len(), 1);
|
|
|
|
environment.release_plugin_accounts(&runtime);
|
|
runtime.shutdown().await;
|
|
drop(access);
|
|
drop(core);
|
|
drop(runtime);
|
|
drop(store);
|
|
environment.close().await;
|
|
}
|
|
|
|
struct HoldCommittedReply {
|
|
inner: Arc<dyn PluginClientKeyAccess>,
|
|
committed: Arc<Notify>,
|
|
}
|
|
|
|
#[async_trait::async_trait]
|
|
impl PluginClientKeyAccess for HoldCommittedReply {
|
|
async fn budget_window(
|
|
&self,
|
|
id: &ClientApiKeyId,
|
|
period: gateway_admin::model::client_keys::ClientKeyBudgetWindowPeriod,
|
|
) -> Result<gateway_admin::model::client_keys::ClientKeyBudgetWindow, AdminError> {
|
|
self.inner.budget_window(id, period).await
|
|
}
|
|
async fn set_budget_window(
|
|
&self,
|
|
owner: &PluginResourceOwner,
|
|
command: gateway_admin::model::client_keys::SetClientKeyBudgetWindow,
|
|
context: &MutationContext,
|
|
) -> Result<u64, AdminError> {
|
|
self.inner.set_budget_window(owner, command, context).await
|
|
}
|
|
|
|
async fn facts(&self, id: &ClientApiKeyId) -> Result<PluginClientKeyFacts, AdminError> {
|
|
self.inner.facts(id).await
|
|
}
|
|
|
|
async fn budget(
|
|
&self,
|
|
id: &ClientApiKeyId,
|
|
) -> Result<gateway_core::engine::budget::ClientBudgetStatus, AdminError> {
|
|
self.inner.budget(id).await
|
|
}
|
|
async fn update_budget_limits(
|
|
&self,
|
|
owner: &PluginResourceOwner,
|
|
command: gateway_admin::model::client_keys::UpdateClientKeyBudgetLimits,
|
|
context: &MutationContext,
|
|
) -> Result<ClientApiKeyId, AdminError> {
|
|
self.inner
|
|
.update_budget_limits(owner, command, context)
|
|
.await
|
|
}
|
|
|
|
async fn reset_budget(
|
|
&self,
|
|
owner: &PluginResourceOwner,
|
|
command: ResetClientKeyBudget,
|
|
context: &MutationContext,
|
|
) -> Result<ClientApiKeyId, AdminError> {
|
|
self.inner.reset_budget(owner, command, context).await?;
|
|
// 在真实事务提交后挡住宿主回包,稳定复现插件未收到提交结果的窗口
|
|
self.committed.notify_one();
|
|
std::future::pending().await
|
|
}
|
|
|
|
async fn list(
|
|
&self,
|
|
query: PluginClientKeyListQuery,
|
|
) -> Result<PluginClientKeyPage, AdminError> {
|
|
self.inner.list(query).await
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn losing_callback_reply_after_commit_keeps_budget_and_audit_without_replay() {
|
|
let Some(environment) = Environment::create().await else {
|
|
eprintln!("SKIP: plugin integration environment absent");
|
|
return;
|
|
};
|
|
let key = seed_budget(&environment).await;
|
|
let disconnect = environment.directory.path().join("disconnect-after-commit");
|
|
let startups = environment.directory.path().join("budget-startups.jsonl");
|
|
environment
|
|
.install_plugin(
|
|
json!({
|
|
"management_registration":{"routes":[{"method":"POST","path":"reset","request_content_types":[],"response_content_types":["application/json"]}]},
|
|
"data_queries":reset_queries(),
|
|
"startup_marker":startups,
|
|
"exit_after_ready_signals":[disconnect]
|
|
}),
|
|
|
|
)
|
|
.await;
|
|
let (runtime, core) = environment.runtime().await;
|
|
let store = environment.store.admin_ports().client_keys();
|
|
let committed = Arc::new(Notify::new());
|
|
let access: Arc<dyn PluginClientKeyAccess> = Arc::new(HoldCommittedReply {
|
|
inner: gateway_admin::initialize_plugin_client_keys(
|
|
native::admin_registry(),
|
|
store.clone(),
|
|
core.snapshot_control(),
|
|
),
|
|
committed: committed.clone(),
|
|
});
|
|
runtime.bind_client_key_ports(&access).unwrap();
|
|
let service = PluginManagementService::new(
|
|
runtime.clone(),
|
|
environment.store.admin_ports().plugins(),
|
|
core.snapshots(),
|
|
);
|
|
let view = service.views().await.unwrap().remove(0);
|
|
let request = tokio::spawn(async move {
|
|
service
|
|
.handle(
|
|
&view.target,
|
|
PluginManagementRequest {
|
|
request_context: None,
|
|
headers: Vec::new(),
|
|
method: "POST".into(),
|
|
path: "reset".into(),
|
|
query: String::new(),
|
|
content_type: None,
|
|
body: vec![],
|
|
request_id: "budget-lost-reply".into(),
|
|
},
|
|
)
|
|
.await
|
|
});
|
|
timeout(Duration::from_secs(15), committed.notified())
|
|
.await
|
|
.expect("native budget transaction committed");
|
|
assert!(!request.is_finished());
|
|
// 只断开插件,宿主保持运行,确保连接丢失不会触发透明重放
|
|
std::fs::write(&disconnect, b"").unwrap();
|
|
assert!(
|
|
timeout(Duration::from_secs(5), request)
|
|
.await
|
|
.unwrap()
|
|
.unwrap()
|
|
.is_err()
|
|
);
|
|
let after = store.get_client_key(&key).await.unwrap().unwrap();
|
|
assert_eq!(after.budget.weekly_used_usd.canonical(), "0");
|
|
assert_eq!(environment.audit_requests("reset_budget").await.len(), 1);
|
|
assert_eq!(
|
|
std::fs::read_to_string(startups).unwrap().lines().count(),
|
|
1
|
|
);
|
|
|
|
environment.release_plugin_accounts(&runtime);
|
|
runtime.shutdown().await;
|
|
drop(access);
|
|
drop(core);
|
|
drop(runtime);
|
|
drop(store);
|
|
environment.close().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn plugin_window_operations_replay_once_and_validate_parameters() {
|
|
let Some(environment) = Environment::create().await else {
|
|
eprintln!("SKIP: plugin integration environment absent");
|
|
return;
|
|
};
|
|
let key = seed_budget(&environment).await;
|
|
let now = chrono::Utc::now().timestamp_micros();
|
|
let hour = chrono::TimeDelta::hours(1).num_microseconds().unwrap();
|
|
let command = json!({"client_key_id":key.as_str(),"period":"weekly","expected_revision":0,"window":{"starts_at_us":now-hour,"ends_at_us":now+hour}});
|
|
let mut changed = command.clone();
|
|
changed["window"]["ends_at_us"] = json!(now + 2 * hour);
|
|
let mut invalid = command.clone();
|
|
invalid["window"]["starts_at_us"] = json!(now + 2 * hour);
|
|
let mut forged = command.clone();
|
|
forged["instance_id"] = json!("forged");
|
|
let result: Vec<Value> = run_window_plugin(&environment, json!({
|
|
"data_queries":[
|
|
{"method":"host.keys.set_budget_window","query":command},
|
|
{"method":"host.keys.set_budget_window","query":command},
|
|
{"method":"host.keys.set_budget_window","query":changed},
|
|
{"method":"host.keys.set_budget_window","query":invalid},
|
|
{"method":"host.keys.set_budget_window","query":forged},
|
|
{"method":"host.keys.set_budget_window","query":{"client_key_id":key.as_str(),"period":"weekly","expected_revision":1}},
|
|
{"method":"host.keys.get_budget_window","query":{"client_key_id":key.as_str(),"period":"weekly"}}
|
|
]
|
|
})).await;
|
|
assert_eq!(result[0], json!({"revision":1}));
|
|
assert_eq!(result[1], result[0]);
|
|
assert_eq!(result[2], json!({"error":"conflict"}));
|
|
assert_eq!(result[3], json!({"error":"invalid_input"}));
|
|
assert_eq!(result[4], json!({"error":"invalid_input"}));
|
|
assert_eq!(result[5], json!({"error":"invalid_input"}));
|
|
assert_eq!(result[6]["ends_at_us"], now + hour);
|
|
assert_eq!(result[6]["explicit"], true);
|
|
assert_eq!(
|
|
environment.audit_requests("set_budget_window").await.len(),
|
|
1
|
|
);
|
|
environment.close().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn sdk_adopts_restored_native_window_without_losing_precision_or_spend() {
|
|
use gateway_plugin_sdk::call::key_budgets::KeyBudgetWindow;
|
|
|
|
let Some(environment) = Environment::create().await else {
|
|
eprintln!("SKIP: plugin integration environment absent");
|
|
return;
|
|
};
|
|
let key = seed_budget(&environment).await;
|
|
environment
|
|
.restore_weekly_budget_without_charge_history(key.as_str())
|
|
.await;
|
|
let [before, after]: [KeyBudgetWindow; 2] = run_window_plugin(
|
|
&environment,
|
|
json!({
|
|
"sdk_session": true,
|
|
"adopt_budget_window": {"client_key_id":key.as_str(), "period":"weekly"}
|
|
}),
|
|
)
|
|
.await;
|
|
assert!(!before.explicit);
|
|
assert_eq!(before.starts_at_us.unwrap().rem_euclid(1_000), 456);
|
|
assert_eq!(before.ends_at_us.unwrap().rem_euclid(1_000), 789);
|
|
assert_eq!(before.used_usd, "4");
|
|
assert_eq!(
|
|
after,
|
|
KeyBudgetWindow {
|
|
explicit: true,
|
|
revision: before.revision + 1,
|
|
..before
|
|
}
|
|
);
|
|
environment.close().await;
|
|
}
|
|
|
|
async fn run_window_plugin<T: serde::de::DeserializeOwned>(
|
|
environment: &Environment,
|
|
mut config: Value,
|
|
) -> T {
|
|
config["management_registration"] = json!({"routes":[{"method":"POST","path":"window","request_content_types":[],"response_content_types":["application/json"]}]});
|
|
environment.install_plugin(config).await;
|
|
let (runtime, core) = environment.runtime().await;
|
|
let access = gateway_admin::initialize_plugin_client_keys(
|
|
native::admin_registry(),
|
|
environment.store.admin_ports().client_keys(),
|
|
core.snapshot_control(),
|
|
);
|
|
runtime.bind_client_key_ports(&access).unwrap();
|
|
let service = PluginManagementService::new(
|
|
runtime.clone(),
|
|
environment.store.admin_ports().plugins(),
|
|
core.snapshots(),
|
|
);
|
|
let view = service.views().await.unwrap().remove(0);
|
|
let reply = service
|
|
.handle(
|
|
&view.target,
|
|
PluginManagementRequest {
|
|
request_context: None,
|
|
headers: vec![],
|
|
method: "POST".into(),
|
|
path: "window".into(),
|
|
query: String::new(),
|
|
content_type: None,
|
|
body: vec![],
|
|
request_id: "explicit-window".into(),
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
let result = serde_json::from_slice(&reply.body).unwrap();
|
|
environment.release_plugin_accounts(&runtime);
|
|
runtime.shutdown().await;
|
|
drop(service);
|
|
drop(access);
|
|
drop(core);
|
|
drop(runtime);
|
|
result
|
|
}
|