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

77.57

/witness_beacon.go

package lnd

import (
        "errors"
        "sync"

        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/contractcourt"
        "github.com/lightningnetwork/lnd/graph/db/models"
        "github.com/lightningnetwork/lnd/htlcswitch"
        "github.com/lightningnetwork/lnd/htlcswitch/hop"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwire"
)

// preimageSubscriber reprints an active subscription to be notified once the
// daemon discovers new preimages, either on chain or off-chain.
type preimageSubscriber struct {
        updateChan chan lntypes.Preimage

        quit chan struct{}
}

type witnessCache interface {
        // LookupSha256Witness attempts to lookup the preimage for a sha256
        // hash. If the witness isn't found, ErrNoWitnesses will be returned.
        LookupSha256Witness(hash lntypes.Hash) (lntypes.Preimage, error)

        // AddSha256Witnesses adds a batch of new sha256 preimages into the
        // witness cache. This is an alias for AddWitnesses that uses
        // Sha256HashWitness as the preimages' witness type.
        AddSha256Witnesses(preimages ...lntypes.Preimage) error
}

// preimageBeacon is an implementation of the contractcourt.WitnessBeacon
// interface, and the lnwallet.PreimageCache interface. This implementation is
// concerned with a single witness type: sha256 hahsh preimages.
type preimageBeacon struct {
        sync.RWMutex

        wCache witnessCache

        clientCounter uint64
        subscribers   map[uint64]*preimageSubscriber

        interceptor func(htlcswitch.InterceptedForward) error
}

func newPreimageBeacon(wCache witnessCache,
        interceptor func(htlcswitch.InterceptedForward) error) *preimageBeacon {

        return &preimageBeacon{
                wCache:      wCache,
                interceptor: interceptor,
                subscribers: make(map[uint64]*preimageSubscriber),
        }
}

// SubscribeUpdates returns a channel that will be sent upon *each* time a new
// preimage is discovered.
func (p *preimageBeacon) SubscribeUpdates(
        chanID lnwire.ShortChannelID, htlc *channeldb.HTLC,
        payload *hop.Payload,
        nextHopOnionBlob []byte) (*contractcourt.WitnessSubscription, error) {

        p.Lock()
        defer p.Unlock()

        clientID := p.clientCounter
        client := &preimageSubscriber{
                updateChan: make(chan lntypes.Preimage, 10),
                quit:       make(chan struct{}),
        }

        p.subscribers[p.clientCounter] = client

        p.clientCounter++

        srvrLog.Debugf("Creating new witness beacon subscriber, id=%v",
                p.clientCounter)

        sub := &contractcourt.WitnessSubscription{
                WitnessUpdates: client.updateChan,
                CancelSubscription: func() {
                        p.Lock()
                        defer p.Unlock()

                        delete(p.subscribers, clientID)

                        close(client.quit)
                },
        }

        // Notify the htlc interceptor. There may be a client connected
        // and willing to supply a preimage.
        packet := &htlcswitch.InterceptedPacket{
                Hash:           htlc.RHash,
                IncomingExpiry: htlc.RefundTimeout,
                IncomingAmount: htlc.Amt,
                IncomingCircuit: models.CircuitKey{
                        ChanID: chanID,
                        HtlcID: htlc.HtlcIndex,
                },
                OutgoingChanID:       payload.FwdInfo.NextHop,
                OutgoingExpiry:       payload.FwdInfo.OutgoingCTLV,
                OutgoingAmount:       payload.FwdInfo.AmountToForward,
                InOnionCustomRecords: payload.CustomRecords(),
                InWireCustomRecords:  htlc.CustomRecords,
        }
        copy(packet.OnionBlob[:], nextHopOnionBlob)

        fwd := newInterceptedForward(packet, p)

        err := p.interceptor(fwd)
        if err != nil {
                return nil, err
        }

        return sub, nil
}

// LookupPreimage attempts to lookup a preimage in the global cache.  True is
// returned for the second argument if the preimage is found.
func (p *preimageBeacon) LookupPreimage(
        payHash lntypes.Hash) (lntypes.Preimage, bool) {

        p.RLock()
        defer p.RUnlock()

        // Otherwise, we'll perform a final check using the witness cache.
        preimage, err := p.wCache.LookupSha256Witness(payHash)
        if errors.Is(err, channeldb.ErrNoWitnesses) {
                ltndLog.Debugf("No witness for payment %v", payHash)
                return lntypes.Preimage{}, false
        }

        if err != nil {
                ltndLog.Errorf("Unable to lookup witness: %v", err)
                return lntypes.Preimage{}, false
        }

        return preimage, true
}

