mirror of
https://github.com/lqtmcstudio/QZMusic_PC.git
synced 2026-06-20 23:35:06 +08:00
feat: 迁移架构&实现功能
- 持久化音量设置 - 搜索页支持自定义每页显示数量(持久化) - vite-electron-plugin迁移electron-vite
This commit is contained in:
lqtmcstudio
974
src/main/proxyServer.ts
Normal file
974
src/main/proxyServer.ts
Normal file
@@ -0,0 +1,974 @@
|
||||
import http from 'http';
|
||||
import { Readable } from 'stream';
|
||||
import fs from 'fs';
|
||||
import path from 'path';
|
||||
import { app } from 'electron';
|
||||
// @ts-ignore
|
||||
import { PluginSystem } from './pluginSystem.ts';
|
||||
|
||||
const PORT = 5266;
|
||||
let CACHE_DIR = '';
|
||||
|
||||
function ensureCacheDir() {
|
||||
if (!CACHE_DIR) {
|
||||
CACHE_DIR = path.join(app.getPath('userData'), 'music', 'cache');
|
||||
}
|
||||
if (!fs.existsSync(CACHE_DIR)) {
|
||||
try {
|
||||
fs.mkdirSync(CACHE_DIR, { recursive: true });
|
||||
console.log(`[Proxy] Created cache directory: ${CACHE_DIR}`);
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Failed to create cache directory:', e);
|
||||
}
|
||||
}
|
||||
return CACHE_DIR;
|
||||
}
|
||||
|
||||
interface CacheEntry {
|
||||
url: string;
|
||||
expiresAt: number;
|
||||
}
|
||||
|
||||
interface CacheMetadata {
|
||||
totalSize: number;
|
||||
contentType: string;
|
||||
complete: boolean;
|
||||
createdAt: number;
|
||||
}
|
||||
|
||||
interface DownloadTask {
|
||||
currentSize: number;
|
||||
totalSize: number;
|
||||
contentType: string;
|
||||
abortController: AbortController | null;
|
||||
promise: Promise<void> | null;
|
||||
// 新增：用于通知等待者的回调列表
|
||||
waiters: Array<{ start: number; end: number; resolve: () => void; reject: (err: Error) => void }>;
|
||||
}
|
||||
|
||||
// Memory cache for resolved URLs
|
||||
const urlCache = new Map<string, CacheEntry>();
|
||||
|
||||
// Track background download tasks
|
||||
const downloadTasks = new Map<string, DownloadTask>();
|
||||
|
||||
function getCachePath(source: string, id: string, quality: string) {
|
||||
const dir = ensureCacheDir();
|
||||
const safeId = id.replace(/[^a-z0-9]/gi, '_');
|
||||
return path.join(dir, `${source}-${safeId}-${quality}`);
|
||||
}
|
||||
|
||||
function getMetadataPath(cachePath: string): string {
|
||||
return cachePath + '.meta';
|
||||
}
|
||||
|
||||
function getTempPath(cachePath: string): string {
|
||||
return cachePath + '.tmp';
|
||||
}
|
||||
|
||||
function readMetadata(cachePath: string): CacheMetadata | null {
|
||||
const metaPath = getMetadataPath(cachePath);
|
||||
try {
|
||||
if (fs.existsSync(metaPath)) {
|
||||
return JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Failed to read metadata:', e);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function writeMetadata(cachePath: string, metadata: CacheMetadata) {
|
||||
const metaPath = getMetadataPath(cachePath);
|
||||
try {
|
||||
fs.writeFileSync(metaPath, JSON.stringify(metadata));
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Failed to write metadata:', e);
|
||||
}
|
||||
}
|
||||
|
||||
async function fetchFreshUrl(source: string, id: string, quality: string): Promise<string | null> {
|
||||
try {
|
||||
const plugin = new PluginSystem(source);
|
||||
const result = await plugin.getUrl(id, quality);
|
||||
if (result.success && result.url) {
|
||||
urlCache.set(`${source}:${id}:${quality}`, {
|
||||
url: result.url,
|
||||
expiresAt: Date.now() + 3600 * 1000
|
||||
});
|
||||
return result.url;
|
||||
}
|
||||
console.error(`[Proxy] Failed to fetch URL for ${source}:${id}`, result.error);
|
||||
return null;
|
||||
} catch (e) {
|
||||
console.error(`[Proxy] Error fetching URL:`, e);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function isValidCacheFile(filePath: string): boolean {
|
||||
try {
|
||||
const metadata = readMetadata(filePath);
|
||||
if (!metadata || !metadata.complete) return false;
|
||||
if (!fs.existsSync(filePath)) return false;
|
||||
|
||||
const stat = fs.statSync(filePath);
|
||||
return stat.size === metadata.totalSize && stat.size > 1024;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function parseRangeHeader(range: string | undefined, fileSize: number): { start: number; end: number } | null {
|
||||
if (!range) return null;
|
||||
|
||||
const match = range.match(/bytes=(\d*)-(\d*)/);
|
||||
if (!match) return null;
|
||||
|
||||
let start = match[1] ? parseInt(match[1], 10) : 0;
|
||||
let end = match[2] ? parseInt(match[2], 10) : fileSize - 1;
|
||||
|
||||
if (start >= fileSize) return null;
|
||||
end = Math.min(end, fileSize - 1);
|
||||
|
||||
return { start, end };
|
||||
}
|
||||
|
||||
function serveFromCache(req: http.IncomingMessage, res: http.ServerResponse, filePath: string): boolean {
|
||||
try {
|
||||
const metadata = readMetadata(filePath);
|
||||
if (!metadata) {
|
||||
console.warn('[Proxy] No metadata for cache file');
|
||||
return false;
|
||||
}
|
||||
|
||||
const stat = fs.statSync(filePath);
|
||||
const fileSize = stat.size;
|
||||
const range = parseRangeHeader(req.headers.range, fileSize);
|
||||
|
||||
if (range) {
|
||||
const { start, end } = range;
|
||||
const chunksize = (end - start) + 1;
|
||||
|
||||
res.writeHead(206, {
|
||||
'Content-Range': `bytes ${start}-${end}/${fileSize}`,
|
||||
'Accept-Ranges': 'bytes',
|
||||
'Content-Length': chunksize,
|
||||
'Content-Type': metadata.contentType || 'audio/mpeg',
|
||||
});
|
||||
|
||||
const file = fs.createReadStream(filePath, { start, end });
|
||||
file.pipe(res);
|
||||
|
||||
file.on('error', (err) => {
|
||||
console.error('[Proxy] Error reading cache file:', err);
|
||||
if (!res.headersSent) {
|
||||
res.writeHead(500);
|
||||
res.end('Cache read error');
|
||||
}
|
||||
});
|
||||
} else {
|
||||
res.writeHead(200, {
|
||||
'Content-Length': fileSize,
|
||||
'Content-Type': metadata.contentType || 'audio/mpeg',
|
||||
'Accept-Ranges': 'bytes',
|
||||
});
|
||||
const stream = fs.createReadStream(filePath);
|
||||
stream.pipe(res);
|
||||
|
||||
stream.on('error', (err) => {
|
||||
console.error('[Proxy] Error reading cache file:', err);
|
||||
});
|
||||
}
|
||||
return true;
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Error serving from cache:', e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 直接代理 Range 请求，不缓存（用于 seek 到未下载的位置）
|
||||
*/
|
||||
async function proxyRangeDirect(
|
||||
req: http.IncomingMessage,
|
||||
res: http.ServerResponse,
|
||||
targetUrl: string,
|
||||
totalSize: number,
|
||||
contentType: string
|
||||
): Promise<void> {
|
||||
const headers: Record<string, string> = {
|
||||
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
|
||||
};
|
||||
|
||||
if (req.headers.range) {
|
||||
headers['Range'] = req.headers.range;
|
||||
}
|
||||
|
||||
const response = await fetch(targetUrl, {
|
||||
method: 'GET',
|
||||
headers: headers,
|
||||
});
|
||||
|
||||
if (!response.ok && response.status !== 206) {
|
||||
throw { statusCode: response.status, statusText: response.statusText };
|
||||
}
|
||||
|
||||
const responseContentType = response.headers.get('content-type') || contentType || 'audio/mpeg';
|
||||
const contentLength = response.headers.get('content-length');
|
||||
const contentRange = response.headers.get('content-range');
|
||||
|
||||
if (response.status === 206 && contentRange) {
|
||||
res.writeHead(206, {
|
||||
'Content-Type': responseContentType,
|
||||
'Content-Length': contentLength || '',
|
||||
'Content-Range': contentRange,
|
||||
'Accept-Ranges': 'bytes',
|
||||
});
|
||||
} else {
|
||||
res.writeHead(200, {
|
||||
'Content-Type': responseContentType,
|
||||
'Content-Length': contentLength || '',
|
||||
'Accept-Ranges': 'bytes',
|
||||
});
|
||||
}
|
||||
|
||||
if (!response.body) {
|
||||
res.end();
|
||||
return;
|
||||
}
|
||||
|
||||
// @ts-ignore
|
||||
const nodeStream = Readable.fromWeb(response.body);
|
||||
nodeStream.pipe(res);
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
nodeStream.on('end', resolve);
|
||||
nodeStream.on('error', reject);
|
||||
res.on('close', () => {
|
||||
nodeStream.destroy();
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* 从部分下载的缓存中读取已下载的部分
|
||||
*/
|
||||
function serveFromPartialCache(
|
||||
req: http.IncomingMessage,
|
||||
res: http.ServerResponse,
|
||||
filePath: string,
|
||||
task: DownloadTask
|
||||
): boolean {
|
||||
try {
|
||||
const tempPath = getTempPath(filePath);
|
||||
if (!fs.existsSync(tempPath)) return false;
|
||||
|
||||
const range = parseRangeHeader(req.headers.range, task.totalSize);
|
||||
if (!range) return false;
|
||||
|
||||
const { start, end } = range;
|
||||
|
||||
// 检查请求的范围是否已下载，使用实际文件大小而不是 task.currentSize
|
||||
// 因为文件写入可能有延迟
|
||||
let actualSize: number;
|
||||
try {
|
||||
actualSize = fs.statSync(tempPath).size;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
|
||||
// 确保请求的范围完全在已下载的部分内
|
||||
if (end >= actualSize) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const chunksize = (end - start) + 1;
|
||||
|
||||
res.writeHead(206, {
|
||||
'Content-Range': `bytes ${start}-${end}/${task.totalSize}`,
|
||||
'Accept-Ranges': 'bytes',
|
||||
'Content-Length': chunksize,
|
||||
'Content-Type': task.contentType || 'audio/mpeg',
|
||||
});
|
||||
|
||||
const file = fs.createReadStream(tempPath, { start, end });
|
||||
file.pipe(res);
|
||||
|
||||
file.on('error', (err) => {
|
||||
console.error('[Proxy] Error reading partial cache:', err);
|
||||
});
|
||||
|
||||
return true;
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Error serving from partial cache:', e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 启动后台下载任务（不阻塞当前请求）
|
||||
* 修复版本：确保下载任务独立运行，不受客户端连接影响
|
||||
*/
|
||||
function startBackgroundDownload(
|
||||
targetUrl: string,
|
||||
cacheFilePath: string,
|
||||
cacheKey: string
|
||||
): DownloadTask {
|
||||
const existingTask = downloadTasks.get(cacheFilePath);
|
||||
if (existingTask && existingTask.promise) {
|
||||
console.log(`[Proxy] Reusing existing download task for ${cacheFilePath}`);
|
||||
return existingTask;
|
||||
}
|
||||
|
||||
const abortController = new AbortController();
|
||||
const task: DownloadTask = {
|
||||
currentSize: 0,
|
||||
totalSize: 0,
|
||||
contentType: 'audio/mpeg',
|
||||
abortController,
|
||||
promise: null,
|
||||
waiters: [],
|
||||
};
|
||||
|
||||
downloadTasks.set(cacheFilePath, task);
|
||||
|
||||
task.promise = (async () => {
|
||||
const tempPath = getTempPath(cacheFilePath);
|
||||
|
||||
try {
|
||||
// 清理旧文件
|
||||
try {
|
||||
if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
|
||||
} catch { }
|
||||
|
||||
const response = await fetch(targetUrl, {
|
||||
method: 'GET',
|
||||
headers: {
|
||||
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
|
||||
},
|
||||
signal: abortController.signal,
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
throw new Error(`HTTP ${response.status}`);
|
||||
}
|
||||
|
||||
const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
|
||||
const contentType = response.headers.get('content-type') || 'audio/mpeg';
|
||||
|
||||
if (!contentLength) {
|
||||
console.warn('[Proxy] Background download: No content-length, skipping cache');
|
||||
downloadTasks.delete(cacheFilePath);
|
||||
return;
|
||||
}
|
||||
|
||||
task.totalSize = contentLength;
|
||||
task.contentType = contentType;
|
||||
|
||||
console.log(`[Proxy] Background download started: ${cacheFilePath} (${contentLength} bytes)`);
|
||||
|
||||
const fileStream = fs.createWriteStream(tempPath);
|
||||
|
||||
if (!response.body) {
|
||||
downloadTasks.delete(cacheFilePath);
|
||||
return;
|
||||
}
|
||||
|
||||
// @ts-ignore
|
||||
const nodeStream = Readable.fromWeb(response.body);
|
||||
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
nodeStream.on('data', (chunk: Buffer) => {
|
||||
task.currentSize += chunk.length;
|
||||
|
||||
// 通知等待下载进度的请求
|
||||
notifyWaiters(task);
|
||||
|
||||
// 每 10% 输出一次进度
|
||||
if (task.currentSize % Math.floor(contentLength / 10) < chunk.length) {
|
||||
const percent = Math.floor((task.currentSize / contentLength) * 100);
|
||||
console.log(`[Proxy] Download progress: ${percent}% (${task.currentSize}/${contentLength})`);
|
||||
}
|
||||
});
|
||||
|
||||
nodeStream.pipe(fileStream);
|
||||
|
||||
fileStream.on('finish', () => {
|
||||
try {
|
||||
const stat = fs.statSync(tempPath);
|
||||
if (stat.size === contentLength) {
|
||||
fs.renameSync(tempPath, cacheFilePath);
|
||||
writeMetadata(cacheFilePath, {
|
||||
totalSize: contentLength,
|
||||
contentType: contentType,
|
||||
complete: true,
|
||||
createdAt: Date.now()
|
||||
});
|
||||
console.log(`[Proxy] Background download complete: ${cacheFilePath}`);
|
||||
} else {
|
||||
console.warn(`[Proxy] Incomplete download: ${stat.size}/${contentLength}`);
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Failed to finalize cache:', e);
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
}
|
||||
resolve();
|
||||
});
|
||||
|
||||
fileStream.on('error', (err) => {
|
||||
console.error('[Proxy] Background download write error:', err);
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
reject(err);
|
||||
});
|
||||
|
||||
nodeStream.on('error', (err: Error) => {
|
||||
console.error('[Proxy] Background download stream error:', err);
|
||||
fileStream.destroy();
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
|
||||
} catch (e: any) {
|
||||
if (e.name !== 'AbortError') {
|
||||
console.error('[Proxy] Background download failed:', e);
|
||||
}
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
|
||||
// 通知所有等待者下载失败
|
||||
for (const waiter of task.waiters) {
|
||||
waiter.reject(new Error('Download failed'));
|
||||
}
|
||||
task.waiters = [];
|
||||
} finally {
|
||||
downloadTasks.delete(cacheFilePath);
|
||||
}
|
||||
})();
|
||||
|
||||
return task;
|
||||
}
|
||||
|
||||
/**
|
||||
* 通知等待下载进度的请求
|
||||
*/
|
||||
function notifyWaiters(task: DownloadTask) {
|
||||
const resolvedWaiters: number[] = [];
|
||||
|
||||
for (let i = 0; i < task.waiters.length; i++) {
|
||||
const waiter = task.waiters[i];
|
||||
// 当下载进度超过请求的结束位置时，通知等待者
|
||||
if (task.currentSize > waiter.end) {
|
||||
waiter.resolve();
|
||||
resolvedWaiters.push(i);
|
||||
}
|
||||
}
|
||||
|
||||
// 移除已解决的等待者
|
||||
for (let i = resolvedWaiters.length - 1; i >= 0; i--) {
|
||||
task.waiters.splice(resolvedWaiters[i], 1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 主代理函数 - 智能处理缓存和 Range 请求
|
||||
* 修复版本：正确处理流的复制，确保下载和响应同时进行
|
||||
*/
|
||||
async function proxyAndCache(
|
||||
req: http.IncomingMessage,
|
||||
res: http.ServerResponse,
|
||||
targetUrl: string,
|
||||
cacheFilePath: string,
|
||||
cacheKey: string
|
||||
): Promise<void> {
|
||||
const requestedRange = req.headers.range;
|
||||
const isSeekRequest = requestedRange && !requestedRange.startsWith('bytes=0-');
|
||||
|
||||
// 检查是否有正在进行的后台下载
|
||||
let task = downloadTasks.get(cacheFilePath);
|
||||
|
||||
if (task) {
|
||||
console.log(`[Proxy] Download in progress: ${task.currentSize}/${task.totalSize}`);
|
||||
|
||||
if (requestedRange && task.totalSize > 0) {
|
||||
const range = parseRangeHeader(requestedRange, task.totalSize);
|
||||
|
||||
if (range) {
|
||||
// 获取临时文件的实际大小
|
||||
const tempPath = getTempPath(cacheFilePath);
|
||||
let actualSize = 0;
|
||||
try {
|
||||
if (fs.existsSync(tempPath)) {
|
||||
actualSize = fs.statSync(tempPath).size;
|
||||
}
|
||||
} catch { }
|
||||
|
||||
// 如果请求的范围已经下载完成，从缓存读取
|
||||
if (range.end < actualSize) {
|
||||
console.log(`[Proxy] Serving range ${range.start}-${range.end} from partial cache (downloaded: ${actualSize})`);
|
||||
if (serveFromPartialCache(req, res, cacheFilePath, task)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 请求的数据还没下载到，直接代理
|
||||
console.log(`[Proxy] Range ${range.start}-${range.end} not cached yet (downloaded: ${actualSize}), proxying directly`);
|
||||
await proxyRangeDirect(req, res, targetUrl, task.totalSize, task.contentType);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// 无法确定如何处理，直接代理
|
||||
await proxyRangeDirect(req, res, targetUrl, task.totalSize, task.contentType);
|
||||
return;
|
||||
}
|
||||
|
||||
// 没有正在进行的下载任务
|
||||
|
||||
if (isSeekRequest) {
|
||||
// Seek 请求：启动后台下载任务，同时直接代理当前请求
|
||||
console.log(`[Proxy] Seek request: ${requestedRange}, starting background download`);
|
||||
|
||||
// 启动后台下载（不等待）
|
||||
startBackgroundDownload(targetUrl, cacheFilePath, cacheKey);
|
||||
|
||||
// 获取文件信息用于正确的 Range 响应
|
||||
const headResponse = await fetch(targetUrl, {
|
||||
method: 'HEAD',
|
||||
headers: {
|
||||
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
|
||||
}
|
||||
});
|
||||
|
||||
const totalSize = parseInt(headResponse.headers.get('content-length') || '0', 10);
|
||||
const contentType = headResponse.headers.get('content-type') || 'audio/mpeg';
|
||||
|
||||
// 直接代理当前的 Range 请求
|
||||
await proxyRangeDirect(req, res, targetUrl, totalSize, contentType);
|
||||
return;
|
||||
}
|
||||
|
||||
// 从头开始的请求：下载并同时流式返回
|
||||
await streamAndCache(req, res, targetUrl, cacheFilePath, cacheKey);
|
||||
}
|
||||
|
||||
/**
|
||||
* 新增：边下载边返回给客户端，同时写入缓存
|
||||
* 使用 PassThrough 流正确复制数据
|
||||
*/
|
||||
async function streamAndCache(
|
||||
req: http.IncomingMessage,
|
||||
res: http.ServerResponse,
|
||||
targetUrl: string,
|
||||
cacheFilePath: string,
|
||||
cacheKey: string
|
||||
): Promise<void> {
|
||||
const headers: Record<string, string> = {
|
||||
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
|
||||
};
|
||||
|
||||
const response = await fetch(targetUrl, {
|
||||
method: 'GET',
|
||||
headers: headers,
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
throw { statusCode: response.status, statusText: response.statusText };
|
||||
}
|
||||
|
||||
const contentLength = parseInt(response.headers.get('content-length') || '0', 10);
|
||||
const contentType = response.headers.get('content-type') || 'audio/mpeg';
|
||||
|
||||
if (!contentLength) {
|
||||
console.warn('[Proxy] No content-length, proxying without cache');
|
||||
res.writeHead(200, {
|
||||
'Content-Type': contentType,
|
||||
'Accept-Ranges': 'bytes',
|
||||
});
|
||||
|
||||
if (response.body) {
|
||||
// @ts-ignore
|
||||
const nodeStream = Readable.fromWeb(response.body);
|
||||
nodeStream.pipe(res);
|
||||
} else {
|
||||
res.end();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
const tempPath = getTempPath(cacheFilePath);
|
||||
|
||||
// 清理旧文件
|
||||
try {
|
||||
if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
|
||||
if (fs.existsSync(cacheFilePath)) fs.unlinkSync(cacheFilePath);
|
||||
} catch { }
|
||||
|
||||
const fileStream = fs.createWriteStream(tempPath);
|
||||
|
||||
// 创建下载任务用于跟踪进度
|
||||
const task: DownloadTask = {
|
||||
currentSize: 0,
|
||||
totalSize: contentLength,
|
||||
contentType: contentType,
|
||||
abortController: null,
|
||||
promise: null,
|
||||
waiters: [],
|
||||
};
|
||||
downloadTasks.set(cacheFilePath, task);
|
||||
|
||||
console.log(`[Proxy] Starting stream download: ${cacheFilePath} (${contentLength} bytes)`);
|
||||
|
||||
// 发送响应头
|
||||
res.writeHead(200, {
|
||||
'Content-Length': contentLength,
|
||||
'Content-Type': contentType,
|
||||
'Accept-Ranges': 'bytes',
|
||||
});
|
||||
|
||||
if (!response.body) {
|
||||
res.end();
|
||||
downloadTasks.delete(cacheFilePath);
|
||||
return;
|
||||
}
|
||||
|
||||
// @ts-ignore
|
||||
const nodeStream = Readable.fromWeb(response.body);
|
||||
|
||||
// 关键修复：使用正确的方式将流复制到多个目标
|
||||
// 手动读取数据并写入多个目标
|
||||
let clientConnected = true;
|
||||
let downloadComplete = false;
|
||||
|
||||
res.on('close', () => {
|
||||
clientConnected = false;
|
||||
console.log('[Proxy] Client disconnected');
|
||||
});
|
||||
|
||||
return new Promise<void>((resolve, reject) => {
|
||||
nodeStream.on('data', (chunk: Buffer) => {
|
||||
task.currentSize += chunk.length;
|
||||
|
||||
// 写入文件（始终进行）
|
||||
fileStream.write(chunk);
|
||||
|
||||
// 写入响应（如果客户端还连接着）
|
||||
if (clientConnected && !res.writableEnded) {
|
||||
res.write(chunk);
|
||||
}
|
||||
|
||||
// 通知等待者
|
||||
notifyWaiters(task);
|
||||
});
|
||||
|
||||
nodeStream.on('end', () => {
|
||||
downloadComplete = true;
|
||||
|
||||
// 结束文件流
|
||||
fileStream.end();
|
||||
|
||||
// 结束响应（如果客户端还连接着）
|
||||
if (clientConnected && !res.writableEnded) {
|
||||
res.end();
|
||||
}
|
||||
});
|
||||
|
||||
nodeStream.on('error', (err: Error) => {
|
||||
console.error('[Proxy] Stream error:', err);
|
||||
fileStream.destroy();
|
||||
|
||||
if (clientConnected && !res.headersSent) {
|
||||
res.writeHead(502);
|
||||
res.end('Proxy stream error');
|
||||
}
|
||||
|
||||
downloadTasks.delete(cacheFilePath);
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
reject(err);
|
||||
});
|
||||
|
||||
fileStream.on('finish', () => {
|
||||
downloadTasks.delete(cacheFilePath);
|
||||
|
||||
// 验证并移动文件
|
||||
try {
|
||||
const stat = fs.statSync(tempPath);
|
||||
if (stat.size === contentLength) {
|
||||
fs.renameSync(tempPath, cacheFilePath);
|
||||
writeMetadata(cacheFilePath, {
|
||||
totalSize: contentLength,
|
||||
contentType: contentType,
|
||||
complete: true,
|
||||
createdAt: Date.now()
|
||||
});
|
||||
console.log(`[Proxy] Cache complete: ${cacheFilePath} (${contentLength} bytes)`);
|
||||
} else {
|
||||
console.warn(`[Proxy] Incomplete download: ${stat.size}/${contentLength}`);
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Failed to finalize cache:', e);
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
}
|
||||
|
||||
resolve();
|
||||
});
|
||||
|
||||
fileStream.on('error', (err) => {
|
||||
console.error('[Proxy] File write error:', err);
|
||||
downloadTasks.delete(cacheFilePath);
|
||||
try { fs.unlinkSync(tempPath); } catch { }
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
let persistCacheEnabled = true;
|
||||
|
||||
export function getCacheDir() {
|
||||
return ensureCacheDir();
|
||||
}
|
||||
|
||||
export function getCacheSize(): string {
|
||||
const dir = ensureCacheDir();
|
||||
if (!fs.existsSync(dir)) return '0 B';
|
||||
|
||||
let totalSize = 0;
|
||||
try {
|
||||
const files = fs.readdirSync(dir);
|
||||
for (const file of files) {
|
||||
const filePath = path.join(dir, file);
|
||||
try {
|
||||
const stat = fs.statSync(filePath);
|
||||
if (stat.isFile()) {
|
||||
totalSize += stat.size;
|
||||
}
|
||||
} catch { }
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Error calculating cache size:', e);
|
||||
}
|
||||
|
||||
if (totalSize < 1024) return `${totalSize} B`;
|
||||
if (totalSize < 1024 * 1024) return `${(totalSize / 1024).toFixed(1)} KB`;
|
||||
if (totalSize < 1024 * 1024 * 1024) return `${(totalSize / (1024 * 1024)).toFixed(1)} MB`;
|
||||
return `${(totalSize / (1024 * 1024 * 1024)).toFixed(2)} GB`;
|
||||
}
|
||||
|
||||
export function isPersistCacheEnabled() {
|
||||
return persistCacheEnabled;
|
||||
}
|
||||
|
||||
export function setPersistCache(persist: boolean) {
|
||||
persistCacheEnabled = persist;
|
||||
console.log(`[Proxy] Cache persistence set to: ${persist}`);
|
||||
}
|
||||
|
||||
export function clearCacheNow() {
|
||||
const dir = ensureCacheDir();
|
||||
if (fs.existsSync(dir)) {
|
||||
console.log(`[Proxy] Clearing cache directory: ${dir}`);
|
||||
|
||||
// 终止所有下载任务
|
||||
for (const [, task] of downloadTasks) {
|
||||
if (task.abortController) {
|
||||
task.abortController.abort();
|
||||
}
|
||||
}
|
||||
downloadTasks.clear();
|
||||
|
||||
try {
|
||||
fs.rmSync(dir, { recursive: true, force: true });
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
console.log('[Proxy] Cache cleared');
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Failed to clear cache:', e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function cleanupCache() {
|
||||
if (!persistCacheEnabled && CACHE_DIR && fs.existsSync(CACHE_DIR)) {
|
||||
console.log(`[Proxy] Cleaning up cache directory: ${CACHE_DIR}`);
|
||||
|
||||
// 终止所有下载任务
|
||||
for (const [, task] of downloadTasks) {
|
||||
if (task.abortController) {
|
||||
task.abortController.abort();
|
||||
}
|
||||
}
|
||||
downloadTasks.clear();
|
||||
|
||||
try {
|
||||
fs.rmSync(CACHE_DIR, { recursive: true, force: true });
|
||||
console.log('[Proxy] Cache cleanup complete');
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Failed to cleanup cache:', e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 清理过期的临时文件
|
||||
*/
|
||||
function cleanupTempFiles() {
|
||||
const dir = ensureCacheDir();
|
||||
try {
|
||||
const files = fs.readdirSync(dir);
|
||||
const now = Date.now();
|
||||
|
||||
for (const file of files) {
|
||||
if (file.endsWith('.tmp')) {
|
||||
const filePath = path.join(dir, file);
|
||||
const cacheFilePath = filePath.replace('.tmp', '');
|
||||
|
||||
// 如果没有正在下载这个文件，且临时文件超过 1 小时，删除它
|
||||
if (!downloadTasks.has(cacheFilePath)) {
|
||||
try {
|
||||
const stat = fs.statSync(filePath);
|
||||
if (now - stat.mtimeMs > 3600 * 1000) {
|
||||
fs.unlinkSync(filePath);
|
||||
console.log(`[Proxy] Cleaned up stale temp file: ${file}`);
|
||||
}
|
||||
} catch { }
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (e) {
|
||||
console.error('[Proxy] Error cleaning up temp files:', e);
|
||||
}
|
||||
}
|
||||
|
||||
export function startProxyServer(persistCache: boolean = true) {
|
||||
persistCacheEnabled = persistCache;
|
||||
console.log(`[Proxy] Persist cache: ${persistCache}`);
|
||||
|
||||
// 定期清理临时文件
|
||||
setInterval(cleanupTempFiles, 30 * 60 * 1000);
|
||||
|
||||
const server = http.createServer(async (req, res) => {
|
||||
res.setHeader('Access-Control-Allow-Origin', '*');
|
||||
res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, OPTIONS');
|
||||
res.setHeader('Access-Control-Allow-Headers', 'Range');
|
||||
|
||||
if (req.method === 'OPTIONS') {
|
||||
res.statusCode = 204;
|
||||
res.end();
|
||||
return;
|
||||
}
|
||||
|
||||
if (req.method === 'HEAD') {
|
||||
res.setHeader('Accept-Ranges', 'bytes');
|
||||
res.statusCode = 200;
|
||||
res.end();
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
const parsedUrl = new URL(req.url || '', `http://localhost:${PORT}`);
|
||||
if (parsedUrl.pathname !== '/music') {
|
||||
res.writeHead(404);
|
||||
res.end('Not Found');
|
||||
return;
|
||||
}
|
||||
|
||||
const id = parsedUrl.searchParams.get('id');
|
||||
const source = parsedUrl.searchParams.get('source');
|
||||
const quality = parsedUrl.searchParams.get('quality') || 'standard';
|
||||
|
||||
if (!id || !source) {
|
||||
res.writeHead(400);
|
||||
res.end('Missing id or source');
|
||||
return;
|
||||
}
|
||||
|
||||
const cacheKey = `${source}:${id}:${quality}`;
|
||||
const cacheFilePath = getCachePath(source, id, quality);
|
||||
|
||||
// 1. 检查完整缓存
|
||||
if (isValidCacheFile(cacheFilePath)) {
|
||||
console.log(`[Proxy] Serving from complete cache: ${cacheFilePath}`);
|
||||
const success = serveFromCache(req, res, cacheFilePath);
|
||||
if (success) return;
|
||||
|
||||
// 缓存无效，清理
|
||||
console.warn('[Proxy] Cache file invalid, cleaning up...');
|
||||
try {
|
||||
fs.unlinkSync(cacheFilePath);
|
||||
fs.unlinkSync(getMetadataPath(cacheFilePath));
|
||||
} catch { }
|
||||
}
|
||||
|
||||
// 2. 解析 URL
|
||||
let playUrl: string | null = null;
|
||||
const memCached = urlCache.get(cacheKey);
|
||||
if (memCached && Date.now() < memCached.expiresAt) {
|
||||
playUrl = memCached.url;
|
||||
}
|
||||
|
||||
if (!playUrl) {
|
||||
console.log(`[Proxy] Resolving URL for ${cacheKey}...`);
|
||||
playUrl = await fetchFreshUrl(source, id, quality);
|
||||
}
|
||||
|
||||
if (!playUrl) {
|
||||
res.writeHead(500);
|
||||
res.end('Failed to Obtain URL');
|
||||
return;
|
||||
}
|
||||
|
||||
// 3. 代理和缓存
|
||||
const maxAttempts = 3;
|
||||
let currentAttempt = 0;
|
||||
let lastError: any = null;
|
||||
|
||||
while (currentAttempt < maxAttempts) {
|
||||
try {
|
||||
await proxyAndCache(req, res, playUrl, cacheFilePath, cacheKey);
|
||||
break;
|
||||
} catch (e: any) {
|
||||
lastError = e;
|
||||
currentAttempt++;
|
||||
console.warn(`[Proxy] Proxy error (Attempt ${currentAttempt}/${maxAttempts}):`, e);
|
||||
|
||||
if (currentAttempt < maxAttempts) {
|
||||
console.log('[Proxy] Error occurred, refreshing URL from plugin...');
|
||||
urlCache.delete(cacheKey);
|
||||
|
||||
const newUrl = await fetchFreshUrl(source, id, quality);
|
||||
if (newUrl) {
|
||||
playUrl = newUrl;
|
||||
continue;
|
||||
} else {
|
||||
console.error('[Proxy] Failed to refresh URL');
|
||||
}
|
||||
}
|
||||
|
||||
if (!res.headersSent) {
|
||||
res.writeHead(lastError?.statusCode || 502);
|
||||
res.end('Proxy Error');
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
} catch (err) {
|
||||
console.error('[Proxy] Internal Error:', err);
|
||||
if (!res.headersSent) {
|
||||
res.writeHead(500);
|
||||
res.end('Internal Server Error');
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
server.listen(PORT, '127.0.0.1', () => {
|
||||
ensureCacheDir();
|
||||
cleanupTempFiles();
|
||||
console.log(`[Proxy] Server running at http://127.0.0.1:${PORT}/music`);
|
||||
console.log(`[Proxy] Cache dir: ${CACHE_DIR}`);
|
||||
});
|
||||
|
||||
return server;
|
||||
}
|
||||
Reference in New Issue
Block a user