Feature: Create separate engine config for behavior and autoRef specifics

Author: g3force

config/engine.yaml

@@ -0,0 +1,49 @@
+{
+  "gameEventBehavior": {
+    "AIMLESS_KICK": "GAME_EVENT_BEHAVIOR_ON",
+    "ATTACKER_DOUBLE_TOUCHED_BALL": "GAME_EVENT_BEHAVIOR_ON",
+    "ATTACKER_TOO_CLOSE_TO_DEFENSE_AREA": "GAME_EVENT_BEHAVIOR_ON",
+    "ATTACKER_TOUCHED_BALL_IN_DEFENSE_AREA": "GAME_EVENT_BEHAVIOR_ON",
+    "ATTACKER_TOUCHED_OPPONENT_IN_DEFENSE_AREA": "GAME_EVENT_BEHAVIOR_ON",
+    "ATTACKER_TOUCHED_OPPONENT_IN_DEFENSE_AREA_SKIPPED": "GAME_EVENT_BEHAVIOR_ON",
+    "BALL_LEFT_FIELD_GOAL_LINE": "GAME_EVENT_BEHAVIOR_ON",
+    "BALL_LEFT_FIELD_TOUCH_LINE": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_CRASH_DRAWN": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_CRASH_UNIQUE": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_CRASH_UNIQUE_SKIPPED": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_DRIBBLED_BALL_TOO_FAR": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_HELD_BALL_DELIBERATELY": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_INTERFERED_PLACEMENT": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_KICKED_BALL_TOO_FAST": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_PUSHED_BOT": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_PUSHED_BOT_SKIPPED": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_SUBSTITUTION": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_TIPPED_OVER": "GAME_EVENT_BEHAVIOR_ON",
+    "BOT_TOO_FAST_IN_STOP": "GAME_EVENT_BEHAVIOR_ON",
+    "BOUNDARY_CROSSING": "GAME_EVENT_BEHAVIOR_ON",
+    "CHIPPED_GOAL": "GAME_EVENT_BEHAVIOR_ON",
+    "DEFENDER_IN_DEFENSE_AREA": "GAME_EVENT_BEHAVIOR_ON",
+    "DEFENDER_IN_DEFENSE_AREA_PARTIALLY": "GAME_EVENT_BEHAVIOR_ON",
+    "DEFENDER_TOO_CLOSE_TO_KICK_POINT": "GAME_EVENT_BEHAVIOR_ON",
+    "GOAL": "GAME_EVENT_BEHAVIOR_ON",
+    "INDIRECT_GOAL": "GAME_EVENT_BEHAVIOR_ON",
+    "INVALID_GOAL": "GAME_EVENT_BEHAVIOR_ON",
+    "KEEPER_HELD_BALL": "GAME_EVENT_BEHAVIOR_ON",
+    "KICK_TIMEOUT": "GAME_EVENT_BEHAVIOR_ON",
+    "MULTIPLE_CARDS": "GAME_EVENT_BEHAVIOR_ON",
+    "MULTIPLE_FOULS": "GAME_EVENT_BEHAVIOR_ON",
+    "MULTIPLE_PLACEMENT_FAILURES": "GAME_EVENT_BEHAVIOR_ON",
+    "NO_PROGRESS_IN_GAME": "GAME_EVENT_BEHAVIOR_ON",
+    "PENALTY_KICK_FAILED": "GAME_EVENT_BEHAVIOR_ON",
+    "PLACEMENT_FAILED": "GAME_EVENT_BEHAVIOR_ON",
+    "PLACEMENT_SUCCEEDED": "GAME_EVENT_BEHAVIOR_ON",
+    "POSSIBLE_GOAL": "GAME_EVENT_BEHAVIOR_ON",
+    "PREPARED": "GAME_EVENT_BEHAVIOR_ON",
+    "TOO_MANY_ROBOTS": "GAME_EVENT_BEHAVIOR_ON",
+    "UNKNOWN_GAME_EVENT_TYPE": "GAME_EVENT_BEHAVIOR_ON",
+    "UNSPORTING_BEHAVIOR_MAJOR": "GAME_EVENT_BEHAVIOR_ON",
+    "UNSPORTING_BEHAVIOR_MINOR": "GAME_EVENT_BEHAVIOR_ON"
+  },
+  "autoRefConfigs": {
+  }
+}

