Download internal/jsonscan/jsonscan.go from a3216/gcli2api: direct link, hf CLI and curl.
- Browser
- Download file 11 kB
-
https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/jsonscan/jsonscan.go
- Command line
-
hf download hf://spaces/a3216/gcli2api/internal/jsonscan/jsonscan.go
-
curl -L -o jsonscan.go https://huggingface.co/spaces/a3216/gcli2api/resolve/main/internal/jsonscan/jsonscan.go
11 kB
| // Package jsonscan 从**原始 JSON 字节**里读取少数几个字段,不做整棵树的解析。 | |
| // | |
| // 为什么需要它:网关每处理一个 chat 请求,会对同一个 body 做 4~6 次 | |
| // json.Unmarshal(会话键、首条 role、kimi 工具、body 归一化、会话字段注入), | |
| // 而线上代理负载的 body 常在 100~500KB。整棵树解析要给每个字符串解转义、 | |
| // 建 map、分配几十万对象;其中大部分字段根本没人看。 | |
| // | |
| // 本包遍历一次、只解出被问到的少数几个字符串,其余值按 JSON 语法跳过(零分配)。 | |
| // 语义与 encoding/json 一致:解出来的值走 json.Unmarshal 解转义;跳过只看语法。 | |
| // 任何解析不了的情况都返回 Ok=false,调用方**必须**回落到整树解析。 | |
| // | |
| // 性能要点(都是实测踩出来的): | |
| // - 不要为「查一个键」扫整个 body 多次——一次遍历收集所有想要的键; | |
| // - 不要对跳过的字符串调用 json.Unmarshal(第一版的致命错误:600KB 历史消息里 | |
| // 几千个字符串各解一次,比整树解析还慢 4 倍); | |
| // - 字符串边界用 bytes.IndexByte,只在疑似反斜杠时才回退逐字节。 | |
| package jsonscan | |
| import ( | |
| "bytes" | |
| "encoding/json" | |
| "fmt" | |
| "unicode/utf8" | |
| ) | |
| // Query 描述要读的字段。 | |
| type Query struct { | |
| // Top 顶层键(只取值是字符串的那些)。 | |
| Top []string | |
| // Nested 顶层子对象键(例如 "metadata");与 NestedKeys 都非空时才生效。 | |
| Nested string | |
| NestedKeys []string | |
| } | |
| // Result 读取结果。Ok=false 表示 body 不是本包能完整走完的 JSON 对象, | |
| // 调用方应回落整树解析(此时其它字段的值不可信)。 | |
| type Result struct { | |
| Top map[string]string | |
| Nested map[string]string | |
| Ok bool | |
| } | |
| // Get 取顶层键的值(未命中 / 非字符串 → "")。 | |
| func (r Result) Get(key string) string { return r.Top[key] } | |
| // GetNested 取顶层子对象里的键值(未命中 / 非字符串 → "")。 | |
| func (r Result) GetNested(key string) string { return r.Nested[key] } | |
| // Lookup 单遍遍历顶层对象,收集 Query 要求的字符串值。 | |
| // | |
| // 大数据量的字段(messages/tools)在这里只是被跳过,不做任何解码。 | |
| func Lookup(body []byte, q Query) Result { | |
| res := Result{Top: map[string]string{}, Nested: map[string]string{}} | |
| i := skipSpace(body, 0) | |
| if i >= len(body) || body[i] != '{' { | |
| return res | |
| } | |
| i++ | |
| for { | |
| i = skipSpace(body, i) | |
| if i >= len(body) { | |
| return res | |
| } | |
| if body[i] == '}' { | |
| res.Ok = true | |
| return res | |
| } | |
| key, next, ok := readKey(body, i) | |
| if !ok { | |
| return res | |
| } | |
| i = skipSpace(body, next) | |
| if i >= len(body) || body[i] != ':' { | |
| return res | |
| } | |
| i = skipSpace(body, i+1) | |
| if q.Nested != "" && len(q.NestedKeys) > 0 && string(key) == q.Nested { | |
| res.Nested = collect(body, i, q.NestedKeys) | |
| j, ok := skipValue(body, i) | |
| if !ok { | |
| return res | |
| } | |
| i = skipSpace(body, j) | |
| } else if matchAny(key, q.Top) { | |
| if v, after, ok := readStrValue(body, i); ok { | |
| res.Top[string(key)] = v | |
| i = skipSpace(body, after) | |
| } else { | |
| j, ok := skipValue(body, i) | |
| if !ok { | |
| return res | |
| } | |
| i = skipSpace(body, j) | |
| } | |
| } else { | |
| j, ok := skipValue(body, i) | |
| if !ok { | |
| return res | |
| } | |
| i = skipSpace(body, j) | |
| } | |
| if i >= len(body) { | |
| return res | |
| } | |
| switch body[i] { | |
| case ',': | |
| i++ | |
| case '}': | |
| res.Ok = true | |
| return res | |
| default: | |
| return res | |
| } | |
| } | |
| } | |
| // collect 在 body[i] 处的对象里收集 keys 的字符串值(未命中留空)。 | |
| func collect(body []byte, i int, keys []string) map[string]string { | |
| out := map[string]string{} | |
| i = skipSpace(body, i) | |
| if i >= len(body) || body[i] != '{' { | |
| return out | |
| } | |
| i++ | |
| for { | |
| i = skipSpace(body, i) | |
| if i >= len(body) || body[i] == '}' { | |
| return out | |
| } | |
| key, next, ok := readKey(body, i) | |
| if !ok { | |
| return out | |
| } | |
| i = skipSpace(body, next) | |
| if i >= len(body) || body[i] != ':' { | |
| return out | |
| } | |
| i = skipSpace(body, i+1) | |
| if matchAny(key, keys) { | |
| if v, after, ok := readStrValue(body, i); ok { | |
| out[string(key)] = v | |
| i = skipSpace(body, after) | |
| } else { | |
| j, ok := skipValue(body, i) | |
| if !ok { | |
| return out | |
| } | |
| i = skipSpace(body, j) | |
| } | |
| } else { | |
| j, ok := skipValue(body, i) | |
| if !ok { | |
| return out | |
| } | |
| i = skipSpace(body, j) | |
| } | |
| if i >= len(body) { | |
| return out | |
| } | |
| switch body[i] { | |
| case ',': | |
| i++ | |
| case '}': | |
| return out | |
| default: | |
| return out | |
| } | |
| } | |
| } | |
| // TopLevelString 取顶层对象里某个键的字符串值(便捷入口;查多个键时直接用 Lookup)。 | |
| func TopLevelString(body []byte, key string) (string, bool) { | |
| res := Lookup(body, Query{Top: []string{key}}) | |
| if !res.Ok { | |
| return "", false | |
| } | |
| v, ok := res.Top[key] | |
| return v, ok | |
| } | |
| // NestedString 取顶层对象.objKey 这个子对象里 key 的字符串值。 | |
| func NestedString(body []byte, objKey, key string) (string, bool) { | |
| res := Lookup(body, Query{Nested: objKey, NestedKeys: []string{key}}) | |
| if !res.Ok { | |
| return "", false | |
| } | |
| v, ok := res.Nested[key] | |
| return v, ok | |
| } | |
| // FirstMessageRole 取 messages[0].role。语义与整树解析一致: | |
| // messages 不是非空数组 / 首元素不是对象 / role 缺失或不是字符串 → ok=false。 | |
| func FirstMessageRole(body []byte) (string, bool) { | |
| i := skipSpace(body, 0) | |
| if i >= len(body) || body[i] != '{' { | |
| return "", false | |
| } | |
| i++ | |
| for { | |
| i = skipSpace(body, i) | |
| if i >= len(body) || body[i] == '}' { | |
| return "", false | |
| } | |
| key, next, ok := readKey(body, i) | |
| if !ok { | |
| return "", false | |
| } | |
| i = skipSpace(body, next) | |
| if i >= len(body) || body[i] != ':' { | |
| return "", false | |
| } | |
| i = skipSpace(body, i+1) | |
| if string(key) == "messages" { | |
| i = skipSpace(body, i) | |
| if i >= len(body) || body[i] != '[' { | |
| return "", false | |
| } | |
| i = skipSpace(body, i+1) | |
| if i < len(body) && body[i] == ']' { | |
| return "", false | |
| } | |
| first := collect(body, i, []string{"role"}) | |
| role, ok := first["role"] | |
| return role, ok | |
| } | |
| j, ok := skipValue(body, i) | |
| if !ok { | |
| return "", false | |
| } | |
| i = skipSpace(body, j) | |
| if i >= len(body) { | |
| return "", false | |
| } | |
| switch body[i] { | |
| case ',': | |
| i++ | |
| case '}': | |
| return "", false | |
| default: | |
| return "", false | |
| } | |
| } | |
| } | |
| // IsObject 报告扫描器能否完整走完这个 body 的顶层对象。 | |
| // | |
| // 用途:调用方用它决定「扫描结果可信」还是「回落整树解析」。走不通说明 body | |
| // 不是合法对象或形态超出本包假设——此时不要相信「没找到键」的结论。 | |
| func IsObject(body []byte) bool { | |
| i := skipSpace(body, 0) | |
| if i >= len(body) || body[i] != '{' { | |
| return false | |
| } | |
| i++ | |
| for { | |
| i = skipSpace(body, i) | |
| if i >= len(body) { | |
| return false | |
| } | |
| if body[i] == '}' { | |
| return true | |
| } | |
| _, next, ok := readKey(body, i) | |
| if !ok { | |
| return false | |
| } | |
| i = skipSpace(body, next) | |
| if i >= len(body) || body[i] != ':' { | |
| return false | |
| } | |
| j, ok := skipValue(body, i+1) | |
| if !ok { | |
| return false | |
| } | |
| i = skipSpace(body, j) | |
| if i >= len(body) { | |
| return false | |
| } | |
| switch body[i] { | |
| case ',': | |
| i++ | |
| case '}': | |
| return true | |
| default: | |
| return false | |
| } | |
| } | |
| } | |
| // matchAny 报告 key 是否在 want 里。 | |
| func matchAny(key []byte, want []string) bool { | |
| for _, w := range want { | |
| if string(key) == w { | |
| return true | |
| } | |
| } | |
| return false | |
| } | |
| // skipSpace 跳过 JSON 空白。 | |
| func skipSpace(b []byte, i int) int { | |
| for i < len(b) { | |
| switch b[i] { | |
| case ' ', '\t', '\n', '\r': | |
| i++ | |
| default: | |
| return i | |
| } | |
| } | |
| return i | |
| } | |
| // readKey 读一个对象键(b[i] 必须是 '"'),返回**未解转义**的原始字节与结束偏移。 | |
| // 键几乎总是纯 ASCII,原始字节可直接与候选键比较;含转义的键由调用方按原文比较 | |
| // (对候选键无转义这一前提成立)。这里不做解码,避免为每个键付一次 Unmarshal。 | |
| func readKey(b []byte, i int) ([]byte, int, bool) { | |
| if i >= len(b) || b[i] != '"' { | |
| return nil, i, false | |
| } | |
| j := i + 1 | |
| for { | |
| n := bytes.IndexByte(b[j:], '"') | |
| if n < 0 { | |
| return nil, i, false | |
| } | |
| j += n | |
| if !escaped(b, i, j) { | |
| return b[i+1 : j], j + 1, true | |
| } | |
| j++ | |
| } | |
| } | |
| // escaped 报告 b[pos] 处的引号是否被反斜杠转义(数前面连续反斜杠的奇偶)。 | |
| func escaped(b []byte, start, pos int) bool { | |
| bs := 0 | |
| for k := pos - 1; k > start && b[k] == '\\'; k-- { | |
| bs++ | |
| } | |
| return bs%2 == 1 | |
| } | |
| // readStrValue 读一个字符串值并解转义。b[i] 必须是 '"'。 | |
| func readStrValue(b []byte, i int) (string, int, bool) { | |
| raw, end, ok := readKey(b, i) | |
| if !ok { | |
| return "", i, false | |
| } | |
| // 快路径只处理「无转义 + 合法 UTF-8」的字符串(绝大多数情况)。 | |
| // 其余一律交给 encoding/json:它会把非法 UTF-8 字节替换成 U+FFFD、把 \uXXXX | |
| // 解成对应字符——直接 string(raw) 会漏掉前者(fuzz 抓到的真实差异)。 | |
| if bytes.IndexByte(raw, '\\') < 0 && utf8.Valid(raw) { | |
| return string(raw), end, true | |
| } | |
| var s string | |
| if err := json.Unmarshal(b[i:end], &s); err != nil { | |
| return "", i, false | |
| } | |
| return s, end, true | |
| } | |
| // skipString 跳过一个字符串(不解转义、不分配),返回结束偏移。 | |
| func skipString(b []byte, i int) (int, bool) { | |
| if i >= len(b) || b[i] != '"' { | |
| return i, false | |
| } | |
| j := i + 1 | |
| for { | |
| n := bytes.IndexByte(b[j:], '"') | |
| if n < 0 { | |
| return i, false | |
| } | |
| j += n | |
| if !escaped(b, i, j) { | |
| return j + 1, true | |
| } | |
| j++ | |
| } | |
| } | |
| // skipValue 从 b[i] 起跳过一个完整 JSON 值,返回其后的偏移。零分配、不解转义。 | |
| func skipValue(b []byte, i int) (int, bool) { | |
| i = skipSpace(b, i) | |
| if i >= len(b) { | |
| return i, false | |
| } | |
| switch b[i] { | |
| case '"': | |
| return skipString(b, i) | |
| case '{', '[': | |
| depth := 0 | |
| for i < len(b) { | |
| switch b[i] { | |
| case '"': | |
| next, ok := skipString(b, i) | |
| if !ok { | |
| return i, false | |
| } | |
| i = next | |
| continue | |
| case '{', '[': | |
| depth++ | |
| case '}', ']': | |
| depth-- | |
| if depth == 0 { | |
| return i + 1, true | |
| } | |
| } | |
| i++ | |
| } | |
| return i, false | |
| default: | |
| // 数字 / true / false / null:扫到分隔符为止。 | |
| start := i | |
| for i < len(b) { | |
| switch b[i] { | |
| case ',', '}', ']', ' ', '\t', '\n', '\r': | |
| if i == start { | |
| return i, false | |
| } | |
| return i, true | |
| } | |
| i++ | |
| } | |
| return i, i > start | |
| } | |
| } | |
| // Validate 只在测试里用:确认扫描器与整树解析对同一 body 的判定一致。 | |
| func Validate(body []byte) error { | |
| var obj map[string]any | |
| if err := json.Unmarshal(body, &obj); err != nil { | |
| return nil // 坏 body 不是本函数的关注点 | |
| } | |
| keys := []string{"model", "conversation_id", "conversationId", "user_id", "prompt_cache_key"} | |
| res := Lookup(body, Query{Top: keys}) | |
| if !res.Ok { | |
| return fmt.Errorf("scanner could not walk object: %s", body) | |
| } | |
| for _, k := range keys { | |
| want, _ := obj[k].(string) | |
| if want != res.Top[k] { | |
| return fmt.Errorf("key %q: got %q want %q", k, res.Top[k], want) | |
| } | |
| } | |
| return nil | |
| } | |