Merge branch 'Josh/RegValidSig' into 'release'

Expose registration validation sig

See merge request !308

bindings/e2eHandler.go

@@ -10,7 +10,8 @@ package bindings
 import (
 	"encoding/json"
 	"fmt"
-
+	"github.com/pkg/errors"
+	jww "github.com/spf13/jwalterweatherman"
 	"gitlab.com/elixxir/client/catalog"
 	"gitlab.com/elixxir/client/cmix/identity/receptionID"
 	"gitlab.com/elixxir/client/cmix/rounds"
@@ -157,6 +158,42 @@ func (e *E2e) AddService(tag string, processor Processor) error {
 		tag, &messageProcessor{bindingsCbs: processor})
 }
 
+// RegisterListener registers a new listener.
+//
+// Parameters:
+//  - senderId - the user ID who sends messages to this user that
+//    this function will register a listener for.
+//  - messageType - message type from the sender you want to listen for.
+//  - newListener: A provider for a callback to hear a message.
+//    Do not pass nil to this.
+func (e *E2e) RegisterListener(senderID []byte,
+	messageType int,
+	newListener Listener) error {
+	jww.INFO.Printf("RegisterListener(%v, %d)", senderID,
+		messageType)
+
+	// Convert senderID to id.Id object
+	var uid *id.ID
+	if len(senderID) == 0 {
+		uid = &id.ID{}
+	} else {
+		var err error
+		uid, err = id.Unmarshal(senderID)
+		if err != nil {
+			return errors.New(fmt.Sprintf("Failed to "+
+				"ResgisterListener: %+v", err))
+		}
+	}
+
+	// Register listener
+	// todo: when implementing an unregister function, return and provide a way
+	//  track this listener ID
+	_ = e.api.GetE2E().RegisterListener(uid,
+		catalog.MessageType(messageType), listener{l: newListener})
+
+	return nil
+}
+
 // Processor is the bindings-specific interface for message.Processor methods.
 type Processor interface {
 	Process(message []byte, receptionId []byte, ephemeralId int64, roundId int64)

bindings/errors.go

+///////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC                                          //
+//                                                                           //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file                                                              //
+///////////////////////////////////////////////////////////////////////////////
+
+package bindings
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"github.com/pkg/errors"
+	"strings"
+	"sync"
+)
+
+// errToUserErr maps backend patterns to user-friendly error messages.
+// Example format:
+// (Back-end) "Building new HostPool because no HostList stored:":  (Front-end) "Missing host list",
+var errToUserErr = map[string]string{
+	// Registration errors
+	//"cannot create username when network is not health" :
+	//	"Cannot create username, unable to connect to network",
+	//"failed to add due to malformed fact stringified facts must at least have a type at the start" :
+	//	"Invalid fact, is the field empty?",
+	//// UD failures
+	//"failed to create user discovery manager: cannot return single manager, network is not health" :
+	//	"Could not connect to user discovery",
+	//"user discovery returned error on search: no results found" :
+	//	"No results found",
+	//"failed to search.: waiting for response to single-use transmisson timed out after 10s" :
+	//	"Search timed out",
+	//"the phone number supplied was empty" : "Invalid phone number",
+	//"failed to create user discovery manager: cannot start ud manager when network follower is not running." :
+	//	"Could not get network status",
+}
+
+// error<Mux is a global lock for the errToUserErr global.
+var errorMux sync.RWMutex
+
+// Error codes
+const (
+	UnrecognizedCode    = "UR: "
+	UnrecognizedMessage = UnrecognizedCode + "Unrecognized error from XX backend, please report"
+)
+
+// CreateUserFriendlyErrorMessage will convert the passed in error string
+// to an error string that is user-friendly if a substring match is
+// found to a common error. Common errors is a map which can be updated
+// using UpdateCommonErrors. If the error is not common, some simple parsing
+// is done on the error message to make it more user-accessible, removing
+// backend specific jargon.
+//
+// Parameters
+//   - errStr - an error returned from the backend.
+//
+// Returns
+//  - A user-friendly error message. This should be devoid of technical speak
+//    but still be meaningful for front-end or back-end teams.
+func CreateUserFriendlyErrorMessage(errStr string) string {
+	errorMux.RLock()
+	defer errorMux.RUnlock()
+	// Go through common errors
+	for backendErr, userFriendly := range errToUserErr {
+		// Determine if error contains a common error
+		if strings.Contains(errStr, backendErr) {
+			return userFriendly
+		}
+	}
+
+	descStr := "desc = "
+	// If this contains an rpc error, determine how to handle it
+	if strings.Contains(errStr, context.DeadlineExceeded.Error()) {
+		// If there is a context deadline exceeded message, return the higher level
+		// as context deadline exceeded is not informative
+		rpcErr := "rpc "
+		rpcIdx := strings.Index(errStr, rpcErr)
+		return errStr[:rpcIdx]
+	} else if strings.Contains(errStr, descStr) {
+		// If containing an rpc error where context deadline exceeded
+		// is NOT involved, the error returned server-side is often
+		//more informative
+		descIdx := strings.Index(errStr, descStr)
+		// return everything after "desc = "
+		return errStr[descIdx+len(descStr):]
+	}
+
+	// If a compound error message, return the highest level message
+	errParts := strings.Split(errStr, ":")
+	if len(errParts) > 1 {
+		// Return everything before the first :
+		return UnrecognizedCode + errParts[0]
+	}
+
+	return fmt.Sprintf("%s: %v", UnrecognizedCode, errStr)
+}
+
+// UpdateCommonErrors updates the internal error mapping DB. This internal database
+// maps errors returned from the backend to user-friendly error messages.
+//
+// Parameters
+//  - jsonFile - contents of a JSON file whose format conforms to the example below.
+// Example Input:
+//   {
+//  	"Failed to Unmarshal Conversation": "Could not retrieve conversation",
+//  	"Failed to unmarshal SentRequestMap": "Failed to pull up friend requests",
+//  	"cannot create username when network is not health": "Cannot create username, unable to connect to network",
+//  }
+func UpdateCommonErrors(jsonFile string) error {
+	errorMux.Lock()
+	defer errorMux.Unlock()
+	err := json.Unmarshal([]byte(jsonFile), &errToUserErr)
+	if err != nil {
+		return errors.WithMessage(err, "Failed to unmarshal json file, "+
+			"did you pass in the contents or the path?")
+	}
+
+	return nil
+}