config/ssl-game-controller.yaml

@@ -14,6 +14,8 @@ server:
     trusted-keys-dir: config/trusted_keys/team
   ci:
     address: :10009
+engine:
+  config-filename: config/engine.yaml
 game:
   state-store-file: state-store.json.stream
   yellow-card-duration: 2m

generateProto.sh

@@ -34,6 +34,7 @@ protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_state.pro
 protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_change.proto
 protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_api.proto
 protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_engine.proto
+protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_engine_config.proto
 
 # continuous integration communication
 protoc -I"./proto" -I"$GOPATH/src" --go_out="$GOPATH/src" proto/ssl_gc_ci.proto

internal/app/api/server.go

@@ -9,6 +9,7 @@ import (
 	"github.com/golang/protobuf/proto"
 	"github.com/golang/protobuf/ptypes"
 	"github.com/gorilla/websocket"
+	"github.com/odeke-em/go-uuid"
 	"log"
 	"net/http"
 	"reflect"
@@ -27,6 +28,7 @@ type ServerConnection struct {
 	lastPublishedState *state.State
 	lastGcState        *engine.GcState
 	lastProtocolId     int32
+	lastConfig         *engine.Config
 	marshaler          jsonpb.Marshaler
 }
 
@@ -71,13 +73,15 @@ func (a *Server) WsHandler(w http.ResponseWriter, r *http.Request) {
 
 func (s *ServerConnection) publish() {
 	hook := make(chan engine.HookOut, 10)
-	s.gcEngine.RegisterHook("apiServer", hook)
+	hookId := "apiServer-" + uuid.New()
+	s.gcEngine.RegisterHook(hookId, hook)
 	defer func() {
-		s.gcEngine.UnregisterHook("apiServer")
+		s.gcEngine.UnregisterHook(hookId)
 		close(hook)
 	}()
 
 	s.publishGcState()
+	s.publishConfig()
 	s.publishState(s.gcEngine.CurrentState())
 	s.publishProtocolFull()
 
@@ -91,6 +95,7 @@ func (s *ServerConnection) publish() {
 				s.publishProtocolDelta()
 			} else if hookOut.State != nil {
 				s.publishGcState()
+				s.publishConfig()
 				s.publishState(hookOut.State)
 				if s.gcEngine.LatestChangeId() != s.lastProtocolId {
 					s.publishProtocolFull()
@@ -124,6 +129,17 @@ func (s *ServerConnection) publishGcState() {
 	}
 }
 
+func (s *ServerConnection) publishConfig() {
+	cfg := s.gcEngine.GetConfig()
+
+	if !reflect.DeepEqual(cfg, s.lastConfig) {
+		out := Output{Config: cfg}
+		s.publishOutput(&out)
+		s.lastConfig = &engine.Config{}
+		proto.Merge(s.lastConfig, cfg)
+	}
+}
+
 func (s *ServerConnection) publishProtocolFull() {
 	changes := s.gcEngine.LatestChangesUntil(-1)
 	entries := s.changesToProtocolEntries(changes)
@@ -227,6 +243,9 @@ func (a *Server) handleNewEventMessage(b []byte) {
 	if in.ResetMatch != nil && *in.ResetMatch {
 		a.gcEngine.ResetMatch()
 	}
+	if in.ConfigDelta != nil {
+		a.gcEngine.UpdateConfig(in.ConfigDelta)
+	}
 }
 
 func stateChanged(s1, s2 *state.State) bool {
@@ -277,9 +296,6 @@ func stateChanged(s1, s2 *state.State) bool {
 	if *s1.FirstKickoffTeam != *s2.FirstKickoffTeam {
 		return true
 	}
-	if !reflect.DeepEqual(s1.GameEventBehavior, s2.GameEventBehavior) {
-		return true
-	}
 	return false
 }
 

internal/app/api/ssl_gc_api.pb.go

@@ -94,12 +94,17 @@ type ServerCi struct {
 	Address string `yaml:"address"`
 }
 
+type Engine struct {
+	ConfigFilename string `yaml:"config-filename"`
+}
+
 // Controller structure for the game controller
 type Controller struct {
 	Network             Network             `yaml:"network"`
 	Game                Game                `yaml:"game"`
 	Server              Server              `yaml:"server"`
 	TimeAcquisitionMode TimeAcquisitionMode `yaml:"time-acquisition-mode"`
+	Engine              Engine              `yaml:"engine"`
 }
 
 type TimeAcquisitionMode string
@@ -224,6 +229,8 @@ func DefaultControllerConfig() (c Controller) {
 
 	c.TimeAcquisitionMode = TimeAcquisitionModeSystem
 
+	c.Engine.ConfigFilename = "config/engine.yaml"
+
 	return
 }
 

internal/app/config/config.go

@@ -14,6 +14,8 @@ server:
     trusted-keys-dir: config/trusted_keys/team
   ci:
     address: :10009
+engine:
+  config-filename: config/engine.yaml
 game:
   state-store-file: state-store.json.stream
   yellow-card-duration: 2m

internal/app/config/testdata/config.yaml

@@ -0,0 +1,74 @@
+package engine
+
+import (
+	"github.com/RoboCup-SSL/ssl-game-controller/internal/app/state"
+	"github.com/golang/protobuf/jsonpb"
+	"github.com/pkg/errors"
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+)
+
+func DefaultConfig() (c Config) {
+	c.AutoRefConfigs = map[string]*AutoRefConfig{}
+	c.GameEventBehavior = map[string]Config_GameEventBehavior{}
+	for _, event := range state.AllGameEvents() {
+		c.GameEventBehavior[event.String()] = Config_GAME_EVENT_BEHAVIOR_ON
+	}
+	return
+}
+
+// ReadFrom loads a config from given file
+func (m *Config) ReadFrom(fileName string) (err error) {
+
+	f, err := os.OpenFile(fileName, os.O_RDONLY, 0600)
+	if err != nil {
+		return
+	}
+	b, err := ioutil.ReadAll(f)
+	if err != nil {
+		return
+	}
+
+	err = jsonpb.UnmarshalString(string(b), m)
+	if err != nil {
+		err = errors.Wrapf(err, "Could not unmarshal config file %v", fileName)
+	}
+
+	return
+}
+
+// LoadControllerConfig loads the controller config, creating a default one if it is not present yet
+func (m *Config) LoadControllerConfig(configFileName string) {
+	err := m.ReadFrom(configFileName)
+	if err != nil {
+		log.Printf("Could not load config: %v", err)
+		*m = DefaultConfig()
+		err = m.WriteTo(configFileName)
+		if err != nil {
+			log.Printf("Failed to write a default config file to %v: %v", configFileName, err)
+		} else {
+			log.Println("New default config has been written to ", configFileName)
+		}
+	}
+	return
+}
+
+// WriteTo writes the config to the given file
+func (m *Config) WriteTo(fileName string) (err error) {
+	marshaler := jsonpb.Marshaler{Indent: "  "}
+	jsonStr, err := marshaler.MarshalToString(m)
+	if err != nil {
+		err = errors.Wrapf(err, "Could not marshal config %v", m)
+		return
+	}
+	err = os.MkdirAll(filepath.Dir(fileName), 0755)
+	if err != nil {
+		err = errors.Wrapf(err, "Could not create directory for config file: %v", fileName)
+		return
+	}
+	err = ioutil.WriteFile(fileName, []byte(jsonStr), 0600)
+	log.Printf("Written to %v", fileName)
+	return
+}