13157733617

Committed 05 Feb 2025 12:49PM UTC coverage: 57.712% (-1.1%) from 58.82%

Build # 13157733617

Build Type

Pull #9447

github

Committed by

yyforyongyu

Commit Message

sweep: rename methods for clarity

We now rename "third party" to "unknown" as the inputs can be spent via
an older sweeping tx, a third party (anchor), or a remote party (pin).
In fee bumper we don't have the info to distinguish the above cases, and
leave them to be further handled by the sweeper as it has more context.

Pull Request Pull Request #9447: sweep: start tracking input spending status in the fee bumper

Run Details

83 of 87 new or added lines in 2 files covered. (95.4%)

19472 existing lines in 252 files now uncovered.

103634 of 179570 relevant lines covered (57.71%)

24840.31 hits per line

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

74.6

/channeldb/peers.go

package channeldb

import (
        "bytes"
        "errors"
        "fmt"
        "time"

        "github.com/lightningnetwork/lnd/kvdb"
        "github.com/lightningnetwork/lnd/routing/route"
)

var (
        // peersBucket is the name of a top level bucket in which we store
        // information about our peers. Information for different peers is
        // stored in buckets keyed by their public key.
        //
        //
        // peers-bucket
        //      |
        //      |-- <peer-pubkey>
        //      |        |--flap-count-key: <ts><flap count>
        //      |
        //      |-- <peer-pubkey>
        //      |        |--flap-count-key: <ts><flap count>
        peersBucket = []byte("peers-bucket")

        // flapCountKey is a key used in the peer pubkey sub-bucket that stores
        // the timestamp of a peer's last flap count and its all time flap
        // count.
        flapCountKey = []byte("flap-count")
)

var (
        // ErrNoPeerBucket is returned when we try to read entries for a peer
        // that is not tracked.
        ErrNoPeerBucket = errors.New("peer bucket not found")
)

// FlapCount contains information about a peer's flap count.
type FlapCount struct {
        // Count provides the total flap count for a peer.
        Count uint32

        // LastFlap is the timestamp of the last flap recorded for a peer.
        LastFlap time.Time
}

// WriteFlapCounts writes the flap count for a set of peers to disk, creating a
// bucket for the peer's pubkey if necessary. Note that this function overwrites
// the current value.
func (d *DB) WriteFlapCounts(flapCounts map[route.Vertex]*FlapCount) error {
        // Exit early if there are no updates.
        if len(flapCounts) == 0 {
                log.Debugf("No flap counts to write, skipped db update")
                return nil
        }

        return kvdb.Update(d, func(tx kvdb.RwTx) error {
                // Run through our set of flap counts and record them for
                // each peer, creating a bucket for the peer pubkey if required.
                for peer, flapCount := range flapCounts {
                        peers := tx.ReadWriteBucket(peersBucket)

                        peerBucket, err := peers.CreateBucketIfNotExists(
                                peer[:],
                        )
                        if err != nil {
                                return err
                        }

                        var b bytes.Buffer
                        err = serializeTime(&b, flapCount.LastFlap)
                        if err != nil {
                                return err
                        }

                        if err = WriteElement(&b, flapCount.Count); err != nil {
                                return err
                        }

                        err = peerBucket.Put(flapCountKey, b.Bytes())
                        if err != nil {
                                return err
                        }
                }

                return nil
        }, func() {})
}

// ReadFlapCount attempts to read the flap count for a peer, failing if the
// peer is not found or we do not have flap count stored.
func (d *DB) ReadFlapCount(pubkey route.Vertex) (*FlapCount, error) {
        var flapCount FlapCount

        if err := kvdb.View(d, func(tx kvdb.RTx) error {
                peers := tx.ReadBucket(peersBucket)

                peerBucket := peers.NestedReadBucket(pubkey[:])
                if peerBucket == nil {
                        return ErrNoPeerBucket
                }

                flapBytes := peerBucket.Get(flapCountKey)
                if flapBytes == nil {
                        return fmt.Errorf("flap count not recorded for: %v",
                                pubkey)
                }

                var (
                        err error
                        r   = bytes.NewReader(flapBytes)
                )

                flapCount.LastFlap, err = deserializeTime(r)
                if err != nil {
                        return err
                }

                return ReadElements(r, &flapCount.Count)
        }, func() {
                flapCount = FlapCount{}
        }); err != nil {
                return nil, err
        }

        return &flapCount, nil
}

