subservers: use a map indexed by name for subservers

So that we can quickly access a sub-server by its name.

Author: ellemouton

subservers/manager.go

@@ -33,7 +33,7 @@ var (
 
 // Manager manages a set of subServer objects.
 type Manager struct {
-	servers      []*subServerWrapper
+	servers      map[string]*subServerWrapper
 	permsMgr     *perms.Manager
 	statusServer *status.Manager
 	mu           sync.RWMutex
@@ -44,30 +44,37 @@ func NewManager(permsMgr *perms.Manager,
 	statusServer *status.Manager) *Manager {
 
 	return &Manager{
+		servers:      make(map[string]*subServerWrapper),
 		permsMgr:     permsMgr,
 		statusServer: statusServer,
 	}
 }
 
 // AddServer adds a new subServer to the manager's set.
-func (s *Manager) AddServer(ss SubServer, enable bool) {
+func (s *Manager) AddServer(ss SubServer, enable bool) error {
 	// Register all sub-servers with the status server.
 	s.statusServer.RegisterSubServer(ss.Name())
 
 	// If the sub-server has explicitly been disabled, then we don't add it
 	// to the set of servers tracked by the Manager.
 	if !enable {
-		return
+		return nil
 	}
 
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
+	_, ok := s.servers[ss.Name()]
+	if ok {
+		return fmt.Errorf("a subserver with name %s has already "+
+			"been registered with the subserver manager", ss.Name())
+	}
+
 	// Add the enabled server to the set of servers tracked by the Manager.
-	s.servers = append(s.servers, &subServerWrapper{
+	s.servers[ss.Name()] = &subServerWrapper{
 		SubServer: ss,
 		quit:      make(chan struct{}),
-	})
+	}
 
 	// Register the sub-server's permissions with the permission manager.
 	s.permsMgr.RegisterSubServer(
@@ -76,6 +83,8 @@ func (s *Manager) AddServer(ss SubServer, enable bool) {
 
 	// Mark the sub-server as enabled with the status manager.
 	s.statusServer.SetEnabled(ss.Name())
+
+	return nil
 }
 
 // StartIntegratedServers starts all the manager's sub-servers that should be

terminal.go

@@ -296,7 +296,10 @@ func (g *LightningTerminal) Run() error {
 
 	// Register our sub-servers. This must be done before the REST proxy is
 	// set up so that the correct REST handlers are registered.
-	g.initSubServers()
+	err = g.initSubServers()
+	if err != nil {
+		return fmt.Errorf("could not initialise sub-servers: %w", err)
+	}
 
 	// Construct the rpcProxy. It must be initialised before the main web
 	// server is started.
@@ -1677,33 +1680,49 @@ func (g *LightningTerminal) validateSuperMacaroon(ctx context.Context,
 
 // initSubServers registers the faraday and loop sub-servers with the
 // subServerMgr.
-func (g *LightningTerminal) initSubServers() {
-	g.subServerMgr.AddServer(
+func (g *LightningTerminal) initSubServers() error {
+	err := g.subServerMgr.AddServer(
 		subservers.NewFaradaySubServer(
 			g.cfg.Faraday, g.cfg.faradayRpcConfig,
 			g.cfg.Remote.Faraday, g.cfg.faradayRemote,
 		), g.cfg.FaradayMode != ModeDisable,
 	)
+	if err != nil {
+		return fmt.Errorf("could not register Faraday subserver: %w",
+			err)
+	}
 
-	g.subServerMgr.AddServer(
+	err = g.subServerMgr.AddServer(
 		subservers.NewLoopSubServer(
 			g.cfg.Loop, g.cfg.Remote.Loop, g.cfg.loopRemote,
 		), g.cfg.LoopMode != ModeDisable,
 	)
+	if err != nil {
+		return fmt.Errorf("could not register Loop subserver: %w", err)
+	}
 
-	g.subServerMgr.AddServer(
+	err = g.subServerMgr.AddServer(
 		subservers.NewPoolSubServer(
 			g.cfg.Pool, g.cfg.Remote.Pool, g.cfg.poolRemote,
 		), g.cfg.PoolMode != ModeDisable,
 	)
+	if err != nil {
+		return fmt.Errorf("could not register Pool subserver: %w", err)
+	}
 
-	g.subServerMgr.AddServer(
+	err = g.subServerMgr.AddServer(
 		subservers.NewTaprootAssetsSubServer(
 			g.cfg.Network, g.cfg.TaprootAssets,
 			g.cfg.Remote.TaprootAssets,
 			g.cfg.tapRemote, g.cfg.lndRemote,
 		), g.cfg.TaprootAssetsMode != ModeDisable,
 	)
+	if err != nil {
+		return fmt.Errorf("could not register Taproot Assets "+
+			"subserver: %w", err)
+	}
+
+	return nil
 }
 
 // BakeSuperMacaroon uses the lnd client to bake a macaroon that can include