terminal: setup LND prior to stores

In the upcoming actions migration, we need fetch LNDs macaroons prior to
initializing the stores, as the macaroons will be required during the
migration.

This requires that we setup the connection to LND before we initialize
the stores, as we can only fetch the macaroons after the LND connection
is established.

This commit refactors the litd startup process, so that the stores are
initialized after the LND connection is established.
This also requires that we refactor the RPC server setup, as litd's RPC
servers require the stores to be initialized prior to being created.

Author: ViktorT-11

terminal.go

@@ -447,36 +447,6 @@ func (g *LightningTerminal) start(ctx context.Context) error {
 		return fmt.Errorf("could not create network directory: %v", err)
 	}
 
-	g.stores, err = NewStores(g.cfg, clock.NewDefaultClock())
-	if err != nil {
-		return fmt.Errorf("could not create stores: %v", err)
-	}
-
-	if err := g.stores.firewall.Start(ctx); err != nil {
-		return fmt.Errorf("could not start firewall DB: %v", err)
-	}
-
-	g.accountService, err = accounts.NewService(
-		g.stores.accounts, accountServiceErrCallback,
-	)
-	if err != nil {
-		return fmt.Errorf("error creating account service: %v", err)
-	}
-
-	superMacBaker := func(ctx context.Context, rootKeyID uint64,
-		perms []bakery.Op, caveats []macaroon.Caveat) (string, error) {
-
-		return litmac.BakeSuperMacaroon(
-			ctx, g.basicClient, rootKeyID, perms, caveats,
-		)
-	}
-
-	g.accountRpcServer = accounts.NewRPCServer(
-		g.accountService, superMacBaker,
-	)
-
-	g.ruleMgrs = rules.NewRuleManagerSet()
-
 	if !g.cfg.Autopilot.Disable {
 		if g.cfg.Autopilot.Address == "" &&
 			len(g.cfg.Autopilot.DialOpts) == 0 {
@@ -506,40 +476,6 @@ func (g *LightningTerminal) start(ctx context.Context) error {
 		}
 	}
 
-	g.sessionRpcServer, err = newSessionRPCServer(&sessionRpcServerConfig{
-		db:        g.stores.sessions,
-		basicAuth: g.rpcProxy.basicAuth,
-		grpcOptions: []grpc.ServerOption{
-			grpc.CustomCodec(grpcProxy.Codec()), // nolint: staticcheck,
-			grpc.ChainStreamInterceptor(
-				g.rpcProxy.StreamServerInterceptor,
-			),
-			grpc.ChainUnaryInterceptor(
-				g.rpcProxy.UnaryServerInterceptor,
-			),
-			grpc.UnknownServiceHandler(
-				grpcProxy.TransparentHandler(
-					// Don't allow calls to litrpc.
-					g.rpcProxy.makeDirector(false),
-				),
-			),
-		},
-		registerGrpcServers: func(server *grpc.Server) {
-			g.registerSubDaemonGrpcServers(server, true)
-		},
-		superMacBaker:           superMacBaker,
-		firstConnectionDeadline: g.cfg.FirstLNCConnDeadline,
-		permMgr:                 g.permsMgr,
-		actionsDB:               g.stores.firewall,
-		autopilot:               g.autopilotClient,
-		ruleMgrs:                g.ruleMgrs,
-		privMap:                 g.stores.firewall,
-	})
-	if err != nil {
-		return fmt.Errorf("could not create new session rpc "+
-			"server: %v", err)
-	}
-
 	// Call the "real" main in a nested manner so the defers will properly
 	// be executed in the case of a graceful shutdown.
 	var (
@@ -769,6 +705,77 @@ func (g *LightningTerminal) start(ctx context.Context) error {
 		return fmt.Errorf("could not start LND")
 	}
 
+	g.stores, err = NewStores(g.cfg, clock.NewDefaultClock())
+	if err != nil {
+		return fmt.Errorf("could not create stores: %v", err)
+	}
+
+	if err := g.stores.firewall.Start(ctx); err != nil {
+		return fmt.Errorf("could not start firewall DB: %v", err)
+	}
+
+	g.accountService, err = accounts.NewService(
+		g.stores.accounts, accountServiceErrCallback,
+	)
+	if err != nil {
+		return fmt.Errorf("error creating account service: %v", err)
+	}
+
+	superMacBaker := func(ctx context.Context, rootKeyID uint64,
+		perms []bakery.Op, caveats []macaroon.Caveat) (string, error) {
+
+		return litmac.BakeSuperMacaroon(
+			ctx, g.basicClient, rootKeyID, perms, caveats,
+		)
+	}
+
+	g.accountRpcServer = accounts.NewRPCServer(
+		g.accountService, superMacBaker,
+	)
+
+	g.sessionRpcServer, err = newSessionRPCServer(&sessionRpcServerConfig{
+		db:        g.stores.sessions,
+		basicAuth: g.rpcProxy.basicAuth,
+		grpcOptions: []grpc.ServerOption{
+			grpc.CustomCodec(grpcProxy.Codec()), // nolint: staticcheck,
+			grpc.ChainStreamInterceptor(
+				g.rpcProxy.StreamServerInterceptor,
+			),
+			grpc.ChainUnaryInterceptor(
+				g.rpcProxy.UnaryServerInterceptor,
+			),
+			grpc.UnknownServiceHandler(
+				grpcProxy.TransparentHandler(
+					// Don't allow calls to litrpc.
+					g.rpcProxy.makeDirector(false),
+				),
+			),
+		},
+		registerGrpcServers: func(server *grpc.Server) {
+			g.registerSubDaemonGrpcServers(server, true)
+		},
+		superMacBaker:           superMacBaker,
+		firstConnectionDeadline: g.cfg.FirstLNCConnDeadline,
+		permMgr:                 g.permsMgr,
+		actionsDB:               g.stores.firewall,
+		autopilot:               g.autopilotClient,
+		ruleMgrs:                g.ruleMgrs,
+		privMap:                 g.stores.firewall,
+	})
+	if err != nil {
+		return fmt.Errorf("could not create new session rpc "+
+			"server: %v", err)
+	}
+
+	g.ruleMgrs = rules.NewRuleManagerSet()
+
+	// Once the accounts and sessions RPC servers have been created, we
+	// can register them with the RPC proxy gRPC server.
+	err = g.registerSubDaemonGrpcServersToProxy()
+	if err != nil {
+		return fmt.Errorf("could not register RPC servers: %v", err)
+	}
+
 	// Mark that lnd is now completely running after connecting the
 	// lnd clients.
 	g.statusMgr.SetRunning(subservers.LND)
@@ -1167,34 +1174,69 @@ func (g *LightningTerminal) RegisterGrpcSubserver(server *grpc.Server) error {
 
 // registerSubDaemonGrpcServers registers the sub daemon (Faraday, Loop, Pool
 // and LiT session) servers to a given gRPC server, given they are running in
-// the local process. Some of LiT's own sub-servers should be registered with
-// LNC sessions and some should not - the forLNCSession boolean can be used to
-// control this.
+// the local process.
+// For LNC sessions, this functions registers some of LiT's own sub-servers with
+// the session. This is toggled by the forLNCSession boolean.
 func (g *LightningTerminal) registerSubDaemonGrpcServers(server *grpc.Server,
 	forLNCSession bool) {
 
 	g.subServerMgr.RegisterRPCServices(server)
 
-	if forLNCSession {
-		litrpc.RegisterStatusServer(server, g.statusMgr)
-		litrpc.RegisterProxyServer(server, g.rpcProxy)
-	} else {
-		litrpc.RegisterSessionsServer(server, g.sessionRpcServer)
-
-		if !g.cfg.Accounts.Disable {
-			litrpc.RegisterAccountsServer(
-				server, g.accountRpcServer,
-			)
-		}
+	// For non-LNC sessions, we will proceed to register the other
+	// necessary sub-daemon servers manually with the
+	// registerSubDaemonGrpcServersToProxy function after they have been
+	// created. They will be registered after we've connected to LND, hence
+	// after this function has been called by LND.
+	if !forLNCSession {
+		return
 	}
 
+	litrpc.RegisterStatusServer(server, g.statusMgr)
+	litrpc.RegisterProxyServer(server, g.rpcProxy)
 	litrpc.RegisterFirewallServer(server, g.sessionRpcServer)
 
 	if !g.cfg.Autopilot.Disable {
 		litrpc.RegisterAutopilotServer(server, g.sessionRpcServer)
 	}
 }
 
+// registerSubDaemonGrpcServersToProxy registers the session and accounts
+// gRPC servers to the RPC proxy gRPC Server.
+//
+// NOTE: This function can only be called once the accounts and session
+// RPC servers have been created.
+func (g *LightningTerminal) registerSubDaemonGrpcServersToProxy() error {
+	if g.rpcProxy == nil || g.rpcProxy.grpcServer == nil {
+		return errors.New("RPC proxy gRPC server is not initialized")
+	}
+
+	if g.sessionRpcServer == nil {
+		return errors.New("session RPC server is not initialized")
+	}
+
+	if !g.cfg.Accounts.Disable && g.accountRpcServer == nil {
+		return errors.New("account RPC server is not initialized")
+	}
+
+	litrpc.RegisterSessionsServer(g.rpcProxy.grpcServer, g.sessionRpcServer)
+
+	litrpc.RegisterFirewallServer(g.rpcProxy.grpcServer, g.sessionRpcServer)
+
+	if !g.cfg.Autopilot.Disable {
+		litrpc.RegisterAutopilotServer(
+			g.rpcProxy.grpcServer, g.sessionRpcServer,
+		)
+	}
+
+	if !g.cfg.Accounts.Disable {
+		litrpc.RegisterAccountsServer(
+			g.rpcProxy.grpcServer, g.accountRpcServer,
+		)
+	}
+
+	return nil
+}
+
 // RegisterRestSubserver is a callback on the lnd.SubserverConfig struct that is
 // called once lnd has initialized its main REST server instance. It gives the
 // daemons (or external subservers) the possibility to register themselves to