13587276956

Committed 28 Feb 2025 11:32AM UTC coverage: 58.857% (+7.8%) from 51.098%

Build # 13587276956

Build Type

Pull #9567

github

Committed by

ellemouton

Commit Message

itest: make sure to not hit the natural ChannelUpdate rate limit

Channel Updates have a natural rate limit of 1 update per second due to
the fact that the timestamp carried in the update is only accurate to
the second. So we need to ensure that the next update we send in the
burst is at least 1 second after the last one.

Pull Request Pull Request #9567: itest: make sure to not hit the natural ChannelUpdate rate limit

Run Details

136630 of 232137 relevant lines covered (58.86%)

19201.78 hits per line

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

90.14

/contractcourt/breach_resolver.go

package contractcourt

import (
        "encoding/binary"
        "fmt"
        "io"

        "github.com/lightningnetwork/lnd/channeldb"
)

// breachResolver is a resolver that will handle breached closes. In the
// future, this will likely take over the duties the current BreachArbitrator
// has.
type breachResolver struct {
        // subscribed denotes whether or not the breach resolver has subscribed
        // to the BreachArbitrator for breach resolution.
        subscribed bool

        // replyChan is closed when the breach arbiter has completed serving
        // justice.
        replyChan chan struct{}

        contractResolverKit
}

// newBreachResolver instantiates a new breach resolver.
func newBreachResolver(resCfg ResolverConfig) *breachResolver {
        r := &breachResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
                replyChan:           make(chan struct{}),
        }

        r.initLogger(fmt.Sprintf("%T(%v)", r, r.ChanPoint))

        return r
}

// ResolverKey returns the unique identifier for this resolver.
func (b *breachResolver) ResolverKey() []byte {
        key := newResolverID(b.ChanPoint)
        return key[:]
}

// Resolve queries the BreachArbitrator to see if the justice transaction has
// been broadcast.
//
// NOTE: Part of the ContractResolver interface.
//
// TODO(yy): let sweeper handle the breach inputs.
func (b *breachResolver) Resolve() (ContractResolver, error) {
        if !b.subscribed {
                complete, err := b.SubscribeBreachComplete(
                        &b.ChanPoint, b.replyChan,
                )
                if err != nil {
                        return nil, err
                }

                // If the breach resolution process is already complete, then
                // we can cleanup and checkpoint the resolved state.
                if complete {
                        b.markResolved()
                        return nil, b.Checkpoint(b)
                }

                // Prevent duplicate subscriptions.
                b.subscribed = true
        }

        select {
        case <-b.replyChan:
                // The replyChan has been closed, signalling that the breach
                // has been fully resolved. Checkpoint the resolved state and
                // exit.
                b.markResolved()
                return nil, b.Checkpoint(b)

        case <-b.quit:
        }

        return nil, errResolverShuttingDown
}

// Stop signals the breachResolver to stop.
func (b *breachResolver) Stop() {
        b.log.Debugf("stopping...")
        close(b.quit)
}

// SupplementState adds additional state to the breachResolver.
func (b *breachResolver) SupplementState(_ *channeldb.OpenChannel) {
}

// Encode encodes the breachResolver to the passed writer.
func (b *breachResolver) Encode(w io.Writer) error {
        return binary.Write(w, endian, b.IsResolved())
}

// newBreachResolverFromReader attempts to decode an encoded breachResolver
// from the passed Reader instance, returning an active breachResolver.
func newBreachResolverFromReader(r io.Reader, resCfg ResolverConfig) (
        *breachResolver, error) {

        b := &breachResolver{
                contractResolverKit: *newContractResolverKit(resCfg),
                replyChan:           make(chan struct{}),
        }

        var resolved bool
        if err := binary.Read(r, endian, &resolved); err != nil {
                return nil, err
        }
        if resolved {
                b.markResolved()
        }

        b.initLogger(fmt.Sprintf("%T(%v)", b, b.ChanPoint))

        return b, nil
}

// A compile time assertion to ensure breachResolver meets the ContractResolver
// interface.
var _ ContractResolver = (*breachResolver)(nil)

// Launch offers the breach outputs to the sweeper - currently it's a NOOP as
// the outputs here are not offered to the sweeper.
//
// NOTE: Part of the ContractResolver interface.
//
// TODO(yy): implement it once the outputs are offered to the sweeper.
func (b *breachResolver) Launch() error {
        if b.isLaunched() {
                b.log.Tracef("already launched")
                return nil
        }

        b.log.Debugf("launching resolver...")
        b.markLaunched()

        return nil
}

