15561477203

Committed 10 Jun 2025 01:54PM UTC coverage: 58.351% (-10.1%) from 68.487%

Build # 15561477203

Build Type

Pull #9356

github

Committed by

web-flow

Commit Message

Merge 6440b25db into c6d6d4c0b

Pull Request Pull Request #9356: lnrpc: add incoming/outgoing channel ids filter to forwarding history request

Run Details

33 of 36 new or added lines in 2 files covered. (91.67%)

28366 existing lines in 455 files now uncovered.

97715 of 167461 relevant lines covered (58.35%)

1.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

63.17

/graph/db/graph.go

package graphdb

import (
        "errors"
        "fmt"
        "sync"
        "sync/atomic"
        "testing"
        "time"

        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/wire"
        "github.com/lightningnetwork/lnd/batch"
        "github.com/lightningnetwork/lnd/graph/db/models"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/routing/route"
        "github.com/stretchr/testify/require"
)

// ErrChanGraphShuttingDown indicates that the ChannelGraph has shutdown or is
// busy shutting down.
var ErrChanGraphShuttingDown = fmt.Errorf("ChannelGraph shutting down")

// ChannelGraph is a layer above the graph's CRUD layer.
//
// NOTE: currently, this is purely a pass-through layer directly to the backing
// KVStore. Upcoming commits will move the graph cache out of the KVStore and
// into this layer so that the KVStore is only responsible for CRUD operations.
type ChannelGraph struct {
        started atomic.Bool
        stopped atomic.Bool

        graphCache *GraphCache

        V1Store
        *topologyManager

        quit chan struct{}
        wg   sync.WaitGroup
}

// NewChannelGraph creates a new ChannelGraph instance with the given backend.
func NewChannelGraph(v1Store V1Store,
        options ...ChanGraphOption) (*ChannelGraph, error) {

        opts := defaultChanGraphOptions()
        for _, o := range options {
                o(opts)
        }

        g := &ChannelGraph{
                V1Store:         v1Store,
                topologyManager: newTopologyManager(),
                quit:            make(chan struct{}),
        }

        // The graph cache can be turned off (e.g. for mobile users) for a
        // speed/memory usage tradeoff.
        if opts.useGraphCache {
                g.graphCache = NewGraphCache(opts.preAllocCacheNumNodes)
        }

        return g, nil
}

// Start kicks off any goroutines required for the ChannelGraph to function.
// If the graph cache is enabled, then it will be populated with the contents of
// the database.
func (c *ChannelGraph) Start() error {
        if !c.started.CompareAndSwap(false, true) {
                return nil
        }
        log.Debugf("ChannelGraph starting")
        defer log.Debug("ChannelGraph started")

        if c.graphCache != nil {
                if err := c.populateCache(); err != nil {
                        return fmt.Errorf("could not populate the graph "+
                                "cache: %w", err)
                }
        }

        c.wg.Add(1)
        go c.handleTopologySubscriptions()

        return nil
}

// Stop signals any active goroutines for a graceful closure.
func (c *ChannelGraph) Stop() error {
        if !c.stopped.CompareAndSwap(false, true) {
                return nil
        }

        log.Debugf("ChannelGraph shutting down...")
        defer log.Debug("ChannelGraph shutdown complete")

        close(c.quit)
        c.wg.Wait()

        return nil
}

// handleTopologySubscriptions ensures that topology client subscriptions,
// subscription cancellations and topology notifications are handled
// synchronously.
//
// NOTE: this MUST be run in a goroutine.
func (c *ChannelGraph) handleTopologySubscriptions() {
        defer c.wg.Done()

        for {
                select {
                // A new fully validated topology update has just arrived.
                // We'll notify any registered clients.
                case update := <-c.topologyUpdate:
                        // TODO(elle): change topology handling to be handled
                        // synchronously so that we can guarantee the order of
                        // notification delivery.
                        c.wg.Add(1)
                        go c.handleTopologyUpdate(update)

                        // TODO(roasbeef): remove all unconnected vertexes
                        // after N blocks pass with no corresponding
                        // announcements.

                // A new notification client update has arrived. We're either
                // gaining a new client, or cancelling notifications for an
                // existing client.
                case ntfnUpdate := <-c.ntfnClientUpdates:
                        clientID := ntfnUpdate.clientID

                        if ntfnUpdate.cancel {
                                client, ok := c.topologyClients.LoadAndDelete(
                                        clientID,
                                )
                                if ok {
                                        close(client.exit)
                                        client.wg.Wait()

                                        close(client.ntfnChan)
                                }

                                continue
                        }

                        c.topologyClients.Store(clientID, &topologyClient{
                                ntfnChan: ntfnUpdate.ntfnChan,
                                exit:     make(chan struct{}),
                        })

                case <-c.quit:
                        return
                }
        }
}

// populateCache loads the entire channel graph into the in-memory graph cache.
//
// NOTE: This should only be called if the graphCache has been constructed.
func (c *ChannelGraph) populateCache() error {
        startTime := time.Now()
        log.Info("Populating in-memory channel graph, this might take a " +
                "while...")

        err := c.V1Store.ForEachNodeCacheable(func(node route.Vertex,
                features *lnwire.FeatureVector) error {

                c.graphCache.AddNodeFeatures(node, features)

                return nil
        })
        if err != nil {
                return err
        }

        err = c.V1Store.ForEachChannel(func(info *models.ChannelEdgeInfo,
                policy1, policy2 *models.ChannelEdgePolicy) error {

                c.graphCache.AddChannel(info, policy1, policy2)

                return nil
        })
        if err != nil {
                return err
        }

        log.Infof("Finished populating in-memory channel graph (took %v, %s)",
                time.Since(startTime), c.graphCache.Stats())

        return nil
}