1	package channeldb
2
3	import (
4	"bytes"
5	"errors"
6	"fmt"
7	"time"
8
9	"github.com/lightningnetwork/lnd/kvdb"
10	"github.com/lightningnetwork/lnd/routing/route"
11	)
12
13	var (
14	// peersBucket is the name of a top level bucket in which we store
15	// information about our peers. Information for different peers is
16	// stored in buckets keyed by their public key.
17	//
18	//
19	// peers-bucket
20	// \|
21	// \|-- <peer-pubkey>
22	// \| \|--flap-count-key: <ts><flap count>
23	// \|
24	// \|-- <peer-pubkey>
25	// \| \|--flap-count-key: <ts><flap count>
26	peersBucket = []byte("peers-bucket")
27
28	// flapCountKey is a key used in the peer pubkey sub-bucket that stores
29	// the timestamp of a peer's last flap count and its all time flap
30	// count.
31	flapCountKey = []byte("flap-count")
32	)
33
34	var (
35	// ErrNoPeerBucket is returned when we try to read entries for a peer
36	// that is not tracked.
37	ErrNoPeerBucket = errors.New("peer bucket not found")
38	)
39
40	// FlapCount contains information about a peer's flap count.
41	type FlapCount struct {
42	// Count provides the total flap count for a peer.
43	Count uint32
44
45	// LastFlap is the timestamp of the last flap recorded for a peer.
46	LastFlap time.Time
47	}
48
49	// WriteFlapCounts writes the flap count for a set of peers to disk, creating a
50	// bucket for the peer's pubkey if necessary. Note that this function overwrites
51	// the current value.
52	func (d DB) WriteFlapCounts(flapCounts map[route.Vertex]FlapCount) error {	1✔
53	// Exit early if there are no updates.	1✔
54	if len(flapCounts) == 0 {	1✔
UNCOV 55	log.Debugf("No flap counts to write, skipped db update")	×
UNCOV 56	return nil	×
UNCOV 57	}	×
58
59	return kvdb.Update(d, func(tx kvdb.RwTx) error {	2✔
60	// Run through our set of flap counts and record them for	1✔
61	// each peer, creating a bucket for the peer pubkey if required.	1✔
62	for peer, flapCount := range flapCounts {	3✔
63	peers := tx.ReadWriteBucket(peersBucket)	2✔
64		2✔
65	peerBucket, err := peers.CreateBucketIfNotExists(	2✔
66	peer[:],	2✔
67	)	2✔
68	if err != nil {	2✔
69	return err	×
70	}	×
71
72	var b bytes.Buffer	2✔
73	err = serializeTime(&b, flapCount.LastFlap)	2✔
74	if err != nil {	2✔
75	return err	×
76	}	×
77
78	if err = WriteElement(&b, flapCount.Count); err != nil {	2✔
79	return err	×
80	}	×
81
82	err = peerBucket.Put(flapCountKey, b.Bytes())	2✔
83	if err != nil {	2✔
84	return err	×
85	}	×
86	}
87
88	return nil	1✔
89	}, func() {})	1✔
90	}
91
92	// ReadFlapCount attempts to read the flap count for a peer, failing if the
93	// peer is not found or we do not have flap count stored.
94	func (d DB) ReadFlapCount(pubkey route.Vertex) (FlapCount, error) {	3✔
95	var flapCount FlapCount	3✔
96		3✔
97	if err := kvdb.View(d, func(tx kvdb.RTx) error {	6✔
98	peers := tx.ReadBucket(peersBucket)	3✔
99		3✔
100	peerBucket := peers.NestedReadBucket(pubkey[:])	3✔
101	if peerBucket == nil {	4✔
102	return ErrNoPeerBucket	1✔
103	}	1✔
104
105	flapBytes := peerBucket.Get(flapCountKey)	2✔
106	if flapBytes == nil {	2✔
107	return fmt.Errorf("flap count not recorded for: %v",	×
108	pubkey)	×
109	}	×
110
111	var (	2✔
112	err error	2✔
113	r = bytes.NewReader(flapBytes)	2✔
114	)	2✔
115		2✔
116	flapCount.LastFlap, err = deserializeTime(r)	2✔
117	if err != nil {	2✔
118	return err	×
119	}	×
120
121	return ReadElements(r, &flapCount.Count)	2✔
122	}, func() {	3✔
123	flapCount = FlapCount{}	3✔
124	}); err != nil {	4✔
125	return nil, err	1✔
126	}	1✔
127
128	return &flapCount, nil	2✔
129	}

lightningnetwork / lnd / 13157733617

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