13566028875

Committed 27 Feb 2025 12:09PM UTC coverage: 49.396% (-9.4%) from 58.748%

Build # 13566028875

Build Type

Pull #9555

github

Committed by

ellemouton

Commit Message

graph/db: populate the graph cache in Start instead of during construction

In this commit, we move the graph cache population logic out of the
ChannelGraph constructor and into its Start method instead.

Pull Request Pull Request #9555: graph: extract cache from CRUD [6]

Run Details

34 of 54 new or added lines in 4 files covered. (62.96%)

27464 existing lines in 436 files now uncovered.

101095 of 204664 relevant lines covered (49.4%)

1.54 hits per line

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

86.96

/watchtower/wtclient/stats.go

package wtclient

import (
        "fmt"
        "sync"
)

// ClientStats is a collection of in-memory statistics of the actions the client
// has performed since its creation.
type ClientStats struct {
        // NumTasksPending is the total number of backups that are pending to
        // be acknowledged by all active and exhausted watchtower sessions.
        NumTasksPending int

        // NumTasksAccepted is the total number of backups made to all active
        // and exhausted watchtower sessions.
        NumTasksAccepted int

        // NumTasksIneligible is the total number of backups that all active and
        // exhausted watchtower sessions have failed to acknowledge.
        NumTasksIneligible int

        // NumSessionsAcquired is the total number of new sessions made to
        // watchtowers.
        NumSessionsAcquired int

        // NumSessionsExhausted is the total number of watchtower sessions that
        // have been exhausted.
        NumSessionsExhausted int
}

// clientStats wraps ClientStats with a mutex so that it's members can be
// accessed in a thread safe manner.
type clientStats struct {
        mu sync.Mutex

        ClientStats
}

// taskReceived increments the number of backup requests the client has received
// from active channels.
func (s *clientStats) taskReceived() {
        s.mu.Lock()
        defer s.mu.Unlock()

        s.NumTasksPending++
}

// taskAccepted increments the number of tasks that have been assigned to active
// session queues, and are awaiting upload to a tower.
func (s *clientStats) taskAccepted() {
        s.mu.Lock()
        defer s.mu.Unlock()

        s.NumTasksAccepted++
        s.NumTasksPending--
}

// getStatsCopy returns a copy of the ClientStats.
func (s *clientStats) getStatsCopy() ClientStats {
        s.mu.Lock()
        defer s.mu.Unlock()

        return s.ClientStats
}

// taskIneligible increments the number of tasks that were unable to satisfy the
// active session queue's policy. These can potentially be retried later, but
// typically this means that the balance created dust outputs, so it may not be
// worth backing up at all.
func (s *clientStats) taskIneligible() {
        s.mu.Lock()
        defer s.mu.Unlock()

        s.NumTasksIneligible++
}

// sessionAcquired increments the number of sessions that have been successfully
// negotiated by the client during this execution.
func (s *clientStats) sessionAcquired() {
        s.mu.Lock()
        defer s.mu.Unlock()

        s.NumSessionsAcquired++
}

// sessionExhausted increments the number of session that have become full as a
// result of accepting backup tasks.
func (s *clientStats) sessionExhausted() {
        s.mu.Lock()
        defer s.mu.Unlock()

        s.NumSessionsExhausted++
}

// String returns a human-readable summary of the client's metrics.
func (s *clientStats) String() string {
        s.mu.Lock()
        defer s.mu.Unlock()

        return fmt.Sprintf("tasks(received=%d accepted=%d ineligible=%d) "+
                "sessions(acquired=%d exhausted=%d)", s.NumTasksPending,
                s.NumTasksAccepted, s.NumTasksIneligible, s.NumSessionsAcquired,
                s.NumSessionsExhausted)
}

1	package wtclient
2
3	import (
4	"fmt"
5	"sync"
6	)
7
8	// ClientStats is a collection of in-memory statistics of the actions the client
9	// has performed since its creation.
10	type ClientStats struct {
11	// NumTasksPending is the total number of backups that are pending to
12	// be acknowledged by all active and exhausted watchtower sessions.
13	NumTasksPending int
14
15	// NumTasksAccepted is the total number of backups made to all active
16	// and exhausted watchtower sessions.
17	NumTasksAccepted int
18
19	// NumTasksIneligible is the total number of backups that all active and
20	// exhausted watchtower sessions have failed to acknowledge.
21	NumTasksIneligible int
22
23	// NumSessionsAcquired is the total number of new sessions made to
24	// watchtowers.
25	NumSessionsAcquired int
26
27	// NumSessionsExhausted is the total number of watchtower sessions that
28	// have been exhausted.
29	NumSessionsExhausted int
30	}
31
32	// clientStats wraps ClientStats with a mutex so that it's members can be
33	// accessed in a thread safe manner.
34	type clientStats struct {
35	mu sync.Mutex
36
37	ClientStats
38	}
39
40	// taskReceived increments the number of backup requests the client has received
41	// from active channels.
42	func (s *clientStats) taskReceived() {	3✔
43	s.mu.Lock()	3✔
44	defer s.mu.Unlock()	3✔
45		3✔
46	s.NumTasksPending++	3✔
47	}	3✔
48
49	// taskAccepted increments the number of tasks that have been assigned to active
50	// session queues, and are awaiting upload to a tower.
51	func (s *clientStats) taskAccepted() {	3✔
52	s.mu.Lock()	3✔
53	defer s.mu.Unlock()	3✔
54		3✔
55	s.NumTasksAccepted++	3✔
56	s.NumTasksPending--	3✔
57	}	3✔
58
59	// getStatsCopy returns a copy of the ClientStats.
60	func (s *clientStats) getStatsCopy() ClientStats {	3✔
61	s.mu.Lock()	3✔
62	defer s.mu.Unlock()	3✔
63		3✔
64	return s.ClientStats	3✔
65	}	3✔
66
67	// taskIneligible increments the number of tasks that were unable to satisfy the
68	// active session queue's policy. These can potentially be retried later, but
69	// typically this means that the balance created dust outputs, so it may not be
70	// worth backing up at all.
UNCOV 71	func (s *clientStats) taskIneligible() {	×
UNCOV 72	s.mu.Lock()	×
UNCOV 73	defer s.mu.Unlock()	×
UNCOV 74		×
UNCOV 75	s.NumTasksIneligible++	×
UNCOV 76	}	×
77
78	// sessionAcquired increments the number of sessions that have been successfully
79	// negotiated by the client during this execution.
80	func (s *clientStats) sessionAcquired() {	3✔
81	s.mu.Lock()	3✔
82	defer s.mu.Unlock()	3✔
83		3✔
84	s.NumSessionsAcquired++	3✔
85	}	3✔
86
87	// sessionExhausted increments the number of session that have become full as a
88	// result of accepting backup tasks.
89	func (s *clientStats) sessionExhausted() {	3✔
90	s.mu.Lock()	3✔
91	defer s.mu.Unlock()	3✔
92		3✔
93	s.NumSessionsExhausted++	3✔
94	}	3✔
95
96	// String returns a human-readable summary of the client's metrics.
97	func (s *clientStats) String() string {	3✔
98	s.mu.Lock()	3✔
99	defer s.mu.Unlock()	3✔
100		3✔
101	return fmt.Sprintf("tasks(received=%d accepted=%d ineligible=%d) "+	3✔
102	"sessions(acquired=%d exhausted=%d)", s.NumTasksPending,	3✔
103	s.NumTasksAccepted, s.NumTasksIneligible, s.NumSessionsAcquired,	3✔
104	s.NumSessionsExhausted)	3✔
105	}	3✔

lightningnetwork / lnd / 13566028875

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