[feature] Preserve refereeEvent history as well

Author: g3force

.gitignore

@@ -21,4 +21,4 @@ yarn-debug.log*
 yarn-error.log*
 
 # app-specific ignores
-logs
+history.json

internal/app/controller/apiServer.go

@@ -8,17 +8,19 @@ import (
 )
 
 type ApiServer struct {
-	Consumer    EventConsumer
-	connections []*websocket.Conn
+	Consumer            EventConsumer
+	connections         []*websocket.Conn
+	latestState         State
+	latestRefereeEvents []RefereeEvent
 }
 
 type EventConsumer interface {
 	OnNewEvent(event Event)
 }
 
 type MessageWrapper struct {
-	State      *State          `json:"state"`
-	GameEvents *[]RefereeEvent `json:"gameEvents"`
+	State         *State          `json:"state"`
+	RefereeEvents *[]RefereeEvent `json:"gameEvents"`
 }
 
 // WsHandler handles incoming web socket connections
@@ -40,6 +42,8 @@ func (a *ApiServer) WsHandler(w http.ResponseWriter, r *http.Request) {
 
 	a.connections = append(a.connections, conn)
 
+	a.publishFullWrapper(conn)
+
 	a.listenForNewEvents(conn)
 }
 
@@ -57,13 +61,27 @@ func (a *ApiServer) PublishWrapper(wrapper MessageWrapper) {
 	}
 }
 
+func (a *ApiServer) publishFullWrapper(conn *websocket.Conn) {
+	wrapper := MessageWrapper{&a.latestState, &a.latestRefereeEvents}
+	b, err := json.Marshal(wrapper)
+	if err != nil {
+		log.Println("Marshal error:", err)
+	}
+	err = conn.WriteMessage(websocket.TextMessage, b)
+	if err != nil {
+		log.Println("Could not write message.", err)
+	}
+}
+
 func (a *ApiServer) PublishState(state State) {
+	a.latestState = state
 	wrapper := MessageWrapper{State: &state}
 	a.PublishWrapper(wrapper)
 }
 