// AddPreimages adds a batch of newly discovered preimages to the global cache,
// and also signals any subscribers of the newly discovered witness.
func (p *preimageBeacon) AddPreimages(preimages ...lntypes.Preimage) error {
        // Exit early if no preimages are presented.
        if len(preimages) == 0 {
                return nil
        }

        // Copy the preimages to ensure the backing area can't be modified by
        // the caller when delivering notifications.
        preimageCopies := make([]lntypes.Preimage, 0, len(preimages))
        for _, preimage := range preimages {
                srvrLog.Infof("Adding preimage=%v to witness cache for %v",
                        preimage, preimage.Hash())

                preimageCopies = append(preimageCopies, preimage)
        }

        // First, we'll add the witness to the decaying witness cache.
        err := p.wCache.AddSha256Witnesses(preimages...)
        if err != nil {
                return err
        }

        p.Lock()
        defer p.Unlock()

        // With the preimage added to our state, we'll now send a new
        // notification to all subscribers.
        for _, client := range p.subscribers {
                go func(c *preimageSubscriber) {
                        for _, preimage := range preimageCopies {
                                select {
                                case c.updateChan <- preimage:
                                case <-c.quit:
                                        return
                                }
                        }
                }(client)
        }

        srvrLog.Debugf("Added %d preimage(s) to witness cache",
                len(preimageCopies))

        return nil
}

var _ contractcourt.WitnessBeacon = (*preimageBeacon)(nil)

