Merge branch 'XX-2878/ParamBindings' into 'release'

add ability to pass in params via bindings

Closes XX-2878

See merge request !480

api/client.go

@@ -40,6 +40,8 @@ type Client struct {
 	switchboard *switchboard.Switchboard
 	//object used for communications
 	comms *client.Comms
+	// Network parameters
+	parameters params.Network
 
 	// note that the manager has a pointer to the context in many cases, but
 	// this interface allows it to be mocked for easy testing without the
@@ -146,7 +148,7 @@ func NewPrecannedClient(precannedID uint, defJSON, storageDir string, password [
 }
 
 // OpenClient session, but don't connect to the network or log in
-func OpenClient(storageDir string, password []byte) (*Client, error) {
+func OpenClient(storageDir string, password []byte, parameters params.Network) (*Client, error) {
 	jww.INFO.Printf("OpenClient()")
 	// Use fastRNG for RNG ops (AES fortuna based RNG using system RNG)
 	rngStreamGen := fastRNG.NewStreamGenerator(12, 3,
@@ -168,16 +170,17 @@ func OpenClient(storageDir string, password []byte) (*Client, error) {
 		network:     nil,
 		runner:      stoppable.NewMulti("client"),
 		status:      newStatusTracker(),
+		parameters:  parameters,
 	}
 
 	return c, nil
 }
 
 // Login initalizes a client object from existing storage.
-func Login(storageDir string, password []byte) (*Client, error) {
+func Login(storageDir string, password []byte, parameters params.Network) (*Client, error) {
 	jww.INFO.Printf("Login()")
 
-	c, err := OpenClient(storageDir, password)
+	c, err := OpenClient(storageDir, password, parameters)
 
 	if err != nil {
 		return nil, err
@@ -187,8 +190,8 @@ func Login(storageDir string, password []byte) (*Client, error) {
 	c.services = newServiceProcessiesList(c.runner)
 
 	//get the user from session
-	user := c.storage.User()
-	cryptoUser := user.GetCryptographicIdentity()
+	u := c.storage.User()
+	cryptoUser := u.GetCryptographicIdentity()
 
 	//start comms
 	c.comms, err = client.NewClientComms(cryptoUser.GetUserID(),
@@ -228,7 +231,7 @@ func Login(storageDir string, password []byte) (*Client, error) {
 
 	// Initialize network and link it to context
 	c.network, err = network.NewManager(c.storage, c.switchboard, c.rng, c.comms,
-		params.GetDefaultNetwork(), def)
+		parameters, def)
 	if err != nil {
 		return nil, err
 	}
@@ -293,7 +296,7 @@ func (c *Client) StartNetworkFollower() error {
 	}
 	c.runner.Add(stopFollow)
 	// Key exchange
-	c.runner.Add(keyExchange.Start(c.switchboard, c.storage, c.network, params.GetDefaultRekey()))
+	c.runner.Add(keyExchange.Start(c.switchboard, c.storage, c.network, c.parameters.Rekey))
 
 	err = c.status.toRunning()
 	if err != nil {

bindings/client.go

@@ -15,6 +15,7 @@ import (
 	"gitlab.com/elixxir/client/api"
 	"gitlab.com/elixxir/client/interfaces/contact"
 	"gitlab.com/elixxir/client/interfaces/message"
+	"gitlab.com/elixxir/client/interfaces/params"
 	"gitlab.com/elixxir/client/interfaces/utility"
 	"gitlab.com/elixxir/comms/mixmessages"
 	ds "gitlab.com/elixxir/comms/network/dataStructures"
@@ -75,8 +76,13 @@ func NewPrecannedClient(precannedID int, network, storageDir string, password []
 // memory and stored as securely as possible using the memguard library.
 // Login does not block on network connection, and instead loads and
 // starts subprocesses to perform network operations.
-func Login(storageDir string, password []byte) (*Client, error) {
-	client, err := api.Login(storageDir, password)
+func Login(storageDir string, password []byte, parameters string) (*Client, error) {
+	p, err := params.GetNetworkParameters(parameters)
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("Failed to login: %+v", err))
+	}
+
+	client, err := api.Login(storageDir, password, p)
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("Failed to login: %+v", err))
 	}

interfaces/params/node.go → bindings/params.go

 ///////////////////////////////////////////////////////////////////////////////
-// Copyright © 2020 xx network SEZC                                          //
+// Copyright © 2021 xx network SEZC                                          //
 //                                                                           //
 // Use of this source code is governed by a license that can be found in the //
 // LICENSE file                                                              //
 ///////////////////////////////////////////////////////////////////////////////
 
-package params
+// Contains params-related bindings
 
-//import (
-//	"time"
-//)
+package bindings
 
-type NodeKeys struct {
-	WorkerPoolSize uint
+import (
+	"gitlab.com/elixxir/client/interfaces/params"
+)
+
+func (c *Client) GetCMIXParams() (string, error) {
+	p, err := params.GetDefaultCMIX().Marshal()
+	return string(p), err
+}
+
+func (c *Client) GetE2EParams() (string, error) {
+	p, err := params.GetDefaultE2E().Marshal()
+	return string(p), err
 }
 
-func GetDefaultNodeKeys() NodeKeys {
-	return NodeKeys{
-		WorkerPoolSize: 10,
+func (c *Client) GetNetworkParams() (string, error) {
+	p, err := params.GetDefaultNetwork().Marshal()
+	return string(p), err
 }
+
+func (c *Client) GetUnsafeParams() (string, error) {
+	p, err := params.GetDefaultUnsafe().Marshal()
+	return string(p), err
 }

bindings/send.go

@@ -30,7 +30,13 @@ import (
 // This will return the round the message was sent on if it is successfully sent
 // This can be used to register a round event to learn about message delivery.
 // on failure a round id of -1 is returned
-func (c *Client) SendCmix(recipient, contents []byte) (int, error) {
+func (c *Client) SendCmix(recipient, contents []byte, parameters string) (int, error) {
+	p, err := params.GetCMIXParameters(parameters)
+	if err != nil {
+		return -1, errors.New(fmt.Sprintf("Failed to sendCmix: %+v",
+			err))
+	}
+
 	u, err := id.Unmarshal(recipient)
 	if err != nil {
 		return -1, errors.New(fmt.Sprintf("Failed to sendCmix: %+v",
@@ -43,7 +49,7 @@ func (c *Client) SendCmix(recipient, contents []byte) (int, error) {
 			err))
 	}
 
-	rid, err := c.api.SendCMIX(msg, params.GetDefaultCMIX())
+	rid, err := c.api.SendCMIX(msg, p)
 	if err != nil {
 		return -1, errors.New(fmt.Sprintf("Failed to sendCmix: %+v",
 			err))
@@ -60,7 +66,12 @@ func (c *Client) SendCmix(recipient, contents []byte) (int, error) {
 // Message Types can be found in client/interfaces/message/type.go
 // Make sure to not conflict with ANY default message types with custom types
 func (c *Client) SendUnsafe(recipient, payload []byte,
-	messageType int) (*RoundList, error) {
+	messageType int, parameters string) (*RoundList, error) {
+	p, err := params.GetUnsafeParameters(parameters)
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("Failed to sendUnsafe: %+v",
+			err))
+	}
 	u, err := id.Unmarshal(recipient)
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("Failed to sendUnsafe: %+v",
@@ -73,7 +84,7 @@ func (c *Client) SendUnsafe(recipient, payload []byte,
 		MessageType: message.Type(messageType),
 	}
 
-	rids, err := c.api.SendUnsafe(m, params.GetDefaultUnsafe())
+	rids, err := c.api.SendUnsafe(m, p)
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("Failed to sendUnsafe: %+v",
 			err))
@@ -88,7 +99,12 @@ func (c *Client) SendUnsafe(recipient, payload []byte,
 //
 // Message Types can be found in client/interfaces/message/type.go
 // Make sure to not conflict with ANY default message types
-func (c *Client) SendE2E(recipient, payload []byte, messageType int) (*SendReport, error) {
+func (c *Client) SendE2E(recipient, payload []byte, messageType int, parameters string) (*SendReport, error) {
+	p, err := params.GetE2EParameters(parameters)
+	if err != nil {
+		return nil, errors.New(fmt.Sprintf("Failed SendE2E: %+v", err))
+	}
+
 	u, err := id.Unmarshal(recipient)
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("Failed SendE2E: %+v", err))
@@ -100,7 +116,7 @@ func (c *Client) SendE2E(recipient, payload []byte, messageType int) (*SendRepor
 		MessageType: message.Type(messageType),
 	}
 
-	rids, mid, err := c.api.SendE2E(m, params.GetDefaultE2E())
+	rids, mid, err := c.api.SendE2E(m, p)
 	if err != nil {
 		return nil, errors.New(fmt.Sprintf("Failed SendE2E: %+v", err))
 	}

cmd/root.go

@@ -212,7 +212,7 @@ func createClient() *api.Client {
 		}
 	}
 
-	client, err := api.OpenClient(storeDir, []byte(pass))
+	client, err := api.OpenClient(storeDir, []byte(pass), params.GetDefaultNetwork())
 	if err != nil {
 		jww.FATAL.Panicf("%+v", err)
 	}
@@ -226,7 +226,7 @@ func initClient() *api.Client {
 	storeDir := viper.GetString("session")
 
 	//load the client
-	client, err := api.Login(storeDir, []byte(pass))
+	client, err := api.Login(storeDir, []byte(pass), params.GetDefaultNetwork())
 	if err != nil {
 		jww.FATAL.Panicf("%+v", err)
 	}

interfaces/params/CMIX.go

@@ -7,7 +7,10 @@
 
 package params
 
-import "time"
+import (
+	"encoding/json"
+	"time"
+)
 
 type CMIX struct {
 	//maximum number of rounds to try and send on
@@ -23,3 +26,19 @@ func GetDefaultCMIX() CMIX {
 		RetryDelay: 1 * time.Second,
 	}
 }
+
+func (c CMIX) Marshal() ([]byte, error) {
+	return json.Marshal(c)
+}
+
+// Obtain default CMIX parameters, or override with given parameters if set
+func GetCMIXParameters(params string) (CMIX, error) {
+	p := GetDefaultCMIX()
+	if len(params) > 0 {
+		err := json.Unmarshal([]byte(params), &p)
+		if err != nil {
+			return CMIX{}, err
+		}
+	}
+	return p, nil
+}

interfaces/params/CMIX_test.go

@@ -18,3 +18,38 @@ func TestGetDefaultCMIX(t *testing.T) {
 		t.Errorf("GetDefaultCMIX did not return expected values")
 	}
 }
+
+// New params path
+func TestGetCMIXParameters(t *testing.T) {
+	p := GetDefaultCMIX()
+
+	expected := p.RoundTries + 1
+	p.RoundTries = expected
+	jsonString, err := p.Marshal()
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	q, err := GetCMIXParameters(string(jsonString))
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.RoundTries != expected {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.RoundTries, expected)
+	}
+}
+
+// No new params path
+func TestGetCMIXParameters_Default(t *testing.T) {
+	p := GetDefaultCMIX()
+
+	q, err := GetCMIXParameters("")
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.RoundTries != p.RoundTries {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.RoundTries, p.RoundTries)
+	}
+}

interfaces/params/E2E.go

@@ -7,7 +7,10 @@
 
 package params
 
-import "fmt"
+import (
+	"encoding/json"
+	"fmt"
+)
 
 type E2E struct {
 	Type SendType
@@ -19,6 +22,21 @@ func GetDefaultE2E() E2E {
 		CMIX: GetDefaultCMIX(),
 	}
 }
+func (e E2E) Marshal() ([]byte, error) {
+	return json.Marshal(e)
+}
+
+// Obtain default E2E parameters, or override with given parameters if set
+func GetE2EParameters(params string) (E2E, error) {
+	p := GetDefaultE2E()
+	if len(params) > 0 {
+		err := json.Unmarshal([]byte(params), &p)
+		if err != nil {
+			return E2E{}, err
+		}
+	}
+	return p, nil
+}
 
 type SendType uint8
 

interfaces/params/E2E_test.go

@@ -31,3 +31,38 @@ func TestSendType_String(t *testing.T) {
 		t.Errorf("Running String on unknown E2E type got %s", e.Type.String())
 	}
 }
+
+// New params path
+func TestGetE2EParameters(t *testing.T) {
+	p := GetDefaultE2E()
+
+	expected := p.RoundTries + 1
+	p.RoundTries = expected
+	jsonString, err := p.Marshal()
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	q, err := GetE2EParameters(string(jsonString))
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.RoundTries != expected {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.RoundTries, expected)
+	}
+}
+
+// No new params path
+func TestGetE2EParameters_Default(t *testing.T) {
+	p := GetDefaultE2E()
+
+	q, err := GetE2EParameters("")
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.RoundTries != p.RoundTries {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.RoundTries, p.RoundTries)
+	}
+}

interfaces/params/keyExchange.go

@@ -7,7 +7,9 @@
 
 package params
 
-import "time"
+import (
+	"time"
+)
 
 type Rekey struct {
 	RoundTimeout time.Duration

interfaces/params/message.go

@@ -7,7 +7,9 @@
 
 package params
 
-import "time"
+import (
+	"time"
+)
 
 type Messages struct {
 	MessageReceptionBuffLen        uint

interfaces/params/network.go

@@ -8,6 +8,7 @@
 package params
 
 import (
+	"encoding/json"
 	"time"
 )
 
@@ -23,6 +24,7 @@ type Network struct {
 
 	Rounds
 	Messages
+	Rekey
 }
 
 func GetDefaultNetwork() Network {
@@ -36,3 +38,19 @@ func GetDefaultNetwork() Network {
 	n.Messages = GetDefaultMessage()
 	return n
 }
+
+func (n Network) Marshal() ([]byte, error) {
+	return json.Marshal(n)
+}
+
+// Obtain default Network parameters, or override with given parameters if set
+func GetNetworkParameters(params string) (Network, error) {
+	p := GetDefaultNetwork()
+	if len(params) > 0 {
+		err := json.Unmarshal([]byte(params), &p)
+		if err != nil {
+			return Network{}, err
+		}
+	}
+	return p, nil
+}

interfaces/params/network_test.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2021 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
+package params
+
+import "testing"
+
+// New params path
+func TestGetNetworkParameters(t *testing.T) {
+	p := GetDefaultNetwork()
+
+	expected := p.MaxCheckedRounds + 1
+	p.MaxCheckedRounds = expected
+	jsonString, err := p.Marshal()
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	q, err := GetNetworkParameters(string(jsonString))
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.MaxCheckedRounds != expected {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.MaxCheckedRounds, expected)
+	}
+}
+
+// No new params path
+func TestGetNetworkParameters_Default(t *testing.T) {
+	p := GetDefaultNetwork()
+
+	q, err := GetNetworkParameters("")
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.MaxCheckedRounds != p.MaxCheckedRounds {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.MaxCheckedRounds, p.MaxCheckedRounds)
+	}
+}

interfaces/params/rounds.go

@@ -7,7 +7,9 @@
 
 package params
 
-import "time"
+import (
+	"time"
+)
 
 type Rounds struct {
 	// maximum number of times to attempt to retrieve a round from a gateway

interfaces/params/Unsafe.go → interfaces/params/unsafe.go

@@ -7,6 +7,8 @@
 
 package params
 
+import "encoding/json"
+
 type Unsafe struct {
 	CMIX
 }
@@ -14,3 +16,19 @@ type Unsafe struct {
 func GetDefaultUnsafe() Unsafe {
 	return Unsafe{CMIX: GetDefaultCMIX()}
 }
+
+func (u Unsafe) Marshal() ([]byte, error) {
+	return json.Marshal(u)
+}
+
+// Obtain default Unsafe parameters, or override with given parameters if set
+func GetUnsafeParameters(params string) (Unsafe, error) {
+	p := GetDefaultUnsafe()
+	if len(params) > 0 {
+		err := json.Unmarshal([]byte(params), &p)
+		if err != nil {
+			return Unsafe{}, err
+		}
+	}
+	return p, nil
+}

interfaces/params/unsafe_test.go

+////////////////////////////////////////////////////////////////////////////////
+// Copyright © 2021 Privategrity Corporation                                   /
+//                                                                             /
+// All rights reserved.                                                        /
+////////////////////////////////////////////////////////////////////////////////
+
+package params
+
+import "testing"
+
+// New params path
+func TestGetUnsafeParameters(t *testing.T) {
+	p := GetDefaultUnsafe()
+
+	expected := p.RoundTries + 1
+	p.RoundTries = expected
+	jsonString, err := p.Marshal()
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	q, err := GetUnsafeParameters(string(jsonString))
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.RoundTries != expected {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.RoundTries, expected)
+	}
+}
+
+// No new params path
+func TestGetUnsafeParameters_Default(t *testing.T) {
+	p := GetDefaultUnsafe()
+
+	q, err := GetUnsafeParameters("")
+	if err != nil {
+		t.Errorf("%+v", err)
+	}
+
+	if q.RoundTries != p.RoundTries {
+		t.Errorf("Parameters failed to change! Got %d, Expected %d", q.RoundTries, p.RoundTries)
+	}
+}

network/internal/internal.go

@@ -35,6 +35,4 @@ type Internal struct {
 
 	//channels
 	NodeRegistration chan network.NodeGateway
-	//local pointer to user ID because it is used often
-
 }

network/message/critical.go

@@ -44,7 +44,7 @@ func (m *Manager) processCriticalMessages(quitCh <-chan struct{}) {
 func (m *Manager) criticalMessages() {
 	critMsgs := m.Session.GetCriticalMessages()
 	// try to send every message in the critical messages and the raw critical
-	// messages buffer in paralell
+	// messages buffer in parallel
 
 	//critical messages
 	for msg, param, has := critMsgs.Next(); has; msg, param, has = critMsgs.Next() {
@@ -60,7 +60,7 @@ func (m *Manager) criticalMessages() {
 				return
 			}
 			jww.INFO.Printf("critical RoundIDs: %v", rounds)
-			//wait on the results to make sure the rounds were sucesfull
+			//wait on the results to make sure the rounds were successful
 			sendResults := make(chan ds.EventReturn, len(rounds))
 			roundEvents := m.Instance.GetRoundEvents()
 			for _, r := range rounds {