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

57.45

/lnwire/custom.go

package lnwire

import (
        "bytes"
        "fmt"
        "io"
        "sync"
)

// CustomTypeStart is the start of the custom type range for peer messages as
// defined in BOLT 01.
const CustomTypeStart MessageType = 32768

var (
        // customTypeOverride contains a set of message types < CustomTypeStart
        // that lnd allows to be treated as custom messages. This allows us to
        // override messages reserved for the protocol level and treat them as
        // custom messages. This set of message types is stored as a global so
        // that we do not need to pass around state when accounting for this
        // set of messages in message creation.
        //
        // Note: This global is protected by the customTypeOverride mutex.
        customTypeOverride map[MessageType]struct{}

        // customTypeOverrideMtx manages concurrent access to
        // customTypeOverride.
        customTypeOverrideMtx sync.RWMutex
)

// SetCustomOverrides validates that the set of override types are outside of
// the custom message range (there's no reason to override messages that are
// already within the range), and updates the customTypeOverride global to hold
// this set of message types. Note that this function will completely overwrite
// the set of overrides, so should be called with the full set of types.
func SetCustomOverrides(overrideTypes []uint16) error {
        customTypeOverrideMtx.Lock()
        defer customTypeOverrideMtx.Unlock()

        customTypeOverride = make(map[MessageType]struct{}, len(overrideTypes))

        for _, t := range overrideTypes {
                msgType := MessageType(t)

                if msgType >= CustomTypeStart {
                        return fmt.Errorf("can't override type: %v, already "+
                                "in custom range", t)
                }

                customTypeOverride[msgType] = struct{}{}
        }

        return nil
}

// IsCustomOverride returns a bool indicating whether the message type is one
// of the protocol messages that we override for custom use.
func IsCustomOverride(t MessageType) bool {
        customTypeOverrideMtx.RLock()
        defer customTypeOverrideMtx.RUnlock()

        _, ok := customTypeOverride[t]

        return ok
}

// Custom represents an application-defined wire message.
type Custom struct {
        Type MessageType
        Data []byte
}

// A compile time check to ensure FundingCreated implements the lnwire.Message
// interface.
var _ Message = (*Custom)(nil)

// NewCustom instantiates a new custom message.
func NewCustom(msgType MessageType, data []byte) (*Custom, error) {
        if msgType < CustomTypeStart && !IsCustomOverride(msgType) {
                return nil, fmt.Errorf("msg type: %d not in custom range: %v "+
                        "and not overridden", msgType, CustomTypeStart)
        }

        return &Custom{
                Type: msgType,
                Data: data,
        }, nil
}

// Encode serializes the target Custom message into the passed io.Writer
// implementation.
//
// This is part of the lnwire.Message interface.
func (c *Custom) Encode(b *bytes.Buffer, pver uint32) error {
        _, err := b.Write(c.Data)
        return err
}

// Decode deserializes the serialized Custom message stored in the passed
// io.Reader into the target Custom message.
//
// This is part of the lnwire.Message interface.
func (c *Custom) Decode(r io.Reader, pver uint32) error {
        var b bytes.Buffer
        if _, err := io.Copy(&b, r); err != nil {
                return err
        }

        c.Data = b.Bytes()

        return nil
}

// MsgType returns the uint32 code which uniquely identifies this message as a
// Custom message on the wire.
//
// This is part of the lnwire.Message interface.
func (c *Custom) MsgType() MessageType {
        return c.Type
}

1	package lnwire
2
3	import (
4	"bytes"
5	"fmt"
6	"io"
7	"sync"
8	)
9
10	// CustomTypeStart is the start of the custom type range for peer messages as
11	// defined in BOLT 01.
12	const CustomTypeStart MessageType = 32768
13
14	var (
15	// customTypeOverride contains a set of message types < CustomTypeStart
16	// that lnd allows to be treated as custom messages. This allows us to
17	// override messages reserved for the protocol level and treat them as
18	// custom messages. This set of message types is stored as a global so
19	// that we do not need to pass around state when accounting for this
20	// set of messages in message creation.
21	//
22	// Note: This global is protected by the customTypeOverride mutex.
23	customTypeOverride map[MessageType]struct{}
24
25	// customTypeOverrideMtx manages concurrent access to
26	// customTypeOverride.
27	customTypeOverrideMtx sync.RWMutex
28	)
29
30	// SetCustomOverrides validates that the set of override types are outside of
31	// the custom message range (there's no reason to override messages that are
32	// already within the range), and updates the customTypeOverride global to hold
33	// this set of message types. Note that this function will completely overwrite
34	// the set of overrides, so should be called with the full set of types.
35	func SetCustomOverrides(overrideTypes []uint16) error {	×
36	customTypeOverrideMtx.Lock()	×
37	defer customTypeOverrideMtx.Unlock()	×
38		×
39	customTypeOverride = make(map[MessageType]struct{}, len(overrideTypes))	×
40		×
41	for _, t := range overrideTypes {	×
42	msgType := MessageType(t)	×
43		×
44	if msgType >= CustomTypeStart {	×
45	return fmt.Errorf("can't override type: %v, already "+	×
46	"in custom range", t)	×
47	}	×
48
49	customTypeOverride[msgType] = struct{}{}	×
50	}
51
52	return nil	×
53	}
54
55	// IsCustomOverride returns a bool indicating whether the message type is one
56	// of the protocol messages that we override for custom use.
57	func IsCustomOverride(t MessageType) bool {	1✔
58	customTypeOverrideMtx.RLock()	1✔
59	defer customTypeOverrideMtx.RUnlock()	1✔
60		1✔
61	_, ok := customTypeOverride[t]	1✔
62		1✔
63	return ok	1✔
64	}	1✔
65
66	// Custom represents an application-defined wire message.
67	type Custom struct {
68	Type MessageType
69	Data []byte
70	}
71
72	// A compile time check to ensure FundingCreated implements the lnwire.Message
73	// interface.
74	var _ Message = (*Custom)(nil)
75
76	// NewCustom instantiates a new custom message.
77	func NewCustom(msgType MessageType, data []byte) (*Custom, error) {	2✔
78	if msgType < CustomTypeStart && !IsCustomOverride(msgType) {	2✔
79	return nil, fmt.Errorf("msg type: %d not in custom range: %v "+	×
80	"and not overridden", msgType, CustomTypeStart)	×
81	}	×
82
83	return &Custom{	2✔
84	Type: msgType,	2✔
85	Data: data,	2✔
86	}, nil	2✔
87	}
88
89	// Encode serializes the target Custom message into the passed io.Writer
90	// implementation.
91	//
92	// This is part of the lnwire.Message interface.
93	func (c Custom) Encode(b bytes.Buffer, pver uint32) error {	5✔
94	_, err := b.Write(c.Data)	5✔
95	return err	5✔
96	}	5✔
97
98	// Decode deserializes the serialized Custom message stored in the passed
99	// io.Reader into the target Custom message.
100	//
101	// This is part of the lnwire.Message interface.
102	func (c *Custom) Decode(r io.Reader, pver uint32) error {	9✔
103	var b bytes.Buffer	9✔
104	if _, err := io.Copy(&b, r); err != nil {	9✔
105	return err	×
106	}	×
107
108	c.Data = b.Bytes()	9✔
109		9✔
110	return nil	9✔
111	}
112
113	// MsgType returns the uint32 code which uniquely identifies this message as a
114	// Custom message on the wire.
115	//
116	// This is part of the lnwire.Message interface.
117	func (c *Custom) MsgType() MessageType {	5✔
118	return c.Type	5✔
119	}	5✔

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