-func (a *ApiServer) PublishGameEvents(gameEvents []RefereeEvent) {
-	wrapper := MessageWrapper{GameEvents: &gameEvents}
+func (a *ApiServer) PublishGameEvents(events []RefereeEvent) {
+	a.latestRefereeEvents = events
+	wrapper := MessageWrapper{RefereeEvents: &events}
 	a.PublishWrapper(wrapper)
 }
 

internal/app/controller/controller.go

@@ -1,27 +1,20 @@
 package controller
 
 import (
-	"encoding/json"
 	"github.com/RoboCup-SSL/ssl-game-controller/pkg/timer"
-	"io"
 	"log"
-	"os"
-	"time"
 )
 
-const logDir = "logs"
-const lastStateFileName = logDir + "/lastState.json"
 const configFileName = "config/ssl-game-controller.yaml"
 
 // GameController controls a game
 type GameController struct {
 	Config           Config
-	stateHistoryFile *os.File
-	lastStateFile    *os.File
 	Publisher        Publisher
 	ApiServer        ApiServer
 	Engine           Engine
 	timer            timer.Timer
+	historyPreserver HistoryPreserver
 }
 
 // NewGameController creates a new RefBox
@@ -42,34 +35,41 @@ func NewGameController() (r *GameController) {
 // Run the GameController by starting an endless loop in the background
 func (r *GameController) Run() (err error) {
 
-	r.openStateFiles()
-	r.readLastState()
+	if err := r.historyPreserver.Open(); err != nil {
+		log.Print("Could not open history", err)
+	} else {
+		history, err := r.historyPreserver.Load()
+		if err != nil {
+			log.Print("Could not load history", err)
+		} else if len(*history) > 0 {
+			r.Engine.History = *history
+			*r.Engine.State = r.Engine.History[len(r.Engine.History)-1].State
+			r.Engine.RefereeEvents = r.Engine.History[len(r.Engine.History)-1].RefereeEvents
+		}
+	}
+
+	r.ApiServer.PublishState(*r.Engine.State)
+	r.ApiServer.PublishGameEvents(r.Engine.RefereeEvents)
 
 	go func() {
-		if r.stateHistoryFile != nil {
-			defer r.stateHistoryFile.Close()
-		}
-		if r.lastStateFile != nil {
-			defer r.lastStateFile.Close()
-		}
+		defer r.historyPreserver.Close()
 		for {
 			r.timer.WaitTillNextFullSecond()
 			r.Engine.Tick(r.timer.Delta())
-			r.saveLatestState()
-			r.publish(nil)
+			r.historyPreserver.Save(r.Engine.History)
+			r.publish()
 		}
 	}()
 	return nil
 }
 
 func (r *GameController) OnNewEvent(event Event) {
-	cmd, err := r.Engine.Process(event)
+	err := r.Engine.Process(event)
 	if err != nil {
 		log.Println("Could not process event:", event, err)
 	} else {
-		r.saveLatestState()
-		r.saveStateHistory()
-		r.publish(cmd)
+		r.historyPreserver.Save(r.Engine.History)
+		r.publish()
 		r.publishGameEvents()
 	}
 }
@@ -90,81 +90,13 @@ func loadConfig() Config {
 	return config
 }
 
-func (r *GameController) openStateFiles() {
-	os.MkdirAll(logDir, os.ModePerm)
-
-	stateHistoryLogFileName := logDir + "/state-history_" + time.Now().Format("2006-01-02_15-04-05") + ".log"
-	f, err := os.OpenFile(stateHistoryLogFileName, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
-	if err != nil {
-		log.Fatal("Can not open state history log file", err)
-	}
-	r.stateHistoryFile = f
-
-	f, err = os.OpenFile(lastStateFileName, os.O_RDWR|os.O_CREATE, 0600)
-	if err != nil {
-		log.Fatal("Can not open last state file", err)
-	}
-	r.lastStateFile = f
-}
-
-func (r *GameController) readLastState() {
-	bufSize := 10000
-	b := make([]byte, bufSize)
-	n, err := r.lastStateFile.Read(b)
-	if err != nil && err != io.EOF {
-		log.Fatal("Could not read from last state file ", err)
-	}
-	if n == bufSize {
-		log.Fatal("Buffer size too small")
-	}
-	if n > 0 {
-		err = json.Unmarshal(b[:n], r.Engine.State)
-		if err != nil {
-			log.Fatalf("Could not read last state: %v %v", string(b), err)
-		}
-	}
-}
-
 // publish publishes the state to the UI and the teams
-func (r *GameController) publish(command *EventCommand) {
+func (r *GameController) publish() {
 	r.ApiServer.PublishState(*r.Engine.State)
 	r.Publisher.Publish(r.Engine.State)
 }
 
 // publishGameEvents publishes the current list of game events
 func (r *GameController) publishGameEvents() {
-	r.ApiServer.PublishGameEvents(r.Engine.RefereeEvent)
-}
-
-// saveLatestState writes the current state into a file
-func (r *GameController) saveLatestState() {
-	jsonState, err := json.MarshalIndent(r.Engine.State, "", "  ")
-	if err != nil {
-		log.Print("Can not marshal state ", err)
-		return
-	}
-
-	err = r.lastStateFile.Truncate(0)
-	if err != nil {
-		log.Fatal("Can not truncate last state file ", err)
-	}
-	_, err = r.lastStateFile.WriteAt(jsonState, 0)
-	if err != nil {
-		log.Print("Could not write last state ", err)
-	}
-	r.lastStateFile.Sync()
-}
-
-// saveStateHistory writes the current state to the history file
-func (r *GameController) saveStateHistory() {
-
-	jsonState, err := json.Marshal(r.Engine.State)
-	if err != nil {
-		log.Print("Can not marshal state ", err)
-		return
-	}
-
-	r.stateHistoryFile.Write(jsonState)
-	r.stateHistoryFile.WriteString("\n")
-	r.stateHistoryFile.Sync()
+	r.ApiServer.PublishGameEvents(r.Engine.RefereeEvents)
 }

internal/app/controller/engine.go

@@ -8,13 +8,15 @@ import (
 	"time"
 )
 
+const maxHistorySize = 10
+
 type Engine struct {
-	State        *State
-	StageTimes   map[Stage]time.Duration
-	config       ConfigGame
-	StateHistory []State
-	TimeProvider func() time.Time
-	RefereeEvent []RefereeEvent
+	State         *State
+	RefereeEvents []RefereeEvent
+	StageTimes    map[Stage]time.Duration
+	config        ConfigGame
+	TimeProvider  func() time.Time
+	History       History
 }
 
 func NewEngine(config ConfigGame) (e Engine) {
@@ -31,7 +33,7 @@ func (e *Engine) ResetGame() {
 	e.State.TeamState[TeamYellow].TimeoutTimeLeft = e.config.Normal.TimeoutDuration
 	e.State.TeamState[TeamBlue].TimeoutsLeft = e.config.Normal.Timeouts
 	e.State.TeamState[TeamYellow].TimeoutsLeft = e.config.Normal.Timeouts
-	e.RefereeEvent = []RefereeEvent{}
+	e.History = History{}
 }
 
 // Tick updates the times of the state and removes cards, if necessary
@@ -45,22 +47,26 @@ func (e *Engine) Tick(delta time.Duration) {
 
 // UndoLastAction restores the last state from internal history
 func (e *Engine) UndoLastAction() {
-	lastIndex := len(e.StateHistory) - 2
+	lastIndex := len(e.History) - 2
 	if lastIndex >= 0 {
-		*e.State = e.StateHistory[lastIndex]
-		e.StateHistory = e.StateHistory[0:lastIndex]
+		*e.State = e.History[lastIndex].State
+		e.History = e.History[0:lastIndex]
 	}
 }
 
-func (e *Engine) Process(event Event) (*EventCommand, error) {
+func (e *Engine) Process(event Event) error {
 	cmd, err := e.processEvent(event)
-	if err == nil {
-		e.StateHistory = append(e.StateHistory, *e.State)
+	if err != nil {
+		return err
 	}
 	if cmd != nil {
 		e.LogCommand(cmd)
 	}
-	return cmd, err
+	e.History = append(e.History, HistoryEntry{*e.State, e.RefereeEvents})
+	if len(e.History) > maxHistorySize {
+		e.History = e.History[1:]
+	}
+	return nil
 }
 
 func (e *Engine) LogGameEvent(eventType GameEventType) {
@@ -70,7 +76,7 @@ func (e *Engine) LogGameEvent(eventType GameEventType) {
 		Type:          RefereeEventGameEvent,
 		GameEventType: &eventType,
 	}
-	e.RefereeEvent = append(e.RefereeEvent, gameEvent)
+	e.RefereeEvents = append(e.RefereeEvents, gameEvent)
 }
 
 func (e *Engine) LogCommand(command *EventCommand) {
@@ -81,7 +87,7 @@ func (e *Engine) LogCommand(command *EventCommand) {
 		Command:   &command.Type,
 		Team:      command.ForTeam,
 	}
-	e.RefereeEvent = append(e.RefereeEvent, gameEvent)
+	e.RefereeEvents = append(e.RefereeEvents, gameEvent)
 }
 
 func (e *Engine) loadStages() {