update:本地代理支持流代理

Author: hjdhnx

Diff for: README.md

@@ -13,13 +13,12 @@ nodejs作为服务端的drpy实现。全面升级异步写法
 
 ## 更新记录
 
-### 20241227
+### 20241228
 
-更新至V1.0.23
+更新至V1.0.24
 
-1. 支持推送
-2. 优化几个盘的源细节问题
-3. 设置中心夸克扫码支持
+1. 本地代理支持多线程流代理
+2. 设置中心功能优化
 
 [点此查看完整更新记录](docs/updateRecord.md)
 

Diff for: controllers/api.js

@@ -1,10 +1,13 @@
 import path from 'path';
 import {existsSync} from 'fs';
 import {base64Decode} from '../libs_drpy/crypto-util.js';
+import '../utils/random-http-ua.js'
 import * as drpy from '../libs/drpyS.js';
 // 创建 Agent 实例以复用 TCP 连接
 import http from 'http';
 import https from 'https';
+import axios from 'axios';
+import {ENV} from "../utils/env.js";
 
 // const AgentOption = { keepAlive: true, maxSockets: 100,timeout: 60000 }; // 最大连接数100,60秒定期清理空闲连接
 const AgentOption = {keepAlive: true};
@@ -34,9 +37,10 @@ export default (fastify, options, done) => {
             const proxyUrl = `${protocol}://${hostname}${request.url}`.split('?')[0].replace('/api/', '/proxy/') + '/?do=js';
             const publicUrl = `${protocol}://${hostname}/public/`;
             const httpUrl = `${protocol}://${hostname}/http`;
+            const mediaProxyUrl = `${protocol}://${hostname}/mediaProxy`;
             // console.log(`proxyUrl:${proxyUrl}`);
             const env = {
-                proxyUrl, publicUrl, httpUrl, getProxyUrl: function () {
+                proxyUrl, publicUrl, httpUrl, mediaProxyUrl, getProxyUrl: function () {
                     return proxyUrl
                 }
             };
@@ -161,7 +165,11 @@ export default (fastify, options, done) => {
                     ...(headers ? headers : {}),
                     ...(rangeHeader ? {Range: rangeHeader} : {}), // 添加 Range 请求头
                 }
-                return proxyStreamMedia(content, new_headers, reply); // 走  流式代理
+                // return proxyStreamMediaMulti(content, new_headers, request, reply); // 走  流式代理
+                // 将查询参数构建为目标 URL
+                const redirectUrl = `/mediaProxy?url=${encodeURIComponent(content)}&headers=${encodeURIComponent(new_headers)}&thread=${ENV.get('thread') || 1}`;
+                // 执行重定向
+                return reply.redirect(redirectUrl);
             }
 
             // 根据媒体类型来决定如何设置字符编码
@@ -250,6 +258,32 @@ export default (fastify, options, done) => {
             reply.status(500).send({error: `Failed to proxy jx ${jxName}: ${error.message}`});
         }
     });
+
+
+    // 用法同 https://github.com/Zhu-zi-a/mediaProxy
+    fastify.all('/mediaProxy', async (request, reply) => {
+        const {thread = 1, form = 'urlcode', url, header, size = '128K', randUa = 0} = request.query;
+
+        // Check if the URL parameter is missing
+        if (!url) {
+            return reply.code(400).send({error: 'Missing required parameter: url'});
+        }
+
+        try {
+            // Decode URL and headers based on the form type
+            const decodedUrl = form === 'base64' ? base64Decode(url) : decodeURIComponent(url);
+            const decodedHeader = header
+                ? JSON.parse(form === 'base64' ? base64Decode(header) : decodeURIComponent(header))
+                : {};
+
+            // Call the proxy function, passing the decoded URL and headers
+            return await proxyStreamMediaMulti(decodedUrl, decodedHeader, request, reply, thread, size, randUa);
+        } catch (error) {
+            fastify.log.error(error);
+            reply.code(500).send({error: error.message});
+        }
+    });
+
     done();
 };
 
@@ -314,3 +348,168 @@ function proxyStreamMedia(videoUrl, headers, reply) {
     // 必须调用 .end() 才能发送请求
     proxyRequest.end();
 }
