htlcswitch+routing: continue threading context through

In this commit, we remove a `context.TODO()` added in the
`Switch.SendHTLC` method & instead pass a context through to the method.
The rest of the commit is all about threading contexts through to
SendHTLC.

Author: ellemouton

htlcswitch/link_test.go

@@ -1585,6 +1585,7 @@ func TestChannelLinkMultiHopInsufficientPayment(t *testing.T) {
 // from Alice if she received not suitable payment hash for htlc.
 func TestChannelLinkMultiHopUnknownPaymentHash(t *testing.T) {
 	t.Parallel()
+	ctx := context.Background()
 
 	channels, _, err := createClusterChannels(
 		t, btcutil.SatoshiPerBitcoin*5, btcutil.SatoshiPerBitcoin*5,
@@ -1624,7 +1625,7 @@ func TestChannelLinkMultiHopUnknownPaymentHash(t *testing.T) {
 
 	// Send payment and expose err channel.
 	err = n.aliceServer.htlcSwitch.SendHTLC(
-		n.firstBobChannelLink.ShortChanID(), pid, htlc,
+		ctx, n.firstBobChannelLink.ShortChanID(), pid, htlc,
 	)
 	require.NoError(t, err, "unable to get send payment")
 
@@ -4518,6 +4519,7 @@ func TestChannelLinkUpdateCommitFee(t *testing.T) {
 // failures, reducing ambiguity when a batch is only partially processed.
 func TestChannelLinkAcceptDuplicatePayment(t *testing.T) {
 	t.Parallel()
+	ctx := context.Background()
 
 	// First, we'll create our traditional three hop network. We'll only be
 	// interacting with and asserting the state of two of the end points
@@ -4559,7 +4561,7 @@ func TestChannelLinkAcceptDuplicatePayment(t *testing.T) {
 	// With the invoice now added to Carol's registry, we'll send the
 	// payment.
 	err = n.aliceServer.htlcSwitch.SendHTLC(
-		n.firstBobChannelLink.ShortChanID(), pid, htlc,
+		ctx, n.firstBobChannelLink.ShortChanID(), pid, htlc,
 	)
 	require.NoError(t, err, "unable to send payment to carol")
 
@@ -4571,7 +4573,7 @@ func TestChannelLinkAcceptDuplicatePayment(t *testing.T) {
 	// Now, if we attempt to send the payment *again* it should be rejected
 	// as it's a duplicate request.
 	err = n.aliceServer.htlcSwitch.SendHTLC(
-		n.firstBobChannelLink.ShortChanID(), pid, htlc,
+		ctx, n.firstBobChannelLink.ShortChanID(), pid, htlc,
 	)
 	if err != ErrDuplicateAdd {
 		t.Fatalf("ErrDuplicateAdd should have been "+

htlcswitch/switch.go

@@ -546,10 +546,8 @@ func (s *Switch) CleanStore(keepPids map[uint64]struct{}) error {
 // package in order to send the htlc update. The attemptID used MUST be unique
 // for this HTLC, and MUST be used only once, otherwise the switch might reject
 // it.
-func (s *Switch) SendHTLC(firstHop lnwire.ShortChannelID, attemptID uint64,
-	htlc *lnwire.UpdateAddHTLC) error {
-
-	ctx := context.TODO()
+func (s *Switch) SendHTLC(ctx context.Context, firstHop lnwire.ShortChannelID,
+	attemptID uint64, htlc *lnwire.UpdateAddHTLC) error {
 
 	// Generate and send new update packet, if error will be received on
 	// this stage it means that packet haven't left boundaries of our

htlcswitch/switch_test.go

@@ -728,7 +728,7 @@ func testSwitchSendHtlcMapping(t *testing.T, zeroConf, useAlias bool, alias,
 		Amount:      1,
 	}
 
-	err = s.SendHTLC(outgoingSCID, 0, htlc)
+	err = s.SendHTLC(context.Background(), outgoingSCID, 0, htlc)
 	require.NoError(t, err)
 }
 
@@ -2364,7 +2364,9 @@ func testSkipLinkLocalForward(t *testing.T, eligible bool,
 	// We'll attempt to send out a new HTLC that has Alice as the first
 	// outgoing link. This should fail as Alice isn't yet able to forward
 	// any active HTLC's.
-	err = s.SendHTLC(aliceChannelLink.ShortChanID(), 0, addMsg)
+	err = s.SendHTLC(
+		context.Background(), aliceChannelLink.ShortChanID(), 0, addMsg,
+	)
 	if err == nil {
 		t.Fatalf("local forward should fail due to inactive link")
 	}
@@ -2693,7 +2695,8 @@ func TestSwitchSendPayment(t *testing.T) {
 	errChan := make(chan error)
 	go func() {
 		err := s.SendHTLC(
-			aliceChannelLink.ShortChanID(), paymentID, update,
+			context.Background(), aliceChannelLink.ShortChanID(),
+			paymentID, update,
 		)
 		if err != nil {
 			errChan <- err
@@ -3200,7 +3203,8 @@ func TestInvalidFailure(t *testing.T) {
 
 	// Send the request.
 	err = s.SendHTLC(
-		aliceChannelLink.ShortChanID(), paymentID, update,
+		context.Background(), aliceChannelLink.ShortChanID(), paymentID,
+		update,
 	)
 	require.NoError(t, err, "unable to send payment")
 
@@ -3552,7 +3556,8 @@ func (n *threeHopNetwork) sendThreeHopPayment(t *testing.T) (*lnwire.UpdateAddHT
 	require.NoError(t, err, "unable to add invoice in carol registry")
 
 	if err := n.aliceServer.htlcSwitch.SendHTLC(
-		n.firstBobChannelLink.ShortChanID(), pid, htlc,
+		context.Background(), n.firstBobChannelLink.ShortChanID(), pid,
+		htlc,
 	); err != nil {
 		t.Fatalf("could not send htlc")
 	}
@@ -4241,6 +4246,7 @@ func TestInterceptableSwitchWatchDog(t *testing.T) {
 // have incoming or outgoing links that breach their fee thresholds.
 func TestSwitchDustForwarding(t *testing.T) {
 	t.Parallel()
+	ctx := context.Background()
 
 	// We'll create a three-hop network:
 	// - Alice has a dust limit of 200sats with Bob
@@ -4344,7 +4350,7 @@ func TestSwitchDustForwarding(t *testing.T) {
 	// anchor channel) we are overexposed in fees (maxFeeExposure) that's
 	// why the HTLC is failed back.
 	err = n.bobServer.htlcSwitch.SendHTLC(
-		aliceBobFirstHop, uint64(bobAttemptID), failingHtlc,
+		ctx, aliceBobFirstHop, uint64(bobAttemptID), failingHtlc,
 	)
 	require.Nil(t, err)
 
@@ -4385,7 +4391,7 @@ func TestSwitchDustForwarding(t *testing.T) {
 	}
 
 	err = n.bobServer.htlcSwitch.SendHTLC(
-		aliceBobFirstHop, uint64(bobAttemptID), nondustHtlc,
+		ctx, aliceBobFirstHop, uint64(bobAttemptID), nondustHtlc,
 	)
 	require.NoError(t, err)
 	assertAlmostDust(n.firstBobChannelLink, bobMbox, lntypes.Local)
@@ -4426,7 +4432,7 @@ func TestSwitchDustForwarding(t *testing.T) {
 	carolAttemptID := 0
 
 	err = n.carolServer.htlcSwitch.SendHTLC(
-		n.carolChannelLink.ShortChanID(), uint64(carolAttemptID),
+		ctx, n.carolChannelLink.ShortChanID(), uint64(carolAttemptID),
 		carolHtlc,
 	)
 	require.NoError(t, err)
@@ -4469,7 +4475,7 @@ func TestSwitchDustForwarding(t *testing.T) {
 	assertAlmostDust(n.aliceChannelLink, aliceMbox, lntypes.Remote)
 
 	err = n.aliceServer.htlcSwitch.SendHTLC(
-		n.aliceChannelLink.ShortChanID(), uint64(aliceAttemptID),
+		ctx, n.aliceChannelLink.ShortChanID(), uint64(aliceAttemptID),
 		aliceMultihopHtlc,
 	)
 	require.Nil(t, err)
@@ -4555,7 +4561,9 @@ func sendDustHtlcs(t *testing.T, n *threeHopNetwork, alice bool,
 			// before all numHTLCs*2 HTLC's are sent due to double
 			// counting. Get around this by continuing to send
 			// until successful.
-			err = sendingSwitch.SendHTLC(sid, attemptID, htlc)
+			err = sendingSwitch.SendHTLC(
+				context.Background(), sid, attemptID, htlc,
+			)
 			if err == nil {
 				break
 			}
@@ -4660,7 +4668,7 @@ func TestSwitchMailboxDust(t *testing.T) {
 
 	// Sending one more HTLC to Alice should result in the fee threshold
 	// being breached.
-	err = s.SendHTLC(aliceChanID, 0, addMsg)
+	err = s.SendHTLC(context.Background(), aliceChanID, 0, addMsg)
 	require.ErrorIs(t, err, errFeeExposureExceeded)
 
 	// We'll now call ForwardPackets from Bob to ensure that the mailbox

htlcswitch/test_utils.go

@@ -768,6 +768,8 @@ func preparePayment(sendingPeer, receivingPeer lnpeer.Peer,
 	sender := sendingPeer.(*mockServer)
 	receiver := receivingPeer.(*mockServer)
 
+	ctx := context.Background()
+
 	// Generate route convert it to blob, and return next destination for
 	// htlc add request.
 	blob, err := generateRoute(hops...)
@@ -785,17 +787,14 @@ func preparePayment(sendingPeer, receivingPeer lnpeer.Peer,
 
 	// Check who is last in the route and add invoice to server registry.
 	hash := invoice.Terms.PaymentPreimage.Hash()
-	if err := receiver.registry.AddInvoice(
-		context.Background(), *invoice, hash,
-	); err != nil {
+	err = receiver.registry.AddInvoice(ctx, *invoice, hash)
+	if err != nil {
 		return nil, nil, err
 	}
 
 	// Send payment and expose err channel.
 	return invoice, func() error {
-		err := sender.htlcSwitch.SendHTLC(
-			firstHop, pid, htlc,
-		)
+		err := sender.htlcSwitch.SendHTLC(ctx, firstHop, pid, htlc)
 		if err != nil {
 			return err
 		}
@@ -1321,6 +1320,8 @@ func (n *twoHopNetwork) makeHoldPayment(sendingPeer, receivingPeer lnpeer.Peer,
 	invoiceAmt, htlcAmt lnwire.MilliSatoshi,
 	timelock uint32, preimage lntypes.Preimage) chan error {
 
+	ctx := context.Background()
+
 	paymentErr := make(chan error, 1)
 
 	sender := sendingPeer.(*mockServer)
@@ -1352,15 +1353,14 @@ func (n *twoHopNetwork) makeHoldPayment(sendingPeer, receivingPeer lnpeer.Peer,
 	}
 
 	// Check who is last in the route and add invoice to server registry.
-	if err := receiver.registry.AddInvoice(
-		context.Background(), *invoice, rhash,
-	); err != nil {
+	err = receiver.registry.AddInvoice(ctx, *invoice, rhash)
+	if err != nil {
 		paymentErr <- err
 		return paymentErr
 	}
 
 	// Send payment and expose err channel.
-	err = sender.htlcSwitch.SendHTLC(firstHop, pid, htlc)
+	err = sender.htlcSwitch.SendHTLC(ctx, firstHop, pid, htlc)
 	if err != nil {
 		paymentErr <- err
 		return paymentErr

lnrpc/routerrpc/router_server.go

@@ -923,11 +923,11 @@ func (s *Server) SendToRouteV2(ctx context.Context,
 	// db.
 	if req.SkipTempErr {
 		attempt, err = s.cfg.Router.SendToRouteSkipTempErr(
-			hash, route, firstHopRecords,
+			ctx, hash, route, firstHopRecords,
 		)
 	} else {
 		attempt, err = s.cfg.Router.SendToRoute(
-			hash, route, firstHopRecords,
+			ctx, hash, route, firstHopRecords,
 		)
 	}
 	if attempt != nil {

routing/mock_test.go

@@ -1,6 +1,7 @@
 package routing
 
 import (
+	"context"
 	"fmt"
 	"sync"
 
@@ -29,7 +30,7 @@ type mockPaymentAttemptDispatcherOld struct {
 
 var _ PaymentAttemptDispatcher = (*mockPaymentAttemptDispatcherOld)(nil)
 
-func (m *mockPaymentAttemptDispatcherOld) SendHTLC(
+func (m *mockPaymentAttemptDispatcherOld) SendHTLC(_ context.Context,
 	firstHop lnwire.ShortChannelID, pid uint64,
 	_ *lnwire.UpdateAddHTLC) error {
 
@@ -206,7 +207,7 @@ type mockPayerOld struct {
 
 var _ PaymentAttemptDispatcher = (*mockPayerOld)(nil)
 
-func (m *mockPayerOld) SendHTLC(_ lnwire.ShortChannelID,
+func (m *mockPayerOld) SendHTLC(_ context.Context, _ lnwire.ShortChannelID,
 	paymentID uint64,
 	_ *lnwire.UpdateAddHTLC) error {
 
@@ -592,7 +593,8 @@ type mockPaymentAttemptDispatcher struct {
 
 var _ PaymentAttemptDispatcher = (*mockPaymentAttemptDispatcher)(nil)
 
-func (m *mockPaymentAttemptDispatcher) SendHTLC(firstHop lnwire.ShortChannelID,
+func (m *mockPaymentAttemptDispatcher) SendHTLC(_ context.Context,
+	firstHop lnwire.ShortChannelID,
 	pid uint64, htlcAdd *lnwire.UpdateAddHTLC) error {
 
 	args := m.Called(firstHop, pid, htlcAdd)

routing/payment_lifecycle.go

@@ -304,7 +304,7 @@ lifecycle:
 		}
 
 		// Once the attempt is created, send it to the htlcswitch.
-		result, err := p.sendAttempt(attempt)
+		result, err := p.sendAttempt(ctx, attempt)
 		if err != nil {
 			return exitWithErr(err)
 		}
@@ -649,7 +649,7 @@ func (p *paymentLifecycle) createNewPaymentAttempt(rt *route.Route,
 // sendAttempt attempts to send the current attempt to the switch to complete
 // the payment. If this attempt fails, then we'll continue on to the next
 // available route.
-func (p *paymentLifecycle) sendAttempt(
+func (p *paymentLifecycle) sendAttempt(ctx context.Context,
 	attempt *channeldb.HTLCAttempt) (*attemptResult, error) {
 
 	log.Debugf("Sending HTLC attempt(id=%v, total_amt=%v, first_hop_amt=%d"+
@@ -690,7 +690,9 @@ func (p *paymentLifecycle) sendAttempt(
 	// the Switch successfully has persisted the payment attempt,
 	// such that we can resume waiting for the result after a
 	// restart.
-	err = p.router.cfg.Payer.SendHTLC(firstHop, attempt.AttemptID, htlcAdd)
+	err = p.router.cfg.Payer.SendHTLC(
+		ctx, firstHop, attempt.AttemptID, htlcAdd,
+	)
 	if err != nil {
 		log.Errorf("Failed sending attempt %d for payment %v to "+
 			"switch: %v", attempt.AttemptID, p.identifier, err)

routing/router.go

@@ -108,7 +108,7 @@ type PaymentAttemptDispatcher interface {
 	// forward a fully encoded payment to the first hop in the route
 	// denoted by its public key. A non-nil error is to be returned if the
 	// payment was unsuccessful.
-	SendHTLC(firstHop lnwire.ShortChannelID,
+	SendHTLC(ctx context.Context, firstHop lnwire.ShortChannelID,
 		attemptID uint64,
 		htlcAdd *lnwire.UpdateAddHTLC) error
 
@@ -1020,21 +1020,22 @@ func (r *ChannelRouter) PreparePayment(payment *LightningPayment) (
 
 // SendToRoute sends a payment using the provided route and fails the payment
 // when an error is returned from the attempt.
-func (r *ChannelRouter) SendToRoute(htlcHash lntypes.Hash, rt *route.Route,
+func (r *ChannelRouter) SendToRoute(ctx context.Context, htlcHash lntypes.Hash,
+	rt *route.Route,
 	firstHopCustomRecords lnwire.CustomRecords) (*channeldb.HTLCAttempt,
 	error) {
 
-	return r.sendToRoute(htlcHash, rt, false, firstHopCustomRecords)
+	return r.sendToRoute(ctx, htlcHash, rt, false, firstHopCustomRecords)
 }
 
 // SendToRouteSkipTempErr sends a payment using the provided route and fails
 // the payment ONLY when a terminal error is returned from the attempt.
-func (r *ChannelRouter) SendToRouteSkipTempErr(htlcHash lntypes.Hash,
-	rt *route.Route,
+func (r *ChannelRouter) SendToRouteSkipTempErr(ctx context.Context,
+	htlcHash lntypes.Hash, rt *route.Route,
 	firstHopCustomRecords lnwire.CustomRecords) (*channeldb.HTLCAttempt,
 	error) {
 
-	return r.sendToRoute(htlcHash, rt, true, firstHopCustomRecords)
+	return r.sendToRoute(ctx, htlcHash, rt, true, firstHopCustomRecords)
 }
 
 // sendToRoute attempts to send a payment with the given hash through the
@@ -1043,8 +1044,8 @@ func (r *ChannelRouter) SendToRouteSkipTempErr(htlcHash lntypes.Hash,
 // information will contain the preimage. If an error occurs after the attempt
 // was initiated, both return values will be non-nil. If skipTempErr is true,
 // the payment won't be failed unless a terminal error has occurred.
-func (r *ChannelRouter) sendToRoute(htlcHash lntypes.Hash, rt *route.Route,
-	skipTempErr bool,
+func (r *ChannelRouter) sendToRoute(ctx context.Context, htlcHash lntypes.Hash,
+	rt *route.Route, skipTempErr bool,
 	firstHopCustomRecords lnwire.CustomRecords) (*channeldb.HTLCAttempt,
 	error) {
 
@@ -1166,7 +1167,7 @@ func (r *ChannelRouter) sendToRoute(htlcHash lntypes.Hash, rt *route.Route,
 	// the `err` returned here has already been processed by
 	// `handleSwitchErr`, which means if there's a terminal failure, the
 	// payment has been failed.
-	result, err := p.sendAttempt(attempt)
+	result, err := p.sendAttempt(ctx, attempt)
 	if err != nil {
 		return nil, err
 	}