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,6 +11,7 @@ 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.
@@ -19,6 +20,7 @@ type sessionRpcServer struct {
 
 	basicAuth string
 
+	cfg           *sessionRpcServerConfig
 	db            *session.DB
 	sessionServer *session.Server
 
@@ -27,12 +29,75 @@ type sessionRpcServer struct {
 	stopOnce sync.Once
 }
 
+// sessionRpcServerConfig holds the values used to configure the
+// sessionRpcServer.
+type sessionRpcServerConfig struct {
+	basicAuth   string
+	dbDir       string
+	grpcOptions []grpc.ServerOption
+}
+
+// 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...)
+			return grpc.NewServer(allOpts...)
+		},
+	)
+
+	return &sessionRpcServer{
+		cfg:           cfg,
+		basicAuth:     cfg.basicAuth,
+		db:            db,
+		sessionServer: server,
+	}, 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.

terminal.go

@@ -22,7 +22,6 @@ import (
 	"github.com/jessevdk/go-flags"
 	"github.com/lightninglabs/faraday/frdrpc"
 	"github.com/lightninglabs/lightning-terminal/litrpc"
-	"github.com/lightninglabs/lightning-terminal/session"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/loop"
 	"github.com/lightninglabs/loop/loopd"
@@ -154,9 +153,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()
@@ -194,52 +192,18 @@ func (g *LightningTerminal) Run() error {
 	g.rpcProxy = newRpcProxy(
 		g.cfg, g, 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.UnknownServiceHandler(
-					grpcProxy.TransparentHandler(
-						g.rpcProxy.director,
-					),
+	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.UnknownServiceHandler(
+				grpcProxy.TransparentHandler(
+					g.rpcProxy.director,
 				),
-			}
-			allOpts = append(allOpts, opts...)
-			mailboxGrpcServer := grpc.NewServer(allOpts...)
-
-			_ = g.RegisterGrpcSubserver(mailboxGrpcServer)
-
-			return mailboxGrpcServer
+			),
 		},
-	)
-	g.sessionRpcServer = &sessionRpcServer{
-		basicAuth:     g.rpcProxy.basicAuth,
-		db:            g.sessionDB,
-		sessionServer: g.sessionServer,
-		quit:          make(chan struct{}),
-	}
-
-	// Now start up all previously created sessions.
-	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)
-		}
-	}
+	})
 
 	// Overwrite the loop and pool daemon's user agent name so it sends
 	// "litd" instead of "loopd" and "poold" respectively.
@@ -565,6 +529,11 @@ func (g *LightningTerminal) startSubservers() error {
 		g.poolStarted = true
 	}
 
+	if err = g.sessionRpcServer.start(); err != nil {
+		return err
+	}
+	g.sessionRpcServerStarted = true
+
 	return nil
 }
 
@@ -839,12 +808,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()