1	package lnd
2
3	import (
4	"errors"
5	"sync"
6
7	"github.com/lightningnetwork/lnd/channeldb"
8	"github.com/lightningnetwork/lnd/contractcourt"
9	"github.com/lightningnetwork/lnd/graph/db/models"
10	"github.com/lightningnetwork/lnd/htlcswitch"
11	"github.com/lightningnetwork/lnd/htlcswitch/hop"
12	"github.com/lightningnetwork/lnd/lntypes"
13	"github.com/lightningnetwork/lnd/lnwire"
14	)
15
16	// preimageSubscriber reprints an active subscription to be notified once the
17	// daemon discovers new preimages, either on chain or off-chain.
18	type preimageSubscriber struct {
19	updateChan chan lntypes.Preimage
20
21	quit chan struct{}
22	}
23
24	type witnessCache interface {
25	// LookupSha256Witness attempts to lookup the preimage for a sha256
26	// hash. If the witness isn't found, ErrNoWitnesses will be returned.
27	LookupSha256Witness(hash lntypes.Hash) (lntypes.Preimage, error)
28
29	// AddSha256Witnesses adds a batch of new sha256 preimages into the
30	// witness cache. This is an alias for AddWitnesses that uses
31	// Sha256HashWitness as the preimages' witness type.
32	AddSha256Witnesses(preimages ...lntypes.Preimage) error
33	}
34
35	// preimageBeacon is an implementation of the contractcourt.WitnessBeacon
36	// interface, and the lnwallet.PreimageCache interface. This implementation is
37	// concerned with a single witness type: sha256 hahsh preimages.
38	type preimageBeacon struct {
39	sync.RWMutex
40
41	wCache witnessCache
42
43	clientCounter uint64
44	subscribers map[uint64]*preimageSubscriber
45
46	interceptor func(htlcswitch.InterceptedForward) error
47	}
48
49	func newPreimageBeacon(wCache witnessCache,
50	interceptor func(htlcswitch.InterceptedForward) error) *preimageBeacon {	1✔
51		1✔
52	return &preimageBeacon{	1✔
53	wCache: wCache,	1✔
54	interceptor: interceptor,	1✔
55	subscribers: make(map[uint64]*preimageSubscriber),	1✔
56	}	1✔
57	}	1✔
58
59	// SubscribeUpdates returns a channel that will be sent upon each time a new
60	// preimage is discovered.
61	func (p *preimageBeacon) SubscribeUpdates(
62	chanID lnwire.ShortChannelID, htlc *channeldb.HTLC,
63	payload *hop.Payload,
64	nextHopOnionBlob []byte) (*contractcourt.WitnessSubscription, error) {	1✔
65		1✔
66	p.Lock()	1✔
67	defer p.Unlock()	1✔
68		1✔
69	clientID := p.clientCounter	1✔
70	client := &preimageSubscriber{	1✔
71	updateChan: make(chan lntypes.Preimage, 10),	1✔
72	quit: make(chan struct{}),	1✔
73	}	1✔
74		1✔
75	p.subscribers[p.clientCounter] = client	1✔
76		1✔
77	p.clientCounter++	1✔
78		1✔
79	srvrLog.Debugf("Creating new witness beacon subscriber, id=%v",	1✔
80	p.clientCounter)	1✔
81		1✔
82	sub := &contractcourt.WitnessSubscription{	1✔
83	WitnessUpdates: client.updateChan,	1✔
84	CancelSubscription: func() {	2✔
85	p.Lock()	1✔
86	defer p.Unlock()	1✔
87		1✔
88	delete(p.subscribers, clientID)	1✔
89		1✔
90	close(client.quit)	1✔
91	},	1✔
92	}
93
94	// Notify the htlc interceptor. There may be a client connected
95	// and willing to supply a preimage.
96	packet := &htlcswitch.InterceptedPacket{	1✔
97	Hash: htlc.RHash,	1✔
98	IncomingExpiry: htlc.RefundTimeout,	1✔
99	IncomingAmount: htlc.Amt,	1✔
100	IncomingCircuit: models.CircuitKey{	1✔
101	ChanID: chanID,	1✔
102	HtlcID: htlc.HtlcIndex,	1✔
103	},	1✔
104	OutgoingChanID: payload.FwdInfo.NextHop,	1✔
105	OutgoingExpiry: payload.FwdInfo.OutgoingCTLV,	1✔
106	OutgoingAmount: payload.FwdInfo.AmountToForward,	1✔
107	InOnionCustomRecords: payload.CustomRecords(),	1✔
108	InWireCustomRecords: htlc.CustomRecords,	1✔
109	}	1✔
110	copy(packet.OnionBlob[:], nextHopOnionBlob)	1✔
111		1✔
112	fwd := newInterceptedForward(packet, p)	1✔
113		1✔
114	err := p.interceptor(fwd)	1✔
115	if err != nil {	1✔
116	return nil, err	×
117	}	×
118
119	return sub, nil	1✔
120	}
121
122	// LookupPreimage attempts to lookup a preimage in the global cache. True is
123	// returned for the second argument if the preimage is found.
124	func (p *preimageBeacon) LookupPreimage(
UNCOV 125	payHash lntypes.Hash) (lntypes.Preimage, bool) {	×
UNCOV 126		×
UNCOV 127	p.RLock()	×
UNCOV 128	defer p.RUnlock()	×
UNCOV 129		×
UNCOV 130	// Otherwise, we'll perform a final check using the witness cache.	×
UNCOV 131	preimage, err := p.wCache.LookupSha256Witness(payHash)	×
UNCOV 132	if errors.Is(err, channeldb.ErrNoWitnesses) {	×
UNCOV 133	ltndLog.Debugf("No witness for payment %v", payHash)	×
UNCOV 134	return lntypes.Preimage{}, false	×
UNCOV 135	}	×
136
UNCOV 137	if err != nil {	×
138	ltndLog.Errorf("Unable to lookup witness: %v", err)	×
139	return lntypes.Preimage{}, false	×
140	}	×
141
UNCOV 142	return preimage, true	×
143	}
144
145	// AddPreimages adds a batch of newly discovered preimages to the global cache,
146	// and also signals any subscribers of the newly discovered witness.
147	func (p *preimageBeacon) AddPreimages(preimages ...lntypes.Preimage) error {	1✔
148	// Exit early if no preimages are presented.	1✔
149	if len(preimages) == 0 {	1✔
UNCOV 150	return nil	×
UNCOV 151	}	×
152
153	// Copy the preimages to ensure the backing area can't be modified by
154	// the caller when delivering notifications.
155	preimageCopies := make([]lntypes.Preimage, 0, len(preimages))	1✔
156	for _, preimage := range preimages {	2✔
157	srvrLog.Infof("Adding preimage=%v to witness cache for %v",	1✔
158	preimage, preimage.Hash())	1✔
159		1✔
160	preimageCopies = append(preimageCopies, preimage)	1✔
161	}	1✔
162
163	// First, we'll add the witness to the decaying witness cache.
164	err := p.wCache.AddSha256Witnesses(preimages...)	1✔
165	if err != nil {	1✔
166	return err	×
167	}	×
168
169	p.Lock()	1✔
170	defer p.Unlock()	1✔
171		1✔
172	// With the preimage added to our state, we'll now send a new	1✔
173	// notification to all subscribers.	1✔
174	for _, client := range p.subscribers {	2✔
175	go func(c *preimageSubscriber) {	2✔
176	for _, preimage := range preimageCopies {	2✔
177	select {	1✔
178	case c.updateChan <- preimage:	1✔
179	case <-c.quit:	×
180	return	×
181	}
182	}
183	}(client)
184	}
185
186	srvrLog.Debugf("Added %d preimage(s) to witness cache",	1✔
187	len(preimageCopies))	1✔
188		1✔
189	return nil	1✔
190	}
191
192	var _ contractcourt.WitnessBeacon = (*preimageBeacon)(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