12293715361

Committed 12 Dec 2024 09:38AM UTC coverage: 57.483% (+7.9%) from 49.538%

Build # 12293715361

Build Type

Pull #9348

github

Committed by

ziggie1984

Commit Message

github: update goveralls tool

The goverall tool had a bug regarding the module versioning of
golang packages see also
https://github.com/mattn/goveralls/pull/222 for more background.
Goveralls is wrapped by another library to make it available for
github actions. So the relevant PR which is referenced here in
LND is:
https://github.com/shogo82148/actions-goveralls/pull/521.

Pull Request Pull Request #9348: github: update goveralls tool

Run Details

101897 of 177264 relevant lines covered (57.48%)

24982.4 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 / 12293715361

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