i/Aether
1
0
Fork 0
mirror of https://github.com/fawney19/Aether.git synced 2026-09-01 17:00:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix(routing): match provider model names in admin routing counts

Browse Source
This commit is contained in:
ZheFox
2026-05-17 18:59:41 +08:00
parent 485d166912
commit d9c8119bda
3 changed files with 206 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
apps/aether-gateway/src/handlers/admin/model/routing.rs
View File

@@ -107,6 +107,13 @@ pub(crate) async fn build_admin_global_model_routing_payload(
let Some(provider) = providers.get(&model.provider_id) else {
continue;
};
let provider_model_mapping_names =
provider_model_mapping_names_for_routing(model.provider_model_mappings.as_ref());
let key_match_model_names = key_match_model_names_for_routing(
&global_model.name,
&model.provider_model_name,
&provider_model_mapping_names,
);
let mut endpoint_payloads = Vec::new();
let mut active_endpoints = 0usize;
for endpoint in endpoints_by_provider
@@ -132,7 +139,7 @@ pub(crate) async fn build_admin_global_model_routing_payload(
.filter(|key| {
key_allowed_models_match_global_model_for_routing(
key.allowed_models.as_ref(),
&global_model.name,
&key_match_model_names,
&global_model_mappings,
)
})
@@ -313,7 +320,7 @@ pub(crate) async fn build_admin_global_model_routing_payload(
fn key_allowed_models_match_global_model_for_routing(
raw_allowed_models: Option<&serde_json::Value>,
global_model_name: &str,
model_names: &[String],
global_model_mappings: &[String],
) -> bool {
// 兼容 Python 预览逻辑：None/[] 视为“不限制”，在链路预览中保留该 Key。
@@ -322,14 +329,16 @@ fn key_allowed_models_match_global_model_for_routing(
return true;
}
if allowed_models
.iter()
.any(|value| value == global_model_name)
{
return true;
}
for allowed_model in &allowed_models {
for allowed_model in allowed_models.iter().map(String::as_str).map(str::trim) {
if allowed_model.is_empty() {
continue;
}
if model_names
.iter()
.any(|model_name| model_name.eq_ignore_ascii_case(allowed_model))
{
return true;
}
for pattern in global_model_mappings {
if matches_model_mapping(pattern, allowed_model) {
return true;
@@ -340,6 +349,54 @@ fn key_allowed_models_match_global_model_for_routing(
false
}
fn provider_model_mapping_names_for_routing(
raw_mappings: Option<&serde_json::Value>,
) -> Vec<String> {
raw_mappings
.and_then(serde_json::Value::as_array)
.map(|items| {
items
.iter()
.filter_map(|item| {
item.as_str()
.or_else(|| item.get("name").and_then(serde_json::Value::as_str))
})
.map(str::trim)
.filter(|value| !value.is_empty())
.map(ToOwned::to_owned)
.collect::<Vec<_>>()
})
.unwrap_or_default()
}
fn key_match_model_names_for_routing(
global_model_name: &str,
provider_model_name: &str,
provider_model_mapping_names: &[String],
) -> Vec<String> {
let mut names = Vec::new();
push_unique_model_name(&mut names, global_model_name);
push_unique_model_name(&mut names, provider_model_name);
for mapping_name in provider_model_mapping_names {
push_unique_model_name(&mut names, mapping_name);
}
names
}
fn push_unique_model_name(names: &mut Vec<String>, value: &str) {
let value = value.trim();
if value.is_empty() {
return;
}
if names
.iter()
.any(|existing| existing.eq_ignore_ascii_case(value))
{
return;
}
names.push(value.to_string());
}
pub(crate) async fn build_admin_assign_global_model_to_providers_payload(
state: &AdminAppState<'_>,
global_model_id: &str,

136
apps/aether-gateway/src/tests/control/admin/models/global.rs
View File

@@ -936,6 +936,142 @@ async fn gateway_handles_admin_global_model_routing_locally_with_trusted_admin_p
upstream_handle.abort();
}
#[tokio::test]
async fn gateway_global_model_routing_counts_image_provider_keys_by_provider_model_name() {
let upstream_hits = Arc::new(Mutex::new(0usize));
let upstream_hits_clone = Arc::clone(&upstream_hits);
let upstream = Router::new().route(
"/api/admin/models/global/global-gpt-image/routing",
any(move |_request: Request| {
let upstream_hits_inner = Arc::clone(&upstream_hits_clone);
async move {
*upstream_hits_inner.lock().expect("mutex should lock") += 1;
(StatusCode::OK, Body::from("unexpected upstream hit"))
}
}),
);
let mut image_provider = sample_provider("provider-image", "image", 10);
image_provider.provider_type = "chatgpt_web".to_string();
let grok_provider = sample_provider("provider-grok", "grok2api", 20);
let mut image_key = sample_key(
"key-image-routing",
"provider-image",
"legacy:mismatch",
"sk-image-routing-1234",
);
image_key.name = "image-account".to_string();
image_key.auth_type = "oauth".to_string();
image_key.allowed_models = Some(json!(["gpt-image-2"]));
let mut grok_key = sample_key(
"key-grok-routing",
"provider-grok",
"openai:chat",
"sk-grok-routing-5678",
);
grok_key.name = "all".to_string();
grok_key.allowed_models = Some(json!(["gpt-image-2"]));
let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
vec![image_provider, grok_provider],
vec![
sample_endpoint(
"endpoint-image",
"provider-image",
"openai:image",
"https://chatgpt.example",
),
sample_endpoint(
"endpoint-grok-chat",
"provider-grok",
"openai:chat",
"https://grok.example",
),
],
vec![image_key, grok_key],
));
let global_model_repository = Arc::new(
InMemoryGlobalModelReadRepository::seed(Vec::new())
.with_admin_global_models(vec![sample_admin_global_model(
"global-gpt-image",
"GPT-Image-2",
"GPT-Image-2",
)])
.with_admin_provider_models(vec![
sample_admin_provider_model(
"model-image-gpt-image",
"provider-image",
"global-gpt-image",
"gpt-image-2",
),
sample_admin_provider_model(
"model-grok-gpt-image",
"provider-grok",
"global-gpt-image",
"gpt-image-2",
),
]),
);
let (upstream_url, upstream_handle) = start_server(upstream).await;
let gateway = build_router_with_state(
AppState::new()
.expect("gateway should build")
.with_data_state_for_tests(
GatewayDataState::with_provider_catalog_reader_for_tests(
provider_catalog_repository,
)
.with_global_model_repository_for_tests(global_model_repository),
),
);
let (gateway_url, gateway_handle) = start_server(gateway).await;
let response = reqwest::Client::new()
.get(format!(
"{gateway_url}/api/admin/models/global/global-gpt-image/routing"
))
.header(crate::constants::GATEWAY_HEADER, "rust-phase3b")
.header(TRUSTED_ADMIN_USER_ID_HEADER, "admin-user-123")
.header(TRUSTED_ADMIN_USER_ROLE_HEADER, "admin")
.header(TRUSTED_ADMIN_SESSION_ID_HEADER, "session-123")
.send()
.await
.expect("request should succeed");
assert_eq!(response.status(), StatusCode::OK);
let payload: serde_json::Value = response.json().await.expect("json body should parse");
assert_eq!(payload["global_model_name"], "GPT-Image-2");
assert_eq!(payload["total_providers"], 2);
assert_eq!(payload["active_providers"], 2);
let providers = payload["providers"].as_array().expect("providers array");
assert_eq!(providers.len(), 2);
let image_endpoints = providers[0]["endpoints"]
.as_array()
.expect("image endpoints array");
assert_eq!(providers[0]["id"], "provider-image");
assert_eq!(image_endpoints[0]["api_format"], "openai:image");
assert_eq!(image_endpoints[0]["total_keys"], 1);
assert_eq!(image_endpoints[0]["active_keys"], 1);
assert_eq!(image_endpoints[0]["keys"][0]["name"], "image-account");
let grok_endpoints = providers[1]["endpoints"]
.as_array()
.expect("grok endpoints array");
assert_eq!(providers[1]["id"], "provider-grok");
assert_eq!(grok_endpoints[0]["api_format"], "openai:chat");
assert_eq!(grok_endpoints[0]["total_keys"], 1);
assert_eq!(grok_endpoints[0]["active_keys"], 1);
assert_eq!(grok_endpoints[0]["keys"][0]["name"], "all");
assert_eq!(*upstream_hits.lock().expect("mutex should lock"), 0);
gateway_handle.abort();
upstream_handle.abort();
}
#[tokio::test]
async fn gateway_creates_admin_global_model_locally_with_trusted_admin_principal() {
let upstream_hits = Arc::new(Mutex::new(0usize));