Ilia Denisov
601970b028
Three-stage refactor of the game-engine plumbing (game logic untouched): Stage 1 — lock-free persistence + admin serialisation. Remove the file lock from repo/fs (the .lock file, the Read/Write-vs-*Safe duality and the dead ReadSafe polling) and replace the two-step rename with a single atomic rename so concurrent reads are torn-free without a lock. Serialise the state-mutating admin writers (init/turn/banish) with one shared router LimitMiddleware, rewritten to block on the request context instead of a racy shared 100ms timer. Stage 2 — remove the obsolete immediate-command path end to end. Players submit through PUT /api/v1/order; the legacy PUT /api/v1/command path is deleted across game (route, handler, 24 command factories, Ctrl), backend (Commands handler/route, engineclient.ExecuteCommands), gateway (dispatch + executeUserGamesCommand + routing entry), the FlatBuffers/model contract (UserGamesCommand[Response]) and transcoder, plus every affected OpenAPI/README/FUNCTIONAL/ARCHITECTURE doc. The integration proxy test is converted to the order path. Stage 3 — flatten the REST->engine wrapper. Replace the executor adapter, the controller package functions and RepoController with one concrete controller.Service; drop the single-implementation Repo and Storage interfaces (repo.Repo / fs.FS are now concrete). Handlers depend on a thin handler.Engine seam and own the domain->REST projection; storage is resolved once at startup instead of per request. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
45 lines
964 B
Go
45 lines
964 B
Go
package repo
|
|
|
|
import (
|
|
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)
|
|
}
|
|
|
|
// Repo persists game state through a file-backed FS. Reads and writes are
|
|
// atomic and lock-free: Write swaps a fully written file into place with
|
|
// rename, so Read never observes a partial file. Serialising concurrent
|
|
// writers to the same state file is the caller's concern (the engine does it
|
|
// at the router, see LimitMiddleware).
|
|
type Repo struct {
|
|
s *fs.FS
|
|
}
|
|
|
|
func NewRepo(s *fs.FS) (*Repo, error) {
|
|
return &Repo{s: s}, nil
|
|
}
|
|
|
|
func NewFileRepo(path string) (*Repo, error) {
|
|
s, err := fs.NewFileStorage(path)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return NewRepo(s)
|
|
}
|