routing: remove second chance logic

routing/missioncontrol.go

@@ -18,30 +18,6 @@ const (
 	// channel is back at 50% probability.
 	DefaultPenaltyHalfLife = time.Hour
 
-	// minSecondChanceInterval is the minimum time required between
-	// second-chance failures.
-	//
-	// If nodes return a channel policy related failure, they may get a
-	// second chance to forward the payment. It could be that the channel
-	// policy that we are aware of is not up to date. This is especially
-	// important in case of mobile apps that are mostly offline.
-	//
-	// However, we don't want to give nodes the option to endlessly return
-	// new channel updates so that we are kept busy trying to route through
-	// that node until the payment loop times out.
-	//
-	// Therefore we only grant a second chance to a node if the previous
-	// second chance is sufficiently long ago. This is what
-	// minSecondChanceInterval defines. If a second policy failure comes in
-	// within that interval, we will apply a penalty.
-	//
-	// Second chances granted are tracked on the level of node pairs. This
-	// means that if a node has multiple channels to the same peer, they
-	// will only get a single second chance to route to that peer again.
-	// Nodes forward non-strict, so it isn't necessary to apply a less
-	// restrictive channel level tracking scheme here.
-	minSecondChanceInterval = time.Minute
-
 	// DefaultMaxMcHistory is the default maximum history size.
 	DefaultMaxMcHistory = 1000
 
@@ -475,15 +451,6 @@ func (m *MissionControl) applyPaymentResult(
 		result.failure,
 	)
 
-	if i.policyFailure != nil {
-		if m.state.requestSecondChance(
-			result.timeReply,
-			i.policyFailure.From, i.policyFailure.To,
-		) {
-			return nil
-		}
-	}
-
 	// If there is a node-level failure, record a failure for every tried
 	// connection of that node. A node-level failure can be considered as a
 	// failure that would have occurred with any of the node's channels.

routing/missioncontrol_state.go

@@ -16,10 +16,6 @@ type missionControlState struct {
 	// particular node.
 	lastPairResult map[route.Vertex]NodeResults
 
-	// lastSecondChance tracks the last time a second chance was granted for
-	// a directed node pair.
-	lastSecondChance map[DirectedNodePair]time.Time
-
 	// minFailureRelaxInterval is the minimum time that must have passed
 	// since the previously recorded failure before the failure amount may
 	// be raised.
@@ -32,7 +28,6 @@ func newMissionControlState(
 
 	return &missionControlState{
 		lastPairResult:          make(map[route.Vertex]NodeResults),
-		lastSecondChance:        make(map[DirectedNodePair]time.Time),
 		minFailureRelaxInterval: minFailureRelaxInterval,
 	}
 }
@@ -49,7 +44,6 @@ func (m *missionControlState) getLastPairResult(node route.Vertex) (NodeResults,
 // if no payment attempts have been made.
 func (m *missionControlState) resetHistory() {
 	m.lastPairResult = make(map[route.Vertex]NodeResults)
-	m.lastSecondChance = make(map[DirectedNodePair]time.Time)
 }
 
 // setLastPairResult stores a result for a node pair.
@@ -153,37 +147,6 @@ func (m *missionControlState) setAllFail(node route.Vertex,
 	}
 }
 
-// requestSecondChance checks whether the node fromNode can have a second chance
-// at providing a channel update for its channel with toNode.
-func (m *missionControlState) requestSecondChance(timestamp time.Time,
-	fromNode, toNode route.Vertex) bool {
-
-	// Look up previous second chance time.
-	pair := DirectedNodePair{
-		From: fromNode,
-		To:   toNode,
-	}
-	lastSecondChance, ok := m.lastSecondChance[pair]
-
-	// If the channel hasn't already be given a second chance or its last
-	// second chance was long ago, we give it another chance.
-	if !ok || timestamp.Sub(lastSecondChance) > minSecondChanceInterval {
-		m.lastSecondChance[pair] = timestamp
-
-		log.Debugf("Second chance granted for %v->%v", fromNode, toNode)
-
-		return true
-	}
-
-	// Otherwise penalize the channel, because we don't allow channel
-	// updates that are that frequent. This is to prevent nodes from keeping
-	// us busy by continuously sending new channel updates.
-	log.Debugf("Second chance denied for %v->%v, remaining interval: %v",
-		fromNode, toNode, timestamp.Sub(lastSecondChance))
-
-	return false
-}
-
 // GetHistorySnapshot takes a snapshot from the current mission control state
 // and actual probability estimates.
 func (m *missionControlState) getSnapshot() *MissionControlSnapshot {

routing/missioncontrol_test.go

@@ -202,23 +202,3 @@ func TestMissionControl(t *testing.T) {
 	// Test reporting a success.
 	ctx.reportSuccess()
 }
-
-// TestMissionControlChannelUpdate tests that the first channel update is not
-// penalizing the channel yet.
-func TestMissionControlChannelUpdate(t *testing.T) {
-	ctx := createMcTestContext(t)
-
-	// Report a policy related failure. Because it is the first, we don't
-	// expect a penalty.
-	ctx.reportFailure(
-		0, lnwire.NewFeeInsufficient(0, lnwire.ChannelUpdate{}),
-	)
-	ctx.expectP(100, testAprioriHopProbability)
-
-	// Report another failure for the same channel. We expect it to be
-	// pruned.
-	ctx.reportFailure(
-		0, lnwire.NewFeeInsufficient(0, lnwire.ChannelUpdate{}),
-	)
-	ctx.expectP(100, 0)
-}

routing/result_interpretation.go

@@ -67,11 +67,6 @@ type interpretedResult struct {
 	// sense to start another payment attempt. It will contain the reason
 	// why.
 	finalFailureReason *channeldb.FailureReason
-
-	// policyFailure is set to a node pair if there is a policy failure on
-	// that connection. This is used to control the second chance logic for
-	// policy failures.
-	policyFailure *DirectedNodePair
 }
 
 // interpretResult interprets a payment outcome and returns an object that
@@ -338,14 +333,6 @@ func (i *interpretedResult) processPaymentOutcomeIntermediate(
 	// Some implementations use this error when the next hop is offline, so we
 	// do the same as FailUnknownNextPeer and also process the channel update.
 	case *lnwire.FailChannelDisabled:
-
-		// Set the node pair for which a channel update may be out of
-		// date. The second chance logic uses the policyFailure field.
-		i.policyFailure = &DirectedNodePair{
-			From: route.Hops[errorSourceIdx-1].PubKeyBytes,
-			To:   route.Hops[errorSourceIdx].PubKeyBytes,
-		}
-
 		reportOutgoing()
 
 		// All nodes up to the failing pair must have forwarded
@@ -368,13 +355,6 @@ func (i *interpretedResult) processPaymentOutcomeIntermediate(
 		*lnwire.FailFeeInsufficient,
 		*lnwire.FailIncorrectCltvExpiry:
 
-		// Set the node pair for which a channel update may be out of
-		// date. The second chance logic uses the policyFailure field.
-		i.policyFailure = &DirectedNodePair{
-			From: route.Hops[errorSourceIdx-1].PubKeyBytes,
-			To:   route.Hops[errorSourceIdx].PubKeyBytes,
-		}
-
 		// We report incoming channel. If a second pair is granted in
 		// mission control, this report is ignored.
 		reportIncoming()

routing/result_interpretation_test.go

@@ -57,11 +57,6 @@ func getTestPair(from, to int) DirectedNodePair {
 	return NewDirectedNodePair(hops[from], hops[to])
 }
 
-func getPolicyFailure(from, to int) *DirectedNodePair {
-	pair := getTestPair(from, to)
-	return &pair
-}
-
 type resultTestCase struct {
 	name          string
 	route         *route.Route
@@ -207,7 +202,6 @@ var resultTestCases = []resultTestCase{
 				getTestPair(1, 2): {},
 				getTestPair(2, 1): {},
 			},
-			policyFailure: getPolicyFailure(2, 3),
 		},
 	},
 
@@ -363,7 +357,6 @@ var resultTestCases = []resultTestCase{
 				getTestPair(2, 1): failPairResult(0),
 				getTestPair(0, 1): successPairResult(100),
 			},
-			policyFailure: getPolicyFailure(1, 2),
 		},
 	},
 }