// ForEachNodeDirectedChannel iterates through all channels of a given node,
// executing the passed callback on the directed edge representing the channel
// and its incoming policy. If the callback returns an error, then the iteration
// is halted with the error propagated back up to the caller. If the graphCache
// is available, then it will be used to retrieve the node's channels instead
// of the database.
//
// Unknown policies are passed into the callback as nil values.
//
// NOTE: this is part of the graphdb.NodeTraverser interface.
func (c *ChannelGraph) ForEachNodeDirectedChannel(node route.Vertex,
        cb func(channel *DirectedChannel) error) error {

        if c.graphCache != nil {
                return c.graphCache.ForEachChannel(node, cb)
        }

        return c.V1Store.ForEachNodeDirectedChannel(node, cb)
}

// FetchNodeFeatures returns the features of the given node. If no features are
// known for the node, an empty feature vector is returned.
// If the graphCache is available, then it will be used to retrieve the node's
// features instead of the database.
//
// NOTE: this is part of the graphdb.NodeTraverser interface.
func (c *ChannelGraph) FetchNodeFeatures(node route.Vertex) (
        *lnwire.FeatureVector, error) {

        if c.graphCache != nil {
                return c.graphCache.GetFeatures(node), nil
        }

        return c.V1Store.FetchNodeFeatures(node)
}

// GraphSession will provide the call-back with access to a NodeTraverser
// instance which can be used to perform queries against the channel graph. If
// the graph cache is not enabled, then the call-back will be provided with
// access to the graph via a consistent read-only transaction.
func (c *ChannelGraph) GraphSession(cb func(graph NodeTraverser) error) error {
        if c.graphCache != nil {
                return cb(c)
        }

        return c.V1Store.GraphSession(cb)
}

// ForEachNodeCached iterates through all the stored vertices/nodes in the
// graph, executing the passed callback with each node encountered.
//
// NOTE: The callback contents MUST not be modified.
func (c *ChannelGraph) ForEachNodeCached(cb func(node route.Vertex,
        chans map[uint64]*DirectedChannel) error) error {

        if c.graphCache != nil {
                return c.graphCache.ForEachNode(cb)
        }

        return c.V1Store.ForEachNodeCached(cb)
}

// AddLightningNode adds a vertex/node to the graph database. If the node is not
// in the database from before, this will add a new, unconnected one to the
// graph. If it is present from before, this will update that node's
// information. Note that this method is expected to only be called to update an
// already present node from a node announcement, or to insert a node found in a
// channel update.
func (c *ChannelGraph) AddLightningNode(node *models.LightningNode,
        op ...batch.SchedulerOption) error {

        err := c.V1Store.AddLightningNode(node, op...)
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                c.graphCache.AddNodeFeatures(
                        node.PubKeyBytes, node.Features,
                )
        }

        select {
        case c.topologyUpdate <- node:
        case <-c.quit:
                return ErrChanGraphShuttingDown
        }

        return nil
}

// DeleteLightningNode starts a new database transaction to remove a vertex/node
// from the database according to the node's public key.
func (c *ChannelGraph) DeleteLightningNode(nodePub route.Vertex) error {
        err := c.V1Store.DeleteLightningNode(nodePub)
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                c.graphCache.RemoveNode(nodePub)
        }

        return nil
}

// AddChannelEdge adds a new (undirected, blank) edge to the graph database. An
// undirected edge from the two target nodes are created. The information stored
// denotes the static attributes of the channel, such as the channelID, the keys
// involved in creation of the channel, and the set of features that the channel
// supports. The chanPoint and chanID are used to uniquely identify the edge
// globally within the database.
func (c *ChannelGraph) AddChannelEdge(edge *models.ChannelEdgeInfo,
        op ...batch.SchedulerOption) error {

        err := c.V1Store.AddChannelEdge(edge, op...)
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                c.graphCache.AddChannel(edge, nil, nil)
        }

        select {
        case c.topologyUpdate <- edge:
        case <-c.quit:
                return ErrChanGraphShuttingDown
        }

        return nil
}

// MarkEdgeLive clears an edge from our zombie index, deeming it as live.
// If the cache is enabled, the edge will be added back to the graph cache if
// we still have a record of this channel in the DB.
func (c *ChannelGraph) MarkEdgeLive(chanID uint64) error {
        err := c.V1Store.MarkEdgeLive(chanID)
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                // We need to add the channel back into our graph cache,
                // otherwise we won't use it for path finding.
                infos, err := c.V1Store.FetchChanInfos([]uint64{chanID})
                if err != nil {
                        return err
                }

                if len(infos) == 0 {
                        return nil
                }

                info := infos[0]

                c.graphCache.AddChannel(info.Info, info.Policy1, info.Policy2)
        }

        return nil
}

