13440912774

Committed 20 Feb 2025 05:14PM UTC coverage: 57.697% (-1.1%) from 58.802%

Build # 13440912774

Build Type

Pull #9535

github

Committed by

guggero

Commit Message

GitHub: remove duplicate caching

Turns out that actions/setup-go starting with @v4 also adds caching.
With that, our cache size on disk has almost doubled, leading to the
GitHub runner running out of space in certain situation.
We fix that by disabling the automated caching since we already have our
own, custom-tailored version.

Pull Request Pull Request #9535: GitHub: remove duplicate caching

Run Details

103519 of 179417 relevant lines covered (57.7%)

24825.3 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 {	148,313✔
35	return &AMP{	148,313✔
36	rootShare: rootShare,	148,313✔
37	setID: setID,	148,313✔
38	childIndex: childIndex,	148,313✔
39	}	148,313✔
40	}	148,313✔
41
42	// RootShare returns the root share contained in the AMP record.
43	func (a *AMP) RootShare() [32]byte {	74,066✔
44	return a.rootShare	74,066✔
45	}	74,066✔
46
47	// SetID returns the set id contained in the AMP record.
48	func (a *AMP) SetID() [32]byte {	263,301✔
49	return a.setID	263,301✔
50	}	263,301✔
51
52	// ChildIndex returns the child index contained in the AMP record.
53	func (a *AMP) ChildIndex() uint32 {	74,066✔
54	return a.childIndex	74,066✔
55	}	74,066✔
56
57	// AMPEncoder writes the AMP record to the provided io.Writer.
58	func AMPEncoder(w io.Writer, val interface{}, buf *[8]byte) error {	59✔
59	if v, ok := val.(*AMP); ok {	118✔
60	if err := tlv.EBytes32(w, &v.rootShare, buf); err != nil {	59✔
61	return err	×
62	}	×
63
64	if err := tlv.EBytes32(w, &v.setID, buf); err != nil {	59✔
65	return err	×
66	}	×
67
68	return tlv.ETUint32T(w, v.childIndex, buf)	59✔
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 {	116✔
87	if v, ok := val.(*AMP); ok && minAMPLength <= l && l <= maxAMPLength {	232✔
88	if err := tlv.DBytes32(r, &v.rootShare, buf, 32); err != nil {	116✔
89	return err	×
90	}	×
91
92	if err := tlv.DBytes32(r, &v.setID, buf, 32); err != nil {	116✔
93	return err	×
94	}	×
95
96	return tlv.DTUint32(r, &v.childIndex, buf, l-minAMPLength)	116✔
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 {	57✔
103	return tlv.MakeDynamicRecord(	57✔
104	AMPOnionType, a, a.PayloadSize, AMPEncoder, AMPDecoder,	57✔
105	)	57✔
106	}	57✔
107
108	// PayloadSize returns the size this record takes up in encoded form.
109	func (a *AMP) PayloadSize() uint64 {	61✔
110	return 32 + 32 + tlv.SizeTUint32(a.childIndex)	61✔
111	}	61✔
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 / 13440912774

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