multi: extract sessionRPCserver stuff into its own struct

Let sessionRpcServer handle the session db and session server instead of
LightningTerminal handling those direclty. Then start the
sessionRpcServer as if it was a subserver like loop/pool.

Author: ellemouton

session_rpcserver.go

@@ -11,31 +11,98 @@ import (
 	"github.com/lightninglabs/lightning-node-connect/mailbox"
 	"github.com/lightninglabs/lightning-terminal/litrpc"
 	"github.com/lightninglabs/lightning-terminal/session"
+	"google.golang.org/grpc"
 )
 
 // sessionRpcServer is the gRPC server for the Session RPC interface.
 type sessionRpcServer struct {
 	litrpc.UnimplementedSessionsServer
 
-	basicAuth string
-
+	cfg           *sessionRpcServerConfig
 	db            *session.DB
 	sessionServer *session.Server
 
-	superMacBaker func(ctx context.Context, rootKeyID uint64,
-		recipe *session.MacaroonRecipe) (string, error)
-
 	quit     chan struct{}
 	wg       sync.WaitGroup
 	stopOnce sync.Once
 }
 
+// sessionRpcServerConfig holds the values used to configure the
+// sessionRpcServer.
+type sessionRpcServerConfig struct {
+	basicAuth           string
+	dbDir               string
+	grpcOptions         []grpc.ServerOption
+	registerGrpcServers func(server *grpc.Server)
+	superMacBaker       func(ctx context.Context, rootKeyID uint64,
+		recipe *session.MacaroonRecipe) (string, error)
+}
+
+// newSessionRPCServer creates a new sessionRpcServer using the passed config.
+func newSessionRPCServer(cfg *sessionRpcServerConfig) (*sessionRpcServer,
+	error) {
+
+	// Create an instance of the local Terminal Connect session store DB.
+	db, err := session.NewDB(cfg.dbDir, session.DBFilename)
+	if err != nil {
+		return nil, fmt.Errorf("error creating session DB: %v", err)
+	}
+
+	// Create the gRPC server that handles adding/removing sessions and the
+	// actual mailbox server that spins up the Terminal Connect server
+	// interface.
+	server := session.NewServer(
+		func(opts ...grpc.ServerOption) *grpc.Server {
+			allOpts := append(cfg.grpcOptions, opts...)
+			grpcServer := grpc.NewServer(allOpts...)
+
+			cfg.registerGrpcServers(grpcServer)
+
+			return grpcServer
+		},
+	)
+
+	return &sessionRpcServer{
+		cfg:           cfg,
+		db:            db,
+		sessionServer: server,
+		quit:          make(chan struct{}),
+	}, nil
+}
+
+// start all the components necessary for the sessionRpcServer to start serving
+// requests. This includes starting the macaroon service and resuming all
+// non-revoked sessions.
+func (s *sessionRpcServer) start() error {
+	// Start up all previously created sessions.
+	sessions, err := s.db.ListSessions()
+	if err != nil {
+		return fmt.Errorf("error listing sessions: %v", err)
+	}
+	for _, sess := range sessions {
+		if err := s.resumeSession(sess); err != nil {
+			return fmt.Errorf("error resuming sesion: %v", err)
+		}
+	}
+
+	return nil
+}
+
 // stop cleans up any sessionRpcServer resources.