// DeleteChannelEdges removes edges with the given channel IDs from the
// database and marks them as zombies. This ensures that we're unable to re-add
// it to our database once again. If an edge does not exist within the
// database, then ErrEdgeNotFound will be returned. If strictZombiePruning is
// true, then when we mark these edges as zombies, we'll set up the keys such
// that we require the node that failed to send the fresh update to be the one
// that resurrects the channel from its zombie state. The markZombie bool
// denotes whether to mark the channel as a zombie.
func (c *ChannelGraph) DeleteChannelEdges(strictZombiePruning, markZombie bool,
        chanIDs ...uint64) error {

        infos, err := c.V1Store.DeleteChannelEdges(
                strictZombiePruning, markZombie, chanIDs...,
        )
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                for _, info := range infos {
                        c.graphCache.RemoveChannel(
                                info.NodeKey1Bytes, info.NodeKey2Bytes,
                                info.ChannelID,
                        )
                }
        }

        return err
}

// DisconnectBlockAtHeight is used to indicate that the block specified
// by the passed height has been disconnected from the main chain. This
// will "rewind" the graph back to the height below, deleting channels
// that are no longer confirmed from the graph. The prune log will be
// set to the last prune height valid for the remaining chain.
// Channels that were removed from the graph resulting from the
// disconnected block are returned.
func (c *ChannelGraph) DisconnectBlockAtHeight(height uint32) (
        []*models.ChannelEdgeInfo, error) {

        edges, err := c.V1Store.DisconnectBlockAtHeight(height)
        if err != nil {
                return nil, err
        }

        if c.graphCache != nil {
                for _, edge := range edges {
                        c.graphCache.RemoveChannel(
                                edge.NodeKey1Bytes, edge.NodeKey2Bytes,
                                edge.ChannelID,
                        )
                }
        }

        return edges, nil
}

// PruneGraph prunes newly closed channels from the channel graph in response
// to a new block being solved on the network. Any transactions which spend the
// funding output of any known channels within he graph will be deleted.
// Additionally, the "prune tip", or the last block which has been used to
// prune the graph is stored so callers can ensure the graph is fully in sync
// with the current UTXO state. A slice of channels that have been closed by
// the target block are returned if the function succeeds without error.
func (c *ChannelGraph) PruneGraph(spentOutputs []*wire.OutPoint,
        blockHash *chainhash.Hash, blockHeight uint32) (
        []*models.ChannelEdgeInfo, error) {

        edges, nodes, err := c.V1Store.PruneGraph(
                spentOutputs, blockHash, blockHeight,
        )
        if err != nil {
                return nil, err
        }

        if c.graphCache != nil {
                for _, edge := range edges {
                        c.graphCache.RemoveChannel(
                                edge.NodeKey1Bytes, edge.NodeKey2Bytes,
                                edge.ChannelID,
                        )
                }

                for _, node := range nodes {
                        c.graphCache.RemoveNode(node)
                }

                log.Debugf("Pruned graph, cache now has %s",
                        c.graphCache.Stats())
        }

        if len(edges) != 0 {
                // Notify all currently registered clients of the newly closed
                // channels.
                closeSummaries := createCloseSummaries(
                        blockHeight, edges...,
                )

                select {
                case c.topologyUpdate <- closeSummaries:
                case <-c.quit:
                        return nil, ErrChanGraphShuttingDown
                }
        }

        return edges, nil
}

// PruneGraphNodes is a garbage collection method which attempts to prune out
// any nodes from the channel graph that are currently unconnected. This ensure
// that we only maintain a graph of reachable nodes. In the event that a pruned
// node gains more channels, it will be re-added back to the graph.
func (c *ChannelGraph) PruneGraphNodes() error {
        nodes, err := c.V1Store.PruneGraphNodes()
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                for _, node := range nodes {
                        c.graphCache.RemoveNode(node)
                }
        }

        return nil
}

// FilterKnownChanIDs takes a set of channel IDs and return the subset of chan
// ID's that we don't know and are not known zombies of the passed set. In other
// words, we perform a set difference of our set of chan ID's and the ones
// passed in. This method can be used by callers to determine the set of
// channels another peer knows of that we don't.
func (c *ChannelGraph) FilterKnownChanIDs(chansInfo []ChannelUpdateInfo,
        isZombieChan func(time.Time, time.Time) bool) ([]uint64, error) {

        unknown, knownZombies, err := c.V1Store.FilterKnownChanIDs(chansInfo)
        if err != nil {
                return nil, err
        }

        for _, info := range knownZombies {
                // TODO(ziggie): Make sure that for the strict pruning case we
                // compare the pubkeys and whether the right timestamp is not
                // older than the `ChannelPruneExpiry`.
                //
                // NOTE: The timestamp data has no verification attached to it
                // in the `ReplyChannelRange` msg so we are trusting this data
                // at this point. However it is not critical because we are just
                // removing the channel from the db when the timestamps are more
                // recent. During the querying of the gossip msg verification
                // happens as usual. However we should start punishing peers
                // when they don't provide us honest data ?
                isStillZombie := isZombieChan(
                        info.Node1UpdateTimestamp, info.Node2UpdateTimestamp,
                )

                if isStillZombie {
                        continue
                }

                // If we have marked it as a zombie but the latest update
                // timestamps could bring it back from the dead, then we mark it
                // alive, and we let it be added to the set of IDs to query our
                // peer for.
                err := c.V1Store.MarkEdgeLive(
                        info.ShortChannelID.ToUint64(),
                )
                // Since there is a chance that the edge could have been marked
                // as "live" between the FilterKnownChanIDs call and the
                // MarkEdgeLive call, we ignore the error if the edge is already
                // marked as live.
                if err != nil && !errors.Is(err, ErrZombieEdgeNotFound) {
                        return nil, err
                }
        }

        return unknown, nil
}

