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

76.19

/chainntnfs/best_block_view.go

package chainntnfs

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

        "github.com/btcsuite/btcd/wire"
)

// BestBlockView is an interface that allows the querying of the most
// up-to-date blockchain state with low overhead. Valid implementations of this
// interface must track the latest chain state.
type BestBlockView interface {
        // BestHeight gets the most recent block height known to the view.
        BestHeight() (uint32, error)

        // BestBlockHeader gets the most recent block header known to the view.
        BestBlockHeader() (*wire.BlockHeader, error)
}

// BestBlockTracker is a tiny subsystem that tracks the blockchain tip
// and saves the most recent tip information in memory for querying. It is a
// valid implementation of BestBlockView and additionally includes
// methods for starting and stopping the system.
type BestBlockTracker struct {
        notifier        ChainNotifier
        blockNtfnStream *BlockEpochEvent
        current         atomic.Pointer[BlockEpoch]
        mu              sync.Mutex
        quit            chan struct{}
        wg              sync.WaitGroup
}

// This is a compile time check to ensure that BestBlockTracker implements
// BestBlockView.
var _ BestBlockView = (*BestBlockTracker)(nil)

// NewBestBlockTracker creates a new BestBlockTracker that isn't running yet.
// It will not provide up to date information unless it has been started. The
// ChainNotifier parameter must also be started prior to starting the
// BestBlockTracker.
func NewBestBlockTracker(chainNotifier ChainNotifier) *BestBlockTracker {
        return &BestBlockTracker{
                notifier:        chainNotifier,
                blockNtfnStream: nil,
                quit:            make(chan struct{}),
        }
}

// BestHeight gets the most recent block height known to the
// BestBlockTracker.
func (t *BestBlockTracker) BestHeight() (uint32, error) {
        epoch := t.current.Load()
        if epoch == nil {
                return 0, errors.New("best block height not yet known")
        }

        return uint32(epoch.Height), nil
}

// BestBlockHeader gets the most recent block header known to the
// BestBlockTracker.
func (t *BestBlockTracker) BestBlockHeader() (*wire.BlockHeader, error) {
        epoch := t.current.Load()
        if epoch == nil {
                return nil, errors.New("best block header not yet known")
        }

        return epoch.BlockHeader, nil
}

// updateLoop is a helper that subscribes to the underlying BlockEpochEvent
// stream and updates the internal values to match the new BlockEpochs that
// are discovered.
//
// MUST be run as a goroutine.
func (t *BestBlockTracker) updateLoop() {
        defer t.wg.Done()
        for {
                select {
                case epoch, ok := <-t.blockNtfnStream.Epochs:
                        if !ok {
                                Log.Error("dead epoch stream in " +
                                        "BestBlockTracker")

                                return
                        }
                        t.current.Store(epoch)
                case <-t.quit:
                        t.current.Store(nil)
                        return
                }
        }
}

// Start starts the BestBlockTracker. It is an error to start it if it
// is already started.
func (t *BestBlockTracker) Start() error {
        t.mu.Lock()
        defer t.mu.Unlock()

        if t.blockNtfnStream != nil {
                return fmt.Errorf("BestBlockTracker is already started")
        }

        var err error
        t.blockNtfnStream, err = t.notifier.RegisterBlockEpochNtfn(nil)
        if err != nil {
                return err
        }

        t.wg.Add(1)
        go t.updateLoop()

        return nil
}

// Stop stops the BestBlockTracker. It is an error to stop it if it has
// not been started or if it has already been stopped.
func (t *BestBlockTracker) Stop() error {
        t.mu.Lock()
        defer t.mu.Unlock()

        if t.blockNtfnStream == nil {
                return fmt.Errorf("BestBlockTracker is not running")
        }
        close(t.quit)
        t.wg.Wait()
        t.blockNtfnStream.Cancel()
        t.blockNtfnStream = nil

        return nil
}