1	package contractcourt
2
3	import (
4	"encoding/binary"
5	"fmt"
6	"io"
7
8	"github.com/lightningnetwork/lnd/channeldb"
9	)
10
11	// breachResolver is a resolver that will handle breached closes. In the
12	// future, this will likely take over the duties the current BreachArbitrator
13	// has.
14	type breachResolver struct {
15	// subscribed denotes whether or not the breach resolver has subscribed
16	// to the BreachArbitrator for breach resolution.
17	subscribed bool
18
19	// replyChan is closed when the breach arbiter has completed serving
20	// justice.
21	replyChan chan struct{}
22
23	contractResolverKit
24	}
25
26	// newBreachResolver instantiates a new breach resolver.
27	func newBreachResolver(resCfg ResolverConfig) *breachResolver {	5✔
28	r := &breachResolver{	5✔
29	contractResolverKit: *newContractResolverKit(resCfg),	5✔
30	replyChan: make(chan struct{}),	5✔
31	}	5✔
32		5✔
33	r.initLogger(fmt.Sprintf("%T(%v)", r, r.ChanPoint))	5✔
34		5✔
35	return r	5✔
36	}	5✔
37
38	// ResolverKey returns the unique identifier for this resolver.
39	func (b *breachResolver) ResolverKey() []byte {	7✔
40	key := newResolverID(b.ChanPoint)	7✔
41	return key[:]	7✔
42	}	7✔
43
44	// Resolve queries the BreachArbitrator to see if the justice transaction has
45	// been broadcast.
46	//
47	// NOTE: Part of the ContractResolver interface.
48	//
49	// TODO(yy): let sweeper handle the breach inputs.
50	func (b *breachResolver) Resolve() (ContractResolver, error) {	5✔
51	if !b.subscribed {	10✔
52	complete, err := b.SubscribeBreachComplete(	5✔
53	&b.ChanPoint, b.replyChan,	5✔
54	)	5✔
55	if err != nil {	5✔
56	return nil, err	×
57	}	×
58
59	// If the breach resolution process is already complete, then
60	// we can cleanup and checkpoint the resolved state.
61	if complete {	5✔
62	b.markResolved()	×
63	return nil, b.Checkpoint(b)	×
64	}	×
65
66	// Prevent duplicate subscriptions.
67	b.subscribed = true	5✔
68	}
69
70	select {	5✔
71	case <-b.replyChan:	5✔
72	// The replyChan has been closed, signalling that the breach	5✔
73	// has been fully resolved. Checkpoint the resolved state and	5✔
74	// exit.	5✔
75	b.markResolved()	5✔
76	return nil, b.Checkpoint(b)	5✔
77
78	case <-b.quit:	3✔
79	}
80
81	return nil, errResolverShuttingDown	3✔
82	}
83
84	// Stop signals the breachResolver to stop.
85	func (b *breachResolver) Stop() {	5✔
86	b.log.Debugf("stopping...")	5✔
87	close(b.quit)	5✔
88	}	5✔
89
90	// SupplementState adds additional state to the breachResolver.
91	func (b breachResolver) SupplementState(_ channeldb.OpenChannel) {	3✔
92	}	3✔
93
94	// Encode encodes the breachResolver to the passed writer.
95	func (b *breachResolver) Encode(w io.Writer) error {	3✔
96	return binary.Write(w, endian, b.IsResolved())	3✔
97	}	3✔
98
99	// newBreachResolverFromReader attempts to decode an encoded breachResolver
100	// from the passed Reader instance, returning an active breachResolver.
101	func newBreachResolverFromReader(r io.Reader, resCfg ResolverConfig) (
102	*breachResolver, error) {	3✔
103		3✔
104	b := &breachResolver{	3✔
105	contractResolverKit: *newContractResolverKit(resCfg),	3✔
106	replyChan: make(chan struct{}),	3✔
107	}	3✔
108		3✔
109	var resolved bool	3✔
110	if err := binary.Read(r, endian, &resolved); err != nil {	3✔
111	return nil, err	×
112	}	×
113	if resolved {	4✔
114	b.markResolved()	1✔
115	}	1✔
116
117	b.initLogger(fmt.Sprintf("%T(%v)", b, b.ChanPoint))	3✔
118		3✔
119	return b, nil	3✔
120	}
121
122	// A compile time assertion to ensure breachResolver meets the ContractResolver
123	// interface.
124	var _ ContractResolver = (*breachResolver)(nil)
125
126	// Launch offers the breach outputs to the sweeper - currently it's a NOOP as
127	// the outputs here are not offered to the sweeper.
128	//
129	// NOTE: Part of the ContractResolver interface.
130	//
131	// TODO(yy): implement it once the outputs are offered to the sweeper.
132	func (b *breachResolver) Launch() error {	5✔
133	if b.isLaunched() {	8✔
134	b.log.Tracef("already launched")	3✔
135	return nil	3✔
136	}	3✔
137
138	b.log.Debugf("launching resolver...")	5✔
139	b.markLaunched()	5✔
140		5✔
141	return nil	5✔
142	}

lightningnetwork / lnd / 13587276956

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