bindings/errors_test.go

+///////////////////////////////////////////////////////////////////////////////
+// Copyright © 2020 xx network SEZC                                          //
+//                                                                           //
+// Use of this source code is governed by a license that can be found in the //
+// LICENSE file                                                              //
+///////////////////////////////////////////////////////////////////////////////
+
+package bindings
+
+import (
+	"context"
+	"strings"
+	"testing"
+)
+
+// Unit test
+func TestErrorStringToUserFriendlyMessage(t *testing.T) {
+	// Setup: Populate map
+	backendErrs := []string{"Failed to Unmarshal Conversation", "failed to create group key preimage",
+		"Failed to unmarshal SentRequestMap"}
+	userErrs := []string{"Could not retrieve conversation", "Failed to initiate group chat",
+		"Failed to pull up friend requests"}
+
+	for i, exampleErr := range backendErrs {
+		errToUserErr[exampleErr] = userErrs[i]
+	}
+
+	// Check if a mapped common error returns the expected user-friendly error
+	received := CreateUserFriendlyErrorMessage(backendErrs[0])
+	if strings.Compare(received, userErrs[0]) != 0 {
+		t.Errorf("Unexpected user friendly message returned from common error mapping."+
+			"\n\tExpected: %s"+
+			"\n\tReceived: %v", userErrs[0], received)
+	}
+
+	// Test RPC error in which high level information should
+	// be passed along (ie context deadline exceeded error)
+	expected := "Could not poll network: "
+	rpcPrefix := "rpc error: desc = "
+	rpcErr := expected + rpcPrefix + context.DeadlineExceeded.Error()
+	received = CreateUserFriendlyErrorMessage(rpcErr)
+	if strings.Compare(expected, received) != 0 {
+		t.Errorf("Rpc error parsed unxecpectedly with error "+
+			"\n\"%s\" "+
+			"\n\tExpected: %s"+
+			"\n\tReceived: %v", rpcErr, UnrecognizedCode+expected, received)
+	}
+
+	// Test RPC error where server side error information is provided
+	serverSideError := "Could not parse message! Please try again with a properly crafted message"
+	rpcErr = rpcPrefix + serverSideError
+	received = CreateUserFriendlyErrorMessage(rpcErr)
+	if strings.Compare(serverSideError, received) != 0 {
+		t.Errorf("RPC error parsed unexpectedly with error "+
+			"\n\"%s\" "+
+			"\n\tExpected: %s"+
+			"\n\tReceived: %v", rpcErr, UnrecognizedCode+serverSideError, received)
+	}
+
+	// Test uncommon error, should return highest level message
+	expected = "failed to register with permissioning"
+	uncommonErr := expected + ": sendRegistrationMessage: Unable to contact Identity Server"
+	received = CreateUserFriendlyErrorMessage(uncommonErr)
+	if strings.Compare(received, UnrecognizedCode+expected) != 0 {
+		t.Errorf("Uncommon error parsed unexpectedly with error "+
+			"\n\"%s\" "+
+			"\n\tExpected: %s"+
+			"\n\tReceived: %s", uncommonErr, UnrecognizedCode+expected, received)
+	}
+
+	// Test fully unrecognizable and un-parsable message,
+	// should hardcoded error message
+	uncommonErr = "failed to register with permissioning"
+	received = CreateUserFriendlyErrorMessage(uncommonErr)
+	if strings.Compare(UnrecognizedCode+": "+uncommonErr, received) != 0 {
+		t.Errorf("Uncommon error parsed unexpectedly with error "+
+			"\n\"%s\" "+
+			"\n\tExpected: %s"+
+			"\n\tReceived: %s", uncommonErr, UnrecognizedMessage, received)
+	}
+
+}
+
+// Unit test
+func TestClient_UpdateCommonErrors(t *testing.T) {
+
+	key, expectedVal := "failed to create group key preimage", "Failed to initiate group chat"
+
+	jsonData := "{\"Failed to Unmarshal Conversation\":\"Could not retrieve conversation\",\"Failed to unmarshal SentRequestMap\":\"Failed to pull up friend requests\",\"failed to create group key preimage\":\"Failed to initiate group chat\"}\n"
+
+	err := UpdateCommonErrors(jsonData)
+	if err != nil {
+		t.Fatalf("UpdateCommonErrors error: %v", err)
+	}
+
+	val, ok := errToUserErr[key]
+	if !ok {
+		t.Fatalf("Expected entry was not populated")
+	}
+
+	if strings.Compare(expectedVal, val) != 0 {
+		t.Fatalf("Entry in updated error map was not expected."+
+			"\n\tExpected: %s"+
+			"\n\tReceived: %s", expectedVal, val)
+	}
+
+}

bindings/identity.go

@@ -89,6 +89,12 @@ func (c *Cmix) MakeLegacyReceptionIdentity() ([]byte, error) {
 	return ident.Marshal()
 }
 
+// GetReceptionRegistrationValidationSignature returns the signature provided by
+// the xx network.
+func (c *Cmix) GetReceptionRegistrationValidationSignature() []byte {
+	return c.api.GetStorage().GetReceptionRegistrationValidationSignature()
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Contact Functions                                                          //
 ////////////////////////////////////////////////////////////////////////////////

bindings/ud.go

@@ -110,6 +110,10 @@ type UdNetworkStatus interface {
 // Parameters:
 //  - e2eID - e2e object ID in the tracker
 //  - follower - network follower func wrapped in UdNetworkStatus
+//  - username - the username the user wants to register with UD.
+//    If the user is already registered, this field may be blank
+//  - registrationValidationSignature - the signature provided by the xx network.
+//    This signature is optional for other consumers who deploy their own UD.
 func LoadOrNewUserDiscovery(e2eID int, follower UdNetworkStatus,
 	username string, registrationValidationSignature []byte) (
 	*UserDiscovery, error) {