Tweaks

example/main.go

···
 	}()
 	startAt := 0
 	startAtType := server.Current
-	if *consumeFrom >= 0-1 {
+	if *consumeFrom > -1 {
 		startAtType = server.From
 		startAt = *consumeFrom
 	}

server/server.go

···
 	From     StartAtType = 2
 )
 
-type Store interface {
-	Write(msg MessageToSend) error
-	ReadFrom(offset int, handleFunc func(msg MessageToSend)) error
-}
-
 // Server accepts subscribe and publish connections and passes messages around
 type Server struct {
 	Addr string
···
 		}
 
 		var topics []string
-		fmt.Println(string(buf))
 		err = json.Unmarshal(buf, &topics)
 		if err != nil {
 			slog.Error("failed to unmarshal subscibers topic data", "error", err, "peer", peer.Addr())
···
 func (s *Server) handlePublish(peer *peer.Peer) {
 	slog.Info("handling publisher", "peer", peer.Addr())
 	for {
-		var message *MessageToSend
-
 		op := func(conn net.Conn) error {
 			dataLen, err := dataLength(conn)
 			if err != nil {
···
 				return nil
 			}
 
-			message = &MessageToSend{
+			message := MessageToSend{
 				topic: topicStr,
 				data:  dataBuf,
 			}
···
 				s.topics[message.topic] = topic
 			}
 
-			err = topic.sendMessageToSubscribers(*message)
+			err = topic.sendMessageToSubscribers(message)
 			if err != nil {
 				slog.Error("failed to send message to subscribers", "error", err, "peer", peer.Addr())
 				writeStatus(Error, "failed to send message to subscribers", conn)
···
 		t = newTopic(topicName)
 	}
 
-	t.subscriptions[peer.Addr()] = newSubscriber(peer, topicName, s.ackDelay, s.ackTimeout, t.messageStore, startAt)
+	t.subscriptions[peer.Addr()] = newSubscriber(peer, t, s.ackDelay, s.ackTimeout, startAt)
 
 	s.topics[topicName] = t
 }

server/subscriber.go

···
 	return message{data: data, deliveryCount: 1}
 }
 
-func newSubscriber(peer *peer.Peer, topic string, ackDelay, ackTimeout time.Duration, messageStore Store, startAt int) *subscriber {
+func newSubscriber(peer *peer.Peer, topic *topic, ackDelay, ackTimeout time.Duration, startAt int) *subscriber {
 	s := &subscriber{
 		peer:          peer,
-		topic:         topic,
+		topic:         topic.name,
 		messages:      make(chan message),
 		ackDelay:      ackDelay,
 		ackTimeout:    ackTimeout,
···
 	offset := startAt
 
 	go func() {
-		err := messageStore.ReadFrom(offset, func(msg MessageToSend) {
+		err := topic.messageStore.ReadFrom(offset, func(msg MessageToSend) {
 			s.messages <- newMessage(msg.data)
 		})
 		if err != nil {

server/topic.go

···
 	"sync"
 )
 
+type Store interface {
+	Write(msg MessageToSend) error
+	ReadFrom(offset int, handleFunc func(msg MessageToSend)) error
+}
+
 type topic struct {
 	name          string
 	subscriptions map[net.Addr]*subscriber