terminal+rpc_proxy: fix gRPC daemon calls in integrated mode

The call flow diagram wasn't accurate what lead to an incorrect
assumption in the last PR.
In integrated mode, lnd spins up its gRPC server as the main entry point
and the other daemons need to hook into it.

Author: guggero

rpc_proxy.go

@@ -100,22 +100,25 @@ func newRpcProxy(cfg *Config, validator macaroons.MacaroonValidator,
 //    +---+----------------------+
 //        |
 //        v native gRPC call with macaroon
-//    +---+----------------------+ registered call
-//    | gRPC server              +--------------+
-//    +---+----------------------+              |
-//        |                                     |
-//        v non-registered call                 |
-//    +---+----------------------+    +---------v----------+
-//    | director                 |    | local subserver    |
-//    +---+----------------------+    |  - faraday         |
-//        |                           |  - loop            |
-//        v authenticated call        |  - pool            |
-//    +---+----------------------+    +--------------------+
-//    | lnd (remote or local)    |
-//    | faraday remote           |
-//    | loop remote              |
-//    | pool remote              |
-//    +--------------------------+
+//    +---+----------------------+
+//    | gRPC server              |
+//    +---+----------------------+
+//        |
+//        v unknown authenticated call, gRPC server is just a wrapper
+//    +---+----------------------+
+//    | director                 |
+//    +---+----------------------+
+//        |
+//        v authenticated call
+//    +---+----------------------+ call to lnd or integrated daemon
+//    | lnd (remote or local)    +---------------+
+//    | faraday remote           |               |
+//    | loop remote              |    +----------v----------+
+//    | pool remote              |    | lnd local subserver |
+//    +--------------------------+    |  - faraday          |
+//                                    |  - loop             |
+//                                    |  - pool             |
+//                                    +---------------------+
 //
 type rpcProxy struct {
 	cfg       *Config
@@ -263,16 +266,13 @@ func (p *rpcProxy) director(ctx context.Context,
 
 	outCtx := metadata.NewOutgoingContext(ctx, mdCopy)
 
-	// Direct the call to the correct backend. For lnd we _always_ have a
-	// client connection, no matter if it's running in integrated or remote
-	// mode. For all other daemons the request shouldn't get here in
-	// integrated mode (after all, the director only picks up calls that the
-	// gRPC server itself would throw a 404 for) so we throw an error
-	// message for them if they're not in remote mode.
+	// Direct the call to the correct backend. All gRPC calls end up here
+	// since our gRPC server instance doesn't have any handlers registered
+	// itself. So all daemon calls that are remote are forwarded to them
+	// directly. Everything else will go to lnd since it must either be an
+	// lnd call or something that'll be handled by the integrated daemons
+	// that are hooking into lnd's gRPC server.
 	switch {
-	case isLndURI(requestURI):
-		return outCtx, p.lndConn, nil
-
 	case isFaradayURI(requestURI) && p.cfg.faradayRemote:
 		return outCtx, p.faradayConn, nil
 
@@ -283,8 +283,7 @@ func (p *rpcProxy) director(ctx context.Context,
 		return outCtx, p.poolConn, nil
 
 	default:
-		return ctx, nil, fmt.Errorf("unknown gRPC web request: %v",
-			requestURI)
+		return outCtx, p.lndConn, nil
 	}
 }
 

terminal.go

@@ -60,7 +60,7 @@ type LightningTerminal struct {
 	wg         sync.WaitGroup
 	lndErrChan chan error
 
-	lndClient     *lndclient.GrpcLndServices
+	lndClient *lndclient.GrpcLndServices
 
 	faradayServer  *frdrpc.RPCServer
 	faradayStarted bool
@@ -342,27 +342,21 @@ func (g *LightningTerminal) startSubservers() error {
 // called once lnd has initialized its main gRPC server instance. It gives the
 // daemons (or external subservers) the possibility to register themselves to
 // the same server instance.
-func (g *LightningTerminal) RegisterGrpcSubserver(_ *grpc.Server) error {
+func (g *LightningTerminal) RegisterGrpcSubserver(server *grpc.Server) error {
 	// In remote mode the "director" of the RPC proxy will act as a catch-
 	// all for any gRPC request that isn't known because we didn't register
 	// any server for it. The director will then forward the request to the
 	// remote service.
 	if !g.cfg.faradayRemote {
-		frdrpc.RegisterFaradayServerServer(
-			g.rpcProxy.grpcServer, g.faradayServer,
-		)
+		frdrpc.RegisterFaradayServerServer(server, g.faradayServer)
 	}
 
 	if !g.cfg.loopRemote {
-		looprpc.RegisterSwapClientServer(
-			g.rpcProxy.grpcServer, g.loopServer,
-		)
+		looprpc.RegisterSwapClientServer(server, g.loopServer)
 	}
 
 	if !g.cfg.poolRemote {
-		poolrpc.RegisterTraderServer(
-			g.rpcProxy.grpcServer, g.poolServer,
-		)
+		poolrpc.RegisterTraderServer(server, g.poolServer)
 	}
 
 	return nil
@@ -550,22 +544,25 @@ func (g *LightningTerminal) shutdown() error {
 //    +---+----------------------+
 //        |
 //        v native gRPC call with macaroon
-//    +---+----------------------+ registered call
-//    | gRPC server              +--------------+
-//    +---+----------------------+              |
-//        |                                     |
-//        v non-registered call                 |
-//    +---+----------------------+    +---------v----------+
-//    | director                 |    | local subserver    |
-//    +---+----------------------+    |  - faraday         |
-//        |                           |  - loop            |
-//        v authenticated call        |  - pool            |
-//    +---+----------------------+    +--------------------+
-//    | lnd (remote or local)    |
-//    | faraday remote           |
-//    | loop remote              |
-//    | pool remote              |
-//    +--------------------------+
+//    +---+----------------------+
+//    | gRPC server              |
+//    +---+----------------------+
+//        |
+//        v unknown authenticated call, gRPC server is just a wrapper
+//    +---+----------------------+
+//    | director                 |
+//    +---+----------------------+
+//        |
+//        v authenticated call
+//    +---+----------------------+ call to lnd or integrated daemon
+//    | lnd (remote or local)    +---------------+
+//    | faraday remote           |               |
+//    | loop remote              |    +----------v----------+
+//    | pool remote              |    | lnd local subserver |
+//    +--------------------------+    |  - faraday          |
+//                                    |  - loop             |
+//                                    |  - pool             |
+//                                    +---------------------+
 //
 func (g *LightningTerminal) startMainWebServer() error {
 	// Initialize the in-memory file server from the content compiled by