persist messages to memory store and allow subscribers to start from x when starting

example/main.go

···
 	"time"
 
 	"github.com/willdot/messagebroker/pubsub"
+	"github.com/willdot/messagebroker/server"
 )
 
 var consumeOnly *bool
+var consumeFrom *int
 
 func main() {
 	consumeOnly = flag.Bool("consume-only", false, "just consumes (doesn't start server and doesn't publish)")
+	consumeFrom = flag.Int("consume-from", -1, "index of message to start consuming from. If not set it will consume from the most recent")
 	flag.Parse()
 
 	if !*consumeOnly {
···
 	defer func() {
 		_ = sub.Close()
 	}()
+	startAt := 0
+	startAtType := server.Current
+	if *consumeFrom >= 0-1 {
+		startAtType = server.From
+		startAt = *consumeFrom
+	}
 
-	err = sub.SubscribeToTopics([]string{"topic a"})
+	err = sub.SubscribeToTopics([]string{"topic a"}, startAtType, startAt)
 	if err != nil {
 		panic(err)
 	}

example/server/main.go

···
 )
 
 func main() {
-	srv, err := server.New(":3000", time.Second, time.Second*2)
+	srv, err := server.New(":3000", time.Second, time.Second*2, server.NewMemoryStore())
 	if err != nil {
 		log.Fatal(err)
 	}

pubsub/subscriber.go

···
 }
 
 // SubscribeToTopics will subscribe to the provided topics
-func (s *Subscriber) SubscribeToTopics(topicNames []string) error {
+func (s *Subscriber) SubscribeToTopics(topicNames []string, startAtType server.StartAtType, startAtIndex int) error {
 	op := func(conn net.Conn) error {
-		actionB := make([]byte, 2)
-		binary.BigEndian.PutUint16(actionB, server.Subscribed)
-		headers := actionB
+		return subscribeToTopics(conn, topicNames, startAtType, startAtIndex)
+	}
+
+	return s.connOperation(op)
+}
 
-		b, err := json.Marshal(topicNames)
-		if err != nil {
-			return fmt.Errorf("failed to marshal topic names: %w", err)
-		}
+// UnsubscribeToTopics will unsubscribe to the provided topics
+func (s *Subscriber) UnsubscribeToTopics(topicNames []string) error {
+	op := func(conn net.Conn) error {
+		return unsubscribeToTopics(conn, topicNames)
+	}
 
-		topicNamesB := make([]byte, 4)
-		binary.BigEndian.PutUint32(topicNamesB, uint32(len(b)))
-		headers = append(headers, topicNamesB...)
+	return s.connOperation(op)
+}
+
+func subscribeToTopics(conn net.Conn, topicNames []string, startAtType server.StartAtType, startAtIndex int) error {
+	actionB := make([]byte, 2)
+	binary.BigEndian.PutUint16(actionB, uint16(server.Subscribe))
+	headers := actionB
+
+	b, err := json.Marshal(topicNames)
+	if err != nil {
+		return fmt.Errorf("failed to marshal topic names: %w", err)
+	}
+
+	topicNamesB := make([]byte, 4)
+	binary.BigEndian.PutUint32(topicNamesB, uint32(len(b)))
+	headers = append(headers, topicNamesB...)
+	headers = append(headers, b...)
+
+	startAtTypeB := make([]byte, 2)
+	binary.BigEndian.PutUint16(startAtTypeB, uint16(startAtType))
+	headers = append(headers, startAtTypeB...)
 
-		_, err = conn.Write(append(headers, b...))
-		if err != nil {
-			return fmt.Errorf("failed to subscribe to topics: %w", err)
-		}
+	if startAtType == server.From {
+		fromB := make([]byte, 2)
+		binary.BigEndian.PutUint16(fromB, uint16(startAtIndex))
+		headers = append(headers, fromB...)
+	}
 
-		var resp server.Status
-		err = binary.Read(conn, binary.BigEndian, &resp)
-		if err != nil {
-			return fmt.Errorf("failed to read confirmation of subscription: %w", err)
-		}
+	_, err = conn.Write(headers)
+	if err != nil {
+		return fmt.Errorf("failed to subscribe to topics: %w", err)
+	}
 
-		if resp == server.Subscribed {
-			return nil
-		}
+	var resp server.Status
+	err = binary.Read(conn, binary.BigEndian, &resp)
+	if err != nil {
+		return fmt.Errorf("failed to read confirmation of subscribe: %w", err)
+	}
 
-		var dataLen uint32
-		err = binary.Read(conn, binary.BigEndian, &dataLen)
-		if err != nil {
-			return fmt.Errorf("received status %s:", resp)
-		}
+	if resp == server.Subscribed {
+		return nil
+	}
 
-		buf := make([]byte, dataLen)
-		_, err = conn.Read(buf)
-		if err != nil {
-			return fmt.Errorf("received status %s:", resp)
-		}
+	var dataLen uint32
+	err = binary.Read(conn, binary.BigEndian, &dataLen)
+	if err != nil {
+		return fmt.Errorf("received status %s:", resp)
+	}
 
-		return fmt.Errorf("received status %s - %s", resp, buf)
+	buf := make([]byte, dataLen)
+	_, err = conn.Read(buf)
+	if err != nil {
+		return fmt.Errorf("received status %s:", resp)
 	}
 
-	return s.connOperation(op)
+	return fmt.Errorf("received status %s - %s", resp, buf)
 }
 
-// UnsubscribeToTopics will unsubscribe to the provided topics
-func (s *Subscriber) UnsubscribeToTopics(topicNames []string) error {
-	op := func(conn net.Conn) error {
-		actionB := make([]byte, 2)
-		binary.BigEndian.PutUint16(actionB, uint16(server.Unsubscribe))
-		headers := actionB
+func unsubscribeToTopics(conn net.Conn, topicNames []string) error {
+	actionB := make([]byte, 2)
+	binary.BigEndian.PutUint16(actionB, uint16(server.Unsubscribe))
+	headers := actionB
 
-		b, err := json.Marshal(topicNames)
-		if err != nil {
-			return fmt.Errorf("failed to marshal topic names: %w", err)
-		}
-
-		topicNamesB := make([]byte, 4)
-		binary.BigEndian.PutUint32(topicNamesB, uint32(len(b)))
-		headers = append(headers, topicNamesB...)
+	b, err := json.Marshal(topicNames)
+	if err != nil {
+		return fmt.Errorf("failed to marshal topic names: %w", err)
+	}
 
-		_, err = conn.Write(append(headers, b...))
-		if err != nil {
-			return fmt.Errorf("failed to unsubscribe to topics: %w", err)
-		}
+	topicNamesB := make([]byte, 4)
+	binary.BigEndian.PutUint32(topicNamesB, uint32(len(b)))
+	headers = append(headers, topicNamesB...)
 
-		var resp server.Status
-		err = binary.Read(conn, binary.BigEndian, &resp)
-		if err != nil {
-			return fmt.Errorf("failed to read confirmation of unsubscription: %w", err)
-		}
+	_, err = conn.Write(append(headers, b...))
+	if err != nil {
+		return fmt.Errorf("failed to unsubscribe to topics: %w", err)
+	}
 
-		if resp == server.Unsubscribed {
-			return nil
-		}
+	var resp server.Status
+	err = binary.Read(conn, binary.BigEndian, &resp)
+	if err != nil {
+		return fmt.Errorf("failed to read confirmation of unsubscribe: %w", err)
+	}
 
-		var dataLen uint32
-		err = binary.Read(conn, binary.BigEndian, &dataLen)
-		if err != nil {
-			return fmt.Errorf("received status %s:", resp)
-		}
+	if resp == server.Unsubscribed {
+		return nil
+	}
 
-		buf := make([]byte, dataLen)
-		_, err = conn.Read(buf)
-		if err != nil {
-			return fmt.Errorf("received status %s:", resp)
-		}
+	var dataLen uint32
+	err = binary.Read(conn, binary.BigEndian, &dataLen)
+	if err != nil {
+		return fmt.Errorf("received status %s:", resp)
+	}
 
-		return fmt.Errorf("received status %s - %s", resp, buf)
+	buf := make([]byte, dataLen)
+	_, err = conn.Read(buf)
+	if err != nil {
+		return fmt.Errorf("received status %s:", resp)
 	}
 
-	return s.connOperation(op)
+	return fmt.Errorf("received status %s - %s", resp, buf)
 }
 
 // Consumer allows the consumption of messages. If during the consumer receiving messages from the

pubsub/subscriber_test.go

···
 	topicB     = "topic b"
 )
 
+type fakeStore struct {
+}
+
+func (f *fakeStore) Write(msg server.MessageToSend) error {
+	return nil
+}
+func (f *fakeStore) ReadFrom(offset int, handleFunc func(msgs []server.MessageToSend)) error {
+	return nil
+}
+
 func createServer(t *testing.T) {
-	server, err := server.New(serverAddr, time.Millisecond*100, time.Millisecond*100)
+	fs := &fakeStore{}
+	server, err := server.New(serverAddr, time.Millisecond*100, time.Millisecond*100, fs)
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
···
 
 	topics := []string{topicA, topicB}
 
-	err = sub.SubscribeToTopics(topics)
+	err = sub.SubscribeToTopics(topics, server.Current, 0)
 	require.NoError(t, err)
 }
 
···
 
 	topics := []string{topicA, topicB}
 
-	err = sub.SubscribeToTopics(topics)
+	err = sub.SubscribeToTopics(topics, server.Current, 0)
 	require.NoError(t, err)
 
 	err = sub.UnsubscribeToTopics([]string{topicA})
···
 
 	topics := []string{topicA, topicB}
 
-	err = sub.SubscribeToTopics(topics)
+	err = sub.SubscribeToTopics(topics, server.Current, 0)
 	require.NoError(t, err)
 
 	ctx, cancel := context.WithCancel(context.Background())

server/message_store.go

···
+package server
+
+import (
+	"fmt"
+	"sync"
+)
+
+type MemoryStore struct {
+	mu     sync.Mutex
+	msgs   map[int]MessageToSend
+	offset int
+}
+
+func NewMemoryStore() *MemoryStore {
+	return &MemoryStore{
+		msgs: make(map[int]MessageToSend),
+	}
+}
+
+func (m *MemoryStore) Write(msg MessageToSend) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	m.msgs[m.offset] = msg
+
+	m.offset++
+
+	return nil
+}
+
+func (m *MemoryStore) ReadFrom(offset int, handleFunc func(msgs []MessageToSend)) error {
+	if offset < 0 || offset > m.offset {
+		return fmt.Errorf("invalid offset provided")
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	msgs := make([]MessageToSend, 0, len(m.msgs))
+	for i := offset; i < len(m.msgs); i++ {
+		msgs = append(msgs, m.msgs[i])
+	}
+
+	handleFunc(msgs)
+
+	return nil
+}

server/server.go

···
 	Nack        Action = 5
 )
 
+func (a Action) String() string {
+	switch a {
+	case Subscribe:
+		return "subscribe"
+	case Unsubscribe:
+		return "unsubscribe"
+	case Publish:
+		return "publish"
+	case Ack:
+		return "ack"
+	case Nack:
+		return "nack"
+	}
+
+	return ""
+}
+
 // Status represents the status of a request
 type Status uint16
 
 const (
-	Subscribed   = 1
-	Unsubscribed = 2
-	Error        = 3
+	Subscribed   Status = 1
+	Unsubscribed Status = 2
+	Error        Status = 3
 )
 
 func (s Status) String() string {
···
 	return ""
 }
 
+// StartAtType represents where the subcriber wishes to start subscribing to a topic from
+type StartAtType uint16
+
+const (
+	Begining StartAtType = 0
+	Current  StartAtType = 1
+	From     StartAtType = 2
+)
+
+type Store interface {
+	Write(msg MessageToSend) error
+	ReadFrom(offset int, handleFunc func(msgs []MessageToSend)) error
+}
+
 // Server accepts subscribe and publish connections and passes messages around
 type Server struct {
 	Addr string
···
 
 	ackDelay   time.Duration
 	ackTimeout time.Duration
+
+	messageStore Store
 }
 
 // New creates and starts a new server
-func New(Addr string, ackDelay, ackTimeout time.Duration) (*Server, error) {
+func New(Addr string, ackDelay, ackTimeout time.Duration, messageStore Store) (*Server, error) {
 	lis, err := net.Listen("tcp", Addr)
 	if err != nil {
 		return nil, fmt.Errorf("failed to listen: %w", err)
 	}
 
 	srv := &Server{
-		lis:        lis,
-		topics:     map[string]*topic{},
-		ackDelay:   ackDelay,
-		ackTimeout: ackTimeout,
+		lis:          lis,
+		topics:       map[string]*topic{},
+		ackDelay:     ackDelay,
+		ackTimeout:   ackTimeout,
+		messageStore: messageStore,
 	}
 
 	go srv.start()
···
 		}
 
 		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())
···
 			return nil
 		}
 
-		s.subscribeToTopics(peer, topics)
+		var startAtType StartAtType
+		err = binary.Read(conn, binary.BigEndian, &startAtType)
+		if err != nil {
+			slog.Error(err.Error(), "peer", peer.Addr())
+			writeStatus(Error, "invalid start at type provided", conn)
+			return nil
+		}
+		var startAt int
+		switch startAtType {
+		case From:
+			// read the from
+			var s uint16
+			err = binary.Read(conn, binary.BigEndian, &s)
+			if err != nil {
+				slog.Error(err.Error(), "peer", peer.Addr())
+				writeStatus(Error, "invalid start at value provided", conn)
+				return nil
+			}
+			startAt = int(s)
+		case Begining:
+			startAt = 0
+		case Current:
+			startAt = -1
+		default:
+			slog.Error("invalid start up type provided", "start up type", startAtType)
+			writeStatus(Error, "invalid start up type provided", conn)
+			return nil
+		}
+
+		s.subscribeToTopics(peer, topics, startAt)
 		writeStatus(Subscribed, "", conn)
 
 		return nil
···
 	_ = peer.RunConnOperation(op)
 }
 