// MarkEdgeZombie attempts to mark a channel identified by its channel ID as a
// zombie. This method is used on an ad-hoc basis, when channels need to be
// marked as zombies outside the normal pruning cycle.
func (c *ChannelGraph) MarkEdgeZombie(chanID uint64,
        pubKey1, pubKey2 [33]byte) error {

        err := c.V1Store.MarkEdgeZombie(chanID, pubKey1, pubKey2)
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                c.graphCache.RemoveChannel(pubKey1, pubKey2, chanID)
        }

        return nil
}

// UpdateEdgePolicy updates the edge routing policy for a single directed edge
// within the database for the referenced channel. The `flags` attribute within
// the ChannelEdgePolicy determines which of the directed edges are being
// updated. If the flag is 1, then the first node's information is being
// updated, otherwise it's the second node's information. The node ordering is
// determined by the lexicographical ordering of the identity public keys of the
// nodes on either side of the channel.
func (c *ChannelGraph) UpdateEdgePolicy(edge *models.ChannelEdgePolicy,
        op ...batch.SchedulerOption) error {

        from, to, err := c.V1Store.UpdateEdgePolicy(edge, op...)
        if err != nil {
                return err
        }

        if c.graphCache != nil {
                var isUpdate1 bool
                if edge.ChannelFlags&lnwire.ChanUpdateDirection == 0 {
                        isUpdate1 = true
                }

                c.graphCache.UpdatePolicy(edge, from, to, isUpdate1)
        }

        select {
        case c.topologyUpdate <- edge:
        case <-c.quit:
                return ErrChanGraphShuttingDown
        }

        return nil
}

// MakeTestGraphNew creates a new instance of the ChannelGraph for testing
// purposes. The backing V1Store implementation depends on the version of
// NewTestDB included in the current build.
//
// NOTE: this is currently unused, but is left here for future use to show how
// NewTestDB can be used. As the SQL implementation of the V1Store is
// implemented, unit tests will be switched to use this function instead of
// the existing MakeTestGraph helper. Once only this function is used, the
// existing MakeTestGraph function will be removed and this one will be renamed.
func MakeTestGraphNew(t testing.TB,
        opts ...ChanGraphOption) *ChannelGraph {

        t.Helper()

        store := NewTestDB(t)

        graph, err := NewChannelGraph(store, opts...)
        require.NoError(t, err)
        require.NoError(t, graph.Start())

        t.Cleanup(func() {
                require.NoError(t, graph.Stop())
        })

        return graph
}

