multi: create gRPC servers at init time

To make sure we always have the same reference to the gRPC servers we
use, we create them earlier and keep them for the whole lifetime of the
outer `server` struct (which is used by litd).
Because we need the config before starting (but don't have the config
ready in litd when we create the server struct), we add a new
UpdateConfig method to all servers.

Author: guggero

authmailbox/client_test.go

@@ -82,7 +82,8 @@ func (h *serverHarness) start(t *testing.T) {
 	}
 	h.grpcServer = grpc.NewServer(serverOpts...)
 
-	h.srv = NewServer(h.cfg)
+	h.srv = NewServer()
+	require.NoError(t, h.srv.Start(h.cfg))
 	mboxrpc.RegisterMailboxServer(h.grpcServer, h.srv)
 
 	cleanup, err := test.StartMockGRPCServerWithAddr(

authmailbox/server.go

@@ -80,9 +80,8 @@ type Server struct {
 }
 
 // NewServer creates a new mailbox server with the given configuration.
-func NewServer(cfg *ServerConfig) *Server {
+func NewServer() *Server {
 	return &Server{
-		cfg: cfg,
 		msgEventsSubs: make(
 			map[uint64]*fn.EventReceiver[[]*Message],
 		),
@@ -92,12 +91,21 @@ func NewServer(cfg *ServerConfig) *Server {
 }
 
 // Start signals that the RPC server starts accepting requests.
-func (s *Server) Start() error {
+func (s *Server) Start(cfg *ServerConfig) error {
+	var startErr error
 	s.startOnce.Do(func() {
 		log.Infof("Starting authmailbox RPC Server")
+
+		if cfg == nil {
+			startErr = fmt.Errorf("authmailbox server config not " +
+				"provided in Start")
+			return
+		}
+
+		s.cfg = cfg
 	})
 
-	return nil
+	return startErr
 }
 
 // RegisterWithGrpcServer registers the rpcServer with the passed root gRPC

rpcserver.go

@@ -39,7 +39,6 @@ import (
 	"github.com/lightninglabs/taproot-assets/rfq"
 	"github.com/lightninglabs/taproot-assets/rfqmath"
 	"github.com/lightninglabs/taproot-assets/rfqmsg"
-	"github.com/lightninglabs/taproot-assets/rpcperms"
 	"github.com/lightninglabs/taproot-assets/rpcutils"
 	"github.com/lightninglabs/taproot-assets/tapchannel"
 	"github.com/lightninglabs/taproot-assets/tapdb"
@@ -176,8 +175,6 @@ type rpcServer struct {
 
 	interceptor signal.Interceptor
 
-	interceptorChain *rpcperms.InterceptorChain
-
 	cfg *Config
 
 	proofQueryRateLimiter *rate.Limiter
@@ -186,30 +183,31 @@ type rpcServer struct {
 	wg   sync.WaitGroup
 }
 
-// newRPCServer creates a new RPC sever from the set of input dependencies.
-func newRPCServer(interceptor signal.Interceptor,
-	interceptorChain *rpcperms.InterceptorChain,
-	cfg *Config) (*rpcServer, error) {
-
+// newRPCServer creates a new RPC sever.
+func newRPCServer() *rpcServer {
 	return &rpcServer{
-		interceptor:      interceptor,
-		interceptorChain: interceptorChain,
-		quit:             make(chan struct{}),
-		proofQueryRateLimiter: rate.NewLimiter(
-			cfg.UniverseQueriesPerSecond, cfg.UniverseQueriesBurst,
-		),
-		cfg: cfg,
-	}, nil
+		quit: make(chan struct{}),
+	}
 }
 
 // TODO(roasbeef): build in batching for asset creation?
 
 // Start signals that the RPC server starts accepting requests.
-func (r *rpcServer) Start() error {
+func (r *rpcServer) Start(cfg *Config) error {
 	if atomic.AddInt32(&r.started, 1) != 1 {
 		return nil
 	}
 
+	if cfg == nil {
+		return fmt.Errorf("RPC server config not provided in Start")
+	}
+
+	r.interceptor = cfg.SignalInterceptor
+	r.cfg = cfg
+	r.proofQueryRateLimiter = rate.NewLimiter(
+		r.cfg.UniverseQueriesPerSecond, r.cfg.UniverseQueriesBurst,
+	)
+
 	rpcsLog.Infof("Starting RPC Server")
 
 	return nil

server.go

@@ -72,11 +72,12 @@ type Server struct {
 	wg   sync.WaitGroup
 }
 
-// NewServer creates a new server given the passed config.
-func NewServer(chainParams *address.ChainParams, cfg *Config) *Server {
+// NewServer creates a new server.
+func NewServer(chainParams *address.ChainParams) *Server {
 	return &Server{
+		rpcServer:   newRPCServer(),
+		mboxServer:  authmailbox.NewServer(),
 		chainParams: chainParams,
-		cfg:         cfg,
 		ready:       make(chan bool),
 		quit:        make(chan struct{}, 1),
 	}
@@ -105,6 +106,11 @@ func (s *Server) initialize(interceptorChain *rpcperms.InterceptorChain) error {
 		}
 	}()
 
+	if s.cfg == nil {
+		return fmt.Errorf("main server config not set before calling " +
+			"initialize")
+	}
+
 	// Show version at startup.
 	srvrLog.Infof("Version: %s, build=%s, logging=%s, "+
 		"debuglevel=%s, active_network=%v", Version(), build.Deployment,
@@ -171,18 +177,6 @@ func (s *Server) initialize(interceptorChain *rpcperms.InterceptorChain) error {
 		}
 	}
 
-	// Initialize, and register our implementation of the gRPC interface
-	// exported by the rpcServer.
-	var err error
-	s.rpcServer, err = newRPCServer(
-		s.cfg.SignalInterceptor, interceptorChain, s.cfg,
-	)
-	if err != nil {
-		return fmt.Errorf("unable to create rpc server: %w", err)
-	}
-
-	s.mboxServer = authmailbox.NewServer(&s.cfg.MboxServerConfig)
-
 	// First, we'll start the main batched asset minter.
 	if err := s.cfg.AssetMinter.Start(); err != nil {
 		return fmt.Errorf("unable to start asset minter: %w", err)
@@ -253,13 +247,13 @@ func (s *Server) initialize(interceptorChain *rpcperms.InterceptorChain) error {
 
 	// Now we have created all dependencies necessary to populate and
 	// start the RPC server.
-	if err := s.rpcServer.Start(); err != nil {
+	if err := s.rpcServer.Start(s.cfg); err != nil {
 		return fmt.Errorf("unable to start RPC server: %w", err)
 	}
 
 	shutdownFuncs["rpcServer"] = s.rpcServer.Stop
 
-	if err := s.mboxServer.Start(); err != nil {
+	if err := s.mboxServer.Start(&s.cfg.MboxServerConfig); err != nil {
 		return fmt.Errorf("unable to start auth mailbox server: %w",
 			err)
 	}

tapcfg/server.go

@@ -771,7 +771,10 @@ func CreateServerFromConfig(cfg *Config, cfgLogger btclog.Logger,
 		LetsEncryptDomain:          cfg.RpcConf.LetsEncryptDomain,
 	}
 
-	return tap.NewServer(&serverCfg.ChainParams, serverCfg), nil
+	srv := tap.NewServer(&serverCfg.ChainParams)
+	srv.UpdateConfig(serverCfg)
+
+	return srv, nil
 }
 
 // ConfigureSubServer updates a Taproot Asset server with the given CLI config.