session+lnrpc: add StateReserved and delete these on start up

Author: ellemouton

litrpc/lit-autopilot.swagger.json

@@ -662,7 +662,8 @@
         "STATE_CREATED",
         "STATE_IN_USE",
         "STATE_REVOKED",
-        "STATE_EXPIRED"
+        "STATE_EXPIRED",
+        "STATE_RESERVED"
       ],
       "default": "STATE_CREATED"
     },

litrpc/lit-sessions.pb.go

@@ -97,6 +97,7 @@ enum SessionState {
     STATE_IN_USE = 1;
     STATE_REVOKED = 2;
     STATE_EXPIRED = 3;
+    STATE_RESERVED = 4;
 }
 
 message AddSessionResponse {

litrpc/lit-sessions.proto

@@ -521,7 +521,8 @@
         "STATE_CREATED",
         "STATE_IN_USE",
         "STATE_REVOKED",
-        "STATE_EXPIRED"
+        "STATE_EXPIRED",
+        "STATE_RESERVED"
       ],
       "default": "STATE_CREATED"
     },

litrpc/lit-sessions.swagger.json

@@ -51,6 +51,12 @@ const (
 	// StateExpired is the state of a session that has passed its expiry
 	// date.
 	StateExpired State = 3
+
+	// StateReserved is a temporary initial state of a session. On start-up,
+	// any sessions in this state should be cleaned up.
+	//
+	// NOTE: this isn't used yet.
+	StateReserved State = 4
 )
 
 // MacaroonRecipe defines the permissions and caveats that should be used
@@ -215,5 +221,9 @@ type Store interface {
 	CheckSessionGroupPredicate(groupID ID,
 		fn func(s *Session) bool) (bool, error)
 
+	// DeleteReservedSessions deletes all sessions that are in the
+	// StateReserved state.
+	DeleteReservedSessions() error
+
 	IDToGroupIndex
 }

session/interface.go

@@ -444,6 +444,99 @@ func (db *BoltStore) listSessions(filterFn func(s *Session) bool) ([]*Session,
 	return sessions, nil
 }
 
+// DeleteReservedSessions deletes all sessions that are in the StateReserved
+// state.
+//
+// NOTE: this is part of the Store interface.
+func (db *BoltStore) DeleteReservedSessions() error {
+	return db.Update(func(tx *bbolt.Tx) error {
+		sessionBucket, err := getBucket(tx, sessionBucketKey)
+		if err != nil {
+			return err
+		}
+
+		return sessionBucket.ForEach(func(k, v []byte) error {
+			// We'll also get buckets here, skip those (identified
+			// by nil value).
+			if v == nil {
+				return nil
+			}
+
+			session, err := DeserializeSession(bytes.NewReader(v))
+			if err != nil {
+				return err
+			}
+
+			if session.State != StateReserved {
+				return nil
+			}
+
+			err = sessionBucket.Delete(k)
+			if err != nil {
+				return err
+			}
+
+			idIndexBkt := sessionBucket.Bucket(idIndexKey)
+			if idIndexBkt == nil {
+				return ErrDBInitErr
+			}
+
+			// Delete the entire session ID bucket.
+			err = idIndexBkt.DeleteBucket(session.ID[:])
+			if err != nil {
+				return err
+			}
+
+			groupIdIndexBkt := sessionBucket.Bucket(groupIDIndexKey)
+			if groupIdIndexBkt == nil {
+				return ErrDBInitErr
+			}
+
+			groupBkt := groupIdIndexBkt.Bucket(session.GroupID[:])
+			if groupBkt == nil {
+				return ErrDBInitErr
+			}
+
+			sessionIDsBkt := groupBkt.Bucket(sessionIDKey)
+			if sessionIDsBkt == nil {
+				return ErrDBInitErr
+			}
+
+			var (
+				seqKey      []byte
+				numSessions int
+			)
+			err = sessionIDsBkt.ForEach(func(k, v []byte) error {
+				numSessions++
+
+				if !bytes.Equal(v, session.ID[:]) {
+					return nil
+				}
+
+				seqKey = k
+
+				return nil
+			})
+			if err != nil {
+				return err
+			}
+
+			if numSessions == 0 {
+				return fmt.Errorf("no sessions found for "+
+					"group ID %x", session.GroupID)
+			}
+
+			if numSessions == 1 {
+				// Delete the whole group bucket.
+				return groupBkt.DeleteBucket(sessionIDKey)
+			}
+
+			// Else, delete just the session ID entry.
+			return sessionIDsBkt.Delete(seqKey)
+		})
+	})
+}
+
 // RevokeSession updates the state of the session with the given local
 // public key to be revoked.
 //