-type messageToSend struct {
+type MessageToSend struct {
 	topic string
 	data  []byte
 }
···
 func (s *Server) handlePublish(peer *peer.Peer) {
 	slog.Info("handling publisher", "peer", peer.Addr())
 	for {
-		var message *messageToSend
+		var message *MessageToSend
 
 		op := func(conn net.Conn) error {
 			dataLen, err := dataLength(conn)
···
 				return nil
 			}
 
-			message = &messageToSend{
+			message = &MessageToSend{
 				topic: topicStr,
 				data:  dataBuf,
 			}
-			return nil
-		}
 
-		_ = peer.RunConnOperation(op)
+			topic := s.getTopic(message.topic)
+			if topic == nil {
+				topic = newTopic(message.topic, s.messageStore)
+				s.topics[message.topic] = topic
+			}
 
-		if message == nil {
-			continue
+			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)
+				return nil
+			}
+
+			return nil
 		}
 
-		// sending messages to the subscribers can be done async because the publisher doesn't need to wait for
-		// subscribers to be sent the message
-		go func() {
-			topic := s.getTopic(message.topic)
-			if topic != nil {
-				topic.sendMessageToSubscribers(message.data)
-			}
-		}()
+		_ = peer.RunConnOperation(op)
 	}
 }
 
