Austin
5dd0a42002
- use sentinel failover client for group message runtime when sentinel_master_name/sentinel_addrs are configured, so seq counter reads never hit a stale replica after failover - re-seed missing redis seq counter from DB topic seqid instead of trusting the caller in-memory baseline - on unique-key conflict during async persist, re-allocate seq from DB latest, bump redis counter and fix the idempotency record so resends with the same client mid return the final seq - add uk(topic, seqid) unique keys for im_messages in tenant DDL
302 lines
10 KiB
Go
302 lines
10 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/tinode/chat/server/store/types"
|
|
)
|
|
|
|
type testGroupMessageRuntime struct {
|
|
claims map[string]*groupMessageUniqueRecord
|
|
seqs map[string]int64
|
|
shortStates map[string]bool
|
|
deletedPrefixes []string
|
|
}
|
|
|
|
func newTestGroupMessageRuntime() *testGroupMessageRuntime {
|
|
return &testGroupMessageRuntime{
|
|
claims: make(map[string]*groupMessageUniqueRecord),
|
|
seqs: make(map[string]int64),
|
|
shortStates: make(map[string]bool),
|
|
}
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) Close() error { return nil }
|
|
|
|
func (r *testGroupMessageRuntime) Claim(tenantID types.TenantID, topic string, from types.Uid, clientMsgID string) (*groupMessageUniqueRecord, bool, error) {
|
|
key := topic + ":" + from.UserId() + ":" + clientMsgID
|
|
if rec := r.claims[key]; rec != nil {
|
|
return rec, false, nil
|
|
}
|
|
rec := &groupMessageUniqueRecord{Status: "pending", CreatedAt: time.Now().UTC()}
|
|
r.claims[key] = rec
|
|
return rec, true, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) NextSeq(_ types.TenantID, topic string, baseline int64) (int64, error) {
|
|
if r.seqs[topic] < baseline {
|
|
r.seqs[topic] = baseline
|
|
}
|
|
r.seqs[topic]++
|
|
return r.seqs[topic], nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) PeekSeq(_ types.TenantID, topic string) (int64, error) {
|
|
return r.seqs[topic], nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) BumpSeqFloor(_ types.TenantID, topic string, seq int64) error {
|
|
if r.seqs[topic] < seq {
|
|
r.seqs[topic] = seq
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) MarkDone(_ types.TenantID, topic string, from types.Uid, clientMsgID string, seq int64, msgID string) error {
|
|
key := topic + ":" + from.UserId() + ":" + clientMsgID
|
|
r.claims[key] = &groupMessageUniqueRecord{Status: "done", Seq: seq, MessageID: msgID, CreatedAt: time.Now().UTC()}
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) MarkPending(_ types.TenantID, topic string, from types.Uid, clientMsgID string, seq int64) error {
|
|
key := topic + ":" + from.UserId() + ":" + clientMsgID
|
|
r.claims[key] = &groupMessageUniqueRecord{Status: "pending", Seq: seq, CreatedAt: time.Now().UTC()}
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) MarkFailed(_ types.TenantID, topic string, from types.Uid, clientMsgID string) error {
|
|
key := topic + ":" + from.UserId() + ":" + clientMsgID
|
|
r.claims[key] = &groupMessageUniqueRecord{Status: "failed", CreatedAt: time.Now().UTC()}
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) CacheHotMessage(types.TenantID, *types.Message) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) CachePendingHotMessage(types.TenantID, *types.Message) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) GetHotMessages(types.TenantID, string, *types.QueryOpt, int) ([]types.Message, bool, error) {
|
|
return nil, false, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) InvalidateHotMessages(types.TenantID, string, []types.Range) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) MarkUserOnline(types.TenantID, types.Uid, string, string, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) RefreshUserPresence(types.TenantID, types.Uid, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) MarkUserOffline(types.TenantID, types.Uid, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) GetUserPresence(types.TenantID, types.Uid) (*UserPresence, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) MarkTopicMemberOnline(types.TenantID, string, types.Uid, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) MarkTopicMemberOffline(types.TenantID, string, types.Uid, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) GetTopicNodeOnlineMembers(types.TenantID, string, string) ([]types.Uid, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) PublishGroupFanout(string, any) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) StartGroupFanoutSubscriber(context.Context, string, func([]byte)) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) PublishRealtimeFanout(string, types.TenantID, string, string, string, string, string, any) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) StartRealtimeFanoutSubscriber(context.Context, string, func(*RealtimeFanoutEnvelope)) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) CacheObject(types.TenantID, string, string, any) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) GetCachedObject(types.TenantID, string, string, any) (bool, error) {
|
|
return false, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) DeleteCachedObject(types.TenantID, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) DeleteCachedObjectsByPrefix(_ types.TenantID, _ string, prefix string) error {
|
|
r.deletedPrefixes = append(r.deletedPrefixes, prefix)
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) AddCachedSetMember(types.TenantID, string, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) RemoveCachedSetMember(types.TenantID, string, string, string) error {
|
|
return nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) CachedSetContains(types.TenantID, string, string, string) (bool, error) {
|
|
return false, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) AllowRate(types.TenantID, string, int, time.Duration) (bool, int, time.Duration, error) {
|
|
return true, 0, 0, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) ClaimShortState(namespace, id string, _ time.Duration) (bool, error) {
|
|
key := namespace + ":" + id
|
|
if r.shortStates[key] {
|
|
return false, nil
|
|
}
|
|
r.shortStates[key] = true
|
|
return true, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) ClaimShortStateValue(string, string, string, time.Duration) (bool, bool, error) {
|
|
return true, true, nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) ShortStateExists(namespace, id string) (bool, error) {
|
|
return r.shortStates[namespace+":"+id], nil
|
|
}
|
|
|
|
func (r *testGroupMessageRuntime) StoreLoginSession([]byte, LoginSession, time.Duration) error {
|
|
return nil
|
|
}
|
|
|
|
func TestLoginTokenRevocation(t *testing.T) {
|
|
oldRuntime := groupMsgRuntime
|
|
groupMsgRuntime = newTestGroupMessageRuntime()
|
|
t.Cleanup(func() { groupMsgRuntime = oldRuntime })
|
|
|
|
token := []byte("current-device-token")
|
|
if revoked, enabled, err := IsLoginTokenRevoked(7, token); err != nil || !enabled || revoked {
|
|
t.Fatalf("unexpected initial state: revoked=%v enabled=%v err=%v", revoked, enabled, err)
|
|
}
|
|
if enabled, err := RevokeLoginToken(7, token, time.Hour); err != nil || !enabled {
|
|
t.Fatalf("revoke token: enabled=%v err=%v", enabled, err)
|
|
}
|
|
if revoked, enabled, err := IsLoginTokenRevoked(7, token); err != nil || !enabled || !revoked {
|
|
t.Fatalf("revoked token was accepted: revoked=%v enabled=%v err=%v", revoked, enabled, err)
|
|
}
|
|
if revoked, _, err := IsLoginTokenRevoked(7, []byte("other-device-token")); err != nil || revoked {
|
|
t.Fatalf("other device token was revoked: revoked=%v err=%v", revoked, err)
|
|
}
|
|
}
|
|
|
|
func TestRealtimeFanoutDedupClaimIDIsNodeScoped(t *testing.T) {
|
|
tenantID := types.TenantID(7)
|
|
dedupKey := "data:p2pABC:42"
|
|
|
|
nodeA := realtimeFanoutDedupClaimID(tenantID, "pod-a", dedupKey)
|
|
nodeB := realtimeFanoutDedupClaimID(tenantID, "pod-b", dedupKey)
|
|
if nodeA == nodeB {
|
|
t.Fatalf("dedup claim id must be node-scoped: %q", nodeA)
|
|
}
|
|
if got, want := realtimeFanoutDedupClaimID(tenantID, "", dedupKey), "7:local:data:p2pABC:42"; got != want {
|
|
t.Fatalf("unexpected local fallback claim id: got %q want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestMessageRuntimeSeqAndClientMidIdempotency(t *testing.T) {
|
|
oldRuntime := groupMsgRuntime
|
|
runtime := newTestGroupMessageRuntime()
|
|
groupMsgRuntime = runtime
|
|
t.Cleanup(func() { groupMsgRuntime = oldRuntime })
|
|
|
|
tenantID := types.TenantID(7)
|
|
topic := types.Uid(1).P2PName(types.Uid(2))
|
|
from := types.Uid(1)
|
|
|
|
claim, claimed, ready, err := ClaimMessageUnique(tenantID, topic, from, "mid-1")
|
|
if err != nil || !ready || !claimed || claim == nil || claim.Status != "pending" {
|
|
t.Fatalf("unexpected first claim: claim=%#v claimed=%v ready=%v err=%v", claim, claimed, ready, err)
|
|
}
|
|
seq, ready, err := ReserveMessageSeq(tenantID, topic, 184)
|
|
if err != nil || !ready || seq != 185 {
|
|
t.Fatalf("unexpected first seq: seq=%d ready=%v err=%v", seq, ready, err)
|
|
}
|
|
if err = MarkMessageUniqueDone(tenantID, topic, from, "mid-1", seq, ""); err != nil {
|
|
t.Fatalf("mark done: %v", err)
|
|
}
|
|
|
|
claim, claimed, ready, err = ClaimMessageUnique(tenantID, topic, from, "mid-1")
|
|
if err != nil || !ready || claimed || claim == nil || claim.Seq != 185 {
|
|
t.Fatalf("unexpected duplicate claim: claim=%#v claimed=%v ready=%v err=%v", claim, claimed, ready, err)
|
|
}
|
|
|
|
claim, claimed, ready, err = ClaimMessageUnique(tenantID, topic, from, "mid-2")
|
|
if err != nil || !ready || !claimed || claim == nil {
|
|
t.Fatalf("unexpected second claim: claim=%#v claimed=%v ready=%v err=%v", claim, claimed, ready, err)
|
|
}
|
|
seq, ready, err = ReserveMessageSeq(tenantID, topic, 184)
|
|
if err != nil || !ready || seq != 186 {
|
|
t.Fatalf("unexpected second seq: seq=%d ready=%v err=%v", seq, ready, err)
|
|
}
|
|
}
|
|
|
|
func TestBumpMessageSeqFloorNeverMovesBackward(t *testing.T) {
|
|
oldRuntime := groupMsgRuntime
|
|
runtime := newTestGroupMessageRuntime()
|
|
groupMsgRuntime = runtime
|
|
t.Cleanup(func() { groupMsgRuntime = oldRuntime })
|
|
|
|
tenantID := types.TenantID(7)
|
|
topic := types.Uid(1).P2PName(types.Uid(2))
|
|
|
|
seq, ready, err := ReserveMessageSeq(tenantID, topic, 0)
|
|
if err != nil || !ready || seq != 1 {
|
|
t.Fatalf("unexpected first seq: seq=%d ready=%v err=%v", seq, ready, err)
|
|
}
|
|
if err = BumpMessageSeqFloor(tenantID, topic, 5); err != nil {
|
|
t.Fatalf("bump floor: %v", err)
|
|
}
|
|
if current, err := runtime.PeekSeq(tenantID, topic); err != nil || current != 5 {
|
|
t.Fatalf("floor was not applied: current=%d err=%v", current, err)
|
|
}
|
|
if err = BumpMessageSeqFloor(tenantID, topic, 3); err != nil {
|
|
t.Fatalf("lower bump: %v", err)
|
|
}
|
|
if current, err := runtime.PeekSeq(tenantID, topic); err != nil || current != 5 {
|
|
t.Fatalf("floor must never move backward: current=%d err=%v", current, err)
|
|
}
|
|
// The next allocation must continue above the bumped floor.
|
|
if seq, _, err := ReserveMessageSeq(tenantID, topic, 0); err != nil || seq != 6 {
|
|
t.Fatalf("unexpected seq after bump: seq=%d err=%v", seq, err)
|
|
}
|
|
}
|
|
|
|
func TestInvalidateGroupMemberPagesUsesTopicKeyPrefix(t *testing.T) {
|
|
oldRuntime := groupMsgRuntime
|
|
runtime := newTestGroupMessageRuntime()
|
|
groupMsgRuntime = runtime
|
|
t.Cleanup(func() { groupMsgRuntime = oldRuntime })
|
|
|
|
invalidateGroupMemberPages(7, "grpAlpha")
|
|
if len(runtime.deletedPrefixes) != 1 || runtime.deletedPrefixes[0] != "grpAlpha|" {
|
|
t.Fatalf("unexpected deleted prefixes: %#v", runtime.deletedPrefixes)
|
|
}
|
|
}
|