12033440129

Committed 26 Nov 2024 03:03PM UTC coverage: 48.738% (-10.3%) from 58.999%

Build # 12033440129

Build Type

Pull #9309

github

Committed by

yyforyongyu

Commit Message

gomod: update `btcd` for shutdown fix

Pull Request Pull Request #9309: chainntnfs: fix `TestHistoricalConfDetailsTxIndex`

Run Details

97664 of 200385 relevant lines covered (48.74%)

0.52 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() {	1✔
43	s.mu.Lock()	1✔
44	defer s.mu.Unlock()	1✔
45		1✔
46	s.NumTasksPending++	1✔
47	}	1✔
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() {	1✔
52	s.mu.Lock()	1✔
53	defer s.mu.Unlock()	1✔
54		1✔
55	s.NumTasksAccepted++	1✔
56	s.NumTasksPending--	1✔
57	}	1✔
58
59	// getStatsCopy returns a copy of the ClientStats.
60	func (s *clientStats) getStatsCopy() ClientStats {	1✔
61	s.mu.Lock()	1✔
62	defer s.mu.Unlock()	1✔
63		1✔
64	return s.ClientStats	1✔
65	}	1✔
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.
71	func (s *clientStats) taskIneligible() {	×
72	s.mu.Lock()	×
73	defer s.mu.Unlock()	×
74		×
75	s.NumTasksIneligible++	×
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() {	1✔
81	s.mu.Lock()	1✔
82	defer s.mu.Unlock()	1✔
83		1✔
84	s.NumSessionsAcquired++	1✔
85	}	1✔
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() {	1✔
90	s.mu.Lock()	1✔
91	defer s.mu.Unlock()	1✔
92		1✔
93	s.NumSessionsExhausted++	1✔
94	}	1✔
95
96	// String returns a human-readable summary of the client's metrics.
97	func (s *clientStats) String() string {	1✔
98	s.mu.Lock()	1✔
99	defer s.mu.Unlock()	1✔
100		1✔
101	return fmt.Sprintf("tasks(received=%d accepted=%d ineligible=%d) "+	1✔
102	"sessions(acquired=%d exhausted=%d)", s.NumTasksPending,	1✔
103	s.NumTasksAccepted, s.NumTasksIneligible, s.NumSessionsAcquired,	1✔
104	s.NumSessionsExhausted)	1✔
105	}	1✔

lightningnetwork / lnd / 12033440129

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