mobile: add support for multiple LNC connections

Author: kaloudis

mobile/mobile.go

@@ -45,6 +45,10 @@ type mobileClient struct {
 
 	registry map[string]func(context.Context, *grpc.ClientConn,
 		string, func(string, error))
+
+	localPrivCreateCallback  NativeCallback
+	remoteKeyReceiveCallback NativeCallback
+	authDataCallback         NativeCallback
 }
 
 func newMobileClient() *mobileClient {
@@ -84,51 +88,54 @@ var (
 
 	jsonCBRegex = regexp.MustCompile(`(\w+)\.(\w+)\.(\w+)`)
 
-	m *mobileClient
+	m = make(map[string]*mobileClient)
 
 	registry = make(map[string]func(context.Context,
 		*grpc.ClientConn, string, func(string, error)))
 
-	localPrivCreateCallback  NativeCallback
-	remoteKeyReceiveCallback NativeCallback
-	authDataCallback         NativeCallback
+	interceptorLogsInitialize = false
 )
 
 // InitLNC sets up everything required for LNC to run including
 // signal interceptor, logs, and an instance of the mobile client.
-func InitLNC(debugLevel string) error {
-	// set debug level to 'info' if not specified
-	if debugLevel == "" {
-		debugLevel = "info"
-	}
+func InitLNC(namespace, debugLevel string) error {
+	// only initialize interceptor and logs on first connection
+	if !interceptorLogsInitialize {
+		// set debug level to 'info' if not specified
+		if debugLevel == "" {
+			debugLevel = "info"
+		}
 
-	// Hook interceptor for os signals.
-	shutdownInterceptor, err := signal.Intercept()
-	if err != nil {
-		return err
-	}
+		// Hook interceptor for os signals.
+		shutdownInterceptor, err := signal.Intercept()
+		if err != nil {
+			return err
+		}
 
-	logWriter := build.NewRotatingLogWriter()
-	SetupLoggers(logWriter, shutdownInterceptor)
+		logWriter := build.NewRotatingLogWriter()
+		SetupLoggers(logWriter, shutdownInterceptor)
 
-	err = build.ParseAndSetDebugLevels(debugLevel, logWriter)
-	if err != nil {
-		return err
-	}
+		err = build.ParseAndSetDebugLevels(debugLevel, logWriter)
+		if err != nil {
+			return err
+		}
 
-	m = newMobileClient()
+		for _, registration := range registrations {
+			registration(registry)
+		}
 
-	for _, registration := range registrations {
-		registration(registry)
+		interceptorLogsInitialize = true
 	}
 
+	m[namespace] = newMobileClient()
+
 	log.Debugf("Mobile client ready for connecting")
 	return nil
 }
 
 // ConnectServer creates a connection from the client to the
 // mailbox server.
-func ConnectServer(mailboxServer string, isDevServer bool,
+func ConnectServer(namespace string, mailboxServer string, isDevServer bool,
 	pairingPhrase string, localStatic string, remoteStatic string) error {
 
 	// Check that the correct arguments and config combinations have been
@@ -139,7 +146,7 @@ func ConnectServer(mailboxServer string, isDevServer bool,
 	}
 
 	// Parse the key arguments.
-	localPriv, remotePub, err := parseKeys(localStatic, remoteStatic)
+	localPriv, remotePub, err := parseKeys(namespace, localStatic, remoteStatic)
 	if err != nil {
 		return err
 	}
@@ -156,7 +163,7 @@ func ConnectServer(mailboxServer string, isDevServer bool,
 	statusChecker, lndConnect, err := core.MailboxRPCConnection(
 		mailboxServer, pairingPhrase, localPriv, remotePub,
 		func(key *btcec.PublicKey) error {
-			remoteKeyReceiveCallback.SendResult(hex.EncodeToString(
+			m[namespace].remoteKeyReceiveCallback.SendResult(hex.EncodeToString(
 				key.SerializeCompressed(),
 			))
 
@@ -180,9 +187,9 @@ func ConnectServer(mailboxServer string, isDevServer bool,
 					"macaroon: %v", err)
 			}
 
-			m.mac = mac
+			m[namespace].mac = mac
 
-			authDataCallback.SendResult(string(data))
+			m[namespace].authDataCallback.SendResult(string(data))
 
 			return nil
 		},
@@ -192,8 +199,8 @@ func ConnectServer(mailboxServer string, isDevServer bool,
 		return err
 	}
 
-	m.statusChecker = statusChecker
-	m.lndConn, err = lndConnect()
+	m[namespace].statusChecker = statusChecker
+	m[namespace].lndConn, err = lndConnect()
 	if err != nil {
 		return err
 	}
@@ -203,49 +210,51 @@ func ConnectServer(mailboxServer string, isDevServer bool,
 }
 
 // IsConnected returns whether or not there is an active connection.
-func IsConnected() bool {
-	return m.lndConn != nil
+func IsConnected(namespace string) bool {
+	return m[namespace].lndConn != nil
 }
 
 // Disconnect closes the RPC connection.
-func Disconnect() {
-	if m.lndConn != nil {
-		if err := m.lndConn.Close(); err != nil {
+func Disconnect(namespace string) {
+	if m[namespace].lndConn != nil {
+		if err := m[namespace].lndConn.Close(); err != nil {
 			log.Errorf("Error closing RPC connection: %v", err)
 		}
-		m.lndConn = nil
+		m[namespace].lndConn = nil
 	}
 }
 
 // Status returns the status of the LNC RPC connection.
-func Status() string {
-	if m.statusChecker == nil {
+func Status(namespace string) string {
+	if m[namespace].statusChecker == nil {
 		return ""
 	}
 
-	return m.statusChecker().String()
+	return m[namespace].statusChecker().String()
 }
 
 // RegisterLocalPrivCreateCallback sets up the native callbacks upon
 // creation of local private key.
-func RegisterLocalPrivCreateCallback(c NativeCallback) {
-	localPrivCreateCallback = c
+func RegisterLocalPrivCreateCallback(namespace string, c NativeCallback) {
+	m[namespace].localPrivCreateCallback = c
 }
 
 // RegisterRemoteKeyReceiveCallback sets up the native callbacks upon
 // receiving the remote key from the server.
-func RegisterRemoteKeyReceiveCallback(c NativeCallback) {
-	remoteKeyReceiveCallback = c
+func RegisterRemoteKeyReceiveCallback(namespace string, c NativeCallback) {
+	m[namespace].remoteKeyReceiveCallback = c
 }
 
 // RegisterAuthDataCallback sets up the native callbacks upon
 // receiving auth data.
-func RegisterAuthDataCallback(c NativeCallback) {
-	authDataCallback = c
+func RegisterAuthDataCallback(namespace string, c NativeCallback) {
+	m[namespace].authDataCallback = c
 }
 
 // InvokeRPC makes a synchronous RPC call.
-func InvokeRPC(rpcName string, requestJSON string, c NativeCallback) error {
+func InvokeRPC(namespace string, rpcName string, requestJSON string,
+	c NativeCallback) error {
+
 	if rpcName == "" {
 		return fmt.Errorf("param rpcName required")
 	}
@@ -254,7 +263,7 @@ func InvokeRPC(rpcName string, requestJSON string, c NativeCallback) error {
 		return fmt.Errorf("param requestJSON required")
 	}
 
-	if m.lndConn == nil {
+	if m[namespace].lndConn == nil {
 		return fmt.Errorf("RPC connection not ready")
 	}
 
@@ -273,21 +282,21 @@ func InvokeRPC(rpcName string, requestJSON string, c NativeCallback) error {
 			}
 		}
 		ctx := context.Background()
-		method(ctx, m.lndConn, requestJSON, cb)
+		method(ctx, m[namespace].lndConn, requestJSON, cb)
 		<-ctx.Done()
 	}()
 
 	return nil
 }
 
 // GetExpiry returns the expiration time of the connection macaroon.
-func GetExpiry() (string, error) {
-	if m.mac == nil {
+func GetExpiry(namespace string) (string, error) {
+	if m[namespace].mac == nil {
 		return "", fmt.Errorf("macaroon not obtained yet. GetExpiry should " +
 			"only be called once the connection is complete")
 	}
 
-	expiry, found := checkers.ExpiryTime(nil, m.mac.Caveats())
+	expiry, found := checkers.ExpiryTime(nil, m[namespace].mac.Caveats())
 	if !found {
 		return "", fmt.Errorf("expiry not found")
 	}
@@ -296,14 +305,14 @@ func GetExpiry() (string, error) {
 }
 
 // IsReadOnly returns whether or not the connection macaroon is read-only.
-func IsReadOnly() bool {
-	if m.mac == nil {
+func IsReadOnly(namespace string) bool {
+	if m[namespace].mac == nil {
 		log.Errorf("macaroon not obtained yet. IsReadOnly should " +
 			"only be called once the connection is complete")
 		return false
 	}
 
-	macOps, err := extractMacaroonOps(m.mac)
+	macOps, err := extractMacaroonOps(m[namespace].mac)
 	if err != nil {
 		log.Errorf("could not extract macaroon ops: %v", err)
 		return false
@@ -316,12 +325,12 @@ func IsReadOnly() bool {
 
 // HasPermissions returns whether or not the connection macaroon
 // has a specificed permission.
-func HasPermissions(permission string) bool {
+func HasPermissions(namespace, permission string) bool {
 	if permission == "" {
 		return false
 	}
 
-	if m.mac == nil {
+	if m[namespace].mac == nil {
 		log.Errorf("macaroon not obtained yet. HasPermissions should " +
 			"only be called once the connection is complete")
 		return false
@@ -340,7 +349,7 @@ func HasPermissions(permission string) bool {
 		return false
 	}
 
-	macOps, err := extractMacaroonOps(m.mac)
+	macOps, err := extractMacaroonOps(m[namespace].mac)
 	if err != nil {
 		log.Errorf("could not extract macaroon ops: %v", err)
 		return false
@@ -430,7 +439,7 @@ func validateArgs(mailboxServer, localPrivKey, remotePubKey string) error {
 // parseKeys parses the given keys from their string format and calls callback
 // functions where appropriate. NOTE: This function assumes that the parameter
 // combinations have been checked by validateArgs.
-func parseKeys(localPrivKey, remotePubKey string) (
+func parseKeys(namespace, localPrivKey, remotePubKey string) (
 	keychain.SingleKeyECDH, *btcec.PublicKey, error) {
 
 	var (
@@ -449,7 +458,7 @@ func parseKeys(localPrivKey, remotePubKey string) (
 		}
 		localStaticKey = &keychain.PrivKeyECDH{PrivKey: privKey}
 
-		localPrivCreateCallback.SendResult(
+		m[namespace].localPrivCreateCallback.SendResult(
 			hex.EncodeToString(privKey.Serialize()),
 		)