1284 lines
41 KiB
Rust
1284 lines
41 KiB
Rust
use std::{collections::BTreeMap, error::Error, fmt, time::SystemTime};
|
|
|
|
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
|
|
use hmac::{Hmac, Mac};
|
|
use httpdate::fmt_http_date;
|
|
use reqwest::Method;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{Value, json};
|
|
use sha1::Sha1;
|
|
use time::{Duration, OffsetDateTime, format_description::well_known::Rfc3339};
|
|
|
|
type HmacSha1 = Hmac<Sha1>;
|
|
|
|
pub const DEFAULT_POST_EXPIRE_SECONDS: u64 = 10 * 60;
|
|
pub const DEFAULT_READ_EXPIRE_SECONDS: u64 = 10 * 60;
|
|
pub const DEFAULT_POST_MAX_SIZE_BYTES: u64 = 20 * 1024 * 1024;
|
|
pub const DEFAULT_SUCCESS_ACTION_STATUS: u16 = 200;
|
|
pub const DEFAULT_METADATA_TOTAL_BYTES_LIMIT: usize = 8 * 1024;
|
|
|
|
pub const LEGACY_PUBLIC_PREFIXES: [&str; 7] = [
|
|
"generated-character-drafts",
|
|
"generated-characters",
|
|
"generated-animations",
|
|
"generated-big-fish-assets",
|
|
"generated-custom-world-scenes",
|
|
"generated-custom-world-covers",
|
|
"generated-qwen-sprites",
|
|
];
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum OssObjectAccess {
|
|
Public,
|
|
Private,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
pub enum LegacyAssetPrefix {
|
|
CharacterDrafts,
|
|
Characters,
|
|
Animations,
|
|
BigFishAssets,
|
|
PuzzleAssets,
|
|
CustomWorldScenes,
|
|
CustomWorldCovers,
|
|
QwenSprites,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct OssConfig {
|
|
bucket: String,
|
|
endpoint: String,
|
|
access_key_id: String,
|
|
access_key_secret: String,
|
|
default_read_expire_seconds: u64,
|
|
default_post_expire_seconds: u64,
|
|
default_post_max_size_bytes: u64,
|
|
default_success_action_status: u16,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct OssPostObjectRequest {
|
|
pub prefix: LegacyAssetPrefix,
|
|
pub path_segments: Vec<String>,
|
|
pub file_name: String,
|
|
pub content_type: Option<String>,
|
|
pub access: OssObjectAccess,
|
|
pub metadata: BTreeMap<String, String>,
|
|
pub max_size_bytes: Option<u64>,
|
|
pub expire_seconds: Option<u64>,
|
|
pub success_action_status: Option<u16>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct OssSignedGetObjectUrlRequest {
|
|
pub object_key: String,
|
|
pub expire_seconds: Option<u64>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct OssHeadObjectRequest {
|
|
pub object_key: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct OssPutObjectRequest {
|
|
pub prefix: LegacyAssetPrefix,
|
|
pub path_segments: Vec<String>,
|
|
pub file_name: String,
|
|
pub content_type: Option<String>,
|
|
pub access: OssObjectAccess,
|
|
pub metadata: BTreeMap<String, String>,
|
|
pub body: Vec<u8>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
|
|
pub struct OssPostObjectResponse {
|
|
#[serde(rename = "signatureVersion")]
|
|
pub signature_version: &'static str,
|
|
pub provider: &'static str,
|
|
pub bucket: String,
|
|
pub endpoint: String,
|
|
pub host: String,
|
|
#[serde(rename = "objectKey")]
|
|
pub object_key: String,
|
|
#[serde(rename = "legacyPublicPath")]
|
|
pub legacy_public_path: String,
|
|
#[serde(rename = "contentType", skip_serializing_if = "Option::is_none")]
|
|
pub content_type: Option<String>,
|
|
pub access: OssObjectAccess,
|
|
#[serde(rename = "keyPrefix")]
|
|
pub key_prefix: String,
|
|
#[serde(rename = "expiresAt")]
|
|
pub expires_at: String,
|
|
#[serde(rename = "maxSizeBytes")]
|
|
pub max_size_bytes: u64,
|
|
#[serde(rename = "successActionStatus")]
|
|
pub success_action_status: u16,
|
|
#[serde(rename = "formFields")]
|
|
pub form_fields: OssPostObjectFormFields,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
|
|
pub struct OssSignedGetObjectUrlResponse {
|
|
pub provider: &'static str,
|
|
pub bucket: String,
|
|
pub endpoint: String,
|
|
pub host: String,
|
|
#[serde(rename = "objectKey")]
|
|
pub object_key: String,
|
|
#[serde(rename = "expiresAt")]
|
|
pub expires_at: String,
|
|
#[serde(rename = "signedUrl")]
|
|
pub signed_url: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq)]
|
|
pub struct OssHeadObjectResponse {
|
|
pub bucket: String,
|
|
pub object_key: String,
|
|
pub content_length: u64,
|
|
pub content_type: Option<String>,
|
|
pub etag: Option<String>,
|
|
pub last_modified: Option<String>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
|
|
pub struct OssPutObjectResponse {
|
|
pub provider: &'static str,
|
|
pub bucket: String,
|
|
pub endpoint: String,
|
|
pub host: String,
|
|
#[serde(rename = "objectKey")]
|
|
pub object_key: String,
|
|
#[serde(rename = "legacyPublicPath")]
|
|
pub legacy_public_path: String,
|
|
#[serde(rename = "contentType", skip_serializing_if = "Option::is_none")]
|
|
pub content_type: Option<String>,
|
|
#[serde(rename = "contentLength")]
|
|
pub content_length: u64,
|
|
pub access: OssObjectAccess,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub etag: Option<String>,
|
|
#[serde(rename = "lastModified", skip_serializing_if = "Option::is_none")]
|
|
pub last_modified: Option<String>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Serialize)]
|
|
pub struct OssPostObjectFormFields {
|
|
pub key: String,
|
|
pub policy: String,
|
|
#[serde(rename = "OSSAccessKeyId")]
|
|
pub oss_access_key_id: String,
|
|
#[serde(rename = "Signature")]
|
|
pub signature: String,
|
|
#[serde(rename = "success_action_status")]
|
|
pub success_action_status: String,
|
|
#[serde(rename = "Content-Type", skip_serializing_if = "Option::is_none")]
|
|
pub content_type: Option<String>,
|
|
#[serde(flatten)]
|
|
pub metadata: BTreeMap<String, String>,
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct OssClient {
|
|
config: OssConfig,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub enum OssError {
|
|
InvalidConfig(String),
|
|
InvalidRequest(String),
|
|
ObjectNotFound(String),
|
|
Request(String),
|
|
SerializePolicy(String),
|
|
Sign(String),
|
|
}
|
|
|
|
impl LegacyAssetPrefix {
|
|
pub fn parse(raw: &str) -> Option<Self> {
|
|
let normalized = raw
|
|
.trim()
|
|
.trim_start_matches('/')
|
|
.trim_end_matches('/')
|
|
.trim_end_matches('*')
|
|
.trim_end_matches('/');
|
|
|
|
match normalized {
|
|
"generated-character-drafts" => Some(Self::CharacterDrafts),
|
|
"generated-characters" => Some(Self::Characters),
|
|
"generated-animations" => Some(Self::Animations),
|
|
"generated-big-fish-assets" => Some(Self::BigFishAssets),
|
|
"generated-puzzle-assets" => Some(Self::PuzzleAssets),
|
|
"generated-custom-world-scenes" => Some(Self::CustomWorldScenes),
|
|
"generated-custom-world-covers" => Some(Self::CustomWorldCovers),
|
|
"generated-qwen-sprites" => Some(Self::QwenSprites),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
pub fn as_str(&self) -> &'static str {
|
|
match self {
|
|
Self::CharacterDrafts => "generated-character-drafts",
|
|
Self::Characters => "generated-characters",
|
|
Self::Animations => "generated-animations",
|
|
Self::BigFishAssets => "generated-big-fish-assets",
|
|
Self::PuzzleAssets => "generated-puzzle-assets",
|
|
Self::CustomWorldScenes => "generated-custom-world-scenes",
|
|
Self::CustomWorldCovers => "generated-custom-world-covers",
|
|
Self::QwenSprites => "generated-qwen-sprites",
|
|
}
|
|
}
|
|
|
|
pub fn as_public_path_prefix(&self) -> String {
|
|
format!("/{}", self.as_str())
|
|
}
|
|
|
|
pub fn from_object_key(raw: &str) -> Option<Self> {
|
|
let normalized = raw.trim().trim_start_matches('/').trim();
|
|
let prefix = normalized.split('/').next()?;
|
|
Self::parse(prefix)
|
|
}
|
|
}
|
|
|
|
impl OssConfig {
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub fn new(
|
|
bucket: String,
|
|
endpoint: String,
|
|
access_key_id: String,
|
|
access_key_secret: String,
|
|
default_read_expire_seconds: u64,
|
|
default_post_expire_seconds: u64,
|
|
default_post_max_size_bytes: u64,
|
|
default_success_action_status: u16,
|
|
) -> Result<Self, OssError> {
|
|
let bucket = normalize_required_value(bucket, "OSS bucket 不能为空")?;
|
|
let endpoint = normalize_endpoint(&endpoint)?;
|
|
let access_key_id = normalize_required_value(access_key_id, "OSS AccessKeyId 不能为空")?;
|
|
let access_key_secret =
|
|
normalize_required_value(access_key_secret, "OSS AccessKeySecret 不能为空")?;
|
|
|
|
if default_read_expire_seconds == 0 {
|
|
return Err(OssError::InvalidConfig(
|
|
"OSS 私有读签名有效期必须大于 0".to_string(),
|
|
));
|
|
}
|
|
|
|
if default_post_expire_seconds == 0 {
|
|
return Err(OssError::InvalidConfig(
|
|
"OSS PostObject 签名有效期必须大于 0".to_string(),
|
|
));
|
|
}
|
|
|
|
if default_post_max_size_bytes == 0 {
|
|
return Err(OssError::InvalidConfig(
|
|
"OSS PostObject 最大上传大小必须大于 0".to_string(),
|
|
));
|
|
}
|
|
|
|
if !(100..=999).contains(&default_success_action_status) {
|
|
return Err(OssError::InvalidConfig(
|
|
"OSS success_action_status 必须是三位 HTTP 状态码".to_string(),
|
|
));
|
|
}
|
|
|
|
Ok(Self {
|
|
bucket,
|
|
endpoint,
|
|
access_key_id,
|
|
access_key_secret,
|
|
default_read_expire_seconds,
|
|
default_post_expire_seconds,
|
|
default_post_max_size_bytes,
|
|
default_success_action_status,
|
|
})
|
|
}
|
|
|
|
pub fn upload_host(&self) -> String {
|
|
format!("https://{}.{}", self.bucket, self.endpoint)
|
|
}
|
|
|
|
pub fn endpoint(&self) -> &str {
|
|
&self.endpoint
|
|
}
|
|
|
|
pub fn bucket(&self) -> &str {
|
|
&self.bucket
|
|
}
|
|
|
|
pub fn access_key_id(&self) -> &str {
|
|
&self.access_key_id
|
|
}
|
|
|
|
pub fn access_key_secret(&self) -> &str {
|
|
&self.access_key_secret
|
|
}
|
|
}
|
|
|
|
impl OssClient {
|
|
pub fn new(config: OssConfig) -> Self {
|
|
Self { config }
|
|
}
|
|
|
|
pub fn config_bucket(&self) -> &str {
|
|
self.config.bucket()
|
|
}
|
|
|
|
pub fn sign_post_object(
|
|
&self,
|
|
request: OssPostObjectRequest,
|
|
) -> Result<OssPostObjectResponse, OssError> {
|
|
let max_size_bytes = request
|
|
.max_size_bytes
|
|
.unwrap_or(self.config.default_post_max_size_bytes);
|
|
let expire_seconds = request
|
|
.expire_seconds
|
|
.unwrap_or(self.config.default_post_expire_seconds);
|
|
let success_action_status = request
|
|
.success_action_status
|
|
.unwrap_or(self.config.default_success_action_status);
|
|
|
|
if max_size_bytes == 0 {
|
|
return Err(OssError::InvalidRequest(
|
|
"maxSizeBytes 必须大于 0".to_string(),
|
|
));
|
|
}
|
|
|
|
if expire_seconds == 0 {
|
|
return Err(OssError::InvalidRequest(
|
|
"expireSeconds 必须大于 0".to_string(),
|
|
));
|
|
}
|
|
|
|
if !(100..=999).contains(&success_action_status) {
|
|
return Err(OssError::InvalidRequest(
|
|
"successActionStatus 必须是三位 HTTP 状态码".to_string(),
|
|
));
|
|
}
|
|
|
|
let sanitized_segments = request
|
|
.path_segments
|
|
.iter()
|
|
.map(|segment| sanitize_path_segment(segment))
|
|
.filter(|segment| !segment.is_empty())
|
|
.collect::<Vec<_>>();
|
|
let file_name = sanitize_file_name(&request.file_name)?;
|
|
let object_key = build_object_key(request.prefix, &sanitized_segments, &file_name);
|
|
let legacy_public_path = format!("/{}", object_key);
|
|
let content_type = normalize_optional_value(request.content_type);
|
|
let metadata = normalize_metadata(request.metadata)?;
|
|
|
|
let expires_at = OffsetDateTime::now_utc()
|
|
.checked_add(Duration::seconds(i64::try_from(expire_seconds).map_err(
|
|
|_| OssError::InvalidRequest("expireSeconds 超出可支持范围".to_string()),
|
|
)?))
|
|
.ok_or_else(|| OssError::InvalidRequest("expireSeconds 计算结果溢出".to_string()))?;
|
|
let expires_at = expires_at
|
|
.format(&Rfc3339)
|
|
.map_err(|error| OssError::SerializePolicy(format!("格式化过期时间失败：{error}")))?;
|
|
|
|
let policy_json = build_policy_json(
|
|
&self.config.bucket,
|
|
&object_key,
|
|
&expires_at,
|
|
max_size_bytes,
|
|
success_action_status,
|
|
content_type.as_deref(),
|
|
&metadata,
|
|
);
|
|
let policy = serde_json::to_string(&policy_json)
|
|
.map_err(|error| OssError::SerializePolicy(format!("序列化 policy 失败：{error}")))?;
|
|
let encoded_policy = BASE64_STANDARD.encode(policy.as_bytes());
|
|
let signature = sign_policy(&self.config.access_key_secret, &encoded_policy)?;
|
|
|
|
Ok(OssPostObjectResponse {
|
|
signature_version: "v1",
|
|
provider: "aliyun-oss",
|
|
bucket: self.config.bucket.clone(),
|
|
endpoint: self.config.endpoint.clone(),
|
|
host: self.config.upload_host(),
|
|
object_key: object_key.clone(),
|
|
legacy_public_path,
|
|
content_type: content_type.clone(),
|
|
access: request.access,
|
|
key_prefix: build_key_prefix(request.prefix, &sanitized_segments),
|
|
expires_at,
|
|
max_size_bytes,
|
|
success_action_status,
|
|
form_fields: OssPostObjectFormFields {
|
|
key: object_key,
|
|
policy: encoded_policy,
|
|
oss_access_key_id: self.config.access_key_id.clone(),
|
|
signature,
|
|
success_action_status: success_action_status.to_string(),
|
|
content_type,
|
|
metadata,
|
|
},
|
|
})
|
|
}
|
|
|
|
// 私有 bucket 的对象读取统一走短期签名 URL，避免把长期主凭证下发给浏览器。
|
|
pub fn sign_get_object_url(
|
|
&self,
|
|
request: OssSignedGetObjectUrlRequest,
|
|
) -> Result<OssSignedGetObjectUrlResponse, OssError> {
|
|
let expire_seconds = request
|
|
.expire_seconds
|
|
.unwrap_or(self.config.default_read_expire_seconds);
|
|
|
|
if expire_seconds == 0 {
|
|
return Err(OssError::InvalidRequest(
|
|
"expireSeconds 必须大于 0".to_string(),
|
|
));
|
|
}
|
|
|
|
let object_key = normalize_object_key(&request.object_key)?;
|
|
let expires_at = OffsetDateTime::now_utc()
|
|
.checked_add(Duration::seconds(i64::try_from(expire_seconds).map_err(
|
|
|_| OssError::InvalidRequest("expireSeconds 超出可支持范围".to_string()),
|
|
)?))
|
|
.ok_or_else(|| OssError::InvalidRequest("expireSeconds 计算结果溢出".to_string()))?;
|
|
let expires_at_text = expires_at
|
|
.format(&Rfc3339)
|
|
.map_err(|error| OssError::Sign(format!("格式化过期时间失败：{error}")))?;
|
|
let expires_epoch_seconds = expires_at.unix_timestamp();
|
|
|
|
let canonical_resource = build_canonical_object_resource(&self.config.bucket, &object_key);
|
|
let string_to_sign = format!("GET\n\n\n{expires_epoch_seconds}\n{canonical_resource}");
|
|
let signature = sign_policy(&self.config.access_key_secret, &string_to_sign)?;
|
|
let signed_url = format!(
|
|
"{}/{}?OSSAccessKeyId={}&Expires={}&Signature={}",
|
|
self.config.upload_host(),
|
|
encode_url_path(&object_key),
|
|
encode_url_query_value(&self.config.access_key_id),
|
|
expires_epoch_seconds,
|
|
encode_url_query_value(&signature)
|
|
);
|
|
|
|
Ok(OssSignedGetObjectUrlResponse {
|
|
provider: "aliyun-oss",
|
|
bucket: self.config.bucket.clone(),
|
|
endpoint: self.config.endpoint.clone(),
|
|
host: self.config.upload_host(),
|
|
object_key,
|
|
expires_at: expires_at_text,
|
|
signed_url,
|
|
})
|
|
}
|
|
|
|
// 上传完成确认前，服务端必须自己探测一次对象，不能只相信客户端回传的 object_key。
|
|
pub async fn head_object(
|
|
&self,
|
|
client: &reqwest::Client,
|
|
request: OssHeadObjectRequest,
|
|
) -> Result<OssHeadObjectResponse, OssError> {
|
|
let object_key = normalize_object_key(&request.object_key)?;
|
|
let target_url = build_object_url(&self.config.bucket, &self.config.endpoint, &object_key)
|
|
.map_err(|error| OssError::Request(format!("构造 OSS 对象 URL 失败：{error}")))?;
|
|
let response = send_signed_request(
|
|
client,
|
|
&self.config,
|
|
Method::HEAD,
|
|
Some(&object_key),
|
|
target_url,
|
|
)
|
|
.await?;
|
|
|
|
if response.status() == reqwest::StatusCode::NOT_FOUND {
|
|
return Err(OssError::ObjectNotFound(format!(
|
|
"OSS 对象不存在：{}",
|
|
request.object_key
|
|
)));
|
|
}
|
|
|
|
if !response.status().is_success() {
|
|
return Err(OssError::Request(format!(
|
|
"OSS HEAD Object 失败，状态码：{}",
|
|
response.status()
|
|
)));
|
|
}
|
|
|
|
let headers = response.headers();
|
|
let content_length = headers
|
|
.get(reqwest::header::CONTENT_LENGTH)
|
|
.and_then(|value| value.to_str().ok())
|
|
.and_then(|value| value.parse::<u64>().ok())
|
|
.unwrap_or(0);
|
|
let content_type = headers
|
|
.get(reqwest::header::CONTENT_TYPE)
|
|
.and_then(|value| value.to_str().ok())
|
|
.map(|value| value.to_string());
|
|
let etag = headers
|
|
.get(reqwest::header::ETAG)
|
|
.and_then(|value| value.to_str().ok())
|
|
.map(|value| value.trim_matches('"').to_string());
|
|
let last_modified = headers
|
|
.get(reqwest::header::LAST_MODIFIED)
|
|
.and_then(|value| value.to_str().ok())
|
|
.map(|value| value.to_string());
|
|
|
|
Ok(OssHeadObjectResponse {
|
|
bucket: self.config.bucket.clone(),
|
|
object_key,
|
|
content_length,
|
|
content_type,
|
|
etag,
|
|
last_modified,
|
|
})
|
|
}
|
|
|
|
// AI 生成资源默认由服务端上传 OSS，Web 端只拿签名读地址，不直接持有写权限。
|
|
pub async fn put_object(
|
|
&self,
|
|
client: &reqwest::Client,
|
|
request: OssPutObjectRequest,
|
|
) -> Result<OssPutObjectResponse, OssError> {
|
|
if request.body.is_empty() {
|
|
return Err(OssError::InvalidRequest(
|
|
"服务端上传对象内容不能为空".to_string(),
|
|
));
|
|
}
|
|
|
|
let sanitized_segments = request
|
|
.path_segments
|
|
.iter()
|
|
.map(|segment| sanitize_path_segment(segment))
|
|
.filter(|segment| !segment.is_empty())
|
|
.collect::<Vec<_>>();
|
|
let file_name = sanitize_file_name(&request.file_name)?;
|
|
let object_key = build_object_key(request.prefix, &sanitized_segments, &file_name);
|
|
let content_type = normalize_optional_value(request.content_type);
|
|
let metadata = normalize_metadata(request.metadata)?;
|
|
let target_url = build_object_url(&self.config.bucket, &self.config.endpoint, &object_key)
|
|
.map_err(|error| OssError::Request(format!("构造 OSS 对象 URL 失败：{error}")))?;
|
|
let content_length = u64::try_from(request.body.len())
|
|
.map_err(|_| OssError::InvalidRequest("上传对象大小超出可支持范围".to_string()))?;
|
|
let builder = signed_request_builder(
|
|
client,
|
|
&self.config,
|
|
Method::PUT,
|
|
Some(&object_key),
|
|
target_url,
|
|
content_type.as_deref(),
|
|
&metadata,
|
|
)?
|
|
.header(reqwest::header::CONTENT_LENGTH, content_length)
|
|
.body(request.body);
|
|
|
|
let response = builder
|
|
.send()
|
|
.await
|
|
.map_err(|error| OssError::Request(format!("请求 OSS 失败：{error}")))?;
|
|
|
|
if !response.status().is_success() {
|
|
return Err(OssError::Request(format!(
|
|
"OSS PutObject 失败，状态码：{}",
|
|
response.status()
|
|
)));
|
|
}
|
|
|
|
let headers = response.headers();
|
|
let etag = headers
|
|
.get(reqwest::header::ETAG)
|
|
.and_then(|value| value.to_str().ok())
|
|
.map(|value| value.trim_matches('"').to_string());
|
|
let last_modified = headers
|
|
.get(reqwest::header::LAST_MODIFIED)
|
|
.and_then(|value| value.to_str().ok())
|
|
.map(|value| value.to_string());
|
|
|
|
Ok(OssPutObjectResponse {
|
|
provider: "aliyun-oss",
|
|
bucket: self.config.bucket.clone(),
|
|
endpoint: self.config.endpoint.clone(),
|
|
host: self.config.upload_host(),
|
|
legacy_public_path: format!("/{object_key}"),
|
|
object_key,
|
|
content_type,
|
|
content_length,
|
|
access: request.access,
|
|
etag,
|
|
last_modified,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl fmt::Display for OssError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::InvalidConfig(message)
|
|
| Self::InvalidRequest(message)
|
|
| Self::ObjectNotFound(message)
|
|
| Self::Request(message)
|
|
| Self::SerializePolicy(message)
|
|
| Self::Sign(message) => f.write_str(message),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Error for OssError {}
|
|
|
|
fn build_policy_json(
|
|
bucket: &str,
|
|
object_key: &str,
|
|
expires_at: &str,
|
|
max_size_bytes: u64,
|
|
success_action_status: u16,
|
|
content_type: Option<&str>,
|
|
metadata: &BTreeMap<String, String>,
|
|
) -> Value {
|
|
let mut conditions = vec![
|
|
json!({ "bucket": bucket }),
|
|
json!(["eq", "$key", object_key]),
|
|
json!(["content-length-range", 1, max_size_bytes]),
|
|
json!([
|
|
"eq",
|
|
"$success_action_status",
|
|
success_action_status.to_string()
|
|
]),
|
|
];
|
|
|
|
if let Some(content_type) = content_type {
|
|
conditions.push(json!(["eq", "$content-type", content_type]));
|
|
}
|
|
|
|
for (key, value) in metadata {
|
|
conditions.push(json!(["eq", format!("${key}"), value]));
|
|
}
|
|
|
|
json!({
|
|
"expiration": expires_at,
|
|
"conditions": conditions,
|
|
})
|
|
}
|
|
|
|
fn build_object_url(
|
|
bucket: &str,
|
|
endpoint: &str,
|
|
object_key: &str,
|
|
) -> Result<reqwest::Url, String> {
|
|
let mut url = reqwest::Url::parse(&format!("https://{bucket}.{endpoint}/"))
|
|
.map_err(|error| error.to_string())?;
|
|
url = url
|
|
.join(object_key.trim_start_matches('/'))
|
|
.map_err(|error| error.to_string())?;
|
|
Ok(url)
|
|
}
|
|
|
|
fn build_canonical_object_resource(bucket: &str, object_key: &str) -> String {
|
|
format!("/{bucket}/{object_key}")
|
|
}
|
|
|
|
fn build_object_key(
|
|
prefix: LegacyAssetPrefix,
|
|
path_segments: &[String],
|
|
file_name: &str,
|
|
) -> String {
|
|
let mut parts = Vec::with_capacity(path_segments.len() + 2);
|
|
parts.push(prefix.as_str().to_string());
|
|
parts.extend(path_segments.iter().cloned());
|
|
parts.push(file_name.to_string());
|
|
parts.join("/")
|
|
}
|
|
|
|
fn normalize_object_key(raw: &str) -> Result<String, OssError> {
|
|
let normalized = raw.trim().trim_start_matches('/').trim().to_string();
|
|
if normalized.is_empty() {
|
|
return Err(OssError::InvalidRequest("objectKey 不能为空".to_string()));
|
|
}
|
|
|
|
if LegacyAssetPrefix::from_object_key(&normalized).is_none() {
|
|
return Err(OssError::InvalidRequest(
|
|
"objectKey 必须落在受支持的 generated-* 前缀下".to_string(),
|
|
));
|
|
}
|
|
|
|
let segments = normalized.split('/').collect::<Vec<_>>();
|
|
if segments.len() < 2 {
|
|
return Err(OssError::InvalidRequest(
|
|
"objectKey 至少需要包含前缀和文件名".to_string(),
|
|
));
|
|
}
|
|
|
|
for segment in &segments {
|
|
if segment.is_empty() || *segment == "." || *segment == ".." {
|
|
return Err(OssError::InvalidRequest(
|
|
"objectKey 包含非法路径片段".to_string(),
|
|
));
|
|
}
|
|
|
|
if segment.contains('\\') {
|
|
return Err(OssError::InvalidRequest(
|
|
"objectKey 不能包含反斜杠".to_string(),
|
|
));
|
|
}
|
|
}
|
|
|
|
Ok(normalized)
|
|
}
|
|
|
|
fn build_key_prefix(prefix: LegacyAssetPrefix, path_segments: &[String]) -> String {
|
|
let mut parts = Vec::with_capacity(path_segments.len() + 1);
|
|
parts.push(prefix.as_str().to_string());
|
|
parts.extend(path_segments.iter().cloned());
|
|
parts.join("/")
|
|
}
|
|
|
|
fn normalize_metadata(
|
|
metadata: BTreeMap<String, String>,
|
|
) -> Result<BTreeMap<String, String>, OssError> {
|
|
let mut normalized = BTreeMap::new();
|
|
|
|
for (key, value) in metadata {
|
|
let key = key.trim();
|
|
let value = value.trim();
|
|
|
|
if key.is_empty() || value.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
let key = normalize_metadata_key(key);
|
|
normalized.insert(key, value.to_string());
|
|
}
|
|
|
|
let total_bytes = normalized
|
|
.iter()
|
|
.map(|(key, value)| key.len() + value.len())
|
|
.sum::<usize>();
|
|
|
|
if total_bytes > DEFAULT_METADATA_TOTAL_BYTES_LIMIT {
|
|
return Err(OssError::InvalidRequest(format!(
|
|
"x-oss-meta-* 总大小不能超过 {} 字节",
|
|
DEFAULT_METADATA_TOTAL_BYTES_LIMIT
|
|
)));
|
|
}
|
|
|
|
Ok(normalized)
|
|
}
|
|
|
|
fn normalize_metadata_key(raw: &str) -> String {
|
|
let stripped = raw
|
|
.trim()
|
|
.trim_start_matches("x-oss-meta-")
|
|
.trim()
|
|
.to_ascii_lowercase();
|
|
let sanitized = stripped
|
|
.chars()
|
|
.map(|character| match character {
|
|
'a'..='z' | '0'..='9' | '-' => character,
|
|
'_' | ' ' | '/' | '.' => '-',
|
|
_ => '-',
|
|
})
|
|
.collect::<String>();
|
|
let sanitized = collapse_dashes(&sanitized);
|
|
|
|
format!(
|
|
"x-oss-meta-{}",
|
|
if sanitized.is_empty() {
|
|
"metadata".to_string()
|
|
} else {
|
|
sanitized
|
|
}
|
|
)
|
|
}
|
|
|
|
fn sanitize_path_segment(raw: &str) -> String {
|
|
let normalized = raw
|
|
.trim()
|
|
.to_ascii_lowercase()
|
|
.chars()
|
|
.map(|character| match character {
|
|
'a'..='z' | '0'..='9' | '-' | '_' => character,
|
|
_ => '-',
|
|
})
|
|
.collect::<String>();
|
|
|
|
collapse_dashes(&normalized)
|
|
}
|
|
|
|
fn sanitize_file_name(raw: &str) -> Result<String, OssError> {
|
|
let trimmed = raw.trim();
|
|
if trimmed.is_empty() {
|
|
return Err(OssError::InvalidRequest("fileName 不能为空".to_string()));
|
|
}
|
|
|
|
let file_name = trimmed.rsplit(['/', '\\']).next().unwrap_or(trimmed).trim();
|
|
|
|
if file_name.is_empty() {
|
|
return Err(OssError::InvalidRequest("fileName 不能为空".to_string()));
|
|
}
|
|
|
|
let (raw_stem, raw_extension) = match file_name.rsplit_once('.') {
|
|
Some((stem, extension)) if !stem.trim().is_empty() && !extension.trim().is_empty() => {
|
|
(stem, Some(extension))
|
|
}
|
|
_ => (file_name, None),
|
|
};
|
|
|
|
let stem = raw_stem
|
|
.trim()
|
|
.to_ascii_lowercase()
|
|
.chars()
|
|
.map(|character| match character {
|
|
'a'..='z' | '0'..='9' | '-' | '_' => character,
|
|
_ => '-',
|
|
})
|
|
.collect::<String>();
|
|
let stem = collapse_dashes(&stem);
|
|
|
|
if stem.is_empty() {
|
|
return Err(OssError::InvalidRequest("fileName 主体不合法".to_string()));
|
|
}
|
|
|
|
let extension = raw_extension
|
|
.map(|extension| {
|
|
extension
|
|
.trim()
|
|
.to_ascii_lowercase()
|
|
.chars()
|
|
.filter(|character| character.is_ascii_alphanumeric())
|
|
.collect::<String>()
|
|
})
|
|
.filter(|extension| !extension.is_empty());
|
|
|
|
Ok(match extension {
|
|
Some(extension) => format!("{stem}.{extension}"),
|
|
None => stem,
|
|
})
|
|
}
|
|
|
|
fn normalize_required_value(value: String, message: &str) -> Result<String, OssError> {
|
|
let value = value.trim().to_string();
|
|
if value.is_empty() {
|
|
return Err(OssError::InvalidConfig(message.to_string()));
|
|
}
|
|
|
|
Ok(value)
|
|
}
|
|
|
|
fn normalize_optional_value(value: Option<String>) -> Option<String> {
|
|
value.and_then(|value| {
|
|
let value = value.trim().to_string();
|
|
if value.is_empty() { None } else { Some(value) }
|
|
})
|
|
}
|
|
|
|
fn normalize_endpoint(raw: &str) -> Result<String, OssError> {
|
|
let endpoint = raw
|
|
.trim()
|
|
.trim_start_matches("https://")
|
|
.trim_start_matches("http://")
|
|
.trim_matches('/')
|
|
.to_string();
|
|
|
|
if endpoint.is_empty() {
|
|
return Err(OssError::InvalidConfig("OSS endpoint 不能为空".to_string()));
|
|
}
|
|
|
|
Ok(endpoint)
|
|
}
|
|
|
|
fn collapse_dashes(value: &str) -> String {
|
|
value
|
|
.chars()
|
|
.fold(
|
|
(String::new(), false),
|
|
|(mut output, last_is_dash), character| {
|
|
let is_dash = character == '-';
|
|
if is_dash && last_is_dash {
|
|
return (output, true);
|
|
}
|
|
|
|
output.push(character);
|
|
(output, is_dash)
|
|
},
|
|
)
|
|
.0
|
|
.trim_matches('-')
|
|
.to_string()
|
|
}
|
|
|
|
fn sign_policy(access_key_secret: &str, encoded_policy: &str) -> Result<String, OssError> {
|
|
let mut signer = HmacSha1::new_from_slice(access_key_secret.as_bytes())
|
|
.map_err(|error| OssError::Sign(format!("初始化 HMAC-SHA1 失败：{error}")))?;
|
|
signer.update(encoded_policy.as_bytes());
|
|
|
|
Ok(BASE64_STANDARD.encode(signer.finalize().into_bytes()))
|
|
}
|
|
|
|
async fn send_signed_request(
|
|
client: &reqwest::Client,
|
|
config: &OssConfig,
|
|
method: Method,
|
|
object_key: Option<&str>,
|
|
target_url: reqwest::Url,
|
|
) -> Result<reqwest::Response, OssError> {
|
|
signed_request_builder(
|
|
client,
|
|
config,
|
|
method,
|
|
object_key,
|
|
target_url,
|
|
None,
|
|
&BTreeMap::new(),
|
|
)?
|
|
.send()
|
|
.await
|
|
.map_err(|error| OssError::Request(format!("请求 OSS 失败：{error}")))
|
|
}
|
|
|
|
fn signed_request_builder(
|
|
client: &reqwest::Client,
|
|
config: &OssConfig,
|
|
method: Method,
|
|
object_key: Option<&str>,
|
|
target_url: reqwest::Url,
|
|
content_type: Option<&str>,
|
|
oss_headers: &BTreeMap<String, String>,
|
|
) -> Result<reqwest::RequestBuilder, OssError> {
|
|
let date = fmt_http_date(SystemTime::now());
|
|
let canonical_resource = match object_key.map(str::trim).filter(|value| !value.is_empty()) {
|
|
Some(object_key) => {
|
|
build_canonical_object_resource(config.bucket(), object_key.trim_start_matches('/'))
|
|
}
|
|
None => format!("/{}/", config.bucket()),
|
|
};
|
|
let canonicalized_oss_headers = build_canonicalized_oss_headers(oss_headers);
|
|
let string_to_sign = format!(
|
|
"{}\n\n{}\n{}\n{}{}",
|
|
method.as_str(),
|
|
content_type.unwrap_or_default(),
|
|
date,
|
|
canonicalized_oss_headers,
|
|
canonical_resource
|
|
);
|
|
let signature = sign_policy(config.access_key_secret(), &string_to_sign)?;
|
|
let mut builder = client
|
|
.request(method, target_url)
|
|
.header("Date", date)
|
|
.header(
|
|
"Authorization",
|
|
format!("OSS {}:{}", config.access_key_id(), signature),
|
|
);
|
|
|
|
if let Some(content_type) = content_type {
|
|
builder = builder.header(reqwest::header::CONTENT_TYPE, content_type);
|
|
}
|
|
|
|
for (key, value) in oss_headers {
|
|
builder = builder.header(key.as_str(), value.as_str());
|
|
}
|
|
|
|
Ok(builder)
|
|
}
|
|
|
|
fn build_canonicalized_oss_headers(headers: &BTreeMap<String, String>) -> String {
|
|
headers
|
|
.iter()
|
|
.map(|(key, value)| format!("{}:{}\n", key.to_ascii_lowercase(), value.trim()))
|
|
.collect::<String>()
|
|
}
|
|
|
|
fn encode_url_path(path: &str) -> String {
|
|
path.split('/')
|
|
.map(encode_url_query_value)
|
|
.collect::<Vec<_>>()
|
|
.join("/")
|
|
}
|
|
|
|
fn encode_url_query_value(value: &str) -> String {
|
|
let mut encoded = String::with_capacity(value.len());
|
|
|
|
for byte in value.bytes() {
|
|
match byte {
|
|
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
|
|
encoded.push(byte as char)
|
|
}
|
|
_ => {
|
|
use std::fmt::Write as _;
|
|
|
|
let _ = write!(&mut encoded, "%{byte:02X}");
|
|
}
|
|
}
|
|
}
|
|
|
|
encoded
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn build_client() -> OssClient {
|
|
OssClient::new(
|
|
OssConfig::new(
|
|
"genarrative-assets".to_string(),
|
|
"oss-cn-shanghai.aliyuncs.com".to_string(),
|
|
"test-access-key-id".to_string(),
|
|
"test-access-key-secret".to_string(),
|
|
DEFAULT_READ_EXPIRE_SECONDS,
|
|
DEFAULT_POST_EXPIRE_SECONDS,
|
|
DEFAULT_POST_MAX_SIZE_BYTES,
|
|
DEFAULT_SUCCESS_ACTION_STATUS,
|
|
)
|
|
.expect("OSS config should be valid"),
|
|
)
|
|
}
|
|
|
|
#[test]
|
|
fn parse_legacy_prefix_accepts_public_style_path() {
|
|
assert_eq!(
|
|
LegacyAssetPrefix::parse("/generated-characters/*"),
|
|
Some(LegacyAssetPrefix::Characters)
|
|
);
|
|
assert_eq!(LegacyAssetPrefix::parse("unknown"), None);
|
|
}
|
|
|
|
#[test]
|
|
fn sign_post_object_returns_bucket_and_object_key_for_private_storage_truth() {
|
|
let client = build_client();
|
|
let mut metadata = BTreeMap::new();
|
|
metadata.insert("asset-kind".to_string(), "character-visual".to_string());
|
|
metadata.insert("origin".to_string(), "browser-upload".to_string());
|
|
|
|
let response = client
|
|
.sign_post_object(OssPostObjectRequest {
|
|
prefix: LegacyAssetPrefix::Characters,
|
|
path_segments: vec![
|
|
"Hero_001".to_string(),
|
|
"Visual".to_string(),
|
|
"Asset_01".to_string(),
|
|
],
|
|
file_name: "Master.PNG".to_string(),
|
|
content_type: Some("image/png".to_string()),
|
|
access: OssObjectAccess::Public,
|
|
metadata,
|
|
max_size_bytes: Some(5 * 1024 * 1024),
|
|
expire_seconds: Some(300),
|
|
success_action_status: Some(200),
|
|
})
|
|
.expect("post object signature should build");
|
|
|
|
assert_eq!(
|
|
response.object_key,
|
|
"generated-characters/hero_001/visual/asset_01/master.png"
|
|
);
|
|
assert_eq!(
|
|
response.legacy_public_path,
|
|
"/generated-characters/hero_001/visual/asset_01/master.png"
|
|
);
|
|
assert_eq!(response.bucket, "genarrative-assets".to_string());
|
|
assert_eq!(
|
|
response.form_fields.oss_access_key_id,
|
|
"test-access-key-id".to_string()
|
|
);
|
|
assert_eq!(
|
|
response.form_fields.metadata.get("x-oss-meta-asset-kind"),
|
|
Some(&"character-visual".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn sign_post_object_embeds_policy_constraints() {
|
|
let client = build_client();
|
|
let response = client
|
|
.sign_post_object(OssPostObjectRequest {
|
|
prefix: LegacyAssetPrefix::QwenSprites,
|
|
path_segments: vec!["_drafts".to_string(), "master".to_string()],
|
|
file_name: "candidate-01.png".to_string(),
|
|
content_type: Some("image/png".to_string()),
|
|
access: OssObjectAccess::Private,
|
|
metadata: BTreeMap::new(),
|
|
max_size_bytes: Some(1024),
|
|
expire_seconds: Some(60),
|
|
success_action_status: Some(200),
|
|
})
|
|
.expect("post object signature should build");
|
|
|
|
let decoded_policy = BASE64_STANDARD
|
|
.decode(response.form_fields.policy.as_bytes())
|
|
.expect("policy should be valid base64");
|
|
let policy: Value =
|
|
serde_json::from_slice(&decoded_policy).expect("policy should be valid json");
|
|
|
|
assert_eq!(
|
|
policy["conditions"][0]["bucket"],
|
|
Value::String("genarrative-assets".to_string())
|
|
);
|
|
assert_eq!(
|
|
policy["conditions"][1],
|
|
json!([
|
|
"eq",
|
|
"$key",
|
|
"generated-qwen-sprites/_drafts/master/candidate-01.png"
|
|
])
|
|
);
|
|
assert_eq!(
|
|
policy["conditions"][2],
|
|
json!(["content-length-range", 1, 1024])
|
|
);
|
|
assert_eq!(
|
|
policy["conditions"][3],
|
|
json!(["eq", "$success_action_status", "200"])
|
|
);
|
|
assert_eq!(
|
|
policy["conditions"][4],
|
|
json!(["eq", "$content-type", "image/png"])
|
|
);
|
|
assert_eq!(response.bucket, "genarrative-assets".to_string());
|
|
}
|
|
|
|
#[test]
|
|
fn sanitize_file_name_rejects_empty_input() {
|
|
let error = sanitize_file_name(" ").expect_err("empty file name should fail");
|
|
|
|
assert_eq!(
|
|
error,
|
|
OssError::InvalidRequest("fileName 不能为空".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn sign_get_object_url_returns_signed_private_read_url() {
|
|
let client = build_client();
|
|
|
|
let response = client
|
|
.sign_get_object_url(OssSignedGetObjectUrlRequest {
|
|
object_key: "generated-characters/hero_001/visual/asset_01/master.png".to_string(),
|
|
expire_seconds: Some(300),
|
|
})
|
|
.expect("signed get url should build");
|
|
|
|
assert_eq!(response.bucket, "genarrative-assets".to_string());
|
|
assert_eq!(
|
|
response.object_key,
|
|
"generated-characters/hero_001/visual/asset_01/master.png".to_string()
|
|
);
|
|
assert!(response
|
|
.signed_url
|
|
.starts_with("https://genarrative-assets.oss-cn-shanghai.aliyuncs.com/generated-characters/hero_001/visual/asset_01/master.png?"));
|
|
assert!(
|
|
response
|
|
.signed_url
|
|
.contains("OSSAccessKeyId=test-access-key-id")
|
|
);
|
|
assert!(response.signed_url.contains("&Expires="));
|
|
assert!(response.signed_url.contains("&Signature="));
|
|
}
|
|
|
|
#[test]
|
|
fn sign_get_object_url_rejects_unsupported_prefix() {
|
|
let client = build_client();
|
|
|
|
let error = client
|
|
.sign_get_object_url(OssSignedGetObjectUrlRequest {
|
|
object_key: "workflow-cache/task-1.json".to_string(),
|
|
expire_seconds: Some(300),
|
|
})
|
|
.expect_err("unsupported prefix should fail");
|
|
|
|
assert_eq!(
|
|
error,
|
|
OssError::InvalidRequest("objectKey 必须落在受支持的 generated-* 前缀下".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn legacy_prefix_can_be_resolved_from_object_key() {
|
|
assert_eq!(
|
|
LegacyAssetPrefix::from_object_key(
|
|
"generated-custom-world-scenes/profile_01/landmark_01/scene.png"
|
|
),
|
|
Some(LegacyAssetPrefix::CustomWorldScenes)
|
|
);
|
|
assert_eq!(
|
|
LegacyAssetPrefix::from_object_key("workflow-cache/demo.json"),
|
|
None
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn put_object_request_reuses_generated_object_key_contract() {
|
|
let request = OssPutObjectRequest {
|
|
prefix: LegacyAssetPrefix::CustomWorldCovers,
|
|
path_segments: vec!["Profile 001".to_string(), "asset_01".to_string()],
|
|
file_name: "Cover.PNG".to_string(),
|
|
content_type: Some(" image/png ".to_string()),
|
|
access: OssObjectAccess::Private,
|
|
metadata: BTreeMap::from([
|
|
("asset_kind".to_string(), "custom_world_cover".to_string()),
|
|
("source job id".to_string(), "job_001".to_string()),
|
|
]),
|
|
body: b"cover-bytes".to_vec(),
|
|
};
|
|
let sanitized_segments = request
|
|
.path_segments
|
|
.iter()
|
|
.map(|segment| sanitize_path_segment(segment))
|
|
.filter(|segment| !segment.is_empty())
|
|
.collect::<Vec<_>>();
|
|
let file_name = sanitize_file_name(&request.file_name).expect("file name should sanitize");
|
|
let object_key = build_object_key(request.prefix, &sanitized_segments, &file_name);
|
|
let metadata = normalize_metadata(request.metadata).expect("metadata should normalize");
|
|
|
|
assert_eq!(
|
|
object_key,
|
|
"generated-custom-world-covers/profile-001/asset_01/cover.png"
|
|
);
|
|
assert_eq!(
|
|
metadata.get("x-oss-meta-asset-kind"),
|
|
Some(&"custom_world_cover".to_string())
|
|
);
|
|
assert_eq!(
|
|
metadata.get("x-oss-meta-source-job-id"),
|
|
Some(&"job_001".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn canonicalized_oss_headers_matches_oss_v1_upload_signature_shape() {
|
|
let headers = BTreeMap::from([
|
|
(
|
|
"x-oss-meta-source-job-id".to_string(),
|
|
" job_001 ".to_string(),
|
|
),
|
|
(
|
|
"x-oss-meta-asset-kind".to_string(),
|
|
"character_visual".to_string(),
|
|
),
|
|
]);
|
|
|
|
assert_eq!(
|
|
build_canonicalized_oss_headers(&headers),
|
|
"x-oss-meta-asset-kind:character_visual\nx-oss-meta-source-job-id:job_001\n"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn put_object_rejects_empty_body_before_calling_oss() {
|
|
let client = build_client();
|
|
let error = client
|
|
.put_object(
|
|
&reqwest::Client::new(),
|
|
OssPutObjectRequest {
|
|
prefix: LegacyAssetPrefix::Characters,
|
|
path_segments: vec!["hero".to_string()],
|
|
file_name: "master.png".to_string(),
|
|
content_type: Some("image/png".to_string()),
|
|
access: OssObjectAccess::Private,
|
|
metadata: BTreeMap::new(),
|
|
body: Vec::new(),
|
|
},
|
|
)
|
|
.await
|
|
.expect_err("empty server upload should fail before network");
|
|
|
|
assert_eq!(
|
|
error,
|
|
OssError::InvalidRequest("服务端上传对象内容不能为空".to_string())
|
|
);
|
|
}
|
|
}
|