Merge branch 'XX-2875/ClientErrMaster' into 'master'

port xx-2875 partially to master

See merge request elixxir/registration!247

cmd/poll.go

@@ -119,48 +119,43 @@ func (m *RegistrationImpl) Poll(msg *pb.PermissioningPoll, auth *connect.Auth,
 		return response, err
 	}
 
-	// if the node is in not started state, do not produce an update
-	if activity == current.NOT_STARTED {
+	// If round creation stopped OR if the node is in not started state,
+	// return early before we get the polling lock
+	stopped := atomic.LoadUint32(m.Stopped) == 1
+	if activity == current.NOT_STARTED || stopped {
+		return response, err
+	}
+
+	// Ensure any errors are properly formatted before sending an update
+	err = verifyError(msg, n, m)
+	if err != nil {
 		return response, err
 	}
 
-	// Return early before we get the polling lock if round creation stopped
-	stopped := atomic.LoadUint32(m.Stopped) == 1
-	if !stopped {
 	// when a node poll is received, the nodes polling lock is taken here. If
 	// there is no update, it is released in this endpoint, otherwise it is
 	// released in the scheduling algorithm which blocks all future polls until
 	// processing completes
 	n.GetPollingLock().Lock()
 
-		err = verifyError(msg, n, m)
-		if err != nil {
-			n.GetPollingLock().Unlock()
-			return response, err
-		}
-	}
-
-	// update does edge checking. It ensures the state change recieved was a
-	// valid one and the state fo the node and
+	// update does edge checking. It ensures the state change received was a
+	// valid one and the state of the node and
 	// any associated round allows for that change. If the change was not
 	// acceptable, it is not recorded and an error is returned, which is
 	// propagated to the node
-	update, updateNotification, err := n.Update(current.Activity(msg.Activity))
-	if !stopped {
-		//if updating to an error state, attach the error the the update
-		if update && err == nil && updateNotification.ToActivity == current.ERROR {
-			updateNotification.Error = msg.Error
-		}
-
-		//if an update ocured, report it to the control thread
-		if update {
-			err = m.State.SendUpdateNotification(updateNotification)
-		} else {
+	isUpdate, updateNotification, err := n.Update(current.Activity(msg.Activity))
+	if !isUpdate || err != nil {
 		n.GetPollingLock().Unlock()
+		return response, err
 	}
+
+	// If updating to an error state, attach the error the the update
+	if updateNotification.ToActivity == current.ERROR {
+		updateNotification.Error = msg.Error
 	}
 
-	return response, err
+	// Update occurred, report it to the control thread
+	return response, m.State.SendUpdateNotification(updateNotification)
 }
 
 // PollNdf handles the client polling for an updated NDF

scheduling/permute.go

@@ -19,23 +19,23 @@ func Permute(items []*node.State) [][]*node.State {
 	var output [][]*node.State
 
 	// Place inline to make appending output easier
-	helper = func(items []*node.State, n int) {
-		if n == 1 {
+	helper = func(items []*node.State, numItems int) {
+		if numItems == 1 {
 			// Create a copy and append the copy to the output
 			ourCopy := make([]*node.State, len(items))
 			copy(ourCopy, items)
 			output = append(output, ourCopy)
 		} else {
-			for i := 0; i < n; i++ {
-				helper(items, n-1)
+			for i := 0; i < numItems; i++ {
+				helper(items, numItems-1)
 				// Swap choice dependent on parity of k (even or odd)
-				if n%2 == 1 {
+				if numItems%2 == 1 {
 					// Swap the values
-					items[i], items[n-1] = items[n-1], items[i]
+					items[i], items[numItems-1] = items[numItems-1], items[i]
 
 				} else {
 					// Swap the values
-					items[0], items[n-1] = items[n-1], items[0]
+					items[0], items[numItems-1] = items[numItems-1], items[0]
 
 				}
 			}

scheduling/schedule.go

@@ -17,6 +17,7 @@ import (
 	"gitlab.com/elixxir/primitives/states"
 	"gitlab.com/elixxir/registration/storage"
 	"gitlab.com/elixxir/registration/storage/node"
+	"gitlab.com/elixxir/registration/storage/round"
 	"sync/atomic"
 	"time"
 )
@@ -95,14 +96,13 @@ func scheduler(params Params, state *storage.NetworkState, killchan chan chan st
 			}
 			lastRound = time.Now()
 
-			err = startRound(newRound, state, roundTracker)
+			ourRound, err := startRound(newRound, state, roundTracker)
 			if err != nil {
 				break
 			}
 
-			go func(roundID id.Round) {
+			go func(roundID id.Round, localRound *round.State) {
 				// Allow for round the to be added to the map
-				ourRound := state.GetRoundMap().GetRound(roundID)
 				roundTimer := time.NewTimer(params.RoundTimeout * time.Second)
 				select {
 				// Wait for the timer to go off
@@ -113,10 +113,11 @@ func scheduler(params Params, state *storage.NetworkState, killchan chan chan st
 					roundTimeoutTracker <- roundID
 				// Signals the round has been completed.
 				// In this case, we can exit the go-routine
-				case <-ourRound.GetRoundCompletedChan():
+				case <-localRound.GetRoundCompletedChan():
+					state.GetRoundMap().DeleteRound(roundID)
 					return
 				}
-			}(newRound.ID)
+			}(newRound.ID, ourRound)
 		}
 
 		jww.ERROR.Printf("Round creation thread should never exit: %s", err)

scheduling/semiOptimalOrdering.go

@@ -159,7 +159,7 @@ func getRegion(region string) (int, error) {
 		return WesternEurope, nil
 	case "CentralEurope":
 		return CentralEurope, nil
-	case "EasternEurope":
+	case "EasternEurope", "EastEurope":
 		return EasternEurope, nil
 	case "MiddleEast":
 		return MiddleEast, nil

scheduling/startRound.go

@@ -10,25 +10,26 @@ import (
 	"github.com/spf13/jwalterweatherman"
 	"gitlab.com/elixxir/primitives/states"
 	"gitlab.com/elixxir/registration/storage"
+	"gitlab.com/elixxir/registration/storage/round"
 	"time"
 )
 
 // startRound is a function which takes the info from createSimpleRound and updates the
 //  node and network states in order to begin the round
-func startRound(round protoRound, state *storage.NetworkState, roundTracker *RoundTracker) error {
+func startRound(round protoRound, state *storage.NetworkState, roundTracker *RoundTracker) (*round.State, error) {
 	// Add the round to the manager
 	r, err := state.GetRoundMap().AddRound(round.ID, round.BatchSize, round.ResourceQueueTimeout,
 		round.Topology)
 	if err != nil {
 		err = errors.WithMessagef(err, "Failed to create new round %v", round.ID)
-		return err
+		return nil, err
 	}
 
 	// Move the round to precomputing
 	err = r.Update(states.PRECOMPUTING, time.Now())
 	if err != nil {
 		err = errors.WithMessagef(err, "Could not move new round into %s", states.PRECOMPUTING)
-		return err
+		return nil, err
 	}
 
 	// Tag all nodes to the round
@@ -38,7 +39,7 @@ func startRound(round protoRound, state *storage.NetworkState, roundTracker *Rou
 		err := n.SetRound(r)
 		if err != nil {
 			err = errors.WithMessagef(err, "could not add round %v to node %s", r.GetRoundID(), n.GetID())
-			return err
+			return nil, err
 		}
 	}
 
@@ -47,11 +48,11 @@ func startRound(round protoRound, state *storage.NetworkState, roundTracker *Rou
 	if err != nil {
 		err = errors.WithMessagef(err, "Could not issue "+
 			"update to create round %v", r.GetRoundID())
-		return err
+		return nil, err
 	}
 
 	// Add round to active set of rounds
 	roundTracker.AddActiveRound(r.GetRoundID())
 
-	return nil
+	return r, nil
 }

scheduling/startRound_test.go

@@ -68,7 +68,7 @@ func TestStartRound(t *testing.T) {
 
 	testTracker := NewRoundTracker()
 
-	err = startRound(testProtoRound, testState, testTracker)
+	_, err = startRound(testProtoRound, testState, testTracker)
 	if err != nil {
 		t.Errorf("Received error from startRound(): %v", err)
 	}
@@ -134,7 +134,7 @@ func TestStartRound_BadState(t *testing.T) {
 
 	testTracker := NewRoundTracker()
 
-	err = startRound(testProtoRound, testState, testTracker)
+	_, err = startRound(testProtoRound, testState, testTracker)
 	if err == nil {
 		t.Errorf("Expected error. Artificially created round " +
 			"should make starting precomputing impossible")
@@ -199,7 +199,7 @@ func TestStartRound_BadNode(t *testing.T) {
 	testProtoRound.NodeStateList[0].SetRound(badState)
 	testTracker := NewRoundTracker()
 
-	err = startRound(testProtoRound, testState, testTracker)
+	_, err = startRound(testProtoRound, testState, testTracker)
 	if err == nil {
 		t.Log(err)
 		t.Errorf("Expected error. Artificially created round " +

storage/round/map.go

@@ -52,6 +52,18 @@ func (rsm *StateMap) GetRound(id id.Round) *State {
 	return rsm.rounds[id]
 }
 
+// add a schedule to delete timestamp
+
+// Cleans out rounds from round map.
+// ONLY to be used upon round completion
+func (rsm *StateMap) DeleteRound(id id.Round) {
+	// Delete the round from the map
+	rsm.mux.Lock()
+	delete(rsm.rounds, id)
+	rsm.mux.Unlock()
+	return
+}
+
 //adds rounds for testing without checks
 func (rsm *StateMap) AddRound_Testing(state *State, t *testing.T) {
 	if t == nil {

storage/round/map_test.go

@@ -114,6 +114,24 @@ func TestStateMap_GetNode_invalid(t *testing.T) {
 	}
 }
 
+// Happy path
+func TestStateMap_DeleteRound(t *testing.T) {
+	sm := &StateMap{
+		rounds: make(map[id.Round]*State),
+	}
+	rid := id.Round(2)
+	sm.rounds[rid] = &State{}
+
+	sm.DeleteRound(rid)
+
+	// Check that the round is empty upon deletion
+	r := sm.GetRound(rid)
+	if r != nil {
+		t.Errorf("Round retrieved after deletion from map")
+	}
+
+}
+
 func buildMockTopology(numNodes int, t *testing.T) *connect.Circuit {
 	nodeLst := make([]*id.ID, numNodes)
 	for i := 0; i < numNodes; i++ {