1	package chainntnfs
2
3	import (
4	"errors"
5	"fmt"
6	"sync"
7	"sync/atomic"
8
9	"github.com/btcsuite/btcd/wire"
10	)
11
12	// BestBlockView is an interface that allows the querying of the most
13	// up-to-date blockchain state with low overhead. Valid implementations of this
14	// interface must track the latest chain state.
15	type BestBlockView interface {
16	// BestHeight gets the most recent block height known to the view.
17	BestHeight() (uint32, error)
18
19	// BestBlockHeader gets the most recent block header known to the view.
20	BestBlockHeader() (*wire.BlockHeader, error)
21	}
22
23	// BestBlockTracker is a tiny subsystem that tracks the blockchain tip
24	// and saves the most recent tip information in memory for querying. It is a
25	// valid implementation of BestBlockView and additionally includes
26	// methods for starting and stopping the system.
27	type BestBlockTracker struct {
28	notifier ChainNotifier
29	blockNtfnStream *BlockEpochEvent
30	current atomic.Pointer[BlockEpoch]
31	mu sync.Mutex
32	quit chan struct{}
33	wg sync.WaitGroup
34	}
35
36	// This is a compile time check to ensure that BestBlockTracker implements
37	// BestBlockView.
38	var _ BestBlockView = (*BestBlockTracker)(nil)
39
40	// NewBestBlockTracker creates a new BestBlockTracker that isn't running yet.
41	// It will not provide up to date information unless it has been started. The
42	// ChainNotifier parameter must also be started prior to starting the
43	// BestBlockTracker.
44	func NewBestBlockTracker(chainNotifier ChainNotifier) *BestBlockTracker {	1✔
45	return &BestBlockTracker{	1✔
46	notifier: chainNotifier,	1✔
47	blockNtfnStream: nil,	1✔
48	quit: make(chan struct{}),	1✔
49	}	1✔
50	}	1✔
51
52	// BestHeight gets the most recent block height known to the
53	// BestBlockTracker.
54	func (t *BestBlockTracker) BestHeight() (uint32, error) {	250✔
55	epoch := t.current.Load()	250✔
56	if epoch == nil {	250✔
57	return 0, errors.New("best block height not yet known")	×
58	}	×
59
60	return uint32(epoch.Height), nil	250✔
61	}
62
63	// BestBlockHeader gets the most recent block header known to the
64	// BestBlockTracker.
65	func (t BestBlockTracker) BestBlockHeader() (wire.BlockHeader, error) {	150✔
66	epoch := t.current.Load()	150✔
67	if epoch == nil {	150✔
68	return nil, errors.New("best block header not yet known")	×
69	}	×
70
71	return epoch.BlockHeader, nil	150✔
72	}
73
74	// updateLoop is a helper that subscribes to the underlying BlockEpochEvent
75	// stream and updates the internal values to match the new BlockEpochs that
76	// are discovered.
77	//
78	// MUST be run as a goroutine.
79	func (t *BestBlockTracker) updateLoop() {	1✔
80	defer t.wg.Done()	1✔
81	for {	102✔
82	select {	101✔
83	case epoch, ok := <-t.blockNtfnStream.Epochs:	100✔
84	if !ok {	100✔
UNCOV 85	Log.Error("dead epoch stream in " +	×
UNCOV 86	"BestBlockTracker")	×
UNCOV 87		×
UNCOV 88	return	×
UNCOV 89	}	×
90	t.current.Store(epoch)	100✔
91	case <-t.quit:	1✔
92	t.current.Store(nil)	1✔
93	return	1✔
94	}
95	}
96	}
97
98	// Start starts the BestBlockTracker. It is an error to start it if it
99	// is already started.
100	func (t *BestBlockTracker) Start() error {	1✔
101	t.mu.Lock()	1✔
102	defer t.mu.Unlock()	1✔
103		1✔
104	if t.blockNtfnStream != nil {	1✔
105	return fmt.Errorf("BestBlockTracker is already started")	×
106	}	×
107
108	var err error	1✔
109	t.blockNtfnStream, err = t.notifier.RegisterBlockEpochNtfn(nil)	1✔
110	if err != nil {	1✔
111	return err	×
112	}	×
113
114	t.wg.Add(1)	1✔
115	go t.updateLoop()	1✔
116		1✔
117	return nil	1✔
118	}
119
120	// Stop stops the BestBlockTracker. It is an error to stop it if it has
121	// not been started or if it has already been stopped.
122	func (t *BestBlockTracker) Stop() error {	1✔
123	t.mu.Lock()	1✔
124	defer t.mu.Unlock()	1✔
125		1✔
126	if t.blockNtfnStream == nil {	1✔
127	return fmt.Errorf("BestBlockTracker is not running")	×
128	}	×
129	close(t.quit)	1✔
130	t.wg.Wait()	1✔
131	t.blockNtfnStream.Cancel()	1✔
132	t.blockNtfnStream = nil	1✔
133		1✔
134	return nil	1✔
135	}

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