448 lines
16 KiB
Go
448 lines
16 KiB
Go
package memory
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"telesrv/internal/domain"
|
||
"telesrv/internal/store"
|
||
"time"
|
||
)
|
||
|
||
type privateSendDedupKey struct {
|
||
senderUserID int64
|
||
randomID int64
|
||
}
|
||
|
||
type privateSendDedupRecord struct {
|
||
recipientUserID int64
|
||
senderSnapshot []byte
|
||
recipientMessage domain.Message
|
||
fingerprint []byte
|
||
senderDeleteEvent *domain.UpdateEvent
|
||
}
|
||
|
||
func (s *MessageStore) Create(_ context.Context, msg domain.Message) (domain.Message, error) {
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
msg.ID = s.nextBoxIDLocked(msg.OwnerUserID)
|
||
msg.UID = s.nextUID
|
||
s.nextUID++
|
||
msg.Entities = append([]domain.MessageEntity(nil), msg.Entities...)
|
||
s.m[msg.OwnerUserID] = append(s.m[msg.OwnerUserID], msg)
|
||
if s.dialogs != nil {
|
||
s.dialogs.mu.Lock()
|
||
list := s.dialogs.m[msg.OwnerUserID]
|
||
list.Messages = append(list.Messages, msg)
|
||
if msg.Peer.Type == domain.PeerTypeUser && !hasUser(list.Users, msg.Peer.ID) {
|
||
if u, ok := domain.SystemUserByID(msg.Peer.ID); ok {
|
||
list.Users = append(list.Users, u)
|
||
}
|
||
}
|
||
s.dialogs.m[msg.OwnerUserID] = list
|
||
s.dialogs.mu.Unlock()
|
||
}
|
||
return msg, nil
|
||
}
|
||
|
||
func (s *MessageStore) SendPrivateText(_ context.Context, req domain.SendPrivateTextRequest) (domain.SendPrivateTextResult, error) {
|
||
if !req.HasContent() {
|
||
return domain.SendPrivateTextResult{}, domain.ErrMessageEmpty
|
||
}
|
||
fingerprint, err := store.PrivateSendFingerprint(req)
|
||
if err != nil {
|
||
return domain.SendPrivateTextResult{}, err
|
||
}
|
||
// Match TogglePrivateNoForwards lock order; only external private-source
|
||
// replies read pair protection while holding the message mutation lock.
|
||
if r := req.ReplyTo; r != nil && r.Peer.Type == domain.PeerTypeUser && r.Peer.ID > 0 && r.Peer.ID != req.RecipientUserID {
|
||
s.noForwardsMu.Lock()
|
||
defer s.noForwardsMu.Unlock()
|
||
}
|
||
s.mu.Lock()
|
||
defer s.mu.Unlock()
|
||
return s.sendPrivateTextLocked(req, fingerprint, nil)
|
||
}
|
||
|
||
// A prefix stages related state events before the message. apply is infallible
|
||
// and only runs after all validation and receipt encoding have succeeded.
|
||
type memoryPrivateSendPrefix struct {
|
||
events []domain.UpdateEvent
|
||
apply func([]domain.UpdateEvent)
|
||
}
|
||
|
||
// Caller holds s.mu; this helper owns the dialog/event locks through commit.
|
||
func (s *MessageStore) sendPrivateTextLocked(req domain.SendPrivateTextRequest, fingerprint []byte, prefix *memoryPrivateSendPrefix) (domain.SendPrivateTextResult, error) {
|
||
if replay, found, err := s.lookupPrivateSendReplayLocked(domain.PrivateSendReplayRequest{
|
||
SenderUserID: req.SenderUserID,
|
||
RecipientUserID: req.RecipientUserID,
|
||
RandomID: req.RandomID,
|
||
IdempotencyFingerprint: fingerprint,
|
||
}); err != nil || found {
|
||
return replay, err
|
||
}
|
||
if req.Date == 0 {
|
||
req.Date = int(time.Now().Unix())
|
||
}
|
||
senderReply, recipientReply, err := s.resolveMemoryReplyLocked(req)
|
||
if err != nil {
|
||
return domain.SendPrivateTextResult{}, err
|
||
}
|
||
events := s.updateEvents
|
||
if events == nil {
|
||
return domain.SendPrivateTextResult{}, store.ErrDeliveryOutboxRequired
|
||
}
|
||
events.mu.Lock()
|
||
defer events.mu.Unlock()
|
||
// Stage counters as well as the message: failed encoding cannot consume PTS.
|
||
allocatedPTS := make(map[int64]int)
|
||
nextPTS := func(userID int64) int {
|
||
current, ok := allocatedPTS[userID]
|
||
if !ok {
|
||
current = s.nextPts[userID]
|
||
for _, event := range events.events[userID] {
|
||
if event.Pts > current {
|
||
current = event.Pts
|
||
}
|
||
}
|
||
}
|
||
allocatedPTS[userID] = current + 1
|
||
return current + 1
|
||
}
|
||
var prefixEvents []domain.UpdateEvent
|
||
if prefix != nil {
|
||
for _, event := range prefix.events {
|
||
event.Pts = nextPTS(event.UserID)
|
||
prefixEvents = append(prefixEvents, event)
|
||
}
|
||
}
|
||
uid := s.nextUID
|
||
sender := domain.Message{
|
||
ID: s.nextBox[req.SenderUserID] + 1,
|
||
UID: uid,
|
||
RandomID: req.RandomID,
|
||
OwnerUserID: req.SenderUserID,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: req.RecipientUserID},
|
||
From: domain.Peer{Type: domain.PeerTypeUser, ID: req.SenderUserID},
|
||
Date: req.Date,
|
||
Out: true,
|
||
Silent: req.Silent,
|
||
NoForwards: req.NoForwards,
|
||
Body: req.Message,
|
||
Entities: append([]domain.MessageEntity(nil), req.Entities...),
|
||
Media: cloneRequestedPeerMedia(req.Media),
|
||
ViaBotID: req.ViaBotID,
|
||
GroupedID: req.GroupedID,
|
||
Effect: req.Effect,
|
||
ReplyMarkup: cloneReplyMarkup(req.ReplyMarkup),
|
||
RichMessage: cloneRichMessage(req.RichMessage),
|
||
ReplyTo: cloneMessageReply(senderReply),
|
||
Forward: cloneMessageForward(req.Forward),
|
||
Pts: nextPTS(req.SenderUserID),
|
||
// voice/round 在发送者副本上同样保持"未听"，由对端内容已读清除。
|
||
MediaUnread: req.Media.HasUnreadPayload() && req.SenderUserID != req.RecipientUserID,
|
||
}
|
||
if req.SenderUserID == req.RecipientUserID {
|
||
sender.SavedPeer = domain.SavedPeerForSelfChat(req.SenderUserID, req.Forward)
|
||
}
|
||
recipient := domain.Message{}
|
||
if req.SenderUserID == req.RecipientUserID {
|
||
recipient = sender
|
||
}
|
||
if req.SenderUserID != req.RecipientUserID && !req.RecipientBlocked {
|
||
recipient = sender
|
||
recipient.ID = s.nextBox[req.RecipientUserID] + 1
|
||
recipient.OwnerUserID = req.RecipientUserID
|
||
recipient.Peer = domain.Peer{Type: domain.PeerTypeUser, ID: req.SenderUserID}
|
||
recipient.Out = false
|
||
recipient.ReplyTo = cloneMessageReply(recipientReply)
|
||
recipient.Media = cloneRequestedPeerMedia(sender.Media)
|
||
// recipient = sender 是值拷贝，共享 sender.ReplyMarkup 指针/Data 切片——深拷
|
||
// 让双盒各持独立快照（与 postgres 每盒独立 decode 对齐，I3/I2）。
|
||
recipient.ReplyMarkup = cloneReplyMarkup(sender.ReplyMarkup)
|
||
recipient.RichMessage = cloneRichMessage(sender.RichMessage)
|
||
recipient.Pts = nextPTS(req.RecipientUserID)
|
||
recipient.MediaUnread = req.Media.HasUnreadPayload()
|
||
}
|
||
var senderSnapshot []byte
|
||
if req.RandomID != 0 {
|
||
senderSnapshot, err = store.EncodePrivateSendSnapshot(sender)
|
||
if err != nil {
|
||
return domain.SendPrivateTextResult{}, err
|
||
}
|
||
}
|
||
// No fallible work follows: publish the prefix and message under all locks.
|
||
if prefix != nil {
|
||
prefix.apply(prefixEvents)
|
||
}
|
||
for _, event := range prefixEvents {
|
||
auth, session := [8]byte{}, int64(0)
|
||
if event.UserID == req.SenderUserID {
|
||
auth, session = req.OriginAuthKeyID, req.OriginSessionID
|
||
}
|
||
appendMemorySendEventLocked(events, event.UserID, event, auth, session)
|
||
}
|
||
s.nextUID++
|
||
s.nextBox[req.SenderUserID] = sender.ID
|
||
if recipient.ID != 0 {
|
||
s.nextBox[recipient.OwnerUserID] = recipient.ID
|
||
}
|
||
for userID, pts := range allocatedPTS {
|
||
s.nextPts[userID] = pts
|
||
}
|
||
s.m[req.SenderUserID] = append(s.m[req.SenderUserID], sender)
|
||
if req.SenderUserID != req.RecipientUserID && !req.RecipientBlocked {
|
||
s.m[req.RecipientUserID] = append(s.m[req.RecipientUserID], recipient)
|
||
}
|
||
if req.RandomID != 0 {
|
||
s.privateSendDedup[privateSendDedupKey{senderUserID: req.SenderUserID, randomID: req.RandomID}] = privateSendDedupRecord{
|
||
recipientUserID: req.RecipientUserID,
|
||
senderSnapshot: senderSnapshot,
|
||
recipientMessage: immutablePrivateSendReceipt(recipient),
|
||
fingerprint: append([]byte(nil), fingerprint...),
|
||
}
|
||
}
|
||
if s.dialogs != nil {
|
||
if recipient.ID != 0 {
|
||
s.upsertMemoryDialogsLocked(sender, recipient)
|
||
} else {
|
||
s.upsertMemoryDialogsLocked(sender, sender)
|
||
}
|
||
}
|
||
originUserID := req.OriginUserID
|
||
if originUserID == 0 {
|
||
originUserID = req.SenderUserID
|
||
}
|
||
senderExcludeAuthKeyID, senderExcludeSessionID := [8]byte{}, int64(0)
|
||
if originUserID == req.SenderUserID {
|
||
senderExcludeAuthKeyID, senderExcludeSessionID = req.OriginAuthKeyID, req.OriginSessionID
|
||
}
|
||
appendMemorySendEventLocked(events, req.SenderUserID, newMessageEvent(sender), senderExcludeAuthKeyID, senderExcludeSessionID)
|
||
if recipient.ID != 0 && recipient.OwnerUserID != sender.OwnerUserID {
|
||
recipientExcludeAuthKeyID, recipientExcludeSessionID := [8]byte{}, int64(0)
|
||
if originUserID == req.RecipientUserID {
|
||
recipientExcludeAuthKeyID, recipientExcludeSessionID = req.OriginAuthKeyID, req.OriginSessionID
|
||
}
|
||
appendMemorySendEventLocked(events, req.RecipientUserID, newMessageEvent(recipient), recipientExcludeAuthKeyID, recipientExcludeSessionID)
|
||
}
|
||
return domain.SendPrivateTextResult{
|
||
SenderMessage: cloneMessage(sender),
|
||
RecipientMessage: cloneMessage(recipient),
|
||
SenderEvent: newMessageEvent(sender),
|
||
RecipientEvent: newMessageEvent(recipient),
|
||
}, nil
|
||
}
|
||
|
||
func (s *MessageStore) nextPtsWithEventsLocked(events *UpdateEventStore, userID int64) int {
|
||
current := s.nextPts[userID]
|
||
for _, event := range events.events[userID] {
|
||
if event.Pts > current {
|
||
current = event.Pts
|
||
}
|
||
}
|
||
current++
|
||
s.nextPts[userID] = current
|
||
return current
|
||
}
|
||
|
||
func appendMemorySendEventLocked(events *UpdateEventStore, userID int64, event domain.UpdateEvent, excludeAuthKeyID [8]byte, excludeSessionID int64) {
|
||
event = events.appendLocked(userID, event, false)
|
||
events.dispatches[userID] = append(events.dispatches[userID], memoryUpdateDispatch{
|
||
Pts: event.Pts, ExcludeAuthKeyID: excludeAuthKeyID, ExcludeSessionID: excludeSessionID,
|
||
})
|
||
}
|
||
|
||
// LookupPrivateSendReplay returns an existing immutable/current replay receipt without running
|
||
// any send permission, reply resolution or allocation path.
|
||
func (s *MessageStore) LookupPrivateSendReplay(_ context.Context, req domain.PrivateSendReplayRequest) (domain.SendPrivateTextResult, bool, error) {
|
||
if req.SenderUserID == 0 || req.RecipientUserID == 0 || req.RandomID == 0 {
|
||
return domain.SendPrivateTextResult{}, false, fmt.Errorf("memory private send replay: invalid scope")
|
||
}
|
||
if err := store.ValidateSendFingerprint(req.IdempotencyFingerprint, "private send replay"); err != nil {
|
||
return domain.SendPrivateTextResult{}, false, err
|
||
}
|
||
s.mu.RLock()
|
||
defer s.mu.RUnlock()
|
||
return s.lookupPrivateSendReplayLocked(req)
|
||
}
|
||
|
||
func (s *MessageStore) lookupPrivateSendReplayLocked(req domain.PrivateSendReplayRequest) (domain.SendPrivateTextResult, bool, error) {
|
||
record, ok := s.privateSendDedup[privateSendDedupKey{senderUserID: req.SenderUserID, randomID: req.RandomID}]
|
||
if !ok {
|
||
return domain.SendPrivateTextResult{}, false, nil
|
||
}
|
||
if record.recipientUserID != req.RecipientUserID || !store.SameSendFingerprint(record.fingerprint, req.IdempotencyFingerprint) {
|
||
return domain.SendPrivateTextResult{}, false, domain.ErrMessageRandomIDDuplicate
|
||
}
|
||
firstSender, err := store.DecodePrivateSendSnapshot(record.senderSnapshot)
|
||
if err != nil {
|
||
return domain.SendPrivateTextResult{}, false, fmt.Errorf("memory duplicate private message snapshot: %w", err)
|
||
}
|
||
sender := firstSender
|
||
visible := false
|
||
for _, current := range s.m[req.SenderUserID] {
|
||
if current.UID == firstSender.UID && current.ID == firstSender.ID {
|
||
sender = cloneMessage(current)
|
||
sender.RandomID = firstSender.RandomID
|
||
visible = true
|
||
break
|
||
}
|
||
}
|
||
if !visible && record.senderDeleteEvent == nil {
|
||
return domain.SendPrivateTextResult{}, false, fmt.Errorf("memory duplicate private message %d is absent without a durable sender delete receipt", firstSender.UID)
|
||
}
|
||
recipient := cloneMessage(record.recipientMessage)
|
||
var replayDelete *domain.UpdateEvent
|
||
if record.senderDeleteEvent != nil {
|
||
cloned := cloneUpdateEvent(*record.senderDeleteEvent)
|
||
replayDelete = &cloned
|
||
}
|
||
return domain.SendPrivateTextResult{
|
||
SenderMessage: sender,
|
||
RecipientMessage: recipient,
|
||
SenderEvent: newMessageEvent(firstSender),
|
||
RecipientEvent: newMessageEvent(recipient),
|
||
Duplicate: true,
|
||
ReplayDeleteEvent: replayDelete,
|
||
}, true, nil
|
||
}
|
||
|
||
// immutablePrivateSendReceipt keeps the recipient allocation facts used by
|
||
// store-level idempotency tests. The sender response snapshot is stored as a
|
||
// versioned JSON value above so all nested media/reply graphs are immutable.
|
||
func immutablePrivateSendReceipt(msg domain.Message) domain.Message {
|
||
if msg.ID == 0 {
|
||
return domain.Message{}
|
||
}
|
||
return domain.Message{
|
||
ID: msg.ID,
|
||
UID: msg.UID,
|
||
RandomID: msg.RandomID,
|
||
OwnerUserID: msg.OwnerUserID,
|
||
Peer: msg.Peer,
|
||
From: msg.From,
|
||
Date: msg.Date,
|
||
Out: msg.Out,
|
||
Pts: msg.Pts,
|
||
}
|
||
}
|
||
|
||
func (s *MessageStore) resolveMemoryReplyLocked(req domain.SendPrivateTextRequest) (*domain.MessageReply, *domain.MessageReply, error) {
|
||
if req.ReplyTo == nil {
|
||
return nil, nil, nil
|
||
}
|
||
if err := domain.ValidateMessageReplyBounds(req.ReplyTo); err != nil {
|
||
return nil, nil, err
|
||
}
|
||
if req.ReplyTo.StoryID > 0 {
|
||
// story 回复（评论）：无源消息可查；story 作者就是会话对端，双盒同持。
|
||
reply := &domain.MessageReply{
|
||
StoryID: req.ReplyTo.StoryID,
|
||
Peer: domain.Peer{Type: domain.PeerTypeUser, ID: req.RecipientUserID},
|
||
}
|
||
return cloneMessageReply(reply), cloneMessageReply(reply), nil
|
||
}
|
||
peer := req.ReplyTo.Peer
|
||
if peer.ID == 0 {
|
||
peer = domain.Peer{Type: domain.PeerTypeUser, ID: req.RecipientUserID}
|
||
}
|
||
if peer.Type != domain.PeerTypeUser || req.ReplyTo.External != nil {
|
||
return nil, nil, domain.ErrReplyMessageIDInvalid
|
||
}
|
||
var target domain.Message
|
||
for _, msg := range s.m[req.SenderUserID] {
|
||
if msg.Peer == peer && msg.ID == req.ReplyTo.MessageID {
|
||
target = msg
|
||
break
|
||
}
|
||
}
|
||
if target.ID == 0 {
|
||
return nil, nil, domain.ErrReplyMessageIDInvalid
|
||
}
|
||
senderReply := cloneMessageReply(req.ReplyTo)
|
||
senderReply.MessageID = target.ID
|
||
senderReply.Peer = peer
|
||
if peer.ID != req.RecipientUserID {
|
||
protected := target.NoForwards || (target.Media != nil && target.Media.TTLSeconds > 0)
|
||
if pair, ok := noForwardsPair(req.SenderUserID, peer.ID); ok {
|
||
protected = protected || s.privateNoForwards[pair].Enabled()
|
||
}
|
||
if protected {
|
||
return nil, nil, domain.ErrChatForwardsRestricted
|
||
}
|
||
if err := domain.ValidateExternalReplyQuote(req.ReplyTo, target.Body); err != nil {
|
||
return nil, nil, err
|
||
}
|
||
var err error
|
||
senderReply.External, err = domain.NewMessageReplyExternal(target)
|
||
if err != nil {
|
||
return nil, nil, err
|
||
}
|
||
recipientReply := cloneMessageReply(senderReply)
|
||
if req.SenderUserID != req.RecipientUserID {
|
||
recipientReply.MessageID = 0
|
||
recipientReply.TopMessageID = 0
|
||
}
|
||
return senderReply, recipientReply, nil
|
||
}
|
||
if req.SenderUserID == req.RecipientUserID {
|
||
return senderReply, cloneMessageReply(senderReply), nil
|
||
}
|
||
for _, msg := range s.m[req.RecipientUserID] {
|
||
if msg.UID == target.UID {
|
||
recipientReply := cloneMessageReply(senderReply)
|
||
recipientReply.MessageID = msg.ID
|
||
recipientReply.Peer = domain.Peer{Type: domain.PeerTypeUser, ID: req.SenderUserID}
|
||
return senderReply, recipientReply, nil
|
||
}
|
||
}
|
||
return senderReply, nil, nil
|
||
}
|
||
|
||
func (s *MessageStore) upsertMemoryDialogsLocked(sender, recipient domain.Message) {
|
||
s.dialogs.mu.Lock()
|
||
defer s.dialogs.mu.Unlock()
|
||
list := s.dialogs.m[sender.OwnerUserID]
|
||
list = upsertMemoryDialog(list, domain.Dialog{Peer: sender.Peer, TopMessage: sender.ID, TopMessageDate: sender.Date})
|
||
// 发送方向清手动未读标记（对齐 postgres UpsertOutboxDialog 与
|
||
// channel 发送路径：向会话发出消息即视为已知晓内容）。
|
||
for i := range list.Dialogs {
|
||
if list.Dialogs[i].Peer == sender.Peer {
|
||
list.Dialogs[i].UnreadMark = false
|
||
break
|
||
}
|
||
}
|
||
list.Messages = append(list.Messages, sender)
|
||
s.dialogs.m[sender.OwnerUserID] = list
|
||
if recipient.OwnerUserID != sender.OwnerUserID {
|
||
peerList := s.dialogs.m[recipient.OwnerUserID]
|
||
peerList = upsertMemoryDialog(peerList, domain.Dialog{
|
||
Peer: recipient.Peer,
|
||
TopMessage: recipient.ID,
|
||
TopMessageDate: recipient.Date,
|
||
UnreadCount: s.privateUnreadCountLocked(recipient.OwnerUserID, recipient.Peer),
|
||
})
|
||
peerList.Messages = append(peerList.Messages, recipient)
|
||
s.dialogs.m[recipient.OwnerUserID] = peerList
|
||
}
|
||
}
|
||
|
||
func (s *MessageStore) privateUnreadCountLocked(ownerUserID int64, peer domain.Peer) int {
|
||
readMax := 0
|
||
if s.dialogs != nil {
|
||
if list, ok := s.dialogs.m[ownerUserID]; ok {
|
||
for _, dialog := range list.Dialogs {
|
||
if dialog.Peer == peer {
|
||
readMax = dialog.ReadInboxMaxID
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
unread := 0
|
||
for _, msg := range s.m[ownerUserID] {
|
||
if msg.Peer == peer && !msg.Out && msg.ID > readMax {
|
||
unread++
|
||
}
|
||
}
|
||
return unread
|
||
}
|