qinqx
e7760ea80d
Add built-in storage support from v-hono-storage module: - StorageProvider interface with 4 backends - FileService with HTTP handlers - Multipart upload support - 86 property-based tests - Retry mechanism with exponential backoff Breaking: None (backward compatible)
558 lines
16 KiB
V
558 lines
16 KiB
V
module hono
|
||
|
||
import time
|
||
import rand
|
||
import math
|
||
|
||
// ============================================================================
|
||
// 重试配置
|
||
// ============================================================================
|
||
|
||
// 重试配置结构
|
||
pub struct RetryConfig {
|
||
pub:
|
||
max_retries int = 3 // 最大重试次数
|
||
initial_delay int = 1000 // 初始延迟（毫秒）
|
||
max_delay int = 30000 // 最大延迟（毫秒）
|
||
multiplier f64 = 2.0 // 延迟倍增因子
|
||
jitter bool = true // 是否添加随机抖动
|
||
jitter_factor f64 = 0.25 // 抖动因子 (0.0 - 1.0)
|
||
}
|
||
|
||
// 默认重试配置
|
||
pub fn default_retry_config() RetryConfig {
|
||
return RetryConfig{
|
||
max_retries: 3
|
||
initial_delay: 1000
|
||
max_delay: 30000
|
||
multiplier: 2.0
|
||
jitter: true
|
||
jitter_factor: 0.25
|
||
}
|
||
}
|
||
|
||
// 激进重试配置（更多重试，更短延迟）
|
||
pub fn aggressive_retry_config() RetryConfig {
|
||
return RetryConfig{
|
||
max_retries: 5
|
||
initial_delay: 500
|
||
max_delay: 10000
|
||
multiplier: 1.5
|
||
jitter: true
|
||
jitter_factor: 0.2
|
||
}
|
||
}
|
||
|
||
// 保守重试配置（更少重试，更长延迟）
|
||
pub fn conservative_retry_config() RetryConfig {
|
||
return RetryConfig{
|
||
max_retries: 2
|
||
initial_delay: 2000
|
||
max_delay: 60000
|
||
multiplier: 3.0
|
||
jitter: true
|
||
jitter_factor: 0.3
|
||
}
|
||
}
|
||
|
||
|
||
// ============================================================================
|
||
// 重试结果
|
||
// ============================================================================
|
||
|
||
// 重试执行结果
|
||
pub struct RetryResult[T] {
|
||
pub:
|
||
success bool
|
||
value T
|
||
total_retries int
|
||
total_delay int // 总延迟时间（毫秒）
|
||
final_error StorageError
|
||
history []RetryAttempt
|
||
}
|
||
|
||
// 创建成功的重试结果
|
||
fn new_retry_success[T](value T, total_retries int, total_delay int, history []RetryAttempt) RetryResult[T] {
|
||
return RetryResult[T]{
|
||
success: true
|
||
value: value
|
||
total_retries: total_retries
|
||
total_delay: total_delay
|
||
final_error: StorageError{}
|
||
history: history
|
||
}
|
||
}
|
||
|
||
// 创建失败的重试结果
|
||
fn new_retry_failure[T](final_error StorageError, total_retries int, total_delay int, history []RetryAttempt) RetryResult[T] {
|
||
return RetryResult[T]{
|
||
success: false
|
||
value: T{}
|
||
total_retries: total_retries
|
||
total_delay: total_delay
|
||
final_error: final_error
|
||
history: history
|
||
}
|
||
}
|
||
|
||
// ============================================================================
|
||
// 重试执行器
|
||
// ============================================================================
|
||
|
||
// 重试执行器
|
||
pub struct RetryExecutor {
|
||
config RetryConfig
|
||
}
|
||
|
||
// 创建重试执行器
|
||
pub fn new_retry_executor(config RetryConfig) RetryExecutor {
|
||
return RetryExecutor{
|
||
config: config
|
||
}
|
||
}
|
||
|
||
// 使用默认配置创建重试执行器
|
||
pub fn new_default_retry_executor() RetryExecutor {
|
||
return RetryExecutor{
|
||
config: default_retry_config()
|
||
}
|
||
}
|
||
|
||
// 计算下一次重试的延迟时间
|
||
pub fn (r RetryExecutor) calculate_delay(attempt int) int {
|
||
// 指数退避: delay = initial_delay * (multiplier ^ attempt)
|
||
base_delay := f64(r.config.initial_delay) * math.pow(r.config.multiplier, f64(attempt))
|
||
|
||
// 限制最大延迟
|
||
mut delay := int(math.min(base_delay, f64(r.config.max_delay)))
|
||
|
||
// 添加随机抖动
|
||
if r.config.jitter && delay > 0 {
|
||
jitter_range := int(f64(delay) * r.config.jitter_factor)
|
||
if jitter_range > 0 {
|
||
jitter := rand.int_in_range(0, jitter_range * 2) or { 0 }
|
||
delay = delay - jitter_range + jitter
|
||
}
|
||
}
|
||
|
||
// 确保延迟不为负
|
||
if delay < 0 {
|
||
delay = 0
|
||
}
|
||
|
||
return delay
|
||
}
|
||
|
||
|
||
// 执行带重试的操作（返回 []u8）
|
||
pub fn (r RetryExecutor) execute_bytes(operation fn () ![]u8, provider string, op_name string) RetryResult[[]u8] {
|
||
mut history := []RetryAttempt{}
|
||
mut total_delay := 0
|
||
mut last_error := StorageError{}
|
||
|
||
for attempt in 0 .. r.config.max_retries + 1 {
|
||
// 执行操作
|
||
result := operation() or {
|
||
// 解析错误
|
||
error_msg := err.msg()
|
||
storage_err := parse_error_message(error_msg, provider, op_name)
|
||
|
||
// 检查是否可重试
|
||
if !storage_err.is_retryable() {
|
||
// 不可重试错误，立即返回
|
||
return new_retry_failure[[]u8](storage_err, attempt, total_delay, history)
|
||
}
|
||
|
||
last_error = storage_err
|
||
|
||
// 如果还有重试机会
|
||
if attempt < r.config.max_retries {
|
||
delay := r.calculate_delay(attempt)
|
||
|
||
// 记录重试尝试
|
||
history << RetryAttempt{
|
||
attempt_number: attempt + 1
|
||
timestamp: time.now().unix()
|
||
error_message: error_msg
|
||
delay_ms: delay
|
||
}
|
||
|
||
total_delay += delay
|
||
|
||
// 等待后重试
|
||
if delay > 0 {
|
||
time.sleep(delay * time.millisecond)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
// 操作成功
|
||
return new_retry_success[[]u8](result, attempt, total_delay, history)
|
||
}
|
||
|
||
// 所有重试都失败
|
||
mut final_error := last_error
|
||
final_error.retry_history = history
|
||
return new_retry_failure[[]u8](final_error, r.config.max_retries, total_delay, history)
|
||
}
|
||
|
||
// 执行带重试的操作（返回 StorageResult）
|
||
pub fn (r RetryExecutor) execute_storage_result(operation fn () !StorageResult, provider string, op_name string) RetryResult[StorageResult] {
|
||
mut history := []RetryAttempt{}
|
||
mut total_delay := 0
|
||
mut last_error := StorageError{}
|
||
|
||
for attempt in 0 .. r.config.max_retries + 1 {
|
||
// 执行操作
|
||
result := operation() or {
|
||
// 解析错误
|
||
error_msg := err.msg()
|
||
storage_err := parse_error_message(error_msg, provider, op_name)
|
||
|
||
// 检查是否可重试
|
||
if !storage_err.is_retryable() {
|
||
// 不可重试错误，立即返回
|
||
return new_retry_failure[StorageResult](storage_err, attempt, total_delay, history)
|
||
}
|
||
|
||
last_error = storage_err
|
||
|
||
// 如果还有重试机会
|
||
if attempt < r.config.max_retries {
|
||
delay := r.calculate_delay(attempt)
|
||
|
||
// 记录重试尝试
|
||
history << RetryAttempt{
|
||
attempt_number: attempt + 1
|
||
timestamp: time.now().unix()
|
||
error_message: error_msg
|
||
delay_ms: delay
|
||
}
|
||
|
||
total_delay += delay
|
||
|
||
// 等待后重试
|
||
if delay > 0 {
|
||
time.sleep(delay * time.millisecond)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
// 操作成功
|
||
return new_retry_success[StorageResult](result, attempt, total_delay, history)
|
||
}
|
||
|
||
// 所有重试都失败
|
||
mut final_error := last_error
|
||
final_error.retry_history = history
|
||
return new_retry_failure[StorageResult](final_error, r.config.max_retries, total_delay, history)
|
||
}
|
||
|
||
|
||
// 执行带重试的操作（返回 bool）
|
||
pub fn (r RetryExecutor) execute_bool(operation fn () !bool, provider string, op_name string) RetryResult[bool] {
|
||
mut history := []RetryAttempt{}
|
||
mut total_delay := 0
|
||
mut last_error := StorageError{}
|
||
|
||
for attempt in 0 .. r.config.max_retries + 1 {
|
||
// 执行操作
|
||
result := operation() or {
|
||
// 解析错误
|
||
error_msg := err.msg()
|
||
storage_err := parse_error_message(error_msg, provider, op_name)
|
||
|
||
// 检查是否可重试
|
||
if !storage_err.is_retryable() {
|
||
// 不可重试错误，立即返回
|
||
return new_retry_failure[bool](storage_err, attempt, total_delay, history)
|
||
}
|
||
|
||
last_error = storage_err
|
||
|
||
// 如果还有重试机会
|
||
if attempt < r.config.max_retries {
|
||
delay := r.calculate_delay(attempt)
|
||
|
||
// 记录重试尝试
|
||
history << RetryAttempt{
|
||
attempt_number: attempt + 1
|
||
timestamp: time.now().unix()
|
||
error_message: error_msg
|
||
delay_ms: delay
|
||
}
|
||
|
||
total_delay += delay
|
||
|
||
// 等待后重试
|
||
if delay > 0 {
|
||
time.sleep(delay * time.millisecond)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
// 操作成功
|
||
return new_retry_success[bool](result, attempt, total_delay, history)
|
||
}
|
||
|
||
// 所有重试都失败
|
||
mut final_error := last_error
|
||
final_error.retry_history = history
|
||
return new_retry_failure[bool](final_error, r.config.max_retries, total_delay, history)
|
||
}
|
||
|
||
// 执行带重试的操作（无返回值）
|
||
pub fn (r RetryExecutor) execute_void(operation fn () !, provider string, op_name string) RetryResult[bool] {
|
||
mut history := []RetryAttempt{}
|
||
mut total_delay := 0
|
||
mut last_error := StorageError{}
|
||
|
||
for attempt in 0 .. r.config.max_retries + 1 {
|
||
// 执行操作
|
||
operation() or {
|
||
// 解析错误
|
||
error_msg := err.msg()
|
||
storage_err := parse_error_message(error_msg, provider, op_name)
|
||
|
||
// 检查是否可重试
|
||
if !storage_err.is_retryable() {
|
||
// 不可重试错误，立即返回
|
||
return new_retry_failure[bool](storage_err, attempt, total_delay, history)
|
||
}
|
||
|
||
last_error = storage_err
|
||
|
||
// 如果还有重试机会
|
||
if attempt < r.config.max_retries {
|
||
delay := r.calculate_delay(attempt)
|
||
|
||
// 记录重试尝试
|
||
history << RetryAttempt{
|
||
attempt_number: attempt + 1
|
||
timestamp: time.now().unix()
|
||
error_message: error_msg
|
||
delay_ms: delay
|
||
}
|
||
|
||
total_delay += delay
|
||
|
||
// 等待后重试
|
||
if delay > 0 {
|
||
time.sleep(delay * time.millisecond)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
// 操作成功
|
||
return new_retry_success[bool](true, attempt, total_delay, history)
|
||
}
|
||
|
||
// 所有重试都失败
|
||
mut final_error := last_error
|
||
final_error.retry_history = history
|
||
return new_retry_failure[bool](final_error, r.config.max_retries, total_delay, history)
|
||
}
|
||
|
||
|
||
// 执行带重试的操作（返回 string）
|
||
pub fn (r RetryExecutor) execute_string(operation fn () !string, provider string, op_name string) RetryResult[string] {
|
||
mut history := []RetryAttempt{}
|
||
mut total_delay := 0
|
||
mut last_error := StorageError{}
|
||
|
||
for attempt in 0 .. r.config.max_retries + 1 {
|
||
// 执行操作
|
||
result := operation() or {
|
||
// 解析错误
|
||
error_msg := err.msg()
|
||
storage_err := parse_error_message(error_msg, provider, op_name)
|
||
|
||
// 检查是否可重试
|
||
if !storage_err.is_retryable() {
|
||
// 不可重试错误，立即返回
|
||
return new_retry_failure[string](storage_err, attempt, total_delay, history)
|
||
}
|
||
|
||
last_error = storage_err
|
||
|
||
// 如果还有重试机会
|
||
if attempt < r.config.max_retries {
|
||
delay := r.calculate_delay(attempt)
|
||
|
||
// 记录重试尝试
|
||
history << RetryAttempt{
|
||
attempt_number: attempt + 1
|
||
timestamp: time.now().unix()
|
||
error_message: error_msg
|
||
delay_ms: delay
|
||
}
|
||
|
||
total_delay += delay
|
||
|
||
// 等待后重试
|
||
if delay > 0 {
|
||
time.sleep(delay * time.millisecond)
|
||
}
|
||
}
|
||
continue
|
||
}
|
||
|
||
// 操作成功
|
||
return new_retry_success[string](result, attempt, total_delay, history)
|
||
}
|
||
|
||
// 所有重试都失败
|
||
mut final_error := last_error
|
||
final_error.retry_history = history
|
||
return new_retry_failure[string](final_error, r.config.max_retries, total_delay, history)
|
||
}
|
||
|
||
// ============================================================================
|
||
// 辅助函数
|
||
// ============================================================================
|
||
|
||
// 从错误消息解析 StorageError
|
||
fn parse_error_message(error_msg string, provider string, operation string) StorageError {
|
||
// 尝试从错误消息中提取信息
|
||
// 格式: "provider/operation: message (kind: xxx, http_status: yyy)"
|
||
|
||
// 检查是否包含已知的错误类型关键字
|
||
kind := detect_error_kind_from_message(error_msg)
|
||
|
||
// 尝试提取 HTTP 状态码
|
||
http_status := extract_http_status_from_message(error_msg)
|
||
|
||
return StorageError{
|
||
kind: kind
|
||
message: error_msg
|
||
provider: provider
|
||
operation: operation
|
||
http_status: http_status
|
||
retry_count: 0
|
||
details: map[string]string{}
|
||
retry_history: []RetryAttempt{}
|
||
}
|
||
}
|
||
|
||
// 从错误消息检测错误类型
|
||
fn detect_error_kind_from_message(msg string) StorageErrorKind {
|
||
lower_msg := msg.to_lower()
|
||
|
||
// 可重试错误
|
||
if lower_msg.contains('timeout') || lower_msg.contains('timed out') {
|
||
return .network_timeout
|
||
}
|
||
if lower_msg.contains('service unavailable') || lower_msg.contains('503') {
|
||
return .service_unavailable
|
||
}
|
||
if lower_msg.contains('rate limit') || lower_msg.contains('too many requests') || lower_msg.contains('429') {
|
||
return .rate_limited
|
||
}
|
||
if lower_msg.contains('connection reset') || lower_msg.contains('connection refused') {
|
||
return .connection_reset
|
||
}
|
||
if lower_msg.contains('temporary') || lower_msg.contains('retry') {
|
||
return .temporary_failure
|
||
}
|
||
|
||
// 不可重试错误
|
||
if lower_msg.contains('invalid credentials') || lower_msg.contains('401') || lower_msg.contains('unauthorized') {
|
||
return .invalid_credentials
|
||
}
|
||
if lower_msg.contains('access denied') || lower_msg.contains('403') || lower_msg.contains('forbidden') {
|
||
return .access_denied
|
||
}
|
||
if lower_msg.contains('bucket not found') || lower_msg.contains('nosuchbucket') {
|
||
return .bucket_not_found
|
||
}
|
||
if lower_msg.contains('not found') || lower_msg.contains('404') || lower_msg.contains('nosuchkey') {
|
||
return .object_not_found
|
||
}
|
||
if lower_msg.contains('invalid') && (lower_msg.contains('key') || lower_msg.contains('name')) {
|
||
return .invalid_object_key
|
||
}
|
||
if lower_msg.contains('quota') || lower_msg.contains('limit exceeded') {
|
||
return .quota_exceeded
|
||
}
|
||
if lower_msg.contains('config') {
|
||
return .invalid_config
|
||
}
|
||
|
||
return .unknown
|
||
}
|
||
|
||
// 从错误消息提取 HTTP 状态码
|
||
fn extract_http_status_from_message(msg string) int {
|
||
// 尝试查找 "http_status: xxx" 模式
|
||
if status_idx := msg.index('http_status:') {
|
||
start := status_idx + 12
|
||
mut end := start
|
||
for end < msg.len && (msg[end].is_digit() || msg[end] == ` `) {
|
||
end++
|
||
}
|
||
status_str := msg[start..end].trim_space()
|
||
return status_str.int()
|
||
}
|
||
|
||
// 尝试查找常见的 HTTP 状态码
|
||
status_codes := [400, 401, 403, 404, 409, 413, 429, 500, 502, 503, 504]
|
||
for code in status_codes {
|
||
if msg.contains(code.str()) {
|
||
return code
|
||
}
|
||
}
|
||
|
||
return 0
|
||
}
|
||
|
||
|
||
// ============================================================================
|
||
// 简化的重试函数
|
||
// ============================================================================
|
||
|
||
// 使用默认配置执行带重试的操作（返回 []u8）
|
||
pub fn retry_bytes(operation fn () ![]u8, provider string, op_name string) RetryResult[[]u8] {
|
||
executor := new_default_retry_executor()
|
||
return executor.execute_bytes(operation, provider, op_name)
|
||
}
|
||
|
||
// 使用默认配置执行带重试的操作（返回 StorageResult）
|
||
pub fn retry_storage_result(operation fn () !StorageResult, provider string, op_name string) RetryResult[StorageResult] {
|
||
executor := new_default_retry_executor()
|
||
return executor.execute_storage_result(operation, provider, op_name)
|
||
}
|
||
|
||
// 使用默认配置执行带重试的操作（返回 bool）
|
||
pub fn retry_bool(operation fn () !bool, provider string, op_name string) RetryResult[bool] {
|
||
executor := new_default_retry_executor()
|
||
return executor.execute_bool(operation, provider, op_name)
|
||
}
|
||
|
||
// 使用默认配置执行带重试的操作（无返回值）
|
||
pub fn retry_void(operation fn () !, provider string, op_name string) RetryResult[bool] {
|
||
executor := new_default_retry_executor()
|
||
return executor.execute_void(operation, provider, op_name)
|
||
}
|
||
|
||
// 使用默认配置执行带重试的操作（返回 string）
|
||
pub fn retry_string(operation fn () !string, provider string, op_name string) RetryResult[string] {
|
||
executor := new_default_retry_executor()
|
||
return executor.execute_string(operation, provider, op_name)
|
||
}
|
||
|
||
// 使用自定义配置执行带重试的操作（返回 []u8）
|
||
pub fn retry_bytes_with_config(operation fn () ![]u8, provider string, op_name string, config RetryConfig) RetryResult[[]u8] {
|
||
executor := new_retry_executor(config)
|
||
return executor.execute_bytes(operation, provider, op_name)
|
||
}
|
||
|
||
// 使用自定义配置执行带重试的操作（返回 StorageResult）
|
||
pub fn retry_storage_result_with_config(operation fn () !StorageResult, provider string, op_name string, config RetryConfig) RetryResult[StorageResult] {
|
||
executor := new_retry_executor(config)
|
||
return executor.execute_storage_result(operation, provider, op_name)
|
||
}
|