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

68.0

/record/amp.go

package record

import (
        "fmt"
        "io"

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

// AMPOnionType is the type used in the onion to reference the AMP fields:
// root_share, set_id, and child_index.
const AMPOnionType tlv.Type = 14

// AMP is a record that encodes the fields necessary for atomic multi-path
// payments.
type AMP struct {
        rootShare  [32]byte
        setID      [32]byte
        childIndex uint32
}

// MaxAmpPayLoadSize is an AMP Record which when serialized to a tlv record uses
// the maximum payload size. The `childIndex` is created randomly and is a
// 4 byte `varint` type so we make sure we use an index which will be encoded in
// 4 bytes.
var MaxAmpPayLoadSize = AMP{
        rootShare:  [32]byte{},
        setID:      [32]byte{},
        childIndex: 0x80000000,
}

// NewAMP generate a new AMP record with the given root_share, set_id, and
// child_index.
func NewAMP(rootShare, setID [32]byte, childIndex uint32) *AMP {
        return &AMP{
                rootShare:  rootShare,
                setID:      setID,
                childIndex: childIndex,
        }
}

// RootShare returns the root share contained in the AMP record.
func (a *AMP) RootShare() [32]byte {
        return a.rootShare
}

// SetID returns the set id contained in the AMP record.
func (a *AMP) SetID() [32]byte {
        return a.setID
}

// ChildIndex returns the child index contained in the AMP record.
func (a *AMP) ChildIndex() uint32 {
        return a.childIndex
}

// AMPEncoder writes the AMP record to the provided io.Writer.
func AMPEncoder(w io.Writer, val interface{}, buf *[8]byte) error {
        if v, ok := val.(*AMP); ok {
                if err := tlv.EBytes32(w, &v.rootShare, buf); err != nil {
                        return err
                }

                if err := tlv.EBytes32(w, &v.setID, buf); err != nil {
                        return err
                }

                return tlv.ETUint32T(w, v.childIndex, buf)
        }
        return tlv.NewTypeForEncodingErr(val, "AMP")
}

const (
        // minAMPLength is the minimum length of a serialized AMP TLV record,
        // which occurs when the truncated encoding of child_index takes 0
        // bytes, leaving only the root_share and set_id.
        minAMPLength = 64

        // maxAMPLength is the maximum length of a serialized AMP TLV record,
        // which occurs when the truncated encoding of a child_index takes 2
        // bytes.
        maxAMPLength = 68
)

// AMPDecoder reads the AMP record from the provided io.Reader.
func AMPDecoder(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {
        if v, ok := val.(*AMP); ok && minAMPLength <= l && l <= maxAMPLength {
                if err := tlv.DBytes32(r, &v.rootShare, buf, 32); err != nil {
                        return err
                }

                if err := tlv.DBytes32(r, &v.setID, buf, 32); err != nil {
                        return err
                }

                return tlv.DTUint32(r, &v.childIndex, buf, l-minAMPLength)
        }
        return tlv.NewTypeForDecodingErr(val, "AMP", l, maxAMPLength)
}

// Record returns a tlv.Record that can be used to encode or decode this record.
func (a *AMP) Record() tlv.Record {
        return tlv.MakeDynamicRecord(
                AMPOnionType, a, a.PayloadSize, AMPEncoder, AMPDecoder,
        )
}

// PayloadSize returns the size this record takes up in encoded form.
func (a *AMP) PayloadSize() uint64 {
        return 32 + 32 + tlv.SizeTUint32(a.childIndex)
}

// String returns a human-readable description of the amp payload fields.
func (a *AMP) String() string {
        if a == nil {
                return "<nil>"
        }

        return fmt.Sprintf("root_share=%x set_id=%x child_index=%d",
                a.rootShare, a.setID, a.childIndex)
}

1	package record
2
3	import (
4	"fmt"
5	"io"
6
7	"github.com/lightningnetwork/lnd/tlv"
8	)
9
10	// AMPOnionType is the type used in the onion to reference the AMP fields:
11	// root_share, set_id, and child_index.
12	const AMPOnionType tlv.Type = 14
13
14	// AMP is a record that encodes the fields necessary for atomic multi-path
15	// payments.
16	type AMP struct {
17	rootShare [32]byte
18	setID [32]byte
19	childIndex uint32
20	}
21
22	// MaxAmpPayLoadSize is an AMP Record which when serialized to a tlv record uses
23	// the maximum payload size. The `childIndex` is created randomly and is a
24	// 4 byte `varint` type so we make sure we use an index which will be encoded in
25	// 4 bytes.
26	var MaxAmpPayLoadSize = AMP{
27	rootShare: [32]byte{},
28	setID: [32]byte{},
29	childIndex: 0x80000000,
30	}
31
32	// NewAMP generate a new AMP record with the given root_share, set_id, and
33	// child_index.
34	func NewAMP(rootShare, setID [32]byte, childIndex uint32) *AMP {	256✔
35	return &AMP{	256✔
36	rootShare: rootShare,	256✔
37	setID: setID,	256✔
38	childIndex: childIndex,	256✔
39	}	256✔
40	}	256✔
41
42	// RootShare returns the root share contained in the AMP record.
43	func (a *AMP) RootShare() [32]byte {	74✔
44	return a.rootShare	74✔
45	}	74✔
46
47	// SetID returns the set id contained in the AMP record.
48	func (a *AMP) SetID() [32]byte {	706✔
49	return a.setID	706✔
50	}	706✔
51
52	// ChildIndex returns the child index contained in the AMP record.
53	func (a *AMP) ChildIndex() uint32 {	74✔
54	return a.childIndex	74✔
55	}	74✔
56
57	// AMPEncoder writes the AMP record to the provided io.Writer.
58	func AMPEncoder(w io.Writer, val interface{}, buf *[8]byte) error {	106✔
59	if v, ok := val.(*AMP); ok {	212✔
60	if err := tlv.EBytes32(w, &v.rootShare, buf); err != nil {	106✔
61	return err	×
62	}	×
63
64	if err := tlv.EBytes32(w, &v.setID, buf); err != nil {	106✔
65	return err	×
66	}	×
67
68	return tlv.ETUint32T(w, v.childIndex, buf)	106✔
69	}
70	return tlv.NewTypeForEncodingErr(val, "AMP")	×
71	}
72
73	const (
74	// minAMPLength is the minimum length of a serialized AMP TLV record,
75	// which occurs when the truncated encoding of child_index takes 0
76	// bytes, leaving only the root_share and set_id.
77	minAMPLength = 64
78
79	// maxAMPLength is the maximum length of a serialized AMP TLV record,
80	// which occurs when the truncated encoding of a child_index takes 2
81	// bytes.
82	maxAMPLength = 68
83	)
84
85	// AMPDecoder reads the AMP record from the provided io.Reader.
86	func AMPDecoder(r io.Reader, val interface{}, buf *[8]byte, l uint64) error {	739✔
87	if v, ok := val.(*AMP); ok && minAMPLength <= l && l <= maxAMPLength {	1,478✔
88	if err := tlv.DBytes32(r, &v.rootShare, buf, 32); err != nil {	739✔
89	return err	×
90	}	×
91
92	if err := tlv.DBytes32(r, &v.setID, buf, 32); err != nil {	739✔
93	return err	×
94	}	×
95
96	return tlv.DTUint32(r, &v.childIndex, buf, l-minAMPLength)	739✔
97	}
98	return tlv.NewTypeForDecodingErr(val, "AMP", l, maxAMPLength)	×
99	}
100
101	// Record returns a tlv.Record that can be used to encode or decode this record.
102	func (a *AMP) Record() tlv.Record {	799✔
103	return tlv.MakeDynamicRecord(	799✔
104	AMPOnionType, a, a.PayloadSize, AMPEncoder, AMPDecoder,	799✔
105	)	799✔
106	}	799✔
107
108	// PayloadSize returns the size this record takes up in encoded form.
109	func (a *AMP) PayloadSize() uint64 {	42✔
110	return 32 + 32 + tlv.SizeTUint32(a.childIndex)	42✔
111	}	42✔
112
113	// String returns a human-readable description of the amp payload fields.
114	func (a *AMP) String() string {	×
115	if a == nil {	×
116	return "<nil>"	×
117	}	×
118
119	return fmt.Sprintf("root_share=%x set_id=%x child_index=%d",	×
120	a.rootShare, a.setID, a.childIndex)	×
121	}

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