ntfy/server/topic.go

102 lines
2.1 KiB
Go
Raw Normal View History

2021-10-23 03:26:01 +02:00
package server
import (
"context"
"log"
"math/rand"
"sync"
"time"
)
2021-10-24 04:49:50 +02:00
// topic represents a channel to which subscribers can subscribe, and publishers
// can publish a message
2021-10-23 03:26:01 +02:00
type topic struct {
id string
subscribers map[int]subscriber
2021-10-29 19:58:14 +02:00
messages []*message
2021-10-23 03:26:01 +02:00
last time.Time
2021-10-23 21:22:17 +02:00
ctx context.Context
cancel context.CancelFunc
mu sync.Mutex
2021-10-23 03:26:01 +02:00
}
2021-10-24 04:49:50 +02:00
// subscriber is a function that is called for every new message on a topic
2021-10-23 03:26:01 +02:00
type subscriber func(msg *message) error
// newTopic creates a new topic
2021-10-23 03:26:01 +02:00
func newTopic(id string) *topic {
ctx, cancel := context.WithCancel(context.Background())
return &topic{
id: id,
subscribers: make(map[int]subscriber),
2021-11-02 19:08:21 +01:00
messages: make([]*message, 0),
2021-10-23 03:26:01 +02:00
last: time.Now(),
ctx: ctx,
cancel: cancel,
}
}
func (t *topic) Subscribe(s subscriber) int {
t.mu.Lock()
defer t.mu.Unlock()
subscriberID := rand.Int()
t.subscribers[subscriberID] = s
t.last = time.Now()
return subscriberID
}
2021-10-29 19:58:14 +02:00
func (t *topic) Unsubscribe(id int) {
2021-10-23 03:26:01 +02:00
t.mu.Lock()
defer t.mu.Unlock()
delete(t.subscribers, id)
}
func (t *topic) Publish(m *message) error {
t.mu.Lock()
defer t.mu.Unlock()
t.last = time.Now()
2021-10-29 19:58:14 +02:00
t.messages = append(t.messages, m)
2021-10-23 03:26:01 +02:00
for _, s := range t.subscribers {
if err := s(m); err != nil {
log.Printf("error publishing message to subscriber")
2021-10-23 03:26:01 +02:00
}
}
return nil
}
2021-10-29 19:58:14 +02:00
func (t *topic) Messages(since time.Time) []*message {
t.mu.Lock()
defer t.mu.Unlock()
messages := make([]*message, 0) // copy!
for _, m := range t.messages {
msgTime := time.Unix(m.Time, 0)
if msgTime == since || msgTime.After(since) {
messages = append(messages, m)
}
}
return messages
}
func (t *topic) Prune(keep time.Duration) {
t.mu.Lock()
defer t.mu.Unlock()
for i, m := range t.messages {
msgTime := time.Unix(m.Time, 0)
if time.Since(msgTime) < keep {
t.messages = t.messages[i:]
return
}
}
t.messages = make([]*message, 0)
}
func (t *topic) Stats() (subscribers int, messages int) {
t.mu.Lock()
defer t.mu.Unlock()
2021-10-29 19:58:14 +02:00
return len(t.subscribers), len(t.messages)
}
2021-10-23 03:26:01 +02:00
func (t *topic) Close() {
t.cancel()
}