session/kvdb_store.go

@@ -142,9 +142,52 @@ func TestBasicSessionStore(t *testing.T) {
 	require.NoError(t, err)
 	require.Empty(t, sessions)
 
-	sessions, err = db.ListSessionsByState(StateInUse)
+	sessions, err = db.ListSessionsByState(StateReserved)
 	require.NoError(t, err)
 	require.Empty(t, sessions)
+
+	// Demonstrate deletion of a reserved session.
+	//
+	// Calling DeleteReservedSessions should have no effect yet since none
+	// of the sessions are reserved.
+	require.NoError(t, db.DeleteReservedSessions())
+
+	sessions, err = db.ListSessionsByState(StateReserved)
+	require.NoError(t, err)
+	require.Empty(t, sessions)
+
+	// Add a session and put it in the StateReserved state.
+	s5 := newSession(t, db, clock, "session 5", withState(StateReserved))
+	require.NoError(t, db.CreateSession(s5))
+
+	sessions, err = db.ListSessionsByState(StateReserved)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(sessions))
+	assertEqualSessions(t, s5, sessions[0])
+
+	// Show that the group ID/session ID index has also been populated with
+	// this session.
+	groupID, err := db.GetGroupID(s5.ID)
+	require.NoError(t, err)
+	require.Equal(t, s5.ID, groupID)
+
+	sessIDs, err := db.GetSessionIDs(s5.GroupID)
+	require.NoError(t, err)
+	require.Equal(t, []ID{s5.ID}, sessIDs)
+
+	// Now delete the reserved session and show that it is no longer in the
+	// database and no longer in the group ID/session ID index.
+	require.NoError(t, db.DeleteReservedSessions())
+
+	sessions, err = db.ListSessionsByState(StateReserved)
+	require.NoError(t, err)
+	require.Empty(t, sessions)
+
+	groupID, err = db.GetGroupID(s5.ID)
+	require.ErrorContains(t, err, "no index entry")
+
+	sessIDs, err = db.GetSessionIDs(s5.GroupID)
+	require.ErrorContains(t, err, "no sessions for group ID")
 }
 
 // TestLinkingSessions tests that session linking works as expected.
@@ -359,6 +402,12 @@ func withType(t Type) testSessionModifier {
 	}
 }
 
+func withState(state State) testSessionModifier {
+	return func(s *Session) {
+		s.State = state
+	}
+}
+
 func newSession(t *testing.T, db Store, clock clock.Clock, label string,
 	mods ...testSessionModifier) *Session {
 

session/store_test.go

@@ -100,6 +100,12 @@ func newSessionRPCServer(cfg *sessionRpcServerConfig) (*sessionRpcServer,
 // start all the components necessary for the sessionRpcServer to start serving
 // requests. This includes resuming all non-revoked sessions.
 func (s *sessionRpcServer) start(ctx context.Context) error {
+	// Delete all sessions in the Reserved state.
+	err := s.cfg.db.DeleteReservedSessions()
+	if err != nil {
+		return fmt.Errorf("error deleting reserved sessions: %v", err)
+	}
+
 	// Start up all previously created sessions.
 	sessions, err := s.cfg.db.ListSessionsByState(
 		session.StateCreated,
@@ -1518,6 +1524,9 @@ func marshalRPCMacaroonRecipe(
 // marshalRPCState converts a session state to its RPC counterpart.
 func marshalRPCState(state session.State) (litrpc.SessionState, error) {
 	switch state {
+	case session.StateReserved:
+		return litrpc.SessionState_STATE_RESERVED, nil
+
 	case session.StateCreated:
 		return litrpc.SessionState_STATE_CREATED, nil