Update app.py

app.py

@@ -1,11 +1,14 @@
 import os
-import requests
+import time
 import urllib.parse
+import requests
+import random
+import hashlib
+import json
 from flask import Flask, render_template, request, redirect, url_for, flash, jsonify, Response
 from flask_login import LoginManager, UserMixin, login_user, logout_user, login_required, current_user
 from werkzeug.security import check_password_hash, generate_password_hash
 from dotenv import load_dotenv
-import time
 
 # 加载环境变量
 load_dotenv()
@@ -38,24 +41,155 @@ users = {
     )
 }
 
-# 检查 subconverter 是否启动
-def check_subconverter():
-    max_retries = 10
-    for i in range(max_retries):
+# 代理和缓存系统
+class ProxySystem:
+    def __init__(self):
+        # 可用的API列表
+        self.apis = [
+            "https://api.v1.mk/sub",
+            "https://pub-api-1.bianyuan.xyz/sub"
+        ]
+        
+        # 简单缓存系统
+        self._cache_file = "cache.json"
+        self._cache = {}
+        self._cache_time = {}
+        self._cache_ttl = 3600  # 1小时缓存
+        self._load_cache()
+        
+        # 统计信息
+        self.stats = {
+            "cache_hits": 0,
+            "cache_misses": 0,
+            "api_successes": 0,
+            "api_failures": 0
+        }
+    
+    def _load_cache(self):
+        """从磁盘加载缓存"""
+        try:
+            if os.path.exists(self._cache_file):
+                with open(self._cache_file, 'r') as f:
+                    cache_data = json.load(f)
+                    self._cache = cache_data.get('cache', {})
+                    self._cache_time = cache_data.get('cache_time', {})
+                    print(f"已加载 {len(self._cache)} 条缓存数据")
+        except Exception as e:
+            print(f"加载缓存失败: {e}")
+            self._cache = {}
+            self._cache_time = {}
+    
+    def _save_cache(self):
+        """保存缓存到磁盘"""
         try:
-            response = requests.get('http://localhost:25500/version', timeout=2)
-            if response.status_code == 200:
-                print(f"Subconverter 服务已启动: {response.text}")
-                return True
-        except:
-            pass
-        print(f"等待 Subconverter 服务启动... ({i+1}/{max_retries})")
-        time.sleep(2)
-    print("警告: Subconverter 服务可能未正常启动")
-    return False
-
-# 应用启动时检查 subconverter 服务
-check_subconverter()
+            # 限制缓存大小，最多保存100条
+            if len(self._cache) > 100:
+                # 移除最旧的缓存
+                sorted_keys = sorted(self._cache_time.items(), key=lambda x: x[1])
+                keys_to_remove = [k for k, v in sorted_keys[:len(self._cache) - 100]]
+                for key in keys_to_remove:
+                    self._cache.pop(key, None)
+                    self._cache_time.pop(key, None)
+            
+            cache_data = {
+                'cache': self._cache,
+                'cache_time': self._cache_time
+            }
+            
+            with open(self._cache_file, 'w') as f:
+                json.dump(cache_data, f)
+        except Exception as e:
+            print(f"保存缓存失败: {e}")
+    
+    def get_random_api(self):
+        """获取随机API"""
+        return random.choice(self.apis)
+    
+    def get_cache_key(self, params):
+        """生成缓存键"""
+        # 排序参数以保持一致性
+        sorted_params = sorted(params.items())
+        param_str = urllib.parse.urlencode(sorted_params)
+        return hashlib.md5(param_str.encode()).hexdigest()
+    
+    def get_from_cache(self, params):
+        """从缓存获取结果"""
+        key = self.get_cache_key(params)
+        current_time = time.time()
+        
+        if key in self._cache and current_time - self._cache_time.get(key, 0) < self._cache_ttl:
+            self.stats["cache_hits"] += 1
+            return self._cache.get(key)
+            
+        self.stats["cache_misses"] += 1
+        return None
+    
+    def save_to_cache(self, params, data):
+        """保存到缓存"""
+        key = self.get_cache_key(params)
+        self._cache[key] = data
+        self._cache_time[key] = time.time()
+        
+        # 定期保存缓存
+        if self.stats["cache_misses"] % 5 == 0:  # 每5次未命中缓存时保存
+            self._save_cache()
+    
+    def convert(self, params):
+        """执行转换，优先使用缓存"""
+        # 尝试从缓存获取
+        cache_result = self.get_from_cache(params)
+        if cache_result:
+            return cache_result
+        
+        # 缓存未命中，请求API
+        errors = []
+        
+        # 随机API顺序
+        apis = list(self.apis)
+        random.shuffle(apis)
+        
+        for api_url in apis:
+            try:
+                # 发送请求
+                response = requests.get(api_url, params=params, timeout=30)
+                
+                if response.status_code == 200:
+                    # 获取内容和类型
+                    content = response.content
+                    content_type = response.headers.get('Content-Type', 'text/plain')
+                    
+                    # 保存到缓存
+                    cache_data = {
+                        'content': content.decode('utf-8', errors='ignore'),  # 保存为字符串
+                        'content_type': content_type
+                    }
+                    self.save_to_cache(params, cache_data)
+                    
+                    self.stats["api_successes"] += 1
+                    return content, content_type
+                else:
+                    errors.append(f"API {api_url} 返回状态码: {response.status_code}")
+            except Exception as e:
+                errors.append(f"API {api_url} 请求失败: {str(e)}")
+                self.stats["api_failures"] += 1
+        
+        # 所有API都失败
+        error_message = "所有转换API均不可用:\n" + "\n".join(errors)
+        raise Exception(error_message)
+    
+    def get_stats(self):
+        """获取统计信息"""
+        return {
+            "cache_size": len(self._cache),
+            "cache_hits": self.stats["cache_hits"],
+            "cache_misses": self.stats["cache_misses"],
+            "api_successes": self.stats["api_successes"],
+            "api_failures": self.stats["api_failures"],
+            "cache_hit_ratio": self.stats["cache_hits"] / (self.stats["cache_hits"] + self.stats["cache_misses"]) if (self.stats["cache_hits"] + self.stats["cache_misses"]) > 0 else 0
+        }
+
+# 初始化代理系统
+proxy_system = ProxySystem()
 
 @login_manager.user_loader
 def load_user(user_id):
