internal/store: export new interface

This exposes store operations safe for direct access, and enables #19 to be implemented in internal/outcome.

Signed-off-by: Ophestra <cat@gensokyo.uk>

1 files changed, 44 insertions, 39 deletions

diff --git a/internal/store/store_test.go b/internal/store/store_test.go
index db1a4c71..0e013177 100644
--- a/internal/store/store_test.go
+++ b/internal/store/store_test.go
@@ -1,4 +1,4 @@
-package store
+package store_test
 
 import (
 	"cmp"
@@ -10,18 +10,23 @@ import (
 	"strings"
 	"syscall"
 	"testing"
+	_ "unsafe"
 
 	"hakurei.app/container/check"
 	"hakurei.app/hst"
+	"hakurei.app/internal/store"
 )
 
+//go:linkname bigLock hakurei.app/internal/store.(*Store).bigLock
+func bigLock(s *store.Store) (unlock func(), err error)
+
 func TestStateStoreBigLock(t *testing.T) {
 	t.Parallel()
 
 	{
-		s := newStore(check.MustAbs(t.TempDir()).Append("state"))
+		s := store.New(check.MustAbs(t.TempDir()).Append("state"))
 		for i := 0; i < 2; i++ { // check once behaviour
-			if unlock, err := s.bigLock(); err != nil {
+			if unlock, err := bigLock(s); err != nil {
 				t.Fatalf("bigLock: error = %v", err)
 			} else {
 				unlock()
@@ -35,7 +40,7 @@ func TestStateStoreBigLock(t *testing.T) {
 		wantErr := &hst.AppError{Step: "create state store directory",
 			Err: &os.PathError{Op: "mkdir", Path: "/proc/nonexistent", Err: syscall.ENOENT}}
 		for i := 0; i < 2; i++ { // check once behaviour
-			if _, err := newStore(check.MustAbs("/proc/nonexistent")).bigLock(); !reflect.DeepEqual(err, wantErr) {
+			if _, err := bigLock(store.New(check.MustAbs("/proc/nonexistent"))); !reflect.DeepEqual(err, wantErr) {
 				t.Errorf("bigLock: error = %#v, want %#v", err, wantErr)
 			}
 		}
@@ -50,35 +55,35 @@ func TestStateStoreBigLock(t *testing.T) {
 		}
 
 		wantErr := &hst.AppError{Step: "acquire lock on the state store",
-			Err: &os.PathError{Op: "open", Path: base.Append(storeMutexName).String(), Err: syscall.EACCES}}
-		if _, err := newStore(base).bigLock(); !reflect.DeepEqual(err, wantErr) {
+			Err: &os.PathError{Op: "open", Path: base.Append(store.MutexName).String(), Err: syscall.EACCES}}
+		if _, err := bigLock(store.New(base)); !reflect.DeepEqual(err, wantErr) {
 			t.Errorf("bigLock: error = %#v, want %#v", err, wantErr)
 		}
 	})
 }
 
-func TestStateStoreIdentityHandle(t *testing.T) {
+func TestStateStoreHandle(t *testing.T) {
 	t.Parallel()
 
 	t.Run("loadstore", func(t *testing.T) {
 		t.Parallel()
 
-		s := newStore(check.MustAbs(t.TempDir()).Append("store"))
+		s := store.New(check.MustAbs(t.TempDir()).Append("store"))
 
-		var handleAddr [8]*storeHandle
+		var handleAddr [8]*store.Handle
 		checkHandle := func(identity int, load bool) {
-			if h, err := s.identityHandle(identity); err != nil {
-				t.Fatalf("identityHandle: error = %v", err)
+			if h, err := s.Handle(identity); err != nil {
+				t.Fatalf("Handle: error = %v", err)
 			} else if load != (handleAddr[identity] != nil) {
-				t.Fatalf("identityHandle: load = %v, want %v", load, handleAddr[identity] != nil)
+				t.Fatalf("Handle: load = %v, want %v", load, handleAddr[identity] != nil)
 			} else if !load {
 				handleAddr[identity] = h
 
-				if h.identity != identity {
-					t.Errorf("identityHandle: identity = %d, want %d", h.identity, identity)
+				if h.Identity != identity {
+					t.Errorf("Handle: identity = %d, want %d", h.Identity, identity)
 				}
 			} else if h != handleAddr[identity] {
-				t.Fatalf("identityHandle: %p, want %p", h, handleAddr[identity])
+				t.Fatalf("Handle: %p, want %p", h, handleAddr[identity])
 			}
 		}
 
@@ -103,9 +108,9 @@ func TestStateStoreIdentityHandle(t *testing.T) {
 		}
 
 		wantErr := &hst.AppError{Step: "acquire lock on the state store",
-			Err: &os.PathError{Op: "open", Path: base.Append(storeMutexName).String(), Err: syscall.EACCES}}
-		if _, err := newStore(base).identityHandle(0); !reflect.DeepEqual(err, wantErr) {
-			t.Errorf("identityHandle: error = %#v, want %#v", err, wantErr)
+			Err: &os.PathError{Op: "open", Path: base.Append(store.MutexName).String(), Err: syscall.EACCES}}
+		if _, err := store.New(base).Handle(0); !reflect.DeepEqual(err, wantErr) {
+			t.Errorf("Handle: error = %#v, want %#v", err, wantErr)
 		}
 	})
 
@@ -116,7 +121,7 @@ func TestStateStoreIdentityHandle(t *testing.T) {
 		if err := os.MkdirAll(base.String(), 0700); err != nil {
 			t.Fatal(err.Error())
 		}
-		if f, err := os.Create(base.Append(storeMutexName).String()); err != nil {
+		if f, err := os.Create(base.Append(store.MutexName).String()); err != nil {
 			t.Fatal(err.Error())
 		} else if err = f.Close(); err != nil {
 			t.Fatal(err.Error())
@@ -132,8 +137,8 @@ func TestStateStoreIdentityHandle(t *testing.T) {
 
 		wantErr := &hst.AppError{Step: "create store segment directory",
 			Err: &os.PathError{Op: "mkdir", Path: base.Append("0").String(), Err: syscall.EACCES}}
-		if _, err := newStore(base).identityHandle(0); !reflect.DeepEqual(err, wantErr) {
-			t.Errorf("identityHandle: error = %#v, want %#v", err, wantErr)
+		if _, err := store.New(base).Handle(0); !reflect.DeepEqual(err, wantErr) {
+			t.Errorf("Handle: error = %#v, want %#v", err, wantErr)
 		}
 	})
 }
@@ -144,8 +149,8 @@ func TestStateStoreSegments(t *testing.T) {
 	testCases := []struct {
 		name string
 		ents [2][]string
-		want []segmentIdentity
-		ext  func(t *testing.T, segments iter.Seq[segmentIdentity], n int)
+		want []store.SegmentIdentity
+		ext  func(t *testing.T, segments iter.Seq[store.SegmentIdentity], n int)
 	}{
 		{"errors", [2][]string{{
 			"f0-invalid-file",
@@ -153,7 +158,7 @@ func TestStateStoreSegments(t *testing.T) {
 			"f1-invalid-syntax",
 			"9999",
 			"16384",
-		}}, []segmentIdentity{
+		}}, []store.SegmentIdentity{
 			{-1, &hst.AppError{Step: "process store segment", Err: syscall.EISDIR,
 				Msg: `skipped non-directory entry "f0-invalid-file"`}},
 			{-1, &hst.AppError{Step: "process store segment", Err: syscall.ERANGE,
@@ -180,7 +185,7 @@ func TestStateStoreSegments(t *testing.T) {
 			"20",
 			"31",
 			"197",
-		}}, []segmentIdentity{
+		}}, []store.SegmentIdentity{
 			{0, nil},
 			{1, nil},
 			{2, nil},
@@ -194,9 +199,9 @@ func TestStateStoreSegments(t *testing.T) {
 			{20, nil},
 			{31, nil},
 			{197, nil},
-		}, func(t *testing.T, segments iter.Seq[segmentIdentity], n int) {
+		}, func(t *testing.T, segments iter.Seq[store.SegmentIdentity], n int) {
 			if n != 13 {
-				t.Fatalf("segments: n = %d", n)
+				t.Fatalf("Segments: n = %d", n)
 			}
 
 			// check partial drain
@@ -215,24 +220,24 @@ func TestStateStoreSegments(t *testing.T) {
 			}
 			createEntries(t, base, tc.ents)
 
-			var got []segmentIdentity
-			if segments, n, err := newStore(base).segments(); err != nil {
-				t.Fatalf("segments: error = %v", err)
+			var got []store.SegmentIdentity
+			if segments, n, err := store.New(base).Segments(); err != nil {
+				t.Fatalf("Segments: error = %v", err)
 			} else {
-				got = slices.AppendSeq(make([]segmentIdentity, 0, n), segments)
+				got = slices.AppendSeq(make([]store.SegmentIdentity, 0, n), segments)
 				if tc.ext != nil {
 					tc.ext(t, segments, n)
 				}
 			}
 
-			slices.SortFunc(got, func(a, b segmentIdentity) int {
-				if a.identity == b.identity {
-					return strings.Compare(a.err.Error(), b.err.Error())
+			slices.SortFunc(got, func(a, b store.SegmentIdentity) int {
+				if a.Identity == b.Identity {
+					return strings.Compare(a.Err.Error(), b.Err.Error())
 				}
-				return cmp.Compare(a.identity, b.identity)
+				return cmp.Compare(a.Identity, b.Identity)
 			})
 			if !reflect.DeepEqual(got, tc.want) {
-				t.Errorf("segments: %#v, want %#v", got, tc.want)
+				t.Errorf("Segments: %#v, want %#v", got, tc.want)
 			}
 		})
 	}
@@ -246,9 +251,9 @@ func TestStateStoreSegments(t *testing.T) {
 		}
 
 		wantErr := &hst.AppError{Step: "acquire lock on the state store",
-			Err: &os.PathError{Op: "open", Path: base.Append(storeMutexName).String(), Err: syscall.EACCES}}
-		if _, _, err := newStore(base).segments(); !reflect.DeepEqual(err, wantErr) {
-			t.Errorf("segments: error = %#v, want %#v", err, wantErr)
+			Err: &os.PathError{Op: "open", Path: base.Append(store.MutexName).String(), Err: syscall.EACCES}}
+		if _, _, err := store.New(base).Segments(); !reflect.DeepEqual(err, wantErr) {
+			t.Errorf("Segments: error = %#v, want %#v", err, wantErr)
 		}
 	})
 }