12293715361

Committed 12 Dec 2024 09:38AM UTC coverage: 57.483% (+7.9%) from 49.538%

Build # 12293715361

Build Type

Pull #9348

github

Committed by

ziggie1984

Commit Message

github: update goveralls tool

The goverall tool had a bug regarding the module versioning of
golang packages see also
https://github.com/mattn/goveralls/pull/222 for more background.
Goveralls is wrapped by another library to make it available for
github actions. So the relevant PR which is referenced here in
LND is:
https://github.com/shogo82148/actions-goveralls/pull/521.

Pull Request Pull Request #9348: github: update goveralls tool

Run Details

101897 of 177264 relevant lines covered (57.48%)

24982.4 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 / 12293715361

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