Support team registration when both teams have the same name

The team protocol was based on the team name only, so if
a team wants to play against itself, there was a conflict
with the team name.
Now, if the team can be send with the team name to solve this conflict.

Author: g3force

internal/app/api/ssl_gc_api.pb.go

@@ -136,10 +136,11 @@ func (s *Server) CloseConnection(id string) {
 	log.Printf("Connection to %v closed", id)
 }
 
-func (c *Client) Ok() (reply ControllerReply) {
+func (c *Client) Ok() (reply *ControllerReply) {
+	reply = new(ControllerReply)
 	reply.StatusCode = new(ControllerReply_StatusCode)
 	*reply.StatusCode = ControllerReply_OK
-	c.addVerification(&reply)
+	c.addVerification(reply)
 	return
 }
 
@@ -156,13 +157,14 @@ func (c *Client) addVerification(reply *ControllerReply) {
 	}
 }
 
-func (c *Client) Reject(reason string) (reply ControllerReply) {
+func (c *Client) Reject(reason string) (reply *ControllerReply) {
 	log.Print("Reject request: " + reason)
+	reply = new(ControllerReply)
 	reply.StatusCode = new(ControllerReply_StatusCode)
 	*reply.StatusCode = ControllerReply_REJECTED
 	reply.Reason = new(string)
 	*reply.Reason = reason
-	c.addVerification(&reply)
+	c.addVerification(reply)
 	return
 }
 

internal/app/ci/ssl_gc_ci.pb.go

@@ -118,23 +118,23 @@ func (s *AutoRefServer) handleClientConnection(conn net.Conn) {
 				continue
 			}
 		}
-		if err := s.processRequest(client.id, req); err != nil {
+		if err := s.processRequest(client.id, &req); err != nil {
 			client.reply(client.Reject(err.Error()))
 		} else {
 			client.reply(client.Ok())
 		}
 	}
 }
 
