149 lines
3.7 KiB
Go
149 lines
3.7 KiB
Go
package model
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"sort"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Timeline encapsulates a collection of ordered Messages, and a mechanism to access them
|
|
// in a threadsafe manner.
|
|
type Timeline struct {
|
|
Messages []Message
|
|
SignedGroupID []byte
|
|
lock sync.Mutex
|
|
|
|
// a cache to allow quick checks for existing messages...
|
|
signatureCache map[string]bool
|
|
}
|
|
|
|
// Message is a local representation of a given message sent over a group chat channel.
|
|
type Message struct {
|
|
Timestamp time.Time
|
|
Received time.Time
|
|
PeerID string
|
|
Message string
|
|
Signature []byte
|
|
PreviousMessageSig []byte
|
|
ReceivedByServer bool // messages sent to a server
|
|
Acknowledged bool // peer to peer
|
|
Error string `json:",omitempty"`
|
|
// Application specific flags, useful for storing small amounts of metadata
|
|
Flags uint64
|
|
}
|
|
|
|
// MessageBaseSize 2021.06 byte size of an *empty* message json serialized
|
|
const MessageBaseSize float64 = 463
|
|
|
|
// compareSignatures checks if a and b are equal. Note: this function does
|
|
// not need to be constant time - in fact it is better that it is not as it's only main use
|
|
// is in sorting timeline state consistently.
|
|
func compareSignatures(a []byte, b []byte) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := range a {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// GetMessages returns a copy of the entire timeline
|
|
func (t *Timeline) GetMessages() []Message {
|
|
t.lock.Lock()
|
|
messages := make([]Message, len(t.Messages))
|
|
copy(messages[:], t.Messages[:])
|
|
t.lock.Unlock()
|
|
return messages
|
|
}
|
|
|
|
// GetCopy returns a duplicate of the Timeline
|
|
func (t *Timeline) GetCopy() *Timeline {
|
|
t.lock.Lock()
|
|
defer t.lock.Unlock()
|
|
newt := &Timeline{}
|
|
// initialize the timeline and copy the message over...
|
|
newt.SetMessages(t.Messages)
|
|
return newt
|
|
}
|
|
|
|
// SetMessages sets the Messages of this timeline. Only to be used in loading/initialization
|
|
func (t *Timeline) SetMessages(messages []Message) {
|
|
t.lock.Lock()
|
|
defer t.lock.Unlock()
|
|
t.init()
|
|
t.Messages = messages
|
|
for _, message := range t.Messages {
|
|
t.signatureCache[base64.StdEncoding.EncodeToString(message.Signature)] = true
|
|
}
|
|
}
|
|
|
|
// Len gets the length of the timeline
|
|
func (t *Timeline) Len() int {
|
|
return len(t.Messages)
|
|
}
|
|
|
|
// Swap swaps 2 Messages on the timeline.
|
|
func (t *Timeline) Swap(i, j int) {
|
|
t.Messages[i], t.Messages[j] = t.Messages[j], t.Messages[i]
|
|
}
|
|
|
|
// Less checks 2 Messages (i and j) in the timeline and returns true if i occurred before j, else false
|
|
func (t *Timeline) Less(i, j int) bool {
|
|
|
|
if t.Messages[i].Timestamp.Before(t.Messages[j].Timestamp) {
|
|
return true
|
|
}
|
|
|
|
// Short circuit false if j is before i, signature checks will give a wrong order in this case.
|
|
if t.Messages[j].Timestamp.Before(t.Messages[i].Timestamp) {
|
|
return false
|
|
}
|
|
|
|
if compareSignatures(t.Messages[i].PreviousMessageSig, t.SignedGroupID) {
|
|
return true
|
|
}
|
|
|
|
if compareSignatures(t.Messages[i].Signature, t.Messages[j].PreviousMessageSig) {
|
|
return true
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
// Sort sorts the timeline in a canonical order.
|
|
func (t *Timeline) Sort() {
|
|
t.lock.Lock()
|
|
defer t.lock.Unlock()
|
|
|
|
sort.Sort(t)
|
|
}
|
|
|
|
// Insert a message into the timeline in a thread safe way.
|
|
func (t *Timeline) Insert(mi *Message) bool {
|
|
t.lock.Lock()
|
|
defer t.lock.Unlock()
|
|
|
|
// assert timeline is initialized
|
|
t.init()
|
|
|
|
_, exists := t.signatureCache[base64.StdEncoding.EncodeToString(mi.Signature)]
|
|
if exists {
|
|
return true
|
|
}
|
|
|
|
t.Messages = append(t.Messages, *mi)
|
|
t.signatureCache[base64.StdEncoding.EncodeToString(mi.Signature)] = true
|
|
return false
|
|
}
|
|
|
|
func (t *Timeline) init() {
|
|
// only allow this setting once...
|
|
if t.signatureCache == nil {
|
|
t.signatureCache = make(map[string]bool)
|
|
}
|
|
}
|