Upload 2 files

Dockerfile

@@ -23,4 +23,4 @@ ENV PYTHONUNBUFFERED=1
 EXPOSE 3000
 
 # 使用 gunicorn 作为生产级 WSGI 服务器
-CMD ["gunicorn", "--bind", "0.0.0.0:3000", "--workers", "4", "app:app"]
+CMD ["gunicorn", "--bind", "0.0.0.0:3000", "--workers", "4", "--timeout", "120", "app:app"]

app.py

@@ -107,7 +107,7 @@ def create_custom_session():
     return session
 
 # 添加速率限制相关的常量
-AUTH_RETRY_DELAY = 60  # 认证���试延迟（秒）
+AUTH_RETRY_DELAY = 60  # 认证试延迟（秒）
 AUTH_BACKOFF_FACTOR = 2  # 退避因子
 AUTH_MAX_RETRIES = 3  # 最大重试次数
 AUTH_CHECK_INTERVAL = 300  # 健康检查间隔（秒）
@@ -308,32 +308,35 @@ class MultiAuthManager:
         self.auth_managers = [AuthManager(email, password) for email, password in credentials]
         self.current_index = 0
         self.last_success_index = 0  # 记录上一次成功的账号索引
-        self.last_rotation_date = datetime.now().date()  # 记录上次轮询的日期
+        self._last_rotation_date = None  # 使用None作为初始值
+        self._lock = threading.Lock()  # 添加线程锁
 
     def get_next_auth_manager(self, model):
         """改进的账号选择逻辑，从上次成功的账号开始尝试"""
-        current_date = datetime.now().date()
-        
-        # 如果是新的一天，重置为从第一个账号开始
-        if current_date > self.last_rotation_date:
-            self.current_index = 0
-            self.last_success_index = 0
-            self.last_rotation_date = current_date
-            # 重置所有账号的模型状态
-            for auth_manager in self.auth_managers:
-                auth_manager.reset_model_status()
-            return self.auth_managers[0] if self.auth_managers else None
-            
-        # 从上次成功的账号开始尝试
-        self.current_index = self.last_success_index
-        auth_manager = self.auth_managers[self.current_index]
-        
-        # 如果当前账号可用，直接返回
-        if auth_manager.is_model_available(model) and auth_manager._should_attempt_auth():
-            return auth_manager
-            
-        # 如果当前账号不可用，等待到第二天
-        return None
+        with self._lock:  # 使用线程锁保护共享状态
+            try:
+                current_date = datetime.now().date()
+                
+                # 初始化或检查日期变更
+                if self._last_rotation_date is None or current_date > self._last_rotation_date:
+                    self.current_index = 0
+                    self.last_success_index = 0
+                    self._last_rotation_date = current_date
+                    # 重置所有账号的模型状态
+                    for auth_manager in self.auth_managers:
+                        auth_manager.reset_model_status()
+                    return self.auth_managers[0] if self.auth_managers else None
+                    
+                # 从上次成功的账号开始尝试
+                self.current_index = self.last_success_index
+                if 0 <= self.current_index < len(self.auth_managers):
+                    auth_manager = self.auth_managers[self.current_index]
+                    if auth_manager.is_model_available(model) and auth_manager._should_attempt_auth():
+                        return auth_manager
+                return None
+            except Exception as e:
+                logger.error(f"Error in get_next_auth_manager: {str(e)}")
+                return None
 
     def ensure_valid_token(self, model):
         auth_manager = self.get_next_auth_manager(model)
@@ -828,6 +831,7 @@ def make_request(payload, auth_manager, model_id):
     global multi_auth_manager
     max_retries = 3
     retry_delay = 1
+    request_timeout = 10  # 减少单次请求超时时间
     
     logger.info(f"尝试发送请求，模型：{model_id}")
     
@@ -848,77 +852,86 @@ def make_request(payload, auth_manager, model_id):
     tried_accounts = set()
     
     while True:  # 持续尝试，直到成功或确定所有账号都不可用
