Merge pull request #1671 from lightninglabs/fix-litd

ci: fix litd itest

Author: GeorgeTsagk

.github/workflows/main.yaml

@@ -21,7 +21,7 @@ env:
 
   GO_VERSION: '1.23.9'
 
-  LITD_ITEST_BRANCH: 'lnd-19-2'
+  LITD_ITEST_BRANCH: 'tapd-main-branch'
 
 jobs:
   #######################

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,18 +91,27 @@ 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
 // server.
-func (s *Server) RegisterWithGrpcServer(grpcServer *grpc.Server) error {
-	mboxrpc.RegisterMailboxServer(grpcServer, s)
+func (s *Server) RegisterWithGrpcServer(registrar grpc.ServiceRegistrar) error {
+	mboxrpc.RegisterMailboxServer(registrar, s)
 
 	return nil
 }

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"
@@ -177,8 +176,6 @@ type rpcServer struct {
 
 	interceptor signal.Interceptor
 
-	interceptorChain *rpcperms.InterceptorChain
-
 	cfg *Config
 
 	proofQueryRateLimiter *rate.Limiter
@@ -187,30 +184,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
@@ -234,15 +232,18 @@ func (r *rpcServer) Stop() error {
 
 // RegisterWithGrpcServer registers the rpcServer with the passed root gRPC
 // server.
-func (r *rpcServer) RegisterWithGrpcServer(grpcServer *grpc.Server) error {
+func (r *rpcServer) RegisterWithGrpcServer(
+	registrar grpc.ServiceRegistrar) error {
+
 	// Register the main RPC server.
-	taprpc.RegisterTaprootAssetsServer(grpcServer, r)
-	wrpc.RegisterAssetWalletServer(grpcServer, r)
-	mintrpc.RegisterMintServer(grpcServer, r)
-	rfqrpc.RegisterRfqServer(grpcServer, r)
-	tchrpc.RegisterTaprootAssetChannelsServer(grpcServer, r)
-	unirpc.RegisterUniverseServer(grpcServer, r)
-	tapdevrpc.RegisterGrpcServer(grpcServer, r)
+	taprpc.RegisterTaprootAssetsServer(registrar, r)
+	wrpc.RegisterAssetWalletServer(registrar, r)
+	mintrpc.RegisterMintServer(registrar, r)
+	rfqrpc.RegisterRfqServer(registrar, r)
+	tchrpc.RegisterTaprootAssetChannelsServer(registrar, r)
+	unirpc.RegisterUniverseServer(registrar, r)
+	tapdevrpc.RegisterGrpcServer(registrar, r)
+
 	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)
 	}
@@ -669,6 +663,35 @@ func startRestProxy(cfg *Config, rpcServer *rpcServer,
 	return shutdown, nil
 }
 
+// RegisterGrpcService must register the sub-server's GRPC server with the given
+// registrar.
+//
+// NOTE: this is part of the SubServer interface.
+func (s *Server) RegisterGrpcService(registrar grpc.ServiceRegistrar) {
+	_ = s.rpcServer.RegisterWithGrpcServer(registrar)
+	_ = s.mboxServer.RegisterWithGrpcServer(registrar)
+}
+
+// RegisterRestService registers the sub-server's REST handlers with the given
+// endpoint.
+//
+// NOTE: this is part of the SubServer interface.
+func (s *Server) RegisterRestService(ctx context.Context, mux *proxy.ServeMux,
+	endpoint string, dialOpts []grpc.DialOption) error {
+
+	err := s.rpcServer.RegisterWithRestProxy(ctx, mux, dialOpts, endpoint)
+	if err != nil {
+		return err
+	}
+
+	err = s.mboxServer.RegisterWithRestProxy(ctx, mux, dialOpts, endpoint)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
 // Stop signals that the main tapd server should attempt a graceful shutdown.
 func (s *Server) Stop() error {
 	if atomic.AddInt32(&s.shutdown, 1) != 1 {

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.

taprpc/tapdevrpc/config_active.go

@@ -4,6 +4,6 @@ package tapdevrpc
 
 import "google.golang.org/grpc"
 
-func RegisterGrpcServer(grpcServer *grpc.Server, srv TapDevServer) {
-	RegisterTapDevServer(grpcServer, srv)
+func RegisterGrpcServer(registrar grpc.ServiceRegistrar, srv TapDevServer) {
+	RegisterTapDevServer(registrar, srv)
 }

taprpc/tapdevrpc/config_default.go

@@ -4,5 +4,5 @@ package tapdevrpc
 
 import "google.golang.org/grpc"
 
-func RegisterGrpcServer(_ *grpc.Server, _ TapDevServer) {
+func RegisterGrpcServer(_ grpc.ServiceRegistrar, _ TapDevServer) {
 }