@@ -85,7 +219,16 @@ def logout():
 @app.route('/')
 @login_required
 def index():
-    return render_template('index.html')
+    # 获取缓存统计信息
+    try:
+        stats = proxy_system.get_stats()
+        cache_hit_ratio = f"{stats['cache_hit_ratio']*100:.1f}%" if stats['cache_hit_ratio'] > 0 else "0%"
+    except:
+        cache_hit_ratio = "计算中"
+        
+    return render_template('index.html', 
+                         conversion_mode="隐私代理+本地缓存", 
+                         cache_hit_ratio=cache_hit_ratio)
 
 @app.route('/convert', methods=['POST'])
 @login_required
@@ -99,23 +242,13 @@ def convert():
         return jsonify({"status": "error", "message": "订阅链接不能为空"})
     
     try:
-        # 检查subconverter服务是否可用
-        try:
-            version_check = requests.get('http://localhost:25500/version', timeout=2)
-            if version_check.status_code != 200:
-                return jsonify({"status": "error", "message": "订阅转换服务暂时不可用，请稍后再试"})
-        except:
-            return jsonify({"status": "error", "message": "订阅转换服务暂时不可用，请稍后再试"})
-        
-        # 构建转换请求参数
+        # 构建参数
         params = {
             'target': target,
             'url': original_url,
-            'insert': 'false',
             'config': backend_url,
             'emoji': 'true',
             'list': 'false',
-            'xudp': 'false',
             'udp': 'false',
             'tfo': 'false',
             'expand': 'true',
@@ -124,37 +257,83 @@ def convert():
             'new_name': 'true'
         }
         
-        # 通过URL参数构建转换链接
-        base_url = request.host_url.rstrip('/')
-        convert_url = f"{base_url}/api/sub?{urllib.parse.urlencode(params)}"
+        # 构建转换URL (隐私代理URL)
+        server_url = request.url_root.rstrip('/')
+        proxy_url = f"{server_url}/api/sub?{urllib.parse.urlencode(params)}"
         
-        return jsonify({"status": "success", "result": convert_url})
+        return jsonify({
+            "status": "success", 
+            "result": proxy_url,
+            "mode": "proxy"
+        })
         
     except Exception as e:
         return jsonify({"status": "error", "message": f"处理失败: {str(e)}"})
 
 @app.route('/api/sub')
-def subscribe_api():
-    """代理 subconverter 的转换请求"""
+def api_sub_proxy():
+    """智能代理API - 带缓存"""
     try:
-        # 获取所有URL参数
+        # 获取所有请求参数
         params = request.args.to_dict()
         
-        # 调用本地 subconverter 服务
-        sub_url = f"http://localhost:25500/sub?{urllib.parse.urlencode(params)}"
-        response = requests.get(sub_url, timeout=30)
-        
-        # 返回原始响应
-        return Response(
-            response.content,
-            status=response.status_code,
-            content_type=response.headers.get('Content-Type', 'text/plain')
-        )
+        # 使用代理系统处理请求
+        try:
+            # 从缓存中获取
+            cache_result = proxy_system.get_from_cache(params)
+            if cache_result:
+                # 返回缓存内容
+                content = cache_result.get('content', '').encode('utf-8')
+                content_type = cache_result.get('content_type', 'text/plain')
+                
+                headers = {
+                    'Content-Type': content_type,
+                    'X-Proxy-By': 'Your Private Space',
+                    'X-Cache': 'HIT',
+                    'X-Content-Type-Options': 'nosniff',
+                    'Cache-Control': 'max-age=3600'
+                }
+                
+                return Response(content, headers=headers)
+            
+            # 缓存未命中，使用API
+            content, content_type = proxy_system.convert(params)
+            
+            # 构建响应
+            headers = {
+                'Content-Type': content_type,
+                'X-Proxy-By': 'Your Private Space',
+                'X-Cache': 'MISS',
+                'X-Content-Type-Options': 'nosniff',
+                'Cache-Control': 'max-age=3600'
+            }
+            
+            return Response(content, headers=headers)
+        except Exception as e:
+            return f"转换失败: {str(e)}", 500
+            
+    except Exception as e:
+        return f"请求处理失败: {str(e)}", 500
+
+# 添加统计接口
+@app.route('/stats')
+@login_required
+def show_stats():
+    stats = proxy_system.get_stats()
+    return jsonify(stats)
+
+# 添加清除缓存接口
+@app.route('/clear-cache', methods=['POST'])
+@login_required
+def clear_cache():
+    try:
+        proxy_system._cache = {}
+        proxy_system._cache_time = {}
+        proxy_system._save_cache()
+        return jsonify({"status": "success", "message": "缓存已清除"})
     except Exception as e:
-        return f"转换失败: {str(e)}", 500
+        return jsonify({"status": "error", "message": f"清除缓存失败: {str(e)}"})
 
-# 不要在这里调用 app.run()
-# 让 Hugging Face 的 WSGI 服务器来运行应用
-# 仅在本地开发时使用以下代码
+# 仅在本地开发时使用
 if __name__ == '__main__' and os.environ.get('DEVELOPMENT') == 'true':
     app.run(host='0.0.0.0', port=7860, debug=True)