routing+routerrpc: expose mission control state over rpc

This commit exposes mission control state for rpc for development
purposes.

routing/missioncontrol.go

@@ -84,6 +84,48 @@ type channelHistory struct {
 	minPenalizeAmt lnwire.MilliSatoshi
 }
 
+// MissionControlSnapshot contains a snapshot of the current state of mission
+// control.
+type MissionControlSnapshot struct {
+	// Nodes contains the per node information of this snapshot.
+	Nodes []MissionControlNodeSnapshot
+}
+
+// MissionControlNodeSnapshot contains a snapshot of the current node state in
+// mission control.
+type MissionControlNodeSnapshot struct {
+	// Node pubkey.
+	Node route.Vertex
+
+	// Lastfail is the time of last failure, if any.
+	LastFail *time.Time
+
+	// Channels is a list of channels for which specific information is
+	// logged.
+	Channels []MissionControlChannelSnapshot
+
+	// OtherChanSuccessProb is the success probability for channels not in
+	// the Channels slice.
+	OtherChanSuccessProb float64
+}
+
+// MissionControlChannelSnapshot contains a snapshot of the current channel
+// state in mission control.
+type MissionControlChannelSnapshot struct {
+	// ChannelID is the short channel id of the snapshot.
+	ChannelID uint64
+
+	// LastFail is the time of last failure.
+	LastFail time.Time
+
+	// MinPenalizeAmt is the minimum amount for which the channel will be
+	// penalized.
+	MinPenalizeAmt lnwire.MilliSatoshi
+
+	// SuccessProb is the success probability estimation for this channel.
+	SuccessProb float64
+}
+
 // NewMissionControl returns a new instance of missionControl.
 //
 // TODO(roasbeef): persist memory
@@ -358,3 +400,55 @@ func (m *MissionControl) reportEdgeFailure(failedEdge edge,
 		minPenalizeAmt: minPenalizeAmt,
 	}
 }
+
+// GetHistorySnapshot takes a snapshot from the current mission control state
+// and actual probability estimates.
+func (m *MissionControl) GetHistorySnapshot() *MissionControlSnapshot {
+	m.Lock()
+	defer m.Unlock()
+
+	log.Debugf("Requesting history snapshot from mission control: "+
+		"node_count=%v", len(m.history))
+
+	nodes := make([]MissionControlNodeSnapshot, 0, len(m.history))
+
+	for v, h := range m.history {
+		channelSnapshot := make([]MissionControlChannelSnapshot, 0,
+			len(h.channelLastFail),
+		)
+
+		for id, lastFail := range h.channelLastFail {
+			// Show probability assuming amount meets min
+			// penalization amount.
+			prob := m.getEdgeProbabilityForNode(
+				h, id, lastFail.minPenalizeAmt,
+			)
+
+			channelSnapshot = append(channelSnapshot,
+				MissionControlChannelSnapshot{
+					ChannelID:      id,
+					LastFail:       lastFail.lastFail,
+					MinPenalizeAmt: lastFail.minPenalizeAmt,
+					SuccessProb:    prob,
+				},
+			)
+		}
+
+		otherProb := m.getEdgeProbabilityForNode(h, 0, 0)
+
+		nodes = append(nodes,
+			MissionControlNodeSnapshot{
+				Node:                 v,
+				LastFail:             h.lastFail,
+				OtherChanSuccessProb: otherProb,
+				Channels:             channelSnapshot,
+			},
+		)
+	}
+
+	snapshot := MissionControlSnapshot{
+		Nodes: nodes,
+	}
+
+	return &snapshot
+}

routing/missioncontrol_test.go

@@ -64,4 +64,14 @@ func TestMissionControl(t *testing.T) {
 	// to zero.
 	mc.reportVertexFailure(testNode)
 	expectP(1000, 0)
+
+	// Check whether history snapshot looks sane.
+	history := mc.GetHistorySnapshot()
+	if len(history.Nodes) != 1 {
+		t.Fatal("unexpected number of nodes")
+	}
+
+	if len(history.Nodes[0].Channels) != 1 {
+		t.Fatal("unexpected number of channels")
+	}
 }