terminal: don't stop litd on account system error

Author: ViktorT-11

accounts/service.go

@@ -60,16 +60,18 @@ type InterceptorService struct {
 	invoiceToAccount map[lntypes.Hash]AccountID
 	pendingPayments  map[lntypes.Hash]*trackedPayment
 
-	mainErrChan chan<- error
-	wg          sync.WaitGroup
-	quit        chan struct{}
+	mainErrCallback func(error)
+	wg              sync.WaitGroup
+	quit            chan struct{}
 
 	isEnabled bool
 }
 
 // NewService returns a service backed by the macaroon Bolt DB stored in the
 // passed-in directory.
-func NewService(dir string, errChan chan<- error) (*InterceptorService, error) {
+func NewService(dir string,
+	errCallback func(error)) (*InterceptorService, error) {
+
 	accountStore, err := NewBoltStore(dir, DBFilename)
 	if err != nil {
 		return nil, err
@@ -83,7 +85,7 @@ func NewService(dir string, errChan chan<- error) (*InterceptorService, error) {
 		contextCancel:    contextCancel,
 		invoiceToAccount: make(map[lntypes.Hash]AccountID),
 		pendingPayments:  make(map[lntypes.Hash]*trackedPayment),
-		mainErrChan:      errChan,
+		mainErrCallback:  errCallback,
 		quit:             make(chan struct{}),
 		isEnabled:        false,
 	}, nil
@@ -185,28 +187,18 @@ func (s *InterceptorService) Start(lightningClient lndclient.LightningClient,
 					log.Errorf("Error processing invoice "+
 						"update: %v", err)
 
-					select {
-					case s.mainErrChan <- err:
-					case <-s.mainCtx.Done():
-					case <-s.quit:
-					}
+					s.mainErrCallback(err)
 					return
 				}
 
 			case err := <-invoiceErrChan:
-				log.Errorf("Error in invoice subscription: %v",
-					err)
-
 				// if the invoice subscription errors out, we
 				// stop the service as we won't be able to
 				// process invoices.
-				s.disable()
+				err = s.disableAndErrorf("Error in invoice "+
+					"subscription: %v", err)
 
-				select {
-				case s.mainErrChan <- err:
-				case <-s.mainCtx.Done():
-				case <-s.quit:
-				}
+				s.mainErrCallback(err)
 				return
 
 			case <-s.mainCtx.Done():
@@ -587,11 +579,7 @@ func (s *InterceptorService) TrackPayment(id AccountID, hash lntypes.Hash,
 					hash, paymentUpdate,
 				)
 				if err != nil {
-					select {
-					case s.mainErrChan <- err:
-					case <-s.mainCtx.Done():
-					case <-s.quit:
-					}
+					s.mainErrCallback(err)
 					return
 				}
 
@@ -613,18 +601,13 @@ func (s *InterceptorService) TrackPayment(id AccountID, hash lntypes.Hash,
 					return
 				}
 
-				log.Errorf("Received error from TrackPayment "+
-					"RPC for payment %v: %v", hash, err)
-
 				if err != nil {
 					// If we error when tracking the
 					// payment, we stop the service.
-					s.disable()
-					select {
-					case s.mainErrChan <- err:
-					case <-s.mainCtx.Done():
-					case <-s.quit:
-					}
+					err = s.disableAndErrorf("Received "+
+						"error from TrackPayment RPC "+
+						"for payment %v: %v", hash, err)
+					s.mainErrCallback(err)
 				}
 				return
 

accounts/service_test.go

@@ -65,6 +65,8 @@ func (m *mockLnd) assertNoMainErr(t *testing.T) {
 	}
 }
 
+// assertMainErr asserts that the main error is set to the expected error, and
+// then resets the main error to nil.
 func (m *mockLnd) assertMainErr(t *testing.T, expectedErr error) {
 	select {
 	case err := <-m.mainErrChan:
@@ -75,6 +77,8 @@ func (m *mockLnd) assertMainErr(t *testing.T, expectedErr error) {
 	}
 }
 
+// assertMainErr asserts that the main error contains the expected error string,
+// and then resets the main error to nil.
 func (m *mockLnd) assertMainErrContains(t *testing.T, expectedStr string) {
 	select {
 	case err := <-m.mainErrChan:
@@ -285,7 +289,7 @@ func TestAccountService(t *testing.T) {
 			err := s.store.UpdateAccount(acct)
 			require.NoError(t, err)
 
-			lnd.mainErrChan <- testErr
+			s.mainErrCallback(testErr)
 		},
 		validate: func(t *testing.T, lnd *mockLnd,
 			s *InterceptorService) {
@@ -670,9 +674,10 @@ func TestAccountService(t *testing.T) {
 			tt.Parallel()
 
 			lndMock := newMockLnd()
-			service, err := NewService(
-				t.TempDir(), lndMock.mainErrChan,
-			)
+			errFunc := func(err error) {
+				lndMock.mainErrChan <- err
+			}
+			service, err := NewService(t.TempDir(), errFunc)
 			require.NoError(t, err)
 
 			// Is a setup call required to initialize initial

terminal.go

@@ -181,8 +181,9 @@ type LightningTerminal struct {
 	middleware        *mid.Manager
 	middlewareStarted bool
 
-	accountService        *accounts.InterceptorService
-	accountServiceStarted bool
+	accountService            *accounts.InterceptorService
+	accountServiceStarted     bool
+	accountServiceErrCallback func(error)
 
 	accountRpcServer *accounts.RPCServer
 
@@ -305,8 +306,14 @@ func (g *LightningTerminal) Run() error {
 func (g *LightningTerminal) start() error {
 	var err error
 
+	accountServiceErrCallback := func(err error) {
+		log.Errorf("Error thrown in the accounts service, keeping "+
+			"litd running: %v", err,
+		)
+	}
+
 	g.accountService, err = accounts.NewService(
-		filepath.Dir(g.cfg.MacaroonPath), g.errQueue.ChanIn(),
+		filepath.Dir(g.cfg.MacaroonPath), accountServiceErrCallback,
 	)
 	if err != nil {
 		return fmt.Errorf("error creating account service: %v", err)
@@ -843,9 +850,12 @@ func (g *LightningTerminal) startInternalSubServers(
 		g.lndClient.ChainParams,
 	)
 	if err != nil {
-		return fmt.Errorf("error starting account service: %v",
-			err)
+		log.Errorf("error starting account service: %v, disabling "+
+			"account service", err)
 	}
+	// Even if we error on accountService.Start, we still want to mark the
+	// service as started so that we can properly shut it down in the
+	// shutdownSubServers call.
 	g.accountServiceStarted = true
 
 	requestLogger, err := firewall.NewRequestLogger(