-func (s *Server) subscribeToTopics(peer *peer.Peer, topics []string) {
+func (s *Server) subscribeToTopics(peer *peer.Peer, topics []string, startAt int) {
 	slog.Info("subscribing peer to topics", "topics", topics, "peer", peer.Addr())
 	for _, topic := range topics {
-		s.addSubsciberToTopic(topic, peer)
+		s.addSubsciberToTopic(topic, peer, startAt)
 	}
 }
 
-func (s *Server) addSubsciberToTopic(topicName string, peer *peer.Peer) {
+func (s *Server) addSubsciberToTopic(topicName string, peer *peer.Peer, startAt int) {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
 	t, ok := s.topics[topicName]
 	if !ok {
-		t = newTopic(topicName)
+		t = newTopic(topicName, s.messageStore)
 	}
 
-	t.subscriptions[peer.Addr()] = newSubscriber(peer, topicName, s.ackDelay, s.ackTimeout)
+	t.subscriptions[peer.Addr()] = newSubscriber(peer, topicName, s.ackDelay, s.ackTimeout, s.messageStore, startAt)
 
 	s.topics[topicName] = t
 }

server/server_test.go

···
 )
 
 func createServer(t *testing.T) *Server {
-	srv, err := New(serverAddr, ackDelay, ackTimeout)
+	store := NewMemoryStore()
+	srv, err := New(serverAddr, ackDelay, ackTimeout, store)
 	require.NoError(t, err)
 
 	t.Cleanup(func() {
···
 	return srv
 }
 
-func createConnectionAndSubscribe(t *testing.T, topics []string) net.Conn {
+func createConnectionAndSubscribe(t *testing.T, topics []string, startAtType StartAtType, startAtIndex int) net.Conn {
 	conn, err := net.Dial("tcp", fmt.Sprintf("localhost%s", serverAddr))
 	require.NoError(t, err)
 
-	subscribeOrUnsubscribetoTopics(t, conn, topics, Subscribe)
+	subscribeToTopics(t, conn, topics, startAtType, startAtIndex)
 
 	expectedRes := Subscribed
 
···
 	err = binary.Read(conn, binary.BigEndian, &resp)
 	require.NoError(t, err)
 
-	assert.Equal(t, expectedRes, int(resp))
+	assert.Equal(t, expectedRes, resp)
 
 	return conn
 }
···
 	require.NoError(t, err)
 }
 
-func subscribeOrUnsubscribetoTopics(t *testing.T, conn net.Conn, topics []string, action Action) {
+func subscribeToTopics(t *testing.T, conn net.Conn, topics []string, startAtType StartAtType, startAtIndex int) {
 	actionB := make([]byte, 2)
-	binary.BigEndian.PutUint16(actionB, uint16(action))
+	binary.BigEndian.PutUint16(actionB, uint16(Subscribe))
+	headers := actionB
+
+	b, err := json.Marshal(topics)
+	require.NoError(t, err)
+
+	topicNamesB := make([]byte, 4)
+	binary.BigEndian.PutUint32(topicNamesB, uint32(len(b)))
+	headers = append(headers, topicNamesB...)
+	headers = append(headers, b...)
+
+	startAtTypeB := make([]byte, 2)
+	binary.BigEndian.PutUint16(startAtTypeB, uint16(startAtType))
+	headers = append(headers, startAtTypeB...)
+
+	if startAtType == From {
+		fromB := make([]byte, 2)
+		binary.BigEndian.PutUint16(fromB, uint16(startAtIndex))
+		headers = append(headers, fromB...)
+	}
+
+	_, err = conn.Write(headers)
+	require.NoError(t, err)
+}
+
+func unsubscribetoTopics(t *testing.T, conn net.Conn, topics []string) {
+	actionB := make([]byte, 2)
+	binary.BigEndian.PutUint16(actionB, uint16(Unsubscribe))
 	headers := actionB
 
 	b, err := json.Marshal(topics)
···
 	// existing topic
 	srv := createServerWithExistingTopic(t, topicA)
 
-	_ = createConnectionAndSubscribe(t, []string{topicA, topicB})
+	_ = createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
 	assert.Len(t, srv.topics, 2)
 	assert.Len(t, srv.topics[topicA].subscriptions, 1)
···
 func TestUnsubscribesFromTopic(t *testing.T) {
 	srv := createServerWithExistingTopic(t, topicA)
 
-	conn := createConnectionAndSubscribe(t, []string{topicA, topicB, topicC})
+	conn := createConnectionAndSubscribe(t, []string{topicA, topicB, topicC}, Current, 0)
 
 	assert.Len(t, srv.topics, 3)
 	assert.Len(t, srv.topics[topicA].subscriptions, 1)
···
 
 	topics := []string{topicA, topicB}
 
-	subscribeOrUnsubscribetoTopics(t, conn, topics, Unsubscribe)
+	unsubscribetoTopics(t, conn, topics)
 
 	expectedRes := Unsubscribed
 
···
 	err := binary.Read(conn, binary.BigEndian, &resp)
 	require.NoError(t, err)
 
-	assert.Equal(t, expectedRes, int(resp))
+	assert.Equal(t, expectedRes, resp)
 
 	assert.Len(t, srv.topics, 3)
 	assert.Len(t, srv.topics[topicA].subscriptions, 0)
···
 func TestSubscriberClosesWithoutUnsubscribing(t *testing.T) {
 	srv := createServer(t)
 
-	conn := createConnectionAndSubscribe(t, []string{topicA, topicB})
+	conn := createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
 	assert.Len(t, srv.topics, 2)
 	assert.Len(t, srv.topics[topicA].subscriptions, 1)
···
 	err = binary.Read(conn, binary.BigEndian, &resp)
 	require.NoError(t, err)
 
-	assert.Equal(t, expectedRes, int(resp))
+	assert.Equal(t, expectedRes, resp)
 
 	expectedMessage := "unknown action"
 
···
 	err = binary.Read(publisherConn, binary.BigEndian, &resp)
 	require.NoError(t, err)
 
-	assert.Equal(t, expectedRes, int(resp))
+	assert.Equal(t, expectedRes, resp)
 
 	expectedMessage := "topic data does not contain 'topic:' prefix"
 
···
 
 	subscribers := make([]net.Conn, 0, 10)
 	for i := 0; i < 10; i++ {
-		subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB})
+		subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
 		subscribers = append(subscribers, subscriberConn)
 	}
···
 
 	// check the subsribers got the data
 	for _, conn := range subscribers {
-		var topicLen uint64
-		err = binary.Read(conn, binary.BigEndian, &topicLen)
-		require.NoError(t, err)
-
-		topicBuf := make([]byte, topicLen)
-		_, err = conn.Read(topicBuf)
-		require.NoError(t, err)
-		assert.Equal(t, topicA, string(topicBuf))
-
-		var dataLen uint64
-		err = binary.Read(conn, binary.BigEndian, &dataLen)
-		require.NoError(t, err)
-
-		buf := make([]byte, dataLen)
-		n, err := conn.Read(buf)
-		require.NoError(t, err)
-
-		require.Equal(t, int(dataLen), n)
-
-		assert.Equal(t, messageData, string(buf))
-
-		err = binary.Write(conn, binary.BigEndian, Ack)
-		require.NoError(t, err)
+		msg := readMessage(t, conn)
+		assert.Equal(t, messageData, string(msg))
 	}
 }
 
···
 
 	subscribeFinCh := make(chan struct{})
 	// create a subscriber that will read messages
-	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB})
+	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 	go func() {
 		// check subscriber got all messages
 		results := make([]string, 0, len(messages))
 		for i := 0; i < len(messages); i++ {
-			var topicLen uint64
-			err = binary.Read(subscriberConn, binary.BigEndian, &topicLen)
-			require.NoError(t, err)
-
-			topicBuf := make([]byte, topicLen)
-			_, err = subscriberConn.Read(topicBuf)
-			require.NoError(t, err)
-			assert.Equal(t, topicA, string(topicBuf))
-
-			var dataLen uint64
-			err = binary.Read(subscriberConn, binary.BigEndian, &dataLen)
-			require.NoError(t, err)
-
-			buf := make([]byte, dataLen)
-			n, err := subscriberConn.Read(buf)
-			require.NoError(t, err)
-			require.Equal(t, int(dataLen), n)
-
-			results = append(results, string(buf))
-
-			err = binary.Write(subscriberConn, binary.BigEndian, Ack)
-			require.NoError(t, err)
+			msg := readMessage(t, subscriberConn)
+			results = append(results, string(msg))
 		}
 
 		assert.ElementsMatch(t, results, messages)
···
 func TestSendsDataToTopicSubscriberNacksThenAcks(t *testing.T) {
 	_ = createServer(t)
 
-	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB})
+	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
 	publisherConn, err := net.Dial("tcp", fmt.Sprintf("localhost%s", serverAddr))
 	require.NoError(t, err)
···
 func TestSendsDataToTopicSubscriberDoesntAckMessage(t *testing.T) {
 	_ = createServer(t)
 
-	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB})
+	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
 	publisherConn, err := net.Dial("tcp", fmt.Sprintf("localhost%s", serverAddr))
 	require.NoError(t, err)
···
 func TestSendsDataToTopicSubscriberDeliveryCountTooHighWithNoAck(t *testing.T) {
 	_ = createServer(t)
 
-	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB})
+	subscriberConn := createConnectionAndSubscribe(t, []string{topicA, topicB}, Current, 0)
 
 	publisherConn, err := net.Dial("tcp", fmt.Sprintf("localhost%s", serverAddr))
 	require.NoError(t, err)