-        auth_manager = multi_auth_manager.get_next_auth_manager(model_id)
-        if not auth_manager:
-            # 检查是否所有账号都已尝试
-            if len(tried_accounts) >= len(multi_auth_manager.auth_managers):
-                logger.error("所有账号都已尝试且不可用")
-                # 尝试注册新账号
-                successful_accounts = register_bot.register_and_verify(5)
-                if successful_accounts:
-                    credentials = [(account['email'], account['password']) for account in successful_accounts]
-                    multi_auth_manager = MultiAuthManager(credentials)
-                    tried_accounts.clear()  # 清空已尝试账号列表
-                    continue  # 继续尝试新注册的账号
-                else:
-                    raise Exception("所有账号均不可用，且注册新账号失败")
-            continue  # 如果还有未尝试的账号，继续循环
-            
-        # 如果这个账号已经尝试过，跳过
-        if auth_manager._email in tried_accounts:
-            continue
-            
-        tried_accounts.add(auth_manager._email)
-        logger.info(f"尝试使用账号 {auth_manager._email}")
-
-        for attempt in range(max_retries):
-            try:
-                url = get_notdiamond_url()
-                headers = get_notdiamond_headers(auth_manager)
-                
-                # 使用 session 发送请求
-                session = create_custom_session()
-                response = session.post(
-                    url,
-                    headers=headers,
-                    json=payload,
-                    stream=True,
-                    timeout=30  # 添加超时设置
-                )
-                
-                if response.status_code == 200:
-                    logger.info(f"请求成功，使用账号 {auth_manager._email}")
-                    return response
-                
-                # 处理不同的错误状态码
-                if response.status_code == 401:  # Unauthorized
-                    logger.warning(f"Token expired for account {auth_manager._email}")
-                    if auth_manager.ensure_valid_token():
-                        continue
-                    break
+        try:
+            auth_manager = multi_auth_manager.get_next_auth_manager(model_id)
+            if not auth_manager:
+                # 检查是否所有账号都已尝试
+                if len(tried_accounts) >= len(multi_auth_manager.auth_managers):
+                    logger.error("所有账号都已尝试且不可用")
+                    # 尝试注册新账号
+                    successful_accounts = register_bot.register_and_verify(5)
+                    if successful_accounts:
+                        credentials = [(account['email'], account['password']) for account in successful_accounts]
+                        multi_auth_manager = MultiAuthManager(credentials)
+                        tried_accounts.clear()  # 清空已尝试账号列表
+                        continue  # 继续尝试新注册的账号
+                    else:
+                        raise Exception("所有账号均不可用，且注册新账号失败")
+                continue  # 如果还有未尝试的账号，继续循环
                 
-                if response.status_code == 403:  # Forbidden
-                    logger.warning(f"Model {model_id} usage limit reached for account {auth_manager._email}")
-                    auth_manager.set_model_unavailable(model_id)
-                    break
+            # 如果这个账号已经尝试过，跳过
+            if auth_manager._email in tried_accounts:
+                continue
                 
-                if response.status_code >= 500:  # Server error
+            tried_accounts.add(auth_manager._email)
+            logger.info(f"尝试使用账号 {auth_manager._email}")
+
+            for attempt in range(max_retries):
+                try:
+                    url = get_notdiamond_url()
+                    headers = get_notdiamond_headers(auth_manager)
+                    
+                    # 使用 session 发送请求
+                    session = create_custom_session()
+                    response = session.post(
+                        url,
+                        headers=headers,
+                        json=payload,
+                        stream=True,
+                        timeout=request_timeout
+                    )
+                    
+                    if response.status_code == 200:
+                        logger.info(f"请求成功，使用账号 {auth_manager._email}")
+                        return response
+                    
+                    # 处理不同的错误状态码
+                    if response.status_code == 401:  # Unauthorized
+                        logger.warning(f"Token expired for account {auth_manager._email}")
+                        if auth_manager.ensure_valid_token():
+                            continue
+                        break
+                    
+                    if response.status_code == 403:  # Forbidden
+                        logger.warning(f"Model {model_id} usage limit reached for account {auth_manager._email}")
+                        auth_manager.set_model_unavailable(model_id)
+                        break
+                    
+                    if response.status_code >= 500:  # Server error
+                        if attempt < max_retries - 1:
+                            time.sleep(retry_delay * (attempt + 1))
+                            continue
+                    
+                    logger.error(f"Request failed with status {response.status_code}")
+                    
+                except requests.Timeout:
+                    logger.warning(f"Request timeout for account {auth_manager._email}, attempt {attempt + 1}")
                     if attempt < max_retries - 1:
                         time.sleep(retry_delay * (attempt + 1))
-                        continue
-                
-                logger.error(f"Request failed with status {response.status_code}")
-                
-            except requests.RequestException as e:
-                logger.error(f"Request error: {str(e)}")
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay * (attempt + 1))
-                continue
-            except Exception as e:
-                logger.error(f"Unexpected error: {str(e)}")
-                if attempt < max_retries - 1:
-                    time.sleep(retry_delay * (attempt + 1))
-                continue
+                    continue
+                except requests.RequestException as e:
+                    logger.error(f"Request error: {str(e)}")
+                    if attempt < max_retries - 1:
+                        time.sleep(retry_delay * (attempt + 1))
+                    continue
+                except Exception as e:
+                    logger.error(f"Unexpected error: {str(e)}")
+                    if attempt < max_retries - 1:
+                        time.sleep(retry_delay * (attempt + 1))
+                    continue
+        except Exception as e:
+            logger.error(f"Error in main request loop: {str(e)}")
+            time.sleep(retry_delay)
     
     raise Exception("无法完成请求，所有可用账号都已尝试")