-
Notifications
You must be signed in to change notification settings - Fork 199
/
interceptedHeartbeat.go
158 lines (133 loc) · 4.22 KB
/
interceptedHeartbeat.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package heartbeat
import (
"fmt"
"github.com/multiversx/mx-chain-core-go/core"
"github.com/multiversx/mx-chain-core-go/core/check"
"github.com/multiversx/mx-chain-core-go/marshal"
"github.com/multiversx/mx-chain-go/heartbeat"
"github.com/multiversx/mx-chain-go/process"
logger "github.com/multiversx/mx-chain-logger-go"
)
const uint32Size = 4
const uint64Size = 8
var log = logger.GetOrCreate("process/heartbeat")
// ArgBaseInterceptedHeartbeat is the base argument used for messages
type ArgBaseInterceptedHeartbeat struct {
DataBuff []byte
Marshaller marshal.Marshalizer
}
// interceptedHeartbeat is a wrapper over HeartbeatV2
type interceptedHeartbeat struct {
heartbeat heartbeat.HeartbeatV2
payload heartbeat.Payload
}
// NewInterceptedHeartbeat tries to create a new intercepted heartbeat instance
func NewInterceptedHeartbeat(arg ArgBaseInterceptedHeartbeat) (*interceptedHeartbeat, error) {
err := checkBaseArg(arg)
if err != nil {
return nil, err
}
hb, payload, err := createHeartbeat(arg.Marshaller, arg.DataBuff)
if err != nil {
return nil, err
}
intercepted := &interceptedHeartbeat{
heartbeat: *hb,
payload: *payload,
}
return intercepted, nil
}
func checkBaseArg(arg ArgBaseInterceptedHeartbeat) error {
if len(arg.DataBuff) == 0 {
return process.ErrNilBuffer
}
if check.IfNil(arg.Marshaller) {
return process.ErrNilMarshalizer
}
return nil
}
func createHeartbeat(marshaller marshal.Marshalizer, buff []byte) (*heartbeat.HeartbeatV2, *heartbeat.Payload, error) {
hb := &heartbeat.HeartbeatV2{}
err := marshaller.Unmarshal(hb, buff)
if err != nil {
return nil, nil, err
}
payload := &heartbeat.Payload{}
err = marshaller.Unmarshal(payload, hb.Payload)
if err != nil {
return nil, nil, err
}
log.Trace("interceptedHeartbeat successfully created")
return hb, payload, nil
}
// CheckValidity will check the validity of the received peer heartbeat
func (ihb *interceptedHeartbeat) CheckValidity() error {
err := verifyPropertyMinMaxLen(payloadProperty, ihb.heartbeat.Payload)
if err != nil {
return err
}
err = verifyPropertyMinMaxLen(versionNumberProperty, []byte(ihb.heartbeat.VersionNumber))
if err != nil {
return err
}
err = verifyPropertyMaxLen(nodeDisplayNameProperty, []byte(ihb.heartbeat.NodeDisplayName))
if err != nil {
return err
}
err = verifyPropertyMaxLen(identityProperty, []byte(ihb.heartbeat.Identity))
if err != nil {
return err
}
if ihb.heartbeat.PeerSubType != uint32(core.RegularPeer) && ihb.heartbeat.PeerSubType != uint32(core.FullHistoryObserver) {
return process.ErrInvalidPeerSubType
}
err = verifyPropertyMinMaxLen(publicKeyProperty, ihb.heartbeat.Pubkey)
if err != nil {
return err
}
log.Trace("interceptedHeartbeat received valid data")
return nil
}
// IsForCurrentShard always returns true
func (ihb *interceptedHeartbeat) IsForCurrentShard() bool {
return true
}
// Hash always returns an empty string
func (ihb *interceptedHeartbeat) Hash() []byte {
return []byte("")
}
// Type returns the type of this intercepted data
func (ihb *interceptedHeartbeat) Type() string {
return interceptedHeartbeatType
}
// Identifiers returns the identifiers used in requests
func (ihb *interceptedHeartbeat) Identifiers() [][]byte {
return [][]byte{[]byte(ihb.String())}
}
// String returns the most important fields as string
func (ihb *interceptedHeartbeat) String() string {
return fmt.Sprintf("version=%s, name=%s, identity=%s, nonce=%d, subtype=%d, payload=%s, pk=%s",
ihb.heartbeat.VersionNumber,
ihb.heartbeat.NodeDisplayName,
ihb.heartbeat.Identity,
ihb.heartbeat.Nonce,
ihb.heartbeat.PeerSubType,
logger.DisplayByteSlice(ihb.heartbeat.Payload),
logger.DisplayByteSlice(ihb.heartbeat.Pubkey))
}
// Message returns the heartbeat message
func (ihb *interceptedHeartbeat) Message() interface{} {
return &ihb.heartbeat
}
// SizeInBytes returns the size in bytes held by this instance
func (ihb *interceptedHeartbeat) SizeInBytes() int {
return len(ihb.heartbeat.Payload) +
len(ihb.heartbeat.VersionNumber) +
len(ihb.heartbeat.NodeDisplayName) +
len(ihb.heartbeat.Identity) +
uint64Size + uint32Size
}
// IsInterfaceNil returns true if there is no value under the interface
func (ihb *interceptedHeartbeat) IsInterfaceNil() bool {
return ihb == nil
}