+
+
+// Helper function for range-based chunk downloading
+async function fetchStream(url, headers, start, end, randUa) {
+    try {
+        const response = await axios.get(url, {
+            headers: {
+                ...headers,
+                ...randUa ? {'User-Agent': randomUa.generateUa(1, {device: ['pc']})} : {},
+                Range: `bytes=${start}-${end}`,
+            },
+            responseType: 'stream',
+        });
+        return {stream: response.data, headers: response.headers};
+    } catch (error) {
+        throw new Error(`Failed to fetch range ${start}-${end}: ${error.message}`);
+    }
+}
+
+async function proxyStreamMediaMulti(mediaUrl, reqHeaders, request, reply, thread, size, randUa = 0) {
+    try {
+        // console.log('mediaUrl:', mediaUrl);
+        // console.log('reqHeaders:', reqHeaders);
+        // console.log('randUa:', randUa);
+        let initialHeaders;
+        let contentLength;
+
+        // First attempt with HEAD request to get the full content length
+        /*
+        try {
+            const response = await axios.head(mediaUrl, {
+                headers: Object.assign({}, reqHeaders, {'User-Agent': randomUa.generateUa()})
+            });
+            initialHeaders = response.headers;
+            contentLength = parseInt(initialHeaders['content-length'], 10);
+
+        } catch (error) {
+            // If HEAD fails, fallback to GET request without Range to get the full content length
+            const response = await axios.get(mediaUrl, {
+                headers: Object.assign({}, reqHeaders, {'User-Agent': randomUa.generateUa()}),
+                responseType: 'stream'
+            });
+            initialHeaders = response.headers;
+            contentLength = parseInt(initialHeaders['content-length'], 10);
+            // 立即销毁流，防止下载文件内容
+            response.data.destroy();
+        }
+        */
+        const randHeaders = randUa ? Object.assign({}, reqHeaders, {'User-Agent': randomUa.generateUa(1, {device: ['pc']})}) : reqHeaders;
+        // console.log('randHeaders:', randHeaders);
+        const response = await axios.get(mediaUrl, {
+            headers: randHeaders,
+            // headers: reqHeaders,
+            responseType: 'stream'
+        });
+        initialHeaders = response.headers;
+        contentLength = parseInt(initialHeaders['content-length'], 10);
+        // 立即销毁流，防止下载文件内容
+        response.data.destroy();
+        // console.log('contentLength:', contentLength);
+
+        // Ensure that we got a valid content length
+        if (!contentLength) {
+            throw new Error('Failed to get the total content length.');
+        }
+
+        // Set response headers based on the target URL headers, excluding certain ones
+        Object.entries(initialHeaders).forEach(([key, value]) => {
+            if (!['transfer-encoding', 'content-length'].includes(key.toLowerCase())) {
+                reply.raw.setHeader(key, value);
+            }
+        });
+
+        reply.raw.setHeader('Accept-Ranges', 'bytes');
+
+        // Parse the range from the request or default to 'bytes=0-'
+        const range = request.headers.range || 'bytes=0-';
+        const [startStr, endStr] = range.replace(/bytes=/, '').split('-');
+        let start = parseInt(startStr, 10);
+        let end = endStr ? parseInt(endStr, 10) : contentLength - 1;
+
+        // Ensure that the range is within the file's length
+        if (start < 0) start = 0;
+        if (end >= contentLength) end = contentLength - 1;
+
+        if (start >= end) {
+            reply.code(416).header('Content-Range', `bytes */${contentLength}`).send();
+            return;
+        }
+
+        // Set Content-Range and Content-Length headers before any data is sent
+        reply.raw.setHeader('Content-Range', `bytes ${start}-${end}/${contentLength}`);
+        reply.raw.setHeader('Content-Length', end - start + 1);
+        reply.raw.writeHead(206);  // Ensure headers are sent before streaming
+
+        // Calculate the chunk size based on the provided size parameter (e.g., '128K', '1M')
+        const chunkSize = sizeToBytes(size);
+
+        // Calculate the total number of chunks
+        const totalChunks = Math.ceil((end - start + 1) / chunkSize);
+
+        // Limit the number of concurrent threads to the provided 'thread' value
+        const threadCount = Math.min(thread, totalChunks);
+
+        // Split the range into multiple sub-ranges based on the number of threads
+        const ranges = Array.from({length: threadCount}, (_, i) => {
+            const subStart = start + i * (end - start + 1) / threadCount;
+            const subEnd = Math.min(subStart + (end - start + 1) / threadCount - 1, end);
+            return {start: Math.floor(subStart), end: Math.floor(subEnd)};
+        });
+
+        // Fetch the streams concurrently for the calculated ranges
+        const fetchChunks = ranges.map(range => fetchStream(mediaUrl, randHeaders, range.start, range.end, randUa));
+        const streams = await Promise.all(fetchChunks);
+
+        // Send the chunks to the client in order
+        let cnt = 0;
+        for (const {stream} of streams) {
+            cnt += 1;
+            // Handle streaming and stop when client disconnects
+            const onAbort = () => {
+                console.log('Client aborted the connection');
+                stream.destroy();  // Destroy the stream if client disconnects
+            };
+
+            // Listen to the 'aborted' event on the request object
+            request.raw.on('aborted', onAbort);
+
+            try {
+                // console.log(`第${cnt}段流代理开始运行...`);
+                for await (const chunk of stream) {
+                    if (request.raw.aborted) {
+                        // console.log(`第${cnt}段流代理结束运行`);
+                        break;  // Stop streaming if the client aborted
+                    }
+                    reply.raw.write(chunk);
+                }
+            } catch (error) {
+                console.error('[proxyStreamMediaMulti] error during streaming:', error.message);
+            } finally {
+                request.raw.removeListener('aborted', onAbort);  // Clean up event listener
+            }
+        }
+
+        reply.raw.end();  // End the response once the streaming is done
+
+    } catch (error) {
+        console.error('[proxyStreamMediaMulti] error:', error.message);
+        if (!reply.sent) {
+            reply.code(500).send({error: error.message});
+        }
+    }
+}
+
+// Helper function to convert size string (e.g., '128K', '1M') to bytes
+function sizeToBytes(size) {
+    const sizeMap = {
+        K: 1024,
+        M: 1024 * 1024,
+        G: 1024 * 1024 * 1024
+    };
+    const unit = size[size.length - 1].toUpperCase();
+    const number = parseInt(size, 10);
+    return number * (sizeMap[unit] || 1);
+}

Diff for: controllers/config.js

@@ -16,8 +16,14 @@ async function generateSiteJSON(jsDir, requestHost, sub, subFilePath) {
             valid_files = valid_files.filter(it => !(new RegExp(sub.reg || '.*')).test(it));
         }
         let sort_file = path.join(path.dirname(subFilePath), `./order_common.html`);
+        if (!existsSync(sort_file)) {
+            sort_file = path.join(path.dirname(subFilePath), `./order_common.example.html`);
+        }
         if (sub.sort) {
             sort_file = path.join(path.dirname(subFilePath), `./${sub.sort}.html`);
+            if (!existsSync(sort_file)) {
+                sort_file = path.join(path.dirname(subFilePath), `./${sub.sort}.example.html`);
+            }
         }
         if (existsSync(sort_file)) {
             console.log('sort_file:', sort_file);