1	package graphdb
2
3	import (
4	"errors"
5	"fmt"
6	"sync"
7	"sync/atomic"
8	"testing"
9	"time"
10
11	"github.com/btcsuite/btcd/chaincfg/chainhash"
12	"github.com/btcsuite/btcd/wire"
13	"github.com/lightningnetwork/lnd/batch"
14	"github.com/lightningnetwork/lnd/graph/db/models"
15	"github.com/lightningnetwork/lnd/lnwire"
16	"github.com/lightningnetwork/lnd/routing/route"
17	"github.com/stretchr/testify/require"
18	)
19
20	// ErrChanGraphShuttingDown indicates that the ChannelGraph has shutdown or is
21	// busy shutting down.
22	var ErrChanGraphShuttingDown = fmt.Errorf("ChannelGraph shutting down")
23
24	// ChannelGraph is a layer above the graph's CRUD layer.
25	//
26	// NOTE: currently, this is purely a pass-through layer directly to the backing
27	// KVStore. Upcoming commits will move the graph cache out of the KVStore and
28	// into this layer so that the KVStore is only responsible for CRUD operations.
29	type ChannelGraph struct {
30	started atomic.Bool
31	stopped atomic.Bool
32
33	graphCache *GraphCache
34
35	V1Store
36	*topologyManager
37
38	quit chan struct{}
39	wg sync.WaitGroup
40	}
41
42	// NewChannelGraph creates a new ChannelGraph instance with the given backend.
43	func NewChannelGraph(v1Store V1Store,
44	options ...ChanGraphOption) (*ChannelGraph, error) {	3✔
45		3✔
46	opts := defaultChanGraphOptions()	3✔
47	for _, o := range options {	6✔
48	o(opts)	3✔
49	}	3✔
50
51	g := &ChannelGraph{	3✔
52	V1Store: v1Store,	3✔
53	topologyManager: newTopologyManager(),	3✔
54	quit: make(chan struct{}),	3✔
55	}	3✔
56		3✔
57	// The graph cache can be turned off (e.g. for mobile users) for a	3✔
58	// speed/memory usage tradeoff.	3✔
59	if opts.useGraphCache {	6✔
60	g.graphCache = NewGraphCache(opts.preAllocCacheNumNodes)	3✔
61	}	3✔
62
63	return g, nil	3✔
64	}
65
66	// Start kicks off any goroutines required for the ChannelGraph to function.
67	// If the graph cache is enabled, then it will be populated with the contents of
68	// the database.
69	func (c *ChannelGraph) Start() error {	3✔
70	if !c.started.CompareAndSwap(false, true) {	3✔
UNCOV 71	return nil	×
UNCOV 72	}	×
73	log.Debugf("ChannelGraph starting")	3✔
74	defer log.Debug("ChannelGraph started")	3✔
75		3✔
76	if c.graphCache != nil {	6✔
77	if err := c.populateCache(); err != nil {	3✔
78	return fmt.Errorf("could not populate the graph "+	×
79	"cache: %w", err)	×
80	}	×
81	}
82
83	c.wg.Add(1)	3✔
84	go c.handleTopologySubscriptions()	3✔
85		3✔
86	return nil	3✔
87	}
88
89	// Stop signals any active goroutines for a graceful closure.
90	func (c *ChannelGraph) Stop() error {	3✔
91	if !c.stopped.CompareAndSwap(false, true) {	3✔
UNCOV 92	return nil	×
UNCOV 93	}	×
94
95	log.Debugf("ChannelGraph shutting down...")	3✔
96	defer log.Debug("ChannelGraph shutdown complete")	3✔
97		3✔
98	close(c.quit)	3✔
99	c.wg.Wait()	3✔
100		3✔
101	return nil	3✔
102	}
103
104	// handleTopologySubscriptions ensures that topology client subscriptions,
105	// subscription cancellations and topology notifications are handled
106	// synchronously.
107	//
108	// NOTE: this MUST be run in a goroutine.
109	func (c *ChannelGraph) handleTopologySubscriptions() {	3✔
110	defer c.wg.Done()	3✔
111		3✔
112	for {	6✔
113	select {	3✔
114	// A new fully validated topology update has just arrived.
115	// We'll notify any registered clients.
116	case update := <-c.topologyUpdate:	3✔
117	// TODO(elle): change topology handling to be handled	3✔
118	// synchronously so that we can guarantee the order of	3✔
119	// notification delivery.	3✔
120	c.wg.Add(1)	3✔
121	go c.handleTopologyUpdate(update)	3✔
122
123	// TODO(roasbeef): remove all unconnected vertexes
124	// after N blocks pass with no corresponding
125	// announcements.
126
127	// A new notification client update has arrived. We're either
128	// gaining a new client, or cancelling notifications for an
129	// existing client.
130	case ntfnUpdate := <-c.ntfnClientUpdates:	3✔
131	clientID := ntfnUpdate.clientID	3✔
132		3✔
133	if ntfnUpdate.cancel {	6✔
134	client, ok := c.topologyClients.LoadAndDelete(	3✔
135	clientID,	3✔
136	)	3✔
137	if ok {	6✔
138	close(client.exit)	3✔
139	client.wg.Wait()	3✔
140		3✔
141	close(client.ntfnChan)	3✔
142	}	3✔
143
144	continue	3✔
145	}
146
147	c.topologyClients.Store(clientID, &topologyClient{	3✔
148	ntfnChan: ntfnUpdate.ntfnChan,	3✔
149	exit: make(chan struct{}),	3✔
150	})	3✔
151
152	case <-c.quit:	3✔
153	return	3✔
154	}
155	}
156	}
157
158	// populateCache loads the entire channel graph into the in-memory graph cache.
159	//
160	// NOTE: This should only be called if the graphCache has been constructed.
161	func (c *ChannelGraph) populateCache() error {	3✔
162	startTime := time.Now()	3✔
163	log.Info("Populating in-memory channel graph, this might take a " +	3✔
164	"while...")	3✔
165		3✔
166	err := c.V1Store.ForEachNodeCacheable(func(node route.Vertex,	3✔
167	features *lnwire.FeatureVector) error {	6✔
168		3✔
169	c.graphCache.AddNodeFeatures(node, features)	3✔
170		3✔
171	return nil	3✔
172	})	3✔
173	if err != nil {	3✔
174	return err	×
175	}	×
176
177	err = c.V1Store.ForEachChannel(func(info *models.ChannelEdgeInfo,	3✔
178	policy1, policy2 *models.ChannelEdgePolicy) error {	6✔
179		3✔
180	c.graphCache.AddChannel(info, policy1, policy2)	3✔
181		3✔
182	return nil	3✔
183	})	3✔
184	if err != nil {	3✔
185	return err	×
186	}	×
187
188	log.Infof("Finished populating in-memory channel graph (took %v, %s)",	3✔
189	time.Since(startTime), c.graphCache.Stats())	3✔
190		3✔
191	return nil	3✔
192	}
193
194	// ForEachNodeDirectedChannel iterates through all channels of a given node,
195	// executing the passed callback on the directed edge representing the channel
196	// and its incoming policy. If the callback returns an error, then the iteration
197	// is halted with the error propagated back up to the caller. If the graphCache
198	// is available, then it will be used to retrieve the node's channels instead
199	// of the database.
200	//
201	// Unknown policies are passed into the callback as nil values.
202	//
203	// NOTE: this is part of the graphdb.NodeTraverser interface.
204	func (c *ChannelGraph) ForEachNodeDirectedChannel(node route.Vertex,
205	cb func(channel *DirectedChannel) error) error {	3✔
206		3✔
207	if c.graphCache != nil {	6✔
208	return c.graphCache.ForEachChannel(node, cb)	3✔
209	}	3✔
210
211	return c.V1Store.ForEachNodeDirectedChannel(node, cb)	3✔
212	}
213
214	// FetchNodeFeatures returns the features of the given node. If no features are
215	// known for the node, an empty feature vector is returned.
216	// If the graphCache is available, then it will be used to retrieve the node's
217	// features instead of the database.
218	//
219	// NOTE: this is part of the graphdb.NodeTraverser interface.
220	func (c *ChannelGraph) FetchNodeFeatures(node route.Vertex) (
221	*lnwire.FeatureVector, error) {	3✔
222		3✔
223	if c.graphCache != nil {	6✔
224	return c.graphCache.GetFeatures(node), nil	3✔
225	}	3✔
226
227	return c.V1Store.FetchNodeFeatures(node)	3✔
228	}
229
230	// GraphSession will provide the call-back with access to a NodeTraverser
231	// instance which can be used to perform queries against the channel graph. If
232	// the graph cache is not enabled, then the call-back will be provided with
233	// access to the graph via a consistent read-only transaction.
234	func (c *ChannelGraph) GraphSession(cb func(graph NodeTraverser) error) error {	3✔
235	if c.graphCache != nil {	6✔
236	return cb(c)	3✔
237	}	3✔
238
UNCOV 239	return c.V1Store.GraphSession(cb)	×
240	}
241
242	// ForEachNodeCached iterates through all the stored vertices/nodes in the
243	// graph, executing the passed callback with each node encountered.
244	//
245	// NOTE: The callback contents MUST not be modified.
246	func (c *ChannelGraph) ForEachNodeCached(cb func(node route.Vertex,
UNCOV 247	chans map[uint64]*DirectedChannel) error) error {	×
UNCOV 248		×
UNCOV 249	if c.graphCache != nil {	×
250	return c.graphCache.ForEachNode(cb)	×
251	}	×
252
UNCOV 253	return c.V1Store.ForEachNodeCached(cb)	×
254	}
255
256	// AddLightningNode adds a vertex/node to the graph database. If the node is not
257	// in the database from before, this will add a new, unconnected one to the
258	// graph. If it is present from before, this will update that node's
259	// information. Note that this method is expected to only be called to update an
260	// already present node from a node announcement, or to insert a node found in a
261	// channel update.
262	func (c ChannelGraph) AddLightningNode(node models.LightningNode,
263	op ...batch.SchedulerOption) error {	3✔
264		3✔
265	err := c.V1Store.AddLightningNode(node, op...)	3✔
266	if err != nil {	3✔
267	return err	×
268	}	×
269
270	if c.graphCache != nil {	6✔
271	c.graphCache.AddNodeFeatures(	3✔
272	node.PubKeyBytes, node.Features,	3✔
273	)	3✔
274	}	3✔
275
276	select {	3✔
277	case c.topologyUpdate <- node:	3✔
278	case <-c.quit:	×
279	return ErrChanGraphShuttingDown	×
280	}
281
282	return nil	3✔
283	}
284
285	// DeleteLightningNode starts a new database transaction to remove a vertex/node
286	// from the database according to the node's public key.
UNCOV 287	func (c *ChannelGraph) DeleteLightningNode(nodePub route.Vertex) error {	×
UNCOV 288	err := c.V1Store.DeleteLightningNode(nodePub)	×
UNCOV 289	if err != nil {	×
UNCOV 290	return err	×
UNCOV 291	}	×
292
UNCOV 293	if c.graphCache != nil {	×
UNCOV 294	c.graphCache.RemoveNode(nodePub)	×
UNCOV 295	}	×
296
UNCOV 297	return nil	×
298	}
299
300	// AddChannelEdge adds a new (undirected, blank) edge to the graph database. An
301	// undirected edge from the two target nodes are created. The information stored
302	// denotes the static attributes of the channel, such as the channelID, the keys
303	// involved in creation of the channel, and the set of features that the channel
304	// supports. The chanPoint and chanID are used to uniquely identify the edge
305	// globally within the database.
306	func (c ChannelGraph) AddChannelEdge(edge models.ChannelEdgeInfo,
307	op ...batch.SchedulerOption) error {	3✔
308		3✔
309	err := c.V1Store.AddChannelEdge(edge, op...)	3✔
310	if err != nil {	3✔
UNCOV 311	return err	×
UNCOV 312	}	×
313
314	if c.graphCache != nil {	6✔
315	c.graphCache.AddChannel(edge, nil, nil)	3✔
316	}	3✔
317
318	select {	3✔
319	case c.topologyUpdate <- edge:	3✔
320	case <-c.quit:	×
321	return ErrChanGraphShuttingDown	×
322	}
323
324	return nil	3✔
325	}
326
327	// MarkEdgeLive clears an edge from our zombie index, deeming it as live.
328	// If the cache is enabled, the edge will be added back to the graph cache if
329	// we still have a record of this channel in the DB.
UNCOV 330	func (c *ChannelGraph) MarkEdgeLive(chanID uint64) error {	×
UNCOV 331	err := c.V1Store.MarkEdgeLive(chanID)	×
UNCOV 332	if err != nil {	×
UNCOV 333	return err	×
UNCOV 334	}	×
335
UNCOV 336	if c.graphCache != nil {	×
UNCOV 337	// We need to add the channel back into our graph cache,	×
UNCOV 338	// otherwise we won't use it for path finding.	×
UNCOV 339	infos, err := c.V1Store.FetchChanInfos([]uint64{chanID})	×
UNCOV 340	if err != nil {	×
341	return err	×
342	}	×
343
UNCOV 344	if len(infos) == 0 {	×
UNCOV 345	return nil	×
UNCOV 346	}	×
347
348	info := infos[0]	×
349		×
350	c.graphCache.AddChannel(info.Info, info.Policy1, info.Policy2)	×
351	}
352
353	return nil	×
354	}
355
356	// DeleteChannelEdges removes edges with the given channel IDs from the
357	// database and marks them as zombies. This ensures that we're unable to re-add
358	// it to our database once again. If an edge does not exist within the
359	// database, then ErrEdgeNotFound will be returned. If strictZombiePruning is
360	// true, then when we mark these edges as zombies, we'll set up the keys such
361	// that we require the node that failed to send the fresh update to be the one
362	// that resurrects the channel from its zombie state. The markZombie bool
363	// denotes whether to mark the channel as a zombie.
364	func (c *ChannelGraph) DeleteChannelEdges(strictZombiePruning, markZombie bool,
365	chanIDs ...uint64) error {	3✔
366		3✔
367	infos, err := c.V1Store.DeleteChannelEdges(	3✔
368	strictZombiePruning, markZombie, chanIDs...,	3✔
369	)	3✔
370	if err != nil {	3✔
UNCOV 371	return err	×
UNCOV 372	}	×
373
374	if c.graphCache != nil {	6✔
375	for _, info := range infos {	6✔
376	c.graphCache.RemoveChannel(	3✔
377	info.NodeKey1Bytes, info.NodeKey2Bytes,	3✔
378	info.ChannelID,	3✔
379	)	3✔
380	}	3✔
381	}
382
383	return err	3✔
384	}
385
386	// DisconnectBlockAtHeight is used to indicate that the block specified
387	// by the passed height has been disconnected from the main chain. This
388	// will "rewind" the graph back to the height below, deleting channels
389	// that are no longer confirmed from the graph. The prune log will be
390	// set to the last prune height valid for the remaining chain.
391	// Channels that were removed from the graph resulting from the
392	// disconnected block are returned.
393	func (c *ChannelGraph) DisconnectBlockAtHeight(height uint32) (
394	[]*models.ChannelEdgeInfo, error) {	2✔
395		2✔
396	edges, err := c.V1Store.DisconnectBlockAtHeight(height)	2✔
397	if err != nil {	2✔
398	return nil, err	×
399	}	×
400
401	if c.graphCache != nil {	4✔
402	for _, edge := range edges {	4✔
403	c.graphCache.RemoveChannel(	2✔
404	edge.NodeKey1Bytes, edge.NodeKey2Bytes,	2✔
405	edge.ChannelID,	2✔
406	)	2✔
407	}	2✔
408	}
409
410	return edges, nil	2✔
411	}
412
413	// PruneGraph prunes newly closed channels from the channel graph in response
414	// to a new block being solved on the network. Any transactions which spend the
415	// funding output of any known channels within he graph will be deleted.
416	// Additionally, the "prune tip", or the last block which has been used to
417	// prune the graph is stored so callers can ensure the graph is fully in sync
418	// with the current UTXO state. A slice of channels that have been closed by
419	// the target block are returned if the function succeeds without error.
420	func (c ChannelGraph) PruneGraph(spentOutputs []wire.OutPoint,
421	blockHash *chainhash.Hash, blockHeight uint32) (
422	[]*models.ChannelEdgeInfo, error) {	3✔
423		3✔
424	edges, nodes, err := c.V1Store.PruneGraph(	3✔
425	spentOutputs, blockHash, blockHeight,	3✔
426	)	3✔
427	if err != nil {	3✔
428	return nil, err	×
429	}	×
430
431	if c.graphCache != nil {	6✔
432	for _, edge := range edges {	6✔
433	c.graphCache.RemoveChannel(	3✔
434	edge.NodeKey1Bytes, edge.NodeKey2Bytes,	3✔
435	edge.ChannelID,	3✔
436	)	3✔
437	}	3✔
438
439	for _, node := range nodes {	6✔
440	c.graphCache.RemoveNode(node)	3✔
441	}	3✔
442
443	log.Debugf("Pruned graph, cache now has %s",	3✔
444	c.graphCache.Stats())	3✔
445	}
446
447	if len(edges) != 0 {	6✔
448	// Notify all currently registered clients of the newly closed	3✔
449	// channels.	3✔
450	closeSummaries := createCloseSummaries(	3✔
451	blockHeight, edges...,	3✔
452	)	3✔
453		3✔
454	select {	3✔
455	case c.topologyUpdate <- closeSummaries:	3✔
456	case <-c.quit:	×
457	return nil, ErrChanGraphShuttingDown	×
458	}
459	}
460
461	return edges, nil	3✔
462	}
463
464	// PruneGraphNodes is a garbage collection method which attempts to prune out
465	// any nodes from the channel graph that are currently unconnected. This ensure
466	// that we only maintain a graph of reachable nodes. In the event that a pruned
467	// node gains more channels, it will be re-added back to the graph.
468	func (c *ChannelGraph) PruneGraphNodes() error {	3✔
469	nodes, err := c.V1Store.PruneGraphNodes()	3✔
470	if err != nil {	3✔
471	return err	×
472	}	×
473
474	if c.graphCache != nil {	6✔
475	for _, node := range nodes {	3✔
UNCOV 476	c.graphCache.RemoveNode(node)	×
UNCOV 477	}	×
478	}
479
480	return nil	3✔
481	}
482
483	// FilterKnownChanIDs takes a set of channel IDs and return the subset of chan
484	// ID's that we don't know and are not known zombies of the passed set. In other
485	// words, we perform a set difference of our set of chan ID's and the ones
486	// passed in. This method can be used by callers to determine the set of
487	// channels another peer knows of that we don't.
488	func (c *ChannelGraph) FilterKnownChanIDs(chansInfo []ChannelUpdateInfo,
489	isZombieChan func(time.Time, time.Time) bool) ([]uint64, error) {	3✔
490		3✔
491	unknown, knownZombies, err := c.V1Store.FilterKnownChanIDs(chansInfo)	3✔
492	if err != nil {	3✔
493	return nil, err	×
494	}	×
495
496	for _, info := range knownZombies {	3✔
UNCOV 497	// TODO(ziggie): Make sure that for the strict pruning case we	×
UNCOV 498	// compare the pubkeys and whether the right timestamp is not	×
UNCOV 499	// older than the `ChannelPruneExpiry`.	×
UNCOV 500	//	×
UNCOV 501	// NOTE: The timestamp data has no verification attached to it	×
UNCOV 502	// in the `ReplyChannelRange` msg so we are trusting this data	×
UNCOV 503	// at this point. However it is not critical because we are just	×
UNCOV 504	// removing the channel from the db when the timestamps are more	×
UNCOV 505	// recent. During the querying of the gossip msg verification	×
UNCOV 506	// happens as usual. However we should start punishing peers	×
UNCOV 507	// when they don't provide us honest data ?	×
UNCOV 508	isStillZombie := isZombieChan(	×
UNCOV 509	info.Node1UpdateTimestamp, info.Node2UpdateTimestamp,	×
UNCOV 510	)	×
UNCOV 511		×
UNCOV 512	if isStillZombie {	×
UNCOV 513	continue	×
514	}
515
516	// If we have marked it as a zombie but the latest update
517	// timestamps could bring it back from the dead, then we mark it
518	// alive, and we let it be added to the set of IDs to query our
519	// peer for.
UNCOV 520	err := c.V1Store.MarkEdgeLive(	×
UNCOV 521	info.ShortChannelID.ToUint64(),	×
UNCOV 522	)	×
UNCOV 523	// Since there is a chance that the edge could have been marked	×
UNCOV 524	// as "live" between the FilterKnownChanIDs call and the	×
UNCOV 525	// MarkEdgeLive call, we ignore the error if the edge is already	×
UNCOV 526	// marked as live.	×
UNCOV 527	if err != nil && !errors.Is(err, ErrZombieEdgeNotFound) {	×
528	return nil, err	×
529	}	×
530	}
531
532	return unknown, nil	3✔
533	}
534
535	// MarkEdgeZombie attempts to mark a channel identified by its channel ID as a
536	// zombie. This method is used on an ad-hoc basis, when channels need to be
537	// marked as zombies outside the normal pruning cycle.
538	func (c *ChannelGraph) MarkEdgeZombie(chanID uint64,
UNCOV 539	pubKey1, pubKey2 [33]byte) error {	×
UNCOV 540		×
UNCOV 541	err := c.V1Store.MarkEdgeZombie(chanID, pubKey1, pubKey2)	×
UNCOV 542	if err != nil {	×
543	return err	×
544	}	×
545
UNCOV 546	if c.graphCache != nil {	×
UNCOV 547	c.graphCache.RemoveChannel(pubKey1, pubKey2, chanID)	×
UNCOV 548	}	×
549
UNCOV 550	return nil	×
551	}
552
553	// UpdateEdgePolicy updates the edge routing policy for a single directed edge
554	// within the database for the referenced channel. The `flags` attribute within
555	// the ChannelEdgePolicy determines which of the directed edges are being
556	// updated. If the flag is 1, then the first node's information is being
557	// updated, otherwise it's the second node's information. The node ordering is
558	// determined by the lexicographical ordering of the identity public keys of the
559	// nodes on either side of the channel.
560	func (c ChannelGraph) UpdateEdgePolicy(edge models.ChannelEdgePolicy,
561	op ...batch.SchedulerOption) error {	3✔
562		3✔
563	from, to, err := c.V1Store.UpdateEdgePolicy(edge, op...)	3✔
564	if err != nil {	3✔
UNCOV 565	return err	×
UNCOV 566	}	×
567
568	if c.graphCache != nil {	6✔
569	var isUpdate1 bool	3✔
570	if edge.ChannelFlags&lnwire.ChanUpdateDirection == 0 {	6✔
571	isUpdate1 = true	3✔
572	}	3✔
573
574	c.graphCache.UpdatePolicy(edge, from, to, isUpdate1)	3✔
575	}
576
577	select {	3✔
578	case c.topologyUpdate <- edge:	3✔
579	case <-c.quit:	×
580	return ErrChanGraphShuttingDown	×
581	}
582
583	return nil	3✔
584	}
585
586	// MakeTestGraphNew creates a new instance of the ChannelGraph for testing
587	// purposes. The backing V1Store implementation depends on the version of
588	// NewTestDB included in the current build.
589	//
590	// NOTE: this is currently unused, but is left here for future use to show how
591	// NewTestDB can be used. As the SQL implementation of the V1Store is
592	// implemented, unit tests will be switched to use this function instead of
593	// the existing MakeTestGraph helper. Once only this function is used, the
594	// existing MakeTestGraph function will be removed and this one will be renamed.
595	func MakeTestGraphNew(t testing.TB,
UNCOV 596	opts ...ChanGraphOption) *ChannelGraph {	×
UNCOV 597		×
UNCOV 598	t.Helper()	×
UNCOV 599		×
UNCOV 600	store := NewTestDB(t)	×
UNCOV 601		×
UNCOV 602	graph, err := NewChannelGraph(store, opts...)	×
UNCOV 603	require.NoError(t, err)	×
UNCOV 604	require.NoError(t, graph.Start())	×
UNCOV 605		×
UNCOV 606	t.Cleanup(func() {	×
UNCOV 607	require.NoError(t, graph.Stop())	×
UNCOV 608	})	×
609
UNCOV 610	return graph	×
611	}

lightningnetwork / lnd / 15561477203

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous