12312390362

Committed 13 Dec 2024 08:44AM UTC coverage: 57.458% (+8.5%) from 48.92%

Build # 12312390362

Build Type

Pull #9343

github

Committed by

ellemouton

Commit Message

fn: rework the ContextGuard and add tests

In this commit, the ContextGuard struct is re-worked such that the
context that its new main WithCtx method provides is cancelled in sync
with a parent context being cancelled or with it's quit channel being
cancelled. Tests are added to assert the behaviour. In order for the
close of the quit channel to be consistent with the cancelling of the
derived context, the quit channel _must_ be contained internal to the
ContextGuard so that callers are only able to close the channel via the
exposed Quit method which will then take care to first cancel any
derived context that depend on the quit channel before returning.

Pull Request Pull Request #9343: fn: expand the ContextGuard and add tests

Run Details

101853 of 177264 relevant lines covered (57.46%)

24972.93 hits per line

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

0.0

/graph/graphsession/graph_session.go

package graphsession

import (
        "fmt"

        graphdb "github.com/lightningnetwork/lnd/graph/db"
        "github.com/lightningnetwork/lnd/kvdb"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/routing"
        "github.com/lightningnetwork/lnd/routing/route"
)

// Factory implements the routing.GraphSessionFactory and can be used to start
// a session with a ReadOnlyGraph.
type Factory struct {
        graph ReadOnlyGraph
}

// NewGraphSessionFactory constructs a new Factory which can then be used to
// start a new session.
func NewGraphSessionFactory(graph ReadOnlyGraph) routing.GraphSessionFactory {
        return &Factory{
                graph: graph,
        }
}

// NewGraphSession will produce a new Graph to use for a path-finding session.
// It returns the Graph along with a call-back that must be called once Graph
// access is complete. This call-back will close any read-only transaction that
// was created at Graph construction time.
//
// NOTE: This is part of the routing.GraphSessionFactory interface.
func (g *Factory) NewGraphSession() (routing.Graph, func() error, error) {
        tx, err := g.graph.NewPathFindTx()
        if err != nil {
                return nil, nil, err
        }

        session := &session{
                graph: g.graph,
                tx:    tx,
        }

        return session, session.close, nil
}

// A compile-time check to ensure that Factory implements the
// routing.GraphSessionFactory interface.
var _ routing.GraphSessionFactory = (*Factory)(nil)

// session is an implementation of the routing.Graph interface where the same
// read-only transaction is held across calls to the graph and can be used to
// access the backing channel graph.
type session struct {
        graph graph
        tx    kvdb.RTx
}

// NewRoutingGraph constructs a session that which does not first start a
// read-only transaction and so each call on the routing.Graph will create a
// new transaction.
func NewRoutingGraph(graph ReadOnlyGraph) routing.Graph {
        return &session{
                graph: graph,
        }
}

// close closes the read-only transaction being used to access the backing
// graph. If no transaction was started then this is a no-op.
func (g *session) close() error {
        if g.tx == nil {
                return nil
        }

        err := g.tx.Rollback()
        if err != nil {
                return fmt.Errorf("error closing db tx: %w", err)
        }

        return nil
}

// ForEachNodeChannel calls the callback for every channel of the given node.
//
// NOTE: Part of the routing.Graph interface.
func (g *session) ForEachNodeChannel(nodePub route.Vertex,
        cb func(channel *graphdb.DirectedChannel) error) error {

        return g.graph.ForEachNodeDirectedChannel(g.tx, nodePub, cb)
}

// FetchNodeFeatures returns the features of the given node. If the node is
// unknown, assume no additional features are supported.
//
// NOTE: Part of the routing.Graph interface.
func (g *session) FetchNodeFeatures(nodePub route.Vertex) (
        *lnwire.FeatureVector, error) {

        return g.graph.FetchNodeFeatures(nodePub)
}

// A compile-time check to ensure that *session implements the
// routing.Graph interface.
var _ routing.Graph = (*session)(nil)

// ReadOnlyGraph is a graph extended with a call to create a new read-only
// transaction that can then be used to make further queries to the graph.
type ReadOnlyGraph interface {
        // NewPathFindTx returns a new read transaction that can be used for a
        // single path finding session. Will return nil if the graph cache is
        // enabled.
        NewPathFindTx() (kvdb.RTx, error)

        graph
}

// graph describes the API necessary for a graph source to have access to on a
// database implementation, like channeldb.ChannelGraph, in order to be used by
// the Router for pathfinding.
type graph interface {
        // 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.
        //
        // Unknown policies are passed into the callback as nil values.
        //
        // NOTE: if a nil tx is provided, then it is expected that the
        // implementation create a read only tx.
        ForEachNodeDirectedChannel(tx kvdb.RTx, node route.Vertex,
                cb func(channel *graphdb.DirectedChannel) error) error

        // FetchNodeFeatures returns the features of a given node. If no
        // features are known for the node, an empty feature vector is returned.
        FetchNodeFeatures(node route.Vertex) (*lnwire.FeatureVector, error)
}

// A compile-time check to ensure that *channeldb.ChannelGraph implements the
// graph interface.
var _ graph = (*graphdb.ChannelGraph)(nil)

1	package graphsession
2
3	import (
4	"fmt"
5
6	graphdb "github.com/lightningnetwork/lnd/graph/db"
7	"github.com/lightningnetwork/lnd/kvdb"
8	"github.com/lightningnetwork/lnd/lnwire"
9	"github.com/lightningnetwork/lnd/routing"
10	"github.com/lightningnetwork/lnd/routing/route"
11	)
12
13	// Factory implements the routing.GraphSessionFactory and can be used to start
14	// a session with a ReadOnlyGraph.
15	type Factory struct {
16	graph ReadOnlyGraph
17	}
18
19	// NewGraphSessionFactory constructs a new Factory which can then be used to
20	// start a new session.
21	func NewGraphSessionFactory(graph ReadOnlyGraph) routing.GraphSessionFactory {	×
22	return &Factory{	×
23	graph: graph,	×
24	}	×
25	}	×
26
27	// NewGraphSession will produce a new Graph to use for a path-finding session.
28	// It returns the Graph along with a call-back that must be called once Graph
29	// access is complete. This call-back will close any read-only transaction that
30	// was created at Graph construction time.
31	//
32	// NOTE: This is part of the routing.GraphSessionFactory interface.
33	func (g *Factory) NewGraphSession() (routing.Graph, func() error, error) {	×
34	tx, err := g.graph.NewPathFindTx()	×
35	if err != nil {	×
36	return nil, nil, err	×
37	}	×
38
39	session := &session{	×
40	graph: g.graph,	×
41	tx: tx,	×
42	}	×
43		×
44	return session, session.close, nil	×
45	}
46
47	// A compile-time check to ensure that Factory implements the
48	// routing.GraphSessionFactory interface.
49	var _ routing.GraphSessionFactory = (*Factory)(nil)
50
51	// session is an implementation of the routing.Graph interface where the same
52	// read-only transaction is held across calls to the graph and can be used to
53	// access the backing channel graph.
54	type session struct {
55	graph graph
56	tx kvdb.RTx
57	}
58
59	// NewRoutingGraph constructs a session that which does not first start a
60	// read-only transaction and so each call on the routing.Graph will create a
61	// new transaction.
62	func NewRoutingGraph(graph ReadOnlyGraph) routing.Graph {	×
63	return &session{	×
64	graph: graph,	×
65	}	×
66	}	×
67
68	// close closes the read-only transaction being used to access the backing
69	// graph. If no transaction was started then this is a no-op.
70	func (g *session) close() error {	×
71	if g.tx == nil {	×
72	return nil	×
73	}	×
74
75	err := g.tx.Rollback()	×
76	if err != nil {	×
77	return fmt.Errorf("error closing db tx: %w", err)	×
78	}	×
79
80	return nil	×
81	}
82
83	// ForEachNodeChannel calls the callback for every channel of the given node.
84	//
85	// NOTE: Part of the routing.Graph interface.
86	func (g *session) ForEachNodeChannel(nodePub route.Vertex,
87	cb func(channel *graphdb.DirectedChannel) error) error {	×
88		×
89	return g.graph.ForEachNodeDirectedChannel(g.tx, nodePub, cb)	×
90	}	×
91
92	// FetchNodeFeatures returns the features of the given node. If the node is
93	// unknown, assume no additional features are supported.
94	//
95	// NOTE: Part of the routing.Graph interface.
96	func (g *session) FetchNodeFeatures(nodePub route.Vertex) (
97	*lnwire.FeatureVector, error) {	×
98		×
99	return g.graph.FetchNodeFeatures(nodePub)	×
100	}	×
101
102	// A compile-time check to ensure that *session implements the
103	// routing.Graph interface.
104	var _ routing.Graph = (*session)(nil)
105
106	// ReadOnlyGraph is a graph extended with a call to create a new read-only
107	// transaction that can then be used to make further queries to the graph.
108	type ReadOnlyGraph interface {
109	// NewPathFindTx returns a new read transaction that can be used for a
110	// single path finding session. Will return nil if the graph cache is
111	// enabled.
112	NewPathFindTx() (kvdb.RTx, error)
113
114	graph
115	}
116
117	// graph describes the API necessary for a graph source to have access to on a
118	// database implementation, like channeldb.ChannelGraph, in order to be used by
119	// the Router for pathfinding.
120	type graph interface {
121	// ForEachNodeDirectedChannel iterates through all channels of a given
122	// node, executing the passed callback on the directed edge representing
123	// the channel and its incoming policy. If the callback returns an
124	// error, then the iteration is halted with the error propagated back
125	// up to the caller.
126	//
127	// Unknown policies are passed into the callback as nil values.
128	//
129	// NOTE: if a nil tx is provided, then it is expected that the
130	// implementation create a read only tx.
131	ForEachNodeDirectedChannel(tx kvdb.RTx, node route.Vertex,
132	cb func(channel *graphdb.DirectedChannel) error) error
133
134	// FetchNodeFeatures returns the features of a given node. If no
135	// features are known for the node, an empty feature vector is returned.
136	FetchNodeFeatures(node route.Vertex) (*lnwire.FeatureVector, error)
137	}
138
139	// A compile-time check to ensure that *channeldb.ChannelGraph implements the
140	// graph interface.
141	var _ graph = (*graphdb.ChannelGraph)(nil)

lightningnetwork / lnd / 12312390362

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