aboutsummaryrefslogtreecommitdiffhomepage
path: root/internal/store
diff options
context:
space:
mode:
Diffstat (limited to 'internal/store')
-rw-r--r--internal/store/data.go10
-rw-r--r--internal/store/header.go3
-rw-r--r--internal/store/segment.go66
-rw-r--r--internal/store/segment_test.go78
-rw-r--r--internal/store/store.go80
5 files changed, 193 insertions, 44 deletions
diff --git a/internal/store/data.go b/internal/store/data.go
index 34a0f261..380481a0 100644
--- a/internal/store/data.go
+++ b/internal/store/data.go
@@ -23,7 +23,8 @@ func entryEncode(w io.Writer, s *hst.State) error {
}
}
-// entryDecodeHeader calls entryReadHeader, returning [hst.AppError] for a non-nil error.
+// entryDecodeHeader calls entryReadHeader, returning [hst.AppError] for a
+// non-nil error.
func entryDecodeHeader(r io.Reader) (hst.Enablements, error) {
if et, err := entryReadHeader(r); err != nil {
return 0, &hst.AppError{Step: "decode state header", Err: err}
@@ -44,11 +45,14 @@ func entryDecode(r io.Reader, p *hst.State) (hst.Enablements, error) {
} else if err = p.Config.Validate(hst.VAllowInsecure); err != nil {
return et, err
} else if p.Enablements.Unwrap() != et {
- return et, &hst.AppError{Step: "validate state enablement", Err: os.ErrInvalid,
+ return et, &hst.AppError{
+ Step: "validate state enablement",
+ Err: os.ErrInvalid,
Msg: fmt.Sprintf(
"state entry %s has unexpected enablement byte %#x, %#x",
p.ID.String(), byte(p.Enablements.Unwrap()), byte(et),
- )}
+ ),
+ }
} else {
return et, nil
}
diff --git a/internal/store/header.go b/internal/store/header.go
index 5b5d73be..0e5a92a2 100644
--- a/internal/store/header.go
+++ b/internal/store/header.go
@@ -60,7 +60,8 @@ func (e *EntrySizeError) Error() string {
return "state entry file " + strconv.Quote(e.Name) + " is too short"
}
-// entryCheckFile checks whether [os.FileInfo] refers to a file that might hold [hst.State].
+// entryCheckFile checks whether [os.FileInfo] refers to a file that might hold
+// [hst.State].
func entryCheckFile(fi os.FileInfo) error {
if fi.IsDir() {
return syscall.EISDIR
diff --git a/internal/store/segment.go b/internal/store/segment.go
index 06849749..8b7dd0d6 100644
--- a/internal/store/segment.go
+++ b/internal/store/segment.go
@@ -7,6 +7,7 @@ import (
"os"
"strconv"
"sync"
+ "syscall"
"hakurei.app/check"
"hakurei.app/hst"
@@ -76,13 +77,20 @@ func (eh *EntryHandle) save(state *hst.State) error {
return err
}
+// KillFunc is the function signature of syscall.Kill.
+type KillFunc func(pid int, sig syscall.Signal) (err error)
+
// Load loads and validates the state entry header, and returns the
// [hst.Enablements] byte. For a non-nil v, the full state payload is decoded
-// and stored in the value pointed to by v.
+// and stored in the value pointed to by v, and if kill is non-nil, the presence
+// of the monitoring process is checked, and a stale entry is destroyed.
//
// Load validates the embedded [hst.Config] value. A non-nil error returned by
// Load is of type [hst.AppError].
-func (eh *EntryHandle) Load(v *hst.State) (hst.Enablements, error) {
+func (eh *EntryHandle) Load(
+ v *hst.State,
+ kill KillFunc,
+) (hst.Enablements, error) {
f, err := eh.open(os.O_RDONLY, 0)
if err != nil {
return 0, err
@@ -92,8 +100,41 @@ func (eh *EntryHandle) Load(v *hst.State) (hst.Enablements, error) {
if v != nil {
et, err = entryDecode(f, v)
if err == nil && v.ID != eh.ID {
- err = &hst.AppError{Step: "validate state identifier", Err: os.ErrInvalid,
- Msg: fmt.Sprintf("state entry %s has unexpected id %s", eh.ID.String(), v.ID.String())}
+ err = &hst.AppError{
+ Step: "validate state identifier",
+ Err: os.ErrInvalid,
+ Msg: fmt.Sprintf(
+ "state entry %s has unexpected id %s",
+ eh.ID.String(), v.ID.String(),
+ ),
+ }
+ }
+ if kill != nil {
+ errno := kill(v.PID, 0)
+ if errno != nil {
+ if !errors.Is(errno, syscall.ESRCH) {
+ err = &hst.AppError{
+ Step: "check monitor process",
+ Err: errno,
+ }
+ } else {
+ if err = eh.Destroy(); err != nil {
+ err = &hst.AppError{
+ Step: "destroy stale entry",
+ Err: err,
+ }
+ } else {
+ err = &hst.AppError{
+ Step: "load stale entry",
+ Err: errno,
+ Msg: fmt.Sprintf(
+ "stale entry %s",
+ eh.ID.String(),
+ ),
+ }
+ }
+ }
+ }
}
} else {
et, err = entryDecodeHeader(f)
@@ -127,7 +168,10 @@ type Handle struct {
// A non-nil error returned by Lock is of type [hst.AppError].
func (h *Handle) Lock() (unlock func(), err error) {
if unlock, err = h.fileMu.Lock(); err != nil {
- return nil, &hst.AppError{Step: "acquire lock on store segment " + strconv.Itoa(h.Identity), Err: err}
+ return nil, &hst.AppError{
+ Step: "acquire lock on store segment " + strconv.Itoa(h.Identity),
+ Err: err,
+ }
}
return
}
@@ -174,8 +218,11 @@ func (h *Handle) Entries() (iter.Seq[*EntryHandle], int, error) {
// this should never happen
if ent.IsDir() {
- eh.DecodeErr = &hst.AppError{Step: step,
- Err: errors.New("unexpected directory " + strconv.Quote(ent.Name()) + " in store")}
+ eh.DecodeErr = &hst.AppError{
+ Step: step,
+ Err: errors.New("unexpected directory " +
+ strconv.Quote(ent.Name()) + " in store"),
+ }
goto out
}
@@ -186,7 +233,10 @@ func (h *Handle) Entries() (iter.Seq[*EntryHandle], int, error) {
// this either indicates a serious bug or external interference
if err := eh.ID.UnmarshalText([]byte(ent.Name())); err != nil {
- eh.DecodeErr = &hst.AppError{Step: "decode store segment entry", Err: err}
+ eh.DecodeErr = &hst.AppError{
+ Step: "decode store segment entry",
+ Err: err,
+ }
goto out
}
diff --git a/internal/store/segment_test.go b/internal/store/segment_test.go
index a244fcdc..6316a278 100644
--- a/internal/store/segment_test.go
+++ b/internal/store/segment_test.go
@@ -2,6 +2,7 @@ package store_test
import (
"errors"
+ "fmt"
"io"
"iter"
"os"
@@ -55,7 +56,7 @@ func TestStateEntryHandle(t *testing.T) {
if err := save(&eh, nil); !reflect.DeepEqual(err, wantErr()) {
t.Errorf("save: error = %v, want %v", err, wantErr())
}
- if _, err := eh.Load(nil); !reflect.DeepEqual(err, wantErr()) {
+ if _, err := eh.Load(nil, nil); !reflect.DeepEqual(err, wantErr()) {
t.Errorf("load: error = %v, want %v", err, wantErr())
}
})
@@ -95,8 +96,10 @@ func TestStateEntryHandle(t *testing.T) {
t.Run("saveload", func(t *testing.T) {
t.Parallel()
- eh := store.EntryHandle{Pathname: check.MustAbs(t.TempDir()).Append("entry"),
- ID: store.NewTemplateState().ID}
+ eh := store.EntryHandle{
+ Pathname: check.MustAbs(t.TempDir()).Append("entry"),
+ ID: store.NewTemplateState().ID,
+ }
if err := save(&eh, store.NewTemplateState()); err != nil {
t.Fatalf("save: error = %v", err)
@@ -125,7 +128,7 @@ func TestStateEntryHandle(t *testing.T) {
t.Run("load header only", func(t *testing.T) {
t.Parallel()
- if et, err := eh.Load(nil); err != nil {
+ if et, err := eh.Load(nil, nil); err != nil {
t.Fatalf("load: error = %v", err)
} else if want := store.NewTemplateState().Enablements.Unwrap(); et != want {
t.Errorf("load: et = %x, want %x", et, want)
@@ -136,7 +139,7 @@ func TestStateEntryHandle(t *testing.T) {
t.Parallel()
var got hst.State
- if _, err := eh.Load(&got); err != nil {
+ if _, err := eh.Load(&got, nil); err != nil {
t.Fatalf("load: error = %v", err)
} else if want := store.NewTemplateState(); !reflect.DeepEqual(&got, want) {
t.Errorf("load: %#v, want %#v", &got, want)
@@ -145,11 +148,64 @@ func TestStateEntryHandle(t *testing.T) {
t.Run("load inconsistent", func(t *testing.T) {
t.Parallel()
- wantErr := &hst.AppError{Step: "validate state identifier", Err: os.ErrInvalid,
- Msg: "state entry 00000000000000000000000000000000 has unexpected id aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}
+ wantErr := &hst.AppError{
+ Step: "validate state identifier",
+ Err: os.ErrInvalid,
+ Msg: "state entry 00000000000000000000000000000000 has unexpected id aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ }
ehi := store.EntryHandle{Pathname: eh.Pathname}
- if _, err := ehi.Load(new(hst.State)); !reflect.DeepEqual(err, wantErr) {
+ if _, err := ehi.Load(new(hst.State), nil); !reflect.DeepEqual(err, wantErr) {
+ t.Errorf("load: error = %#v, want %#v", err, wantErr)
+ }
+ })
+
+ t.Run("stale fault", func(t *testing.T) {
+ t.Parallel()
+ wantErr := &hst.AppError{
+ Step: "check monitor process",
+ Err: syscall.EFAULT,
+ }
+
+ if _, err := eh.Load(new(hst.State), func(pid int, sig syscall.Signal) (err error) {
+ if pid != store.NewTemplateState().PID {
+ return fmt.Errorf("bad pid %d", pid)
+ }
+ if sig != 0 {
+ return fmt.Errorf("bad signal %d", sig)
+ }
+ return syscall.EFAULT
+ }); !reflect.DeepEqual(err, wantErr) {
+ t.Errorf("load: error = %#v, want %#v", err, wantErr)
+ }
+ })
+
+ t.Run("stale", func(t *testing.T) {
+ t.Parallel()
+ wantErr := &hst.AppError{
+ Step: "load stale entry",
+ Err: syscall.ESRCH,
+ Msg: "stale entry aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ }
+
+ ehi := store.EntryHandle{
+ Pathname: check.MustAbs(t.TempDir()).Append("entry"),
+ ID: eh.ID,
+ }
+
+ if err := save(&ehi, store.NewTemplateState()); err != nil {
+ t.Fatalf("save: error = %v", err)
+ }
+
+ if _, err := ehi.Load(new(hst.State), func(pid int, sig syscall.Signal) (err error) {
+ if pid != store.NewTemplateState().PID {
+ return fmt.Errorf("bad pid %d", pid)
+ }
+ if sig != 0 {
+ return fmt.Errorf("bad signal %d", sig)
+ }
+ return syscall.ESRCH
+ }); !reflect.DeepEqual(err, wantErr) {
t.Errorf("load: error = %#v, want %#v", err, wantErr)
}
})
@@ -229,7 +285,9 @@ func TestSegmentHandle(t *testing.T) {
}
}
- slices.SortFunc(got, func(a, b *store.EntryHandle) int { return strings.Compare(a.Pathname.String(), b.Pathname.String()) })
+ slices.SortFunc(got, func(a, b *store.EntryHandle) int {
+ return strings.Compare(a.Pathname.String(), b.Pathname.String())
+ })
want := tc.want(func(err error, name string) *store.EntryHandle {
eh := store.EntryHandle{DecodeErr: err, Pathname: segment.Append(name)}
if err == nil {
@@ -247,6 +305,8 @@ func TestSegmentHandle(t *testing.T) {
}
t.Run("nonexistent", func(t *testing.T) {
+ t.Parallel()
+
var wantErr = &hst.AppError{Step: "read store segment entries", Err: &os.PathError{
Op: "open",
Path: "/proc/nonexistent",
diff --git a/internal/store/store.go b/internal/store/store.go
index 3604521c..eb9cec41 100644
--- a/internal/store/store.go
+++ b/internal/store/store.go
@@ -1,4 +1,5 @@
-// Package store implements cross-process state tracking for hakurei container instances.
+// Package store provides storage for hakurei instance states, safe for
+// concurrent and cross-process use.
package store
import (
@@ -15,11 +16,15 @@ import (
"hakurei.app/internal/lockedfile"
)
-// MutexName is the pathname of the file backing [lockedfile.Mutex] of a [Store] and [Handle].
+// MutexName is the pathname of the file backing [lockedfile.Mutex] of a [Store]
+// and [Handle].
const MutexName = "lock"
-// A Store keeps track of [hst.State] via a well-known filesystem accessible to all hakurei priv-side processes.
-// Access to store data and related resources are synchronised on a per-segment basis via [Handle].
+// A Store keeps track of [hst.State] via a well-known filesystem accessible to
+// all hakurei priv-side processes.
+//
+// Access to store data and related resources are synchronised on a per-segment
+// basis via [Handle].
type Store struct {
// Pathname of directory that the store is rooted in.
base *check.Absolute
@@ -28,8 +33,10 @@ type Store struct {
handles sync.Map
// Inter-process mutex to synchronise operations against the entire store.
- // Held during List and when initialising previously unknown identities during Do.
- // Must not be accessed directly. Callers should use the bigLock method instead.
+ //
+ // Held during List and when initialising previously unknown identities
+ // during Do. Must not be accessed directly. Callers should use the bigLock
+ // method instead.
fileMu *lockedfile.Mutex
// For creating the base directory.
@@ -43,11 +50,17 @@ type Store struct {
func (s *Store) bigLock() (unlock func(), err error) {
s.mkdirOnce.Do(func() { s.mkdirErr = os.MkdirAll(s.base.String(), 0700) })
if s.mkdirErr != nil {
- return nil, &hst.AppError{Step: "create state store directory", Err: s.mkdirErr}
+ return nil, &hst.AppError{
+ Step: "create state store directory",
+ Err: s.mkdirErr,
+ }
}
if unlock, err = s.fileMu.Lock(); err != nil {
- return nil, &hst.AppError{Step: "acquire lock on the state store", Err: err}
+ return nil, &hst.AppError{
+ Step: "acquire lock on the state store",
+ Err: err,
+ }
}
return
}
@@ -73,7 +86,10 @@ func (s *Store) Handle(identity int) (*Handle, error) {
if err != nil && !errors.Is(err, fs.ErrExist) {
// handle methods will likely return ENOENT
s.handles.CompareAndDelete(identity, h)
- return nil, &hst.AppError{Step: "create store segment directory", Err: err}
+ return nil, &hst.AppError{
+ Step: "create store segment directory",
+ Err: err,
+ }
}
}
return h, nil
@@ -88,8 +104,9 @@ type SegmentIdentity struct {
}
// Segments returns an iterator over all [SegmentIdentity] known to the [Store].
-// To obtain a [Handle] on a segment, caller must then call [Store.Handle].
-// A non-nil error returned by segments is of type [hst.AppError].
+//
+// To obtain a [Handle] on a segment, caller must then call [Store.Handle]. A
+// non-nil error returned by segments is of type [hst.AppError].
func (s *Store) Segments() (iter.Seq[SegmentIdentity], int, error) {
// read directory contents, should only contain storeMutexName and identity
var entries []os.DirEntry
@@ -102,7 +119,10 @@ func (s *Store) Segments() (iter.Seq[SegmentIdentity], int, error) {
unlock()
if err != nil && !errors.Is(err, os.ErrNotExist) {
- return nil, -1, &hst.AppError{Step: "read store segments", Err: err}
+ return nil, -1, &hst.AppError{
+ Step: "read store segments",
+ Err: err,
+ }
}
}
@@ -126,19 +146,25 @@ func (s *Store) Segments() (iter.Seq[SegmentIdentity], int, error) {
}
// this should never happen
- si.Err = &hst.AppError{Step: step, Err: syscall.ENOTDIR,
- Msg: "skipped non-directory entry " + strconv.Quote(ent.Name())}
+ si.Err = &hst.AppError{
+ Step: step, Err: syscall.ENOTDIR,
+ Msg: "skipped non-directory entry " + strconv.Quote(ent.Name()),
+ }
goto out
}
// failure paths either indicates a serious bug or external interference
if v, err := strconv.Atoi(ent.Name()); err != nil {
- si.Err = &hst.AppError{Step: step, Err: err,
- Msg: "skipped non-identity entry " + strconv.Quote(ent.Name())}
+ si.Err = &hst.AppError{
+ Step: step, Err: err,
+ Msg: "skipped non-identity entry " + strconv.Quote(ent.Name()),
+ }
goto out
} else if v < hst.IdentityStart || v > hst.IdentityEnd {
- si.Err = &hst.AppError{Step: step, Err: syscall.ERANGE,
- Msg: "skipped out of bounds entry " + strconv.Itoa(v)}
+ si.Err = &hst.AppError{
+ Step: step, Err: syscall.ERANGE,
+ Msg: "skipped out of bounds entry " + strconv.Itoa(v),
+ }
goto out
} else {
si.Identity = v
@@ -152,9 +178,12 @@ func (s *Store) Segments() (iter.Seq[SegmentIdentity], int, error) {
}, l, nil
}
-// All returns a non-reusable iterator over all [EntryHandle] known to this [Store].
-// Callers must call copyError after completing iteration and handle the error accordingly.
-// A non-nil error returned by copyError is of type [hst.AppError].
+// All returns a non-reusable iterator over all [EntryHandle] known to this
+// [Store]. The resulting handles may be retained, but are only safe to use
+// during the iteration producing them.
+//
+// Callers must call copyError after completing iteration and handle the error
+// accordingly. A non-nil error returned by copyError is of type [hst.AppError].
func (s *Store) All() (entries iter.Seq[*EntryHandle], copyError func() error) {
var savedErr error
return func(yield func(*EntryHandle) bool) {
@@ -197,7 +226,12 @@ func (s *Store) All() (entries iter.Seq[*EntryHandle], copyError func() error) {
}
// New returns the address of a new instance of [Store].
-// Multiple instances of [Store] rooted in the same directory is possible, but unsupported.
+//
+// Multiple instances of [Store] rooted in the same directory is possible, but
+// unsupported.
func New(base *check.Absolute) *Store {
- return &Store{base: base, fileMu: lockedfile.MutexAt(base.Append(MutexName).String())}
+ return &Store{
+ base: base,
+ fileMu: lockedfile.MutexAt(base.Append(MutexName).String()),
+ }
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-09-04 15:20:27 +0000