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

refactor: 拆分 admin handler 大文件为模块目录，消除 shared.rs 反模式

Browse Source 
- endpoint_keys/pool/architecture 等大文件拆分为独立模块目录
- 删除 crud/query/strategy/system 中的 shared.rs，内容归位到各自模块
- endpoints_admin/models/oauth/write 等模块拆出 payloads/responses/support 子文件
- system/core 下多个 *_routes.rs 合并到 system_routes.rs
- 更新 refactor-execution-plan 文档进度
This commit is contained in:
fawney19
2026-04-07 12:15:19 +08:00
parent 29055c575f
commit 4fb9882b54
109 changed files with 8151 additions and 7047 deletions
Download Patch File Download Diff File Expand all files Collapse all files
apps/aether-gateway/src/handlers/admin/model/mod.rs
+1 -11
View File
@@ -18,19 +18,9 @@ pub(crate) use self::global::{
build_admin_model_catalog_payload, resolve_admin_global_model_by_id_or_err,
};
pub(crate) use self::global_models::maybe_build_local_admin_global_models_response;
pub(crate) use self::payloads::{
admin_provider_model_effective_capability, admin_provider_model_effective_input_price,
admin_provider_model_effective_output_price, admin_provider_model_name_exists,
build_admin_provider_model_payload, build_admin_provider_model_response,
build_admin_provider_models_payload, normalize_optional_price,
normalize_required_trimmed_string,
};
pub(crate) use self::routing::{
build_admin_assign_global_model_to_providers_payload, build_admin_global_model_routing_payload,
};
pub(crate) use self::write::{
build_admin_batch_assign_global_models_payload, build_admin_global_model_create_record,
build_admin_global_model_update_record, build_admin_import_provider_models_payload,
build_admin_provider_available_source_models_payload, build_admin_provider_model_create_record,
build_admin_provider_model_update_record,
build_admin_global_model_create_record, build_admin_global_model_update_record,
};
apps/aether-gateway/src/handlers/admin/model/payloads.rs
+1 -183
View File
@@ -1,10 +1,5 @@
use crate::handlers::admin::shared::unix_secs_to_rfc3339;
use crate::{AppState, GatewayError};
use aether_data_contracts::repository::global_models::{
AdminProviderModelListQuery, StoredAdminProviderModel,
};
use serde_json::json;
use std::time::{SystemTime, UNIX_EPOCH};
use aether_data_contracts::repository::global_models::StoredAdminProviderModel;
pub(crate) fn model_tiered_pricing_first_tier_value(
tiered_pricing: Option<&serde_json::Value>,
@@ -31,42 +26,6 @@ fn model_effective_capability(
})
}
fn merge_json_values(base: &mut serde_json::Value, overlay: serde_json::Value) {
match (base, overlay) {
(serde_json::Value::Object(base_map), serde_json::Value::Object(overlay_map)) => {
for (key, value) in overlay_map {
match base_map.get_mut(&key) {
Some(existing) => merge_json_values(existing, value),
None => {
base_map.insert(key, value);
}
}
}
}
(base, overlay) => *base = overlay,
}
}
fn merge_admin_provider_model_effective_config(
model: &StoredAdminProviderModel,
) -> Option<serde_json::Value> {
let mut merged = match model.global_model_config.clone() {
Some(serde_json::Value::Object(map)) => serde_json::Value::Object(map),
Some(other) => other,
None => serde_json::Value::Object(serde_json::Map::new()),
};
if let Some(config) = model.config.clone() {
merge_json_values(&mut merged, config);
}
match merged {
serde_json::Value::Null => None,
serde_json::Value::Object(ref map) if map.is_empty() => None,
value => Some(value),
}
}
pub(crate) fn timestamp_or_now(value: Option<u64>, now_unix_secs: u64) -> serde_json::Value {
unix_secs_to_rfc3339(value.unwrap_or(now_unix_secs))
.map(serde_json::Value::String)
@@ -154,144 +113,3 @@ pub(crate) fn admin_provider_model_effective_capability(
_ => false,
}
}
pub(crate) fn build_admin_provider_model_response(
model: &StoredAdminProviderModel,
now_unix_secs: u64,
) -> serde_json::Value {
let effective_tiered_pricing = model
.tiered_pricing
.clone()
.or_else(|| model.global_model_default_tiered_pricing.clone());
let effective_config = merge_admin_provider_model_effective_config(model);
json!({
"id": &model.id,
"provider_id": &model.provider_id,
"global_model_id": &model.global_model_id,
"provider_model_name": &model.provider_model_name,
"provider_model_mappings": model.provider_model_mappings.clone(),
"price_per_request": model.price_per_request,
"tiered_pricing": model.tiered_pricing.clone(),
"effective_tiered_pricing": effective_tiered_pricing,
"effective_input_price": admin_provider_model_effective_input_price(model),
"effective_output_price": admin_provider_model_effective_output_price(model),
"effective_price_per_request": model
.price_per_request
.or(model.global_model_default_price_per_request),
"supports_vision": model.supports_vision,
"supports_function_calling": model.supports_function_calling,
"supports_streaming": model.supports_streaming,
"supports_extended_thinking": model.supports_extended_thinking,
"supports_image_generation": model.supports_image_generation,
"effective_supports_vision": admin_provider_model_effective_capability(model, "vision"),
"effective_supports_function_calling": admin_provider_model_effective_capability(
model,
"function_calling",
),
"effective_supports_streaming": admin_provider_model_effective_capability(model, "streaming"),
"effective_supports_extended_thinking": admin_provider_model_effective_capability(
model,
"extended_thinking",
),
"effective_supports_image_generation": admin_provider_model_effective_capability(
model,
"image_generation",
),
"is_active": model.is_active,
"is_available": model.is_available,
"config": model.config.clone(),
"effective_config": effective_config,
"global_model_name": model.global_model_name.clone(),
"global_model_display_name": model.global_model_display_name.clone(),
"created_at": timestamp_or_now(model.created_at_unix_secs, now_unix_secs),
"updated_at": timestamp_or_now(model.updated_at_unix_secs, now_unix_secs),
})
}
pub(crate) async fn build_admin_provider_models_payload(
state: &AppState,
provider_id: &str,
skip: usize,
limit: usize,
is_active: Option<bool>,
) -> Option<serde_json::Value> {
if !state.has_provider_catalog_data_reader() || !state.has_global_model_data_reader() {
return None;
}
let provider = state
.read_provider_catalog_providers_by_ids(&[provider_id.to_string()])
.await
.ok()?
.into_iter()
.next()?;
let mut models = state
.list_admin_provider_models(&AdminProviderModelListQuery {
provider_id: provider.id,
is_active,
offset: skip,
limit,
})
.await
.ok()?;
models.sort_by(|left, right| {
left.provider_model_name
.cmp(&right.provider_model_name)
.then_with(|| left.id.cmp(&right.id))
});
let now_unix_secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.ok()
.map(|duration| duration.as_secs())
.unwrap_or(0);
Some(serde_json::Value::Array(
models
.iter()
.map(|model| build_admin_provider_model_response(model, now_unix_secs))
.collect(),
))
}
pub(crate) async fn build_admin_provider_model_payload(
state: &AppState,
provider_id: &str,
model_id: &str,
) -> Option<serde_json::Value> {
if !state.has_global_model_data_reader() {
return None;
}
let model = state
.get_admin_provider_model(provider_id, model_id)
.await
.ok()??;
let now_unix_secs = SystemTime::now()
.duration_since(UNIX_EPOCH)
.ok()
.map(|duration| duration.as_secs())
.unwrap_or(0);
Some(build_admin_provider_model_response(&model, now_unix_secs))
}
pub(crate) async fn admin_provider_model_name_exists(
state: &AppState,
provider_id: &str,
provider_model_name: &str,
exclude_model_id: Option<&str>,
) -> Result<bool, GatewayError> {
let target = provider_model_name.trim();
if target.is_empty() {
return Ok(false);
}
let models = state
.list_admin_provider_models(&AdminProviderModelListQuery {
provider_id: provider_id.to_string(),
is_active: None,
offset: 0,
limit: 10_000,
})
.await?;
Ok(models.into_iter().any(|model| {
model.provider_model_name == target
&& exclude_model_id.is_none_or(|exclude| model.id != exclude)
}))
}
apps/aether-gateway/src/handlers/admin/model/write.rs
+3 -432
View File
@@ -1,26 +1,13 @@
use super::{
admin_provider_model_effective_capability, admin_provider_model_effective_input_price,
admin_provider_model_effective_output_price, admin_provider_model_name_exists,
normalize_optional_price, normalize_required_trimmed_string,
resolve_admin_global_model_by_id_or_err,
};
use super::payloads::{normalize_optional_price, normalize_required_trimmed_string};
use crate::handlers::admin::model::shared::{
AdminGlobalModelCreateRequest, AdminGlobalModelUpdateRequest,
};
use crate::handlers::admin::provider::shared::{
AdminImportProviderModelsRequest, AdminProviderModelCreateRequest,
AdminProviderModelUpdateRequest,
};
use crate::handlers::admin::shared::{
normalize_json_array, normalize_json_object, normalize_string_list,
};
use crate::handlers::admin::shared::{normalize_json_object, normalize_string_list};
use crate::AppState;
use aether_data_contracts::repository::global_models::{
AdminProviderModelListQuery, CreateAdminGlobalModelRecord, StoredAdminGlobalModel,
StoredAdminProviderModel, UpdateAdminGlobalModelRecord, UpsertAdminProviderModelRecord,
CreateAdminGlobalModelRecord, StoredAdminGlobalModel, UpdateAdminGlobalModelRecord,
};
use serde_json::json;
use std::collections::{BTreeMap, BTreeSet};
use uuid::Uuid;
pub(crate) async fn build_admin_global_model_create_record(
@@ -116,419 +103,3 @@ pub(crate) async fn build_admin_global_model_update_record(
)
.map_err(|err| err.to_string())
}
pub(crate) async fn build_admin_provider_model_create_record(
state: &AppState,
provider_id: &str,
payload: AdminProviderModelCreateRequest,
) -> Result<UpsertAdminProviderModelRecord, String> {
let provider_model_name =
normalize_required_trimmed_string(&payload.provider_model_name, "provider_model_name")?;
if admin_provider_model_name_exists(state, provider_id, &provider_model_name, None)
.await
.map_err(|err| format!("{err:?}"))?
{
return Err(format!("模型 '{provider_model_name}' 已存在"));
}
let global_model_id =
normalize_required_trimmed_string(&payload.global_model_id, "global_model_id")?;
resolve_admin_global_model_by_id_or_err(state, &global_model_id).await?;
let price_per_request =
normalize_optional_price(payload.price_per_request, "price_per_request")?;
let tiered_pricing = normalize_json_object(payload.tiered_pricing, "tiered_pricing")?;
let provider_model_mappings =
normalize_json_array(payload.provider_model_mappings, "provider_model_mappings")?;
let config = normalize_json_object(payload.config, "config")?;
UpsertAdminProviderModelRecord::new(
Uuid::new_v4().to_string(),
provider_id.to_string(),
global_model_id,
provider_model_name,
provider_model_mappings,
price_per_request,
tiered_pricing,
payload.supports_vision,
payload.supports_function_calling,
payload.supports_streaming,
payload.supports_extended_thinking,
None,
payload.is_active.unwrap_or(true),
true,
config,
)
.map_err(|err| err.to_string())
}
pub(crate) async fn build_admin_provider_model_update_record(
state: &AppState,
existing: &StoredAdminProviderModel,
raw_payload: &serde_json::Map<String, serde_json::Value>,
payload: AdminProviderModelUpdateRequest,
) -> Result<UpsertAdminProviderModelRecord, String> {
let provider_model_name = if let Some(value) = raw_payload.get("provider_model_name") {
let Some(name) = payload.provider_model_name.as_deref() else {
return Err(if value.is_null() {
"provider_model_name 不能为空".to_string()
} else {
"provider_model_name 必须是字符串".to_string()
});
};
let name = normalize_required_trimmed_string(name, "provider_model_name")?;
if admin_provider_model_name_exists(state, &existing.provider_id, &name, Some(&existing.id))
.await
.map_err(|err| format!("{err:?}"))?
{
return Err(format!("模型 '{name}' 已存在"));
}
name
} else {
existing.provider_model_name.clone()
};
let global_model_id = if let Some(value) = raw_payload.get("global_model_id") {
let Some(global_model_id) = payload.global_model_id.as_deref() else {
return Err(if value.is_null() {
"global_model_id 不能为空".to_string()
} else {
"global_model_id 必须是字符串".to_string()
});
};
let global_model_id =
normalize_required_trimmed_string(global_model_id, "global_model_id")?;
resolve_admin_global_model_by_id_or_err(state, &global_model_id).await?;
global_model_id
} else {
existing.global_model_id.clone()
};
let price_per_request = if raw_payload.contains_key("price_per_request") {
normalize_optional_price(payload.price_per_request, "price_per_request")?
} else {
existing.price_per_request
};
let tiered_pricing = if raw_payload.contains_key("tiered_pricing") {
normalize_json_object(payload.tiered_pricing, "tiered_pricing")?
} else {
existing.tiered_pricing.clone()
};
let provider_model_mappings = if raw_payload.contains_key("provider_model_mappings") {
normalize_json_array(payload.provider_model_mappings, "provider_model_mappings")?
} else {
existing.provider_model_mappings.clone()
};
let config = if raw_payload.contains_key("config") {
normalize_json_object(payload.config, "config")?
} else {
existing.config.clone()
};
UpsertAdminProviderModelRecord::new(
existing.id.clone(),
existing.provider_id.clone(),
global_model_id,
provider_model_name,
provider_model_mappings,
price_per_request,
tiered_pricing,
if raw_payload.contains_key("supports_vision") {
payload.supports_vision
} else {
existing.supports_vision
},
if raw_payload.contains_key("supports_function_calling") {
payload.supports_function_calling
} else {
existing.supports_function_calling
},
if raw_payload.contains_key("supports_streaming") {
payload.supports_streaming
} else {
existing.supports_streaming
},
if raw_payload.contains_key("supports_extended_thinking") {
payload.supports_extended_thinking
} else {
existing.supports_extended_thinking
},
existing.supports_image_generation,
payload.is_active.unwrap_or(existing.is_active),
payload.is_available.unwrap_or(existing.is_available),
config,
)
.map_err(|err| err.to_string())
}
pub(crate) async fn build_admin_provider_available_source_models_payload(
state: &AppState,
provider_id: &str,
) -> Option<serde_json::Value> {
if !state.has_global_model_data_reader() || !state.has_provider_catalog_data_reader() {
return None;
}
let provider = state
.read_provider_catalog_providers_by_ids(&[provider_id.to_string()])
.await
.ok()?
.into_iter()
.next()?;
let models = state
.list_admin_provider_available_source_models(&provider.id)
.await
.ok()?;
let mut by_global_model = BTreeMap::<String, StoredAdminProviderModel>::new();
for model in models {
by_global_model
.entry(model.global_model_id.clone())
.or_insert(model);
}
let mut payload_models = by_global_model
.into_values()
.map(|model| {
json!({
"global_model_name": model.global_model_name,
"display_name": model.global_model_display_name,
"provider_model_name": model.provider_model_name,
"model_id": model.id,
"price": {
"input_price_per_1m": admin_provider_model_effective_input_price(&model),
"output_price_per_1m": admin_provider_model_effective_output_price(&model),
"cache_creation_price_per_1m": serde_json::Value::Null,
"cache_read_price_per_1m": serde_json::Value::Null,
"price_per_request": model.price_per_request.or(model.global_model_default_price_per_request),
},
"capabilities": json!({
"supports_vision": admin_provider_model_effective_capability(&model, "vision"),
"supports_function_calling": admin_provider_model_effective_capability(&model, "function_calling"),
"supports_streaming": admin_provider_model_effective_capability(&model, "streaming"),
}),
"is_active": model.is_active,
})
})
.collect::<Vec<_>>();
let total = payload_models.len();
payload_models.sort_by(|left, right| {
left.get("global_model_name")
.and_then(serde_json::Value::as_str)
.cmp(
&right
.get("global_model_name")
.and_then(serde_json::Value::as_str),
)
});
Some(json!({
"models": payload_models,
"total": total,
}))
}
pub(crate) async fn build_admin_batch_assign_global_models_payload(
state: &AppState,
provider_id: &str,
global_model_ids: Vec<String>,
) -> Result<serde_json::Value, String> {
let existing_models = state
.list_admin_provider_models(&AdminProviderModelListQuery {
provider_id: provider_id.to_string(),
is_active: None,
offset: 0,
limit: 10_000,
})
.await
.map_err(|err| format!("{err:?}"))?;
let existing_global_model_ids = existing_models
.into_iter()
.map(|model| model.global_model_id)
.collect::<BTreeSet<_>>();
let mut success = Vec::new();
let mut errors = Vec::new();
for global_model_id in global_model_ids {
let global_model_id = global_model_id.trim().to_string();
if global_model_id.is_empty() {
continue;
}
let global_model =
match resolve_admin_global_model_by_id_or_err(state, &global_model_id).await {
Ok(model) => model,
Err(detail) => {
errors.push(json!({
"global_model_id": global_model_id,
"error": detail,
}));
continue;
}
};
if existing_global_model_ids.contains(&global_model.id) {
errors.push(json!({
"global_model_id": global_model.id,
"error": "Model already exists",
}));
continue;
}
let record = UpsertAdminProviderModelRecord::new(
Uuid::new_v4().to_string(),
provider_id.to_string(),
global_model.id.clone(),
global_model.name.clone(),
None,
None,
None,
None,
None,
None,
None,
None,
true,
true,
None,
)
.map_err(|err| err.to_string())?;
match state.create_admin_provider_model(&record).await {
Ok(Some(created)) => success.push(json!({
"global_model_id": global_model.id,
"global_model_name": global_model.name,
"provider_model_id": created.id,
})),
Ok(None) => errors.push(json!({
"global_model_id": global_model.id,
"error": "Create provider model failed",
})),
Err(err) => errors.push(json!({
"global_model_id": global_model.id,
"error": format!("{err:?}"),
})),
}
}
Ok(json!({
"success": success,
"errors": errors,
}))
}
pub(crate) async fn build_admin_import_provider_models_payload(
state: &AppState,
provider_id: &str,
payload: AdminImportProviderModelsRequest,
) -> Result<serde_json::Value, String> {
let default_pricing = json!({
"tiers": [{
"up_to": null,
"input_price_per_1m": 0.0,
"output_price_per_1m": 0.0,
}]
});
let tiered_pricing = normalize_json_object(payload.tiered_pricing, "tiered_pricing")?;
let existing_models = state
.list_admin_provider_models(&AdminProviderModelListQuery {
provider_id: provider_id.to_string(),
is_active: None,
offset: 0,
limit: 10_000,
})
.await
.map_err(|err| format!("{err:?}"))?;
let mut existing_by_name = existing_models
.iter()
.map(|model| (model.provider_model_name.clone(), model.clone()))
.collect::<BTreeMap<_, _>>();
let mut success = Vec::new();
let mut errors = Vec::new();
for model_id in payload.model_ids {
let trimmed = model_id.trim();
if trimmed.is_empty() || trimmed.len() > 100 {
errors.push(json!({
"model_id": if trimmed.is_empty() { "<empty>" } else { trimmed },
"error": "Invalid model_id: must be 1-100 characters",
}));
continue;
}
if let Some(existing) = existing_by_name.get(trimmed) {
success.push(json!({
"model_id": trimmed,
"global_model_id": existing.global_model_id,
"global_model_name": existing.global_model_name,
"provider_model_id": existing.id,
"created_global_model": false,
}));
continue;
}
let mut created_global_model = false;
let global_model = if let Some(existing) = state
.get_admin_global_model_by_name(trimmed)
.await
.map_err(|err| format!("{err:?}"))?
{
existing
} else {
let created = state
.create_admin_global_model(
&CreateAdminGlobalModelRecord::new(
Uuid::new_v4().to_string(),
trimmed.to_string(),
trimmed.to_string(),
true,
payload.price_per_request,
tiered_pricing
.clone()
.or_else(|| Some(default_pricing.clone())),
None,
None,
)
.map_err(|err| err.to_string())?,
)
.await
.map_err(|err| format!("{err:?}"))?;
let Some(created) = created else {
errors.push(json!({"model_id": trimmed, "error": "Create GlobalModel failed"}));
continue;
};
created_global_model = true;
created
};
let record = UpsertAdminProviderModelRecord::new(
Uuid::new_v4().to_string(),
provider_id.to_string(),
global_model.id.clone(),
trimmed.to_string(),
None,
payload.price_per_request,
tiered_pricing.clone(),
None,
None,
None,
None,
None,
true,
true,
None,
)
.map_err(|err| err.to_string())?;
match state.create_admin_provider_model(&record).await {
Ok(Some(created)) => {
existing_by_name.insert(trimmed.to_string(), created.clone());
success.push(json!({
"model_id": trimmed,
"global_model_id": global_model.id,
"global_model_name": global_model.name,
"provider_model_id": created.id,
"created_global_model": created_global_model,
}));
}
Ok(None) => {
errors.push(json!({"model_id": trimmed, "error": "Create model failed"}));
}
Err(err) => {
errors.push(json!({"model_id": trimmed, "error": format!("{err:?}")}));
}
}
}
Ok(json!({ "success": success, "errors": errors }))
}