Adds doc comments

Author: ashishkujoy

internal/storage/segments.go

@@ -5,6 +5,10 @@ import (
 	"sync"
 )
 
+// Segments manages multiple segments.
+// It is responsible for appending data to the active segment,
+// reading data from segments, and rolling over to a new segment
+// when the current segment is full.
 type Segments struct {
 	config         *Config
 	active         *Segment
@@ -14,6 +18,7 @@ type Segments struct {
 	mu             *sync.Mutex
 }
 
+// NewSegments creates a new Segments instance with the given configuration and index.
 func NewSegments(config *Config, index *Index) (*Segments, error) {
 	segment, err := NewSegment(0, config)
 	if err != nil {
@@ -28,6 +33,8 @@ func NewSegments(config *Config, index *Index) (*Segments, error) {
 	}, nil
 }
 
+// Append appends data to the active segment.
+// If the active segment is full, it rolls over to a new segment.
 func (s *Segments) Append(data []byte) (int, error) {
 	if s.active.isFull(s.config.maxSegmentSizeInBytes) {
 		if err := s.rollOverSegment(); err != nil {
@@ -42,6 +49,12 @@ func (s *Segments) Append(data []byte) (int, error) {
 	return messageId, nil
 }
 
+// Read reads data from the segment with the given message ID.
+// It retrieves the offset from the index and reads the data from the corresponding segment.
+// If the message ID is unknown, it returns an error.
+// If the segment is not found, it returns an error.
+// It returns the data read from the segment or an error if the operation fails.
+// It locks the segment for reading to ensure thread safety.
 func (s *Segments) Read(messageId int) ([]byte, error) {
 	entry, ok := s.index.GetOffset(messageId)
 	if !ok {
@@ -54,10 +67,12 @@ func (s *Segments) Read(messageId int) ([]byte, error) {
 	return segment.Read(entry.offset)
 }
 
+// Flush flushes any pending writes to the active segment.
 func (s *Segments) Flush() {
 	s.active.store.Flush()
 }
 
+// findSegment finds a segment by its ID.
 func (s *Segments) findSegment(segmentId int) (*Segment, error) {
 	if s.active.id == segmentId {
 		return s.active, nil
@@ -70,6 +85,9 @@ func (s *Segments) findSegment(segmentId int) (*Segment, error) {
 	return nil, fmt.Errorf("unknown segment %d", segmentId)
 }
 
+// rollOverSegment rolls over to a new segment.
+// It closes the current active segment writer,
+// appends it to the closed segments list, and creates a new active segment.
 func (s *Segments) rollOverSegment() error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -85,6 +103,8 @@ func (s *Segments) rollOverSegment() error {
 	return nil
 }
 
+// Close closes the active segment and all closed segments.
+// It flushes any pending writes to the store and releases resources.
 func (s *Segments) Close() error {
 	if err := s.active.Close(); err != nil {
 		return err