13236757158

Committed 10 Feb 2025 08:39AM UTC coverage: 57.649% (-1.2%) from 58.815%

Build # 13236757158

Build Type

Pull #9493

github

Committed by

ziggie1984

Commit Message

lncli: for some cmds we don't replace the data of the response.

For some cmds it is not very practical to replace the json output
because we might pipe it into other commands. For example when
creating the route we want to pipe it into sendtoRoute.

Pull Request Pull Request #9493: For some lncli cmds we should not replace the content with other data

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

19535 existing lines in 252 files now uncovered.

103517 of 179563 relevant lines covered (57.65%)

24878.49 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.
UNCOV 21	func NewGraphSessionFactory(graph ReadOnlyGraph) routing.GraphSessionFactory {	×
UNCOV 22	return &Factory{	×
UNCOV 23	graph: graph,	×
UNCOV 24	}	×
UNCOV 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.
UNCOV 33	func (g *Factory) NewGraphSession() (routing.Graph, func() error, error) {	×
UNCOV 34	tx, err := g.graph.NewPathFindTx()	×
UNCOV 35	if err != nil {	×
36	return nil, nil, err	×
37	}	×
38
UNCOV 39	session := &session{	×
UNCOV 40	graph: g.graph,	×
UNCOV 41	tx: tx,	×
UNCOV 42	}	×
UNCOV 43		×
UNCOV 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.
UNCOV 62	func NewRoutingGraph(graph ReadOnlyGraph) routing.Graph {	×
UNCOV 63	return &session{	×
UNCOV 64	graph: graph,	×
UNCOV 65	}	×
UNCOV 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.
UNCOV 70	func (g *session) close() error {	×
UNCOV 71	if g.tx == nil {	×
UNCOV 72	return nil	×
UNCOV 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,
UNCOV 87	cb func(channel *graphdb.DirectedChannel) error) error {	×
UNCOV 88		×
UNCOV 89	return g.graph.ForEachNodeDirectedChannel(g.tx, nodePub, cb)	×
UNCOV 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) (
UNCOV 97	*lnwire.FeatureVector, error) {	×
UNCOV 98		×
UNCOV 99	return g.graph.FetchNodeFeatures(nodePub)	×
UNCOV 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 / 13236757158

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