multi: implement the status server

Author: ellemouton

perms/permissions.go

@@ -62,6 +62,7 @@ var (
 			Entity: "account",
 			Action: "write",
 		}},
+		"/litrpc.Status/GetSubServerState": {},
 	}
 
 	// whiteListedLNDMethods is a map of all lnd RPC methods that don't

rpc_proxy.go

@@ -12,6 +12,7 @@ import (
 	"time"
 
 	"github.com/improbable-eng/grpc-web/go/grpcweb"
+	"github.com/lightninglabs/lightning-terminal/litrpc"
 	"github.com/lightninglabs/lightning-terminal/perms"
 	"github.com/lightninglabs/lightning-terminal/session"
 	"github.com/lightningnetwork/lnd/lncfg"
@@ -259,7 +260,7 @@ func (p *rpcProxy) isHandling(resp http.ResponseWriter,
 	if p.grpcWebProxy.IsGrpcWebRequest(req) ||
 		p.grpcWebProxy.IsGrpcWebSocketRequest(req) {
 
-		if !p.hasStarted() {
+		if !p.hasStarted() && !isStatusReq(req.URL.Path) {
 			resp.WriteHeader(http.StatusServiceUnavailable)
 			_, _ = resp.Write(make([]byte, 0))
 		} else {
@@ -273,7 +274,7 @@ func (p *rpcProxy) isHandling(resp http.ResponseWriter,
 	// Normal gRPC requests are also easy to identify. These we can
 	// send directly to the lnd proxy's gRPC server.
 	if isGrpcRequest(req) {
-		if !p.hasStarted() {
+		if !p.hasStarted() && !isStatusReq(req.URL.Path) {
 			resp.WriteHeader(http.StatusServiceUnavailable)
 			_, _ = resp.Write(make([]byte, 0))
 		} else {
@@ -652,3 +653,11 @@ func isGrpcRequest(req *http.Request) bool {
 	return req.ProtoMajor == 2 &&
 		strings.HasPrefix(contentType, contentTypeGrpc)
 }
+
+// isStatusReq returns true if the given request is intended for the
+// litrpc.Status service.
+func isStatusReq(uri string) bool {
+	return strings.HasPrefix(
+		uri, fmt.Sprintf("/%s", litrpc.Status_ServiceDesc.ServiceName),
+	)
+}

state_server.go

@@ -0,0 +1,127 @@
+package terminal
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/lightninglabs/lightning-terminal/litrpc"
+)
+
+const (
+	LitSubServer     string = "lit"
+	LNDSubServer     string = "lnd"
+	PoolSubServer    string = "pool"
+	LoopSubServer    string = "loop"
+	FaradaySubServer string = "faraday"
+)
+
+// statusServer is an implementation of the litrpc.StatusServer which can be
+// queried for the status of various LiT sub-servers.
+type statusServer struct {
+	litrpc.UnimplementedStatusServer
+
+	m  map[string]*subServerStatus
+	mu sync.RWMutex
+}
+
+// subServerStatus represents the status of a sub-server.
+type subServerStatus struct {
+	running bool
+	err     string
+}
+
+// newSubServerStatus constructs a new subServerStatus.
+func newSubServerStatus() *subServerStatus {
+	return &subServerStatus{}
+}
+
+// newStatusServer constructs a new statusServer.
+func newStatusServer() *statusServer {
+	s := &statusServer{
+		m: map[string]*subServerStatus{
+			LitSubServer:     newSubServerStatus(),
+			LNDSubServer:     newSubServerStatus(),
+			FaradaySubServer: newSubServerStatus(),
+			PoolSubServer:    newSubServerStatus(),
+			LoopSubServer:    newSubServerStatus(),
+		},
+	}
+
+	return s
+}
+
+// GetSubServerState queries the current status of a given sub-server.
+//
+// NOTE: this is part of the litrpc.StatusServer interface.
+func (s *statusServer) GetSubServerState(_ context.Context,
+	_ *litrpc.GetSubServerStatusReq) (*litrpc.GetSubServerStatusResp,
+	error) {
+
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	resp := make(map[string]*litrpc.SubServerStatus, len(s.m))
+	for server, status := range s.m {
+		resp[server] = &litrpc.SubServerStatus{
+			Running: status.running,
+			Error:   status.err,
+		}
+	}
+
+	return &litrpc.GetSubServerStatusResp{
+		SubServers: resp,
+	}, nil
+}
+
+// getSubServerState queries the current status of a given sub-server.
+func (s *statusServer) getSubServerState(name string) (bool, string) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	system, ok := s.m[name]
+	if !ok {
+		return false, ""
+	}
+
+	return system.running, system.err
+}
+
+// setServerRunning can be used to set the status of a sub-server as running
+// with no errors.
+func (s *statusServer) setServerRunning(name string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.m[name] = &subServerStatus{
+		running: true,
+	}
+}
+
+// setServerStopped can be used to set the status of a sub-server as not running
+// and with no errors.
+func (s *statusServer) setServerStopped(name string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.m[name] = &subServerStatus{
+		running: false,
+	}
+}
+
+// setServerErrored can be used to set the status of a sub-server as not running
+// and also to set an error message for the sub-server.
+func (s *statusServer) setServerErrored(name string, errStr string,
+	params ...interface{}) {
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	err := fmt.Sprintf(errStr, params...)
+	log.Errorf("could not start the %s sub-server: %s", name, err)
+
+	s.m[name] = &subServerStatus{
+		running: false,
+		err:     err,
+	}
+}

terminal.go

@@ -151,6 +151,8 @@ type LightningTerminal struct {
 	lndClient   *lndclient.GrpcLndServices
 	basicClient lnrpc.LightningClient
 
+	statusServer *statusServer
+
 	faradayServer  *frdrpcserver.RPCServer
 	faradayStarted bool
 
@@ -183,7 +185,9 @@ type LightningTerminal struct {
 
 // New creates a new instance of the lightning-terminal daemon.
 func New() *LightningTerminal {
-	return &LightningTerminal{}
+	return &LightningTerminal{
+		statusServer: newStatusServer(),
+	}
 }
 
 // Run starts everything and then blocks until either the application is shut
@@ -756,6 +760,7 @@ func (g *LightningTerminal) registerSubDaemonGrpcServers(server *grpc.Server,
 	if withLitRPC {
 		litrpc.RegisterSessionsServer(server, g.sessionRpcServer)
 		litrpc.RegisterAccountsServer(server, g.accountRpcServer)
+		litrpc.RegisterStatusServer(server, g.statusServer)
 	}
 }