mdbq 4.0.100__tar.gz → 4.0.102__tar.gz

{mdbq-4.0.100 → mdbq-4.0.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdbq
-Version: 4.0.100
+Version: 4.0.102
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

mdbq-4.0.102/mdbq/__version__.py

@@ -0,0 +1 @@
+VERSION = '4.0.102'

{mdbq-4.0.100 → mdbq-4.0.102}/mdbq/auth/auth_backend.py

@@ -1427,24 +1427,74 @@ class StandaloneAuthManager:
             cursor.close()
             conn.close()
 
-    def logout_device(self, user_id, device_id):
-        """登出指定设备"""
+    def logout_device(self, user_id, device_id=None, ip_address=None, user_agent=None, device_info=None, login_domain=''):
+        """
+        登出设备（支持两种识别方式）
+        
+        Args:
+            user_id: 用户ID
+            device_id: 设备ID（用于指定设备登出）
+            ip_address: IP地址（用于当前设备登出）
+            user_agent: 用户代理（用于当前设备登出）
+            device_info: 设备信息（用于当前设备登出）
+            login_domain: 登录域名（用于当前设备登出）
+        
+        Returns:
+            dict: 登出结果
+        """
         conn = self.pool.connection()
         cursor = conn.cursor()
         
         try:
             current_time_utc = datetime.now(timezone.utc)
             
-            # 查找设备
-            cursor.execute('''
-                SELECT id, device_name FROM device_sessions 
-                WHERE user_id = %s AND device_id = %s AND is_active = 1
-            ''', (user_id, device_id))
-            
-            device = cursor.fetchone()
-            
-            if not device:
-                return {'success': False, 'message': '设备不存在或已登出'}
+            if device_id:
+                # 方式1：通过device_id查找设备（用于设备管理界面）
+                cursor.execute('''
+                    SELECT id, device_name FROM device_sessions 
+                    WHERE user_id = %s AND device_id = %s AND is_active = 1
+                ''', (user_id, device_id))
+                
+                device = cursor.fetchone()
+                logout_reason = 'single_device_logout'
+                
+                if not device:
+                    return {'success': False, 'message': '设备不存在或已登出'}
+                    
+            else:
+                # 方式2：通过设备指纹查找当前设备（用于当前设备登出）
+                if not user_agent:
+                    return {'success': False, 'message': '缺少设备识别信息'}
+                
+                # 解析用户代理获取基本信息
+                parsed_ua = self._parse_user_agent(user_agent)
+                
+                # 合并设备信息
+                full_device_info = {
+                    'user_agent': user_agent,
+                    'platform': parsed_ua.get('platform'),
+                    **parsed_ua,
+                    **(device_info or {})
+                }
+                
+                # 生成包含域名的设备指纹来识别当前设备
+                device_fingerprint = self._generate_device_fingerprint(full_device_info, login_domain)
+                
+                # 查找当前活跃的设备会话
+                cursor.execute('''
+                    SELECT ds.id, ds.device_name
+                    FROM device_sessions ds
+                    WHERE ds.user_id = %s AND ds.device_fingerprint = %s AND ds.login_domain = %s 
+                      AND ds.is_active = 1
+                    ORDER BY ds.session_version DESC
+                    LIMIT 1
+                ''', (user_id, device_fingerprint, login_domain))
+                
+                device = cursor.fetchone()
+                logout_reason = 'current_device_logout'
+                
+                if not device:
+                    return {'success': False, 'message': '当前设备会话不存在或已失效'}
             
             device_session_id = device['id']
             device_name = device['device_name']
@@ -1452,9 +1502,9 @@ class StandaloneAuthManager:
             # 撤销该设备的刷新令牌
             cursor.execute('''
                 UPDATE refresh_tokens 
-                SET is_revoked = 1, revoked_at = %s, revoked_reason = 'single_device_logout' 
+                SET is_revoked = 1, revoked_at = %s, revoked_reason = %s 
                 WHERE device_session_id = %s AND is_revoked = 0
-            ''', (current_time_utc, device_session_id))
+            ''', (current_time_utc, logout_reason, device_session_id))
             
             # 停用设备会话
             cursor.execute('''
@@ -1463,7 +1513,8 @@ class StandaloneAuthManager:
                 WHERE id = %s
             ''', (device_session_id,))
             
-            return {'success': True, 'message': f'设备 "{device_name}" 已成功登出'}
+            message = f'设备 "{device_name}" 已成功登出' if device_id else f'已成功登出当前设备 "{device_name}"'
+            return {'success': True, 'message': message}
             
         except Exception as e:
             return {'success': False, 'message': f'登出设备失败: {str(e)}'}

{mdbq-4.0.100 → mdbq-4.0.102}/mdbq/auth/rate_limiter.py

@@ -255,30 +255,60 @@ class AdvancedRateLimiter:
     
     def check_sliding_window_log(self, key: str, rule: RateLimitRule) -> Tuple[bool, int]:
         """滑动窗口日志算法"""
-        with self.locks[key]:
-            current_time = time.time()
-            window_start = current_time - rule.window
-            
-            if key not in self.storage:
-                self.storage[key] = {'requests': deque(), 'last_access': current_time}
-            
-            # 更新最后访问时间
-            self.storage[key]['last_access'] = current_time
-            requests = self.storage[key]['requests']
-            
-            # 清理过期请求
-            while requests and requests[0] < window_start:
-                requests.popleft()
-            
-            # 检查是否超过限制
-            if len(requests) >= rule.requests:
-                return False, 0
-            
-            # 记录当前请求
-            requests.append(current_time)
-            remaining = rule.requests - len(requests)
+        try:
+            if self.logger:
+                self.logger.debug(f"滑动窗口检查: key={key}, rule.requests={rule.requests}, rule.window={rule.window}")
             
-            return True, remaining
+            with self.locks[key]:
+                current_time = time.time()
+                window_start = current_time - rule.window
+                
+                if key not in self.storage:
+                    if self.logger:
+                        self.logger.debug(f"创建新的存储条目: key={key}")
+                    self.storage[key] = {'requests': deque(), 'last_access': current_time}
+                
+                # 更新最后访问时间
+                self.storage[key]['last_access'] = current_time
+                
+                # 确保存储结构正确（可能被其他算法创建了不同结构）
+                if 'requests' not in self.storage[key]:
+                    if self.logger:
+                        self.logger.debug(f"修复存储结构: key={key}, 当前结构={list(self.storage[key].keys())}")
+                    # 重新初始化为滑动窗口结构
+                    self.storage[key] = {'requests': deque(), 'last_access': current_time}
+                
+                requests = self.storage[key]['requests']
+                
+                if self.logger:
+                    self.logger.debug(f"当前请求队列长度: {len(requests)}")
+                # 清理过期请求
+                while requests and requests[0] < window_start:
+                    requests.popleft()
+                
+                # 检查是否超过限制
+                if len(requests) >= rule.requests:
+                    if self.logger:
+                        self.logger.debug(f"请求超限: {len(requests)} >= {rule.requests}")
+                    return False, 0
+                
+                # 记录当前请求
+                requests.append(current_time)
+                remaining = rule.requests - len(requests)
+                
+                if self.logger:
+                    self.logger.debug(f"请求允许: remaining={remaining}")
+                
+                return True, remaining
+                
+        except Exception as e:
+            if self.logger:
+                import traceback
+                self.logger.error(f"滑动窗口算法异常: {str(e)}")
+                self.logger.error(f"Key: {key}, Rule: {rule}")
+                self.logger.error(f"异常详情: {traceback.format_exc()}")
+            # 异常时允许通过
+            return True, 100
     
     def check_token_bucket(self, key: str, rule: RateLimitRule) -> Tuple[bool, int]:
         """令牌桶算法"""
@@ -313,59 +343,122 @@ class AdvancedRateLimiter:
     
     def check_fixed_window(self, key: str, rule: RateLimitRule) -> Tuple[bool, int]:
         """固定窗口算法"""
-        current_time = time.time()
-        window_start = int(current_time // rule.window) * rule.window
-        
-        with self.locks[key]:
-            if key not in self.storage:
-                self.storage[key] = {'count': 0, 'window_start': window_start, 'last_access': current_time}
-            
-            # 更新最后访问时间
-            self.storage[key]['last_access'] = current_time
-            data = self.storage[key]
-            
-            # 检查是否是新窗口
-            if data['window_start'] != window_start:
-                data['count'] = 0
-                data['window_start'] = window_start
+        try:
+            if self.logger:
+                self.logger.debug(f"固定窗口检查: key={key}, rule.requests={rule.requests}, rule.window={rule.window}")
             
-            # 检查是否超过限制
-            if data['count'] >= rule.requests:
-                return False, 0
+            current_time = time.time()
+            window_start = int(current_time // rule.window) * rule.window
             
-            data['count'] += 1
-            remaining = rule.requests - data['count']
+            with self.locks[key]:
+                if key not in self.storage:
+                    if self.logger:
+                        self.logger.debug(f"创建新的固定窗口存储: key={key}")
+                    self.storage[key] = {'count': 0, 'window_start': window_start, 'last_access': current_time}
+                
+                # 更新最后访问时间
+                self.storage[key]['last_access'] = current_time
+                
+                # 确保存储结构正确（可能被滑动窗口算法创建了不同结构）
+                if 'count' not in self.storage[key] or 'window_start' not in self.storage[key]:
+                    if self.logger:
+                        self.logger.debug(f"修复固定窗口存储结构: key={key}, 当前结构={list(self.storage[key].keys())}")
+                    # 重新初始化为固定窗口结构
+                    self.storage[key] = {'count': 0, 'window_start': window_start, 'last_access': current_time}
+                
+                data = self.storage[key]
             
-            return True, remaining
+                # 检查是否是新窗口
+                if data['window_start'] != window_start:
+                    if self.logger:
+                        self.logger.debug(f"新窗口开始: {window_start}")
+                    data['count'] = 0
+                    data['window_start'] = window_start
+                
+                # 检查是否超过限制
+                if data['count'] >= rule.requests:
+                    if self.logger:
+                        self.logger.debug(f"固定窗口请求超限: {data['count']} >= {rule.requests}")
+                    return False, 0
+                
+                data['count'] += 1
+                remaining = rule.requests - data['count']
+                
+                if self.logger:
+                    self.logger.debug(f"固定窗口请求允许: count={data['count']}, remaining={remaining}")
+                
+                return True, remaining
+                
+        except Exception as e:
+            if self.logger:
+                import traceback
+                self.logger.error(f"固定窗口算法异常: {str(e)}")
+                self.logger.error(f"Key: {key}, Rule: {rule}")
+                self.logger.error(f"异常详情: {traceback.format_exc()}")
+            # 异常时允许通过
+            return True, 100
     
     def check_rate_limit(self, api_type: str, key: str, level: RateLimitLevel, 
                         strategy: RateLimitStrategy = None) -> Tuple[bool, int, dict]:
         """核心限流检查"""
-        # 检查是否被阻断
-        is_blocked, block_remaining = self.is_blocked(key)
-        if is_blocked:
-            return False, 0, {
-                'error': 'blocked',
-                'retry_after': block_remaining,
-                'reason': 'IP temporarily blocked due to excessive requests'
-            }
-        
-        # 获取限流规则
-        if api_type not in self.rules or level not in self.rules[api_type]:
-            rule = RateLimitRule(100, 60)  # 默认规则
-        else:
-            rule = self.rules[api_type][level]
+        try:
+            if self.logger:
+                self.logger.debug(f"check_rate_limit: api_type={api_type}, key={key}, level={level}")
+            
+            # 检查是否被阻断
+            is_blocked, block_remaining = self.is_blocked(key)
+            if is_blocked:
+                if self.logger:
+                    self.logger.debug(f"Key {key} is blocked, remaining: {block_remaining}")
+                return False, 0, {
+                    'error': 'blocked',
+                    'retry_after': block_remaining,
+                    'reason': 'IP temporarily blocked due to excessive requests'
+                }
+            
+            # 获取限流规则
+            if api_type not in self.rules or level not in self.rules[api_type]:
+                if self.logger:
+                    self.logger.debug(f"Using default rule for api_type={api_type}, level={level}")
+                rule = RateLimitRule(100, 60)  # 默认规则
+            else:
+                rule = self.rules[api_type][level]
+                if self.logger:
+                    self.logger.debug(f"Using rule: requests={rule.requests}, window={rule.window}")
+        except Exception as e:
+            if self.logger:
+                import traceback
+                self.logger.error(f"check_rate_limit异常: {str(e)}")
+                self.logger.error(f"异常详情: {traceback.format_exc()}")
+            # 异常时返回允许通过
+            return True, 100, {}
         
         # 选择限流策略
-        strategy = strategy or rule.strategy
-        
-        if strategy == RateLimitStrategy.SLIDING_WINDOW_LOG:
-            allowed, remaining = self.check_sliding_window_log(key, rule)
-        elif strategy == RateLimitStrategy.TOKEN_BUCKET:
-            allowed, remaining = self.check_token_bucket(key, rule)
-        else:
-            # 默认固定窗口
-            allowed, remaining = self.check_fixed_window(key, rule)
+        try:
+            strategy = strategy or rule.strategy
+            
+            if self.logger:
+                self.logger.debug(f"Using strategy: {strategy}")
+            
+            if strategy == RateLimitStrategy.SLIDING_WINDOW_LOG:
+                allowed, remaining = self.check_sliding_window_log(key, rule)
+            elif strategy == RateLimitStrategy.TOKEN_BUCKET:
+                allowed, remaining = self.check_token_bucket(key, rule)
+            else:
+                # 默认固定窗口
+                allowed, remaining = self.check_fixed_window(key, rule)
+                
+            if self.logger:
+                self.logger.debug(f"Strategy result: allowed={allowed}, remaining={remaining}")
+                
+        except Exception as e:
+            if self.logger:
+                import traceback
+                self.logger.error(f"限流策略执行异常: {str(e)}")
+                self.logger.error(f"策略: {strategy}, Key: {key}")
+                self.logger.error(f"异常详情: {traceback.format_exc()}")
+            # 策略执行异常时，允许通过
+            return True, 100, {}
         
         # 如果超过限制，考虑是否阻断
         if not allowed:
@@ -459,13 +552,22 @@ class RateLimitDecorators:
             def decorated_function(*args, **kwargs):
                 try:
                     # 获取客户端信息
+                    if self.limiter.logger:
+                        self.limiter.logger.debug(f"限流检查开始: api_type={api_type}")
+                    
                     client_ip, user_level, rate_limit_key = self.limiter.get_client_info()
                     
+                    if self.limiter.logger:
+                        self.limiter.logger.debug(f"客户端信息: ip={client_ip}, level={user_level}, key={rate_limit_key}")
+                    
                     # 执行限流检查
                     allowed, remaining, error_info = self.limiter.check_rate_limit(
                         api_type, rate_limit_key, user_level, strategy
                     )
                     
+                    if self.limiter.logger:
+                        self.limiter.logger.debug(f"限流检查结果: allowed={allowed}, remaining={remaining}")
+                    
                     if not allowed:
                         # 记录限流事件
                         if self.limiter.logger:
@@ -495,18 +597,26 @@ class RateLimitDecorators:
                     if isinstance(response, tuple) and len(response) >= 2:
                         response_data, status_code = response[0], response[1]
                         if hasattr(response_data, 'headers'):
-                            rule = self.limiter.rules.get(api_type, {}).get(user_level)
-                            if rule:
-                                response_data.headers['X-RateLimit-Limit'] = str(rule.requests)
-                                response_data.headers['X-RateLimit-Remaining'] = str(remaining)
-                                response_data.headers['X-RateLimit-Reset'] = str(int(time.time() + rule.window))
-                                response_data.headers['X-RateLimit-Policy'] = f"{api_type}:{user_level.value}"
+                            try:
+                                rule = self.limiter.rules.get(api_type, {}).get(user_level)
+                                if rule and hasattr(rule, 'requests') and hasattr(rule, 'window'):
+                                    response_data.headers['X-RateLimit-Limit'] = str(rule.requests)
+                                    response_data.headers['X-RateLimit-Remaining'] = str(remaining)
+                                    response_data.headers['X-RateLimit-Reset'] = str(int(time.time() + rule.window))
+                                    response_data.headers['X-RateLimit-Policy'] = f"{api_type}:{user_level.value}"
+                            except (AttributeError, KeyError, TypeError):
+                                # 忽略头部设置错误，不影响主要功能
+                                pass
                     
                     return response
                     
                 except Exception as e:
                     if self.limiter.logger:
+                        import traceback
                         self.limiter.logger.error(f"限流系统异常: {str(e)}")
+                        self.limiter.logger.error(f"异常类型: {type(e).__name__}")
+                        self.limiter.logger.error(f"异常详情: {traceback.format_exc()}")
+                        self.limiter.logger.error(f"API类型: {api_type}, 策略: {strategy}")
                     # 限流系统故障时，允许请求通过
                     return f(*args, **kwargs)
             

{mdbq-4.0.100 → mdbq-4.0.102}/mdbq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mdbq
-Version: 4.0.100
+Version: 4.0.102
 Home-page: https://pypi.org/project/mdbq
 Author: xigua, 
 Author-email: 2587125111@qq.com

mdbq-4.0.100/mdbq/__version__.py

@@ -1 +0,0 @@
-VERSION = '4.0.100'