rpc_proxy: remote subserver remote conn creation

Remove the code for creating remote connections to loop, faraday and
pool subservers from the rpcProxy. This is now handled by the subserver
manager.

Author: ellemouton

rpc_proxy.go

@@ -61,7 +61,7 @@ func (e *proxyErr) Unwrap() error {
 // component.
 func newRpcProxy(cfg *Config, validator macaroons.MacaroonValidator,
 	superMacValidator session.SuperMacaroonValidator,
-	permsMgr *perms.Manager) *rpcProxy {
+	permsMgr *perms.Manager, subServerMgr *subservers.Manager) *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
@@ -81,6 +81,7 @@ func newRpcProxy(cfg *Config, validator macaroons.MacaroonValidator,
 		permsMgr:          permsMgr,
 		macValidator:      validator,
 		superMacValidator: superMacValidator,
+		subServerMgr:      subServerMgr,
 	}
 	p.grpcServer = grpc.NewServer(
 		// From the grpxProxy doc: This codec is *crucial* to the
@@ -151,64 +152,26 @@ type rpcProxy struct {
 	// must only ever be used atomically.
 	started int32
 
-	cfg       *Config
-	basicAuth string
-	permsMgr  *perms.Manager
+	cfg          *Config
+	basicAuth    string
+	permsMgr     *perms.Manager
+	subServerMgr *subservers.Manager
 
 	macValidator      macaroons.MacaroonValidator
 	superMacValidator session.SuperMacaroonValidator
 
 	superMacaroon string
 
-	lndConn     *grpc.ClientConn
-	faradayConn *grpc.ClientConn
-	loopConn    *grpc.ClientConn
-	poolConn    *grpc.ClientConn
+	lndConn *grpc.ClientConn
 
 	grpcServer   *grpc.Server
 	grpcWebProxy *grpcweb.WrappedGrpcServer
 }
 
 // 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)
-		}
-	}
-
 	atomic.CompareAndSwapInt32(&p.started, 0, 1)
 
 	return nil
@@ -224,27 +187,6 @@ func (p *rpcProxy) hasStarted() bool {
 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
 }
 
@@ -362,38 +304,21 @@ 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.
-		isFaraday := p.permsMgr.IsSubServerURI(
-			subservers.FARADAY, requestURI,
-		)
-		isLoop := p.permsMgr.IsSubServerURI(
-			subservers.LOOP, requestURI,
-		)
-		isPool := p.permsMgr.IsSubServerURI(
-			subservers.POOL, requestURI,
-		)
-		isLit := p.permsMgr.IsSubServerURI(
-			subservers.LIT, requestURI,
-		)
-		switch {
-		case isFaraday && p.cfg.faradayRemote:
-			return outCtx, p.faradayConn, nil
-
-		case isLoop && p.cfg.loopRemote:
-			return outCtx, p.loopConn, nil
-
-		case isPool && 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 isLit && !allowLitRPC:
+		isLit := p.permsMgr.IsSubServerURI(subservers.LIT, requestURI)
+		if isLit && !allowLitRPC {
 			return outCtx, nil, status.Errorf(
 				codes.Unimplemented, "unknown service %s",
 				requestURI,
 			)
-
-		default:
-			return outCtx, p.lndConn, nil
 		}
+
+		return outCtx, p.lndConn, nil
 	}
 }
 

terminal.go

@@ -236,7 +236,9 @@ func (g *LightningTerminal) Run() error {
 
 	// Construct the rpcProxy. It must be initialised before the main web
 	// server is started.
-	g.rpcProxy = newRpcProxy(g.cfg, g, g.validateSuperMacaroon, g.permsMgr)
+	g.rpcProxy = newRpcProxy(
+		g.cfg, g, g.validateSuperMacaroon, g.permsMgr, g.subServerMgr,
+	)
 
 	// Start the main web server that dispatches requests either to the
 	// static UI file server or the RPC proxy. This makes it possible to