-func (c *AutoRefClient) reply(reply ControllerReply) {
-	msg := ControllerToAutoRef_ControllerReply{ControllerReply: &reply}
+func (c *AutoRefClient) reply(reply *ControllerReply) {
+	msg := ControllerToAutoRef_ControllerReply{ControllerReply: reply}
 	response := ControllerToAutoRef{Msg: &msg}
 	if err := sslconn.SendMessage(c.conn, &response); err != nil {
 		log.Print("Failed to send reply: ", err)
 	}
 }
 
-func (s *AutoRefServer) processRequest(id string, request AutoRefToController) error {
+func (s *AutoRefServer) processRequest(id string, request *AutoRefToController) error {
 
 	if request.GameEvent != nil {
 		request.GameEvent.Origin = []string{id}

internal/app/engine/ssl_gc_engine.pb.go

@@ -112,7 +112,7 @@ func (s *RemoteControlServer) handleClientConnection(conn net.Conn) {
 				continue
 			}
 		}
-		if response, err := s.processRequest(*client.team, req); err != nil {
+		if response, err := s.processRequest(*client.team, &req); err != nil {
 			client.reply(client.Reject(err.Error()))
 		} else {
 			client.replyWithPayload(client.Ok(), response)
@@ -129,24 +129,24 @@ func (s *RemoteControlServer) updateConnectionState(client RemoteControlClient,
 	})
 }
 
-func (s *RemoteControlServer) SendRequest(teamName string, request ControllerToRemoteControl) error {
+func (s *RemoteControlServer) SendRequest(teamName string, request *ControllerToRemoteControl) error {
 	if client, ok := s.clients[teamName]; ok {
-		return sslconn.SendMessage(client.conn, &request)
+		return sslconn.SendMessage(client.conn, request)
 	}
 	return errors.Errorf("Remote control client '%v' not connected", teamName)
 }
 
-func (c *RemoteControlClient) reply(reply ControllerReply) {
-	response := ControllerToRemoteControl{ControllerReply: &reply}
+func (c *RemoteControlClient) reply(reply *ControllerReply) {
+	response := ControllerToRemoteControl{ControllerReply: reply}
 
 	if err := sslconn.SendMessage(c.conn, &response); err != nil {
 		log.Print("Failed to send reply: ", err)
 	}
 }
 
-func (c *RemoteControlClient) replyWithPayload(reply ControllerReply, response *ControllerToRemoteControl) {
+func (c *RemoteControlClient) replyWithPayload(reply *ControllerReply, response *ControllerToRemoteControl) {
 	if response != nil {
-		response.ControllerReply = &reply
+		response.ControllerReply = reply
 
 		if err := sslconn.SendMessage(c.conn, response); err != nil {
 			log.Print("Failed to send reply: ", err)
@@ -172,7 +172,7 @@ func gameEventPresent(events []*state.GameEvent, eventType state.GameEvent_Type,
 	return
 }
 
-func (s *RemoteControlServer) processRequest(team state.Team, request RemoteControlToController) (*ControllerToRemoteControl, error) {
+func (s *RemoteControlServer) processRequest(team state.Team, request *RemoteControlToController) (*ControllerToRemoteControl, error) {
 
 	if request.GetRequest() == RemoteControlToController_PING {
 		return nil, nil
@@ -195,7 +195,7 @@ func (s *RemoteControlServer) processRequest(team state.Team, request RemoteCont
 		}, nil
 	}
 
-	log.Print("Received request from remote-control: ", proto.MarshalTextString(&request))
+	log.Print("Received request from remote-control: ", proto.MarshalTextString(request))
 
 	currentState := s.gcEngine.CurrentState()
 	teamState := *currentState.TeamInfo(team)

internal/app/engine/ssl_gc_engine_config.pb.go

@@ -20,6 +20,8 @@ type TeamServer struct {
 }
 
 type TeamClient struct {
+	teamName string
+	team     state.Team
 	*Client
 }
 
@@ -38,8 +40,10 @@ func (c *TeamClient) receiveRegistration(reader *bufio.Reader, server *TeamServe
 	}
 
 	var allowedTeamNames []string
-	for _, teamInfo := range server.gcEngine.CurrentState().TeamState {
+	nameToTeamMap := map[string]state.Team{}
+	for team, teamInfo := range server.gcEngine.CurrentState().TeamState {
 		allowedTeamNames = append(allowedTeamNames, *teamInfo.Name)
+		nameToTeamMap[*teamInfo.Name] = state.Team(state.Team_value[team])
 	}
 
 	if registration.TeamName == nil {
@@ -48,11 +52,22 @@ func (c *TeamClient) receiveRegistration(reader *bufio.Reader, server *TeamServe
 	if !isAllowedTeamName(*registration.TeamName, allowedTeamNames) {
 		return errors.Errorf("Invalid team name: '%v'. Expecting one of these: %v", *registration.TeamName, allowedTeamNames)
 	}
-	c.id = *registration.TeamName
+	var team state.Team
+	if registration.Team != nil {
+		team = *registration.Team
+	} else if len(nameToTeamMap) == 2 {
+		team = nameToTeamMap[*registration.TeamName]
+	} else {
+		return errors.Errorf("No team specified and both teams have the same name. Specify the team (-color).")
+	}
+
+	c.id = team.String() + "-" + *registration.TeamName
+	c.team = team
+	c.teamName = *registration.TeamName
 	if _, exists := server.clients[c.id]; exists {
 		return errors.New("Team with given name already registered: " + c.id)
 	}
-	c.pubKey = server.trustedKeys[c.id]
+	c.pubKey = server.trustedKeys[*registration.TeamName]
 	if c.pubKey != nil {
 		if err := c.Client.verifyMessage(&registration); err != nil {
 			return err
@@ -97,21 +112,21 @@ func (s *TeamServer) handleClientConnection(conn net.Conn) {
 
 	s.clients[client.id] = client.Client
 	defer func() {
-		team := s.gcEngine.CurrentState().TeamByName(client.id)
 		s.gcEngine.UpdateGcState(func(gcState *engine.GcState) {
-			if teamState, ok := gcState.TeamState[team.String()]; ok {
+			if teamState, ok := gcState.TeamState[client.team.String()]; ok {
 				connected := false
 				teamState.Connected = &connected
 				teamState.ConnectionVerified = &connected
+			} else {
+				log.Println("Team not connected: " + client.team.String())
 			}
 		})
 		s.CloseConnection(client.id)
 	}()
 
 	log.Printf("Team Client %v connected", client.id)
-	team := s.gcEngine.CurrentState().TeamByName(client.id)
 	s.gcEngine.UpdateGcState(func(gcState *engine.GcState) {
-		if teamState, ok := gcState.TeamState[team.String()]; ok {
+		if teamState, ok := gcState.TeamState[client.team.String()]; ok {
 			connected := true
 			teamState.Connected = &connected
 			teamState.ConnectionVerified = &client.verifiedConnection
@@ -133,53 +148,52 @@ func (s *TeamServer) handleClientConnection(conn net.Conn) {
 				continue
 			}
 		}
-		if err := s.processRequest(client.id, req); err != nil {
+		if err := s.processRequest(client, &req); err != nil {
 			client.reply(client.Reject(err.Error()))
 		} else {
 			client.reply(client.Ok())
 		}
 	}
 }
 
-func (s *TeamServer) SendRequest(teamName string, request ControllerToTeam) error {
+func (s *TeamServer) SendRequest(teamName string, request *ControllerToTeam) error {
 	if client, ok := s.clients[teamName]; ok {
-		return sslconn.SendMessage(client.conn, &request)
+		return sslconn.SendMessage(client.conn, request)
 	}
 	return errors.Errorf("Team Client '%v' not connected", teamName)
 }
 
-func (c *TeamClient) reply(reply ControllerReply) {
-	msg := ControllerToTeam_ControllerReply{ControllerReply: &reply}
+func (c *TeamClient) reply(reply *ControllerReply) {
+	msg := ControllerToTeam_ControllerReply{ControllerReply: reply}
 	response := ControllerToTeam{Msg: &msg}
 	if err := sslconn.SendMessage(c.conn, &response); err != nil {
 		log.Print("Failed to send reply: ", err)
 	}
 }
 
-func (s *TeamServer) processRequest(teamName string, request TeamToController) error {
+func (s *TeamServer) processRequest(teamClient TeamClient, request *TeamToController) error {
 
 	if request.GetPing() {
 		return nil
 	}
 
-	log.Print("Received request from team: ", proto.MarshalTextString(&request))
+	log.Print("Received request from team: ", proto.MarshalTextString(request))
 
 	currentState := s.gcEngine.CurrentState()
-	team := currentState.TeamByName(teamName)
-	if team == state.Team_UNKNOWN {
+	if teamClient.team == state.Team_UNKNOWN {
 		return errors.New("Your team is not playing?!")
 	}
 
-	teamState := *currentState.TeamInfo(team)
+	teamState := *currentState.TeamInfo(teamClient.team)
 
 	if x, ok := request.GetMsg().(*TeamToController_SubstituteBot); ok {
 		if *timeSet(teamState.RequestsBotSubstitutionSince) != x.SubstituteBot {
-			log.Printf("Team %v requests to change bot substituation intent to %v", team, x.SubstituteBot)
+			log.Printf("Team %v requests to change bot substituation intent to %v", teamClient.id, x.SubstituteBot)
 			s.gcEngine.Enqueue(&statemachine.Change{
-				Origin: &teamName,
+				Origin: &teamClient.id,
 				Change: &statemachine.Change_UpdateTeamState{
 					UpdateTeamState: &statemachine.UpdateTeamState{
-						ForTeam:                 &team,
+						ForTeam:                 &teamClient.team,
 						RequestsBotSubstitution: &x.SubstituteBot,
 					}},
 			})
@@ -195,12 +209,12 @@ func (s *TeamServer) processRequest(teamName string, request TeamToController) e
 		if err := mayChangeKeeper(s.gcEngine.CurrentGcState(), &teamState); err != nil {
 			return errors.Wrap(err, "Team requests to change keeper, but: ")
 		}
-		log.Printf("Team %v requests to change keeper to %v", team, x.DesiredKeeper)
+		log.Printf("Team %v requests to change keeper to %v", teamClient.team, x.DesiredKeeper)
 		s.gcEngine.Enqueue(&statemachine.Change{
-			Origin: &teamName,
+			Origin: &teamClient.teamName,
 			Change: &statemachine.Change_UpdateTeamState{
 				UpdateTeamState: &statemachine.UpdateTeamState{
-					ForTeam:    &team,
+					ForTeam:    &teamClient.team,
 					Goalkeeper: &x.DesiredKeeper,
 				}},
 		})