Merge pull request #9 from willdot/persist

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 > -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)
 	}

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

···
 
 	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 (
+	"sync"
+)
+
+// Memory store allows messages to be stored in memory
+type MemoryStore struct {
+	mu         sync.Mutex
+	msgs       map[int]message
+	nextOffset int
+}
+
+// New memory store initializes a new in memory store
+func NewMemoryStore() *MemoryStore {
+	return &MemoryStore{
+		msgs: make(map[int]message),
+	}
+}
+
+// Write will write the provided message to the in memory store
+func (m *MemoryStore) Write(msg message) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	m.msgs[m.nextOffset] = msg
+
+	m.nextOffset++
+
+	return nil
+}
+
+// ReadFrom will read messages from (and including) the provided offset and pass them to the provided handler
+func (m *MemoryStore) ReadFrom(offset int, handleFunc func(msg message)) {
+	if offset < 0 || offset >= m.nextOffset {
+		return
+	}
+
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for i := offset; i < len(m.msgs); i++ {
+		handleFunc(m.msgs[i])
+	}
+}

server/server.go

···
 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 (
+	Beginning StartAtType = 0
+	Current   StartAtType = 1
+	From      StartAtType = 2
+)
 
 // Server accepts subscribe and publish connections and passes messages around
 type Server struct {
···
 			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:
+			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 Beginning:
+			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 {
-	topic string
-	data  []byte
-}
-
 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{
-				topic: topicStr,
-				data:  dataBuf,
+			topic := s.getTopic(topicStr)
+			if topic == nil {
+				topic = newTopic(topicStr)
+				s.topics[topicStr] = topic
+			}
+
+			message := newMessage(dataBuf)
+
+			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
 		}
 
 		_ = peer.RunConnOperation(op)
-
-		if message == nil {
-			continue
-		}
-
-		// 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)
-			}
-		}()
 	}
 }
 
-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 = newTopic(topicName)
 	}
 
-	t.subscriptions[peer.Addr()] = newSubscriber(peer, topicName, s.ackDelay, s.ackTimeout)
+	t.subscriptions[peer.Addr()] = newSubscriber(peer, t, s.ackDelay, s.ackTimeout, startAt)
 
 	s.topics[topicName] = t
 }

server/server_test.go

···
 	srv.topics[topicName] = &topic{
 		name:          topicName,
 		subscriptions: make(map[net.Addr]*subscriber),
+		messageStore:  NewMemoryStore(),
 	}
 
 	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(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(action))
+	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)
···
 
 	sendMessage(t, publisherConn, topicA, data)
 
+	// the timeout for a connection is 100 milliseconds, so we should wait at least this long before checking the unsubscribe
+	// TODO: see if theres a better way, but without this, the test is flakey
+	time.Sleep(time.Millisecond * 100)
+
 	assert.Len(t, srv.topics, 2)
 	assert.Len(t, srv.topics[topicA].subscriptions, 0)
 	assert.Len(t, srv.topics[topicB].subscriptions, 0)
···
 	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))
+	}
+
+	topic := fmt.Sprintf("topic:%s", topicA)
+
+	for _, msg := range messages {
+		sendMessage(t, publisherConn, topic, []byte(msg))
+	}
+
+	// send some messages for topic B as well
+	sendMessage(t, publisherConn, fmt.Sprintf("topic:%s", topicB), []byte("topic b message 1"))
+	sendMessage(t, publisherConn, fmt.Sprintf("topic:%s", topicB), []byte("topic b message 2"))
+	sendMessage(t, publisherConn, fmt.Sprintf("topic:%s", topicB), []byte("topic b message 3"))
+
+	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))
+	}
+
+	topic := fmt.Sprintf("topic:%s", topicA)
+
+	// send multiple messages
+	for _, msg := range messages {
+		sendMessage(t, publisherConn, topic, []byte(msg))
+	}
+
+	// send some messages for topic B as well
+	sendMessage(t, publisherConn, fmt.Sprintf("topic:%s", topicB), []byte("topic b message 1"))
+	sendMessage(t, publisherConn, fmt.Sprintf("topic:%s", topicB), []byte("topic b message 2"))
+	sendMessage(t, publisherConn, fmt.Sprintf("topic:%s", topicB), []byte("topic b message 3"))
+
+	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 *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,
-		unsubscribeCh: make(chan struct{}),
+		unsubscribeCh: make(chan struct{}, 1),
 	}
 
 	go s.sendMessages()
+
+	go func() {
+		topic.messageStore.ReadFrom(startAt, func(msg message) {
+			select {
+			case s.messages <- msg:
+				return
+			case <-s.unsubscribeCh:
+				return
+			}
+		})
+	}()
 
 	return s
 }

server/topic.go

···
 package server
 
 import (
+	"fmt"
 	"net"
 	"sync"
 )
 
+type Store interface {
+	Write(msg message) error
+	ReadFrom(offset int, handleFunc func(msg message))
+}
+
 type topic struct {
 	name          string
 	subscriptions map[net.Addr]*subscriber
 	mu            sync.Mutex
+	messageStore  Store
 }
 
 func newTopic(name string) *topic {
+	messageStore := NewMemoryStore()
 	return &topic{
 		name:          name,
 		subscriptions: make(map[net.Addr]*subscriber),
+		messageStore:  messageStore,
 	}
 }
 
-func (t *topic) sendMessageToSubscribers(msgData []byte) {
+func (t *topic) sendMessageToSubscribers(msg message) 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(msg, 0)
 	}
+
+	return nil
 }