fs storage

game/internal/repo/fs/fs.go

@@ -0,0 +1,222 @@
+package fs
+
+import (
+	"encoding"
+	"errors"
+	"fmt"
+	"galaxy/util"
+	"math/big"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+const (
+	defaultPerm   = 0o644
+	lockFile      = ".lock"
+	oldFileSuffix = ".old"
+	newFileSuffix = ".new"
+)
+
+type fs struct {
+	root string
+	lock *os.File
+}
+
+func NewFileStorage(path string) (*fs, error) {
+	filepath.Join("", "")
+	absPath, err := filepath.Abs(path)
+	if err != nil {
+		return nil, fmt.Errorf("path %s invalid: %s", path, err)
+	}
+	if ok, err := util.DirExists(absPath); err != nil {
+		return nil, fmt.Errorf("check dir exist: %s", err)
+	} else if !ok {
+		return nil, errors.New("directory does not exist: " + absPath)
+	}
+
+	if ok, err := util.Writable(absPath); err != nil {
+		return nil, fmt.Errorf("check dir access: %s", err)
+	} else if !ok {
+		return nil, errors.New("directory should have read-write access: " + absPath)
+	}
+
+	fs := &fs{
+		root: path,
+	}
+	return fs, nil
+}
+
+func (f *fs) Lock() (func() error, error) {
+	lockPath := f.lockFilePath()
+	exists, err := util.FileExists(lockPath)
+	if err != nil {
+		return nil, fmt.Errorf("check lock file exists: %s", err)
+	}
+	if exists {
+		return nil, errors.New("lock file already exists")
+	}
+	fd, err := os.OpenFile(lockPath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o600)
+	if err != nil {
+		return nil, fmt.Errorf("create lock file: %s", err)
+	}
+	f.lock = fd
+	unlock := func() error {
+		if err := f.lock.Close(); err != nil {
+			return fmt.Errorf("close lock file: %s", err)
+		}
+		if err := os.Remove(f.lock.Name()); err != nil {
+			return fmt.Errorf("remove lock file: %s", err)
+		}
+		f.lock = nil
+		return nil
+	}
+	if _, err := f.lock.Write(big.NewInt(time.Now().UnixMilli()).Bytes()); err != nil {
+		return nil, errors.Join(fmt.Errorf("write lock file: %s", err), unlock())
+	}
+	return unlock, nil
+}
+
+func (f *fs) Exists(path string) (bool, error) {
+	return util.FileExists(filepath.Join(f.root, path))
+}
+
+func (f *fs) WriteSafe(path string, v encoding.BinaryMarshaler) error {
+	if v == nil {
+		return errors.New("cant't marshal from nil object")
+	}
+
+	targetFilePath := filepath.Join(f.root, path)
+	if targetFilePath == f.lockFilePath() {
+		return errors.New("can't write to the lock file")
+	}
+
+	data, err := v.MarshalBinary()
+	if err != nil {
+		return fmt.Errorf("marshal data: %s", err)
+	}
+
+	targetDir := filepath.Dir(targetFilePath)
+	if targetDir != f.root {
+		ok, err := util.DirExists(targetDir)
+		if err != nil {
+			return fmt.Errorf("check target dir exists: %s", err)
+		}
+		if !ok {
+			err := os.MkdirAll(targetDir, os.ModePerm)
+			if err != nil {
+				return fmt.Errorf("create target dirs: %s", err)
+			}
+		}
+	}
+	oldFilePath := targetFilePath + oldFileSuffix
+
+	targetExists, err := util.FileExists(targetFilePath)
+	if err != nil {
+		return fmt.Errorf("check target file exists: %s", err)
+	}
+	if targetExists {
+		oldFileExists, err := util.FileExists(oldFilePath)
+		if err != nil {
+			return fmt.Errorf("check old file exists: %s", err)
+		}
+		if oldFileExists {
+			return fmt.Errorf("old file exists at: %s", oldFilePath)
+		}
+	}
+
+	newFilePath := targetFilePath + newFileSuffix
+	newFileExists, err := util.FileExists(newFilePath)
+	if err != nil {
+		return fmt.Errorf("check new file exists: %s", err)
+	}
+	if newFileExists {
+		return fmt.Errorf("new file exists at: %s", oldFilePath)
+	}
+
+	err = os.WriteFile(newFilePath, data, defaultPerm)
+	if err != nil {
+		return fmt.Errorf("write data to the new file: %s", err)
+	}
+
+	if targetExists {
+		if err := os.Rename(targetFilePath, oldFilePath); err != nil {
+			return fmt.Errorf("rename target file to the old file: %s", err)
+		}
+	}
+
+	if err := os.Rename(newFilePath, targetFilePath); err != nil {
+		return fmt.Errorf("rename new file to the target file: %s", err)
+	}
+
+	if targetExists {
+		err := os.Remove(oldFilePath)
+		if err != nil {
+			return fmt.Errorf("remove old file: %s", err)
+		}
+	}
+	return nil
+}
+
+func (f *fs) Write(path string, v encoding.BinaryMarshaler) error {
+	if f.lock == nil {
+		return errors.New("lock must be acquired before write")
+	}
+
+	return f.WriteSafe(path, v)
+}
+
+func (f *fs) Read(path string, v encoding.BinaryUnmarshaler) error {
+	if f.lock == nil {
+		return errors.New("lock must be acquired before read")
+	}
+
+	return f.readUnsafe(path, v)
+}
+
+func (f *fs) ReadSafe(path string, v encoding.BinaryUnmarshaler) error {
+	if f.lock != nil {
+		timeout := time.NewTimer(time.Millisecond * 100)
+		checker := time.NewTicker(time.Millisecond)
+	out:
+		for {
+			select {
+			case <-checker.C:
+				if f.lock == nil {
+					checker.Stop()
+					timeout.Stop()
+					break out
+				}
+			case <-timeout.C:
+				checker.Stop()
+				return errors.New("timeout waiting for lock release")
+			}
+		}
+	}
+
+	return f.readUnsafe(path, v)
+}
+
+// readUnsafe reads the file contents without locking mechanism in mind.
+// Using readUnsafe directly may cause errors if file being written at the moment.
+func (f *fs) readUnsafe(file string, v encoding.BinaryUnmarshaler) error {
+	if v == nil {
+		return errors.New("can't unmarshal to a nil object")
+	}
+
+	targetFilePath := filepath.Join(f.root, file)
+	if targetFilePath == f.lockFilePath() {
+		return errors.New("can't read from the lock file")
+	}
+
+	data, err := os.ReadFile(targetFilePath)
+	if err != nil {
+		return fmt.Errorf("reading data file: %s", err)
+	}
+
+	return v.UnmarshalBinary(data)
+}
+
+func (f *fs) lockFilePath() string {
+	return filepath.Join(f.root, lockFile)
+}

game/internal/repo/fs/fs_test.go

@@ -0,0 +1,197 @@
+package fs_test
+
+import (
+	"os"
+	"path/filepath"
+	"slices"
+	"testing"
+
+	"galaxy/game/internal/repo/fs"
+	"galaxy/util"
+
+	"github.com/stretchr/testify/assert"
+)
+
+const (
+	lockFile = ".lock"
+)
+
+type sampleData struct {
+	data []byte
+}
+
+func (sd *sampleData) UnmarshalBinary(data []byte) error {
+	sd.data = slices.Clone(data)
+	return nil
+}
+
+func (sd sampleData) MarshalBinary() (data []byte, err error) {
+	return sd.data, nil
+}
+
+func TestNewFileStorageSuccess(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+	_, err := fs.NewFileStorage(root)
+	assert.NoError(t, err)
+}
+
+func TestLock(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+	fs, err := fs.NewFileStorage(root)
+	assert.NoError(t, err, "create file storage")
+	unlock, err := fs.Lock()
+	assert.NoError(t, err, "acquire lock")
+	lockPath := filepath.Join(root, lockFile)
+	assert.FileExists(t, lockPath, "lock file should be created")
+	err = unlock()
+	assert.NoError(t, err, "unlocking existing lock")
+	assert.NoFileExists(t, lockPath, "lock file must be removed")
+}
+
+func TestExist(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+
+	fileName := "some-file.ext"
+	if err := os.WriteFile(filepath.Join(root, fileName), []byte{1, 2, 3, 4}, os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	fs, err := fs.NewFileStorage(root)
+	assert.NoError(t, err, "create file storage")
+
+	exist, err := fs.Exists(fileName)
+	assert.NoError(t, err)
+	assert.True(t, exist)
+
+	exist, err = fs.Exists("random/path")
+	assert.NoError(t, err)
+	assert.False(t, exist)
+}
+
+func TestWrite(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+
+	fs, err := fs.NewFileStorage(root)
+	assert.NoError(t, err, "create file storage: %s", err)
+
+	unlock, err := fs.Lock()
+	assert.NoError(t, err, "acquire lock: %s", err)
+
+	dirName := "some-dir"
+	if err := os.Mkdir(filepath.Join(root, dirName), os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, tc := range []struct {
+		path string
+		err  string
+	}{
+		{path: "file-1.ext"},
+		{path: "/dir/file-2.ext"},
+		{path: "dir/subdir/file-3.ext"},
+		{path: lockFile, err: "write to the lock file"},
+		{path: dirName, err: "wrong type"},
+		{path: "/" + dirName, err: "wrong type"},
+	} {
+		t.Run(tc.path, func(t *testing.T) {
+			sd := &sampleData{[]byte{0, 1, 2, 3}}
+			err = fs.Write(tc.path, sd)
+			if tc.err == "" {
+				assert.NoError(t, err)
+				assert.FileExists(t, filepath.Join(root, tc.path), "the written file should exist")
+			} else if tc.err != "" {
+				assert.ErrorContains(t, err, tc.err)
+			}
+		})
+	}
+
+	assert.NoError(t, unlock(), "unlocking existing lock")
+}
+
+func TestRead(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+
+	sd := new(sampleData)
+
+	fs, err := fs.NewFileStorage(root)
+	assert.NoError(t, err, "create file storage: %s", err)
+
+	assert.EqualError(t, fs.Read("some.file", sd), "lock must be acquired before read")
+
+	unlock, err := fs.Lock()
+	assert.NoError(t, err, "acquire lock: %s", err)
+
+	dirName := "some-dir"
+	if err := os.Mkdir(filepath.Join(root, dirName), os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	fileName := "some-file.ext"
+	if err := os.WriteFile(filepath.Join(root, fileName), []byte{1, 2, 3, 4}, os.ModePerm); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, tc := range []struct {
+		path string
+		err  string
+	}{
+		{path: fileName},
+		{path: "/" + fileName},
+		{path: lockFile, err: "read from the lock file"},
+		{path: "dir/subdir/file-3.ext", err: "no such file"},
+		{path: lockFile, err: "read from the lock file"},
+		{path: dirName, err: "is a directory"},
+	} {
+		t.Run(tc.path, func(t *testing.T) {
+			err = fs.Read(tc.path, sd)
+			if tc.err == "" {
+				assert.NoError(t, err)
+				assert.FileExists(t, filepath.Join(root, tc.path), "the written file should exist")
+			} else if tc.err != "" {
+				assert.ErrorContains(t, err, tc.err)
+			}
+		})
+	}
+	assert.NoError(t, unlock(), "unlocking existing lock")
+}
+
+func TestWriteErrorWithoutLock(t *testing.T) {
+	root, cleanup := util.CreateWorkDir(t)
+	defer cleanup()
+	fs, err := fs.NewFileStorage(root)
+	assert.NoError(t, err, "create file storage")
+	sd := &sampleData{[]byte{0, 1, 2, 3}}
+	err = fs.Write("some/path", sd)
+	assert.Error(t, err, "should return error when no lock acquired")
+	assert.EqualError(t, err, "lock must be acquired before write")
+}
+
+func TestNewFileStorageErrorNotExists(t *testing.T) {
+	_, err := fs.NewFileStorage(filepath.Join(os.TempDir(), "non-existent-dir"))
+	assert.Error(t, err)
+}
+
+func TestNewFileStorageErrorNotADirectory(t *testing.T) {
+	f, err := os.CreateTemp("", "fs-test-file")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := f.Close(); err != nil {
+		t.Fatal(err)
+	}
+	_, err = fs.NewFileStorage(f.Name())
+	assert.Error(t, err)
+	if err := os.Remove(f.Name()); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestNewFileStorageErrorNoAccess(t *testing.T) {
+	_, err := fs.NewFileStorage("/some/random/dir")
+	assert.Error(t, err)
+}

game/internal/repo/game.go

@@ -0,0 +1,341 @@
+package repo
+
+/*
+	/state.json
+	/0001/state.json
+	/0001/meta.json
+	/0000/order/{UUID}.json
+	/0001/bombing.json
+	/0001/battle/{UUID}.json
+	/0001/report/{UUID}.json
+*/
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"galaxy/model/order"
+	"galaxy/model/report"
+
+	"galaxy/game/internal/model/game"
+
+	"github.com/google/uuid"
+)
+
+const (
+	statePath = "state.json"
+	metaPath  = "meta.json"
+)
+
+type storedOrder struct {
+	Commands []json.RawMessage `json:"cmd"`
+}
+
+func (o storedOrder) MarshalBinary() (data []byte, err error) {
+	return json.Marshal(&o)
+}
+
+func (o *storedOrder) UnmarshalBinary(data []byte) error {
+	return json.Unmarshal(data, o)
+}
+
+func (r *repo) SaveNewTurn(t uint, g *game.Game) error {
+	return saveNewTurn(r.s, t, g)
+}
+
+func saveNewTurn(s Storage, t uint, g *game.Game) error {
+	path := fmt.Sprintf("%s/state.json", TurnDir(t))
+	exist, err := s.Exists(path)
+	if err != nil {
+		return NewStorageError(err)
+	}
+	if exist {
+		return NewStateError(fmt.Sprintf("turn %d already saved at %s", t, path))
+	}
+	if err := s.Write(path, g); err != nil {
+		return NewStorageError(err)
+	}
+	return saveLastState(s, g)
+}
+
+func (r *repo) SaveLastState(g *game.Game) error {
+	return saveLastState(r.s, g)
+}
+
+func saveLastState(s Storage, g *game.Game) error {
+	if err := s.Write(statePath, g); err != nil {
+		return NewStorageError(err)
+	}
+	return nil
+}
+
+func (r *repo) LoadState() (*game.Game, error) {
+	return loadState(r.s, true)
+}
+
+func (r *repo) LoadStateSafe() (*game.Game, error) {
+	return loadState(r.s, false)
+}
+
+func loadState(s Storage, locked bool) (*game.Game, error) {
+	var result *game.Game = new(game.Game)
+	path := statePath
+	exist, err := s.Exists(path)
+	if err != nil {
+		return nil, NewStorageError(err)
+	}
+	if !exist {
+		return nil, NewGameNotInitializedError()
+	}
+	if locked {
+		if err := s.Read(path, result); err != nil {
+			return nil, NewStorageError(err)
+		}
+	} else {
+		if err := s.ReadSafe(path, result); err != nil {
+			return nil, NewStorageError(err)
+		}
+	}
+	return result, nil
+}
+
+func loadMeta(s Storage) (*game.GameMeta, error) {
+	var result *game.GameMeta = new(game.GameMeta)
+	path := metaPath
+	exist, err := s.Exists(path)
+	if err != nil {
+		return nil, NewStorageError(err)
+	}
+	if !exist {
+		return result, nil
+	}
+	if err := s.ReadSafe(path, result); err != nil {
+		return nil, NewStorageError(err)
+	}
+	return result, nil
+}
+
+func saveMeta(s Storage, t uint, gm *game.GameMeta) error {
+	// save turn's meta
+	path := fmt.Sprintf("%s/%s", TurnDir(t), metaPath)
+	if err := s.Write(path, gm); err != nil {
+		return NewStorageError(err)
+	}
+	// also save as latest meta
+	path = metaPath
+	if err := s.Write(path, gm); err != nil {
+		return NewStorageError(err)
+	}
+	return nil
+}
+
+func (r *repo) SaveBattle(t uint, b *report.BattleReport, m *game.BattleMeta) error {
+	meta, err := loadMeta(r.s)
+	if err != nil {
+		return err
+	}
+	err = saveBattle(r.s, t, b)
+	if err != nil {
+		return err
+	}
+	meta.Battles = append(meta.Battles, *m)
+	return saveMeta(r.s, t, meta)
+}
+
+func saveBattle(s Storage, t uint, b *report.BattleReport) error {
+	path := fmt.Sprintf("%s/battle/%s.json", TurnDir(t), b.ID.String())
+	exist, err := s.Exists(path)
+	if err != nil {
+		return NewStorageError(err)
+	}
+	if exist {
+		return NewStateError(fmt.Sprintf("battle %v for turn %d already has been saved", b.ID, t))
+	}
+	if err := s.Write(path, b); err != nil {
+		return NewStorageError(err)
+	}
+	return nil
+}
+
+func (r *repo) SaveBombings(t uint, b []*game.Bombing) error {
+	meta, err := loadMeta(r.s)
+	if err != nil {
+		return err
+	}
+	for i := range b {
+		meta.Bombings = append(meta.Bombings, *b[i])
+	}
+	return saveMeta(r.s, t, meta)
+}
+
+func (r *repo) SaveReport(t uint, rep *report.Report) error {
+	return saveReport(r.s, t, rep)
+}
+
+func saveReport(s Storage, t uint, v *report.Report) error {
+	path := ReportDir(t, v.RaceID)
+	if err := s.Write(path, v); err != nil {
+		return NewStorageError(err)
+	}
+	return nil
+}
+
+func (r *repo) LoadReport(t uint, id uuid.UUID) (*report.Report, error) {
+	return loadReport(r.s, t, id)
+}
+
+func loadReport(s Storage, t uint, id uuid.UUID) (*report.Report, error) {
+	path := ReportDir(t, id)
+	result := new(report.Report)
+	exist, err := s.Exists(path)
+	if err != nil {
+		return nil, NewStorageError(err)
+	}
+	if !exist {
+		return nil, NewReportNotFoundError()
+	}
+	if err := s.ReadSafe(path, result); err != nil {
+		return nil, NewStorageError(err)
+	}
+	return result, nil
+}
+
+func (r *repo) SaveOrder(t uint, id uuid.UUID, o *order.Order) error {
+	return saveOrder(r.s, t, id, o)
+}
+
+func saveOrder(s Storage, t uint, id uuid.UUID, o *order.Order) error {
+	path := OrderDir(t, id)
+	if err := s.WriteSafe(path, o); err != nil {
+		return NewStorageError(err)
+	}
+	return nil
+}
+
+func (r *repo) LoadOrder(t uint, id uuid.UUID) (*order.Order, bool, error) {
+	return loadOrder(r.s, t, id)
+}
+
+func loadOrder(s Storage, t uint, id uuid.UUID) (*order.Order, bool, error) {
+	path := OrderDir(t, id)
+
+	exist, err := s.Exists(path)
+	if err != nil {
+		return nil, false, NewStorageError(err)
+	}
+	if !exist {
+		return nil, false, nil
+	}
+
+	cmd := new(storedOrder)
+	if err := s.ReadSafe(path, cmd); err != nil {
+		return nil, false, NewStorageError(err)
+	}
+	result := &order.Order{Commands: make([]order.DecodableCommand, len(cmd.Commands))}
+	if len(cmd.Commands) == 0 {
+		return nil, false, errors.New("no commands were stored")
+	}
+
+	for i := range cmd.Commands {
+		command, err := ParseOrder(cmd.Commands[i], nil)
+		if err != nil {
+			return nil, false, err
+		}
+		result.Commands[i] = command
+	}
+
+	return result, true, nil
+}
+
+// Helper funcs
+
+func OrderDir(t uint, id uuid.UUID) string {
+	return fmt.Sprintf("%s/order/%s.json", TurnDir(t), id.String())
+}
+
+func ReportDir(t uint, id uuid.UUID) string {
+	return fmt.Sprintf("%s/report/%s.json", TurnDir(t), id.String())
+}
+
+func TurnDir(t uint) string {
+	return fmt.Sprintf("%04d", t)
+}
+
+func ParseOrder(c json.RawMessage, validator func(order.DecodableCommand) error) (order.DecodableCommand, error) {
+	meta := new(order.CommandMeta)
+	if err := json.Unmarshal(c, meta); err != nil {
+		return nil, err
+	}
+	switch t := meta.CmdType; t {
+	case order.CommandTypeRaceQuit:
+		return decodeCommand(c, new(order.CommandRaceQuit), validator)
+	case order.CommandTypeRaceVote:
+		return decodeCommand(c, new(order.CommandRaceVote), validator)
+	case order.CommandTypeRaceRelation:
+		return decodeCommand(c, new(order.CommandRaceRelation), validator)
+	case order.CommandTypeShipClassCreate:
+		return decodeCommand(c, new(order.CommandShipClassCreate), validator)
+	case order.CommandTypeShipClassMerge:
+		return decodeCommand(c, new(order.CommandShipClassMerge), validator)
+	case order.CommandTypeShipClassRemove:
+		return decodeCommand(c, new(order.CommandShipClassRemove), validator)
+	case order.CommandTypeShipGroupBreak:
+		return decodeCommand(c, new(order.CommandShipGroupBreak), validator)
+	case order.CommandTypeShipGroupLoad:
+		return decodeCommand(c, new(order.CommandShipGroupLoad), validator)
+	case order.CommandTypeShipGroupUnload:
+		return decodeCommand(c, new(order.CommandShipGroupUnload), validator)
+	case order.CommandTypeShipGroupSend:
+		return decodeCommand(c, new(order.CommandShipGroupSend), validator)
+	case order.CommandTypeShipGroupUpgrade:
+		return decodeCommand(c, new(order.CommandShipGroupUpgrade), validator)
+	case order.CommandTypeShipGroupMerge:
+		return decodeCommand(c, new(order.CommandShipGroupMerge), validator)
+	case order.CommandTypeShipGroupDismantle:
+		return decodeCommand(c, new(order.CommandShipGroupDismantle), validator)
+	case order.CommandTypeShipGroupTransfer:
+		return decodeCommand(c, new(order.CommandShipGroupTransfer), validator)
+	case order.CommandTypeShipGroupJoinFleet:
+		return decodeCommand(c, new(order.CommandShipGroupJoinFleet), validator)
+	case order.CommandTypeFleetMerge:
+		return decodeCommand(c, new(order.CommandFleetMerge), validator)
+	case order.CommandTypeFleetSend:
+		return decodeCommand(c, new(order.CommandFleetSend), validator)
+	case order.CommandTypeScienceCreate:
+		return decodeCommand(c, new(order.CommandScienceCreate), validator)
+	case order.CommandTypeScienceRemove:
+		return decodeCommand(c, new(order.CommandScienceRemove), validator)
+	case order.CommandTypePlanetRename:
+		return decodeCommand(c, new(order.CommandPlanetRename), validator)
+	case order.CommandTypePlanetProduce:
+		return decodeCommand(c, new(order.CommandPlanetProduce), validator)
+	case order.CommandTypePlanetRouteSet:
+		return decodeCommand(c, new(order.CommandPlanetRouteSet), validator)
+	case order.CommandTypePlanetRouteRemove:
+		return decodeCommand(c, new(order.CommandPlanetRouteRemove), validator)
+	default:
+		return nil, fmt.Errorf("unknown comman type: %s", t)
+	}
+}
+
+func decodeCommand(m json.RawMessage, c order.DecodableCommand, validator func(order.DecodableCommand) error) (order.DecodableCommand, error) {
+	v, err := unmarshallCommand(m, c)
+	if err != nil {
+		return nil, err
+	}
+	if validator != nil {
+		err = validator(v)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return v, nil
+}
+
+func unmarshallCommand[T order.DecodableCommand](c json.RawMessage, v T) (T, error) {
+	if err := json.Unmarshal(c, v); err != nil {
+		return v, err
+	}
+	return v, nil
+}

game/internal/repo/repo.go

@@ -0,0 +1,90 @@
+package repo
+
+import (
+	"encoding"
+	"errors"
+
+	e "galaxy/error"
+
+	"galaxy/game/internal/repo/fs"
+)
+
+func NewStorageError(err error) error {
+	return e.NewRepoError(err)
+}
+
+func NewGameNotInitializedError() error {
+	return e.NewGameNotInitializedError()
+}
+
+func NewReportNotFoundError() error {
+	return e.NewReportNotFoundError()
+}
+
+func NewStateError(msg string) error {
+	return e.NewGameStateError(msg)
+}
+
+type Storage interface {
+	Lock() (func() error, error)
+	Exists(string) (bool, error)
+	Write(string, encoding.BinaryMarshaler) error
+	WriteSafe(string, encoding.BinaryMarshaler) error
+	Read(string, encoding.BinaryUnmarshaler) error
+	ReadSafe(string, encoding.BinaryUnmarshaler) error
+}
+
+type repo struct {
+	s       Storage
+	release func() error
+}
+
+func NewRepo(s Storage) (*repo, error) {
+	r := &repo{
+		s: s,
+	}
+	return r, nil
+}
+
+func NewFileRepo(path string) (*repo, error) {
+	s, err := fs.NewFileStorage(path)
+	if err != nil {
+		return nil, err
+	}
+	return NewRepo(s)
+}
+
+func (r *repo) Lock() (err error) {
+	if r.s == nil {
+		return errors.New("storage is closed")
+	}
+	if r.release != nil {
+		return errors.New("storage already locked")
+	}
+	r.release, err = r.s.Lock()
+	if err != nil {
+		r.close()
+		return
+	}
+	return nil
+}
+
+func (r *repo) Release() (err error) {
+	if r.s == nil {
+		return errors.New("storage is closed")
+	}
+	if r.release == nil {
+		return errors.New("storage was never locked")
+	}
+	err = r.release()
+	if err != nil {
+		return
+	}
+	r.close()
+	return nil
+}
+
+func (r *repo) close() {
+	r.release = nil
+	r.s = nil
+}

game/internal/repo/repo_export_test.go

@@ -0,0 +1,15 @@
+package repo
+
+import (
+	"galaxy/model/order"
+
+	"github.com/google/uuid"
+)
+
+func LoadOrder_T(s Storage, t uint, id uuid.UUID) (*order.Order, bool, error) {
+	return loadOrder(s, t, id)
+}
+
+func SaveOrder_T(s Storage, t uint, id uuid.UUID, o *order.Order) error {
+	return saveOrder(s, t, id, o)
+}

game/internal/repo/repo_test.go

@@ -0,0 +1,121 @@
+package repo_test
+
+import (
+	"path/filepath"
+	"testing"
+
+	"galaxy/model/order"
+
+	"galaxy/game/internal/repo"
+	"galaxy/game/internal/repo/fs"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSaveOrder(t *testing.T) {
+	root := t.ArtifactDir()
+	s, err := fs.NewFileStorage(root)
+	assert.NoError(t, err)
+	id := uuid.New()
+	o := &order.Order{
+		Commands: []order.DecodableCommand{
+			&order.CommandRaceVote{
+				CommandMeta: order.CommandMeta{
+					CmdType: order.CommandTypeRaceVote,
+					CmdID:   uuid.New().String(),
+				},
+				Acceptor: "Race_acc",
+			},
+			&order.CommandShipClassCreate{
+				CommandMeta: order.CommandMeta{
+					CmdType: order.CommandTypeShipClassCreate,
+					CmdID:   uuid.New().String(),
+				},
+				Name:     "Fighter",
+				Drive:    20.5,
+				Armament: 5,
+				Weapons:  20,
+				Shields:  15.5,
+				Cargo:    0,
+			},
+			&order.CommandShipGroupMerge{
+				CommandMeta: order.CommandMeta{
+					CmdType: order.CommandTypeShipGroupMerge,
+					CmdID:   uuid.New().String(),
+				},
+			},
+			&order.CommandShipClassCreate{
+				CommandMeta: order.CommandMeta{
+					CmdType: order.CommandTypeShipClassCreate,
+					CmdID:   uuid.New().String(),
+				},
+				Name:     "Freighter",
+				Drive:    30.33,
+				Armament: 1,
+				Weapons:  1,
+				Shields:  10.1,
+				Cargo:    0,
+			},
+			&order.CommandRaceQuit{
+				CommandMeta: order.CommandMeta{
+					CmdType: order.CommandTypeRaceQuit,
+					CmdID:   uuid.New().String(),
+				},
+			},
+		},
+	}
+	var turn uint = 2
+
+	for i := range o.Commands {
+		if v, ok := order.AsCommand[*order.CommandRaceVote](o.Commands[i]); ok {
+			m := &v.CommandMeta
+			m.Result(0)
+		} else if v, ok := order.AsCommand[*order.CommandRaceQuit](o.Commands[i]); ok {
+			v.Result(10)
+		} else if v, ok := order.AsCommand[*order.CommandShipClassCreate](o.Commands[i]); ok {
+			m := &v.CommandMeta
+			m.Result(33)
+		} else if v, ok := order.AsCommand[*order.CommandShipGroupMerge](o.Commands[i]); ok {
+			v.Result(0)
+		}
+	}
+
+	assert.NoError(t, repo.SaveOrder_T(s, turn, id, o))
+	assert.FileExists(t, filepath.Join(root, repo.OrderDir(turn, id)))
+
+	LoadOrderTest(t, s, root, turn, id, o)
+}
+
+func LoadOrderTest(t *testing.T, s repo.Storage, root string, turn uint, id uuid.UUID, expected *order.Order) {
+	o, ok, err := repo.LoadOrder_T(s, turn, id)
+	assert.NoError(t, err)
+	assert.True(t, ok)
+	assert.Len(t, o.Commands, 5)
+	assert.ElementsMatch(t, expected.Commands, o.Commands)
+
+	CommandResultTest(t, o)
+}
+
+func CommandResultTest(t *testing.T, o *order.Order) {
+	assert.NotEmpty(t, o.Commands)
+	for i := range o.Commands {
+		if v, ok := order.AsCommand[*order.CommandRaceVote](o.Commands[i]); ok {
+			assert.NotNil(t, v.CmdApplied)
+			assert.True(t, *v.CmdApplied)
+			assert.Equal(t, 0, *v.CmdErrCode)
+		} else if v, ok := order.AsCommand[*order.CommandRaceQuit](o.Commands[i]); ok {
+			assert.NotNil(t, v.CmdApplied)
+			assert.False(t, *v.CmdApplied)
+			assert.Equal(t, 10, *v.CmdErrCode)
+		} else if v, ok := order.AsCommand[*order.CommandShipClassCreate](o.Commands[i]); ok {
+			assert.NotNil(t, v.CmdApplied)
+			assert.False(t, *v.CmdApplied)
+			assert.Equal(t, 33, *v.CmdErrCode)
+		} else if v, ok := order.AsCommand[*order.CommandShipGroupMerge](o.Commands[i]); ok {
+			assert.NotNil(t, v.CmdApplied)
+			assert.True(t, *v.CmdApplied)
+			assert.Equal(t, 0, *v.CmdErrCode)
+		}
+	}
+}