subservers: embed Subserver in subServerWrapper

Author: ellemouton

subservers/manager.go

@@ -46,7 +46,7 @@ func (s *Manager) AddServer(ss SubServer) {
 	defer s.mu.Unlock()
 
 	s.servers = append(s.servers, &subServerWrapper{
-		subServer: ss,
+		SubServer: ss,
 		quit:      make(chan struct{}),
 	})
 }
@@ -60,16 +60,16 @@ func (s *Manager) StartIntegratedServers(lndClient lnrpc.LightningClient,
 	defer s.mu.Unlock()
 
 	for _, ss := range s.servers {
-		if ss.subServer.Remote() {
+		if ss.Remote() {
 			continue
 		}
 
 		err := ss.startIntegrated(
 			lndClient, lndGrpc, withMacaroonService,
 		)
 		if err != nil {
-			return fmt.Errorf("Unable to start %v in integrated "+
-				"mode: %v", ss.subServer.Name(), err)
+			return fmt.Errorf("unable to start %v in integrated "+
+				"mode: %v", ss.Name(), err)
 		}
 	}
 
@@ -83,14 +83,14 @@ func (s *Manager) ConnectRemoteSubServers() {
 	defer s.mu.Unlock()
 
 	for _, ss := range s.servers {
-		if !ss.subServer.Remote() {
+		if !ss.Remote() {
 			continue
 		}
 
 		err := ss.connectRemote()
 		if err != nil {
 			log.Errorf("Failed to connect to remote %s: %v",
-				ss.subServer.Name(), err)
+				ss.Name(), err)
 
 			continue
 		}
@@ -108,11 +108,11 @@ func (s *Manager) RegisterRPCServices(server grpc.ServiceRegistrar) {
 		// a catch-all for any gRPC request that isn't known because we
 		// didn't register any server for it. The director will then
 		// forward the request to the remote service.
-		if ss.subServer.Remote() {
+		if ss.Remote() {
 			continue
 		}
 
-		ss.subServer.RegisterGrpcService(server)
+		ss.RegisterGrpcService(server)
 	}
 }
 
@@ -125,11 +125,11 @@ func (s *Manager) GetRemoteConn(uri string) (bool, *grpc.ClientConn) {
 	defer s.mu.RUnlock()
 
 	for _, ss := range s.servers {
-		if !s.permsMgr.IsSubServerURI(ss.subServer.Name(), uri) {
+		if !s.permsMgr.IsSubServerURI(ss.Name(), uri) {
 			continue
 		}
 
-		if !ss.subServer.Remote() {
+		if !ss.Remote() {
 			return false, nil
 		}
 
@@ -151,15 +151,15 @@ func (s *Manager) ValidateMacaroon(ctx context.Context,
 	defer s.mu.RUnlock()
 
 	for _, ss := range s.servers {
-		if !s.permsMgr.IsSubServerURI(ss.subServer.Name(), uri) {
+		if !s.permsMgr.IsSubServerURI(ss.Name(), uri) {
 			continue
 		}
 
 		// If the sub-server is running in remote mode, then we don't
 		// need to validate the macaroon here since the remote server
 		// will do it when the request arrives. But we have handled the
 		// request, as we were able to identify it.
-		if ss.subServer.Remote() {
+		if ss.Remote() {
 			return true, nil
 		}
 
@@ -170,14 +170,12 @@ func (s *Manager) ValidateMacaroon(ctx context.Context,
 			return true, fmt.Errorf("%s is not yet ready for "+
 				"requests, the subserver has not started or "+
 				"lnd still starting/syncing",
-				ss.subServer.Name())
+				ss.Name())
 		}
 
 		// Validate the macaroon with the integrated sub-server's own
 		// validator.
-		err := ss.subServer.ValidateMacaroon(
-			ctx, requiredPermissions, uri,
-		)
+		err := ss.ValidateMacaroon(ctx, requiredPermissions, uri)
 		if err != nil {
 			return true, fmt.Errorf("invalid macaroon: %v", err)
 		}
@@ -199,14 +197,13 @@ func (s *Manager) Stop() error {
 	defer s.mu.RUnlock()
 
 	for _, ss := range s.servers {
-		if ss.subServer.Remote() {
+		if ss.Remote() {
 			continue
 		}
 
 		err := ss.stop()
 		if err != nil {
-			log.Errorf("Error stopping %s: %v", ss.subServer.Name(),
-				err)
+			log.Errorf("Error stopping %s: %v", ss.Name(), err)
 			returnErr = err
 		}
 	}

subservers/subserver.go

@@ -21,13 +21,13 @@ const (
 // subServerWrapper is a wrapper around the SubServer interface and is used by
 // the subServerMgr to manage a SubServer.
 type subServerWrapper struct {
+	SubServer
+
 	integratedStarted bool
 	startedMu         sync.RWMutex
 
 	stopped sync.Once
 
-	subServer SubServer
-
 	remoteConn *grpc.ClientConn
 
 	wg   sync.WaitGroup
@@ -66,7 +66,7 @@ func (s *subServerWrapper) stop() error {
 		s.wg.Wait()
 
 		// If running in remote mode, close the connection.
-		if s.subServer.Remote() && s.remoteConn != nil {
+		if s.Remote() && s.remoteConn != nil {
 			err := s.remoteConn.Close()
 			if err != nil {
 				returnErr = fmt.Errorf("could not close "+
@@ -76,19 +76,19 @@ func (s *subServerWrapper) stop() error {
 		}
 
 		// Else, stop the integrated sub-server process.
-		err := s.subServer.Stop()
+		err := s.Stop()
 		if err != nil {
 			returnErr = fmt.Errorf("could not close "+
 				"integrated connection: %v", err)
 			return
 		}
 
-		if s.subServer.ServerErrChan() == nil {
+		if s.ServerErrChan() == nil {
 			return
 		}
 
 		select {
-		case returnErr = <-s.subServer.ServerErrChan():
+		case returnErr = <-s.ServerErrChan():
 		default:
 		}
 	})
@@ -100,13 +100,13 @@ func (s *subServerWrapper) stop() error {
 func (s *subServerWrapper) startIntegrated(lndClient lnrpc.LightningClient,
 	lndGrpc *lndclient.GrpcLndServices, withMacaroonService bool) error {
 
-	err := s.subServer.Start(lndClient, lndGrpc, withMacaroonService)
+	err := s.Start(lndClient, lndGrpc, withMacaroonService)
 	if err != nil {
 		return err
 	}
 	s.setStarted(true)
 
-	if s.subServer.ServerErrChan() == nil {
+	if s.ServerErrChan() == nil {
 		return nil
 	}
 
@@ -115,14 +115,14 @@ func (s *subServerWrapper) startIntegrated(lndClient lnrpc.LightningClient,
 		defer s.wg.Done()
 
 		select {
-		case err := <-s.subServer.ServerErrChan():
+		case err := <-s.ServerErrChan():
 			// The sub server should shut itself down if an error
 			// happens. We don't need to try to stop it again.
 			s.setStarted(false)
 
 			err = fmt.Errorf("received critical error from "+
 				"sub-server (%s), shutting down: %v",
-				s.subServer.Name(), err)
+				s.Name(), err)
 
 			log.Error(err)
 
@@ -135,9 +135,9 @@ func (s *subServerWrapper) startIntegrated(lndClient lnrpc.LightningClient,
 
 // connectRemote attempts to make a connection to the remote sub-server.
 func (s *subServerWrapper) connectRemote() error {
-	cfg := s.subServer.RemoteConfig()
+	cfg := s.RemoteConfig()
 	certPath := lncfg.CleanAndExpandPath(cfg.TLSCertPath)
-	name := s.subServer.Name()
+	name := s.Name()
 	conn, err := dialBackend(name, cfg.RPCServer, certPath)
 	if err != nil {
 		return fmt.Errorf("remote dial error: %v", err)