1440 lines
53 KiB
Rust
1440 lines
53 KiB
Rust
use axum::{
|
||
Json,
|
||
extract::{Extension, Query, State},
|
||
http::StatusCode,
|
||
};
|
||
use module_assets::{
|
||
AssetObjectAccessPolicy, AssetObjectFieldError, INITIAL_ASSET_OBJECT_VERSION,
|
||
build_asset_entity_binding_input, build_asset_object_upsert_input, generate_asset_binding_id,
|
||
generate_asset_object_id, normalize_optional_value, validate_asset_object_fields,
|
||
};
|
||
use platform_oss::{
|
||
LegacyAssetPrefix, OssHeadObjectRequest, OssObjectAccess, OssPostObjectRequest,
|
||
OssSignedGetObjectUrlRequest,
|
||
};
|
||
use serde_json::{Value, json};
|
||
use shared_contracts::assets::{
|
||
AssetBindingPayload, AssetHistoryEntryPayload, AssetHistoryListResponse, AssetHistoryQuery,
|
||
AssetObjectPayload, AssetReadUrlPayload, BindAssetObjectRequest, BindAssetObjectResponse,
|
||
ConfirmAssetObjectAccessPolicy, ConfirmAssetObjectRequest, ConfirmAssetObjectResponse,
|
||
CreateDirectUploadTicketRequest, CreateDirectUploadTicketResponse, DirectUploadTicketPayload,
|
||
GetAssetReadUrlResponse, GetReadUrlQuery,
|
||
};
|
||
use spacetime_client::SpacetimeClientError;
|
||
|
||
use crate::{
|
||
api_response::json_success_body, auth::AuthenticatedAccessToken, http_error::AppError,
|
||
request_context::RequestContext, state::AppState,
|
||
};
|
||
|
||
// 历史素材类型需要与 SpacetimeDB 侧白名单保持同一口径，避免新增素材类型时 HTTP 门面漏同步。
|
||
const SUPPORTED_ASSET_HISTORY_KINDS: [&str; 3] =
|
||
["character_visual", "scene_image", "puzzle_cover_image"];
|
||
|
||
pub async fn create_direct_upload_ticket(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Json(payload): Json<CreateDirectUploadTicketRequest>,
|
||
) -> Result<Json<Value>, AppError> {
|
||
let oss_client = state.oss_client().ok_or_else(|| {
|
||
AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
|
||
"provider": "aliyun-oss",
|
||
"reason": "OSS 未完成环境变量配置",
|
||
}))
|
||
})?;
|
||
|
||
let legacy_prefix = LegacyAssetPrefix::parse(&payload.legacy_prefix).ok_or_else(|| {
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"field": "legacyPrefix",
|
||
"supported": platform_oss::LEGACY_PUBLIC_PREFIXES,
|
||
}))
|
||
})?;
|
||
|
||
let signed = oss_client
|
||
.sign_post_object(OssPostObjectRequest {
|
||
prefix: legacy_prefix,
|
||
path_segments: payload.path_segments,
|
||
file_name: payload.file_name,
|
||
content_type: payload.content_type,
|
||
access: payload.access.unwrap_or(OssObjectAccess::Private),
|
||
metadata: payload.metadata,
|
||
max_size_bytes: payload.max_size_bytes,
|
||
expire_seconds: payload.expire_seconds,
|
||
success_action_status: payload.success_action_status,
|
||
})
|
||
.map_err(|error| {
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "aliyun-oss",
|
||
"message": error.to_string(),
|
||
}))
|
||
})?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
CreateDirectUploadTicketResponse {
|
||
upload: DirectUploadTicketPayload::from(signed),
|
||
},
|
||
))
|
||
}
|
||
|
||
pub async fn get_asset_read_url(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Query(query): Query<GetReadUrlQuery>,
|
||
) -> Result<Json<Value>, AppError> {
|
||
let oss_client = state.oss_client().ok_or_else(|| {
|
||
AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
|
||
"provider": "aliyun-oss",
|
||
"reason": "OSS 未完成环境变量配置",
|
||
}))
|
||
})?;
|
||
|
||
let object_key = resolve_object_key_from_query(&query).ok_or_else(|| {
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"field": "objectKey",
|
||
"reason": "必须提供 objectKey 或 legacyPublicPath",
|
||
}))
|
||
})?;
|
||
|
||
let signed = oss_client
|
||
.sign_get_object_url(OssSignedGetObjectUrlRequest {
|
||
object_key,
|
||
expire_seconds: query.expire_seconds,
|
||
})
|
||
.map_err(|error| {
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "aliyun-oss",
|
||
"message": error.to_string(),
|
||
}))
|
||
})?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
GetAssetReadUrlResponse {
|
||
read: AssetReadUrlPayload::from(signed),
|
||
},
|
||
))
|
||
}
|
||
|
||
pub async fn get_asset_history(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Extension(authenticated): Extension<AuthenticatedAccessToken>,
|
||
Query(query): Query<AssetHistoryQuery>,
|
||
) -> Result<Json<Value>, AppError> {
|
||
let asset_kind = query.kind.trim().to_string();
|
||
if !is_supported_asset_history_kind(asset_kind.as_str()) {
|
||
return Err(
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"field": "kind",
|
||
"message": supported_asset_history_kind_message(),
|
||
})),
|
||
);
|
||
}
|
||
|
||
let entries = state
|
||
.spacetime_client()
|
||
.list_asset_history(build_asset_history_list_input(asset_kind, query.limit))
|
||
.await
|
||
.map_err(map_confirm_asset_object_error)?;
|
||
let owner_user_id = authenticated.claims().user_id().to_string();
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
AssetHistoryListResponse {
|
||
assets: entries
|
||
.into_iter()
|
||
// 中文注释：旧 wasm 的历史素材 procedure 仍按类型返回，HTTP 门面必须兜底做账号隔离。
|
||
.filter(|entry| {
|
||
is_asset_history_owned_by(
|
||
entry.owner_user_id.as_deref(),
|
||
owner_user_id.as_str(),
|
||
)
|
||
})
|
||
.map(|entry| AssetHistoryEntryPayload {
|
||
owner_label: format_asset_owner_label(entry.owner_user_id.as_deref()),
|
||
asset_object_id: entry.asset_object_id,
|
||
asset_kind: entry.asset_kind,
|
||
image_src: entry.image_src,
|
||
owner_user_id: entry.owner_user_id,
|
||
profile_id: entry.profile_id,
|
||
entity_id: entry.entity_id,
|
||
created_at: entry.created_at,
|
||
updated_at: entry.updated_at,
|
||
})
|
||
.collect(),
|
||
},
|
||
))
|
||
}
|
||
|
||
pub async fn create_sts_upload_credentials(
|
||
Extension(_request_context): Extension<RequestContext>,
|
||
) -> Result<Json<Value>, AppError> {
|
||
Err(
|
||
AppError::from_status(StatusCode::FORBIDDEN).with_details(json!({
|
||
"provider": "aliyun-sts",
|
||
"enabled": false,
|
||
"reason": "当前上传主链为服务器上传 OSS，Web 端只负责读取，不开放浏览器 STS 写权限",
|
||
"fallback": "/api/assets/direct-upload-tickets",
|
||
})),
|
||
)
|
||
}
|
||
|
||
pub async fn confirm_asset_object(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Json(payload): Json<ConfirmAssetObjectRequest>,
|
||
) -> Result<Json<Value>, AppError> {
|
||
let oss_client = state.oss_client().ok_or_else(|| {
|
||
AppError::from_status(StatusCode::SERVICE_UNAVAILABLE).with_details(json!({
|
||
"provider": "aliyun-oss",
|
||
"reason": "OSS 未完成环境变量配置",
|
||
}))
|
||
})?;
|
||
|
||
let result = state
|
||
.spacetime_client()
|
||
.confirm_asset_object(
|
||
build_confirm_asset_object_upsert_input(oss_client, payload)
|
||
.await
|
||
.map_err(map_confirm_asset_object_prepare_error)?,
|
||
)
|
||
.await
|
||
.map_err(map_confirm_asset_object_error)?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
ConfirmAssetObjectResponse {
|
||
asset_object: AssetObjectPayload {
|
||
asset_object_id: result.asset_object_id,
|
||
bucket: result.bucket,
|
||
object_key: result.object_key,
|
||
access_policy: result.access_policy.as_str().to_string(),
|
||
content_type: result.content_type,
|
||
content_length: result.content_length,
|
||
content_hash: result.content_hash,
|
||
version: result.version,
|
||
source_job_id: result.source_job_id,
|
||
owner_user_id: result.owner_user_id,
|
||
profile_id: result.profile_id,
|
||
entity_id: result.entity_id,
|
||
asset_kind: result.asset_kind,
|
||
created_at: result.created_at,
|
||
updated_at: result.updated_at,
|
||
},
|
||
},
|
||
))
|
||
}
|
||
|
||
pub async fn bind_asset_object_to_entity(
|
||
State(state): State<AppState>,
|
||
Extension(request_context): Extension<RequestContext>,
|
||
Json(payload): Json<BindAssetObjectRequest>,
|
||
) -> Result<Json<Value>, AppError> {
|
||
let now_micros = current_utc_micros();
|
||
let input = build_asset_entity_binding_input(
|
||
generate_asset_binding_id(now_micros),
|
||
payload.asset_object_id,
|
||
payload.entity_kind,
|
||
payload.entity_id,
|
||
payload.slot,
|
||
payload.asset_kind,
|
||
payload.owner_user_id,
|
||
payload.profile_id,
|
||
now_micros,
|
||
)
|
||
.map_err(map_asset_entity_binding_prepare_error)?;
|
||
|
||
let result = state
|
||
.spacetime_client()
|
||
.bind_asset_object_to_entity(input)
|
||
.await
|
||
.map_err(map_confirm_asset_object_error)?;
|
||
|
||
Ok(json_success_body(
|
||
Some(&request_context),
|
||
BindAssetObjectResponse {
|
||
asset_binding: AssetBindingPayload {
|
||
binding_id: result.binding_id,
|
||
asset_object_id: result.asset_object_id,
|
||
entity_kind: result.entity_kind,
|
||
entity_id: result.entity_id,
|
||
slot: result.slot,
|
||
asset_kind: result.asset_kind,
|
||
owner_user_id: result.owner_user_id,
|
||
profile_id: result.profile_id,
|
||
created_at: result.created_at,
|
||
updated_at: result.updated_at,
|
||
},
|
||
},
|
||
))
|
||
}
|
||
|
||
fn resolve_object_key_from_query(query: &GetReadUrlQuery) -> Option<String> {
|
||
if let Some(object_key) = query
|
||
.object_key
|
||
.as_deref()
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
{
|
||
return Some(object_key.trim_start_matches('/').to_string());
|
||
}
|
||
|
||
query
|
||
.legacy_public_path
|
||
.as_deref()
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.map(|value| value.trim_start_matches('/').to_string())
|
||
}
|
||
|
||
fn format_asset_owner_label(owner_user_id: Option<&str>) -> String {
|
||
let Some(owner_user_id) = owner_user_id
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
else {
|
||
return "未记录账号".to_string();
|
||
};
|
||
format!("账号 {owner_user_id}")
|
||
}
|
||
|
||
fn is_supported_asset_history_kind(asset_kind: &str) -> bool {
|
||
SUPPORTED_ASSET_HISTORY_KINDS.contains(&asset_kind)
|
||
}
|
||
|
||
fn is_asset_history_owned_by(entry_owner_user_id: Option<&str>, owner_user_id: &str) -> bool {
|
||
let owner_user_id = owner_user_id.trim();
|
||
!owner_user_id.is_empty()
|
||
&& entry_owner_user_id
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
== Some(owner_user_id)
|
||
}
|
||
|
||
fn build_asset_history_list_input(
|
||
asset_kind: String,
|
||
limit: Option<u32>,
|
||
) -> module_assets::AssetHistoryListInput {
|
||
module_assets::AssetHistoryListInput {
|
||
asset_kind,
|
||
limit: limit.unwrap_or(120).clamp(1, 120),
|
||
}
|
||
}
|
||
|
||
fn supported_asset_history_kind_message() -> String {
|
||
format!(
|
||
"历史素材类型只支持 {}",
|
||
SUPPORTED_ASSET_HISTORY_KINDS.join("、")
|
||
)
|
||
}
|
||
|
||
async fn build_confirm_asset_object_upsert_input(
|
||
oss_client: &platform_oss::OssClient,
|
||
payload: ConfirmAssetObjectRequest,
|
||
) -> Result<module_assets::AssetObjectUpsertInput, ConfirmAssetObjectPrepareError> {
|
||
let configured_bucket = oss_client.config_bucket().to_string();
|
||
let resolved_bucket = payload
|
||
.bucket
|
||
.as_deref()
|
||
.map(str::trim)
|
||
.filter(|value| !value.is_empty())
|
||
.unwrap_or(configured_bucket.as_str())
|
||
.to_string();
|
||
|
||
if resolved_bucket != configured_bucket {
|
||
return Err(ConfirmAssetObjectPrepareError::BucketMismatch);
|
||
}
|
||
|
||
validate_asset_object_fields(
|
||
&resolved_bucket,
|
||
&payload.object_key,
|
||
&payload.asset_kind,
|
||
INITIAL_ASSET_OBJECT_VERSION,
|
||
)
|
||
.map_err(ConfirmAssetObjectPrepareError::Field)?;
|
||
|
||
let head = oss_client
|
||
.head_object(
|
||
&reqwest::Client::new(),
|
||
OssHeadObjectRequest {
|
||
object_key: payload.object_key,
|
||
},
|
||
)
|
||
.await
|
||
.map_err(ConfirmAssetObjectPrepareError::Oss)?;
|
||
|
||
if let Some(expected_length) = payload.content_length
|
||
&& expected_length != head.content_length
|
||
{
|
||
return Err(ConfirmAssetObjectPrepareError::ContentLengthMismatch);
|
||
}
|
||
|
||
let now_micros = current_utc_micros();
|
||
build_asset_object_upsert_input(
|
||
generate_asset_object_id(now_micros),
|
||
resolved_bucket,
|
||
head.object_key,
|
||
payload
|
||
.access_policy
|
||
.map(map_confirm_asset_object_access_policy)
|
||
.unwrap_or(AssetObjectAccessPolicy::Private),
|
||
head.content_type
|
||
.or_else(|| normalize_optional_value(payload.content_type)),
|
||
head.content_length,
|
||
normalize_optional_value(payload.content_hash),
|
||
payload.asset_kind,
|
||
payload.source_job_id,
|
||
payload.owner_user_id,
|
||
payload.profile_id,
|
||
payload.entity_id,
|
||
now_micros,
|
||
)
|
||
.map_err(ConfirmAssetObjectPrepareError::Field)
|
||
}
|
||
|
||
fn map_confirm_asset_object_prepare_error(error: ConfirmAssetObjectPrepareError) -> AppError {
|
||
match error {
|
||
ConfirmAssetObjectPrepareError::BucketMismatch
|
||
| ConfirmAssetObjectPrepareError::ContentLengthMismatch
|
||
| ConfirmAssetObjectPrepareError::Field(_) => {
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "asset-object",
|
||
"message": error.to_string(),
|
||
}))
|
||
}
|
||
ConfirmAssetObjectPrepareError::Oss(platform_oss::OssError::ObjectNotFound(_)) => {
|
||
AppError::from_status(StatusCode::NOT_FOUND).with_details(json!({
|
||
"provider": "aliyun-oss",
|
||
"message": error.to_string(),
|
||
}))
|
||
}
|
||
ConfirmAssetObjectPrepareError::Oss(_) => AppError::from_status(StatusCode::BAD_GATEWAY)
|
||
.with_details(json!({
|
||
"provider": "aliyun-oss",
|
||
"message": error.to_string(),
|
||
})),
|
||
}
|
||
}
|
||
|
||
fn map_asset_entity_binding_prepare_error(error: AssetObjectFieldError) -> AppError {
|
||
AppError::from_status(StatusCode::BAD_REQUEST).with_details(json!({
|
||
"provider": "asset-entity-binding",
|
||
"message": error.to_string(),
|
||
}))
|
||
}
|
||
|
||
fn map_confirm_asset_object_error(error: SpacetimeClientError) -> AppError {
|
||
AppError::from_status(StatusCode::BAD_GATEWAY).with_details(json!({
|
||
"provider": "spacetimedb",
|
||
"message": error.to_string(),
|
||
}))
|
||
}
|
||
|
||
fn current_utc_micros() -> i64 {
|
||
use std::time::{SystemTime, UNIX_EPOCH};
|
||
|
||
let duration = SystemTime::now()
|
||
.duration_since(UNIX_EPOCH)
|
||
.expect("system clock should be after unix epoch");
|
||
i64::try_from(duration.as_micros()).expect("current unix micros should fit in i64")
|
||
}
|
||
|
||
#[derive(Debug)]
|
||
enum ConfirmAssetObjectPrepareError {
|
||
BucketMismatch,
|
||
ContentLengthMismatch,
|
||
Field(AssetObjectFieldError),
|
||
Oss(platform_oss::OssError),
|
||
}
|
||
|
||
impl std::fmt::Display for ConfirmAssetObjectPrepareError {
|
||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||
match self {
|
||
Self::BucketMismatch => f.write_str("bucket 与当前服务端 OSS bucket 不一致"),
|
||
Self::ContentLengthMismatch => {
|
||
f.write_str("客户端声明的 contentLength 与 OSS 实际对象大小不一致")
|
||
}
|
||
Self::Field(error) => write!(f, "{error}"),
|
||
Self::Oss(error) => write!(f, "{error}"),
|
||
}
|
||
}
|
||
}
|
||
|
||
fn map_confirm_asset_object_access_policy(
|
||
value: ConfirmAssetObjectAccessPolicy,
|
||
) -> AssetObjectAccessPolicy {
|
||
match value {
|
||
ConfirmAssetObjectAccessPolicy::Private => AssetObjectAccessPolicy::Private,
|
||
ConfirmAssetObjectAccessPolicy::PublicRead => AssetObjectAccessPolicy::PublicRead,
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use std::{
|
||
collections::BTreeMap,
|
||
error::Error,
|
||
fs,
|
||
path::{Path, PathBuf},
|
||
time::SystemTime,
|
||
};
|
||
|
||
use axum::{
|
||
body::Body,
|
||
http::{Request, StatusCode},
|
||
};
|
||
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
|
||
use hmac::{Hmac, Mac};
|
||
use http_body_util::BodyExt;
|
||
use httpdate::fmt_http_date;
|
||
use reqwest::{Method, multipart};
|
||
use serde_json::{Value, json};
|
||
use sha1::Sha1;
|
||
use shared_kernel::new_uuid_simple_string;
|
||
use tower::ServiceExt;
|
||
|
||
use crate::{app::build_router, config::AppConfig, state::AppState};
|
||
|
||
type HmacSha1 = Hmac<Sha1>;
|
||
|
||
#[test]
|
||
fn asset_history_kind_support_includes_puzzle_cover_image() {
|
||
assert!(super::is_supported_asset_history_kind("character_visual"));
|
||
assert!(super::is_supported_asset_history_kind("scene_image"));
|
||
assert!(super::is_supported_asset_history_kind("puzzle_cover_image"));
|
||
assert!(!super::is_supported_asset_history_kind(
|
||
"puzzle_preview_image"
|
||
));
|
||
}
|
||
|
||
#[test]
|
||
fn asset_history_kind_message_lists_all_supported_kinds() {
|
||
assert_eq!(
|
||
super::supported_asset_history_kind_message(),
|
||
"历史素材类型只支持 character_visual、scene_image、puzzle_cover_image"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn asset_history_owner_filter_keeps_only_authenticated_owner_assets() {
|
||
assert!(super::is_asset_history_owned_by(
|
||
Some("user-current"),
|
||
"user-current"
|
||
));
|
||
assert!(!super::is_asset_history_owned_by(
|
||
Some("user-other"),
|
||
"user-current"
|
||
));
|
||
assert!(!super::is_asset_history_owned_by(None, "user-current"));
|
||
assert!(!super::is_asset_history_owned_by(Some("user-current"), ""));
|
||
}
|
||
|
||
#[test]
|
||
fn asset_history_input_clamps_limit_for_spacetime_query() {
|
||
let input =
|
||
super::build_asset_history_list_input("puzzle_cover_image".to_string(), Some(240));
|
||
|
||
assert_eq!(input.asset_kind, "puzzle_cover_image");
|
||
assert_eq!(input.limit, 120);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn direct_upload_ticket_returns_service_unavailable_when_oss_missing() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/direct-upload-tickets")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(
|
||
json!({
|
||
"legacyPrefix": "/generated-characters/*",
|
||
"pathSegments": ["hero", "visual", "asset-01"],
|
||
"fileName": "master.png"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(
|
||
payload["error"]["code"],
|
||
Value::String("SERVICE_UNAVAILABLE".to_string())
|
||
);
|
||
assert_eq!(
|
||
payload["error"]["details"]["provider"],
|
||
Value::String("aliyun-oss".to_string())
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn direct_upload_ticket_returns_signed_payload_when_oss_configured() {
|
||
let config = AppConfig {
|
||
oss_bucket: Some("genarrative-assets".to_string()),
|
||
oss_endpoint: Some("oss-cn-shanghai.aliyuncs.com".to_string()),
|
||
oss_access_key_id: Some("test-access-key-id".to_string()),
|
||
oss_access_key_secret: Some("test-access-key-secret".to_string()),
|
||
..AppConfig::default()
|
||
};
|
||
|
||
let app = build_router(AppState::new(config).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/direct-upload-tickets")
|
||
.header("content-type", "application/json")
|
||
.header("x-request-id", "req-oss-ticket")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::from(
|
||
json!({
|
||
"legacyPrefix": "/generated-characters/*",
|
||
"pathSegments": ["hero_001", "visual", "asset_01"],
|
||
"fileName": "master.png",
|
||
"contentType": "image/png",
|
||
"metadata": {
|
||
"asset-kind": "character-visual"
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(payload["ok"], Value::Bool(true));
|
||
assert_eq!(
|
||
payload["data"]["upload"]["bucket"],
|
||
Value::String("genarrative-assets".to_string())
|
||
);
|
||
assert_eq!(
|
||
payload["data"]["upload"]["objectKey"],
|
||
Value::String("generated-characters/hero_001/visual/asset_01/master.png".to_string())
|
||
);
|
||
assert_eq!(
|
||
payload["data"]["upload"]["access"],
|
||
Value::String("private".to_string())
|
||
);
|
||
assert_eq!(
|
||
payload["data"]["upload"]["formFields"]["OSSAccessKeyId"],
|
||
Value::String("test-access-key-id".to_string())
|
||
);
|
||
assert!(payload["data"]["upload"].get("publicUrl").is_none());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn read_url_returns_signed_private_object_url_when_oss_configured() {
|
||
let config = AppConfig {
|
||
oss_bucket: Some("genarrative-assets".to_string()),
|
||
oss_endpoint: Some("oss-cn-shanghai.aliyuncs.com".to_string()),
|
||
oss_access_key_id: Some("test-access-key-id".to_string()),
|
||
oss_access_key_secret: Some("test-access-key-secret".to_string()),
|
||
..AppConfig::default()
|
||
};
|
||
|
||
let app = build_router(AppState::new(config).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/assets/read-url?objectKey=generated-characters/hero_001/visual/asset_01/master.png")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(payload["ok"], Value::Bool(true));
|
||
assert_eq!(
|
||
payload["data"]["read"]["objectKey"],
|
||
Value::String("generated-characters/hero_001/visual/asset_01/master.png".to_string())
|
||
);
|
||
assert!(
|
||
payload["data"]["read"]["signedUrl"]
|
||
.as_str()
|
||
.is_some_and(|value| value.contains("OSSAccessKeyId=test-access-key-id"))
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn read_url_accepts_legacy_public_path_for_transition() {
|
||
let config = AppConfig {
|
||
oss_bucket: Some("genarrative-assets".to_string()),
|
||
oss_endpoint: Some("oss-cn-shanghai.aliyuncs.com".to_string()),
|
||
oss_access_key_id: Some("test-access-key-id".to_string()),
|
||
oss_access_key_secret: Some("test-access-key-secret".to_string()),
|
||
..AppConfig::default()
|
||
};
|
||
|
||
let app = build_router(AppState::new(config).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/assets/read-url?legacyPublicPath=%2Fgenerated-custom-world-scenes%2Fprofile_01%2Flandmark_01%2Fscene.png")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::OK);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(
|
||
payload["read"]["objectKey"],
|
||
Value::String(
|
||
"generated-custom-world-scenes/profile_01/landmark_01/scene.png".to_string()
|
||
)
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn read_url_rejects_missing_identifier() {
|
||
let config = AppConfig {
|
||
oss_bucket: Some("genarrative-assets".to_string()),
|
||
oss_endpoint: Some("oss-cn-shanghai.aliyuncs.com".to_string()),
|
||
oss_access_key_id: Some("test-access-key-id".to_string()),
|
||
oss_access_key_secret: Some("test-access-key-secret".to_string()),
|
||
..AppConfig::default()
|
||
};
|
||
|
||
let app = build_router(AppState::new(config).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri("/api/assets/read-url")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn sts_upload_credentials_are_disabled_for_browser_writes() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/sts-upload-credentials")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::FORBIDDEN);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(
|
||
payload["error"]["details"]["provider"],
|
||
Value::String("aliyun-sts".to_string())
|
||
);
|
||
assert_eq!(payload["error"]["details"]["enabled"], Value::Bool(false));
|
||
assert!(payload["error"]["details"].get("credentials").is_none());
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn confirm_asset_object_returns_service_unavailable_when_oss_missing() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/objects/confirm")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(
|
||
json!({
|
||
"objectKey": "generated-characters/hero_001/visual/asset_404/master.png",
|
||
"assetKind": "character_visual"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::SERVICE_UNAVAILABLE);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn confirm_asset_object_rejects_bucket_mismatch_before_calling_oss() {
|
||
let config = AppConfig {
|
||
oss_bucket: Some("xushi-dev".to_string()),
|
||
oss_endpoint: Some("oss-cn-beijing.aliyuncs.com".to_string()),
|
||
oss_access_key_id: Some("test-access-key-id".to_string()),
|
||
oss_access_key_secret: Some("test-access-key-secret".to_string()),
|
||
..AppConfig::default()
|
||
};
|
||
|
||
let app = build_router(AppState::new(config).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/objects/confirm")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(
|
||
json!({
|
||
"bucket": "another-bucket",
|
||
"objectKey": "generated-characters/hero_001/visual/asset_404/master.png",
|
||
"assetKind": "character_visual"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(
|
||
response.status(),
|
||
StatusCode::BAD_REQUEST,
|
||
"bucket 不一致应在发 OSS 请求前直接被拒绝"
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
async fn bind_asset_object_rejects_missing_slot_before_calling_spacetime() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/objects/bind")
|
||
.header("content-type", "application/json")
|
||
.body(Body::from(
|
||
json!({
|
||
"assetObjectId": "assetobj_001",
|
||
"entityKind": "character",
|
||
"entityId": "hero_001",
|
||
"slot": " ",
|
||
"assetKind": "character_visual"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::BAD_REQUEST);
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
assert_eq!(
|
||
payload["error"]["details"]["provider"],
|
||
Value::String("asset-entity-binding".to_string())
|
||
);
|
||
}
|
||
|
||
#[tokio::test]
|
||
#[ignore = "需要本地 SpacetimeDB genarrative-dev 已启动并发布当前模块"]
|
||
async fn bind_asset_object_rejects_missing_asset_object_in_spacetime() {
|
||
let app = build_router(AppState::new(AppConfig::default()).expect("state should build"));
|
||
|
||
let response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/objects/bind")
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::from(
|
||
json!({
|
||
"assetObjectId": "assetobj_missing_for_binding_test",
|
||
"entityKind": "character",
|
||
"entityId": "hero_001",
|
||
"slot": "primary_visual",
|
||
"assetKind": "character_visual"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
assert_eq!(response.status(), StatusCode::BAD_GATEWAY);
|
||
}
|
||
|
||
#[tokio::test]
|
||
#[ignore = "需要仓库根目录 .env / .env.local 中的真实 OSS 配置"]
|
||
async fn oss_live_roundtrip_works_with_private_bucket() {
|
||
let config = load_live_oss_config().expect("live OSS config should load");
|
||
let client = reqwest::Client::new();
|
||
let mut uploaded_object_key: Option<String> = None;
|
||
|
||
let test_result = async {
|
||
let bucket_head = send_signed_oss_request(&client, &config, Method::HEAD, None).await?;
|
||
ensure_success_status(bucket_head.status().as_u16(), "bucket HEAD 应成功")?;
|
||
|
||
let app = build_router(AppState::new(config.clone()).expect("state should build"));
|
||
let run_id = new_uuid_simple_string();
|
||
let file_name = format!("oss-live-{run_id}.txt");
|
||
let file_content = format!("Genarrative OSS Rust live test {run_id}");
|
||
|
||
let response = app
|
||
.clone()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/direct-upload-tickets")
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::from(
|
||
json!({
|
||
"legacyPrefix": "/generated-character-drafts/*",
|
||
"pathSegments": ["rust-live-test", run_id],
|
||
"fileName": file_name,
|
||
"contentType": "text/plain",
|
||
"metadata": {
|
||
"origin": "cargo-test",
|
||
"asset-kind": "manual-test"
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
if response.status() != StatusCode::OK {
|
||
return Err(std::io::Error::other(format!(
|
||
"直传票据接口返回了非预期状态码：{}",
|
||
response.status()
|
||
))
|
||
.into());
|
||
}
|
||
|
||
let body = response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let payload: Value =
|
||
serde_json::from_slice(&body).expect("response body should be valid json");
|
||
|
||
let upload = payload["data"]["upload"].clone();
|
||
let upload_host = upload["host"]
|
||
.as_str()
|
||
.ok_or_else(|| std::io::Error::other("upload.host 缺失"))?
|
||
.to_string();
|
||
let object_key = upload["objectKey"]
|
||
.as_str()
|
||
.ok_or_else(|| std::io::Error::other("upload.objectKey 缺失"))?
|
||
.to_string();
|
||
uploaded_object_key = Some(object_key.clone());
|
||
|
||
let mut form = multipart::Form::new();
|
||
for (key, value) in read_form_fields(&upload)? {
|
||
form = form.text(key, value);
|
||
}
|
||
form = form.part(
|
||
"file",
|
||
multipart::Part::text(file_content.clone())
|
||
.file_name("oss-live-test.txt")
|
||
.mime_str("text/plain")?,
|
||
);
|
||
|
||
let upload_response = client.post(upload_host).multipart(form).send().await?;
|
||
ensure_success_status(upload_response.status().as_u16(), "PostObject 上传应成功")?;
|
||
|
||
let public_response = client
|
||
.head(build_object_url(&config, &object_key)?)
|
||
.send()
|
||
.await?;
|
||
if public_response.status().as_u16() != 403 {
|
||
return Err(std::io::Error::other(format!(
|
||
"私有对象匿名读取应返回 403，实际为 {}",
|
||
public_response.status()
|
||
))
|
||
.into());
|
||
}
|
||
|
||
let read_response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("GET")
|
||
.uri(format!("/api/assets/read-url?objectKey={object_key}"))
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::empty())
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
if read_response.status() != StatusCode::OK {
|
||
return Err(std::io::Error::other(format!(
|
||
"私有读签名接口返回了非预期状态码：{}",
|
||
read_response.status()
|
||
))
|
||
.into());
|
||
}
|
||
|
||
let read_body = read_response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let read_payload: Value =
|
||
serde_json::from_slice(&read_body).expect("response body should be valid json");
|
||
let signed_url = read_payload["data"]["read"]["signedUrl"]
|
||
.as_str()
|
||
.ok_or_else(|| std::io::Error::other("read.signedUrl 缺失"))?;
|
||
|
||
let signed_read = client.get(signed_url).send().await?;
|
||
ensure_success_status(signed_read.status().as_u16(), "签名读应成功")?;
|
||
let signed_content = signed_read.text().await?;
|
||
if signed_content != file_content {
|
||
return Err(std::io::Error::other("签名读回来的对象内容与上传内容不一致").into());
|
||
}
|
||
|
||
Ok::<(), Box<dyn Error>>(())
|
||
}
|
||
.await;
|
||
|
||
if let Some(object_key) = uploaded_object_key.as_deref() {
|
||
let delete_result =
|
||
send_signed_oss_request(&client, &config, Method::DELETE, Some(object_key)).await;
|
||
if let Ok(response) = delete_result {
|
||
ensure_success_status(response.status().as_u16(), "测试对象删除应成功")
|
||
.expect("cleanup should succeed");
|
||
}
|
||
}
|
||
|
||
test_result.expect("live OSS roundtrip should succeed");
|
||
}
|
||
|
||
#[tokio::test]
|
||
#[ignore = "需要仓库根目录 .env / .env.local 中的真实 OSS 配置"]
|
||
async fn confirm_asset_object_live_roundtrip_persists_confirmed_record() {
|
||
let config = load_live_oss_config().expect("live OSS config should load");
|
||
let client = reqwest::Client::new();
|
||
let mut uploaded_object_key: Option<String> = None;
|
||
|
||
let test_result = async {
|
||
let app = build_router(AppState::new(config.clone()).expect("state should build"));
|
||
let run_id = new_uuid_simple_string();
|
||
let file_content = format!("Genarrative confirm asset object live test {run_id}");
|
||
|
||
let ticket_response = app
|
||
.clone()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/direct-upload-tickets")
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::from(
|
||
json!({
|
||
"legacyPrefix": "/generated-characters/*",
|
||
"pathSegments": ["confirm-live-test", run_id],
|
||
"fileName": "master.txt",
|
||
"contentType": "text/plain",
|
||
"metadata": {
|
||
"origin": "cargo-test",
|
||
"asset-kind": "character-visual"
|
||
}
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
let ticket_body = ticket_response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let ticket_payload: Value =
|
||
serde_json::from_slice(&ticket_body).expect("response body should be valid json");
|
||
let upload = ticket_payload["data"]["upload"].clone();
|
||
let object_key = upload["objectKey"]
|
||
.as_str()
|
||
.ok_or_else(|| std::io::Error::other("upload.objectKey 缺失"))?
|
||
.to_string();
|
||
let upload_host = upload["host"]
|
||
.as_str()
|
||
.ok_or_else(|| std::io::Error::other("upload.host 缺失"))?
|
||
.to_string();
|
||
uploaded_object_key = Some(object_key.clone());
|
||
|
||
let mut form = multipart::Form::new();
|
||
for (key, value) in read_form_fields(&upload)? {
|
||
form = form.text(key, value);
|
||
}
|
||
form = form.part(
|
||
"file",
|
||
multipart::Part::text(file_content)
|
||
.file_name("master.txt")
|
||
.mime_str("text/plain")?,
|
||
);
|
||
|
||
let upload_response = client.post(upload_host).multipart(form).send().await?;
|
||
ensure_success_status(upload_response.status().as_u16(), "PostObject 上传应成功")?;
|
||
|
||
let confirm_response = app
|
||
.clone()
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/objects/confirm")
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::from(
|
||
json!({
|
||
"objectKey": object_key,
|
||
"assetKind": "character_visual",
|
||
"accessPolicy": "private"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
if confirm_response.status() != StatusCode::OK {
|
||
return Err(std::io::Error::other(format!(
|
||
"对象确认接口返回了非预期状态码：{}",
|
||
confirm_response.status()
|
||
))
|
||
.into());
|
||
}
|
||
|
||
let confirm_body = confirm_response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let confirm_payload: Value =
|
||
serde_json::from_slice(&confirm_body).expect("response body should be valid json");
|
||
|
||
assert!(
|
||
confirm_payload["data"]["assetObject"]["assetObjectId"]
|
||
.as_str()
|
||
.is_some_and(|value| value.starts_with("assetobj_"))
|
||
);
|
||
assert_eq!(
|
||
confirm_payload["data"]["assetObject"]["bucket"],
|
||
Value::String(
|
||
config
|
||
.oss_bucket
|
||
.clone()
|
||
.expect("live config should have bucket")
|
||
)
|
||
);
|
||
assert_eq!(
|
||
confirm_payload["data"]["assetObject"]["accessPolicy"],
|
||
Value::String("private".to_string())
|
||
);
|
||
|
||
let asset_object_id = confirm_payload["data"]["assetObject"]["assetObjectId"]
|
||
.as_str()
|
||
.ok_or_else(|| std::io::Error::other("assetObjectId 缺失"))?
|
||
.to_string();
|
||
let bind_response = app
|
||
.oneshot(
|
||
Request::builder()
|
||
.method("POST")
|
||
.uri("/api/assets/objects/bind")
|
||
.header("content-type", "application/json")
|
||
.header("x-genarrative-response-envelope", "1")
|
||
.body(Body::from(
|
||
json!({
|
||
"assetObjectId": asset_object_id,
|
||
"entityKind": "character",
|
||
"entityId": format!("hero_{run_id}"),
|
||
"slot": "primary_visual",
|
||
"assetKind": "character_visual"
|
||
})
|
||
.to_string(),
|
||
))
|
||
.expect("request should build"),
|
||
)
|
||
.await
|
||
.expect("request should succeed");
|
||
|
||
if bind_response.status() != StatusCode::OK {
|
||
return Err(std::io::Error::other(format!(
|
||
"对象绑定接口返回了非预期状态码：{}",
|
||
bind_response.status()
|
||
))
|
||
.into());
|
||
}
|
||
|
||
let bind_body = bind_response
|
||
.into_body()
|
||
.collect()
|
||
.await
|
||
.expect("body should collect")
|
||
.to_bytes();
|
||
let bind_payload: Value =
|
||
serde_json::from_slice(&bind_body).expect("response body should be valid json");
|
||
|
||
assert!(
|
||
bind_payload["data"]["assetBinding"]["bindingId"]
|
||
.as_str()
|
||
.is_some_and(|value| value.starts_with("assetbind_"))
|
||
);
|
||
assert_eq!(
|
||
bind_payload["data"]["assetBinding"]["assetObjectId"],
|
||
Value::String(asset_object_id)
|
||
);
|
||
assert_eq!(
|
||
bind_payload["data"]["assetBinding"]["slot"],
|
||
Value::String("primary_visual".to_string())
|
||
);
|
||
|
||
Ok::<(), Box<dyn Error>>(())
|
||
}
|
||
.await;
|
||
|
||
if let Some(object_key) = uploaded_object_key.as_deref() {
|
||
let delete_result =
|
||
send_signed_oss_request(&client, &config, Method::DELETE, Some(object_key)).await;
|
||
if let Ok(response) = delete_result {
|
||
ensure_success_status(response.status().as_u16(), "测试对象删除应成功")
|
||
.expect("cleanup should succeed");
|
||
}
|
||
}
|
||
|
||
test_result.expect("live asset confirm roundtrip should succeed");
|
||
}
|
||
|
||
fn load_live_oss_config() -> Result<AppConfig, Box<dyn Error>> {
|
||
let repo_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||
.join("..")
|
||
.join("..")
|
||
.join("..")
|
||
.canonicalize()?;
|
||
let mut env_map = BTreeMap::new();
|
||
|
||
read_env_file(&repo_root.join(".env"), &mut env_map)?;
|
||
read_env_file(&repo_root.join(".env.local"), &mut env_map)?;
|
||
|
||
Ok(AppConfig {
|
||
oss_bucket: Some(read_required_env(&env_map, "ALIYUN_OSS_BUCKET")?),
|
||
oss_endpoint: Some(read_required_env(&env_map, "ALIYUN_OSS_ENDPOINT")?),
|
||
oss_access_key_id: Some(read_required_env(&env_map, "ALIYUN_OSS_ACCESS_KEY_ID")?),
|
||
oss_access_key_secret: Some(read_required_env(
|
||
&env_map,
|
||
"ALIYUN_OSS_ACCESS_KEY_SECRET",
|
||
)?),
|
||
..AppConfig::default()
|
||
})
|
||
}
|
||
|
||
fn read_env_file(
|
||
path: &Path,
|
||
target: &mut BTreeMap<String, String>,
|
||
) -> Result<(), Box<dyn Error>> {
|
||
if !path.exists() {
|
||
return Ok(());
|
||
}
|
||
|
||
let content = fs::read_to_string(path)?;
|
||
for line in content.lines() {
|
||
let trimmed = line.trim();
|
||
if trimmed.is_empty() || trimmed.starts_with('#') {
|
||
continue;
|
||
}
|
||
|
||
let Some((key, value)) = trimmed.split_once('=') else {
|
||
continue;
|
||
};
|
||
|
||
let value = value.trim().trim_matches('"').to_string();
|
||
target.insert(key.trim().to_string(), value);
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
fn read_required_env(
|
||
env_map: &BTreeMap<String, String>,
|
||
key: &str,
|
||
) -> Result<String, Box<dyn Error>> {
|
||
env_map
|
||
.get(key)
|
||
.map(|value| value.trim().to_string())
|
||
.filter(|value| !value.is_empty())
|
||
.ok_or_else(|| std::io::Error::other(format!("缺少 {key}")).into())
|
||
}
|
||
|
||
fn read_form_fields(upload: &Value) -> Result<Vec<(String, String)>, Box<dyn Error>> {
|
||
let form_fields = upload["formFields"]
|
||
.as_object()
|
||
.ok_or_else(|| std::io::Error::other("upload.formFields 缺失"))?;
|
||
|
||
let mut fields = Vec::with_capacity(form_fields.len());
|
||
for (key, value) in form_fields {
|
||
let value = value
|
||
.as_str()
|
||
.ok_or_else(|| std::io::Error::other(format!("formFields.{key} 不是字符串")))?;
|
||
fields.push((key.clone(), value.to_string()));
|
||
}
|
||
|
||
Ok(fields)
|
||
}
|
||
|
||
fn build_object_url(
|
||
config: &AppConfig,
|
||
object_key: &str,
|
||
) -> Result<reqwest::Url, Box<dyn Error>> {
|
||
let bucket = config
|
||
.oss_bucket
|
||
.as_deref()
|
||
.ok_or_else(|| std::io::Error::other("缺少 oss bucket"))?;
|
||
let endpoint = config
|
||
.oss_endpoint
|
||
.as_deref()
|
||
.ok_or_else(|| std::io::Error::other("缺少 oss endpoint"))?;
|
||
let mut url = reqwest::Url::parse(&format!("https://{bucket}.{endpoint}/"))?;
|
||
url = url.join(object_key.trim_start_matches('/'))?;
|
||
Ok(url)
|
||
}
|
||
|
||
async fn send_signed_oss_request(
|
||
client: &reqwest::Client,
|
||
config: &AppConfig,
|
||
method: Method,
|
||
object_key: Option<&str>,
|
||
) -> Result<reqwest::Response, Box<dyn Error>> {
|
||
let bucket = config
|
||
.oss_bucket
|
||
.as_deref()
|
||
.ok_or_else(|| std::io::Error::other("缺少 oss bucket"))?;
|
||
let endpoint = config
|
||
.oss_endpoint
|
||
.as_deref()
|
||
.ok_or_else(|| std::io::Error::other("缺少 oss endpoint"))?;
|
||
let access_key_id = config
|
||
.oss_access_key_id
|
||
.as_deref()
|
||
.ok_or_else(|| std::io::Error::other("缺少 oss access key id"))?;
|
||
let access_key_secret = config
|
||
.oss_access_key_secret
|
||
.as_deref()
|
||
.ok_or_else(|| std::io::Error::other("缺少 oss access key secret"))?;
|
||
let date = fmt_http_date(SystemTime::now());
|
||
let canonical_resource = match object_key.map(str::trim).filter(|value| !value.is_empty()) {
|
||
Some(object_key) => format!("/{bucket}/{}", object_key.trim_start_matches('/')),
|
||
None => format!("/{bucket}/"),
|
||
};
|
||
let string_to_sign = format!("{}\n\n\n{}\n{}", method.as_str(), date, canonical_resource);
|
||
let signature = sign_oss_string(access_key_secret, &string_to_sign)?;
|
||
let target_url = match object_key.map(str::trim).filter(|value| !value.is_empty()) {
|
||
Some(object_key) => build_object_url(config, object_key)?,
|
||
None => reqwest::Url::parse(&format!("https://{bucket}.{endpoint}/"))?,
|
||
};
|
||
|
||
let response = client
|
||
.request(method, target_url)
|
||
.header("Date", date)
|
||
.header("Authorization", format!("OSS {access_key_id}:{signature}"))
|
||
.send()
|
||
.await?;
|
||
|
||
Ok(response)
|
||
}
|
||
|
||
fn sign_oss_string(secret: &str, content: &str) -> Result<String, Box<dyn Error>> {
|
||
let mut signer = HmacSha1::new_from_slice(secret.as_bytes())?;
|
||
signer.update(content.as_bytes());
|
||
Ok(BASE64_STANDARD.encode(signer.finalize().into_bytes()))
|
||
}
|
||
|
||
fn ensure_success_status(status: u16, message: &str) -> Result<(), Box<dyn Error>> {
|
||
if (200..300).contains(&status) {
|
||
return Ok(());
|
||
}
|
||
|
||
Err(std::io::Error::other(format!("{message}，实际状态码为 {status}")).into())
|
||
}
|
||
}
|