Assign unique ids the proposal groups

Before, they were referenced by their array index, but at the same time, the array was limited to 5 proposals groups and shifted, so a wrong proposal group could be accepted.

Author: g3force

frontend/src/proto/ssl_gc_state.ts

@@ -208,6 +208,8 @@ export interface ProposalGroup {
   proposals?: Proposal[];
   /** Whether the proposal group was accepted */
   accepted?: boolean;
+  /** unique id of the proposal group */
+  id?: number;
 }
 
 export interface TeamInfo {
@@ -376,6 +378,7 @@ export const ProposalGroup = {
     return {
       proposals: Array.isArray(object?.proposals) ? object.proposals.map((e: any) => Proposal.fromJSON(e)) : [],
       accepted: isSet(object.accepted) ? Boolean(object.accepted) : false,
+      id: isSet(object.id) ? Number(object.id) : 0,
     };
   },
 
@@ -387,6 +390,7 @@ export const ProposalGroup = {
       obj.proposals = [];
     }
     message.accepted !== undefined && (obj.accepted = message.accepted);
+    message.id !== undefined && (obj.id = Math.round(message.id));
     return obj;
   },
 };

internal/app/engine/process_proposals.go

@@ -10,7 +10,7 @@ import (
 const maxProposals = 5
 
 func (e *Engine) processProposals() {
-	for i, group := range e.currentState.ProposalGroups {
+	for _, group := range e.currentState.ProposalGroups {
 		latestGameEvent := group.Proposals[len(group.Proposals)-1].GameEvent
 		if *group.Accepted ||
 			e.groupIsStillAcceptingProposals(group) ||
@@ -23,13 +23,12 @@ func (e *Engine) processProposals() {
 
 		if numProposals > majority {
 			log.Printf("Majority of %v reached with %v out of %v for %v.", majority, numProposals, numAutoRefs, latestGameEvent.Type)
-			groupId := uint32(i)
 			acceptedBy := "Majority"
 			e.Enqueue(&statemachine.Change{
 				Origin: &changeOriginEngine,
 				Change: &statemachine.Change_AcceptProposalGroupChange{
 					AcceptProposalGroupChange: &statemachine.Change_AcceptProposalGroup{
-						GroupId:    &groupId,
+						GroupId:    group.Id,
 						AcceptedBy: &acceptedBy,
 					},
 				},

internal/app/state/ssl_gc_state.pb.go

@@ -8,13 +8,12 @@ import (
 
 func (s *StateMachine) processChangeAcceptProposals(newState *state.State, change *Change_AcceptProposalGroup) (changes []*Change) {
 
-	numGroups := len(newState.ProposalGroups)
-	if int(*change.GroupId) >= numGroups {
-		log.Printf("Proposal group id %v invalid, there are only  %v groups", *change.GroupId, numGroups)
+	group := findGroupById(newState.ProposalGroups, *change.GroupId)
+	if group == nil {
+		log.Printf("Proposal group with id %v can not be accepted, as it was not found", *change.GroupId)
 		return
 	}
 
-	group := newState.ProposalGroups[*change.GroupId]
 	majorityEvent := s.createMergedGameEvent(group.Proposals, change.AcceptedBy)
 	changes = append(changes, &Change{
 		Change: &Change_AddGameEventChange{
@@ -29,6 +28,15 @@ func (s *StateMachine) processChangeAcceptProposals(newState *state.State, chang
 	return
 }
 
+func findGroupById(groups []*state.ProposalGroup, id uint32) *state.ProposalGroup {
+	for _, group := range groups {
+		if *group.Id == id {
+			return group
+		}
+	}
+	return nil
+}
+
 func (s *StateMachine) createMergedGameEvent(proposals []*state.Proposal, acceptedBy *string) *state.GameEvent {
 	event := new(state.GameEvent)
 	proto.Merge(event, proposals[0].GameEvent)

internal/app/statemachine/change_acceptproposal.go

@@ -13,9 +13,12 @@ func (s *StateMachine) processChangeAddProposal(newState *state.State, change *C
 	if ok, pid := findGroup(change.Proposal, newState.ProposalGroups, s.gameConfig.AutoRefProposalTimeout); ok {
 		newState.ProposalGroups[pid].Proposals = append(newState.ProposalGroups[pid].Proposals, change.Proposal)
 	} else {
+		groupId := s.nextProposalGroupId
+		s.nextProposalGroupId++
 		newState.ProposalGroups = append(newState.ProposalGroups, &state.ProposalGroup{
 			Proposals: []*state.Proposal{change.Proposal},
 			Accepted:  new(bool),
+			Id:        &groupId,
 		})
 	}
 

internal/app/statemachine/change_proposedgameevent.go

@@ -14,11 +14,12 @@ var changeOriginStateMachine = "StateMachine"
 
 // StateMachine describes the state machine that translates changes into new states
 type StateMachine struct {
-	gameConfig   config.Game
-	Geometry     config.Geometry
-	stageTimes   map[state.Referee_Stage]time.Duration
-	rand         *rand.Rand
-	timeProvider timer.TimeProvider
+	gameConfig          config.Game
+	Geometry            config.Geometry
+	stageTimes          map[state.Referee_Stage]time.Duration
+	rand                *rand.Rand
+	timeProvider        timer.TimeProvider
+	nextProposalGroupId uint32
 }
 
 // NewStateMachine creates a new state machine

internal/app/statemachine/statemachine.go

@@ -75,6 +75,8 @@ message ProposalGroup {
     repeated Proposal proposals = 1;
     // Whether the proposal group was accepted
     optional bool accepted = 2;
+    // unique id of the proposal group
+    optional uint32 id = 3;
 }
 
 message TeamInfo {