649 lines
19 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import { NextRequest, NextResponse } from 'next/server'
import { S3Client, GetObjectCommand, PutObjectCommand, ListObjectsV2Command, DeleteObjectCommand, ListObjectsV2CommandOutput } from '@aws-sdk/client-s3'
import { randomBytes } from 'crypto'
import { detectIsIntranet } from '@/lib/network-detection'
export const dynamic = 'force-dynamic'
// 创建S3客户端
const s3Client = new S3Client({
endpoint: process.env.S3_ENDPOINT || '',
region: process.env.S3_REGION || 'us-east-1',
credentials: {
accessKeyId: process.env.S3_ACCESS_KEY_ID!,
secretAccessKey: process.env.S3_SECRET_ACCESS_KEY!,
},
forcePathStyle: true,
requestHandler: {
requestTimeout: 60000, // 增加到60秒以支持大文件
connectionTimeout: 10000,
},
})
// 计算统计信息
function calculateStats(durations: number[]) {
if (durations.length === 0) {
return {
min: 0,
max: 0,
avg: 0,
p50: 0,
p90: 0,
p95: 0,
p99: 0,
total: 0,
}
}
const sorted = [...durations].sort((a, b) => a - b)
return {
min: sorted[0],
max: sorted[sorted.length - 1],
avg: durations.reduce((a, b) => a + b, 0) / durations.length,
p50: sorted[Math.floor(sorted.length * 0.5)],
p90: sorted[Math.floor(sorted.length * 0.9)],
p95: sorted[Math.floor(sorted.length * 0.95)],
p99: sorted[Math.floor(sorted.length * 0.99)],
total: durations.reduce((a, b) => a + b, 0),
}
}
// 测试连接速度
async function testConnectionSpeed(): Promise<number> {
const startTime = Date.now()
try {
const command = new ListObjectsV2Command({
Bucket: process.env.S3_BUCKET!,
MaxKeys: 1,
})
await s3Client.send(command)
return Date.now() - startTime
} catch (error: any) {
return Date.now() - startTime
}
}
// 测试上传速度(单个)
async function testUploadSpeed(sizeKB: number, testKey?: string): Promise<{ duration: number; speed: number; success: boolean; error?: string; key?: string }> {
const key = testKey || `speed-test-${Date.now()}-${Math.random().toString(36).substring(7)}.bin`
const testData = randomBytes(sizeKB * 1024)
const startTime = Date.now()
try {
const command = new PutObjectCommand({
Bucket: process.env.S3_BUCKET!,
Key: key,
Body: testData,
ContentType: 'application/octet-stream',
})
await s3Client.send(command)
const duration = Date.now() - startTime
const speed = (sizeKB / duration) * 1000 // KB/s
return { duration, speed, success: true, key }
} catch (error: any) {
const duration = Date.now() - startTime
return { duration, speed: 0, success: false, error: error.message, key }
}
}
// 测试下载速度(通过HTTP)
async function testDownloadSpeed(url: string): Promise<{ duration: number; speed: number; ttfb: number; success: boolean; error?: string }> {
const startTime = Date.now()
let ttfb = 0
try {
const response = await fetch(url, {
method: 'HEAD',
signal: AbortSignal.timeout(30000),
})
ttfb = Date.now() - startTime
if (response.ok) {
const contentLength = response.headers.get('content-length')
if (contentLength) {
const sizeKB = parseInt(contentLength) / 1024
// 如果文件较小,尝试完整下载测试
if (sizeKB < 5000) { // 增加到5MB
const downloadStart = Date.now()
const downloadResponse = await fetch(url, {
signal: AbortSignal.timeout(60000),
})
if (downloadResponse.ok) {
await downloadResponse.arrayBuffer()
const downloadDuration = Date.now() - downloadStart
const speed = (sizeKB / downloadDuration) * 1000 // KB/s
return { duration: downloadDuration, speed, ttfb, success: true }
}
}
return { duration: ttfb, speed: 0, ttfb, success: true }
}
return { duration: ttfb, speed: 0, ttfb, success: true }
} else {
return { duration: ttfb, speed: 0, ttfb, success: false, error: `HTTP ${response.status}` }
}
} catch (error: any) {
const duration = Date.now() - startTime
return { duration, speed: 0, ttfb: duration, success: false, error: error.message }
}
}
// 并发上传测试
async function testConcurrentUploads(
concurrency: number,
sizeKB: number,
count: number
): Promise<{
total: number
success: number
failed: number
durations: number[]
speeds: number[]
stats: ReturnType<typeof calculateStats>
throughput: number // 总吞吐量 MB/s
}> {
const durations: number[] = []
const speeds: number[] = []
let success = 0
let failed = 0
const keys: string[] = []
const startTime = Date.now()
// 分批执行,每批concurrency个
for (let i = 0; i < count; i += concurrency) {
const batch = []
for (let j = 0; j < concurrency && i + j < count; j++) {
batch.push(testUploadSpeed(sizeKB))
}
const results = await Promise.allSettled(batch)
for (const result of results) {
if (result.status === 'fulfilled') {
const r = result.value
if (r.success) {
durations.push(r.duration)
speeds.push(r.speed)
success++
if (r.key) keys.push(r.key)
} else {
failed++
}
} else {
failed++
}
}
}
const totalTime = Date.now() - startTime
const totalSizeMB = (success * sizeKB) / 1024
const throughput = totalTime > 0 ? (totalSizeMB / totalTime) * 1000 : 0 // MB/s
// 清理测试文件
if (keys.length > 0) {
await Promise.allSettled(
keys.map(key =>
s3Client.send(
new DeleteObjectCommand({
Bucket: process.env.S3_BUCKET!,
Key: key,
})
)
)
)
}
return {
total: count,
success,
failed,
durations,
speeds,
stats: calculateStats(durations),
throughput,
}
}
// 并发下载测试
async function testConcurrentDownloads(
concurrency: number,
urls: string[],
count: number
): Promise<{
total: number
success: number
failed: number
durations: number[]
speeds: number[]
ttfb: number[]
stats: ReturnType<typeof calculateStats>
ttfbStats: ReturnType<typeof calculateStats>
throughput: number // 总吞吐量 MB/s
}> {
const durations: number[] = []
const speeds: number[] = []
const ttfb: number[] = []
let success = 0
let failed = 0
const startTime = Date.now()
// 循环使用URLs
for (let i = 0; i < count; i += concurrency) {
const batch = []
for (let j = 0; j < concurrency && i + j < count; j++) {
const url = urls[(i + j) % urls.length]
batch.push(testDownloadSpeed(url))
}
const results = await Promise.allSettled(batch)
for (const result of results) {
if (result.status === 'fulfilled') {
const r = result.value
if (r.success) {
durations.push(r.duration)
speeds.push(r.speed)
ttfb.push(r.ttfb)
success++
} else {
failed++
}
} else {
failed++
}
}
}
const totalTime = Date.now() - startTime
// 估算总大小(假设每个文件平均大小)
const avgSizeKB = speeds.length > 0 ? (speeds.reduce((a, b) => a + b, 0) / speeds.length) * (durations.reduce((a, b) => a + b, 0) / durations.length) / 1000 : 0
const totalSizeMB = (success * avgSizeKB) / 1024
const throughput = totalTime > 0 ? (totalSizeMB / totalTime) * 1000 : 0 // MB/s
return {
total: count,
success,
failed,
durations,
speeds,
ttfb,
stats: calculateStats(durations),
ttfbStats: calculateStats(ttfb),
throughput,
}
}
// 混合负载测试(同时上传和下载)
async function testMixedLoad(
uploadConcurrency: number,
downloadConcurrency: number,
uploadSizeKB: number,
downloadUrls: string[],
duration: number // 测试持续时间(毫秒)
): Promise<{
upload: {
total: number
success: number
failed: number
throughput: number
}
download: {
total: number
success: number
failed: number
throughput: number
}
}> {
let uploadTotal = 0
let uploadSuccess = 0
let uploadFailed = 0
let uploadTotalSizeMB = 0
let downloadTotal = 0
let downloadSuccess = 0
let downloadFailed = 0
let downloadTotalSizeMB = 0
const startTime = Date.now()
const endTime = startTime + duration
// 启动上传任务
const uploadTask = (async () => {
while (Date.now() < endTime) {
const batch = []
for (let i = 0; i < uploadConcurrency; i++) {
batch.push(testUploadSpeed(uploadSizeKB))
}
const results = await Promise.allSettled(batch)
for (const result of results) {
uploadTotal++
if (result.status === 'fulfilled') {
const r = result.value
if (r.success) {
uploadSuccess++
uploadTotalSizeMB += uploadSizeKB / 1024
// 清理
if (r.key) {
s3Client.send(
new DeleteObjectCommand({
Bucket: process.env.S3_BUCKET!,
Key: r.key,
})
).catch(() => {})
}
} else {
uploadFailed++
}
} else {
uploadFailed++
}
}
}
})()
// 启动下载任务
const downloadTask = (async () => {
while (Date.now() < endTime) {
const batch = []
for (let i = 0; i < downloadConcurrency; i++) {
const url = downloadUrls[i % downloadUrls.length]
if (url) {
batch.push(testDownloadSpeed(url))
}
}
const results = await Promise.allSettled(batch)
for (const result of results) {
downloadTotal++
if (result.status === 'fulfilled') {
const r = result.value
if (r.success) {
downloadSuccess++
// 估算大小
if (r.speed > 0) {
downloadTotalSizeMB += (r.speed * r.duration) / (1024 * 1000)
}
} else {
downloadFailed++
}
} else {
downloadFailed++
}
}
}
})()
await Promise.all([uploadTask, downloadTask])
const actualDuration = Date.now() - startTime
return {
upload: {
total: uploadTotal,
success: uploadSuccess,
failed: uploadFailed,
throughput: actualDuration > 0 ? (uploadTotalSizeMB / actualDuration) * 1000 : 0,
},
download: {
total: downloadTotal,
success: downloadSuccess,
failed: downloadFailed,
throughput: actualDuration > 0 ? (downloadTotalSizeMB / actualDuration) * 1000 : 0,
},
}
}
// 获取测试文件URLs
async function getTestFileUrls(count: number = 10): Promise<string[]> {
const urls: string[] = []
try {
const command = new ListObjectsV2Command({
Bucket: process.env.S3_BUCKET!,
MaxKeys: count,
})
const response = await s3Client.send(command)
if (response.Contents && response.Contents.length > 0) {
for (const file of response.Contents) {
const key = file.Key || ''
// 跳过测试文件
if (key && !key.includes('speed-test-')) {
urls.push(`${process.env.S3_PUBLIC_DOMAIN}/${key}`)
}
}
}
} catch (error) {
// ignore
}
return urls
}
// 清理所有测试文件(以防有遗漏)
async function cleanupAllTestFiles(): Promise<{ deleted: number; failed: number }> {
let deleted = 0
let failed = 0
let continuationToken: string | undefined = undefined
try {
do {
const listCommand: ListObjectsV2Command = new ListObjectsV2Command({
Bucket: process.env.S3_BUCKET!,
Prefix: 'speed-test-',
ContinuationToken: continuationToken,
MaxKeys: 1000,
})
const listResponse = await s3Client.send(listCommand) as ListObjectsV2CommandOutput
if (listResponse.Contents && listResponse.Contents.length > 0) {
const deletePromises = listResponse.Contents.map((file) => {
if (file.Key) {
return s3Client.send(
new DeleteObjectCommand({
Bucket: process.env.S3_BUCKET!,
Key: file.Key,
})
).then(() => {
deleted++
}).catch(() => {
failed++
})
}
return Promise.resolve()
})
await Promise.allSettled(deletePromises)
}
continuationToken = listResponse.NextContinuationToken
} while (continuationToken)
} catch (error) {
console.warn('[S3 Speed Test] Cleanup error:', error)
}
return { deleted, failed }
}
export async function GET(request: NextRequest) {
try {
const searchParams = request.nextUrl.searchParams
const testType = (searchParams.get('type') || 'full') as 'full' | 'concurrent' | 'mixed' | 'quick'
const concurrency = parseInt(searchParams.get('concurrency') || '10')
const count = parseInt(searchParams.get('count') || '50')
const isIntranet = detectIsIntranet(request)
console.log('[S3 Speed Test] Starting comprehensive tests...')
console.log(`[S3 Speed Test] Type: ${testType}, Concurrency: ${concurrency}, Count: ${count}`)
console.log(`[S3 Speed Test] Is Intranet: ${isIntranet}`)
const result: any = {
success: true,
isIntranet,
config: {
s3Endpoint: process.env.S3_ENDPOINT,
s3PublicDomain: process.env.S3_PUBLIC_DOMAIN,
serverIp: process.env.SERVER_IP,
minioPort: process.env.MINIO_API_PORT || '9000',
},
timestamp: new Date().toISOString(),
}
// 1. 基础连接测试
console.log('[S3 Speed Test] 1. Testing connection...')
const connectionTime = await testConnectionSpeed()
result.connection = { duration: connectionTime }
// 2. 单文件上传测试(不同大小)
if (testType === 'full' || testType === 'quick') {
console.log('[S3 Speed Test] 2. Testing single file uploads (various sizes)...')
const uploadSizes: number[] = testType === 'quick'
? [10, 100, 1024] // 快速测试:10KB, 100KB, 1MB
: [10, 50, 100, 500, 1024, 5120, 10240] // 完整测试:10KB到10MB
result.upload = {}
for (const sizeKB of uploadSizes) {
const test = await testUploadSpeed(sizeKB)
result.upload[`${sizeKB}KB`] = {
sizeKB,
duration: test.duration,
speedKBps: test.speed,
speedMBps: test.speed / 1024,
success: test.success,
error: test.error,
}
// 清理
if (test.key) {
s3Client.send(
new DeleteObjectCommand({
Bucket: process.env.S3_BUCKET!,
Key: test.key,
})
).catch(() => {})
}
}
}
// 3. 并发上传测试
if (testType === 'full' || testType === 'concurrent' || testType === 'mixed' || testType === 'quick') {
console.log('[S3 Speed Test] 3. Testing concurrent uploads...')
const concurrentSizes = testType === 'quick'
? [{ size: 100, concurrency: 5, count: 20 }]
: [
{ size: 10, concurrency: 10, count: 50 },
{ size: 100, concurrency: 10, count: 50 },
{ size: 1024, concurrency: 5, count: 20 },
{ size: 100, concurrency: 20, count: 100 },
{ size: 100, concurrency: 50, count: 200 },
]
result.concurrentUpload = {}
for (const config of concurrentSizes) {
const test = await testConcurrentUploads(config.concurrency, config.size, config.count)
result.concurrentUpload[`${config.size}KB_${config.concurrency}并发_${config.count}次`] = {
...test,
config,
}
}
}
// 4. 下载测试
if (testType === 'full' || testType === 'quick' || testType === 'concurrent' || testType === 'mixed') {
console.log('[S3 Speed Test] 4. Testing downloads...')
const testFileUrls = await getTestFileUrls(20)
if (testFileUrls.length > 0) {
// 公网下载测试
const publicDownload = await testDownloadSpeed(testFileUrls[0])
result.download = {
public: {
url: testFileUrls[0],
...publicDownload,
speedMBps: publicDownload.speed / 1024,
},
}
// 内网下载测试
if (isIntranet && process.env.SERVER_IP) {
try {
const url = new URL(testFileUrls[0])
const intranetUrl = `http://${process.env.SERVER_IP}:${process.env.MINIO_API_PORT || '9000'}${url.pathname}`
const intranetDownload = await testDownloadSpeed(intranetUrl)
result.download.intranet = {
url: intranetUrl,
...intranetDownload,
speedMBps: intranetDownload.speed / 1024,
speedup: publicDownload.speed > 0 ? (intranetDownload.speed / publicDownload.speed) : 0,
}
} catch (error) {
console.warn('[S3 Speed Test] Cannot test intranet download')
}
}
// 并发下载测试
if (testType === 'full' || testType === 'concurrent' || testType === 'mixed' || testType === 'quick') {
console.log('[S3 Speed Test] 5. Testing concurrent downloads...')
const concurrentConfigs: Array<{ concurrency: number; count: number }> = testType === 'quick'
? [{ concurrency: 5, count: 20 }]
: [
{ concurrency: 10, count: 50 },
{ concurrency: 20, count: 100 },
{ concurrency: 50, count: 200 },
]
result.concurrentDownload = {}
for (const config of concurrentConfigs) {
const test = await testConcurrentDownloads(config.concurrency, testFileUrls, config.count)
result.concurrentDownload[`${config.concurrency}并发_${config.count}次`] = {
...test,
config,
}
}
}
}
}
// 6. 混合负载测试
if (testType === 'full' || testType === 'mixed') {
console.log('[S3 Speed Test] 6. Testing mixed load (upload + download)...')
const testFileUrls = await getTestFileUrls(10)
if (testFileUrls.length > 0) {
const mixedTest = await testMixedLoad(
concurrency,
concurrency,
100, // 100KB上传
testFileUrls,
30000 // 30秒
)
result.mixedLoad = mixedTest
}
}
// 7. 压力测试(高并发)
if (testType === 'full') {
console.log('[S3 Speed Test] 7. Testing stress (high concurrency)...')
const stressTest = await testConcurrentUploads(100, 50, 500) // 100并发,50KB,500次
result.stressTest = stressTest
}
// 8. 最终清理:确保所有测试文件都被删除
console.log('[S3 Speed Test] 8. Cleaning up all test files...')
const cleanupResult = await cleanupAllTestFiles()
result.cleanup = cleanupResult
console.log(`[S3 Speed Test] Cleanup: ${cleanupResult.deleted} deleted, ${cleanupResult.failed} failed`)
console.log('[S3 Speed Test] All tests completed')
return NextResponse.json(result)
} catch (error: any) {
console.error('[S3 Speed Test] Error:', error)
return NextResponse.json(
{
success: false,
error: error.message || '测试失败',
stack: process.env.NODE_ENV === 'development' ? error.stack : undefined,
},
{ status: 500 }
)
}
}