diff --git a/context/context.go b/context/context.go
index 21c2a39c2b60ebbeef381ecb99dcc119a0464119..565d431e8199fa1d2bedc510c4789d9fa668da85 100644
--- a/context/context.go
+++ b/context/context.go
@@ -1,8 +1,8 @@
package context
import (
- "gitlab.com/elixxir/client/context/switchboard"
"gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/switchboard"
"gitlab.com/elixxir/crypto/fastRNG"
)
diff --git a/globals/log.go b/globals/log.go
deleted file mode 100644
index e9bfc4a45df68296c87ff7eebc42727fd8f73a35..0000000000000000000000000000000000000000
--- a/globals/log.go
+++ /dev/null
@@ -1,54 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2019 Privategrity Corporation /
-// /
-// All rights reserved. /
-////////////////////////////////////////////////////////////////////////////////
-
-package globals
-
-import (
- jww "github.com/spf13/jwalterweatherman"
- "io"
- "io/ioutil"
- "log"
- "os"
-)
-
-// Log is logging everything to this notepad so that the CUI can replace it
-// with its own notepad and get logging statements from the client
-var Log = jww.NewNotepad(jww.LevelInfo, jww.LevelInfo, os.Stdout,
- ioutil.Discard, "CLIENT", log.Ldate|log.Ltime)
-
-// InitLog initializes logging thresholds and the log path.
-// verbose turns on debug logging, setting the log path to nil
-// uses std out.
-func InitLog(verbose bool, logPath string) *jww.Notepad {
- logLevel := jww.LevelInfo
- logFlags := (log.Ldate | log.Ltime)
- stdOut := io.Writer(os.Stdout)
- logFile := ioutil.Discard
-
- // If the verbose flag is set, print all logs and
- // print microseconds as well
- if verbose {
- logLevel = jww.LevelDebug
- logFlags = (log.Ldate | log.Ltime | log.Lmicroseconds)
- }
- // If the logpath is empty or not set to - (stdout),
- // set up the log file and do not log to stdout
- if logPath != "" && logPath != "-" {
- // Create log file, overwrites if existing
- lF, err := os.OpenFile(logPath,
- os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
- if err != nil {
- Log.WARN.Println("Invalid or missing log path," +
- " stdout used.")
- } else {
- logFile = io.Writer(lF)
- stdOut = ioutil.Discard
- }
- }
-
- return jww.NewNotepad(logLevel, logLevel, stdOut, logFile,
- "CLIENT", logFlags)
-}
diff --git a/globals/statusEvents.go b/globals/statusEvents.go
deleted file mode 100644
index 834db9f61d9ab557c127c09ac83209c41ff64b77..0000000000000000000000000000000000000000
--- a/globals/statusEvents.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package globals
-
-//Registration
-const REG_KEYGEN = 1 //Generating Cryptographic Keys
-const REG_PRECAN = 2 //Doing a Precanned Registration (Not Secure)
-const REG_UID_GEN = 3 //Generating User ID
-const REG_PERM = 4 //Validating User Identity With Permissioning Server
-const REG_NODE = 5 //Registering with Nodes
-const REG_FAIL = 6 //Failed to Register with Nodes
-const REG_SECURE_STORE = 7 //Creating Local Secure Session
-const REG_SAVE = 8 //Storing Session
-//UDB registration
-const UDB_REG_PUSHKEY = 9 //Pushing Cryptographic Material to the User Discovery Bot
-const UDB_REG_PUSHUSER = 10 //Registering User with the User Discovery Bot
-//UDB Search
-const UDB_SEARCH_LOOK = 11 //Searching for User in User Discovery
-const UDB_SEARCH_GETKEY = 12 //Getting Keying Material From User Discovery
-const UDB_SEARCH_BUILD_CREDS = 13 //Building secure end to end relationship
diff --git a/globals/storage.go b/globals/storage.go
deleted file mode 100644
index aecd54789a000a50eb0fc766db9937a8cd00f6a3..0000000000000000000000000000000000000000
--- a/globals/storage.go
+++ /dev/null
@@ -1,202 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2019 Privategrity Corporation /
-// /
-// All rights reserved. /
-////////////////////////////////////////////////////////////////////////////////
-
-package globals
-
-import (
- "os"
- "sync"
-)
-
-const (
- NoSave uint8 = iota
- LocationA
- LocationB
-)
-
-type Storage interface {
- SetLocation(string, string) error
- GetLocation() (string, string)
- SaveA([]byte) error
- SaveB([]byte) error
- LoadA() []byte
- LoadB() []byte
- IsEmpty() bool
-}
-
-type DefaultStorage struct {
- locationA string
- locationB string
- sync.Mutex
-}
-
-func (ds *DefaultStorage) SetLocation(locationA, locationB string) error {
- ds.Lock()
- ds.locationA = locationA
- ds.locationB = locationB
- ds.Unlock()
- return nil
-}
-
-func (ds *DefaultStorage) GetLocation() (string, string) {
- ds.Lock()
- defer ds.Unlock()
- return ds.locationA, ds.locationB
-}
-
-func (ds *DefaultStorage) IsEmpty() bool {
- _, err := os.Stat(ds.locationA)
- firstEmpty := err != nil && os.IsNotExist(err)
- _, err = os.Stat(ds.locationB)
- secondEmpty := err != nil && os.IsNotExist(err)
- return firstEmpty && secondEmpty
-}
-
-func (ds *DefaultStorage) SaveA(data []byte) error {
- return dsSaveHelper(ds.locationA, data)
-}
-
-func (ds *DefaultStorage) LoadA() []byte {
- return dsLoadHelper(ds.locationA)
-}
-
-func (ds *DefaultStorage) SaveB(data []byte) error {
- return dsSaveHelper(ds.locationB, data)
-}
-
-func (ds *DefaultStorage) LoadB() []byte {
- return dsLoadHelper(ds.locationB)
-}
-
-type RamStorage struct {
- DataA []byte
- DataB []byte
-}
-
-func (rs *RamStorage) SetLocation(string, string) error {
- return nil
-}
-
-func (rs *RamStorage) GetLocation() (string, string) {
- return "", ""
-}
-
-func (rs *RamStorage) SaveA(data []byte) error {
- rs.DataA = make([]byte, len(data))
- copy(rs.DataA, data)
- return nil
-}
-
-func (rs *RamStorage) SaveB(data []byte) error {
- rs.DataB = make([]byte, len(data))
- copy(rs.DataB, data)
- return nil
-}
-
-func (rs *RamStorage) LoadA() []byte {
- b := make([]byte, len(rs.DataA))
- copy(b, rs.DataA)
-
- return b
-}
-
-func (rs *RamStorage) LoadB() []byte {
- b := make([]byte, len(rs.DataB))
- copy(b, rs.DataB)
-
- return b
-}
-
-func (rs *RamStorage) IsEmpty() bool {
- return (rs.DataA == nil || len(rs.DataA) == 0) && (rs.DataB == nil || len(rs.DataB) == 0)
-}
-
-func dsLoadHelper(loc string) []byte {
- // Check if the file exists, return nil if it does not
- finfo, err1 := os.Stat(loc)
-
- if err1 != nil {
- Log.ERROR.Printf("Default Storage Load: Unknown Error Occurred on"+
- " file check: \n %v", err1.Error())
- return nil
- }
-
- b := make([]byte, finfo.Size())
-
- // Open the file, return nil if it cannot be opened
- f, err2 := os.Open(loc)
-
- defer func() {
- if f != nil {
- f.Close()
- } else {
- Log.WARN.Println("Could not close file, file is nil")
- }
- }()
-
- if err2 != nil {
- Log.ERROR.Printf("Default Storage Load: Unknown Error Occurred on"+
- " file open: \n %v", err2.Error())
- return nil
- }
-
- // Read the data from the file, return nil if read fails
- _, err3 := f.Read(b)
-
- if err3 != nil {
- Log.ERROR.Printf("Default Storage Load: Unknown Error Occurred on"+
- " file read: \n %v", err3.Error())
- return nil
- }
-
- return b
-
-}
-
-func dsSaveHelper(loc string, data []byte) error {
- //check if the file exists, delete if it does
- _, err1 := os.Stat(loc)
-
- if err1 == nil {
- errRmv := os.Remove(loc)
- if errRmv != nil {
- Log.WARN.Printf("Could not remove Storage File B: %s", errRmv)
- }
- } else if !os.IsNotExist(err1) {
- Log.ERROR.Printf("Default Storage Save: Unknown Error Occurred on"+
- " file check: \n %v",
- err1.Error())
- return err1
- }
-
- //create new file
- f, err2 := os.Create(loc)
-
- defer func() {
- if f != nil {
- f.Close()
- } else {
- Log.WARN.Println("Could not close file, file is nil")
- }
- }()
-
- if err2 != nil {
- Log.ERROR.Printf("Default Storage Save: Unknown Error Occurred on"+
- " file creation: \n %v", err2.Error())
- return err2
- }
-
- //Save to file
- _, err3 := f.Write(data)
-
- if err3 != nil {
- Log.ERROR.Printf("Default Storage Save: Unknown Error Occurred on"+
- " file write: \n %v", err3.Error())
- return err3
- }
-
- return nil
-}
diff --git a/globals/storage_test.go b/globals/storage_test.go
deleted file mode 100644
index 96abc9532bd258097ffd73da5c4430def403fe5d..0000000000000000000000000000000000000000
--- a/globals/storage_test.go
+++ /dev/null
@@ -1,144 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2019 Privategrity Corporation /
-// /
-// All rights reserved. /
-////////////////////////////////////////////////////////////////////////////////
-
-package globals
-
-import (
- "os"
- "reflect"
- "testing"
-)
-
-func TestInitStorage(t *testing.T) {
- TestDataA := []byte{12, 14, 54}
- TestDataB := []byte{69, 42, 32}
- TestSaveLocA := "testStorageA.data"
- TestSaveLocB := "testStorageB.data"
-
- // Test DefaultStorage initialization without existing storage
- storage := &DefaultStorage{}
- //Check that storage is empty prior to any Save calls
- if !storage.IsEmpty() {
- t.Errorf("ds.IsEmpty failed to detect an empty storage")
- }
-
- storage.SetLocation(TestSaveLocA, TestSaveLocB)
-
- // Test DS saveA
- err := storage.SaveA(TestDataA)
- if err != nil {
- t.Errorf("ds.Save failed to create a save file A at: %v",
- TestSaveLocA)
- }
- // Check that save file was made
- if !exists(TestSaveLocA) {
- t.Errorf("ds.Save failed to create a save file A at: %v",
- TestSaveLocA)
- }
- //Check that the storage is not empty after a saveA call
- if storage.IsEmpty() {
- t.Errorf("ds.IsEmpty failed to detect a non-empty storage")
- }
-
- // Test DS loadA
- actualData := storage.LoadA()
- if reflect.DeepEqual(actualData, TestDataA) != true {
- t.Errorf("ds.Load failed to load expected data on A. Expected:%v Actual:%v",
- TestDataA, actualData)
- }
-
- // Test DS saveB
- err = storage.SaveB(TestDataB)
- if err != nil {
- t.Errorf("ds.Save failed to create a save file B at: %v",
- TestSaveLocB)
- }
- // Check that save file was made
- if !exists(TestSaveLocB) {
- t.Errorf("ds.Save failed to create a save file B at: %v",
- TestSaveLocB)
- }
-
- // Test DS loadA
- actualData = storage.LoadB()
- if reflect.DeepEqual(actualData, TestDataB) != true {
- t.Errorf("ds.Load failed to load expected data on B. Expected:%v Actual:%v",
- TestDataB, actualData)
- }
-
- // Test RamStorage
- store := RamStorage{}
- actualData = nil
- // Test A
- store.SaveA(TestDataA)
- actualData = store.LoadA()
- if reflect.DeepEqual(actualData, TestDataA) != true {
- t.Errorf("rs.Load failed to load expected data A. Expected:%v Actual:%v",
- TestDataA, actualData)
- }
- //Test B
- store.SaveB(TestDataB)
- actualData = store.LoadB()
- if reflect.DeepEqual(actualData, TestDataB) != true {
- t.Errorf("rs.Load failed to load expected data B. Expected:%v Actual:%v",
- TestDataB, actualData)
- }
- os.Remove(TestSaveLocA)
- os.Remove(TestSaveLocB)
-}
-
-// exists returns whether the given file or directory exists or not
-func exists(path string) bool {
- _, err := os.Stat(path)
- if err == nil {
- return true
- }
- if os.IsNotExist(err) {
- return false
- }
- return true
-}
-
-func TestDefaultStorage_GetLocation(t *testing.T) {
- locationA := "hi"
- locationB := "hi2"
-
- ds := DefaultStorage{locationA: locationA, locationB: locationB}
-
- recievedLocA, recievedLocB := ds.GetLocation()
-
- if recievedLocA != locationA {
- t.Errorf("defaultStorage.GetLocation returned incorrect location A. Expected:%v Actual:%v",
- locationA, recievedLocA)
- }
-
- if recievedLocB != locationB {
- t.Errorf("defaultStorage.GetLocation returned incorrect location B. Expected:%v Actual:%v",
- locationB, recievedLocB)
- }
-}
-
-func TestRamStorage_GetLocation(t *testing.T) {
-
- ds := RamStorage{}
-
- a, b := ds.GetLocation()
-
- if a != "" && b != "" {
- t.Errorf("RamStorage.GetLocation returned incorrect location. Actual: '', ''; Expected:'%v','%v'",
- a, b)
- }
-}
-
-func Test_dsLoadHelper_LocError(t *testing.T) {
- testLoc := "~a/test"
-
- result := dsLoadHelper(testLoc)
-
- if result != nil {
- t.Errorf("dsLoadHelper() did not error on invalid path.")
- }
-}
diff --git a/globals/terminator.go b/globals/terminator.go
deleted file mode 100644
index 5b17199f2a3d75466da1e17088135d7620d572fe..0000000000000000000000000000000000000000
--- a/globals/terminator.go
+++ /dev/null
@@ -1,47 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2019 Privategrity Corporation /
-// /
-// All rights reserved. /
-////////////////////////////////////////////////////////////////////////////////
-
-package globals
-
-import (
- "time"
-)
-
-type ThreadTerminator chan chan bool
-
-func NewThreadTerminator() ThreadTerminator {
- t := make(chan chan bool, 1)
- return t
-}
-
-func (t ThreadTerminator) Terminate() {
- t <- nil
-}
-
-// Try's to kill a thread controlled by a termination channel for the length of
-// the timeout, returns its success. pass 0 for no timeout
-func (t ThreadTerminator) BlockingTerminate(timeout uint64) bool {
-
- killNotify := make(chan bool)
- defer close(killNotify)
-
- if timeout != 0 {
- timer := time.NewTimer(time.Duration(timeout) * time.Millisecond)
- defer timer.Stop()
-
- t <- killNotify
-
- select {
- case _ = <-killNotify:
- return true
- case <-timer.C:
- return false
- }
- } else {
- _ = <-killNotify
- return true
- }
-}
diff --git a/globals/terminator_test.go b/globals/terminator_test.go
deleted file mode 100644
index b43c8cc03cb4e315c945f1e2983c5f85f555bc8c..0000000000000000000000000000000000000000
--- a/globals/terminator_test.go
+++ /dev/null
@@ -1,69 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// Copyright © 2019 Privategrity Corporation /
-// /
-// All rights reserved. /
-////////////////////////////////////////////////////////////////////////////////
-
-package globals
-
-import (
- "testing"
- "time"
-)
-
-func TestNewThreadTerminator(t *testing.T) {
-
- term := NewThreadTerminator()
-
- var success bool
-
- go func(term ThreadTerminator) {
- term <- nil
- }(term)
-
- timer := time.NewTimer(time.Duration(1000) * time.Millisecond)
- defer timer.Stop()
-
- select {
- case _ = <-term:
- success = true
- case <-timer.C:
- success = false
- }
-
- if !success {
- t.Errorf("NewThreadTerminator: Could not use the ThreadTerminator to" +
- " stop a thread")
- }
-
-}
-
-func TestBlockingTerminate(t *testing.T) {
-
- term := NewThreadTerminator()
-
- go func(term ThreadTerminator) {
- var killNotify chan<- bool
-
- q := false
-
- for !q {
- select {
- case killNotify = <-term:
- q = true
- }
-
- close(term)
-
- killNotify <- true
-
- }
- }(term)
-
- success := term.BlockingTerminate(1000)
-
- if !success {
- t.Errorf("BlockingTerminate: Thread did not terminate in time")
- }
-
-}
diff --git a/globals/version_vars.go b/globals/version_vars.go
deleted file mode 100644
index 4f7517beceb488feace30b2b97e9d90e13ca2ae4..0000000000000000000000000000000000000000
--- a/globals/version_vars.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// Code generated by go generate; DO NOT EDIT.
-// This file was generated by robots at
-// 2020-08-10 10:05:18.2662998 -0700 PDT m=+0.116012701
-package globals
-
-const GITVERSION = `127a946 Merge branch 'XX-2415/NodeKeys' into 'Optimus/ClientStorage'`
-const SEMVER = "1.4.0"
-const DEPENDENCIES = `module gitlab.com/elixxir/client
-
-go 1.13
-
-require (
- github.com/golang-collections/collections v0.0.0-20130729185459-604e922904d3
- github.com/golang/protobuf v1.4.2
- github.com/gopherjs/gopherjs v0.0.0-20200217142428-fce0ec30dd00 // indirect
- github.com/pelletier/go-toml v1.6.0 // indirect
- github.com/pkg/errors v0.9.1
- github.com/smartystreets/assertions v1.0.1 // indirect
- github.com/spf13/afero v1.2.2 // indirect
- github.com/spf13/cast v1.3.1 // indirect
- github.com/spf13/cobra v1.0.0
- github.com/spf13/jwalterweatherman v1.1.0
- github.com/spf13/pflag v1.0.5 // indirect
- github.com/spf13/viper v1.6.2
- gitlab.com/elixxir/comms v0.0.0-20200805174832-240bba97beaa
- gitlab.com/elixxir/crypto v0.0.0-20200805174804-bdf909f2a16d
- gitlab.com/elixxir/ekv v0.1.1
- gitlab.com/elixxir/primitives v0.0.0-20200805174810-86b366d1dd2d
- gitlab.com/xx_network/comms v0.0.0-20200805174823-841427dd5023
- gitlab.com/xx_network/primitives v0.0.0-20200804183002-f99f7a7284da
- golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de
- golang.org/x/sys v0.0.0-20200806125547-5acd03effb82 // indirect
- gopkg.in/ini.v1 v1.52.0 // indirect
-)
-
-replace google.golang.org/grpc => github.com/grpc/grpc-go v1.27.1
-`
diff --git a/network/health/healthTracker.go b/network/health/healthTracker.go
index 505deeadda921e6d14cd68582a3b9233872936c7..81008b09853c4d71878318eef36139579f124b1a 100644
--- a/network/health/healthTracker.go
+++ b/network/health/healthTracker.go
@@ -10,7 +10,6 @@ package health
import (
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/context"
"gitlab.com/elixxir/client/context/stoppable"
"gitlab.com/elixxir/comms/network"
"sync"
@@ -32,10 +31,10 @@ type Tracker struct {
}
// Creates a single HealthTracker thread, starts it, and returns a tracker and a stoppable
-func Init(ctx *context.Context, timeout time.Duration) *Tracker {
+func Init(instance *network.Instance, timeout time.Duration) *Tracker {
tracker := newTracker(timeout)
- ctx.Manager.GetInstance().SetNetworkHealthChan(tracker.heartbeat)
+ instance.SetNetworkHealthChan(tracker.heartbeat)
return tracker
}
diff --git a/network/health/healthTracker_test.go b/network/health/healthTracker_test.go
index 6b15b2bc533a60ee7913010bcde48675a268d3f3..9a1a8d048412ee7229e3a0f0607a18ee99a6b200 100644
--- a/network/health/healthTracker_test.go
+++ b/network/health/healthTracker_test.go
@@ -40,5 +40,4 @@ func TestNewTracker(t *testing.T) {
quit := make(chan struct{})
go tracker.start(quit)
-
}
diff --git a/network/internal/internal.go b/network/internal/internal.go
index 7d20ae8026c0bf755c0a2d625c19a0eea3e48cd6..290b328c9ee8ac62b64cb43617647c636eb26acf 100644
--- a/network/internal/internal.go
+++ b/network/internal/internal.go
@@ -1,15 +1,20 @@
package internal
import (
- "gitlab.com/elixxir/client/context"
"gitlab.com/elixxir/client/network/health"
+ "gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/switchboard"
"gitlab.com/elixxir/comms/client"
"gitlab.com/elixxir/comms/network"
+ "gitlab.com/elixxir/crypto/fastRNG"
"gitlab.com/xx_network/primitives/id"
)
type Internal struct {
- *context.Context
+ Session *storage.Session
+ Switchboard *switchboard.Switchboard
+ //generic RNG for client
+ Rng *fastRNG.StreamGenerator
// Comms pointer to send/recv messages
Comms *client.Comms
diff --git a/network/keyExchange/confirm.go b/network/keyExchange/confirm.go
index a2026c14e55837162ef4084ac1cbd4f38fec9530..2e4e743f04c5641a15caedb1a1cafeb353938fd5 100644
--- a/network/keyExchange/confirm.go
+++ b/network/keyExchange/confirm.go
@@ -4,25 +4,25 @@ import (
"github.com/golang/protobuf/proto"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/context"
"gitlab.com/elixxir/client/context/message"
"gitlab.com/elixxir/client/context/stoppable"
+ "gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/e2e"
)
-func startConfirm(ctx *context.Context, c chan message.Receive,
+func startConfirm(sess *storage.Session, c chan message.Receive,
stop *stoppable.Single) {
for true {
select {
case <-stop.Quit():
return
case confirmation := <-c:
- handleConfirm(ctx, confirmation)
+ handleConfirm(sess, confirmation)
}
}
}
-func handleConfirm(ctx *context.Context, confirmation message.Receive) {
+func handleConfirm(sess *storage.Session, confirmation message.Receive) {
//ensure the message was encrypted properly
if confirmation.Encryption != message.E2E {
jww.ERROR.Printf("Received non-e2e encrypted Key Exchange "+
@@ -31,7 +31,7 @@ func handleConfirm(ctx *context.Context, confirmation message.Receive) {
}
//Get the partner
- partner, err := ctx.Session.E2e().GetPartner(confirmation.Sender)
+ partner, err := sess.E2e().GetPartner(confirmation.Sender)
if err != nil {
jww.ERROR.Printf("Received Key Exchange Confirmation with unknown "+
"partner %s", confirmation.Sender)
diff --git a/network/keyExchange/exchange.go b/network/keyExchange/exchange.go
index 9f4ab35c5b9db4b63c5c733baa17abac2a445e02..c498d37a3e6c6bead8d6c9af8961ad92b1a8e28b 100644
--- a/network/keyExchange/exchange.go
+++ b/network/keyExchange/exchange.go
@@ -4,6 +4,8 @@ import (
"gitlab.com/elixxir/client/context"
"gitlab.com/elixxir/client/context/message"
"gitlab.com/elixxir/client/context/stoppable"
+ "gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/switchboard"
"gitlab.com/xx_network/primitives/id"
"time"
)
@@ -12,39 +14,40 @@ const keyExchangeTriggerName = "KeyExchangeTrigger"
const keyExchangeConfirmName = "KeyExchangeConfirm"
const keyExchangeMulti = "KeyExchange"
-func Start(ctx *context.Context, garbledMessageTrigger chan<- struct{}) stoppable.Stoppable {
+func Start(switchboard *switchboard.Switchboard, sess *storage.Session,
+ net context.NetworkManager, garbledMessageTrigger chan<- struct{}) stoppable.Stoppable {
// register the rekey trigger thread
triggerCh := make(chan message.Receive, 100)
- triggerID := ctx.Switchboard.RegisterChannel(keyExchangeTriggerName,
+ triggerID := switchboard.RegisterChannel(keyExchangeTriggerName,
&id.ID{}, message.KeyExchangeTrigger, triggerCh)
// create the trigger stoppable
triggerStop := stoppable.NewSingle(keyExchangeTriggerName)
triggerStopCleanup := stoppable.NewCleanup(triggerStop,
func(duration time.Duration) error {
- ctx.Switchboard.Unregister(triggerID)
+ switchboard.Unregister(triggerID)
return nil
})
// start the trigger thread
- go startTrigger(ctx, triggerCh, triggerStop, garbledMessageTrigger)
+ go startTrigger(sess, net, triggerCh, triggerStop, garbledMessageTrigger)
//register the rekey confirm thread
confirmCh := make(chan message.Receive, 100)
- confirmID := ctx.Switchboard.RegisterChannel(keyExchangeConfirmName,
+ confirmID := switchboard.RegisterChannel(keyExchangeConfirmName,
&id.ID{}, message.KeyExchangeConfirm, confirmCh)
// register the confirm stoppable
confirmStop := stoppable.NewSingle(keyExchangeConfirmName)
confirmStopCleanup := stoppable.NewCleanup(confirmStop,
func(duration time.Duration) error {
- ctx.Switchboard.Unregister(confirmID)
+ switchboard.Unregister(confirmID)
return nil
})
// start the confirm thread
- go startConfirm(ctx, confirmCh, confirmStop)
+ go startConfirm(sess, confirmCh, confirmStop)
//bundle the stoppables and return
exchangeStop := stoppable.NewMulti(keyExchangeMulti)
diff --git a/network/keyExchange/rekey.go b/network/keyExchange/rekey.go
index bf8e348bdeb79a54d76752b499bccf4a31f13f01..a513c9739e5517ec9e31b496511ea44b2d995b36 100644
--- a/network/keyExchange/rekey.go
+++ b/network/keyExchange/rekey.go
@@ -10,21 +10,25 @@ import (
"github.com/golang/protobuf/proto"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/context"
"gitlab.com/elixxir/client/context/message"
"gitlab.com/elixxir/client/context/params"
"gitlab.com/elixxir/client/context/utility"
+ "gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/e2e"
+ "gitlab.com/elixxir/comms/network"
ds "gitlab.com/elixxir/comms/network/dataStructures"
"gitlab.com/elixxir/crypto/diffieHellman"
"gitlab.com/elixxir/primitives/states"
+ "gitlab.com/xx_network/primitives/id"
"time"
)
-func CheckKeyExchanges(ctx *context.Context, manager *e2e.Manager) {
+type SendE2E func(msg message.Send, param params.E2E) ([]id.Round, error)
+
+func CheckKeyExchanges(instance *network.Instance, sendE2E SendE2E, sess *storage.Session, manager *e2e.Manager) {
sessions := manager.TriggerNegotiations()
- for _, ses := range sessions {
- go trigger(ctx, manager, ses)
+ for _, session := range sessions {
+ go trigger(instance, sendE2E, sess, manager, session)
}
}
@@ -32,7 +36,7 @@ func CheckKeyExchanges(ctx *context.Context, manager *e2e.Manager) {
// session and negotiation, or resenting a negotiation for an already created
// session. They run the same negotiation, the former does it on a newly created
// session while the latter on an extand
-func trigger(ctx *context.Context, manager *e2e.Manager, session *e2e.Session) {
+func trigger(instance *network.Instance, sendE2E SendE2E, sess *storage.Session, manager *e2e.Manager, session *e2e.Session) {
var negotiatingSession *e2e.Session
switch session.NegotiationStatus() {
// If the passed session is triggering a negotiation on a new session to
@@ -52,7 +56,7 @@ func trigger(ctx *context.Context, manager *e2e.Manager, session *e2e.Session) {
}
// send the rekey notification to the partner
- err := negotiate(ctx, negotiatingSession)
+ err := negotiate(instance, sendE2E, sess, negotiatingSession)
// if sending the negotiation fails, revert the state of the session to
// unconfirmed so it will be triggered in the future
if err != nil {
@@ -61,8 +65,8 @@ func trigger(ctx *context.Context, manager *e2e.Manager, session *e2e.Session) {
}
}
-func negotiate(ctx *context.Context, session *e2e.Session) error {
- e2eStore := ctx.Session.E2e()
+func negotiate(instance *network.Instance, sendE2E SendE2E, sess *storage.Session, session *e2e.Session) error {
+ e2eStore := sess.E2e()
//generate public key
pubKey := diffieHellman.GeneratePublicKey(session.GetMyPrivKey(),
@@ -91,7 +95,7 @@ func negotiate(ctx *context.Context, session *e2e.Session) error {
e2eParams := params.GetDefaultE2E()
e2eParams.Type = params.KeyExchange
- rounds, err := ctx.Manager.SendE2E(m, e2eParams)
+ rounds, err := sendE2E(m, e2eParams)
// If the send fails, returns the error so it can be handled. The caller
// should ensure the calling session is in a state where the Rekey will
// be triggered next time a key is used
@@ -104,7 +108,7 @@ func negotiate(ctx *context.Context, session *e2e.Session) error {
sendResults := make(chan ds.EventReturn, len(rounds))
//Register the event for all rounds
- roundEvents := ctx.Manager.GetInstance().GetRoundEvents()
+ roundEvents := instance.GetRoundEvents()
for _, r := range rounds {
roundEvents.AddRoundEventChan(r, sendResults, 1*time.Minute,
states.COMPLETED, states.FAILED)
diff --git a/network/keyExchange/trigger.go b/network/keyExchange/trigger.go
index c40713e8857ad1695ad5f42901cde9193872e21d..a4c642e743bf6eadd8e11bd9bccf934dd2686bf8 100644
--- a/network/keyExchange/trigger.go
+++ b/network/keyExchange/trigger.go
@@ -10,6 +10,7 @@ import (
"gitlab.com/elixxir/client/context/params"
"gitlab.com/elixxir/client/context/stoppable"
"gitlab.com/elixxir/client/context/utility"
+ "gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/e2e"
ds "gitlab.com/elixxir/comms/network/dataStructures"
"gitlab.com/elixxir/crypto/cyclic"
@@ -22,14 +23,14 @@ const (
errUnknown = "unknown trigger from partner %s"
)
-func startTrigger(ctx *context.Context, c chan message.Receive,
+func startTrigger(sess *storage.Session, net context.NetworkManager, c chan message.Receive,
stop *stoppable.Single, garbledMessageTrigger chan<- struct{}) {
for true {
select {
case <-stop.Quit():
return
case request := <-c:
- err := handleTrigger(ctx, request, garbledMessageTrigger)
+ err := handleTrigger(sess, net, request, garbledMessageTrigger)
if err != nil {
jww.ERROR.Printf("Failed to handle rekey trigger: %s",
err)
@@ -38,7 +39,7 @@ func startTrigger(ctx *context.Context, c chan message.Receive,
}
}
-func handleTrigger(ctx *context.Context, request message.Receive,
+func handleTrigger(sess *storage.Session, net context.NetworkManager, request message.Receive,
garbledMessageTrigger chan<- struct{}) error {
//ensure the message was encrypted properly
if request.Encryption != message.E2E {
@@ -48,7 +49,7 @@ func handleTrigger(ctx *context.Context, request message.Receive,
}
//Get the partner
- partner, err := ctx.Session.E2e().GetPartner(request.Sender)
+ partner, err := sess.E2e().GetPartner(request.Sender)
if err != nil {
errMsg := fmt.Sprintf(errUnknown, request.Sender)
jww.ERROR.Printf(errMsg)
@@ -57,7 +58,7 @@ func handleTrigger(ctx *context.Context, request message.Receive,
//unmarshal the message
oldSessionID, PartnerPublicKey, err := unmarshalSource(
- ctx.Session.E2e().GetGroup(), request.Payload)
+ sess.E2e().GetGroup(), request.Payload)
if err != nil {
jww.ERROR.Printf("could not unmarshal partner %s: %s",
request.Sender, err)
@@ -117,13 +118,13 @@ func handleTrigger(ctx *context.Context, request message.Receive,
// store in critical messages buffer first to ensure it is resent if the
// send fails
- ctx.Session.GetCriticalMessages().AddProcessing(m, e2eParams)
+ sess.GetCriticalMessages().AddProcessing(m, e2eParams)
- rounds, err := ctx.Manager.SendE2E(m, e2eParams)
+ rounds, err := net.SendE2E(m, e2eParams)
//Register the event for all rounds
sendResults := make(chan ds.EventReturn, len(rounds))
- roundEvents := ctx.Manager.GetInstance().GetRoundEvents()
+ roundEvents := net.GetInstance().GetRoundEvents()
for _, r := range rounds {
roundEvents.AddRoundEventChan(r, sendResults, 1*time.Minute,
states.COMPLETED, states.FAILED)
@@ -140,13 +141,13 @@ func handleTrigger(ctx *context.Context, request message.Receive,
"transmit %v/%v paritions: %v round failures, %v timeouts",
session, numRoundFail+numTimeOut, len(rounds), numRoundFail,
numTimeOut)
- ctx.Session.GetCriticalMessages().Failed(m)
+ sess.GetCriticalMessages().Failed(m)
return nil
}
// otherwise, the transmission is a success and this should be denoted
// in the session and the log
- ctx.Session.GetCriticalMessages().Succeeded(m)
+ sess.GetCriticalMessages().Succeeded(m)
jww.INFO.Printf("Key Negotiation transmission for %s sucesfull",
session)
diff --git a/network/manager.go b/network/manager.go
index b39179cbdda782f335978b8a5551637a9126af18..7013d7f6f0ce7201f9cbbff085ab62829d70d88e 100644
--- a/network/manager.go
+++ b/network/manager.go
@@ -21,8 +21,11 @@ import (
"gitlab.com/elixxir/client/network/node"
"gitlab.com/elixxir/client/network/permissioning"
"gitlab.com/elixxir/client/network/rounds"
+ "gitlab.com/elixxir/client/storage"
+ "gitlab.com/elixxir/client/switchboard"
"gitlab.com/elixxir/comms/client"
"gitlab.com/elixxir/comms/network"
+ "gitlab.com/elixxir/crypto/fastRNG"
"gitlab.com/xx_network/crypto/signature/rsa"
"gitlab.com/xx_network/primitives/id"
"gitlab.com/xx_network/primitives/ndf"
@@ -49,25 +52,11 @@ type manager struct {
}
// NewManager builds a new reception manager object using inputted key fields
-func NewManager(ctx *context.Context, params params.Network, ndf *ndf.NetworkDefinition) (context.NetworkManager, error) {
-
- //get the user from storage
- user := ctx.Session.User()
- cryptoUser := user.GetCryptographicIdentity()
-
- //start comms
- comms, err := client.NewClientComms(cryptoUser.GetUserID(),
- rsa.CreatePublicKeyPem(cryptoUser.GetRSA().GetPublic()),
- rsa.CreatePrivateKeyPem(cryptoUser.GetRSA()),
- cryptoUser.GetSalt())
- if err != nil {
- return nil, errors.WithMessage(err, "failed to create"+
- " client network manager")
- }
+func NewManager(session *storage.Session, switchboard *switchboard.Switchboard,
+ rng *fastRNG.StreamGenerator, comms *client.Comms,
+ params params.Network, ndf *ndf.NetworkDefinition) (context.NetworkManager, error) {
//start network instance
- // TODO: Need to parse/retrieve the ntework string and load it
- // from the context storage session!
instance, err := network.NewInstance(comms.ProtoComms, ndf, nil, nil)
if err != nil {
return nil, errors.WithMessage(err, "failed to create"+
@@ -81,14 +70,16 @@ func NewManager(ctx *context.Context, params params.Network, ndf *ndf.NetworkDef
}
m.Internal = internal.Internal{
+ Session: session,
+ Switchboard: switchboard,
+ Rng: rng,
Comms: comms,
- Health: health.Init(ctx, 5*time.Second),
+ Health: health.Init(instance, 5*time.Second),
NodeRegistration: make(chan network.NodeGateway, params.RegNodesBufferLen),
Instance: instance,
+ Uid: session.User().GetCryptographicIdentity().GetUserID(),
}
- m.Internal.Context = ctx
-
//create sub managers
m.message = message.NewManager(m.Internal, m.param.Messages, m.NodeRegistration)
m.round = rounds.NewManager(m.Internal, m.param.Rounds, m.message.GetMessageReceptionChannel())
diff --git a/network/message/sendE2E.go b/network/message/sendE2E.go
index 76370c30262cffc2f9f158c6d2be62e09c00eaa4..c36cc9d25b4b91d4c7fd309e8101c7895380a3ff 100644
--- a/network/message/sendE2E.go
+++ b/network/message/sendE2E.go
@@ -72,7 +72,7 @@ func (m *Manager) SendE2E(msg message.Send, param params.E2E) ([]id.Round, error
// while waiting check if any rekeys need to happen and trigger them. This
// can happen now because the key popping happens in this thread,
// only the sending is parallelized
- keyExchange.CheckKeyExchanges(m.Context, partner)
+ keyExchange.CheckKeyExchanges(m.Instance, m.SendE2E, m.Session, partner)
wg.Wait()
diff --git a/network/node/register.go b/network/node/register.go
index 40934a0d8f58a453a78c6749364cd190d366e5f3..02a882f3f64788b467a24381bfef4a790eb67b1e 100644
--- a/network/node/register.go
+++ b/network/node/register.go
@@ -8,14 +8,15 @@ import (
"fmt"
"github.com/pkg/errors"
jww "github.com/spf13/jwalterweatherman"
- "gitlab.com/elixxir/client/context"
"gitlab.com/elixxir/client/context/stoppable"
+ "gitlab.com/elixxir/client/storage"
"gitlab.com/elixxir/client/storage/cmix"
"gitlab.com/elixxir/client/storage/user"
pb "gitlab.com/elixxir/comms/mixmessages"
"gitlab.com/elixxir/comms/network"
"gitlab.com/elixxir/crypto/csprng"
"gitlab.com/elixxir/crypto/cyclic"
+ "gitlab.com/elixxir/crypto/fastRNG"
"gitlab.com/elixxir/crypto/hash"
"gitlab.com/elixxir/crypto/registration"
"gitlab.com/xx_network/comms/connect"
@@ -33,26 +34,25 @@ type RegisterNodeCommsInterface interface {
message *pb.RequestRegistrationConfirmation) (*pb.RegistrationConfirmation, error)
}
-func StartRegistration(ctx *context.Context, comms RegisterNodeCommsInterface,
+func StartRegistration(instance *network.Instance, session *storage.Session, rngGen *fastRNG.StreamGenerator, comms RegisterNodeCommsInterface,
c chan network.NodeGateway) stoppable.Stoppable {
stop := stoppable.NewSingle("NodeRegistration")
- instance := ctx.Manager.GetInstance()
instance.SetAddGatewayChan(c)
- go registerNodes(ctx, comms, stop, c)
+ go registerNodes(session, rngGen, comms, stop, c)
return stop
}
-func registerNodes(ctx *context.Context, comms RegisterNodeCommsInterface,
+func registerNodes(session *storage.Session, rngGen *fastRNG.StreamGenerator, comms RegisterNodeCommsInterface,
stop *stoppable.Single, c chan network.NodeGateway) {
- u := ctx.Session.User()
+ u := session.User()
regSignature := u.GetRegistrationValidationSignature()
uci := u.GetCryptographicIdentity()
- cmix := ctx.Session.Cmix()
+ cmix := session.Cmix()
- rng := ctx.Rng.GetStream()
+ rng := rngGen.GetStream()
interval := time.Duration(500) * time.Millisecond
t := time.NewTicker(interval)
for true {
diff --git a/network/node/register_test.go b/network/node/register_test.go
index c2bb1a538e83a09ae280ffccee3b62b1dab4da40..3d5c27bcdb203d8ddf5360e359a27db184d2b126 100644
--- a/network/node/register_test.go
+++ b/network/node/register_test.go
@@ -2,16 +2,12 @@ package node
import (
"crypto/rand"
- "gitlab.com/elixxir/client/context"
- "gitlab.com/elixxir/client/context/message"
- "gitlab.com/elixxir/client/context/params"
"gitlab.com/elixxir/client/context/stoppable"
"gitlab.com/elixxir/client/storage"
pb "gitlab.com/elixxir/comms/mixmessages"
"gitlab.com/elixxir/comms/network"
"gitlab.com/elixxir/crypto/csprng"
"gitlab.com/elixxir/crypto/fastRNG"
- "gitlab.com/elixxir/primitives/format"
"gitlab.com/xx_network/comms/connect"
"gitlab.com/xx_network/crypto/signature/rsa"
"gitlab.com/xx_network/primitives/id"
@@ -20,39 +16,6 @@ import (
"time"
)
-// Mock network manager for
-type MockNetworkManager struct {
- instance *network.Instance
-}
-
-func (nm *MockNetworkManager) SendE2E(m message.Send, p params.E2E) ([]id.Round, error) {
- return nil, nil
-}
-func (nm *MockNetworkManager) SendUnsafe(m message.Send, p params.Unsafe) ([]id.Round, error) {
- return nil, nil
-}
-func (nm *MockNetworkManager) SendCMIX(message format.Message, p params.CMIX) (id.Round, error) {
- return id.Round(0), nil
-}
-func (nm *MockNetworkManager) GetInstance() *network.Instance {
- return nm.instance
-}
-func (nm *MockNetworkManager) GetHealthTracker() context.HealthTracker {
- return nil
-}
-
-func (nm *MockNetworkManager) GetRemoteVersion() (string, error) {
- return "", nil
-}
-
-func (nm *MockNetworkManager) GetStoppable() stoppable.Stoppable {
- return nil
-}
-
-func (nm *MockNetworkManager) RegisterWithPermissioning(string) ([]byte, error) {
- return nil, nil
-}
-
// Mock client comms object
type MockClientComms struct {
request chan bool
@@ -104,28 +67,19 @@ func TestRegisterNodes(t *testing.T) {
//uid := id.NewIdFromString("zezima", id.User, t)
comms := NewMockClientComms()
- def := getNDF()
instanceComms := &connect.ProtoComms{}
_, err = instanceComms.AddHost(&id.Permissioning, "0.0.0.0:420", []byte(pub), false, false)
if err != nil {
t.Errorf("Faield to add perm host: %+v", err)
}
- instance, err := network.NewInstanceTesting(instanceComms, def, def, nil, nil, t)
- if err != nil {
- t.Errorf("Failed to init test instance: %+v", err)
- }
+
sess := storage.InitTestingSession(t)
- ctx := context.Context{
- Manager: &MockNetworkManager{
- instance: instance,
- },
- Session: sess,
- Rng: fastRNG.NewStreamGenerator(7, 3, csprng.NewSystemRNG),
- }
+
+ rng := fastRNG.NewStreamGenerator(7, 3, csprng.NewSystemRNG)
stop := stoppable.NewSingle("test")
c := make(chan network.NodeGateway, 100)
- go registerNodes(&ctx, comms, stop, c)
+ go registerNodes(sess, rng, comms, stop, c)
c <- network.NodeGateway{
Node: ndf.Node{
@@ -158,43 +112,4 @@ func TestRegisterNodes(t *testing.T) {
if err != nil {
t.Errorf("Failed to stop registration thread: %+v", err)
}
-}
-
-func getNDF() *ndf.NetworkDefinition {
- return &ndf.NetworkDefinition{
- E2E: ndf.Group{
- Prime: "E2EE983D031DC1DB6F1A7A67DF0E9A8E5561DB8E8D49413394C049B" +
- "7A8ACCEDC298708F121951D9CF920EC5D146727AA4AE535B0922C688B55B3DD2AE" +
- "DF6C01C94764DAB937935AA83BE36E67760713AB44A6337C20E7861575E745D31F" +
- "8B9E9AD8412118C62A3E2E29DF46B0864D0C951C394A5CBBDC6ADC718DD2A3E041" +
- "023DBB5AB23EBB4742DE9C1687B5B34FA48C3521632C4A530E8FFB1BC51DADDF45" +
- "3B0B2717C2BC6669ED76B4BDD5C9FF558E88F26E5785302BEDBCA23EAC5ACE9209" +
- "6EE8A60642FB61E8F3D24990B8CB12EE448EEF78E184C7242DD161C7738F32BF29" +
- "A841698978825B4111B4BC3E1E198455095958333D776D8B2BEEED3A1A1A221A6E" +
- "37E664A64B83981C46FFDDC1A45E3D5211AAF8BFBC072768C4F50D7D7803D2D4F2" +
- "78DE8014A47323631D7E064DE81C0C6BFA43EF0E6998860F1390B5D3FEACAF1696" +
- "015CB79C3F9C2D93D961120CD0E5F12CBB687EAB045241F96789C38E89D796138E" +
- "6319BE62E35D87B1048CA28BE389B575E994DCA755471584A09EC723742DC35873" +
- "847AEF49F66E43873",
- Generator: "2",
- },
- CMIX: ndf.Group{
- Prime: "9DB6FB5951B66BB6FE1E140F1D2CE5502374161FD6538DF1648218642F0B5C48" +
- "C8F7A41AADFA187324B87674FA1822B00F1ECF8136943D7C55757264E5A1A44F" +
- "FE012E9936E00C1D3E9310B01C7D179805D3058B2A9F4BB6F9716BFE6117C6B5" +
- "B3CC4D9BE341104AD4A80AD6C94E005F4B993E14F091EB51743BF33050C38DE2" +
- "35567E1B34C3D6A5C0CEAA1A0F368213C3D19843D0B4B09DCB9FC72D39C8DE41" +
- "F1BF14D4BB4563CA28371621CAD3324B6A2D392145BEBFAC748805236F5CA2FE" +
- "92B871CD8F9C36D3292B5509CA8CAA77A2ADFC7BFD77DDA6F71125A7456FEA15" +
- "3E433256A2261C6A06ED3693797E7995FAD5AABBCFBE3EDA2741E375404AE25B",
- Generator: "5C7FF6B06F8F143FE8288433493E4769C4D988ACE5BE25A0E24809670716C613" +
- "D7B0CEE6932F8FAA7C44D2CB24523DA53FBE4F6EC3595892D1AA58C4328A06C4" +
- "6A15662E7EAA703A1DECF8BBB2D05DBE2EB956C142A338661D10461C0D135472" +
- "085057F3494309FFA73C611F78B32ADBB5740C361C9F35BE90997DB2014E2EF5" +
- "AA61782F52ABEB8BD6432C4DD097BC5423B285DAFB60DC364E8161F4A2A35ACA" +
- "3A10B1C4D203CC76A470A33AFDCBDD92959859ABD8B56E1725252D78EAC66E71" +
- "BA9AE3F1DD2487199874393CD4D832186800654760E1E34C09E4D155179F9EC0" +
- "DC4473F996BDCE6EED1CABED8B6F116F7AD9CF505DF0F998E34AB27514B0FFE7",
- },
- }
-}
+}
\ No newline at end of file
diff --git a/context/switchboard/any.go b/switchboard/any.go
similarity index 100%
rename from context/switchboard/any.go
rename to switchboard/any.go
diff --git a/context/switchboard/any_test.go b/switchboard/any_test.go
similarity index 100%
rename from context/switchboard/any_test.go
rename to switchboard/any_test.go
diff --git a/context/switchboard/byID.go b/switchboard/byID.go
similarity index 100%
rename from context/switchboard/byID.go
rename to switchboard/byID.go
diff --git a/context/switchboard/byID_test.go b/switchboard/byID_test.go
similarity index 100%
rename from context/switchboard/byID_test.go
rename to switchboard/byID_test.go
diff --git a/context/switchboard/byType.go b/switchboard/byType.go
similarity index 100%
rename from context/switchboard/byType.go
rename to switchboard/byType.go
diff --git a/context/switchboard/byType_test.go b/switchboard/byType_test.go
similarity index 100%
rename from context/switchboard/byType_test.go
rename to switchboard/byType_test.go
diff --git a/context/switchboard/listener.go b/switchboard/listener.go
similarity index 100%
rename from context/switchboard/listener.go
rename to switchboard/listener.go
diff --git a/context/switchboard/listener_test.go b/switchboard/listener_test.go
similarity index 100%
rename from context/switchboard/listener_test.go
rename to switchboard/listener_test.go
diff --git a/context/switchboard/switchboard.go b/switchboard/switchboard.go
similarity index 99%
rename from context/switchboard/switchboard.go
rename to switchboard/switchboard.go
index 0053686c3a57bcd8c8ec69c08a7d9fd4f3e11045..3c04a5a5577b8958e593fab48a729d9fc5520729 100644
--- a/context/switchboard/switchboard.go
+++ b/switchboard/switchboard.go
@@ -135,7 +135,7 @@ func (sw *Switchboard) Speak(item message.Receive) {
//Execute hear on all matched listeners in a new goroutine
matches.Do(func(i interface{}) {
r := i.(Listener)
- go r.Hear(item)
+ go Hear(item)
})
// print to log if nothing was heard
diff --git a/context/switchboard/switchboard_test.go b/switchboard/switchboard_test.go
similarity index 99%
rename from context/switchboard/switchboard_test.go
rename to switchboard/switchboard_test.go
index 5c54d2906a3a6558faa5123a7d9c2c36b9c05c64..de5a5bbc945fb25ade99357ff91e452f64e9104a 100644
--- a/context/switchboard/switchboard_test.go
+++ b/switchboard/switchboard_test.go
@@ -155,7 +155,7 @@ func TestSwitchboard_RegisterFunc(t *testing.T) {
t.Errorf("Listener is not registered by Message Type")
}
- lid.listener.Hear(message.Receive{})
+ Hear(message.Receive{})
if !heard {
t.Errorf("Func listener not registered correctly")
}
@@ -224,7 +224,7 @@ func TestSwitchboard_RegisterChan(t *testing.T) {
t.Errorf("Listener is not registered by Message Type")
}
- lid.listener.Hear(message.Receive{})
+ Hear(message.Receive{})
select {
case <-ch:
case <-time.After(5 * time.Millisecond):