pebble persister

events/events.go

···
 	return obj.MarshalCBOR(cborWriter)
 }
 
+func (xevt *XRPCStreamEvent) Deserialize(r io.Reader) error {
+	var header EventHeader
+	if err := header.UnmarshalCBOR(r); err != nil {
+		return fmt.Errorf("reading header: %w", err)
+	}
+	switch header.Op {
+	case EvtKindMessage:
+		switch header.MsgType {
+		case "#commit":
+			var evt comatproto.SyncSubscribeRepos_Commit
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return fmt.Errorf("reading repoCommit event: %w", err)
+			}
+			xevt.RepoCommit = &evt
+		case "#handle":
+			var evt comatproto.SyncSubscribeRepos_Handle
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return err
+			}
+			xevt.RepoHandle = &evt
+		case "#identity":
+			var evt comatproto.SyncSubscribeRepos_Identity
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return err
+			}
+			xevt.RepoIdentity = &evt
+		case "#account":
+			var evt comatproto.SyncSubscribeRepos_Account
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return err
+			}
+			xevt.RepoAccount = &evt
+		case "#info":
+			// TODO: this might also be a LabelInfo (as opposed to RepoInfo)
+			var evt comatproto.SyncSubscribeRepos_Info
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return err
+			}
+			xevt.RepoInfo = &evt
+		case "#migrate":
+			var evt comatproto.SyncSubscribeRepos_Migrate
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return err
+			}
+			xevt.RepoMigrate = &evt
+		case "#tombstone":
+			var evt comatproto.SyncSubscribeRepos_Tombstone
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return err
+			}
+			xevt.RepoTombstone = &evt
+		case "#labels":
+			var evt comatproto.LabelSubscribeLabels_Labels
+			if err := evt.UnmarshalCBOR(r); err != nil {
+				return fmt.Errorf("reading Labels event: %w", err)
+			}
+			xevt.LabelLabels = &evt
+		}
+	case EvtKindErrorFrame:
+		var errframe ErrorFrame
+		if err := errframe.UnmarshalCBOR(r); err != nil {
+			return err
+		}
+		xevt.Error = &errframe
+	default:
+		return fmt.Errorf("unrecognized event stream type: %d", header.Op)
+	}
+	return nil
+}
+
 var ErrNoSeq = errors.New("event has no sequence number")
 
 // serialize content into Preserialized cache

events/pebblepersist.go

···
 package events
 
 import (
+	"bytes"
 	"context"
 	"encoding/binary"
 	"fmt"
···
 	}
 	blob := e.Preserialized
 
-	seq := e.Se
+	seq := e.Sequence()
+	if seq < 0 {
+		// drop event
+		// TODO: persist with longer key? {prev 8 byte key}{int32 extra counter}
+		return nil
+	}
 
 	var key [8]byte
-	binary.BigEndian.PutUint64(key, seq)
+	binary.BigEndian.PutUint64(key[:], uint64(seq))
+
+	err = pp.db.Set(key[:], blob, pebble.Sync)
 
-	return nil
+	return err
+}
+
+func eventFromPebbleIter(iter *pebble.Iterator) (*XRPCStreamEvent, error) {
+	blob, err := iter.ValueAndErr()
+	if err != nil {
+		return nil, err
+	}
+	br := bytes.NewReader(blob)
+	evt := new(XRPCStreamEvent)
+	err = evt.Deserialize(br)
+	if err != nil {
+		return nil, err
+	}
+	evt.Preserialized = bytes.Clone(blob)
+	return evt, nil
 }
+
 func (pp *PebblePersist) Playback(ctx context.Context, since int64, cb func(*XRPCStreamEvent) error) error {
+	var key [8]byte
+	binary.BigEndian.PutUint64(key[:], uint64(since))
+
+	iter, err := pp.db.NewIterWithContext(ctx, &pebble.IterOptions{LowerBound: key[:]})
+	if err != nil {
+		return err
+	}
+	defer iter.Close()
+
+	for iter.First(); iter.Valid(); iter.Next() {
+		evt, err := eventFromPebbleIter(iter)
+		if err != nil {
+			return err
+		}
+
+		err = cb(evt)
+		if err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 func (pp *PebblePersist) TakeDownRepo(ctx context.Context, usr models.Uid) error {
+	// TODO: implement filter on playback to ignore taken-down-repos?
 	return nil
 }
 func (pp *PebblePersist) Flush(context.Context) error {
-	return nil
+	return pp.db.Flush()
 }
 func (pp *PebblePersist) Shutdown(context.Context) error {
-	return nil
+	err := pp.db.Close()
+	pp.db = nil
+	return err
 }
 
 func (pp *PebblePersist) SetEventBroadcaster(broadcast func(*XRPCStreamEvent)) {
···
 }
 
 func (pp *PebblePersist) GetLast(ctx context.Context) (*XRPCStreamEvent, error) {
-
+	iter, err := pp.db.NewIterWithContext(ctx, &pebble.IterOptions{})
+	if err != nil {
+		return nil, err
+	}
+	ok := iter.Last()
+	if !ok {
+		return nil, nil
+	}
+	evt, err := eventFromPebbleIter(iter)
+	return evt, nil
 }