···
 	err = binary.Read(subscriberConn, binary.BigEndian, &topicLen)
 	require.Error(t, err)
 }
+
+func TestSubscribeAndReplaysFromStart(t *testing.T) {
+	_ = createServer(t)
+
+	publisherConn, err := net.Dial("tcp", fmt.Sprintf("localhost%s", serverAddr))
+	require.NoError(t, err)
+
+	err = binary.Write(publisherConn, binary.BigEndian, Publish)
+	require.NoError(t, err)
+
+	messages := make([]string, 0, 10)
+	for i := 0; i < 10; i++ {
+		messages = append(messages, fmt.Sprintf("message %d", i))
+	}
+
+	// send messages first
+	topic := fmt.Sprintf("topic:%s", topicA)
+
+	// send multiple messages
+	for _, msg := range messages {
+		sendMessage(t, publisherConn, topic, []byte(msg))
+	}
+
+	subscriberConn := createConnectionAndSubscribe(t, []string{topicA}, From, 0)
+	results := make([]string, 0, len(messages))
+	for i := 0; i < len(messages); i++ {
+		msg := readMessage(t, subscriberConn)
+		results = append(results, string(msg))
+	}
+	assert.ElementsMatch(t, results, messages)
+}
+
+func TestSubscribeAndReplaysFromIndex(t *testing.T) {
+	_ = createServer(t)
+
+	publisherConn, err := net.Dial("tcp", fmt.Sprintf("localhost%s", serverAddr))
+	require.NoError(t, err)
+
+	err = binary.Write(publisherConn, binary.BigEndian, Publish)
+	require.NoError(t, err)
+
+	messages := make([]string, 0, 10)
+	for i := 0; i < 10; i++ {
+		messages = append(messages, fmt.Sprintf("message %d", i))
+	}
+
+	// send messages first
+	topic := fmt.Sprintf("topic:%s", topicA)
+
+	// send multiple messages
+	for _, msg := range messages {
+		sendMessage(t, publisherConn, topic, []byte(msg))
+	}
+
+	subscriberConn := createConnectionAndSubscribe(t, []string{topicA}, From, 3)
+
+	// now that the subscriber has subecribed send another message that should arrive after all the other messages were consumed
+	sendMessage(t, publisherConn, topic, []byte("hello there"))
+
+	results := make([]string, 0, len(messages))
+	for i := 0; i < len(messages)-3; i++ {
+		msg := readMessage(t, subscriberConn)
+		results = append(results, string(msg))
+	}
+	require.Len(t, results, 7)
+	expMessages := make([]string, 0, 7)
+	for i, msg := range messages {
+		if i < 3 {
+			continue
+		}
+		expMessages = append(expMessages, msg)
+	}
+	assert.Equal(t, expMessages, results)
+
+	// now check we can get the message that was sent after the subscription was created
+	msg := readMessage(t, subscriberConn)
+	assert.Equal(t, "hello there", string(msg))
+}
+
+func readMessage(t *testing.T, subscriberConn net.Conn) []byte {
+	var topicLen uint64
+	err := binary.Read(subscriberConn, binary.BigEndian, &topicLen)
+	require.NoError(t, err)
+
+	topicBuf := make([]byte, topicLen)
+	_, err = subscriberConn.Read(topicBuf)
+	require.NoError(t, err)
+	assert.Equal(t, topicA, string(topicBuf))
+
+	var dataLen uint64
+	err = binary.Read(subscriberConn, binary.BigEndian, &dataLen)
+	require.NoError(t, err)
+
+	buf := make([]byte, dataLen)
+	n, err := subscriberConn.Read(buf)
+	require.NoError(t, err)
+	require.Equal(t, int(dataLen), n)
+
+	err = binary.Write(subscriberConn, binary.BigEndian, Ack)
+	require.NoError(t, err)
+
+	return buf
+}

