security/hakurei
6
3
Fork 0
Code Issues 10 Pull Requests Actions Packages Projects Releases 11 Wiki Activity

internal/store: export new interface
All checks were successful
Test / Create distribution (push) Successful in 33s
Details
Test / Sandbox (push) Successful in 2m19s
Details
Test / Hakurei (push) Successful in 3m13s
Details
Test / Hpkg (push) Successful in 4m4s
Details
Test / Sandbox (race detector) (push) Successful in 4m16s
Details
Test / Hakurei (race detector) (push) Successful in 4m58s
Details
Test / Flake checks (push) Successful in 1m30s
Details

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

Signed-off-by: Ophestra <cat@gensokyo.uk>
This commit is contained in:
Ophestra
2025-10-31 03:41:26 +09:00
parent b25ade5f3d
commit b667fea1cb
5 changed files with 225 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
internal/store/store_test.go
View File

@@ -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)
}
})
}