diff --git a/bindings/client.go b/bindings/client.go
index f0f74433f46bcbb2870935d16174ef89661fe8f4..2068bfbfa01b8ca1cc338c919cd50a015a9e28fe 100644
--- a/bindings/client.go
+++ b/bindings/client.go
@@ -13,6 +13,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "gitlab.com/elixxir/client/network"
"runtime/pprof"
"strings"
"sync"
@@ -407,7 +408,7 @@ func (c *Client) RegisterRoundEventsHandler(rid int, cb RoundEventCallback,
func (c *Client) WaitForRoundCompletion(roundID int,
rec RoundCompletionCallback, timeoutMS int) error {
- f := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]api.RoundResult) {
+ f := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]network.RoundLookupStatus) {
rec.EventCallback(roundID, allRoundsSucceeded, timedOut)
}
@@ -442,7 +443,7 @@ func (c *Client) WaitForMessageDelivery(marshaledSendReport []byte,
"unmarshal: %s", string(marshaledSendReport)))
}
- f := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]api.RoundResult) {
+ f := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]network.RoundLookupStatus) {
results := make([]byte, len(sr.rl.list))
jww.INFO.Printf("Processing WaitForMessageDelivery report "+
"for %v, success: %v, timedout: %v", sr.mid, allRoundsSucceeded,
diff --git a/cmd/root.go b/cmd/root.go
index c34ab06ccc3cd3ebc9c9f89500a31c13edb58ed2..39f8ee6bdb8244368f32c828f0538ba6185b3605 100644
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -14,6 +14,7 @@ import (
"encoding/hex"
"encoding/json"
"fmt"
+ "gitlab.com/elixxir/client/network"
"io/ioutil"
"log"
"os"
@@ -377,7 +378,7 @@ var rootCmd = &cobra.Command{
// Construct the callback function which
// verifies successful message send or retries
f := func(allRoundsSucceeded, timedOut bool,
- rounds map[id.Round]api.RoundResult) {
+ rounds map[id.Round]network.RoundLookupStatus) {
printRoundResults(allRoundsSucceeded, timedOut, rounds, roundIDs, msg)
if !allRoundsSucceeded {
retryChan <- struct{}{}
diff --git a/cmd/utils.go b/cmd/utils.go
index 9e26e2c762c343432991c5e161a57e9eb1ad0995..5ded04095948763e64f9c7f2bf9725edf295ec61 100644
--- a/cmd/utils.go
+++ b/cmd/utils.go
@@ -4,8 +4,8 @@ import (
"fmt"
jww "github.com/spf13/jwalterweatherman"
"github.com/spf13/viper"
- "gitlab.com/elixxir/client/api"
"gitlab.com/elixxir/client/interfaces/message"
+ "gitlab.com/elixxir/client/network"
backupCrypto "gitlab.com/elixxir/crypto/backup"
"gitlab.com/elixxir/crypto/contact"
"gitlab.com/xx_network/primitives/id"
@@ -47,7 +47,7 @@ func printChanRequest(requestor contact.Contact) {
// Helper function which prints the round resuls
func printRoundResults(allRoundsSucceeded, timedOut bool,
- rounds map[id.Round]api.RoundResult, roundIDs []id.Round, msg message.Send) {
+ rounds map[id.Round]network.RoundLookupStatus, roundIDs []id.Round, msg message.Send) {
// Done as string slices for easy and human readable printing
successfulRounds := make([]string, 0)
@@ -58,9 +58,9 @@ func printRoundResults(allRoundsSucceeded, timedOut bool,
// Group all round reports into a category based on their
// result (successful, failed, or timed out)
if result, exists := rounds[r]; exists {
- if result == api.Succeeded {
+ if result == network.Succeeded {
successfulRounds = append(successfulRounds, strconv.Itoa(int(r)))
- } else if result == api.Failed {
+ } else if result == network.Failed {
failedRounds = append(failedRounds, strconv.Itoa(int(r)))
} else {
timedOutRounds = append(timedOutRounds, strconv.Itoa(int(r)))
diff --git a/e2e/interface.go b/e2e/interface.go
index ecbaf75be5de5e6087a1b2de32d241546c72148e..d9990b4d472201c11bdad2a07deac38f303ca5fd 100644
--- a/e2e/interface.go
+++ b/e2e/interface.go
@@ -96,7 +96,7 @@ type Handler interface {
// sessions using the passed cryptographic data and per the parameters sent
AddPartner(partnerID *id.ID, partnerPubKey, myPrivKey *cyclic.Int,
partnerSIDHPubKey *sidh.PublicKey, mySIDHPrivKey *sidh.PrivateKey,
- sendParams, receiveParams session.Params) (*partner.Manager, error)
+ sendParams, receiveParams session.Params, myID *id.ID, myPrivateKey *cyclic.Int, temporary bool) (*partner.Manager, error)
// GetPartner returns the partner per its ID, if it exists
GetPartner(partnerID *id.ID) (*partner.Manager, error)
diff --git a/fileTransfer/manager.go b/fileTransfer/manager.go
index 713e230c96a3076669fbd718115f62b97b65a8af..7fc8e3416e8808c5c482260aa0dbe3d584f71caa 100644
--- a/fileTransfer/manager.go
+++ b/fileTransfer/manager.go
@@ -13,6 +13,7 @@ import (
"gitlab.com/elixxir/client/api"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/message"
+ "gitlab.com/elixxir/client/network"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage"
ftStorage "gitlab.com/elixxir/client/storage/fileTransfer"
@@ -119,7 +120,7 @@ type Manager struct {
// getRoundResultsFunc is a function that matches client.GetRoundResults. It is
// used to pass in an alternative function for testing.
type getRoundResultsFunc func(roundList []id.Round, timeout time.Duration,
- roundCallback api.RoundEventCallback) error
+ roundCallback network.RoundEventCallback) error
// queuedPart contains the unique information identifying a file part.
type queuedPart struct {
diff --git a/fileTransfer/oldTransferRecovery_test.go b/fileTransfer/oldTransferRecovery_test.go
index 341b39542ae7540282669a1cb293ca763cb8e92f..561785100d4611e7923b6eb6bd6e4e80d48ea4d1 100644
--- a/fileTransfer/oldTransferRecovery_test.go
+++ b/fileTransfer/oldTransferRecovery_test.go
@@ -10,8 +10,8 @@ package fileTransfer
import (
"fmt"
"github.com/pkg/errors"
- "gitlab.com/elixxir/client/api"
"gitlab.com/elixxir/client/interfaces"
+ "gitlab.com/elixxir/client/network"
"gitlab.com/elixxir/client/storage/versioned"
ftCrypto "gitlab.com/elixxir/crypto/fileTransfer"
"gitlab.com/elixxir/ekv"
@@ -77,13 +77,13 @@ func TestManager_oldTransferRecovery(t *testing.T) {
// Returns an error on function and round failure on callback if sendErr is
// set; otherwise, it reports round successes and returns nil
- rr := func(rIDs []id.Round, _ time.Duration, cb api.RoundEventCallback) error {
- rounds := make(map[id.Round]api.RoundResult, len(rIDs))
+ rr := func(rIDs []id.Round, _ time.Duration, cb network.RoundEventCallback) error {
+ rounds := make(map[id.Round]network.RoundLookupStatus, len(rIDs))
for _, rid := range rIDs {
if finishedRounds[rid] != nil {
- rounds[rid] = api.Succeeded
+ rounds[rid] = network.Succeeded
} else {
- rounds[rid] = api.Failed
+ rounds[rid] = network.Failed
}
}
cb(true, false, rounds)
@@ -240,13 +240,13 @@ func TestManager_updateSentRounds(t *testing.T) {
// Returns an error on function and round failure on callback if sendErr is
// set; otherwise, it reports round successes and returns nil
- rr := func(rIDs []id.Round, _ time.Duration, cb api.RoundEventCallback) error {
- rounds := make(map[id.Round]api.RoundResult, len(rIDs))
+ rr := func(rIDs []id.Round, _ time.Duration, cb network.RoundEventCallback) error {
+ rounds := make(map[id.Round]network.RoundLookupStatus, len(rIDs))
for _, rid := range rIDs {
if finishedRounds[rid] != nil {
- rounds[rid] = api.Succeeded
+ rounds[rid] = network.Succeeded
} else {
- rounds[rid] = api.Failed
+ rounds[rid] = network.Failed
}
}
cb(true, false, rounds)
@@ -322,7 +322,7 @@ func TestManager_updateSentRounds_Error(t *testing.T) {
// Returns an error on function and round failure on callback if sendErr is
// set; otherwise, it reports round successes and returns nil
m.getRoundResults = func(
- []id.Round, time.Duration, api.RoundEventCallback) error {
+ []id.Round, time.Duration, network.RoundEventCallback) error {
return errors.Errorf("GetRoundResults error")
}
diff --git a/fileTransfer/send.go b/fileTransfer/send.go
index fb593445ffbbbf0eeb03b72b9ebce2b90e369ff8..299db3b0e17101073dc7df71f9746c06d95a4442 100644
--- a/fileTransfer/send.go
+++ b/fileTransfer/send.go
@@ -12,7 +12,6 @@ import (
"encoding/binary"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/api"
"gitlab.com/elixxir/client/interfaces/message"
"gitlab.com/elixxir/client/interfaces/params"
"gitlab.com/elixxir/client/network"
@@ -419,11 +418,11 @@ func (m *Manager) newCmixMessage(transfer *ftStorage.SentTransfer,
// fails, then each part for each transfer is removed from the in-progress list,
// added to the end of the sending queue, and the callback called with an error.
func (m *Manager) makeRoundEventCallback(
- sentRounds map[id.Round][]ftCrypto.TransferID) api.RoundEventCallback {
+ sentRounds map[id.Round][]ftCrypto.TransferID) network.RoundEventCallback {
- return func(allSucceeded, timedOut bool, rounds map[id.Round]api.RoundResult) {
+ return func(allSucceeded, timedOut bool, rounds map[id.Round]network.RoundLookupStatus) {
for rid, roundResult := range rounds {
- if roundResult == api.Succeeded {
+ if roundResult == network.Succeeded {
// If the round succeeded, then set all parts for each transfer
// for this round to finished and call the progress callback
for _, tid := range sentRounds[rid] {
diff --git a/fileTransfer/send_test.go b/fileTransfer/send_test.go
index d090d4dca6aca58f5fae3a3b6fbfa10d42cf3b2a..35e1f239a8c4a3249cbd91a3ac05d3e96e47cce9 100644
--- a/fileTransfer/send_test.go
+++ b/fileTransfer/send_test.go
@@ -12,10 +12,10 @@ import (
"errors"
"fmt"
"github.com/cloudflare/circl/dh/sidh"
- "gitlab.com/elixxir/client/api"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/message"
"gitlab.com/elixxir/client/interfaces/params"
+ "gitlab.com/elixxir/client/network"
"gitlab.com/elixxir/client/stoppable"
ftStorage "gitlab.com/elixxir/client/storage/fileTransfer"
util "gitlab.com/elixxir/client/storage/utility"
@@ -382,7 +382,7 @@ func TestManager_sendParts_RoundResultsError(t *testing.T) {
grrErr := errors.New("GetRoundResultsError")
m.getRoundResults =
- func([]id.Round, time.Duration, api.RoundEventCallback) error {
+ func([]id.Round, time.Duration, network.RoundEventCallback) error {
return grrErr
}
@@ -765,7 +765,7 @@ func TestManager_makeRoundEventCallback(t *testing.T) {
roundEventCB := m.makeRoundEventCallback(
map[id.Round][]ftCrypto.TransferID{rid: {tid}})
- roundEventCB(true, false, map[id.Round]api.RoundResult{rid: api.Succeeded})
+ roundEventCB(true, false, map[id.Round]network.RoundLookupStatus{rid: network.Succeeded})
<-done1
@@ -853,7 +853,7 @@ func TestManager_makeRoundEventCallback_RoundFailure(t *testing.T) {
roundEventCB := m.makeRoundEventCallback(
map[id.Round][]ftCrypto.TransferID{rid: {tid}})
- roundEventCB(false, false, map[id.Round]api.RoundResult{rid: api.Failed})
+ roundEventCB(false, false, map[id.Round]network.RoundLookupStatus{rid: network.Failed})
<-done1
diff --git a/fileTransfer/utils_test.go b/fileTransfer/utils_test.go
index 6065e0441d183908f661948dd86bcfd20d7734c4..0ea0e5386b39c9a926fad4a774a11cd103b86410 100644
--- a/fileTransfer/utils_test.go
+++ b/fileTransfer/utils_test.go
@@ -12,11 +12,11 @@ import (
"encoding/binary"
"github.com/cloudflare/circl/dh/sidh"
"github.com/pkg/errors"
- "gitlab.com/elixxir/client/api"
"gitlab.com/elixxir/client/event"
"gitlab.com/elixxir/client/interfaces"
"gitlab.com/elixxir/client/interfaces/message"
"gitlab.com/elixxir/client/interfaces/params"
+ network2 "gitlab.com/elixxir/client/network"
"gitlab.com/elixxir/client/network/gateway"
"gitlab.com/elixxir/client/stoppable"
"gitlab.com/elixxir/client/storage"
@@ -170,13 +170,13 @@ func newTestManager(sendErr bool, sendChan, sendE2eChan chan message.Receive,
// Returns an error on function and round failure on callback if sendErr is
// set; otherwise, it reports round successes and returns nil
- rr := func(rIDs []id.Round, _ time.Duration, cb api.RoundEventCallback) error {
- rounds := make(map[id.Round]api.RoundResult, len(rIDs))
+ rr := func(rIDs []id.Round, _ time.Duration, cb network2.RoundEventCallback) error {
+ rounds := make(map[id.Round]network2.RoundLookupStatus, len(rIDs))
for _, rid := range rIDs {
if sendErr {
- rounds[rid] = api.Failed
+ rounds[rid] = network2.Failed
} else {
- rounds[rid] = api.Succeeded
+ rounds[rid] = network2.Succeeded
}
}
cb(!sendErr, false, rounds)
diff --git a/network/interface.go b/network/interface.go
index fa047f5ed67bb2fc3b00e19f540eec01e1cc3efe..665ba791d9f4210aa8f458d42aa76b00ce05d902 100644
--- a/network/interface.go
+++ b/network/interface.go
@@ -150,7 +150,7 @@ type Manager interface {
// A service may have a nil response unless it is default. In general a
// nil service is used to detect notifications when pickup is done by
// fingerprints
- AddService(AddService *id.ID, newService message.Service,
+ AddService(clientID *id.ID, newService message.Service,
response message.Processor)
// DeleteService deletes a message service. If only a single response is
@@ -214,12 +214,17 @@ type Manager interface {
// with a given node.
TriggerNodeRegistration(nid *id.ID)
- /* === Historical Rounds ================================================ */
+ /* === Rounds =========================================================== */
/* A complete set of round info is not kept on the client, and sometimes
the network will need to be queried to get round info. Historical rounds
is the system internal to the Network Manager to do this. It can be used
externally as well. */
+ // GetRoundResults adjudicates on the rounds requested. Checks if they are
+ // older rounds or in progress rounds.
+ GetRoundResults(roundList []id.Round, timeout time.Duration,
+ roundCallback RoundEventCallback) error
+
// LookupHistoricalRound looks up the passed historical round on the network.
LookupHistoricalRound(
rid id.Round, callback historical.RoundResultCallback) error
diff --git a/api/results.go b/network/results.go
similarity index 64%
rename from api/results.go
rename to network/results.go
index eb0403dee92b93be7ad90cc3ab2b4cafff28e8f8..dbc16ae78b79478f655cd191bc393c923396e444 100644
--- a/api/results.go
+++ b/network/results.go
@@ -5,30 +5,29 @@
// LICENSE file //
///////////////////////////////////////////////////////////////////////////////
-package api
+package network
import (
"fmt"
+ "gitlab.com/elixxir/client/network/historical"
"time"
jww "github.com/spf13/jwalterweatherman"
- pb "gitlab.com/elixxir/comms/mixmessages"
ds "gitlab.com/elixxir/comms/network/dataStructures"
"gitlab.com/elixxir/primitives/states"
- "gitlab.com/xx_network/comms/connect"
"gitlab.com/xx_network/primitives/id"
)
-// RoundResult is the enum of possible round results to pass back
-type RoundResult uint
+// RoundLookupStatus is the enum of possible round results to pass back
+type RoundLookupStatus uint
const (
- TimeOut RoundResult = iota
+ TimeOut RoundLookupStatus = iota
Failed
Succeeded
)
-func (rr RoundResult) String() string {
+func (rr RoundLookupStatus) String() string {
switch rr {
case TimeOut:
return "TimeOut"
@@ -41,6 +40,16 @@ func (rr RoundResult) String() string {
}
}
+type RoundResult struct {
+ Status RoundLookupStatus
+ Round historical.Round
+}
+
+type historicalRoundsRtn struct {
+ Success bool
+ Round historical.Round
+}
+
// RoundEventCallback interface which reports the requested rounds.
// Designed such that the caller may decide how much detail they need.
// allRoundsSucceeded:
@@ -53,41 +62,30 @@ func (rr RoundResult) String() string {
// their respective round results
type RoundEventCallback func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult)
-// Comm interface for RequestHistoricalRounds.
-// Constructed for testability with getRoundResults
-type historicalRoundsComm interface {
- RequestHistoricalRounds(host *connect.Host,
- message *pb.HistoricalRounds) (*pb.HistoricalRoundsResponse, error)
- GetHost(hostId *id.ID) (*connect.Host, bool)
-}
-
// GetRoundResults adjudicates on the rounds requested. Checks if they are
// older rounds or in progress rounds.
-func (c *Client) GetRoundResults(roundList []id.Round, timeout time.Duration,
+func (m *manager) GetRoundResults(roundList []id.Round, timeout time.Duration,
roundCallback RoundEventCallback) error {
jww.INFO.Printf("GetRoundResults(%v, %s)", roundList, timeout)
sendResults := make(chan ds.EventReturn, len(roundList))
- return c.getRoundResults(roundList, timeout, roundCallback,
- sendResults, c.comms)
+ return m.getRoundResults(roundList, timeout, roundCallback,
+ sendResults)
}
// Helper function which does all the logic for GetRoundResults
-func (c *Client) getRoundResults(roundList []id.Round, timeout time.Duration,
- roundCallback RoundEventCallback, sendResults chan ds.EventReturn,
- commsInterface historicalRoundsComm) error {
+func (m *manager) getRoundResults(roundList []id.Round, timeout time.Duration,
+ roundCallback RoundEventCallback, sendResults chan ds.EventReturn) error {
- networkInstance := c.network.GetInstance()
+ networkInstance := m.GetInstance()
// Generate a message to track all older rounds
- historicalRequest := &pb.HistoricalRounds{
- Rounds: []uint64{},
- }
+ historicalRequest := make([]id.Round, 0, len(roundList))
// Generate all tracking structures for rounds
- roundEvents := c.GetRoundEvents()
+ roundEvents := networkInstance.GetRoundEvents()
roundsResults := make(map[id.Round]RoundResult)
allRoundsSucceeded := true
anyRoundTimedOut := false
@@ -98,15 +96,23 @@ func (c *Client) getRoundResults(roundList []id.Round, timeout time.Duration,
// Parse and adjudicate every round
for _, rnd := range roundList {
// Every round is timed out by default, until proven to have finished
- roundsResults[rnd] = TimeOut
+ roundsResults[rnd] = RoundResult{
+ Status: TimeOut,
+ }
roundInfo, err := networkInstance.GetRound(rnd)
// If we have the round in the buffer
if err == nil {
// Check if the round is done (completed or failed) or in progress
if states.Round(roundInfo.State) == states.COMPLETED {
- roundsResults[rnd] = Succeeded
+ roundsResults[rnd] = RoundResult{
+ Status: Succeeded,
+ Round: historical.MakeRound(roundInfo),
+ }
} else if states.Round(roundInfo.State) == states.FAILED {
- roundsResults[rnd] = Failed
+ roundsResults[rnd] = RoundResult{
+ Status: Failed,
+ Round: historical.MakeRound(roundInfo),
+ }
allRoundsSucceeded = false
} else {
// If in progress, add a channel monitoring its state
@@ -119,7 +125,7 @@ func (c *Client) getRoundResults(roundList []id.Round, timeout time.Duration,
if rnd < oldestRound {
// If round is older that oldest round in our buffer
// Add it to the historical round request (performed later)
- historicalRequest.Rounds = append(historicalRequest.Rounds, uint64(rnd))
+ historicalRequest = append(historicalRequest, rnd)
numResults++
} else {
// Otherwise, monitor its progress
@@ -129,10 +135,30 @@ func (c *Client) getRoundResults(roundList []id.Round, timeout time.Duration,
}
}
}
-
+ historicalRoundsCh := make(chan RoundResult, len(historicalRequest))
// Find out what happened to old (historical) rounds if any are needed
- if len(historicalRequest.Rounds) > 0 {
- go c.getHistoricalRounds(historicalRequest, sendResults, commsInterface)
+ if len(historicalRequest) > 0 {
+ for _, rnd := range historicalRequest {
+ rrc := func(round historical.Round, success bool) {
+ var status RoundLookupStatus
+ if success {
+ status = Succeeded
+ } else {
+ status = TimeOut
+ }
+ historicalRoundsCh <- RoundResult{
+ Status: status,
+ Round: round,
+ }
+ }
+ err := m.Retriever.LookupHistoricalRound(rnd, rrc)
+ if err != nil {
+ historicalRoundsCh <- RoundResult{
+ Status: TimeOut,
+ }
+ }
+ }
+
}
// Determine the results of all rounds requested
@@ -147,11 +173,16 @@ func (c *Client) getRoundResults(roundList []id.Round, timeout time.Duration,
return
}
+ var result RoundResult
+ hasResult := false
+
// Wait for info about rounds or the timeout to occur
select {
case <-timer.C:
roundCallback(false, true, roundsResults)
return
+ case result = <-historicalRoundsCh:
+ hasResult = true
case roundReport := <-sendResults:
numResults--
@@ -162,11 +193,18 @@ func (c *Client) getRoundResults(roundList []id.Round, timeout time.Duration,
roundInfo, err := networkInstance.GetRound(roundId)
// If we have the round in the buffer
if err == nil {
+ hasResult = true
// Check if the round is done (completed or failed) or in progress
if states.Round(roundInfo.State) == states.COMPLETED {
- roundsResults[roundId] = Succeeded
+ result = RoundResult{
+ Status: Succeeded,
+ Round: historical.MakeRound(roundInfo),
+ }
} else if states.Round(roundInfo.State) == states.FAILED {
- roundsResults[roundId] = Failed
+ result = RoundResult{
+ Status: Failed,
+ Round: historical.MakeRound(roundInfo),
+ }
allRoundsSucceeded = false
}
continue
@@ -174,62 +212,28 @@ func (c *Client) getRoundResults(roundList []id.Round, timeout time.Duration,
allRoundsSucceeded = false
anyRoundTimedOut = true
} else {
+ hasResult = true
// If available, denote the result
if states.Round(roundReport.RoundInfo.State) == states.COMPLETED {
- roundsResults[roundId] = Succeeded
+ result = RoundResult{
+ Status: Succeeded,
+ Round: historical.MakeRound(roundReport.RoundInfo),
+ }
} else {
- roundsResults[roundId] = Failed
+ result = RoundResult{
+ Status: Failed,
+ Round: historical.MakeRound(roundReport.RoundInfo),
+ }
allRoundsSucceeded = false
}
}
}
+ if hasResult {
+ roundsResults[result.Round.ID] = result
+ }
+
}
}()
return nil
}
-
-// Helper function which asynchronously pings a random gateway until
-// it gets information on its requested historical rounds
-func (c *Client) getHistoricalRounds(msg *pb.HistoricalRounds,
- sendResults chan ds.EventReturn, comms historicalRoundsComm) {
-
- var resp *pb.HistoricalRoundsResponse
-
- //retry 5 times
- for i := 0; i < 5; i++ {
- // Find a gateway to request about the roundRequests
- result, err := c.GetNetworkInterface().GetSender().SendToAny(func(host *connect.Host) (interface{}, error) {
- return comms.RequestHistoricalRounds(host, msg)
- }, nil)
-
- // If an error, retry with (potentially) a different gw host.
- // If no error from received gateway request, exit loop
- // and process rounds
- if err == nil {
- resp = result.(*pb.HistoricalRoundsResponse)
- break
- } else {
- jww.ERROR.Printf("Failed to lookup historical rounds: %s", err)
- }
- }
-
- if resp == nil {
- return
- }
-
- // Service historical rounds, sending back to the caller thread
- for i, ri := range resp.Rounds {
- if ri == nil {
- // Handle unknown by historical rounds
- sendResults <- ds.EventReturn{
- RoundInfo: &pb.RoundInfo{ID: msg.Rounds[i]},
- TimedOut: true,
- }
- } else {
- sendResults <- ds.EventReturn{
- RoundInfo: ri,
- }
- }
- }
-}
diff --git a/api/results_test.go b/network/results_test.go
similarity index 89%
rename from api/results_test.go
rename to network/results_test.go
index c5245dd9a193d2f6c8bdb84e3f3862f1f884b1c2..338d71f58ca6390144014d54d37472081aa0d5e8 100644
--- a/api/results_test.go
+++ b/network/results_test.go
@@ -4,9 +4,10 @@
// Use of this source code is governed by a license that can be found in the //
// LICENSE file //
///////////////////////////////////////////////////////////////////////////////
-package api
+package network
import (
+ "gitlab.com/elixxir/client/api"
pb "gitlab.com/elixxir/comms/mixmessages"
ds "gitlab.com/elixxir/comms/network/dataStructures"
"gitlab.com/elixxir/primitives/states"
@@ -38,21 +39,21 @@ func TestClient_GetRoundResults(t *testing.T) {
}
// Create a new copy of the test client for this test
- client, err := newTestingClient(t)
+ client, err := api.newTestingClient(t)
if err != nil {
t.Fatalf("Failed in setup: %+v", err)
}
// Construct the round call back function signature
var successfulRounds, timeout bool
- receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
+ receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
successfulRounds = allRoundsSucceeded
timeout = timedOut
}
// Call the round results
err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
- receivedRCB, sendResults, NewNoHistoricalRoundsComm())
+ receivedRCB, sendResults, api.NewNoHistoricalRoundsComm())
if err != nil {
t.Errorf("Error in happy path: %v", err)
}
@@ -101,21 +102,21 @@ func TestClient_GetRoundResults_FailedRounds(t *testing.T) {
}
// Create a new copy of the test client for this test
- client, err := newTestingClient(t)
+ client, err := api.newTestingClient(t)
if err != nil {
t.Fatalf("Failed in setup: %v", err)
}
// Construct the round call back function signature
var successfulRounds, timeout bool
- receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
+ receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
successfulRounds = allRoundsSucceeded
timeout = timedOut
}
// Call the round results
err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
- receivedRCB, sendResults, NewNoHistoricalRoundsComm())
+ receivedRCB, sendResults, api.NewNoHistoricalRoundsComm())
if err != nil {
t.Errorf("Error in happy path: %v", err)
}
@@ -144,8 +145,8 @@ func TestClient_GetRoundResults_HistoricalRounds(t *testing.T) {
sendResults := make(chan ds.EventReturn, len(roundList)-2)
for i := 0; i < numRounds; i++ {
// Skip sending rounds intended for historical rounds comm
- if i == failedHistoricalRoundID ||
- i == completedHistoricalRoundID {
+ if i == api.failedHistoricalRoundID ||
+ i == api.completedHistoricalRoundID {
continue
}
@@ -159,15 +160,15 @@ func TestClient_GetRoundResults_HistoricalRounds(t *testing.T) {
}
// Create a new copy of the test client for this test
- client, err := newTestingClient(t)
+ client, err := api.newTestingClient(t)
if err != nil {
t.Fatalf("Failed in setup: %v", err)
}
// Overpopulate the round buffer, ensuring a circle back of the ring buffer
- for i := 1; i <= ds.RoundInfoBufLen+completedHistoricalRoundID+1; i++ {
+ for i := 1; i <= ds.RoundInfoBufLen+api.completedHistoricalRoundID+1; i++ {
ri := &pb.RoundInfo{ID: uint64(i)}
- if err = signRoundInfo(ri); err != nil {
+ if err = api.signRoundInfo(ri); err != nil {
t.Errorf("Failed to sign round in set up: %v", err)
}
@@ -180,14 +181,14 @@ func TestClient_GetRoundResults_HistoricalRounds(t *testing.T) {
// Construct the round call back function signature
var successfulRounds, timeout bool
- receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
+ receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
successfulRounds = allRoundsSucceeded
timeout = timedOut
}
// Call the round results
err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
- receivedRCB, sendResults, NewHistoricalRoundsComm())
+ receivedRCB, sendResults, api.NewHistoricalRoundsComm())
if err != nil {
t.Errorf("Error in happy path: %v", err)
}
@@ -217,21 +218,21 @@ func TestClient_GetRoundResults_Timeout(t *testing.T) {
sendResults = nil
// Create a new copy of the test client for this test
- client, err := newTestingClient(t)
+ client, err := api.newTestingClient(t)
if err != nil {
t.Fatalf("Failed in setup: %v", err)
}
// Construct the round call back function signature
var successfulRounds, timeout bool
- receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundResult) {
+ receivedRCB := func(allRoundsSucceeded, timedOut bool, rounds map[id.Round]RoundLookupStatus) {
successfulRounds = allRoundsSucceeded
timeout = timedOut
}
// Call the round results
err = client.getRoundResults(roundList, time.Duration(10)*time.Millisecond,
- receivedRCB, sendResults, NewNoHistoricalRoundsComm())
+ receivedRCB, sendResults, api.NewNoHistoricalRoundsComm())
if err != nil {
t.Errorf("Error in happy path: %v", err)
}