1097 lines
46 KiB
JavaScript
1097 lines
46 KiB
JavaScript
const http = require('http');
|
||
const https = require('https');
|
||
const url = require('url');
|
||
const querystring = require('querystring');
|
||
const fs = require('fs');
|
||
const pathModule = require('path');
|
||
const crypto = require('crypto');
|
||
|
||
const CACHE_DIR_NAME = '.cache';
|
||
const DEFAULT_PORT = 9001;
|
||
const DEFAULT_API_ENDPOINT = 'http://183.6.121.121:9519/api';
|
||
// 备用 API
|
||
const BACKUP_API_ENDPOINT = 'http://x-mo.cn:9519/api';
|
||
|
||
const cacheDir = pathModule.join(__dirname, CACHE_DIR_NAME);
|
||
const pathIndex = {};
|
||
|
||
// 访问计数器
|
||
const viewsInfo = {
|
||
request: 0,
|
||
cacheHit: 0,
|
||
apiCall: 0,
|
||
cacheCall: 0,
|
||
cacheReadError: 0,
|
||
fetchApiError: 0,
|
||
fetchApiWarning: 0,
|
||
increment: function (key) {
|
||
if (this.hasOwnProperty(key)) {
|
||
this[key]++;
|
||
}
|
||
}
|
||
};
|
||
|
||
let port = DEFAULT_PORT;
|
||
let apiEndpoint = DEFAULT_API_ENDPOINT;
|
||
|
||
// 解析命令行参数函数
|
||
function parseArguments() {
|
||
const args = process.argv.slice(2);
|
||
args.forEach(arg => {
|
||
const cleanArg = arg.startsWith('--') ? arg.substring(2) : arg;
|
||
const [key, value] = cleanArg.split('=');
|
||
if (key === 'port' && value) {
|
||
const parsedPort = parseInt(value, 10);
|
||
if (!isNaN(parsedPort)) {
|
||
port = parsedPort;
|
||
}
|
||
} else if (key === 'api' && value) {
|
||
apiEndpoint = value;
|
||
}
|
||
});
|
||
}
|
||
|
||
// 初始化函数，包含参数解析和目录创建
|
||
function initializeApp() {
|
||
parseArguments();
|
||
if (!fs.existsSync(cacheDir)) {
|
||
try {
|
||
fs.mkdirSync(cacheDir, { recursive: true });
|
||
console.log(`Cache directory created: ${cacheDir}`);
|
||
} catch (err) {
|
||
console.error(`Error creating cache directory ${cacheDir}:`, err);
|
||
process.exit(1); // Exit if cache directory cannot be created
|
||
}
|
||
}
|
||
}
|
||
|
||
initializeApp();
|
||
|
||
const CACHE_EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours
|
||
const CACHE_CLEANUP_INTERVAL_MS = 60 * 60 * 1000; // 1 hour
|
||
const HTTP_STATUS = {
|
||
OK: 200,
|
||
NO_CONTENT: 204,
|
||
REDIRECT: 302,
|
||
NOT_MODIFIED: 304,
|
||
BAD_REQUEST: 400,
|
||
NOT_FOUND: 404,
|
||
INTERNAL_SERVER_ERROR: 500,
|
||
BAD_GATEWAY: 502,
|
||
};
|
||
|
||
// 定时清理过期缓存数据
|
||
setInterval(() => {
|
||
const currentTime = Date.now();
|
||
for (const key in pathIndex) {
|
||
if (currentTime - pathIndex[key].timestamp > CACHE_EXPIRY_MS) {
|
||
delete pathIndex[key];
|
||
}
|
||
}
|
||
}, CACHE_CLEANUP_INTERVAL_MS);
|
||
|
||
// 统一发送错误响应
|
||
function sendErrorResponse(res, statusCode, message) {
|
||
if (!res.headersSent) {
|
||
res.writeHead(statusCode, { 'Content-Type': 'text/plain;charset=UTF-8' });
|
||
res.end(message);
|
||
}
|
||
}
|
||
|
||
// --- Request Handling Logic ---
|
||
|
||
async function handleFavicon(req, res) {
|
||
res.writeHead(HTTP_STATUS.NO_CONTENT);
|
||
res.end();
|
||
}
|
||
|
||
async function handleEndpoint(req, res, parsedUrl) {
|
||
if (parsedUrl.query.api) {
|
||
const urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([\/\w.-]*)*\/?$/;
|
||
if (urlRegex.test(parsedUrl.query.api)) {
|
||
apiEndpoint = parsedUrl.query.api;
|
||
console.log(`API endpoint updated to: ${apiEndpoint}`);
|
||
}
|
||
}
|
||
res.writeHead(HTTP_STATUS.OK, { 'Content-Type': 'application/json; charset=utf-8' });
|
||
res.end(JSON.stringify({
|
||
code: HTTP_STATUS.OK,
|
||
data: {
|
||
api: apiEndpoint,
|
||
port: port,
|
||
cacheDir: cacheDir,
|
||
pathIndexCount: Object.keys(pathIndex).length,
|
||
viewsInfo: {
|
||
request: viewsInfo.request,
|
||
cacheHit: viewsInfo.cacheHit,
|
||
apiCall: viewsInfo.apiCall,
|
||
cacheCall: viewsInfo.cacheCall,
|
||
cacheReadError: viewsInfo.cacheReadError,
|
||
fetchApiError: viewsInfo.fetchApiError,
|
||
fetchApiWarning: viewsInfo.fetchApiWarning,
|
||
}
|
||
}
|
||
}));
|
||
}
|
||
|
||
async function handleApiRedirect(res, apiData) {
|
||
res.writeHead(HTTP_STATUS.REDIRECT, { Location: apiData.data.url });
|
||
res.end();
|
||
}
|
||
|
||
async function processSuccessfulApiData(apiData, uniqidhex, reqPath, token, sign, res, req) {
|
||
const { url: realUrl, cloudtype, expiration, path: apiPath, headers, uniqid, thumb } = apiData.data;
|
||
const data = { realUrl, cloudtype, expiration: expiration * 1000, path: apiPath, headers, uniqid, thumb };
|
||
|
||
pathIndex[uniqidhex] = { uniqid: data.uniqid, timestamp: Date.now() };
|
||
const cacheMetaFile = pathModule.join(cacheDir, `${uniqidhex}.meta`);
|
||
const cacheContentFile = pathModule.join(cacheDir, `${data.uniqid}.content`);
|
||
const tempCacheContentFile = pathModule.join(cacheDir, `${data.uniqid}_${crypto.randomBytes(16).toString('hex')}.temp`);
|
||
|
||
try {
|
||
fs.writeFileSync(cacheMetaFile, JSON.stringify(data));
|
||
} catch (writeError) {
|
||
console.error(`Error writing meta file ${cacheMetaFile}:`, writeError);
|
||
sendErrorResponse(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, 'Failed to write cache metadata.');
|
||
return;
|
||
}
|
||
|
||
if (fs.existsSync(cacheContentFile)) {
|
||
const stats = fs.statSync(cacheContentFile);
|
||
const contentLength = stats.size;
|
||
if (contentLength < 2048 && data.headers['content-length'] && parseInt(data.headers['content-length'], 10) !== contentLength) {
|
||
console.warn(`Content length mismatch for ${cacheContentFile}. API: ${data.headers['content-length']}, Cache: ${contentLength}. Re-fetching.`);
|
||
fetchAndServe(data, tempCacheContentFile, cacheContentFile, cacheMetaFile, res, req);
|
||
} else {
|
||
serveFromCache(data, cacheContentFile, cacheMetaFile, res, req);
|
||
}
|
||
} else {
|
||
fetchAndServe(data, tempCacheContentFile, cacheContentFile, cacheMetaFile, res, req);
|
||
}
|
||
}
|
||
|
||
async function tryServeFromStaleCacheOrError(uniqidhex, res, req, errorMessage) {
|
||
if (pathIndex[uniqidhex]) {
|
||
const cacheMetaFile = pathModule.join(cacheDir, `${uniqidhex}.meta`);
|
||
const cacheContentFile = pathModule.join(cacheDir, `${pathIndex[uniqidhex].uniqid}.content`);
|
||
if (fs.existsSync(cacheMetaFile) && fs.existsSync(cacheContentFile)) {
|
||
console.warn(`API call failed or returned non-200. Serving stale cache for ${uniqidhex}`);
|
||
try {
|
||
const cacheData = JSON.parse(fs.readFileSync(cacheMetaFile, 'utf8'));
|
||
serveFromCache(cacheData, cacheContentFile, cacheMetaFile, res, req);
|
||
return;
|
||
} catch (parseError) {
|
||
console.error(`Error parsing stale meta file ${cacheMetaFile}:`, parseError);
|
||
// Fall through to generic error if stale cache is also broken
|
||
}
|
||
}
|
||
}
|
||
sendErrorResponse(res, HTTP_STATUS.BAD_GATEWAY, errorMessage || 'Bad Gateway');
|
||
}
|
||
|
||
async function handleMainRequest(req, res) {
|
||
req.url = req.url.replace(/\/{2,}/g, '/');
|
||
const parsedUrl = url.parse(req.url, true);
|
||
const sign = parsedUrl.query.sign || '';
|
||
let reqPath = parsedUrl.pathname.split('/')[1] || ''; // Ensure reqPath is not undefined
|
||
let token = parsedUrl.pathname.split('/').slice(2).join('/');
|
||
|
||
if (reqPath === 'favicon.ico') return handleFavicon(req, res);
|
||
if (reqPath === 'endpoint') return handleEndpoint(req, res, parsedUrl);
|
||
|
||
if (!token && reqPath) { // If token is empty but reqPath is not, assume reqPath is the token
|
||
token = reqPath;
|
||
reqPath = 'app'; // Default to 'app' if only one path segment is provided
|
||
}
|
||
|
||
const ALLOWED_PATHS = ['avatar', 'go', 'bbs', 'www', 'url', 'thumb', 'app'];
|
||
if (!ALLOWED_PATHS.includes(reqPath) || !token) {
|
||
return sendErrorResponse(res, HTTP_STATUS.BAD_REQUEST, `Bad Request: Invalid path or missing token.`);
|
||
}
|
||
|
||
viewsInfo.increment('request');
|
||
const uniqidhex = crypto.createHash('md5').update(reqPath + token + sign).digest('hex');
|
||
let cacheMetaFile = '';
|
||
let cacheContentFile = '';
|
||
|
||
if (pathIndex[uniqidhex]) {
|
||
cacheMetaFile = pathModule.join(cacheDir, `${uniqidhex}.meta`);
|
||
cacheContentFile = pathModule.join(cacheDir, `${pathIndex[uniqidhex].uniqid}.content`);
|
||
}
|
||
|
||
if (pathIndex[uniqidhex] && isCacheValid(cacheMetaFile, cacheContentFile)) {
|
||
const { cacheData, isNotModified } = await checkCacheHeaders(req, cacheMetaFile);
|
||
if (isNotModified) {
|
||
res.writeHead(HTTP_STATUS.NOT_MODIFIED);
|
||
res.end();
|
||
} else {
|
||
viewsInfo.increment('cacheHit');
|
||
serveFromCache(cacheData, cacheContentFile, cacheMetaFile, res, req);
|
||
}
|
||
} else {
|
||
try {
|
||
viewsInfo.increment('apiCall');
|
||
const apiData = await fetchApiData(reqPath, token, sign);
|
||
|
||
if (apiData.code === HTTP_STATUS.REDIRECT || apiData.code === 301) {
|
||
return handleApiRedirect(res, apiData);
|
||
}
|
||
|
||
if (apiData.code === HTTP_STATUS.OK && apiData.data && apiData.data.url) {
|
||
await processSuccessfulApiData(apiData, uniqidhex, reqPath, token, sign, res, req);
|
||
} else {
|
||
viewsInfo.increment('fetchApiWarning');
|
||
await tryServeFromStaleCacheOrError(uniqidhex, res, req, apiData.message);
|
||
}
|
||
} catch (error) {
|
||
viewsInfo.increment('fetchApiError');
|
||
console.error('Error in API call or processing:', error);
|
||
await tryServeFromStaleCacheOrError(uniqidhex, res, req, `Bad Gateway: API request failed. ${error.message}`);
|
||
}
|
||
}
|
||
}
|
||
|
||
const server = http.createServer(handleMainRequest);
|
||
|
||
// 检查缓存头并返回是否为304
|
||
async function checkCacheHeaders(req, cacheMetaFile) {
|
||
try {
|
||
const metaContent = fs.readFileSync(cacheMetaFile, 'utf8');
|
||
const cacheData = JSON.parse(metaContent);
|
||
const ifNoneMatch = req.headers['if-none-match'];
|
||
const ifModifiedSince = req.headers['if-modified-since'];
|
||
|
||
// 优先检查ETag (更精确的缓存验证方式)
|
||
if (ifNoneMatch && cacheData.uniqid) {
|
||
// 支持弱验证器格式 "W/"etag-value""
|
||
const cleanEtag = ifNoneMatch.replace(/^W\//, '').replace(/"/g, '');
|
||
const cleanCacheEtag = cacheData.uniqid.replace(/^W\//, '').replace(/"/g, '');
|
||
|
||
if (cleanEtag === cleanCacheEtag || ifNoneMatch === cacheData.uniqid) {
|
||
console.log(`304 Not Modified: ETag match for ${cacheMetaFile}`);
|
||
return { cacheData, isNotModified: true };
|
||
}
|
||
}
|
||
|
||
// 检查If-Modified-Since (基于时间的缓存验证)
|
||
if (ifModifiedSince && cacheData.headers && cacheData.headers['last-modified']) {
|
||
try {
|
||
const lastModifiedDate = new Date(cacheData.headers['last-modified']);
|
||
const ifModifiedSinceDate = new Date(ifModifiedSince);
|
||
|
||
// HTTP日期的时间精度是1秒
|
||
// 如果If-Modified-Since至少与Last-Modified一样新，则返回304
|
||
if (lastModifiedDate.getTime() <= ifModifiedSinceDate.getTime()) {
|
||
console.log(`304 Not Modified: Last-Modified check for ${cacheMetaFile}`);
|
||
return { cacheData, isNotModified: true };
|
||
}
|
||
} catch (dateParseError) {
|
||
console.warn(`Error parsing date for cache header check (${cacheMetaFile}):`, dateParseError);
|
||
// 如果日期无效，则继续处理，视为未修改检查失败
|
||
}
|
||
}
|
||
|
||
// 如果没有缓存验证头或验证失败，返回正常内容
|
||
return { cacheData, isNotModified: false };
|
||
} catch (error) {
|
||
console.error(`Error reading or parsing cache meta file ${cacheMetaFile} in checkCacheHeaders:`, error);
|
||
// 如果无法读取元数据，假设缓存无效
|
||
return { cacheData: null, isNotModified: false };
|
||
}
|
||
}
|
||
|
||
|
||
// 检查缓存是否有效
|
||
function isCacheValid(cacheMetaFile, cacheContentFile) {
|
||
if (!fs.existsSync(cacheMetaFile) || !fs.existsSync(cacheContentFile)) {
|
||
return false;
|
||
}
|
||
try {
|
||
const metaContent = fs.readFileSync(cacheMetaFile, 'utf8');
|
||
const cacheData = JSON.parse(metaContent);
|
||
|
||
// 确保expiration是一个数字并且在未来
|
||
// 如果expiration未定义或为0，则设置为24小时后过期
|
||
if (!cacheData.expiration || cacheData.expiration === 0) {
|
||
cacheData.expiration = Date.now() + CACHE_EXPIRY_MS;
|
||
// 更新缓存元数据文件
|
||
fs.writeFileSync(cacheMetaFile, JSON.stringify(cacheData));
|
||
console.log(`Updated missing expiration in ${cacheMetaFile} to ${cacheData.expiration}`);
|
||
return true;
|
||
}
|
||
|
||
return typeof cacheData.expiration === 'number' && cacheData.expiration > Date.now();
|
||
} catch (error) {
|
||
console.warn(`Error reading or parsing cache meta file ${cacheMetaFile} for validation:`, error);
|
||
return false; // 如果元数据文件损坏或不可读，则缓存无效
|
||
}
|
||
}
|
||
|
||
|
||
// 从 API 获取数据
|
||
const API_TIMEOUT_MS = 5000;
|
||
const USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/89.0.4389.114 Safari/537.36';
|
||
|
||
// 用于跟踪API状态的变量
|
||
let isDefaultApiHealthy = true;
|
||
let lastApiSwitchTime = 0;
|
||
const API_SWITCH_COOLDOWN_MS = 60000; // 切换API后的冷却时间，防止频繁切换
|
||
|
||
// 尝试使用指定的API端点获取数据
|
||
async function tryFetchWithEndpoint(endpoint, reqPath, token, sign) {
|
||
const queryParams = querystring.stringify({
|
||
type: reqPath,
|
||
sign: sign
|
||
});
|
||
const apiUrl = `${endpoint}?${queryParams}`;
|
||
const parsedApiUrl = new URL(apiUrl);
|
||
const protocol = parsedApiUrl.protocol === 'https:' ? https : http;
|
||
|
||
const options = {
|
||
method: 'GET',
|
||
headers: {
|
||
'Accept': 'application/json; charset=utf-8',
|
||
'User-Agent': USER_AGENT,
|
||
'token': token
|
||
},
|
||
timeout: API_TIMEOUT_MS,
|
||
rejectUnauthorized: false, // Allow self-signed certificates, use with caution
|
||
};
|
||
|
||
return new Promise((resolve, reject) => {
|
||
const apiReq = protocol.request(apiUrl, options, (apiRes) => {
|
||
let responseData = '';
|
||
apiRes.setEncoding('utf8');
|
||
apiRes.on('data', chunk => responseData += chunk);
|
||
apiRes.on('end', () => {
|
||
try {
|
||
if (apiRes.statusCode >= 400) {
|
||
// Treat HTTP errors from API as rejections for easier handling
|
||
console.error(`API request to ${apiUrl} failed with status ${apiRes.statusCode}: ${responseData}`);
|
||
// Attempt to parse for a message, but prioritize status code for error type
|
||
let errorPayload = { code: apiRes.statusCode, message: `API Error: ${apiRes.statusCode}` };
|
||
try {
|
||
const parsedError = JSON.parse(responseData);
|
||
if (parsedError && parsedError.message) errorPayload.message = parsedError.message;
|
||
} catch (e) { /* Ignore if response is not JSON */ }
|
||
resolve({ success: false, data: errorPayload });
|
||
return;
|
||
}
|
||
resolve({ success: true, data: JSON.parse(responseData) });
|
||
} catch (parseError) {
|
||
console.error(`Error parsing JSON response from ${apiUrl}:`, parseError, responseData);
|
||
reject(new Error(`Failed to parse API response: ${parseError.message}`));
|
||
}
|
||
});
|
||
});
|
||
|
||
apiReq.on('timeout', () => {
|
||
apiReq.destroy(); // Destroy the request to free up resources
|
||
console.error(`API request to ${apiUrl} timed out after ${API_TIMEOUT_MS}ms`);
|
||
reject(new Error('API request timed out'));
|
||
});
|
||
|
||
apiReq.on('error', (networkError) => {
|
||
console.error(`API request to ${apiUrl} failed:`, networkError);
|
||
reject(networkError);
|
||
});
|
||
|
||
apiReq.end();
|
||
});
|
||
}
|
||
|
||
// 主API获取函数，支持故障转移
|
||
async function fetchApiData(reqPath, token, sign) {
|
||
// 确定当前使用的API端点
|
||
const currentEndpoint = isDefaultApiHealthy ? DEFAULT_API_ENDPOINT : BACKUP_API_ENDPOINT;
|
||
const backupEndpoint = isDefaultApiHealthy ? BACKUP_API_ENDPOINT : DEFAULT_API_ENDPOINT;
|
||
|
||
try {
|
||
// 尝试使用当前API端点
|
||
const result = await tryFetchWithEndpoint(currentEndpoint, reqPath, token, sign);
|
||
|
||
// 如果当前使用的是备用API且成功了，考虑是否切回主API
|
||
if (!isDefaultApiHealthy && result.success) {
|
||
const now = Date.now();
|
||
if (now - lastApiSwitchTime > API_SWITCH_COOLDOWN_MS) {
|
||
// 尝试恢复使用默认API
|
||
console.log(`尝试恢复使用默认API: ${DEFAULT_API_ENDPOINT}`);
|
||
isDefaultApiHealthy = true;
|
||
lastApiSwitchTime = now;
|
||
}
|
||
}
|
||
|
||
return result.data;
|
||
} catch (error) {
|
||
console.error(`API请求失败，尝试使用备用API: ${backupEndpoint}`, error);
|
||
|
||
// 如果当前API失败，切换到备用API
|
||
if (isDefaultApiHealthy) {
|
||
console.log(`主API ${DEFAULT_API_ENDPOINT} 不可用，切换到备用API ${BACKUP_API_ENDPOINT}`);
|
||
isDefaultApiHealthy = false;
|
||
lastApiSwitchTime = Date.now();
|
||
} else {
|
||
console.log(`备用API ${BACKUP_API_ENDPOINT} 不可用，切换回主API ${DEFAULT_API_ENDPOINT}`);
|
||
isDefaultApiHealthy = true;
|
||
lastApiSwitchTime = Date.now();
|
||
}
|
||
|
||
try {
|
||
// 尝试使用备用API端点
|
||
const backupResult = await tryFetchWithEndpoint(backupEndpoint, reqPath, token, sign);
|
||
return backupResult.data;
|
||
} catch (backupError) {
|
||
console.error(`备用API也失败了，无法获取数据`, backupError);
|
||
throw backupError; // 如果备用API也失败，则抛出错误
|
||
}
|
||
}
|
||
}
|
||
|
||
// 从真实 URL 获取数据并写入缓存
|
||
const REAL_URL_FETCH_TIMEOUT_MS = 30000; // 30秒超时
|
||
const HIGH_WATER_MARK = 64 * 1024; // 64KB 缓冲区
|
||
|
||
// 媒体文件扩展名列表
|
||
const VIDEO_EXTENSIONS = ['.mp4', '.mkv', '.webm', '.avi', '.mov', '.flv'];
|
||
const AUDIO_EXTENSIONS = ['.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a'];
|
||
|
||
// 检查文件类型的辅助函数
|
||
const isMediaFile = (path, extensions) => {
|
||
if (!path || typeof path !== 'string') return false;
|
||
return extensions.some(ext => path.includes(ext));
|
||
};
|
||
|
||
// 从缓存提供范围请求的辅助函数
|
||
const serveRangeFromCache = (rangeHeader, cacheContentFile, cacheMetaFile, res, isVideo, isAudio) => {
|
||
try {
|
||
const stats = fs.statSync(cacheContentFile);
|
||
const fileSize = stats.size;
|
||
|
||
// 解析Range头
|
||
const ranges = rangeHeader.replace(/bytes=/, '').split(',');
|
||
const rangeSpec = ranges[0].trim();
|
||
const parts = rangeSpec.split('-');
|
||
let start = parseInt(parts[0], 10);
|
||
let end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
|
||
|
||
// 处理特殊范围格式，如 bytes=-500 (最后500字节)
|
||
if (isNaN(start)) {
|
||
start = Math.max(0, fileSize - parseInt(parts[1], 10));
|
||
end = fileSize - 1;
|
||
}
|
||
|
||
// 确保范围有效
|
||
end = Math.min(end, fileSize - 1);
|
||
start = Math.min(start, end);
|
||
|
||
if (start < fileSize && fileSize > 0) {
|
||
console.log(`Serving range request from cache: bytes ${start}-${end}/${fileSize}`);
|
||
|
||
const chunkSize = (end - start) + 1;
|
||
const metaData = JSON.parse(fs.readFileSync(cacheMetaFile, 'utf8'));
|
||
|
||
const readStream = fs.createReadStream(cacheContentFile, {
|
||
start, end, highWaterMark: HIGH_WATER_MARK
|
||
});
|
||
|
||
const contentType = (metaData.headers && metaData.headers['content-type']) ||
|
||
(isVideo ? 'video/mp4' : (isAudio ? 'audio/mpeg' : 'application/octet-stream'));
|
||
|
||
res.writeHead(206, {
|
||
'Content-Range': `bytes ${start}-${end}/${fileSize}`,
|
||
'Content-Length': chunkSize.toString(),
|
||
'Content-Type': contentType,
|
||
'Accept-Ranges': 'bytes',
|
||
'ETag': metaData.uniqid || '',
|
||
'Cache-Control': 'public, max-age=3600',
|
||
'Cloud-Type': metaData.cloudtype || 'unknown',
|
||
'Cloud-Expiration': new Date(metaData.expiration || (Date.now() + 3600000)).toLocaleString()
|
||
});
|
||
|
||
readStream.pipe(res);
|
||
|
||
readStream.on('error', (err) => {
|
||
console.error(`Read stream error: ${err.message}`);
|
||
if (!res.headersSent) {
|
||
sendErrorResponse(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, 'Error reading from cache');
|
||
} else {
|
||
try { res.end(); } catch (e) { /* ignore */ }
|
||
}
|
||
});
|
||
|
||
return true; // 成功从缓存提供服务
|
||
}
|
||
} catch (error) {
|
||
console.error(`Error serving range request from cache: ${error.message}`);
|
||
}
|
||
return false; // 从缓存提供服务失败
|
||
};
|
||
|
||
const fetchAndServe = (data, tempCacheContentFile, cacheContentFile, cacheMetaFile, res, req) => {
|
||
const protocol = data.realUrl.startsWith('https:') ? https : http;
|
||
const cacheFileExists = fs.existsSync(cacheContentFile);
|
||
|
||
// 如果缓存文件已存在，直接使用它
|
||
if (cacheFileExists) {
|
||
tempCacheContentFile = cacheContentFile;
|
||
console.log(`Using existing cache file: ${cacheContentFile}`);
|
||
}
|
||
|
||
// 检查媒体文件类型
|
||
const isVideo = isMediaFile(data.path, VIDEO_EXTENSIONS);
|
||
const isAudio = isMediaFile(data.path, AUDIO_EXTENSIONS);
|
||
const rangeHeader = req && req.headers && req.headers.range;
|
||
|
||
// 构建请求选项
|
||
const requestOptions = {
|
||
timeout: REAL_URL_FETCH_TIMEOUT_MS,
|
||
rejectUnauthorized: false,
|
||
headers: {
|
||
'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.114 Safari/537.36',
|
||
'Accept': '*/*',
|
||
'Accept-Encoding': 'gzip, deflate, br',
|
||
'Connection': 'keep-alive'
|
||
}
|
||
};
|
||
|
||
// 处理范围请求
|
||
if (rangeHeader) {
|
||
console.log(`Forwarding range request: ${rangeHeader} to ${data.realUrl}`);
|
||
requestOptions.headers['Range'] = rangeHeader;
|
||
|
||
// 尝试从缓存提供范围请求
|
||
if (cacheFileExists && fs.existsSync(cacheMetaFile)) {
|
||
if (serveRangeFromCache(rangeHeader, cacheContentFile, cacheMetaFile, res, isVideo, isAudio)) {
|
||
return; // 成功从缓存提供服务，不需要继续
|
||
}
|
||
}
|
||
}
|
||
|
||
// 转发条件请求头
|
||
if (req && req.headers) {
|
||
['if-range', 'if-match', 'if-none-match'].forEach(header => {
|
||
if (req.headers[header]) {
|
||
requestOptions.headers[header.charAt(0).toUpperCase() + header.slice(1)] = req.headers[header];
|
||
console.log(`Forwarding ${header} header: ${req.headers[header]}`);
|
||
}
|
||
});
|
||
}
|
||
|
||
protocol.get(data.realUrl, requestOptions, (realRes) => {
|
||
// 处理304 Not Modified响应
|
||
if (realRes.statusCode === 304) {
|
||
console.log(`Received 304 Not Modified from source for ${data.realUrl}`);
|
||
res.writeHead(304, {
|
||
'ETag': data.uniqid || '',
|
||
'Cache-Control': 'public, max-age=3600',
|
||
'Date': new Date().toUTCString()
|
||
});
|
||
res.end();
|
||
return;
|
||
}
|
||
|
||
// 使用更高效的缓冲区设置，对于已存在的文件使用追加模式
|
||
const cacheStream = fs.createWriteStream(tempCacheContentFile, {
|
||
flags: tempCacheContentFile === cacheContentFile && fs.existsSync(tempCacheContentFile) ? 'a' : 'w',
|
||
highWaterMark: HIGH_WATER_MARK
|
||
});
|
||
|
||
// 处理响应头和缓存元数据
|
||
const handleResponseHeaders = () => {
|
||
const contentLength = realRes.headers['content-length'];
|
||
|
||
// 验证内容长度
|
||
if (contentLength) {
|
||
// 检查内容长度是否异常
|
||
if (contentLength < 2048 && data.headers['content-length'] !== contentLength && !rangeHeader) {
|
||
console.warn('Warning: content-length mismatch from:', data.realUrl);
|
||
sendErrorResponse(res, HTTP_STATUS.BAD_GATEWAY, `Bad Gateway: Content-Length mismatch`);
|
||
|
||
// 清理临时文件
|
||
if (fs.existsSync(tempCacheContentFile)) {
|
||
fs.unlinkSync(tempCacheContentFile);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 只在非范围请求时更新content-length
|
||
if (!rangeHeader) {
|
||
data.headers['content-length'] = contentLength;
|
||
updateCacheMetadata();
|
||
}
|
||
} else {
|
||
console.warn('Warning: content-length undefined from:', data.realUrl);
|
||
}
|
||
|
||
// 确保过期时间有效
|
||
if (!data.expiration || data.expiration === 0) {
|
||
data.expiration = Date.now() + CACHE_EXPIRY_MS;
|
||
updateCacheMetadata();
|
||
}
|
||
|
||
return true;
|
||
};
|
||
|
||
// 更新缓存元数据
|
||
const updateCacheMetadata = () => {
|
||
fs.writeFile(cacheMetaFile, JSON.stringify(data), (err) => {
|
||
if (err) console.error(`Error updating cache metadata: ${err.message}`);
|
||
});
|
||
};
|
||
|
||
// 如果头部处理失败，直接返回
|
||
if (!handleResponseHeaders()) return;
|
||
|
||
// 格式化过期时间为可读格式
|
||
const expirationDate = new Date(data.expiration).toLocaleString();
|
||
|
||
// 设置响应头 - 更精简的方式
|
||
const responseHeaders = {
|
||
'Cloud-Type': data.cloudtype,
|
||
'Cloud-Expiration': expirationDate,
|
||
'ETag': data.uniqid || '',
|
||
'Cache-Control': 'public, max-age=3600, stale-while-revalidate=86400',
|
||
'Expires': new Date(Date.now() + 3600000).toUTCString(),
|
||
'Accept-Ranges': 'bytes',
|
||
'Connection': 'keep-alive',
|
||
'Date': new Date().toUTCString(),
|
||
'Last-Modified': data.headers['last-modified'] || new Date().toUTCString(),
|
||
'Vary': 'Accept-Encoding',
|
||
'Content-Type': realRes.headers['content-type'] || (isVideo ? 'video/mp4' : 'application/octet-stream'),
|
||
...data.headers
|
||
};
|
||
|
||
// 处理范围响应
|
||
if (realRes.headers['content-range']) {
|
||
responseHeaders['Content-Range'] = realRes.headers['content-range'];
|
||
console.log(`Received partial content: ${realRes.headers['content-range']} for ${data.realUrl}`);
|
||
|
||
// 从Content-Range中提取文件总大小
|
||
const contentRangeMatch = /\/([0-9]+)$/.exec(realRes.headers['content-range']);
|
||
if (contentRangeMatch && contentRangeMatch[1]) {
|
||
const totalSize = parseInt(contentRangeMatch[1], 10);
|
||
if (totalSize > 0 && (!data.headers['content-length'] || parseInt(data.headers['content-length'], 10) !== totalSize)) {
|
||
data.headers['content-length'] = totalSize.toString();
|
||
console.log(`Updated content-length: ${totalSize}`);
|
||
fs.writeFile(cacheMetaFile, JSON.stringify(data), err => {
|
||
if (err) console.error(`Error updating meta: ${err.message}`);
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
// 使用源服务器返回的状态码
|
||
res.writeHead(realRes.statusCode, responseHeaders);
|
||
|
||
// 使用流事件处理来优化性能
|
||
let bytesReceived = 0;
|
||
const startTime = Date.now();
|
||
|
||
// 检测是否需要处理压缩内容
|
||
const contentEncoding = realRes.headers['content-encoding'];
|
||
if (contentEncoding && (contentEncoding.includes('gzip') || contentEncoding.includes('deflate') || contentEncoding.includes('br'))) {
|
||
// 对于压缩内容，我们直接传递，不做解压处理
|
||
console.log(`Streaming compressed content (${contentEncoding}) for ${data.realUrl}`);
|
||
}
|
||
|
||
// 使用更高效的流处理方式，确保边下边播
|
||
// 创建一个Transform流，同时写入缓存和响应
|
||
const { Transform } = require('stream');
|
||
const streamRelay = new Transform({
|
||
transform(chunk, encoding, callback) {
|
||
// 将数据传递给下一个流
|
||
this.push(chunk);
|
||
|
||
// 更新接收的字节数
|
||
bytesReceived += chunk.length;
|
||
|
||
// 每10MB记录一次进度
|
||
if (bytesReceived % (10 * 1024 * 1024) === 0) {
|
||
const elapsedSeconds = (Date.now() - startTime) / 1000;
|
||
const mbReceived = bytesReceived / (1024 * 1024);
|
||
const mbps = mbReceived / elapsedSeconds;
|
||
console.log(`Progress for ${data.realUrl}: ${mbReceived.toFixed(2)}MB received at ${mbps.toFixed(2)}MB/s`);
|
||
}
|
||
|
||
callback();
|
||
}
|
||
});
|
||
|
||
// 设置错误处理
|
||
streamRelay.on('error', (err) => {
|
||
console.error(`Stream relay error for ${data.realUrl}:`, err);
|
||
try {
|
||
cacheStream.end();
|
||
if (!res.writableEnded) res.end();
|
||
} catch (e) { /* ignore */ }
|
||
});
|
||
|
||
// 优化流处理，确保数据立即流向客户端，实现真正的边下边播
|
||
// 直接将源响应通过中继流同时发送到客户端和缓存
|
||
realRes.pipe(streamRelay);
|
||
|
||
// 优先将数据发送给客户端，确保低延迟
|
||
streamRelay.pipe(res, { end: true });
|
||
|
||
// 同时将数据写入缓存
|
||
streamRelay.pipe(cacheStream, { end: false }); // 不自动结束缓存流，我们需要在完成后手动处理
|
||
|
||
// 处理客户端提前关闭连接
|
||
res.on('close', () => {
|
||
if (!res.writableEnded) {
|
||
console.log(`Client closed connection prematurely for ${data.realUrl}`);
|
||
// 断开客户端连接，但继续下载到缓存
|
||
streamRelay.unpipe(res);
|
||
// 不中断缓存写入，继续下载完整文件
|
||
}
|
||
});
|
||
|
||
// 处理完成事件
|
||
realRes.on('end', () => {
|
||
const totalTime = (Date.now() - startTime) / 1000;
|
||
const totalMB = bytesReceived / (1024 * 1024);
|
||
console.log(`Completed ${data.realUrl}: ${totalMB.toFixed(2)}MB in ${totalTime.toFixed(2)}s (${(totalMB/totalTime).toFixed(2)}MB/s)`);
|
||
|
||
// 确保缓存流正确结束
|
||
cacheStream.end(() => {
|
||
if (fs.existsSync(tempCacheContentFile)) {
|
||
// 如果临时文件就是缓存文件，不需要重命名
|
||
if (tempCacheContentFile === cacheContentFile) {
|
||
console.log(`Successfully cached: ${cacheContentFile}`);
|
||
|
||
// 更新缓存元数据，添加文件大小信息
|
||
if (bytesReceived > 0) {
|
||
data.headers['content-length'] = bytesReceived.toString();
|
||
fs.writeFile(cacheMetaFile, JSON.stringify(data), (err) => {
|
||
if (err) console.error(`Error updating content-length in cache meta file ${cacheMetaFile}:`, err);
|
||
});
|
||
}
|
||
} else {
|
||
// 确保目标目录存在
|
||
const targetDir = pathModule.dirname(cacheContentFile);
|
||
fs.mkdir(targetDir, { recursive: true }, (mkdirErr) => {
|
||
if (mkdirErr) {
|
||
console.error(`Error creating directory ${targetDir}:`, mkdirErr);
|
||
try { fs.unlinkSync(tempCacheContentFile); } catch (e) { /* ignore */ }
|
||
return;
|
||
}
|
||
|
||
// 异步重命名文件
|
||
fs.rename(tempCacheContentFile, cacheContentFile, (renameErr) => {
|
||
if (renameErr) {
|
||
console.error(`Error renaming temp cache file ${tempCacheContentFile} to ${cacheContentFile}:`, renameErr);
|
||
try { fs.unlinkSync(tempCacheContentFile); } catch (e) { /* ignore */ }
|
||
} else {
|
||
console.log(`Successfully cached: ${cacheContentFile}`);
|
||
|
||
// 更新缓存元数据，添加文件大小信息
|
||
if (bytesReceived > 0) {
|
||
data.headers['content-length'] = bytesReceived.toString();
|
||
fs.writeFile(cacheMetaFile, JSON.stringify(data), (err) => {
|
||
if (err) console.error(`Error updating content-length in cache meta file ${cacheMetaFile}:`, err);
|
||
});
|
||
}
|
||
}
|
||
});
|
||
});
|
||
}
|
||
} else {
|
||
console.warn(`Temp cache file ${tempCacheContentFile} not found after stream end for ${data.realUrl}`);
|
||
}
|
||
});
|
||
});
|
||
|
||
// 改进错误处理
|
||
realRes.on('error', (streamError) => {
|
||
console.error(`Error during response stream from ${data.realUrl}:`, streamError);
|
||
cacheStream.end(); // Close the writable stream
|
||
|
||
// 如果响应已经开始发送，我们不能再发送错误响应
|
||
if (!res.headersSent) {
|
||
handleResponseError(res, tempCacheContentFile, data.realUrl);
|
||
} else {
|
||
// 如果头部已发送，尝试结束响应
|
||
try { res.end(); } catch (e) { /* ignore */ }
|
||
// 清理临时文件
|
||
try { fs.unlinkSync(tempCacheContentFile); } catch (e) { /* ignore */ }
|
||
}
|
||
});
|
||
|
||
}).on('error', (requestError) => {
|
||
console.error(`Error making GET request to ${data.realUrl}:`, requestError);
|
||
// No cacheStream involved here if the request itself fails before response
|
||
handleResponseError(res, tempCacheContentFile, data.realUrl); // tempCacheContentFile might not exist or be empty
|
||
});
|
||
};
|
||
|
||
// 从缓存中读取数据并返回
|
||
function serveFromCache(cacheData, cacheContentFile, cacheMetaFile, res, req) {
|
||
if (!cacheData) { // Added check for null cacheData from checkCacheHeaders failure
|
||
console.error(`serveFromCache called with null cacheData for ${cacheContentFile}`);
|
||
sendErrorResponse(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, 'Cache metadata unavailable.');
|
||
return;
|
||
}
|
||
|
||
// 获取文件大小
|
||
let fileSize = 0;
|
||
try {
|
||
const stats = fs.statSync(cacheContentFile);
|
||
fileSize = stats.size;
|
||
|
||
// 更新缓存元数据中的content-length
|
||
if (fileSize > 0) {
|
||
if (!cacheData.headers) cacheData.headers = {};
|
||
if (!cacheData.headers['content-length'] || parseInt(cacheData.headers['content-length'], 10) !== fileSize) {
|
||
cacheData.headers['content-length'] = fileSize.toString();
|
||
// 异步更新缓存元数据
|
||
fs.writeFile(cacheMetaFile, JSON.stringify(cacheData), (err) => {
|
||
if (err) console.error(`Error updating content-length in ${cacheMetaFile}:`, err);
|
||
else console.log(`Updated content-length in ${cacheMetaFile} to ${fileSize}`);
|
||
});
|
||
}
|
||
}
|
||
} catch (statError) {
|
||
console.error(`Error stating cache content file ${cacheContentFile}:`, statError);
|
||
handleCacheReadError(res, cacheContentFile);
|
||
return;
|
||
}
|
||
|
||
// 设置更强的缓存控制，确保短时间内不会重复请求
|
||
const now = Date.now();
|
||
const nowUTC = new Date(now).toUTCString();
|
||
const expiresUTC = new Date(now + 3600000).toUTCString();
|
||
|
||
// 获取Last-Modified，优先使用API的值
|
||
let lastModified = cacheData.headers && cacheData.headers['last-modified']
|
||
? cacheData.headers['last-modified']
|
||
: new Date(fs.statSync(cacheMetaFile).mtime).toUTCString();
|
||
|
||
// 生成ETag，用于断点下载
|
||
const etag = cacheData.uniqid || crypto.createHash('md5').update(cacheContentFile + fileSize).digest('hex');
|
||
|
||
const baseHeaders = {
|
||
'Cloud-Type': cacheData.cloudtype || 'unknown',
|
||
'Cloud-Expiration': new Date(cacheData.expiration || (now + CACHE_EXPIRY_MS)).toLocaleString(),
|
||
'ETag': etag,
|
||
'Cache-Control': 'public, max-age=3600, stale-while-revalidate=86400',
|
||
'Expires': expiresUTC,
|
||
'Pragma': 'cache',
|
||
'Accept-Ranges': 'bytes', // 关键：支持范围请求和断点下载
|
||
'Connection': 'keep-alive',
|
||
'Date': nowUTC,
|
||
'Last-Modified': lastModified,
|
||
'Vary': 'Accept-Encoding',
|
||
};
|
||
|
||
viewsInfo.increment('cacheCall');
|
||
|
||
// 检测文件类型
|
||
const isVideo = cacheData.path && typeof cacheData.path === 'string' &&
|
||
(cacheData.path.includes('.mp4') || cacheData.path.includes('.mkv') ||
|
||
cacheData.path.includes('.webm') || cacheData.path.includes('.avi') ||
|
||
cacheData.path.includes('.mov') || cacheData.path.includes('.flv'));
|
||
|
||
const isAudio = cacheData.path && typeof cacheData.path === 'string' &&
|
||
(cacheData.path.includes('.mp3') || cacheData.path.includes('.wav') ||
|
||
cacheData.path.includes('.ogg') || cacheData.path.includes('.flac') ||
|
||
cacheData.path.includes('.aac') || cacheData.path.includes('.m4a'));
|
||
|
||
// 检查是否是断点续传请求
|
||
const ifRange = req && req.headers && req.headers['if-range'];
|
||
const ifMatch = req && req.headers && req.headers['if-match'];
|
||
const ifNoneMatch = req && req.headers && req.headers['if-none-match'];
|
||
|
||
// 处理条件请求 - 如果ETag匹配，返回304
|
||
if (ifNoneMatch && ifNoneMatch.includes(etag)) {
|
||
console.log(`304 Not Modified for ${cacheContentFile} - ETag match`);
|
||
res.writeHead(304, baseHeaders);
|
||
res.end();
|
||
return;
|
||
}
|
||
|
||
// 处理范围请求 (Range Requests)
|
||
const rangeHeader = req && req.headers && req.headers.range;
|
||
|
||
// 如果有If-Range头且不匹配当前ETag，则忽略Range头，返回整个文件
|
||
const ignoreRange = ifRange && ifRange !== etag && ifRange !== lastModified;
|
||
|
||
if (rangeHeader && fileSize > 0 && !ignoreRange) {
|
||
console.log(`Range request received: ${rangeHeader} for file ${cacheContentFile}`);
|
||
|
||
// 解析Range头
|
||
const ranges = rangeHeader.replace(/bytes=/, '').split(',');
|
||
|
||
// 如果是多范围请求，我们简化处理，只返回第一个范围
|
||
const rangeSpec = ranges[0].trim();
|
||
const parts = rangeSpec.split('-');
|
||
let start = parseInt(parts[0], 10);
|
||
let end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
|
||
|
||
// 处理特殊范围格式，如 bytes=-500 (最后500字节)
|
||
if (isNaN(start)) {
|
||
start = Math.max(0, fileSize - parseInt(parts[1], 10));
|
||
end = fileSize - 1;
|
||
}
|
||
|
||
// 确保范围不超过文件大小
|
||
end = Math.min(end, fileSize - 1);
|
||
start = Math.min(start, end);
|
||
|
||
// 验证范围有效性
|
||
if (start >= fileSize) {
|
||
// 无效范围，返回416错误
|
||
res.writeHead(416, {
|
||
'Content-Range': `bytes */${fileSize}`,
|
||
...baseHeaders
|
||
});
|
||
res.end();
|
||
return;
|
||
}
|
||
|
||
// 计算范围大小
|
||
const chunkSize = (end - start) + 1;
|
||
|
||
// 创建范围流
|
||
const readStream = fs.createReadStream(cacheContentFile, {
|
||
start,
|
||
end,
|
||
highWaterMark: HIGH_WATER_MARK // 使用更高效的缓冲区设置
|
||
});
|
||
|
||
// 设置206部分内容响应
|
||
const responseHeaders = {
|
||
...baseHeaders,
|
||
'Content-Range': `bytes ${start}-${end}/${fileSize}`,
|
||
'Content-Length': chunkSize.toString(),
|
||
'Content-Type': (cacheData.headers && cacheData.headers['content-type']) ||
|
||
(isVideo ? 'video/mp4' : (isAudio ? 'audio/mpeg' : 'application/octet-stream')),
|
||
};
|
||
|
||
console.log(`Serving partial content: bytes ${start}-${end}/${fileSize} for ${cacheContentFile}`);
|
||
res.writeHead(206, responseHeaders);
|
||
|
||
// 处理流错误
|
||
readStream.on('error', (err) => {
|
||
console.error(`Read stream error for range request ${cacheContentFile}:`, err);
|
||
if (!res.headersSent) {
|
||
handleCacheReadError(res, cacheContentFile);
|
||
} else {
|
||
try { res.end(); } catch (e) { /* ignore */ }
|
||
}
|
||
});
|
||
|
||
// 监控数据传输速度
|
||
let bytesSent = 0;
|
||
const startTime = Date.now();
|
||
|
||
readStream.on('data', (chunk) => {
|
||
bytesSent += chunk.length;
|
||
// 每10MB记录一次进度
|
||
if (bytesSent % (10 * 1024 * 1024) === 0) {
|
||
const elapsedSeconds = (Date.now() - startTime) / 1000;
|
||
const mbSent = bytesSent / (1024 * 1024);
|
||
const mbps = mbSent / elapsedSeconds;
|
||
console.log(`Range progress for ${cacheContentFile}: ${mbSent.toFixed(2)}MB sent at ${mbps.toFixed(2)}MB/s`);
|
||
}
|
||
});
|
||
|
||
// 将范围流传输到响应
|
||
readStream.pipe(res);
|
||
|
||
// 处理客户端提前关闭连接
|
||
res.on('close', () => {
|
||
if (!res.writableEnded) {
|
||
console.log(`Client closed range request connection prematurely for ${cacheContentFile}`);
|
||
readStream.destroy();
|
||
}
|
||
});
|
||
} else {
|
||
// 非范围请求，返回完整文件
|
||
const readStream = fs.createReadStream(cacheContentFile, {
|
||
highWaterMark: HIGH_WATER_MARK // 使用更高效的缓冲区设置
|
||
});
|
||
|
||
readStream.on('open', () => {
|
||
const responseHeaders = {
|
||
...baseHeaders,
|
||
'Content-Length': fileSize.toString(),
|
||
'Content-Type': (cacheData.headers && cacheData.headers['content-type']) ||
|
||
(isVideo ? 'video/mp4' : (isAudio ? 'audio/mpeg' : 'application/octet-stream')),
|
||
...(cacheData.headers || {}),
|
||
};
|
||
|
||
res.writeHead(HTTP_STATUS.OK, responseHeaders);
|
||
|
||
// 监控数据传输速度
|
||
let bytesSent = 0;
|
||
const startTime = Date.now();
|
||
|
||
readStream.on('data', (chunk) => {
|
||
bytesSent += chunk.length;
|
||
// 每10MB记录一次进度
|
||
if (bytesSent % (10 * 1024 * 1024) === 0) {
|
||
const elapsedSeconds = (Date.now() - startTime) / 1000;
|
||
const mbSent = bytesSent / (1024 * 1024);
|
||
const mbps = mbSent / elapsedSeconds;
|
||
console.log(`Full file progress for ${cacheContentFile}: ${mbSent.toFixed(2)}MB sent at ${mbps.toFixed(2)}MB/s`);
|
||
}
|
||
});
|
||
|
||
readStream.pipe(res);
|
||
});
|
||
|
||
readStream.on('error', (err) => {
|
||
console.error(`Read stream error for ${cacheContentFile}:`, err);
|
||
handleCacheReadError(res, cacheContentFile);
|
||
});
|
||
|
||
// 处理客户端提前关闭连接
|
||
res.on('close', () => {
|
||
if (!res.writableEnded) {
|
||
console.log(`Client closed connection prematurely for ${cacheContentFile}`);
|
||
readStream.destroy();
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
|
||
// 处理响应错误
|
||
const handleResponseError = (res, tempCacheContentFile, realUrl) => {
|
||
viewsInfo.increment('fetchApiError');
|
||
console.error(`Error fetching from real URL: ${realUrl}`);
|
||
sendErrorResponse(res, HTTP_STATUS.BAD_GATEWAY, `Bad Gateway: Failed to fetch from ${realUrl}`);
|
||
if (fs.existsSync(tempCacheContentFile)) {
|
||
try {
|
||
fs.unlinkSync(tempCacheContentFile);
|
||
} catch (unlinkErr) {
|
||
console.error(`Error unlinking temp file ${tempCacheContentFile}:`, unlinkErr);
|
||
}
|
||
}
|
||
};
|
||
|
||
// 处理缓存读取错误
|
||
const handleCacheReadError = (res, filePath) => {
|
||
viewsInfo.increment('cacheReadError');
|
||
console.error(`Error reading cache file: ${filePath}`);
|
||
sendErrorResponse(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, 'Internal Server Error: Unable to read cache content file');
|
||
};
|
||
|
||
// 启动服务器
|
||
server.listen(port, () => {
|
||
console.log(`Proxy server is running on http://localhost:${port}`);
|
||
});
|
||
|
||
// 处理 SIGINT 信号（Ctrl+C）
|
||
process.on('SIGINT', () => {
|
||
console.log('Received SIGINT. Shutting down gracefully...');
|
||
server.close(() => {
|
||
console.log('Server closed.');
|
||
process.exit(0);
|
||
});
|
||
|
||
setTimeout(() => {
|
||
console.error('Forcing shutdown...');
|
||
process.exit(1);
|
||
}, 10000);
|
||
}); |