firewalldb: add ListGroupActions method

This method can be used to list actions in a session Group. Note that
actions are still stored under session IDs.

Author: ellemouton

firewalldb/actions.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"io"
 	"time"
@@ -386,6 +387,79 @@ func (db *DB) ListSessionActions(sessionID session.ID,
 	return actions, lastIndex, totalCount, nil
 }
 
+// ListGroupActions returns a list of the given session group's Actions that
+// pass the filterFn requirements.
+//
+// TODO: update to allow for pagination.
+func (db *DB) ListGroupActions(groupID session.ID,
+	filterFn ListActionsFilterFn) ([]*Action, error) {
+
+	if filterFn == nil {
+		filterFn = func(a *Action, reversed bool) (bool, bool) {
+			return true, true
+		}
+	}
+
+	sessionIDs, err := db.sessionIDIndex.GetSessionIDs(groupID)
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		actions []*Action
+		errDone = errors.New("done iterating")
+	)
+	err = db.View(func(tx *bbolt.Tx) error {
+		mainActionsBucket, err := getBucket(tx, actionsBucketKey)
+		if err != nil {
+			return err
+		}
+
+		actionsBucket := mainActionsBucket.Bucket(actionsKey)
+		if actionsBucket == nil {
+			return ErrNoSuchKeyFound
+		}
+
+		// Iterate over each session ID in this group.
+		for _, sessionID := range sessionIDs {
+			sessionsBucket := actionsBucket.Bucket(sessionID[:])
+			if sessionsBucket == nil {
+				return nil
+			}
+
+			err = sessionsBucket.ForEach(func(_, v []byte) error {
+				action, err := DeserializeAction(
+					bytes.NewReader(v), sessionID,
+				)
+				if err != nil {
+					return err
+				}
+
+				include, cont := filterFn(action, false)
+				if include {
+					actions = append(actions, action)
+				}
+
+				if !cont {
+					return errDone
+				}
+
+				return nil
+			})
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+	if err != nil && !errors.Is(err, errDone) {
+		return nil, err
+	}
+
+	return actions, nil
+}
+
 // SerializeAction binary serializes the given action to the writer using the
 // tlv format.
 func SerializeAction(w io.Writer, action *Action) error {

firewalldb/actions_test.go

@@ -5,21 +5,15 @@ import (
 	"testing"
 	"time"
 
+	"github.com/lightninglabs/lightning-terminal/session"
 	"github.com/stretchr/testify/require"
 )
 
-// TestActionStorage tests that the ActionsDB CRUD logic.
-func TestActionStorage(t *testing.T) {
-	tmpDir := t.TempDir()
+var (
+	sessionID1 = intToSessionID(1)
+	sessionID2 = intToSessionID(2)
 
-	db, err := NewDB(tmpDir, "test.db", nil)
-	require.NoError(t, err)
-	t.Cleanup(func() {
-		_ = db.Close()
-	})
-
-	sessionID1 := [4]byte{1, 1, 1, 1}
-	action1 := &Action{
+	action1 = &Action{
 		SessionID:          sessionID1,
 		ActorName:          "Autopilot",
 		FeatureName:        "auto-fees",
@@ -32,8 +26,7 @@ func TestActionStorage(t *testing.T) {
 		State:              ActionStateDone,
 	}
 
-	sessionID2 := [4]byte{2, 2, 2, 2}
-	action2 := &Action{
+	action2 = &Action{
 		SessionID:     sessionID2,
 		ActorName:     "Autopilot",
 		FeatureName:   "rebalancer",
@@ -44,6 +37,17 @@ func TestActionStorage(t *testing.T) {
 		AttemptedAt:   time.Unix(12300, 0),
 		State:         ActionStateInit,
 	}
+)
+
+// TestActionStorage tests that the ActionsDB CRUD logic.
+func TestActionStorage(t *testing.T) {
+	tmpDir := t.TempDir()
+
+	db, err := NewDB(tmpDir, "test.db", nil)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
 
 	actionsStateFilterFn := func(state ActionState) ListActionsFilterFn {
 		return func(a *Action, _ bool) (bool, bool) {
@@ -335,3 +339,91 @@ func TestListActions(t *testing.T) {
 		{sessionID2, "6"},
 	})
 }
+
+// TestListGroupActions tests that the ListGroupActions correctly returns all
+// actions in a particular session group.
+func TestListGroupActions(t *testing.T) {
+	group1 := intToSessionID(0)
+
+	// Link session 1 and session 2 to group 1.
+	index := newMockSessionIDIndex()
+	index.addPair(sessionID1, group1)
+	index.addPair(sessionID2, group1)
+
+	db, err := NewDB(t.TempDir(), "test.db", index)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		_ = db.Close()
+	})
+
+	// There should not be any actions in group 1 yet.
+	al, err := db.ListGroupActions(group1, nil)
+	require.NoError(t, err)
+	require.Empty(t, al)
+
+	// Add an action under session 1.
+	_, err = db.AddAction(sessionID1, action1)
+	require.NoError(t, err)
+
+	// There should now be one action in the group.
+	al, err = db.ListGroupActions(group1, nil)
+	require.NoError(t, err)
+	require.Len(t, al, 1)
+	require.Equal(t, sessionID1, al[0].SessionID)
+
+	// Add an action under session 2.
+	_, err = db.AddAction(sessionID2, action2)
+	require.NoError(t, err)
+
+	// There should now be actions in the group.
+	al, err = db.ListGroupActions(group1, nil)
+	require.NoError(t, err)
+	require.Len(t, al, 2)
+	require.Equal(t, sessionID1, al[0].SessionID)
+	require.Equal(t, sessionID2, al[1].SessionID)
+}
+
+type mockSessionIDIndex struct {
+	sessionToGroupID  map[session.ID]session.ID
+	groupToSessionIDs map[session.ID][]session.ID
+}
+
+var _ session.IDToGroupIndex = (*mockSessionIDIndex)(nil)
+
+func newMockSessionIDIndex() *mockSessionIDIndex {
+	return &mockSessionIDIndex{
+		sessionToGroupID:  make(map[session.ID]session.ID),
+		groupToSessionIDs: make(map[session.ID][]session.ID),
+	}
+}
+
+func (m *mockSessionIDIndex) addPair(sessionID, groupID session.ID) {
+	m.sessionToGroupID[sessionID] = groupID
+
+	m.groupToSessionIDs[groupID] = append(
+		m.groupToSessionIDs[groupID], sessionID,
+	)
+}
+
+func (m *mockSessionIDIndex) GetGroupID(sessionID session.ID) (session.ID,
+	error) {
+
+	id, ok := m.sessionToGroupID[sessionID]
+	if !ok {
+		return session.ID{}, fmt.Errorf("no group ID found for " +
+			"session ID")
+	}
+
+	return id, nil
+}
+
+func (m *mockSessionIDIndex) GetSessionIDs(groupID session.ID) ([]session.ID,
+	error) {
+
+	ids, ok := m.groupToSessionIDs[groupID]
+	if !ok {
+		return nil, fmt.Errorf("no session IDs found for group ID")
+	}
+
+	return ids, nil
+}