server/subscriber.go

···
 	return message{data: data, deliveryCount: 1}
 }
 
-func newSubscriber(peer *peer.Peer, topic string, ackDelay, ackTimeout time.Duration) *subscriber {
+func newSubscriber(peer *peer.Peer, topic string, ackDelay, ackTimeout time.Duration, messageStore Store, startAt int) *subscriber {
 	s := &subscriber{
 		peer:          peer,
 		topic:         topic,
 		messages:      make(chan message),
 		ackDelay:      ackDelay,
 		ackTimeout:    ackTimeout,
-		unsubscribeCh: make(chan struct{}),
+		unsubscribeCh: make(chan struct{}, 1),
 	}
 
 	go s.sendMessages()
+
+	offset := startAt
+
+	go func() {
+		// here we need to replay all messages from the store for the topic.
+		err := messageStore.ReadFrom(offset, func(msgs []MessageToSend) {
+			// go func() {
+			for _, msg := range msgs {
+				s.messages <- newMessage(msg.data)
+			}
+			// }()
+		})
+		if err != nil {
+			slog.Error("failed to replay messages from offset", "error", err, "offset", offset)
+		}
+	}()
 
 	return s
 }
···
 		case <-s.unsubscribeCh:
 			return
 		case <-timer.C:
+			fmt.Printf("waiting to put message on queue: %s\n", msg.data)
 			s.messages <- msg
+			fmt.Printf("put message on queue: %s\n", msg.data)
 		}
 	}()
 }

server/topic.go

···
 package server
 
 import (
+	"fmt"
 	"net"
 	"sync"
 )
···
 	name          string
 	subscriptions map[net.Addr]*subscriber
 	mu            sync.Mutex
+	messageStore  Store
 }
 
-func newTopic(name string) *topic {
+func newTopic(name string, messageStore Store) *topic {
 	return &topic{
 		name:          name,
 		subscriptions: make(map[net.Addr]*subscriber),
+		messageStore:  messageStore,
 	}
 }
 
-func (t *topic) sendMessageToSubscribers(msgData []byte) {
+func (t *topic) sendMessageToSubscribers(msg MessageToSend) error {
+	err := t.messageStore.Write(msg)
+	if err != nil {
+		return fmt.Errorf("failed to write message to store: %w", err)
+	}
+
 	t.mu.Lock()
 	subscribers := t.subscriptions
 	t.mu.Unlock()
 
 	for _, subscriber := range subscribers {
-		subscriber.addMessage(newMessage(msgData), 0)
+		subscriber.addMessage(newMessage(msg.data), 0)
 	}
+
+	return nil
 }