-func (s *sessionRpcServer) stop() {
+func (s *sessionRpcServer) stop() error {
+	var returnErr error
 	s.stopOnce.Do(func() {
+		if err := s.db.Close(); err != nil {
+			log.Errorf("Error closing session DB: %v", err)
+			returnErr = err
+		}
+		s.sessionServer.Stop()
+
 		close(s.quit)
 		s.wg.Wait()
 	})
+
+	return returnErr
 }
 
 // AddSession adds and starts a new Terminal Connect session.
@@ -117,12 +184,12 @@ func (s *sessionRpcServer) resumeSession(sess *session.Session) error {
 	var authData []byte
 	switch sess.Type {
 	case session.TypeUIPassword:
-		authData = []byte("Authorization: Basic " + s.basicAuth)
+		authData = []byte("Authorization: Basic " + s.cfg.basicAuth)
 
 	case session.TypeMacaroonAdmin, session.TypeMacaroonReadonly:
 		ctx := context.Background()
 		readOnly := sess.Type == session.TypeMacaroonReadonly
-		mac, err := s.superMacBaker(
+		mac, err := s.cfg.superMacBaker(
 			ctx, sess.MacaroonRootKey, &session.MacaroonRecipe{
 				Permissions: GetAllPermissions(readOnly),
 			},

terminal.go

@@ -156,9 +156,8 @@ type LightningTerminal struct {
 	rpcProxy   *rpcProxy
 	httpServer *http.Server
 
-	sessionDB        *session.DB
-	sessionServer    *session.Server
-	sessionRpcServer *sessionRpcServer
+	sessionRpcServer        *sessionRpcServer
+	sessionRpcServerStarted bool
 
 	restHandler http.Handler
 	restCancel  func()
@@ -200,46 +199,27 @@ func (g *LightningTerminal) Run() error {
 		g.cfg, g, g.validateSuperMacaroon, getAllMethodPermissions(),
 		bufRpcListener,
 	)
-
-	// Create an instance of the local Terminal Connect session store DB.
-	networkDir := path.Join(g.cfg.LitDir, g.cfg.Network)
-	g.sessionDB, err = session.NewDB(networkDir, session.DBFilename)
-	if err != nil {
-		return fmt.Errorf("error creating session DB: %v", err)
-	}
-
-	// Create the gRPC server that handles adding/removing sessions and the
-	// actual mailbox server that spins up the Terminal Connect server
-	// interface.
-	g.sessionServer = session.NewServer(
-		func(opts ...grpc.ServerOption) *grpc.Server {
-			allOpts := []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),
-					),
+	g.sessionRpcServer, err = newSessionRPCServer(&sessionRpcServerConfig{
+		basicAuth: g.rpcProxy.basicAuth,
+		dbDir:     path.Join(g.cfg.LitDir, g.cfg.Network),
+		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),
 				),
-			}
-			allOpts = append(allOpts, opts...)
-			grpcServer := grpc.NewServer(allOpts...)
-			g.registerSubDaemonGrpcServers(grpcServer, false)
-
-			return grpcServer
+			),
+		},
+		registerGrpcServers: func(server *grpc.Server) {
+			g.registerSubDaemonGrpcServers(server, false)
 		},
-	)
-	g.sessionRpcServer = &sessionRpcServer{
-		basicAuth:     g.rpcProxy.basicAuth,
-		db:            g.sessionDB,
-		sessionServer: g.sessionServer,
-		quit:          make(chan struct{}),
 		superMacBaker: func(ctx context.Context, rootKeyID uint64,
 			recipe *session.MacaroonRecipe) (string, error) {
 
@@ -248,6 +228,10 @@ func (g *LightningTerminal) Run() error {
 				recipe.Permissions, recipe.Caveats,
 			)
 		},
+	})
+	if err != nil {
+		return fmt.Errorf("could not create new session rpc "+
+			"server: %v", err)
 	}
 
 	// Overwrite the loop and pool daemon's user agent name so it sends
@@ -387,20 +371,6 @@ func (g *LightningTerminal) Run() error {
 		return err
 	}
 
-	// Now start up all previously created sessions. Since the sessions
-	// require a lnd connection in order to bake macaroons, we can only
-	// start up the sessions once the connection to lnd has been
-	// established.
-	sessions, err := g.sessionDB.ListSessions()
-	if err != nil {
-		return fmt.Errorf("error listing sessions: %v", err)
-	}
-	for _, sess := range sessions {
-		if err := g.sessionRpcServer.resumeSession(sess); err != nil {
-			return fmt.Errorf("error resuming sesion: %v", err)
-		}
-	}
-
 	// Now block until we receive an error or the main shutdown signal.
 	select {
 	case err := <-g.loopServer.ErrChan:
@@ -578,6 +548,11 @@ func (g *LightningTerminal) startSubservers() error {
 		g.poolStarted = true
 	}
 
+	if err = g.sessionRpcServer.start(); err != nil {
+		return err
+	}
+	g.sessionRpcServerStarted = true
+
 	return nil
 }
 
@@ -847,12 +822,12 @@ func (g *LightningTerminal) shutdown() error {
 		}
 	}
 
-	g.sessionRpcServer.stop()
-	if err := g.sessionDB.Close(); err != nil {
-		log.Errorf("Error closing session DB: %v", err)
-		returnErr = err
+	if g.sessionRpcServerStarted {
+		if err := g.sessionRpcServer.stop(); err != nil {
+			log.Errorf("Error closing session DB: %v", err)
+			returnErr = err
+		}
 	}
-	g.sessionServer.Stop()
 
 	if g.lndClient != nil {
 		g.lndClient.Close()