File size: 7,560 Bytes
b0074f5
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
"""
会话凭证缓存(凭证亲和)
同一会话(由请求内容派生的稳定 key)绑定同一凭证,命中上游 prompt cache。

双后端:
- Redis(可选): 设置 REDIS_URL 后启用,多实例共享绑定
- 内存(默认): 无 Redis 时自动使用,进程内字典 + 过期清理

行为:
- get: 命中时自动续期 TTL(活跃会话保持绑定,空闲会话过期)
- set: 每次成功调用后写入/刷新绑定
- Redis 故障仅跳过该次操作并告警,不影响主流程;内存后端始终可用兜底
"""

import asyncio
import hashlib
import json
import time
from typing import Any, Dict, Optional

from log import log

# 绑定 TTL(秒):会话空闲超过该时长后解绑
SESSION_BINDING_TTL = 3600

_KEY_PREFIX = "agy2api:sess:"

# Redis 客户端(None = 未启用,使用内存后端)
_redis_client = None

# 内存后端: {session_key: (email, expire_at)}
_memory_store: Dict[str, tuple] = {}
_memory_lock = asyncio.Lock()

# 内存后端容量上限(防止无限增长),超限时清理过期项后仍超限则丢弃最旧的
_MEMORY_MAX_ENTRIES = 50000


def _now() -> float:
    return time.time()


def _get_client():
    """返回已初始化的 Redis 客户端;未启用时返回 None"""
    return _redis_client


async def init_redis(redis_url: str) -> bool:
    """初始化 Redis 连接。连接失败返回 False(回落内存后端),不抛异常。"""
    global _redis_client
    if not redis_url:
        return False
    try:
        import redis.asyncio as redis_aiolib

        client = redis_aiolib.from_url(
            redis_url,
            decode_responses=False,
            socket_connect_timeout=2.0,
            socket_timeout=2.0,
            health_check_interval=30,
        )
        await client.ping()
        _redis_client = client
        log.info("会话凭证缓存已连接 Redis")
        return True
    except Exception as e:
        log.warning(f"Redis 连接失败,使用内存后端: {e}")
        _redis_client = None
        return False


async def close() -> None:
    """关闭 Redis 连接(应用关闭时调用)"""
    global _redis_client
    if _redis_client is not None:
        try:
            await _redis_client.aclose()
        except Exception:
            pass
        _redis_client = None
    _memory_store.clear()


# ====================== 会话 key 派生 ======================

def derive_session_key(model_name: str, gemini_request: Dict[str, Any]) -> Optional[str]:
    """
    从规范化后的 Gemini 请求派生会话 key:
    hash(模型 + systemInstruction 或 第一条 user 消息)

    必须在格式转换完成后调用(openai2gemini / anthropic2gemini / 原生 gemini 都已
    转成 Gemini 格式),保证不同 API 格式的相同内容派生相同的 key。

    Returns:
        "auto:<hash>" 或 None(无法派生时)
    """
    if not isinstance(gemini_request, dict):
        return None

    model_part = model_name if isinstance(model_name, str) else ""

    # 优先 systemInstruction(对话稳定的锚点)
    anchor = None
    system_instruction = gemini_request.get("systemInstruction")
    if isinstance(system_instruction, dict):
        parts = system_instruction.get("parts")
        if isinstance(parts, list) and parts:
            anchor = _stable_json(parts)

    # 没有 system 时取第一条 user 消息的 parts
    if anchor is None:
        contents = gemini_request.get("contents")
        if isinstance(contents, list):
            for content in contents:
                if isinstance(content, dict) and content.get("role") == "user":
                    parts = content.get("parts")
                    if isinstance(parts, list) and parts:
                        anchor = _stable_json(parts)
                        break

    if anchor is None:
        return None

    digest = hashlib.sha256(f"{model_part}|{anchor}".encode("utf-8")).hexdigest()
    return f"auto:{digest[:32]}"


def _stable_json(value: Any) -> Optional[str]:
    """稳定序列化(排序键),失败返回 None"""
    try:
        return json.dumps(value, sort_keys=True, ensure_ascii=False)
    except (TypeError, ValueError):
        return None


# ====================== 绑定读写 ======================

async def get_session_binding(session_key: str) -> Optional[str]:
    """查询会话绑定的凭证 email;命中时续期 TTL。未绑定/后端故障返回 None。"""
    if not session_key:
        return None

    client = _get_client()
    if client is not None:
        redis_key = f"{_KEY_PREFIX}{session_key}"
        try:
            raw = await client.get(redis_key)
            if raw is None:
                return None
            await client.expire(redis_key, SESSION_BINDING_TTL)
            return raw.decode("utf-8") if isinstance(raw, bytes) else str(raw)
        except Exception as e:
            log.warning(f"Redis get 会话绑定失败: {e}")
            # Redis 故障回落内存后端

    return await _memory_get(session_key)


async def set_session_binding(session_key: str, email: str) -> None:
    """写入/刷新会话绑定(凭证亲和成功后调用)。后端故障仅告警。"""
    if not session_key or not email:
        return

    client = _get_client()
    if client is not None:
        try:
            await client.setex(
                f"{_KEY_PREFIX}{session_key}", SESSION_BINDING_TTL, email
            )
        except Exception as e:
            log.warning(f"Redis set 会话绑定失败: {e}")

    await _memory_set(session_key, email)


async def delete_session_binding(session_key: str) -> None:
    """删除会话绑定(绑定凭证不可用时清除)"""
    if not session_key:
        return

    client = _get_client()
    if client is not None:
        try:
            await client.delete(f"{_KEY_PREFIX}{session_key}")
        except Exception as e:
            log.warning(f"Redis delete 会话绑定失败: {e}")

    async with _memory_lock:
        _memory_store.pop(session_key, None)


# ====================== 内存后端 ======================

async def _memory_get(session_key: str) -> Optional[str]:
    async with _memory_lock:
        entry = _memory_store.get(session_key)
        if not entry:
            return None
        email, expire_at = entry
        if _now() >= expire_at:
            _memory_store.pop(session_key, None)
            return None
        # 命中续期
        _memory_store[session_key] = (email, _now() + SESSION_BINDING_TTL)
        return email


async def _memory_set(session_key: str, email: str) -> None:
    async with _memory_lock:
        # 容量控制:超过上限先清理过期项
        if len(_memory_store) >= _MEMORY_MAX_ENTRIES:
            _cleanup_expired_locked()
        # 仍超限则丢弃最旧的一半(按过期时间排序)
        if len(_memory_store) >= _MEMORY_MAX_ENTRIES:
            sorted_items = sorted(_memory_store.items(), key=lambda kv: kv[1][1])
            for k, _ in sorted_items[: len(sorted_items) // 2]:
                _memory_store.pop(k, None)
        _memory_store[session_key] = (email, _now() + SESSION_BINDING_TTL)


def _cleanup_expired_locked() -> None:
    """清理过期项(须持有锁时调用)"""
    now = _now()
    expired = [k for k, (_, exp) in _memory_store.items() if now >= exp]
    for k in expired:
        _memory_store.pop(k, None)


def memory_store_size() -> int:
    """内存后端条目数(诊断用)"""
    return len(_memory_store)