multi: track LiT and LND status

Author: ellemouton

rpc_proxy.go

@@ -421,10 +421,10 @@ func (p *rpcProxy) checkSubSystemStarted(requestURI string) error {
 		system = subServerName
 
 	case p.permsMgr.IsLndURI(requestURI):
-		return nil
+		system = LNDSubServer
 
 	case p.permsMgr.IsLitURI(requestURI):
-		return nil
+		system = LitSubServer
 
 	default:
 		return fmt.Errorf("unknown gRPC web request: %v", requestURI)

terminal.go

@@ -222,10 +222,50 @@ func (g *LightningTerminal) Run() error {
 		return fmt.Errorf("error starting UI HTTP server: %v", err)
 	}
 
+	// Attempt to start Lit and all of its sub-servers.
+	if err = g.start(); err != nil {
+		g.statusServer.setServerErrored(
+			LitSubServer, "could not start Lit: %v", err,
+		)
+	}
+
+	// Now block until we receive an error or the main shutdown
+	// signal.
+	<-shutdownInterceptor.ShutdownChannel()
+	log.Infof("Shutdown signal received")
+
+	if g.rpcProxy != nil {
+		if err := g.rpcProxy.Stop(); err != nil {
+			log.Errorf("Error stopping rpc proxy: %v", err)
+		}
+	}
+
+	if g.httpServer != nil {
+		if err := g.httpServer.Close(); err != nil {
+			log.Errorf("Error stopping UI server: %v", err)
+		}
+	}
+
+	if err := g.statusServer.Stop(); err != nil {
+		log.Errorf("Error stopping status server: %v", err)
+	}
+
+	g.wg.Wait()
+
+	return nil
+}
+
+// start attempts to start all the various components of Litd. Only Litd and
+// LND errors are considered fatal and will result in an error being returned.
+// If any of the sub-servers managed by the subServerMgr error while starting
+// up, these are considered non-fatal and will not result in an error being
+// returned.
+func (g *LightningTerminal) start() error {
 	// Create the instances of our subservers now so we can hook them up to
 	// lnd once it's fully running.
 	g.initSubServers()
 
+	var err error
 	g.sessionRpcServer, err = newSessionRPCServer(&sessionRpcServerConfig{
 		basicAuth: g.rpcProxy.basicAuth,
 		dbDir:     filepath.Join(g.cfg.LitDir, g.cfg.Network),
@@ -300,9 +340,7 @@ func (g *LightningTerminal) Run() error {
 		go func() {
 			defer g.wg.Done()
 
-			err := lnd.Main(
-				g.cfg.Lnd, lisCfg, implCfg, shutdownInterceptor,
-			)
+			err := lnd.Main(g.cfg.Lnd, lisCfg, implCfg, interceptor)
 			if e, ok := err.(*flags.Error); err != nil &&
 				(!ok || e.Type != flags.ErrHelp) {
 
@@ -344,24 +382,30 @@ func (g *LightningTerminal) Run() error {
 		return err
 
 	case <-lndQuit:
-		return nil
+		g.statusServer.setServerErrored(
+			LNDSubServer, "lndQuit channel closed",
+		)
+		return fmt.Errorf("LND has stopped")
 
-	case <-shutdownInterceptor.ShutdownChannel():
-		return errors.New("shutting down")
+	case <-interceptor.ShutdownChannel():
+		return fmt.Errorf("received the shutdown signal")
 	}
 
 	// We now know that starting lnd was successful. If we now run into an
 	// error, we must shut down lnd correctly.
 	defer func() {
-		err := g.shutdown()
+		err := g.shutdownSubServers()
 		if err != nil {
 			log.Errorf("Error shutting down: %v", err)
 		}
 	}()
 
 	// Connect to LND.
 	if err = g.connectLND(bufRpcListener); err != nil {
-		return fmt.Errorf("could not connect to LND: %v", err)
+		g.statusServer.setServerErrored(
+			LNDSubServer, "could not connect to LND: %v", err,
+		)
+		return fmt.Errorf("could not connect to LND")
 	}
 
 	// Initialise any connections to sub-servers that we are running in
@@ -389,12 +433,18 @@ func (g *LightningTerminal) Run() error {
 		return err
 
 	case <-lndQuit:
-		return nil
+		g.statusServer.setServerErrored(
+			LNDSubServer, "lndQuit channel closed",
+		)
+		return fmt.Errorf("LND is not running")
 
-	case <-shutdownInterceptor.ShutdownChannel():
+	case <-interceptor.ShutdownChannel():
 		return errors.New("shutting down")
 	}
 
+	// We can now set the status of LND as running.
+	g.statusServer.setServerRunning(LNDSubServer)
+
 	// If we're in integrated mode, we'll need to wait for lnd to send the
 	// macaroon after unlock before going any further.
 	if g.cfg.LndMode == ModeIntegrated {
@@ -405,8 +455,10 @@ func (g *LightningTerminal) Run() error {
 	// Set up all the LND clients required by LiT.
 	err = g.setUpLNDClients()
 	if err != nil {
-		log.Errorf("Could not set up LND clients: %v", err)
-		return err
+		g.statusServer.setServerErrored(
+			LNDSubServer, "could not set up LND clients: %v", err,
+		)
+		return fmt.Errorf("could not start LND")
 	}
 
 	// If we're in integrated and stateless init mode, we won't create
@@ -433,22 +485,28 @@ func (g *LightningTerminal) Run() error {
 		return fmt.Errorf("could not start litd sub-servers: %v", err)
 	}
 
+	// We can now set the status of LiT as running.
+	g.statusServer.setServerRunning(LitSubServer)
+
 	// Now block until we receive an error or the main shutdown signal.
 	select {
 	case err := <-g.errQueue.ChanOut():
 		if err != nil {
-			log.Errorf("Received critical error from subsystem, "+
-				"shutting down: %v", err)
+			return fmt.Errorf("received critical error from "+
+				"subsystem, shutting down: %v", err,
+			)
 		}
 
 	case <-lndQuit:
-		return nil
+		g.statusServer.setServerErrored(
+			LNDSubServer, "lndQuit channel closed",
+		)
+		return fmt.Errorf("LND is not running")
 
-	case <-shutdownInterceptor.ShutdownChannel():
-		log.Infof("Shutdown signal received")
+	case <-interceptor.ShutdownChannel():
 	}
 
-	return nil
+	return fmt.Errorf("received the shutdown signal")
 }
 
 // initSubServers registers the faraday, loop and pool sub-servers with the
@@ -899,8 +957,9 @@ func (g *LightningTerminal) BuildWalletConfig(ctx context.Context,
 	)
 }
 
-// shutdown stops all subservers that were started and attached to lnd.
-func (g *LightningTerminal) shutdown() error {
+// shutdownSubServers stops all subservers that were started and attached to
+// lnd.
+func (g *LightningTerminal) shutdownSubServers() error {
 	var returnErr error
 
 	err := g.subServerMgr.Stop()
@@ -934,37 +993,13 @@ func (g *LightningTerminal) shutdown() error {
 		g.restCancel()
 	}
 
-	if g.rpcProxy != nil {
-		if err := g.rpcProxy.Stop(); err != nil {
-			log.Errorf("Error stopping lnd proxy: %v", err)
-			returnErr = err
-		}
-	}
-
 	if g.lndConn != nil {
 		if err := g.lndConn.Close(); err != nil {
 			log.Errorf("Error closing lnd connection: %v", err)
 			returnErr = err
 		}
 	}
 
-	if g.httpServer != nil {
-		if err := g.httpServer.Close(); err != nil {
-			log.Errorf("Error stopping UI server: %v", err)
-			returnErr = err
-		}
-	}
-
-	if err := g.statusServer.Stop(); err != nil {
-		log.Errorf("Error stopping status server: %v", err)
-		returnErr = err
-	}
-
-	// In case the error wasn't thrown by lnd, make sure we stop it too.
-	interceptor.RequestShutdown()
-
-	g.wg.Wait()
-
 	// Do we have any last errors to display? We use an anonymous function,
 	// so we can use return instead of breaking to a label in the default
 	// case.