lnrpc+lnd+rpc: add new Signer RPC service, and sub RPC server infrastructure

config.go

@@ -24,6 +24,7 @@ import (
 	"github.com/lightningnetwork/lnd/build"
 	"github.com/lightningnetwork/lnd/htlcswitch/hodl"
 	"github.com/lightningnetwork/lnd/lncfg"
+	"github.com/lightningnetwork/lnd/lnrpc/signrpc"
 	"github.com/lightningnetwork/lnd/lnwire"
 	"github.com/lightningnetwork/lnd/routing"
 	"github.com/lightningnetwork/lnd/tor"
@@ -220,6 +221,8 @@ type config struct {
 
 	Tor *torConfig `group:"Tor" namespace:"tor"`
 
+	SubRPCServers *subRPCServerConfigs `group:"subrpc"`
+
 	Hodl *hodl.Config `group:"hodl" namespace:"hodl"`
 
 	NoNetBootstrap bool `long:"nobootstrap" description:"If true, then automatic network bootstrapping will not be attempted."`
@@ -295,6 +298,9 @@ func loadConfig() (*config, error) {
 		},
 		MaxPendingChannels: defaultMaxPendingChannels,
 		NoSeedBackup:       defaultNoSeedBackup,
+		SubRPCServers: &subRPCServerConfigs{
+			SignRPC: &signrpc.Config{},
+		},
 		Autopilot: &autoPilotConfig{
 			MaxChannels:    5,
 			Allocation:     0.6,

lnd.go

@@ -312,66 +312,20 @@ func lndMain() error {
 		return err
 	}
 
-	// Check macaroon authentication if macaroons aren't disabled.
-	if macaroonService != nil {
-		serverOpts = append(serverOpts,
-			grpc.UnaryInterceptor(macaroonService.
-				UnaryServerInterceptor(permissions)),
-			grpc.StreamInterceptor(macaroonService.
-				StreamServerInterceptor(permissions)),
-		)
-	}
-
 	// Initialize, and register our implementation of the gRPC interface
 	// exported by the rpcServer.
-	rpcServer := newRPCServer(server)
-	if err := rpcServer.Start(); err != nil {
-		return err
-	}
-	defer rpcServer.Stop()
-
-	grpcServer := grpc.NewServer(serverOpts...)
-	lnrpc.RegisterLightningServer(grpcServer, rpcServer)
-
-	// Next, Start the gRPC server listening for HTTP/2 connections.
-	for _, listener := range cfg.RPCListeners {
-		lis, err := lncfg.ListenOnAddress(listener)
-		if err != nil {
-			ltndLog.Errorf(
-				"RPC server unable to listen on %s", listener,
-			)
-			return err
-		}
-		defer lis.Close()
-		go func() {
-			rpcsLog.Infof("RPC server listening on %s", lis.Addr())
-			grpcServer.Serve(lis)
-		}()
-	}
-
-	// Finally, start the REST proxy for our gRPC server above.
-	mux := proxy.NewServeMux()
-	err = lnrpc.RegisterLightningHandlerFromEndpoint(
-		ctx, mux, cfg.RPCListeners[0].String(), proxyOpts,
+	rpcServer, err := newRPCServer(
+		server, macaroonService, cfg.SubRPCServers, serverOpts,
+		proxyOpts, tlsConf,
 	)
 	if err != nil {
+		srvrLog.Errorf("unable to start RPC server: %v", err)
 		return err
 	}
-	for _, restEndpoint := range cfg.RESTListeners {
-		lis, err := lncfg.TLSListenOnAddress(restEndpoint, tlsConf)
-		if err != nil {
-			ltndLog.Errorf(
-				"gRPC proxy unable to listen on %s",
-				restEndpoint,
-			)
-			return err
-		}
-		defer lis.Close()
-		go func() {
-			rpcsLog.Infof("gRPC proxy started at %s", lis.Addr())
-			http.Serve(lis, mux)
-		}()
+	if err := rpcServer.Start(); err != nil {
+		return err
 	}
+	defer rpcServer.Stop()
 
 	// If we're not in simnet mode, We'll wait until we're fully synced to
 	// continue the start up of the remainder of the daemon. This ensures
@@ -602,9 +556,9 @@ func genCertPair(certFile, keyFile string) error {
 	return nil
 }
 
-// genMacaroons generates three macaroon files; one admin-level, one
-// for invoice access and one read-only. These can also be used
-// to generate more granular macaroons.
+// genMacaroons generates three macaroon files; one admin-level, one for
+// invoice access and one read-only. These can also be used to generate more
+// granular macaroons.
 func genMacaroons(ctx context.Context, svc *macaroons.Service,
 	admFile, roFile, invoiceFile string) error {
 

lnrpc/gen_protos.sh

@@ -1,14 +1,14 @@
 #!/bin/sh
 
+echo "Generating root gRPC server protos"
+
 # Generate the protos.
 protoc -I/usr/local/include -I. \
        -I$GOPATH/src \
        -I$GOPATH/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis \
        --go_out=plugins=grpc:. \
        rpc.proto
 
-
-
 # Generate the REST reverse proxy.
 protoc -I/usr/local/include -I. \
        -I$GOPATH/src \
@@ -22,3 +22,16 @@ protoc -I/usr/local/include -I. \
        -I$GOPATH/src/github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis \
        --swagger_out=logtostderr=true:. \
        rpc.proto
+
+# For each of the sub-servers, we then generate their protos, but a restricted
+# set as they don't yet require REST proxies, or swagger docs.
+for file in **/*.proto
+do
+    DIRECTORY=$(dirname ${file})
+    echo "Generating protos from ${file}, into ${DIRECTORY}"
+
+    protoc -I/usr/local/include -I. \
+           -I$GOPATH/src \
+           --go_out=plugins=grpc:. \
+           ${file}
+done

lnrpc/signrpc/config_active.go

@@ -0,0 +1,33 @@
+// +build signrpc
+
+package signrpc
+
+import (
+	"github.com/lightningnetwork/lnd/lnwallet"
+	"github.com/lightningnetwork/lnd/macaroons"
+)
+
+// Config is the primary configuration struct for the signer RPC server. It
+// contains all the items required for the signer rpc server to carry out its
+// duties. The fields with struct tags are meant to be parsed as normal
+// configuration options, while if able to be populated, the latter fields MUST
+// also be specified.
+type Config struct {
+	// SignerMacPath is the path for the signer macaroon. If unspecified
+	// then we assume that the macaroon will be found under the network
+	// directory, named DefaultSignerMacFilename.
+	SignerMacPath string `long:"signermacaroonpath" description:"Path to the signer macaroon"`
+
+	// NetworkDir is the main network directory wherein the signer rpc
+	// server will find the macaroon named DefaultSignerMacFilename.
+	NetworkDir string
+
+	// MacService is the main macaroon service that we'll use to handle
+	// authentication for the signer rpc server.
+	MacService *macaroons.Service
+
+	// Signer is the signer instance that backs the signer RPC server. The
+	// job of the signer RPC server is simply to proxy valid requests to
+	// the active signer instance.
+	Signer lnwallet.Signer
+}

lnrpc/signrpc/config_default.go

@@ -0,0 +1,6 @@
+// +build !signrpc
+
+package signrpc
+
+// Config is empty for non-signrpc builds.
+type Config struct{}

lnrpc/signrpc/driver.go

@@ -0,0 +1,71 @@
+// +build signrpc
+
+package signrpc
+
+import (
+	"fmt"
+
+	"github.com/lightningnetwork/lnd/lnrpc"
+)
+
+// createNewSubServer is a helper method that will create the new signer sub
+// server given the main config dispatcher method. If we're unable to find the
+// config that is meant for us in the config dispatcher, then we'll exit with
+// an error.
+func createNewSubServer(configRegistry lnrpc.SubServerConfigDispatcher) (
+	lnrpc.SubServer, lnrpc.MacaroonPerms, error) {
+
+	// We'll attempt to look up the config that we expect, according to our
+	// subServerName name. If we can't find this, then we'll exit with an
+	// error, as we're unable to properly initialize ourselves without this
+	// config.
+	signServerConf, ok := configRegistry.FetchConfig(subServerName)
+	if !ok {
+		return nil, nil, fmt.Errorf("unable to find config for "+
+			"subserver type %s", subServerName)
+	}
+
+	// Now that we've found an object mapping to our service name, we'll
+	// ensure that it's the type we need.
+	config, ok := signServerConf.(*Config)
+	if !ok {
+		return nil, nil, fmt.Errorf("wrong type of config for "+
+			"subserver %s, expected %T got %T", subServerName,
+			&Config{}, signServerConf)
+	}
+
+	// Before we try to make the new signer service instance, we'll perform
+	// some sanity checks on the arguments to ensure that they're useable.
+
+	switch {
+	// If the macaroon service is set (we should use macaroons), then
+	// ensure that we know where to look for them, or create them if not
+	// found.
+	case config.MacService != nil && config.NetworkDir == "":
+		return nil, nil, fmt.Errorf("NetworkDir must be set to create " +
+			"Signrpc")
+	case config.Signer == nil:
+		return nil, nil, fmt.Errorf("Signer must be set to create " +
+			"Signrpc")
+	}
+
+	return New(config)
+}
+
+func init() {
+	subServer := &lnrpc.SubServerDriver{
+		SubServerName: subServerName,
+		New: func(c lnrpc.SubServerConfigDispatcher) (
+			lnrpc.SubServer, lnrpc.MacaroonPerms, error) {
+
+			return createNewSubServer(c)
+		},
+	}
+
+	// If the build tag is active, then we'll register ourselves as a
+	// sub-RPC server within the global lnrpc package namespace.
+	if err := lnrpc.RegisterSubServer(subServer); err != nil {
+		panic(fmt.Sprintf("failed to register sub server driver '%s': %v",
+			subServerName, err))
+	}
+}

lnrpc/signrpc/log.go

@@ -0,0 +1,45 @@
+package signrpc
+
+import (
+	"github.com/btcsuite/btclog"
+	"github.com/lightningnetwork/lnd/build"
+)
+
+// log is a logger that is initialized with no output filters.  This
+// means the package will not perform any logging by default until the caller
+// requests it.
+var log btclog.Logger
+
+// The default amount of logging is none.
+func init() {
+	UseLogger(build.NewSubLogger("SGNR", nil))
+}
+
+// DisableLog disables all library log output.  Logging output is disabled
+// by default until UseLogger is called.
+func DisableLog() {
+	UseLogger(btclog.Disabled)
+}
+
+// UseLogger uses a specified Logger to output package logging info.
+// This should be used in preference to SetLogWriter if the caller is also
+// using btclog.
+func UseLogger(logger btclog.Logger) {
+	log = logger
+}
+
+// logClosure is used to provide a closure over expensive logging operations so
+// don't have to be performed when the logging level doesn't warrant it.
+type logClosure func() string
+
+// String invokes the underlying function and returns the result.
+func (c logClosure) String() string {
+	return c()
+}
+
+// newLogClosure returns a new closure over a function that returns a string
+// which itself provides a Stringer interface so that it can be used with the
+// logging system.
+func newLogClosure(c func() string) logClosure {
+	return logClosure(c)
+}