12312390362

Committed 13 Dec 2024 08:44AM UTC coverage: 57.458% (+8.5%) from 48.92%

Build # 12312390362

Build Type

Pull #9343

github

Committed by

ellemouton

Commit Message

fn: rework the ContextGuard and add tests

In this commit, the ContextGuard struct is re-worked such that the
context that its new main WithCtx method provides is cancelled in sync
with a parent context being cancelled or with it's quit channel being
cancelled. Tests are added to assert the behaviour. In order for the
close of the quit channel to be consistent with the cancelling of the
derived context, the quit channel _must_ be contained internal to the
ContextGuard so that callers are only able to close the channel via the
exposed Quit method which will then take care to first cancel any
derived context that depend on the quit channel before returning.

Pull Request Pull Request #9343: fn: expand the ContextGuard and add tests

Run Details

101853 of 177264 relevant lines covered (57.46%)

24972.93 hits per line

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

31.25

/intercepted_forward.go

package lnd

import (
        "errors"

        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/htlcswitch"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwire"
)

var (
        // ErrCannotResume is returned when an intercepted forward cannot be
        // resumed. This is the case in the on-chain resolution flow.
        ErrCannotResume = errors.New("cannot resume in the on-chain flow")

        // ErrCannotFail is returned when an intercepted forward cannot be failed.
        // This is the case in the on-chain resolution flow.
        ErrCannotFail = errors.New("cannot fail in the on-chain flow")

        // ErrPreimageMismatch is returned when the preimage that is specified to
        // settle an htlc doesn't match the htlc hash.
        ErrPreimageMismatch = errors.New("preimage does not match hash")
)

// interceptedForward implements the on-chain behavior for the resolution of
// a forwarded htlc.
type interceptedForward struct {
        packet *htlcswitch.InterceptedPacket
        beacon *preimageBeacon
}

func newInterceptedForward(
        packet *htlcswitch.InterceptedPacket,
        beacon *preimageBeacon) *interceptedForward {

        return &interceptedForward{
                beacon: beacon,
                packet: packet,
        }
}

// Packet returns the intercepted htlc packet.
func (f *interceptedForward) Packet() htlcswitch.InterceptedPacket {
        return *f.packet
}

// Resume notifies the intention to resume an existing hold forward. This
// basically means the caller wants to resume with the default behavior for this
// htlc which usually means forward it.
func (f *interceptedForward) Resume() error {
        return ErrCannotResume
}

// ResumeModified notifies the intention to resume an existing hold forward with
// a modified htlc.
func (f *interceptedForward) ResumeModified(_, _ fn.Option[lnwire.MilliSatoshi],
        _ fn.Option[lnwire.CustomRecords]) error {

        return ErrCannotResume
}

// Fail notifies the intention to fail an existing hold forward with an
// encrypted failure reason.
func (f *interceptedForward) Fail(_ []byte) error {
        // We can't actively fail an htlc. The best we could do is abandon the
        // resolver, but this wouldn't be a safe operation. There may be a race
        // with the preimage beacon supplying a preimage. Therefore we don't
        // attempt to fail and just return an error here.
        return ErrCannotFail
}

// FailWithCode notifies the intention to fail an existing hold forward with the
// specified failure code.
func (f *interceptedForward) FailWithCode(_ lnwire.FailCode) error {
        return ErrCannotFail
}

// Settle notifies the intention to settle an existing hold forward with a given
// preimage.
func (f *interceptedForward) Settle(preimage lntypes.Preimage) error {
        if !preimage.Matches(f.packet.Hash) {
                return ErrPreimageMismatch
        }

        // Add preimage to the preimage beacon. The onchain resolver will pick
        // up the preimage from the beacon.
        return f.beacon.AddPreimages(preimage)
}

1	package lnd
2
3	import (
4	"errors"
5
6	"github.com/lightningnetwork/lnd/fn/v2"
7	"github.com/lightningnetwork/lnd/htlcswitch"
8	"github.com/lightningnetwork/lnd/lntypes"
9	"github.com/lightningnetwork/lnd/lnwire"
10	)
11
12	var (
13	// ErrCannotResume is returned when an intercepted forward cannot be
14	// resumed. This is the case in the on-chain resolution flow.
15	ErrCannotResume = errors.New("cannot resume in the on-chain flow")
16
17	// ErrCannotFail is returned when an intercepted forward cannot be failed.
18	// This is the case in the on-chain resolution flow.
19	ErrCannotFail = errors.New("cannot fail in the on-chain flow")
20
21	// ErrPreimageMismatch is returned when the preimage that is specified to
22	// settle an htlc doesn't match the htlc hash.
23	ErrPreimageMismatch = errors.New("preimage does not match hash")
24	)
25
26	// interceptedForward implements the on-chain behavior for the resolution of
27	// a forwarded htlc.
28	type interceptedForward struct {
29	packet *htlcswitch.InterceptedPacket
30	beacon *preimageBeacon
31	}
32
33	func newInterceptedForward(
34	packet *htlcswitch.InterceptedPacket,
35	beacon preimageBeacon) interceptedForward {	1✔
36		1✔
37	return &interceptedForward{	1✔
38	beacon: beacon,	1✔
39	packet: packet,	1✔
40	}	1✔
41	}	1✔
42
43	// Packet returns the intercepted htlc packet.
44	func (f *interceptedForward) Packet() htlcswitch.InterceptedPacket {	×
45	return *f.packet	×
46	}	×
47
48	// Resume notifies the intention to resume an existing hold forward. This
49	// basically means the caller wants to resume with the default behavior for this
50	// htlc which usually means forward it.
51	func (f *interceptedForward) Resume() error {	×
52	return ErrCannotResume	×
53	}	×
54
55	// ResumeModified notifies the intention to resume an existing hold forward with
56	// a modified htlc.
57	func (f *interceptedForward) ResumeModified(_, _ fn.Option[lnwire.MilliSatoshi],
58	_ fn.Option[lnwire.CustomRecords]) error {	×
59		×
60	return ErrCannotResume	×
61	}	×
62
63	// Fail notifies the intention to fail an existing hold forward with an
64	// encrypted failure reason.
65	func (f *interceptedForward) Fail(_ []byte) error {	×
66	// We can't actively fail an htlc. The best we could do is abandon the	×
67	// resolver, but this wouldn't be a safe operation. There may be a race	×
68	// with the preimage beacon supplying a preimage. Therefore we don't	×
69	// attempt to fail and just return an error here.	×
70	return ErrCannotFail	×
71	}	×
72
73	// FailWithCode notifies the intention to fail an existing hold forward with the
74	// specified failure code.
75	func (f *interceptedForward) FailWithCode(_ lnwire.FailCode) error {	×
76	return ErrCannotFail	×
77	}	×
78
79	// Settle notifies the intention to settle an existing hold forward with a given
80	// preimage.
81	func (f *interceptedForward) Settle(preimage lntypes.Preimage) error {	1✔
82	if !preimage.Matches(f.packet.Hash) {	1✔
83	return ErrPreimageMismatch	×
84	}	×
85
86	// Add preimage to the preimage beacon. The onchain resolver will pick
87	// up the preimage from the beacon.
88	return f.beacon.AddPreimages(preimage)	1✔
89	}

lightningnetwork / lnd / 12312390362

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