multi: let the subServerMgr handle loop, pool & faraday

Now we actually register new sub-servers with the new sub-server
manager. We do this for Loop, Pool & Faraday. With this transition, the
LightningTerminal and rpcProxy structs no longer need to directly manage
these sub-servers. Note that with this transition, any errors
encountered by these sub-servers will no longer cause LiT to crash and
will instead only result in the status of these servers being updated.
Any requests for sub-servers that did not start successfully will result
in an error saying that they are not yet running.

Author: ellemouton

rpc_proxy.go

@@ -56,7 +56,8 @@ func (e *proxyErr) Unwrap() error {
 // component.
 func newRpcProxy(cfg *Config, validator macaroons.MacaroonValidator,
 	superMacValidator session.SuperMacaroonValidator,
-	permsMgr *perms.Manager) *rpcProxy {
+	permsMgr *perms.Manager, statusServer *statusServer,
+	subServerMgr *subServerMgr) *rpcProxy {
 
 	// The gRPC web calls are protected by HTTP basic auth which is defined
 	// by base64(username:password). Because we only have a password, we
@@ -76,6 +77,8 @@ func newRpcProxy(cfg *Config, validator macaroons.MacaroonValidator,
 		permsMgr:          permsMgr,
 		macValidator:      validator,
 		superMacValidator: superMacValidator,
+		statusServer:      statusServer,
+		subServerMgr:      subServerMgr,
 	}
 	p.grpcServer = grpc.NewServer(
 		// From the grpxProxy doc: This codec is *crucial* to the
@@ -150,10 +153,10 @@ type rpcProxy struct {
 
 	superMacaroon string
 
-	lndConn     *grpc.ClientConn
-	faradayConn *grpc.ClientConn
-	loopConn    *grpc.ClientConn
-	poolConn    *grpc.ClientConn
+	lndConn *grpc.ClientConn
+
+	statusServer *statusServer
+	subServerMgr *subServerMgr
 
 	grpcServer   *grpc.Server
 	grpcWebProxy *grpcweb.WrappedGrpcServer
@@ -164,44 +167,8 @@ type rpcProxy struct {
 
 // Start creates initial connection to lnd.
 func (p *rpcProxy) Start(lndConn *grpc.ClientConn) error {
-	var err error
 	p.lndConn = lndConn
 
-	// Make sure we can connect to all the daemons that are configured to be
-	// running in remote mode.
-	if p.cfg.faradayRemote {
-		p.faradayConn, err = dialBackend(
-			"faraday", p.cfg.Remote.Faraday.RPCServer,
-			lncfg.CleanAndExpandPath(
-				p.cfg.Remote.Faraday.TLSCertPath,
-			),
-		)
-		if err != nil {
-			return fmt.Errorf("could not dial remote faraday: %v",
-				err)
-		}
-	}
-
-	if p.cfg.loopRemote {
-		p.loopConn, err = dialBackend(
-			"loop", p.cfg.Remote.Loop.RPCServer,
-			lncfg.CleanAndExpandPath(p.cfg.Remote.Loop.TLSCertPath),
-		)
-		if err != nil {
-			return fmt.Errorf("could not dial remote loop: %v", err)
-		}
-	}
-
-	if p.cfg.poolRemote {
-		p.poolConn, err = dialBackend(
-			"pool", p.cfg.Remote.Pool.RPCServer,
-			lncfg.CleanAndExpandPath(p.cfg.Remote.Pool.TLSCertPath),
-		)
-		if err != nil {
-			return fmt.Errorf("could not dial remote pool: %v", err)
-		}
-	}
-
 	// Set started to true to indicate that the rpcProxy is now ready to
 	// handle requests.
 	p.mu.Lock()
@@ -215,27 +182,6 @@ func (p *rpcProxy) Start(lndConn *grpc.ClientConn) error {
 func (p *rpcProxy) Stop() error {
 	p.grpcServer.Stop()
 
-	if p.faradayConn != nil {
-		if err := p.faradayConn.Close(); err != nil {
-			log.Errorf("Error closing faraday connection: %v", err)
-			return err
-		}
-	}
-
-	if p.loopConn != nil {
-		if err := p.loopConn.Close(); err != nil {
-			log.Errorf("Error closing loop connection: %v", err)
-			return err
-		}
-	}
-
-	if p.poolConn != nil {
-		if err := p.poolConn.Close(); err != nil {
-			log.Errorf("Error closing pool connection: %v", err)
-			return err
-		}
-	}
-
 	return nil
 }
 
@@ -306,6 +252,12 @@ func (p *rpcProxy) makeDirector(allowLitRPC bool) func(ctx context.Context,
 
 		outCtx := metadata.NewOutgoingContext(ctx, mdCopy)
 
+		// Check that the target subsystem is running.
+		err := p.checkSubSystemStarted(requestURI)
+		if err != nil {
+			return nil, nil, err
+		}
+
 		// Is there a basic auth or super macaroon set?
 		authHeaders := md.Get("authorization")
 		macHeader := md.Get(HeaderMacaroon)
@@ -347,26 +299,20 @@ func (p *rpcProxy) makeDirector(allowLitRPC bool) func(ctx context.Context,
 		// 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 p.permsMgr.IsFaradayURI(requestURI) && p.cfg.faradayRemote:
-			return outCtx, p.faradayConn, nil
-
-		case p.permsMgr.IsLoopURI(requestURI) && p.cfg.loopRemote:
-			return outCtx, p.loopConn, nil
-
-		case p.permsMgr.IsPoolURI(requestURI) && p.cfg.poolRemote:
-			return outCtx, p.poolConn, nil
+		handled, conn := p.subServerMgr.GetRemoteConn(requestURI)
+		if handled {
+			return outCtx, conn, nil
+		}
 
 		// Calls to LiT session RPC aren't allowed in some cases.
-		case p.permsMgr.IsLitURI(requestURI) && !allowLitRPC:
+		if p.permsMgr.IsLitURI(requestURI) && !allowLitRPC {
 			return outCtx, nil, status.Errorf(
 				codes.Unimplemented, "unknown service %s",
 				requestURI,
 			)
-
-		default:
-			return outCtx, p.lndConn, nil
 		}
+
+		return outCtx, p.lndConn, nil
 	}
 }
 
@@ -382,6 +328,12 @@ func (p *rpcProxy) UnaryServerInterceptor(ctx context.Context, req interface{},
 			"required for method", info.FullMethod)
 	}
 
+	// Check that the target subsystem is running.
+	err := p.checkSubSystemStarted(info.FullMethod)
+	if err != nil {
+		return nil, err
+	}
+
 	// For now, basic authentication is just a quick fix until we
 	// have proper macaroon support implemented in the UI. We allow
 	// gRPC web requests to have it and "convert" the auth into a
@@ -423,6 +375,12 @@ func (p *rpcProxy) StreamServerInterceptor(srv interface{},
 			"for method", info.FullMethod)
 	}
 
+	// Check that the target subsystem is running.
+	err := p.checkSubSystemStarted(info.FullMethod)
+	if err != nil {
+		return err
+	}
+
 	// For now, basic authentication is just a quick fix until we
 	// have proper macaroon support implemented in the UI. We allow
 	// gRPC web requests to have it and "convert" the auth into a
@@ -454,6 +412,35 @@ func (p *rpcProxy) StreamServerInterceptor(srv interface{},
 	return handler(srv, ss)
 }
 
+// checkSubSystemStarted checks if the subsystem responsible for handling the
+// given URI has started.
+func (p *rpcProxy) checkSubSystemStarted(requestURI string) error {
+	var system string
+
+	handled, subServerName := p.subServerMgr.HandledBy(requestURI)
+
+	switch {
+	case handled:
+		system = subServerName
+
+	case p.permsMgr.IsLndURI(requestURI):
+		return nil
+
+	case p.permsMgr.IsLitURI(requestURI):
+		return nil
+
+	default:
+		return fmt.Errorf("unknown gRPC web request: %v", requestURI)
+	}
+
+	started, startErr := p.statusServer.getSubServerState(system)
+	if !started {
+		return fmt.Errorf("%s is not running: %s", system, startErr)
+	}
+
+	return nil
+}
+
 // convertBasicAuth tries to convert the HTTP authorization header into a
 // macaroon based authentication header.
 func (p *rpcProxy) convertBasicAuth(ctx context.Context,
@@ -505,30 +492,15 @@ func (p *rpcProxy) basicAuthToMacaroon(basicAuth, requestURI string,
 		macPath string
 		macData []byte
 	)
+
+	handled, path := p.subServerMgr.MacaroonPath(requestURI)
+
 	switch {
 	case p.permsMgr.IsLndURI(requestURI):
 		_, _, _, macPath, macData = p.cfg.lndConnectParams()
 
-	case p.permsMgr.IsFaradayURI(requestURI):
-		if p.cfg.faradayRemote {
-			macPath = p.cfg.Remote.Faraday.MacaroonPath
-		} else {
-			macPath = p.cfg.Faraday.MacaroonPath
-		}
-
-	case p.permsMgr.IsLoopURI(requestURI):
-		if p.cfg.loopRemote {
-			macPath = p.cfg.Remote.Loop.MacaroonPath
-		} else {
-			macPath = p.cfg.Loop.MacaroonPath
-		}
-
-	case p.permsMgr.IsPoolURI(requestURI):
-		if p.cfg.poolRemote {
-			macPath = p.cfg.Remote.Pool.MacaroonPath
-		} else {
-			macPath = p.cfg.Pool.MacaroonPath
-		}
+	case handled:
+		macPath = path
 
 	case p.permsMgr.IsLitURI(requestURI):
 		macPath = p.cfg.MacaroonPath
@@ -607,21 +579,9 @@ func (p *rpcProxy) convertSuperMacaroon(ctx context.Context, macHex string,
 
 	// Is this actually a request that goes to a daemon that is running
 	// remotely?
-	switch {
-	case p.permsMgr.IsFaradayURI(fullMethod) && p.cfg.faradayRemote:
-		return readMacaroon(lncfg.CleanAndExpandPath(
-			p.cfg.Remote.Faraday.MacaroonPath,
-		))
-
-	case p.permsMgr.IsLoopURI(fullMethod) && p.cfg.loopRemote:
-		return readMacaroon(lncfg.CleanAndExpandPath(
-			p.cfg.Remote.Loop.MacaroonPath,
-		))
-
-	case p.permsMgr.IsPoolURI(fullMethod) && p.cfg.poolRemote:
-		return readMacaroon(lncfg.CleanAndExpandPath(
-			p.cfg.Remote.Pool.MacaroonPath,
-		))
+	handled, macBytes, err := p.subServerMgr.ReadRemoteMacaroon(fullMethod)
+	if handled {
+		return macBytes, err
 	}
 
 	return nil, nil