DrSmoothl
7d5ca5523b
Inbound person lookup used to be split across decoders, the packet pipeline, and Bridge closures. Missing identities were filled from unrelated packet headers, and "who is this person" was coupled to roster refresh and pending-request enrichment. Identity now owns both directions of resolution. The hot path stays synchronous and emits unresolved events on a miss. Only the paths that already waited before dispatch perform a network lookup, and that lookup is a profile fetch by UID rather than a member-list refresh. Pending-request comments and approval flags stay outside Identity. Decoders no longer invent a UIN from a group routing header. Private chat routing still uses a hop's own wire UIN when the hop is named that way. Inbound misses stay availability-first: they do not throw and do not mark Identity degraded.
292 lines
11 KiB
TypeScript
292 lines
11 KiB
TypeScript
// Regression for #137: inviting an official robot (e.g. 2854207029) into a
|
||
// group makes QQ push the `group_member_increase` notice TWICE, so SnowLuma
|
||
// reported two `notice.group_increase` while a normal member produced one.
|
||
// QQ NT dedups system messages in `sys_msg_mgr.cc::ProcessRecvSysMsg` by a
|
||
// global key whose per-message discriminators are msg_seq (contentHead field 5
|
||
// = head.sequence) and random (contentHead field 4 = head.msgId); kernel-based
|
||
// bots see events only after that dedup. SnowLuma reads the raw OlPush, so
|
||
// parseMsgPush must replicate the drop for routes in QQ NT's static system-
|
||
// message table, but only when given a dedup tracker (the live path). Ordinary
|
||
// chat routes remain outside that table even when their outer msgType matches.
|
||
|
||
import {
|
||
getLogLevel,
|
||
setLogLevel,
|
||
subscribeLogs,
|
||
type LogEntry,
|
||
} from '@snowluma/common/logger';
|
||
import { describe, expect, it } from 'vitest';
|
||
import type { PacketInfo } from '@snowluma/common/protocol-types';
|
||
import { protobuf_encode } from '@snowluma/proton';
|
||
import type { PushMsg, PushMsgBody } from '@snowluma/proto-defs/message';
|
||
import type { GroupChange, OnlineDeviceNotify } from '@snowluma/proto-defs/notify';
|
||
import { IdentityService } from '../../src/identity-service';
|
||
import {
|
||
deriveSysMsgDedupIdentity,
|
||
parseMsgPush,
|
||
SysMsgDedup,
|
||
type SysMsgDedupIdentity,
|
||
} from '../../src/msg-push';
|
||
|
||
const identity = IdentityService.memory('2000000001');
|
||
|
||
function pushPacket(message: PushMsgBody): PacketInfo {
|
||
return {
|
||
pid: 0,
|
||
uin: '2000000001',
|
||
serviceCmd: 'trpc.msg.olpush.OlPushService.MsgPush',
|
||
seqId: 0,
|
||
retCode: 0,
|
||
fromClient: false,
|
||
body: protobuf_encode<PushMsg>({ message }),
|
||
};
|
||
}
|
||
|
||
// A type-33 group member-increase push (the #137 shape). `memberUid` is a
|
||
// numeric string so Identity.findUinByUid returns it without a map lookup.
|
||
function memberIncreasePush(opts: { groupId: number; memberUin: number; sequence: number; msgId: number }): PacketInfo {
|
||
return pushPacket({
|
||
responseHead: { fromUin: opts.groupId, fromUid: '' },
|
||
contentHead: { msgType: 33, subType: 0, sequence: opts.sequence, timestamp: 1781540572, msgId: opts.msgId },
|
||
body: { msgContent: protobuf_encode<GroupChange>({ groupUin: opts.groupId, memberUid: String(opts.memberUin) }) },
|
||
});
|
||
}
|
||
|
||
function c2cPacket(msgType: number, subType: number): PacketInfo {
|
||
return pushPacket({
|
||
responseHead: { fromUin: 10001, fromUid: 'u_x' },
|
||
contentHead: { msgType, subType, sequence: 900, timestamp: 1781540572, msgId: 7 },
|
||
body: { richText: { elems: [{ text: { str: 'hi' } }] } },
|
||
});
|
||
}
|
||
|
||
function onlineDevicesPush(deviceName: string): PacketInfo {
|
||
return pushPacket({
|
||
responseHead: { fromUin: 2000000001, fromUid: '' },
|
||
contentHead: { msgType: 528, subType: 349, sequence: 800, timestamp: 1781540572, msgId: 555 },
|
||
body: {
|
||
msgContent: protobuf_encode<OnlineDeviceNotify>({
|
||
devices: [{ appId: 537242075, instanceId: 202, clientType: 1, platform: 3, deviceName }],
|
||
}),
|
||
},
|
||
});
|
||
}
|
||
|
||
function dedupIdentity(overrides: Partial<SysMsgDedupIdentity> = {}): SysMsgDedupIdentity {
|
||
return {
|
||
peerUid: '700',
|
||
chatType: 2,
|
||
sequence: 500,
|
||
random: 12345,
|
||
...overrides,
|
||
};
|
||
}
|
||
|
||
function deriveIdentity(opts: {
|
||
msgType: number;
|
||
subType: number;
|
||
sequence?: number;
|
||
msgId?: number;
|
||
fromUin?: number;
|
||
fromUid?: string;
|
||
}) {
|
||
return deriveSysMsgDedupIdentity({
|
||
head: {
|
||
msgType: opts.msgType,
|
||
subType: opts.subType,
|
||
c2cCmd: 0,
|
||
sequence: opts.sequence ?? 500,
|
||
ntMsgSeq: 0,
|
||
timestamp: 1781540572,
|
||
msgId: opts.msgId ?? 12345,
|
||
},
|
||
fromUin: opts.fromUin ?? 700,
|
||
fromUid: opts.fromUid ?? 'u_peer',
|
||
});
|
||
}
|
||
|
||
describe('deriveSysMsgDedupIdentity', () => {
|
||
it.each([
|
||
[528, 290],
|
||
[166, 75],
|
||
[166, 129],
|
||
[166, 131],
|
||
[166, 133],
|
||
[166, 135],
|
||
[167, 133],
|
||
])('maps native C2C route %d/%d to fromUid and chatType 1', (msgType, subType) => {
|
||
expect(deriveIdentity({ msgType, subType, fromUin: 700, fromUid: 'u_peer' })).toEqual({
|
||
peerUid: 'u_peer',
|
||
chatType: 1,
|
||
sequence: 500,
|
||
random: 12345,
|
||
});
|
||
});
|
||
|
||
it.each([
|
||
[732, 12],
|
||
[732, 16],
|
||
[732, 20],
|
||
[33, 0],
|
||
[34, 0],
|
||
[85, 0],
|
||
])('maps native group route %d/%d to decimal fromUin and chatType 2', (msgType, subType) => {
|
||
expect(deriveIdentity({ msgType, subType, fromUin: 700, fromUid: 'ignored' })).toEqual({
|
||
peerUid: '700',
|
||
chatType: 2,
|
||
sequence: 500,
|
||
random: 12345,
|
||
});
|
||
});
|
||
|
||
it('[#266] fails open for an outer package pair absent from QQ NT’s static table', () => {
|
||
expect(deriveIdentity({ msgType: 528, subType: 99 })).toBeNull();
|
||
});
|
||
|
||
it('fails open when the native sequence, random, or route-specific peer is missing', () => {
|
||
expect(deriveIdentity({ msgType: 33, subType: 0, sequence: 0 })).toBeNull();
|
||
expect(deriveIdentity({ msgType: 33, subType: 0, msgId: 0 })).toBeNull();
|
||
expect(deriveIdentity({ msgType: 33, subType: 0, fromUin: 0 })).toBeNull();
|
||
expect(deriveIdentity({ msgType: 528, subType: 290, fromUid: '' })).toBeNull();
|
||
});
|
||
});
|
||
|
||
describe('SysMsgDedup', () => {
|
||
it('flags the second push with the same native global key', () => {
|
||
const d = new SysMsgDedup();
|
||
expect(d.seenDuplicate(dedupIdentity())).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity())).toBe(true);
|
||
});
|
||
|
||
it('treats a different sequence, random, peer, or chat type as distinct', () => {
|
||
const d = new SysMsgDedup();
|
||
expect(d.seenDuplicate(dedupIdentity())).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 501 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ random: 99999 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ peerUid: '701' }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ chatType: 1 }))).toBe(false);
|
||
});
|
||
|
||
it('[#266] dedups different listed outer routes that derive the same native identity', () => {
|
||
const d = new SysMsgDedup();
|
||
const first = deriveIdentity({ msgType: 166, subType: 133 });
|
||
const alternateRoute = deriveIdentity({ msgType: 167, subType: 133 });
|
||
expect(first).not.toBeNull();
|
||
expect(alternateRoute).toEqual(first);
|
||
expect(d.seenDuplicate(first!)).toBe(false);
|
||
expect(d.seenDuplicate(alternateRoute!)).toBe(true);
|
||
});
|
||
|
||
it('[#266] does not record an unlisted outer route', () => {
|
||
const d = new SysMsgDedup();
|
||
const unlisted = deriveIdentity({ msgType: 528, subType: 99 });
|
||
const listed = deriveIdentity({ msgType: 528, subType: 290 });
|
||
expect(unlisted).toBeNull();
|
||
expect(listed).not.toBeNull();
|
||
expect(d.seenDuplicate(listed!)).toBe(false);
|
||
});
|
||
|
||
it('never dedups a manually supplied identity without a server discriminator or peer', () => {
|
||
const d = new SysMsgDedup();
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 0 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 0 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ random: 0 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ peerUid: '' }))).toBe(false);
|
||
});
|
||
|
||
it('evicts the oldest key once capacity is exceeded (bounded memory)', () => {
|
||
const d = new SysMsgDedup(2);
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 1, random: 1 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 2, random: 1 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 3, random: 1 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 1, random: 1 }))).toBe(false);
|
||
expect(d.seenDuplicate(dedupIdentity({ sequence: 3, random: 1 }))).toBe(true);
|
||
});
|
||
});
|
||
|
||
describe('parseMsgPush — system-push dedup (#137)', () => {
|
||
it('drops the second identical official-robot member-increase push', () => {
|
||
const dedup = new SysMsgDedup();
|
||
const push = () => memberIncreasePush({ groupId: 700, memberUin: 2854207029, sequence: 800, msgId: 555 });
|
||
|
||
const first = parseMsgPush(push(), identity, dedup);
|
||
expect(first).toHaveLength(1);
|
||
expect(first[0]).toMatchObject({ kind: 'group_member_join', groupId: 700, userUin: 2854207029 });
|
||
|
||
const second = parseMsgPush(push(), identity, dedup);
|
||
expect(second).toEqual([]);
|
||
});
|
||
|
||
it('traces the actual duplicate branch before returning zero events', () => {
|
||
const previousLevel = getLogLevel();
|
||
const entries: LogEntry[] = [];
|
||
setLogLevel('trace');
|
||
const unsubscribe = subscribeLogs((entry) => entries.push(entry));
|
||
try {
|
||
const dedup = new SysMsgDedup();
|
||
const push = () => memberIncreasePush({
|
||
groupId: 700,
|
||
memberUin: 2854207029,
|
||
sequence: 800,
|
||
msgId: 555,
|
||
});
|
||
expect(parseMsgPush(push(), identity, dedup)).toHaveLength(1);
|
||
expect(parseMsgPush(push(), identity, dedup)).toEqual([]);
|
||
|
||
expect(entries.filter((entry) => entry.scope === 'MsgPush' && entry.level === 'trace'))
|
||
.toEqual([
|
||
expect.objectContaining({
|
||
message: 'packet_branch serviceCmd="trpc.msg.olpush.OlPushService.MsgPush" seqId=0 branch=duplicate_system_push peer="700" chatType=2 messageSeq=800 messageRandom=555',
|
||
}),
|
||
]);
|
||
} finally {
|
||
unsubscribe();
|
||
setLogLevel(previousLevel);
|
||
}
|
||
});
|
||
|
||
it('keeps both pushes when no dedup tracker is supplied (forward re-parse path)', () => {
|
||
const push = () => memberIncreasePush({ groupId: 700, memberUin: 2854207029, sequence: 800, msgId: 555 });
|
||
expect(parseMsgPush(push(), identity)).toHaveLength(1);
|
||
expect(parseMsgPush(push(), identity)).toHaveLength(1);
|
||
});
|
||
|
||
it('keeps distinct member-increase events (different members → different seq/msgId)', () => {
|
||
const dedup = new SysMsgDedup();
|
||
const a = parseMsgPush(memberIncreasePush({ groupId: 700, memberUin: 111, sequence: 800, msgId: 555 }), identity, dedup);
|
||
const b = parseMsgPush(memberIncreasePush({ groupId: 700, memberUin: 222, sequence: 801, msgId: 556 }), identity, dedup);
|
||
expect(a).toHaveLength(1);
|
||
expect(b).toHaveLength(1);
|
||
expect(b[0]).toMatchObject({ userUin: 222 });
|
||
});
|
||
|
||
it('[#266] dedups a listed C2C route before its outer type is decoded as a chat message', () => {
|
||
const dedup = new SysMsgDedup();
|
||
expect(parseMsgPush(c2cPacket(166, 133), identity, dedup)).toHaveLength(1);
|
||
expect(parseMsgPush(c2cPacket(166, 133), identity, dedup)).toEqual([]);
|
||
});
|
||
|
||
it('[#266] records a listed undecoded route before a matching listed route is dispatched', () => {
|
||
const dedup = new SysMsgDedup();
|
||
expect(parseMsgPush(c2cPacket(167, 133), identity, dedup)).toEqual([]);
|
||
expect(parseMsgPush(c2cPacket(166, 133), identity, dedup)).toEqual([]);
|
||
});
|
||
|
||
it('does not dedup ordinary chat messages outside the native system-message table', () => {
|
||
const dedup = new SysMsgDedup();
|
||
expect(parseMsgPush(c2cPacket(166, 0), identity, dedup)).toHaveLength(1);
|
||
expect(parseMsgPush(c2cPacket(166, 0), identity, dedup)).toHaveLength(1);
|
||
});
|
||
|
||
it('does not dedup replacement state snapshots with the same server identity', () => {
|
||
const dedup = new SysMsgDedup();
|
||
|
||
expect(parseMsgPush(onlineDevicesPush('DESKTOP-A'), identity, dedup)).toMatchObject([
|
||
{ kind: 'online_devices_changed', devices: [{ deviceName: 'DESKTOP-A' }] },
|
||
]);
|
||
expect(parseMsgPush(onlineDevicesPush('DESKTOP-B'), identity, dedup)).toMatchObject([
|
||
{ kind: 'online_devices_changed', devices: [{ deviceName: 'DESKTOP-B' }] },
|
||
]);
|
||
});
|
||
});
|