From 69d38bd5937e027d7c644e63353b901ec1b80300 Mon Sep 17 00:00:00 2001
From: Wolfgang Welz <welzwo@gmail.com>
Date: Wed, 12 Jun 2019 11:32:58 +0200
Subject: [PATCH] Fix linter errors and warnings
---
.golangci.yml | 2 -
packages/database/database.go | 9 +-
.../datastructure/doubly_linked_list_test.go | 12 +-
packages/iac/iac.go | 2 +-
packages/transaction/constants.go | 2 +-
packages/transaction/transaction.go | 2 +-
packages/typeconversion/typeconversion.go | 2 +-
plugins/analysis/server/constants.go | 10 +-
plugins/analysis/server/plugin.go | 64 +++---
plugins/analysis/types/addnode/constants.go | 16 +-
plugins/analysis/types/addnode/packet.go | 18 +-
.../analysis/types/connectnodes/constants.go | 22 +-
plugins/analysis/types/connectnodes/packet.go | 24 +--
.../types/disconnectnodes/constants.go | 22 +-
.../analysis/types/disconnectnodes/packet.go | 24 +--
plugins/analysis/types/ping/constants.go | 10 +-
plugins/analysis/types/ping/packet.go | 12 +-
.../analysis/types/removenode/constants.go | 16 +-
plugins/analysis/types/removenode/packet.go | 18 +-
.../recordedevents/recorded_events.go | 4 +-
plugins/autopeering/server/tcp/server.go | 36 ++--
plugins/autopeering/server/udp/server.go | 8 +-
plugins/autopeering/types/drop/constants.go | 22 +-
plugins/autopeering/types/drop/drop.go | 22 +-
plugins/autopeering/types/peer/constants.go | 38 ++--
plugins/autopeering/types/peer/peer.go | 38 ++--
plugins/autopeering/types/ping/constants.go | 32 +--
plugins/autopeering/types/ping/ping.go | 34 ++--
.../autopeering/types/request/constants.go | 6 +-
plugins/autopeering/types/request/request.go | 10 +-
.../autopeering/types/response/constants.go | 38 ++--
.../autopeering/types/response/response.go | 44 ++--
plugins/autopeering/types/salt/constants.go | 2 +-
plugins/autopeering/types/salt/salt.go | 10 +-
plugins/cli/plugin.go | 2 -
plugins/gossip/neighbors.go | 10 +-
plugins/gossip/protocol_v1.go | 28 +--
plugins/gossip/transaction_processor_test.go | 4 +-
plugins/statusscreen/ui_header_bar.go | 3 +-
plugins/tangle/approvers.go | 55 ++---
plugins/tangle/solidifier.go | 4 +-
plugins/tangle/transaction.go | 48 +++--
plugins/tangle/transaction_metadata.go | 190 +++++++++---------
43 files changed, 482 insertions(+), 493 deletions(-)
diff --git a/.golangci.yml b/.golangci.yml
index dc169135..6de39205 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -4,8 +4,6 @@ run:
linters-settings:
gofmt:
simplify: true
- goimports:
- local-prefixes: github.com/iotaledger/goshimmer
golint:
min-confidence: 0.9
gocyclo:
diff --git a/packages/database/database.go b/packages/database/database.go
index 9ac44a31..61d0fcbe 100644
--- a/packages/database/database.go
+++ b/packages/database/database.go
@@ -78,14 +78,16 @@ func (this *databaseImpl) Set(key []byte, value []byte) error {
}
func (this *databaseImpl) Contains(key []byte) (bool, error) {
- if err := this.db.View(func(txn *badger.Txn) error {
+ err := this.db.View(func(txn *badger.Txn) error {
_, err := txn.Get(key)
if err != nil {
return err
}
return nil
- }); err == ErrKeyNotFound {
+ })
+
+ if err == ErrKeyNotFound {
return false, nil
} else {
return err == nil, err
@@ -94,9 +96,8 @@ func (this *databaseImpl) Contains(key []byte) (bool, error) {
func (this *databaseImpl) Get(key []byte) ([]byte, error) {
var result []byte = nil
- var err error = nil
- err = this.db.View(func(txn *badger.Txn) error {
+ err := this.db.View(func(txn *badger.Txn) error {
item, err := txn.Get(key)
if err != nil {
return err
diff --git a/packages/datastructure/doubly_linked_list_test.go b/packages/datastructure/doubly_linked_list_test.go
index 4e44086a..7d43f0ce 100644
--- a/packages/datastructure/doubly_linked_list_test.go
+++ b/packages/datastructure/doubly_linked_list_test.go
@@ -29,11 +29,9 @@ func TestDelete(t *testing.T) {
t.Error(err)
}
- firstEntry, err := doublyLinkedList.GetFirst()
- if err != nil {
+ if firstEntry, err := doublyLinkedList.GetFirst(); err != nil {
t.Error(err)
- }
- if firstEntry != 13 {
+ } else if firstEntry != 13 {
t.Error("first entry should be 13 after delete")
}
@@ -41,11 +39,9 @@ func TestDelete(t *testing.T) {
t.Error(err)
}
- lastEntry, err := doublyLinkedList.GetLast()
- if err != nil {
+ if lastEntry, err := doublyLinkedList.GetLast(); err != nil {
t.Error(err)
- }
- if lastEntry != 15 {
+ } else if lastEntry != 15 {
t.Error("last entry should be 15 after delete")
}
diff --git a/packages/iac/iac.go b/packages/iac/iac.go
index 4d8153c4..02e860db 100644
--- a/packages/iac/iac.go
+++ b/packages/iac/iac.go
@@ -7,7 +7,7 @@ import (
)
func Decode(trinary ternary.Trinary) (result *Area, err errors.IdentifiableError) {
- if olcCode, conversionErr := OLCCodeFromTrinary(trinary); err != nil {
+ if olcCode, conversionErr := OLCCodeFromTrinary(trinary); conversionErr != nil {
err = conversionErr
} else {
if codeArea, olcErr := olc.Decode(olcCode); olcErr == nil {
diff --git a/packages/transaction/constants.go b/packages/transaction/constants.go
index dd329015..0b821f5e 100644
--- a/packages/transaction/constants.go
+++ b/packages/transaction/constants.go
@@ -41,5 +41,5 @@ const (
NONCE_END = NONCE_OFFSET + NONCE_SIZE
// the full size of a transaction
- MARSHALLED_TOTAL_SIZE = NONCE_END
+ MARSHALED_TOTAL_SIZE = NONCE_END
)
diff --git a/packages/transaction/transaction.go b/packages/transaction/transaction.go
index 9d703309..0c606d8a 100644
--- a/packages/transaction/transaction.go
+++ b/packages/transaction/transaction.go
@@ -49,7 +49,7 @@ func FromTrits(trits ternary.Trits, optionalHash ...ternary.Trits) *Transaction
}
func FromBytes(bytes []byte) *Transaction {
- transaction := FromTrits(ternary.BytesToTrits(bytes)[:MARSHALLED_TOTAL_SIZE])
+ transaction := FromTrits(ternary.BytesToTrits(bytes)[:MARSHALED_TOTAL_SIZE])
transaction.Bytes = bytes
return transaction
diff --git a/packages/typeconversion/typeconversion.go b/packages/typeconversion/typeconversion.go
index ed053ee8..4ed9a507 100644
--- a/packages/typeconversion/typeconversion.go
+++ b/packages/typeconversion/typeconversion.go
@@ -8,7 +8,7 @@ import (
func BytesToString(b []byte) string {
bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
- return *(*string)(unsafe.Pointer(&reflect.StringHeader{bh.Data, bh.Len}))
+ return *(*string)(unsafe.Pointer(&reflect.StringHeader{Data: bh.Data, Len: bh.Len}))
}
func StringToBytes(str string) []byte {
diff --git a/plugins/analysis/server/constants.go b/plugins/analysis/server/constants.go
index 63083804..b4c1f739 100644
--- a/plugins/analysis/server/constants.go
+++ b/plugins/analysis/server/constants.go
@@ -16,9 +16,9 @@ const (
STATE_INITIAL = byte(255)
STATE_INITIAL_ADDNODE = byte(254)
STATE_CONSECUTIVE = byte(253)
- STATE_PING = ping.MARSHALLED_PACKET_HEADER
- STATE_ADD_NODE = addnode.MARSHALLED_PACKET_HEADER
- STATE_REMOVE_NODE = removenode.MARSHALLED_PACKET_HEADER
- STATE_CONNECT_NODES = connectnodes.MARSHALLED_PACKET_HEADER
- STATE_DISCONNECT_NODES = disconnectnodes.MARSHALLED_PACKET_HEADER
+ STATE_PING = ping.MARSHALED_PACKET_HEADER
+ STATE_ADD_NODE = addnode.MARSHALED_PACKET_HEADER
+ STATE_REMOVE_NODE = removenode.MARSHALED_PACKET_HEADER
+ STATE_CONNECT_NODES = connectnodes.MARSHALED_PACKET_HEADER
+ STATE_DISCONNECT_NODES = disconnectnodes.MARSHALED_PACKET_HEADER
)
diff --git a/plugins/analysis/server/plugin.go b/plugins/analysis/server/plugin.go
index c8e9f0b7..86522f1c 100644
--- a/plugins/analysis/server/plugin.go
+++ b/plugins/analysis/server/plugin.go
@@ -73,11 +73,11 @@ func HandleConnection(conn *network.ManagedConnection) {
conn.Events.Close.Attach(onDisconnect)
maxPacketsSize := getMaxPacketSize(
- ping.MARSHALLED_TOTAL_SIZE,
- addnode.MARSHALLED_TOTAL_SIZE,
- removenode.MARSHALLED_TOTAL_SIZE,
- connectnodes.MARSHALLED_TOTAL_SIZE,
- disconnectnodes.MARSHALLED_PACKET_HEADER,
+ ping.MARSHALED_TOTAL_SIZE,
+ addnode.MARSHALED_TOTAL_SIZE,
+ removenode.MARSHALED_TOTAL_SIZE,
+ connectnodes.MARSHALED_TOTAL_SIZE,
+ disconnectnodes.MARSHALED_PACKET_HEADER,
)
go conn.Read(make([]byte, maxPacketsSize))
@@ -112,19 +112,19 @@ func processIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *n
switch *connectionState {
case STATE_ADD_NODE:
- *receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, addnode.MARSHALED_TOTAL_SIZE)
case STATE_PING:
- *receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
case STATE_CONNECT_NODES:
- *receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, connectnodes.MARSHALED_TOTAL_SIZE)
case STATE_DISCONNECT_NODES:
- *receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, disconnectnodes.MARSHALED_TOTAL_SIZE)
case STATE_REMOVE_NODE:
- *receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, removenode.MARSHALED_TOTAL_SIZE)
}
}
@@ -162,28 +162,28 @@ func parsePackageHeader(data []byte) (ConnectionState, []byte, error) {
var receiveBuffer []byte
switch data[0] {
- case ping.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ case ping.MARSHALED_PACKET_HEADER:
+ receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
connectionState = STATE_PING
- case addnode.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
+ case addnode.MARSHALED_PACKET_HEADER:
+ receiveBuffer = make([]byte, addnode.MARSHALED_TOTAL_SIZE)
connectionState = STATE_ADD_NODE
- case connectnodes.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
+ case connectnodes.MARSHALED_PACKET_HEADER:
+ receiveBuffer = make([]byte, connectnodes.MARSHALED_TOTAL_SIZE)
connectionState = STATE_CONNECT_NODES
- case disconnectnodes.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
+ case disconnectnodes.MARSHALED_PACKET_HEADER:
+ receiveBuffer = make([]byte, disconnectnodes.MARSHALED_TOTAL_SIZE)
connectionState = STATE_DISCONNECT_NODES
- case removenode.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
+ case removenode.MARSHALED_PACKET_HEADER:
+ receiveBuffer = make([]byte, removenode.MARSHALED_TOTAL_SIZE)
connectionState = STATE_REMOVE_NODE
@@ -195,11 +195,11 @@ func parsePackageHeader(data []byte) (ConnectionState, []byte, error) {
}
func processIncomingAddNodePacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
- remainingCapacity := int(math.Min(float64(addnode.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+ remainingCapacity := int(math.Min(float64(addnode.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset+len(data) < addnode.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) < addnode.MARSHALED_TOTAL_SIZE {
*offset += len(data)
} else {
if addNodePacket, err := addnode.Unmarshal(*receiveBuffer); err != nil {
@@ -222,18 +222,18 @@ func processIncomingAddNodePacket(connectionState *byte, receiveBuffer *[]byte,
*connectionState = STATE_CONSECUTIVE
- if *offset+len(data) > addnode.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) > addnode.MARSHALED_TOTAL_SIZE {
processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
}
}
}
func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
- remainingCapacity := int(math.Min(float64(ping.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+ remainingCapacity := int(math.Min(float64(ping.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset+len(data) < ping.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) < ping.MARSHALED_TOTAL_SIZE {
*offset += len(data)
} else {
if _, err := ping.Unmarshal(*receiveBuffer); err != nil {
@@ -246,18 +246,18 @@ func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, con
*connectionState = STATE_CONSECUTIVE
- if *offset+len(data) > ping.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) > ping.MARSHALED_TOTAL_SIZE {
processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
}
}
}
func processIncomingConnectNodesPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
- remainingCapacity := int(math.Min(float64(connectnodes.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+ remainingCapacity := int(math.Min(float64(connectnodes.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset+len(data) < connectnodes.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) < connectnodes.MARSHALED_TOTAL_SIZE {
*offset += len(data)
} else {
if connectNodesPacket, err := connectnodes.Unmarshal(*receiveBuffer); err != nil {
@@ -275,18 +275,18 @@ func processIncomingConnectNodesPacket(connectionState *byte, receiveBuffer *[]b
*connectionState = STATE_CONSECUTIVE
- if *offset+len(data) > connectnodes.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) > connectnodes.MARSHALED_TOTAL_SIZE {
processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
}
}
}
func processIncomingDisconnectNodesPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
- remainingCapacity := int(math.Min(float64(disconnectnodes.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+ remainingCapacity := int(math.Min(float64(disconnectnodes.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset+len(data) < disconnectnodes.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) < disconnectnodes.MARSHALED_TOTAL_SIZE {
*offset += len(data)
} else {
if disconnectNodesPacket, err := disconnectnodes.Unmarshal(*receiveBuffer); err != nil {
@@ -304,7 +304,7 @@ func processIncomingDisconnectNodesPacket(connectionState *byte, receiveBuffer *
*connectionState = STATE_CONSECUTIVE
- if *offset+len(data) > disconnectnodes.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) > disconnectnodes.MARSHALED_TOTAL_SIZE {
processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
}
}
diff --git a/plugins/analysis/types/addnode/constants.go b/plugins/analysis/types/addnode/constants.go
index 43636315..6534ce8d 100644
--- a/plugins/analysis/types/addnode/constants.go
+++ b/plugins/analysis/types/addnode/constants.go
@@ -1,15 +1,15 @@
package addnode
const (
- MARSHALLED_PACKET_HEADER = 0x01
+ MARSHALED_PACKET_HEADER = 0x01
- MARSHALLED_PACKET_HEADER_START = 0
- MARSHALLED_PACKET_HEADER_SIZE = 1
- MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+ MARSHALED_PACKET_HEADER_START = 0
+ MARSHALED_PACKET_HEADER_SIZE = 1
+ MARSHALED_PACKET_HEADER_END = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
- MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
- MARSHALLED_ID_SIZE = 20
- MARSHALLED_ID_END = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
+ MARSHALED_ID_START = MARSHALED_PACKET_HEADER_END
+ MARSHALED_ID_SIZE = 20
+ MARSHALED_ID_END = MARSHALED_ID_START + MARSHALED_ID_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_ID_END
)
diff --git a/plugins/analysis/types/addnode/packet.go b/plugins/analysis/types/addnode/packet.go
index d378b677..79d0274d 100644
--- a/plugins/analysis/types/addnode/packet.go
+++ b/plugins/analysis/types/addnode/packet.go
@@ -7,24 +7,24 @@ type Packet struct {
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+ if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
return nil, errors.New("malformed add node packet")
}
- unmarshalledPackage := &Packet{
- NodeId: make([]byte, MARSHALLED_ID_SIZE),
+ unmarshaledPackage := &Packet{
+ NodeId: make([]byte, MARSHALED_ID_SIZE),
}
- copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
+ copy(unmarshaledPackage.NodeId, data[MARSHALED_ID_START:MARSHALED_ID_END])
- return unmarshalledPackage, nil
+ return unmarshaledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
+ marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+ copy(marshaledPackage[MARSHALED_ID_START:MARSHALED_ID_END], packet.NodeId[:MARSHALED_ID_SIZE])
- return marshalledPackage
+ return marshaledPackage
}
diff --git a/plugins/analysis/types/connectnodes/constants.go b/plugins/analysis/types/connectnodes/constants.go
index 564264df..d4006520 100644
--- a/plugins/analysis/types/connectnodes/constants.go
+++ b/plugins/analysis/types/connectnodes/constants.go
@@ -1,19 +1,19 @@
package connectnodes
const (
- MARSHALLED_PACKET_HEADER = 0x03
+ MARSHALED_PACKET_HEADER = 0x03
- MARSHALLED_PACKET_HEADER_START = 0
- MARSHALLED_PACKET_HEADER_SIZE = 1
- MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+ MARSHALED_PACKET_HEADER_START = 0
+ MARSHALED_PACKET_HEADER_SIZE = 1
+ MARSHALED_PACKET_HEADER_END = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
- MARSHALLED_SOURCE_ID_START = MARSHALLED_PACKET_HEADER_END
- MARSHALLED_SOURCE_ID_SIZE = 20
- MARSHALLED_SOURCE_ID_END = MARSHALLED_SOURCE_ID_START + MARSHALLED_SOURCE_ID_SIZE
+ MARSHALED_SOURCE_ID_START = MARSHALED_PACKET_HEADER_END
+ MARSHALED_SOURCE_ID_SIZE = 20
+ MARSHALED_SOURCE_ID_END = MARSHALED_SOURCE_ID_START + MARSHALED_SOURCE_ID_SIZE
- MARSHALLED_TARGET_ID_START = MARSHALLED_SOURCE_ID_END
- MARSHALLED_TARGET_ID_SIZE = 20
- MARSHALLED_TARGET_ID_END = MARSHALLED_TARGET_ID_START + MARSHALLED_TARGET_ID_SIZE
+ MARSHALED_TARGET_ID_START = MARSHALED_SOURCE_ID_END
+ MARSHALED_TARGET_ID_SIZE = 20
+ MARSHALED_TARGET_ID_END = MARSHALED_TARGET_ID_START + MARSHALED_TARGET_ID_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_TARGET_ID_END
)
diff --git a/plugins/analysis/types/connectnodes/packet.go b/plugins/analysis/types/connectnodes/packet.go
index 954c5607..7d9c05a8 100644
--- a/plugins/analysis/types/connectnodes/packet.go
+++ b/plugins/analysis/types/connectnodes/packet.go
@@ -8,27 +8,27 @@ type Packet struct {
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+ if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
return nil, errors.New("malformed connect nodes packet")
}
- unmarshalledPackage := &Packet{
- SourceId: make([]byte, MARSHALLED_SOURCE_ID_SIZE),
- TargetId: make([]byte, MARSHALLED_TARGET_ID_SIZE),
+ unmarshaledPackage := &Packet{
+ SourceId: make([]byte, MARSHALED_SOURCE_ID_SIZE),
+ TargetId: make([]byte, MARSHALED_TARGET_ID_SIZE),
}
- copy(unmarshalledPackage.SourceId, data[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END])
- copy(unmarshalledPackage.TargetId, data[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END])
+ copy(unmarshaledPackage.SourceId, data[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END])
+ copy(unmarshaledPackage.TargetId, data[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END])
- return unmarshalledPackage, nil
+ return unmarshaledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(marshalledPackage[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END], packet.SourceId[:MARSHALLED_SOURCE_ID_SIZE])
- copy(marshalledPackage[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END], packet.TargetId[:MARSHALLED_TARGET_ID_SIZE])
+ marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+ copy(marshaledPackage[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END], packet.SourceId[:MARSHALED_SOURCE_ID_SIZE])
+ copy(marshaledPackage[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END], packet.TargetId[:MARSHALED_TARGET_ID_SIZE])
- return marshalledPackage
+ return marshaledPackage
}
diff --git a/plugins/analysis/types/disconnectnodes/constants.go b/plugins/analysis/types/disconnectnodes/constants.go
index 5145c909..928a723f 100644
--- a/plugins/analysis/types/disconnectnodes/constants.go
+++ b/plugins/analysis/types/disconnectnodes/constants.go
@@ -1,19 +1,19 @@
package disconnectnodes
const (
- MARSHALLED_PACKET_HEADER = 0x04
+ MARSHALED_PACKET_HEADER = 0x04
- MARSHALLED_PACKET_HEADER_START = 0
- MARSHALLED_PACKET_HEADER_SIZE = 1
- MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+ MARSHALED_PACKET_HEADER_START = 0
+ MARSHALED_PACKET_HEADER_SIZE = 1
+ MARSHALED_PACKET_HEADER_END = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
- MARSHALLED_SOURCE_ID_START = MARSHALLED_PACKET_HEADER_END
- MARSHALLED_SOURCE_ID_SIZE = 20
- MARSHALLED_SOURCE_ID_END = MARSHALLED_SOURCE_ID_START + MARSHALLED_SOURCE_ID_SIZE
+ MARSHALED_SOURCE_ID_START = MARSHALED_PACKET_HEADER_END
+ MARSHALED_SOURCE_ID_SIZE = 20
+ MARSHALED_SOURCE_ID_END = MARSHALED_SOURCE_ID_START + MARSHALED_SOURCE_ID_SIZE
- MARSHALLED_TARGET_ID_START = MARSHALLED_SOURCE_ID_END
- MARSHALLED_TARGET_ID_SIZE = 20
- MARSHALLED_TARGET_ID_END = MARSHALLED_TARGET_ID_START + MARSHALLED_TARGET_ID_SIZE
+ MARSHALED_TARGET_ID_START = MARSHALED_SOURCE_ID_END
+ MARSHALED_TARGET_ID_SIZE = 20
+ MARSHALED_TARGET_ID_END = MARSHALED_TARGET_ID_START + MARSHALED_TARGET_ID_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_TARGET_ID_END
)
diff --git a/plugins/analysis/types/disconnectnodes/packet.go b/plugins/analysis/types/disconnectnodes/packet.go
index bf708645..9193312e 100644
--- a/plugins/analysis/types/disconnectnodes/packet.go
+++ b/plugins/analysis/types/disconnectnodes/packet.go
@@ -8,27 +8,27 @@ type Packet struct {
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+ if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
return nil, errors.New("malformed disconnect nodes packet")
}
- unmarshalledPackage := &Packet{
- SourceId: make([]byte, MARSHALLED_SOURCE_ID_SIZE),
- TargetId: make([]byte, MARSHALLED_TARGET_ID_SIZE),
+ unmarshaledPackage := &Packet{
+ SourceId: make([]byte, MARSHALED_SOURCE_ID_SIZE),
+ TargetId: make([]byte, MARSHALED_TARGET_ID_SIZE),
}
- copy(unmarshalledPackage.SourceId, data[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END])
- copy(unmarshalledPackage.TargetId, data[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END])
+ copy(unmarshaledPackage.SourceId, data[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END])
+ copy(unmarshaledPackage.TargetId, data[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END])
- return unmarshalledPackage, nil
+ return unmarshaledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(marshalledPackage[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END], packet.SourceId[:MARSHALLED_SOURCE_ID_SIZE])
- copy(marshalledPackage[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END], packet.TargetId[:MARSHALLED_TARGET_ID_SIZE])
+ marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+ copy(marshaledPackage[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END], packet.SourceId[:MARSHALED_SOURCE_ID_SIZE])
+ copy(marshaledPackage[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END], packet.TargetId[:MARSHALED_TARGET_ID_SIZE])
- return marshalledPackage
+ return marshaledPackage
}
diff --git a/plugins/analysis/types/ping/constants.go b/plugins/analysis/types/ping/constants.go
index f3fd24bf..41de5de4 100644
--- a/plugins/analysis/types/ping/constants.go
+++ b/plugins/analysis/types/ping/constants.go
@@ -1,11 +1,11 @@
package ping
const (
- MARSHALLED_PACKET_HEADER = 0x00
+ MARSHALED_PACKET_HEADER = 0x00
- MARSHALLED_PACKET_HEADER_START = 0
- MARSHALLED_PACKET_HEADER_SIZE = 1
- MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+ MARSHALED_PACKET_HEADER_START = 0
+ MARSHALED_PACKET_HEADER_SIZE = 1
+ MARSHALED_PACKET_HEADER_END = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_PACKET_HEADER_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_PACKET_HEADER_END
)
diff --git a/plugins/analysis/types/ping/packet.go b/plugins/analysis/types/ping/packet.go
index 89728d17..6325771d 100644
--- a/plugins/analysis/types/ping/packet.go
+++ b/plugins/analysis/types/ping/packet.go
@@ -5,19 +5,19 @@ import "github.com/pkg/errors"
type Packet struct{}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[MARSHALLED_PACKET_HEADER_START] != MARSHALLED_PACKET_HEADER {
+ if len(data) < MARSHALED_TOTAL_SIZE || data[MARSHALED_PACKET_HEADER_START] != MARSHALED_PACKET_HEADER {
return nil, errors.New("malformed ping packet")
}
- unmarshalledPacket := &Packet{}
+ unmarshaledPacket := &Packet{}
- return unmarshalledPacket, nil
+ return unmarshaledPacket, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+ marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
- return marshalledPackage
+ return marshaledPackage
}
diff --git a/plugins/analysis/types/removenode/constants.go b/plugins/analysis/types/removenode/constants.go
index 269d4bec..52d9bcc5 100644
--- a/plugins/analysis/types/removenode/constants.go
+++ b/plugins/analysis/types/removenode/constants.go
@@ -1,15 +1,15 @@
package removenode
const (
- MARSHALLED_PACKET_HEADER = 0x02
+ MARSHALED_PACKET_HEADER = 0x02
- MARSHALLED_PACKET_HEADER_START = 0
- MARSHALLED_PACKET_HEADER_SIZE = 1
- MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+ MARSHALED_PACKET_HEADER_START = 0
+ MARSHALED_PACKET_HEADER_SIZE = 1
+ MARSHALED_PACKET_HEADER_END = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
- MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
- MARSHALLED_ID_SIZE = 20
- MARSHALLED_ID_END = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
+ MARSHALED_ID_START = MARSHALED_PACKET_HEADER_END
+ MARSHALED_ID_SIZE = 20
+ MARSHALED_ID_END = MARSHALED_ID_START + MARSHALED_ID_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_ID_END
)
diff --git a/plugins/analysis/types/removenode/packet.go b/plugins/analysis/types/removenode/packet.go
index 504f3f3c..c44bf94b 100644
--- a/plugins/analysis/types/removenode/packet.go
+++ b/plugins/analysis/types/removenode/packet.go
@@ -7,24 +7,24 @@ type Packet struct {
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+ if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
return nil, errors.New("malformed remove node packet")
}
- unmarshalledPackage := &Packet{
- NodeId: make([]byte, MARSHALLED_ID_SIZE),
+ unmarshaledPackage := &Packet{
+ NodeId: make([]byte, MARSHALED_ID_SIZE),
}
- copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
+ copy(unmarshaledPackage.NodeId, data[MARSHALED_ID_START:MARSHALED_ID_END])
- return unmarshalledPackage, nil
+ return unmarshaledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
+ marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+ copy(marshaledPackage[MARSHALED_ID_START:MARSHALED_ID_END], packet.NodeId[:MARSHALED_ID_SIZE])
- return marshalledPackage
+ return marshaledPackage
}
diff --git a/plugins/analysis/webinterface/recordedevents/recorded_events.go b/plugins/analysis/webinterface/recordedevents/recorded_events.go
index 19aa2035..3110aa6a 100644
--- a/plugins/analysis/webinterface/recordedevents/recorded_events.go
+++ b/plugins/analysis/webinterface/recordedevents/recorded_events.go
@@ -9,8 +9,6 @@ import (
"github.com/iotaledger/goshimmer/plugins/analysis/webinterface/types"
)
-var recordedEvents = make([]types.EventHandlersConsumer, 0)
-
var nodes = make(map[string]bool)
var links = make(map[string]map[string]bool)
@@ -84,7 +82,7 @@ func Replay(handlers *types.EventHandlers) {
}
for sourceId, targetMap := range links {
- for targetId, _ := range targetMap {
+ for targetId := range targetMap {
handlers.ConnectNodes(sourceId, targetId)
}
}
diff --git a/plugins/autopeering/server/tcp/server.go b/plugins/autopeering/server/tcp/server.go
index 570b8075..3d4977aa 100644
--- a/plugins/autopeering/server/tcp/server.go
+++ b/plugins/autopeering/server/tcp/server.go
@@ -65,7 +65,7 @@ func HandleConnection(conn *network.ManagedConnection) {
ProcessIncomingPacket(&connectionState, &receiveBuffer, conn, data, &offset)
}))
- go conn.Read(make([]byte, int(math.Max(ping.MARSHALLED_TOTAL_SIZE, math.Max(request.MARSHALLED_TOTAL_SIZE, response.MARSHALLED_TOTAL_SIZE)))))
+ go conn.Read(make([]byte, int(math.Max(ping.MARSHALED_TOTAL_SIZE, math.Max(request.MARSHALED_TOTAL_SIZE, response.MARSHALED_TOTAL_SIZE)))))
}
func ProcessIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
@@ -83,11 +83,11 @@ func ProcessIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *n
switch *connectionState {
case STATE_REQUEST:
- *receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, request.MARSHALED_TOTAL_SIZE)
case STATE_RESPONSE:
- *receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, response.MARSHALED_TOTAL_SIZE)
case STATE_PING:
- *receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ *receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
}
}
@@ -106,16 +106,16 @@ func parsePackageHeader(data []byte) (byte, []byte, error) {
var receiveBuffer []byte
switch data[0] {
- case request.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
+ case request.MARSHALED_PACKET_HEADER:
+ receiveBuffer = make([]byte, request.MARSHALED_TOTAL_SIZE)
connectionState = STATE_REQUEST
case response.MARHSALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
+ receiveBuffer = make([]byte, response.MARSHALED_TOTAL_SIZE)
connectionState = STATE_RESPONSE
- case ping.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ case ping.MARSHALED_PACKET_HEADER:
+ receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
connectionState = STATE_PING
default:
@@ -126,11 +126,11 @@ func parsePackageHeader(data []byte) (byte, []byte, error) {
}
func processIncomingRequestPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
- remainingCapacity := int(math.Min(float64(request.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+ remainingCapacity := int(math.Min(float64(request.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset+len(data) < request.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) < request.MARSHALED_TOTAL_SIZE {
*offset += len(data)
} else {
if req, err := request.Unmarshal(*receiveBuffer); err != nil {
@@ -152,18 +152,18 @@ func processIncomingRequestPacket(connectionState *byte, receiveBuffer *[]byte,
*connectionState = STATE_INITIAL
- if *offset+len(data) > request.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) > request.MARSHALED_TOTAL_SIZE {
ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
}
}
}
func processIncomingResponsePacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
- remainingCapacity := int(math.Min(float64(response.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+ remainingCapacity := int(math.Min(float64(response.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset+len(data) < response.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) < response.MARSHALED_TOTAL_SIZE {
*offset += len(data)
} else {
if res, err := response.Unmarshal(*receiveBuffer); err != nil {
@@ -185,18 +185,18 @@ func processIncomingResponsePacket(connectionState *byte, receiveBuffer *[]byte,
*connectionState = STATE_INITIAL
- if *offset+len(data) > response.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) > response.MARSHALED_TOTAL_SIZE {
ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
}
}
}
func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
- remainingCapacity := int(math.Min(float64(ping.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+ remainingCapacity := int(math.Min(float64(ping.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset+len(data) < ping.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) < ping.MARSHALED_TOTAL_SIZE {
*offset += len(data)
} else {
if ping, err := ping.Unmarshal(*receiveBuffer); err != nil {
@@ -218,7 +218,7 @@ func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, con
*connectionState = STATE_INITIAL
- if *offset+len(data) > ping.MARSHALLED_TOTAL_SIZE {
+ if *offset+len(data) > ping.MARSHALED_TOTAL_SIZE {
ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
}
}
diff --git a/plugins/autopeering/server/udp/server.go b/plugins/autopeering/server/udp/server.go
index 563a9d88..01e66fad 100644
--- a/plugins/autopeering/server/udp/server.go
+++ b/plugins/autopeering/server/udp/server.go
@@ -17,7 +17,7 @@ import (
"github.com/pkg/errors"
)
-var udpServer = udp.NewServer(int(math.Max(float64(request.MARSHALLED_TOTAL_SIZE), float64(response.MARSHALLED_TOTAL_SIZE))))
+var udpServer = udp.NewServer(int(math.Max(float64(request.MARSHALED_TOTAL_SIZE), float64(response.MARSHALED_TOTAL_SIZE))))
func ConfigureServer(plugin *node.Plugin) {
Events.Error.Attach(events.NewClosure(func(ip net.IP, err error) {
@@ -60,7 +60,7 @@ func ShutdownUDPServer(plugin *node.Plugin) {
func processReceivedData(addr *net.UDPAddr, data []byte) {
switch data[0] {
- case request.MARSHALLED_PACKET_HEADER:
+ case request.MARSHALED_PACKET_HEADER:
if peeringRequest, err := request.Unmarshal(data); err != nil {
Events.Error.Trigger(addr.IP, err)
} else {
@@ -76,7 +76,7 @@ func processReceivedData(addr *net.UDPAddr, data []byte) {
Events.ReceiveResponse.Trigger(peeringResponse)
}
- case ping.MARSHALLED_PACKET_HEADER:
+ case ping.MARSHALED_PACKET_HEADER:
if ping, err := ping.Unmarshal(data); err != nil {
Events.Error.Trigger(addr.IP, err)
} else {
@@ -84,7 +84,7 @@ func processReceivedData(addr *net.UDPAddr, data []byte) {
Events.ReceivePing.Trigger(ping)
}
- case drop.MARSHALLED_PACKET_HEADER:
+ case drop.MARSHALED_PACKET_HEADER:
if drop, err := drop.Unmarshal(data); err != nil {
Events.Error.Trigger(addr.IP, err)
} else {
diff --git a/plugins/autopeering/types/drop/constants.go b/plugins/autopeering/types/drop/constants.go
index ccc3c1d6..b12728d7 100644
--- a/plugins/autopeering/types/drop/constants.go
+++ b/plugins/autopeering/types/drop/constants.go
@@ -5,19 +5,19 @@ import (
)
const (
- MARSHALLED_PACKET_HEADER = 0x05
+ MARSHALED_PACKET_HEADER = 0x05
- PACKET_HEADER_START = 0
- MARSHALLED_ISSUER_START = PACKET_HEADER_END
- MARSHALLED_SIGNATURE_START = MARSHALLED_ISSUER_END
+ PACKET_HEADER_START = 0
+ MARSHALED_ISSUER_START = PACKET_HEADER_END
+ MARSHALED_SIGNATURE_START = MARSHALED_ISSUER_END
- PACKET_HEADER_END = PACKET_HEADER_START + PACKET_HEADER_SIZE
- MARSHALLED_ISSUER_END = MARSHALLED_ISSUER_START + MARSHALLED_ISSUER_SIZE
- MARSHALLED_SIGNATURE_END = MARSHALLED_SIGNATURE_START + MARSHALLED_SIGNATURE_SIZE
+ PACKET_HEADER_END = PACKET_HEADER_START + PACKET_HEADER_SIZE
+ MARSHALED_ISSUER_END = MARSHALED_ISSUER_START + MARSHALED_ISSUER_SIZE
+ MARSHALED_SIGNATURE_END = MARSHALED_SIGNATURE_START + MARSHALED_SIGNATURE_SIZE
- PACKET_HEADER_SIZE = 1
- MARSHALLED_ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
- MARSHALLED_SIGNATURE_SIZE = 65
+ PACKET_HEADER_SIZE = 1
+ MARSHALED_ISSUER_SIZE = peer.MARSHALED_TOTAL_SIZE
+ MARSHALED_SIGNATURE_SIZE = 65
- MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_SIGNATURE_END
)
diff --git a/plugins/autopeering/types/drop/drop.go b/plugins/autopeering/types/drop/drop.go
index e86b5cfa..4ed249d2 100644
--- a/plugins/autopeering/types/drop/drop.go
+++ b/plugins/autopeering/types/drop/drop.go
@@ -10,49 +10,49 @@ import (
type Drop struct {
Issuer *peer.Peer
- Signature [MARSHALLED_SIGNATURE_SIZE]byte
+ Signature [MARSHALED_SIGNATURE_SIZE]byte
}
func Unmarshal(data []byte) (*Drop, error) {
- if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+ if data[0] != MARSHALED_PACKET_HEADER || len(data) != MARSHALED_TOTAL_SIZE {
return nil, ErrMalformedDropMessage
}
ping := &Drop{}
- if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+ if unmarshaledPeer, err := peer.Unmarshal(data[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END]); err != nil {
return nil, err
} else {
- ping.Issuer = unmarshalledPeer
+ ping.Issuer = unmarshaledPeer
}
if err := saltmanager.CheckSalt(ping.Issuer.Salt); err != nil {
return nil, err
}
- if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_SIGNATURE_START:]); err != nil {
+ if issuer, err := identity.FromSignedData(data[:MARSHALED_SIGNATURE_START], data[MARSHALED_SIGNATURE_START:]); err != nil {
return nil, err
} else {
if !bytes.Equal(issuer.Identifier, ping.Issuer.Identity.Identifier) {
return nil, ErrInvalidSignature
}
}
- copy(ping.Signature[:], data[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END])
+ copy(ping.Signature[:], data[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END])
return ping, nil
}
func (ping *Drop) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALED_TOTAL_SIZE)
- result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], ping.Issuer.Marshal())
- copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], ping.Signature[:MARSHALLED_SIGNATURE_SIZE])
+ result[PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+ copy(result[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END], ping.Issuer.Marshal())
+ copy(result[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END], ping.Signature[:MARSHALED_SIGNATURE_SIZE])
return result
}
func (this *Drop) Sign() {
- if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_SIGNATURE_START]); err != nil {
+ if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALED_SIGNATURE_START]); err != nil {
panic(err)
} else {
copy(this.Signature[:], signature)
diff --git a/plugins/autopeering/types/peer/constants.go b/plugins/autopeering/types/peer/constants.go
index 28e04611..1abfe107 100644
--- a/plugins/autopeering/types/peer/constants.go
+++ b/plugins/autopeering/types/peer/constants.go
@@ -6,25 +6,25 @@ import (
)
const (
- MARSHALLED_PUBLIC_KEY_START = 0
- MARSHALLED_ADDRESS_TYPE_START = MARSHALLED_PUBLIC_KEY_END
- MARSHALLED_ADDRESS_START = MARSHALLED_ADDRESS_TYPE_END
- MARSHALLED_PEERING_PORT_START = MARSHALLED_ADDRESS_END
- MARSHALLED_GOSSIP_PORT_START = MARSHALLED_PEERING_PORT_END
- MARSHALLED_SALT_START = MARSHALLED_GOSSIP_PORT_END
+ MARSHALED_PUBLIC_KEY_START = 0
+ MARSHALED_ADDRESS_TYPE_START = MARSHALED_PUBLIC_KEY_END
+ MARSHALED_ADDRESS_START = MARSHALED_ADDRESS_TYPE_END
+ MARSHALED_PEERING_PORT_START = MARSHALED_ADDRESS_END
+ MARSHALED_GOSSIP_PORT_START = MARSHALED_PEERING_PORT_END
+ MARSHALED_SALT_START = MARSHALED_GOSSIP_PORT_END
- MARSHALLED_PUBLIC_KEY_END = MARSHALLED_PUBLIC_KEY_START + MARSHALLED_PUBLIC_KEY_SIZE
- MARSHALLED_ADDRESS_TYPE_END = MARSHALLED_ADDRESS_TYPE_START + MARSHALLED_ADDRESS_TYPE_SIZE
- MARSHALLED_ADDRESS_END = MARSHALLED_ADDRESS_START + MARSHALLED_ADDRESS_SIZE
- MARSHALLED_PEERING_PORT_END = MARSHALLED_PEERING_PORT_START + MARSHALLED_PEERING_PORT_SIZE
- MARSHALLED_GOSSIP_PORT_END = MARSHALLED_GOSSIP_PORT_START + MARSHALLED_GOSSIP_PORT_SIZE
- MARSHALLED_SALT_END = MARSHALLED_SALT_START + MARSHALLED_SALT_SIZE
+ MARSHALED_PUBLIC_KEY_END = MARSHALED_PUBLIC_KEY_START + MARSHALED_PUBLIC_KEY_SIZE
+ MARSHALED_ADDRESS_TYPE_END = MARSHALED_ADDRESS_TYPE_START + MARSHALED_ADDRESS_TYPE_SIZE
+ MARSHALED_ADDRESS_END = MARSHALED_ADDRESS_START + MARSHALED_ADDRESS_SIZE
+ MARSHALED_PEERING_PORT_END = MARSHALED_PEERING_PORT_START + MARSHALED_PEERING_PORT_SIZE
+ MARSHALED_GOSSIP_PORT_END = MARSHALED_GOSSIP_PORT_START + MARSHALED_GOSSIP_PORT_SIZE
+ MARSHALED_SALT_END = MARSHALED_SALT_START + MARSHALED_SALT_SIZE
- MARSHALLED_PUBLIC_KEY_SIZE = identity.PUBLIC_KEY_BYTE_LENGTH
- MARSHALLED_ADDRESS_TYPE_SIZE = 1
- MARSHALLED_ADDRESS_SIZE = 16
- MARSHALLED_PEERING_PORT_SIZE = 2
- MARSHALLED_GOSSIP_PORT_SIZE = 2
- MARSHALLED_SALT_SIZE = salt.SALT_MARSHALLED_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_SALT_END
+ MARSHALED_PUBLIC_KEY_SIZE = identity.PUBLIC_KEY_BYTE_LENGTH
+ MARSHALED_ADDRESS_TYPE_SIZE = 1
+ MARSHALED_ADDRESS_SIZE = 16
+ MARSHALED_PEERING_PORT_SIZE = 2
+ MARSHALED_GOSSIP_PORT_SIZE = 2
+ MARSHALED_SALT_SIZE = salt.SALT_MARSHALED_SIZE
+ MARSHALED_TOTAL_SIZE = MARSHALED_SALT_END
)
diff --git a/plugins/autopeering/types/peer/peer.go b/plugins/autopeering/types/peer/peer.go
index bd3605d8..9bc8510c 100644
--- a/plugins/autopeering/types/peer/peer.go
+++ b/plugins/autopeering/types/peer/peer.go
@@ -25,28 +25,28 @@ type Peer struct {
}
func Unmarshal(data []byte) (*Peer, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE {
- return nil, errors.New("size of marshalled peer is too small")
+ if len(data) < MARSHALED_TOTAL_SIZE {
+ return nil, errors.New("size of marshaled peer is too small")
}
peer := &Peer{
- Identity: identity.NewIdentity(data[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END]),
+ Identity: identity.NewIdentity(data[MARSHALED_PUBLIC_KEY_START:MARSHALED_PUBLIC_KEY_END]),
}
- switch data[MARSHALLED_ADDRESS_TYPE_START] {
+ switch data[MARSHALED_ADDRESS_TYPE_START] {
case types.ADDRESS_TYPE_IPV4:
- peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END]).To4()
+ peer.Address = net.IP(data[MARSHALED_ADDRESS_START:MARSHALED_ADDRESS_END]).To4()
case types.ADDRESS_TYPE_IPV6:
- peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END]).To16()
+ peer.Address = net.IP(data[MARSHALED_ADDRESS_START:MARSHALED_ADDRESS_END]).To16()
}
- peer.PeeringPort = binary.BigEndian.Uint16(data[MARSHALLED_PEERING_PORT_START:MARSHALLED_PEERING_PORT_END])
- peer.GossipPort = binary.BigEndian.Uint16(data[MARSHALLED_GOSSIP_PORT_START:MARSHALLED_GOSSIP_PORT_END])
+ peer.PeeringPort = binary.BigEndian.Uint16(data[MARSHALED_PEERING_PORT_START:MARSHALED_PEERING_PORT_END])
+ peer.GossipPort = binary.BigEndian.Uint16(data[MARSHALED_GOSSIP_PORT_START:MARSHALED_GOSSIP_PORT_END])
- if unmarshalledSalt, err := salt.Unmarshal(data[MARSHALLED_SALT_START:MARSHALLED_SALT_END]); err != nil {
+ if unmarshaledSalt, err := salt.Unmarshal(data[MARSHALED_SALT_START:MARSHALED_SALT_END]); err != nil {
return nil, err
} else {
- peer.Salt = unmarshalledSalt
+ peer.Salt = unmarshaledSalt
}
return peer, nil
@@ -115,26 +115,26 @@ func (peer *Peer) Connect(protocol types.ProtocolType) (*network.ManagedConnecti
}
func (peer *Peer) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALED_TOTAL_SIZE)
- copy(result[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END],
- peer.Identity.PublicKey[:MARSHALLED_PUBLIC_KEY_SIZE])
+ copy(result[MARSHALED_PUBLIC_KEY_START:MARSHALED_PUBLIC_KEY_END],
+ peer.Identity.PublicKey[:MARSHALED_PUBLIC_KEY_SIZE])
switch len(peer.Address) {
case net.IPv4len:
- result[MARSHALLED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV4
+ result[MARSHALED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV4
case net.IPv6len:
- result[MARSHALLED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV6
+ result[MARSHALED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV6
default:
panic("invalid address in peer")
}
- copy(result[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END], peer.Address.To16())
+ copy(result[MARSHALED_ADDRESS_START:MARSHALED_ADDRESS_END], peer.Address.To16())
- binary.BigEndian.PutUint16(result[MARSHALLED_PEERING_PORT_START:MARSHALLED_PEERING_PORT_END], peer.PeeringPort)
- binary.BigEndian.PutUint16(result[MARSHALLED_GOSSIP_PORT_START:MARSHALLED_GOSSIP_PORT_END], peer.GossipPort)
+ binary.BigEndian.PutUint16(result[MARSHALED_PEERING_PORT_START:MARSHALED_PEERING_PORT_END], peer.PeeringPort)
+ binary.BigEndian.PutUint16(result[MARSHALED_GOSSIP_PORT_START:MARSHALED_GOSSIP_PORT_END], peer.GossipPort)
- copy(result[MARSHALLED_SALT_START:MARSHALLED_SALT_END], peer.Salt.Marshal())
+ copy(result[MARSHALED_SALT_START:MARSHALED_SALT_END], peer.Salt.Marshal())
return result
}
diff --git a/plugins/autopeering/types/ping/constants.go b/plugins/autopeering/types/ping/constants.go
index 6d37911b..22b17d9d 100644
--- a/plugins/autopeering/types/ping/constants.go
+++ b/plugins/autopeering/types/ping/constants.go
@@ -6,24 +6,24 @@ import (
)
const (
- MARSHALLED_PACKET_HEADER = 0x04
+ MARSHALED_PACKET_HEADER = 0x04
- PACKET_HEADER_START = 0
- MARSHALLED_ISSUER_START = PACKET_HEADER_END
- MARSHALLED_PEERS_START = MARSHALLED_ISSUER_END
- MARSHALLED_SIGNATURE_START = MARSHALLED_PEERS_END
+ PACKET_HEADER_START = 0
+ MARSHALED_ISSUER_START = PACKET_HEADER_END
+ MARSHALED_PEERS_START = MARSHALED_ISSUER_END
+ MARSHALED_SIGNATURE_START = MARSHALED_PEERS_END
- PACKET_HEADER_END = PACKET_HEADER_START + PACKET_HEADER_SIZE
- MARSHALLED_ISSUER_END = MARSHALLED_ISSUER_START + MARSHALLED_ISSUER_SIZE
- MARSHALLED_PEERS_END = MARSHALLED_PEERS_START + MARSHALLED_PEERS_SIZE
- MARSHALLED_SIGNATURE_END = MARSHALLED_SIGNATURE_START + MARSHALLED_SIGNATURE_SIZE
+ PACKET_HEADER_END = PACKET_HEADER_START + PACKET_HEADER_SIZE
+ MARSHALED_ISSUER_END = MARSHALED_ISSUER_START + MARSHALED_ISSUER_SIZE
+ MARSHALED_PEERS_END = MARSHALED_PEERS_START + MARSHALED_PEERS_SIZE
+ MARSHALED_SIGNATURE_END = MARSHALED_SIGNATURE_START + MARSHALED_SIGNATURE_SIZE
- PACKET_HEADER_SIZE = 1
- MARSHALLED_ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
- MARSHALLED_PEER_ENTRY_FLAG_SIZE = 1
- MARSHALLED_PEER_ENTRY_SIZE = MARSHALLED_PEER_ENTRY_FLAG_SIZE + peer.MARSHALLED_TOTAL_SIZE
- MARSHALLED_PEERS_SIZE = MARSHALLED_PEER_ENTRY_SIZE * constants.NEIGHBOR_COUNT
- MARSHALLED_SIGNATURE_SIZE = 65
+ PACKET_HEADER_SIZE = 1
+ MARSHALED_ISSUER_SIZE = peer.MARSHALED_TOTAL_SIZE
+ MARSHALED_PEER_ENTRY_FLAG_SIZE = 1
+ MARSHALED_PEER_ENTRY_SIZE = MARSHALED_PEER_ENTRY_FLAG_SIZE + peer.MARSHALED_TOTAL_SIZE
+ MARSHALED_PEERS_SIZE = MARSHALED_PEER_ENTRY_SIZE * constants.NEIGHBOR_COUNT
+ MARSHALED_SIGNATURE_SIZE = 65
- MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_SIGNATURE_END
)
diff --git a/plugins/autopeering/types/ping/ping.go b/plugins/autopeering/types/ping/ping.go
index 3153d660..a658af15 100644
--- a/plugins/autopeering/types/ping/ping.go
+++ b/plugins/autopeering/types/ping/ping.go
@@ -13,11 +13,11 @@ import (
type Ping struct {
Issuer *peer.Peer
Neighbors peerlist.PeerList
- Signature [MARSHALLED_SIGNATURE_SIZE]byte
+ Signature [MARSHALED_SIGNATURE_SIZE]byte
}
func Unmarshal(data []byte) (*Ping, error) {
- if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+ if data[0] != MARSHALED_PACKET_HEADER || len(data) != MARSHALED_TOTAL_SIZE {
return nil, ErrMalformedPing
}
@@ -25,59 +25,59 @@ func Unmarshal(data []byte) (*Ping, error) {
Neighbors: make(peerlist.PeerList, 0),
}
- if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+ if unmarshaledPeer, err := peer.Unmarshal(data[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END]); err != nil {
return nil, err
} else {
- ping.Issuer = unmarshalledPeer
+ ping.Issuer = unmarshaledPeer
}
if err := saltmanager.CheckSalt(ping.Issuer.Salt); err != nil {
return nil, err
}
- offset := MARSHALLED_PEERS_START
+ offset := MARSHALED_PEERS_START
for i := 0; i < constants.NEIGHBOR_COUNT; i++ {
if data[offset] == 1 {
- if unmarshalledPing, err := peer.Unmarshal(data[offset+1 : offset+MARSHALLED_PEER_ENTRY_SIZE]); err != nil {
+ if unmarshaledPing, err := peer.Unmarshal(data[offset+1 : offset+MARSHALED_PEER_ENTRY_SIZE]); err != nil {
return nil, err
} else {
- ping.Neighbors = append(ping.Neighbors, unmarshalledPing)
+ ping.Neighbors = append(ping.Neighbors, unmarshaledPing)
}
}
- offset += MARSHALLED_PEER_ENTRY_SIZE
+ offset += MARSHALED_PEER_ENTRY_SIZE
}
- if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_SIGNATURE_START:]); err != nil {
+ if issuer, err := identity.FromSignedData(data[:MARSHALED_SIGNATURE_START], data[MARSHALED_SIGNATURE_START:]); err != nil {
return nil, err
} else {
if !bytes.Equal(issuer.Identifier, ping.Issuer.Identity.Identifier) {
return nil, ErrInvalidSignature
}
}
- copy(ping.Signature[:], data[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END])
+ copy(ping.Signature[:], data[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END])
return ping, nil
}
func (ping *Ping) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALED_TOTAL_SIZE)
- result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], ping.Issuer.Marshal())
+ result[PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+ copy(result[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END], ping.Issuer.Marshal())
for i, neighbor := range ping.Neighbors {
- entryStartOffset := MARSHALLED_PEERS_START + i*MARSHALLED_PEER_ENTRY_SIZE
+ entryStartOffset := MARSHALED_PEERS_START + i*MARSHALED_PEER_ENTRY_SIZE
result[entryStartOffset] = 1
- copy(result[entryStartOffset+1:entryStartOffset+MARSHALLED_PEER_ENTRY_SIZE], neighbor.Marshal())
+ copy(result[entryStartOffset+1:entryStartOffset+MARSHALED_PEER_ENTRY_SIZE], neighbor.Marshal())
}
- copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], ping.Signature[:MARSHALLED_SIGNATURE_SIZE])
+ copy(result[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END], ping.Signature[:MARSHALED_SIGNATURE_SIZE])
return result
}
func (this *Ping) Sign() {
- if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_SIGNATURE_START]); err != nil {
+ if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALED_SIGNATURE_START]); err != nil {
panic(err)
} else {
copy(this.Signature[:], signature)
diff --git a/plugins/autopeering/types/request/constants.go b/plugins/autopeering/types/request/constants.go
index c70d8427..c1e70715 100644
--- a/plugins/autopeering/types/request/constants.go
+++ b/plugins/autopeering/types/request/constants.go
@@ -6,7 +6,7 @@ import (
const (
PACKET_HEADER_SIZE = 1
- ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
+ ISSUER_SIZE = peer.MARSHALED_TOTAL_SIZE
SIGNATURE_SIZE = 65
PACKET_HEADER_START = 0
@@ -17,7 +17,7 @@ const (
ISSUER_END = ISSUER_START + ISSUER_SIZE
SIGNATURE_END = SIGNATURE_START + SIGNATURE_SIZE
- MARSHALLED_TOTAL_SIZE = SIGNATURE_END
+ MARSHALED_TOTAL_SIZE = SIGNATURE_END
- MARSHALLED_PACKET_HEADER = 0xBE
+ MARSHALED_PACKET_HEADER = 0xBE
)
diff --git a/plugins/autopeering/types/request/request.go b/plugins/autopeering/types/request/request.go
index 13976548..1fa6a956 100644
--- a/plugins/autopeering/types/request/request.go
+++ b/plugins/autopeering/types/request/request.go
@@ -18,16 +18,16 @@ type Request struct {
}
func Unmarshal(data []byte) (*Request, error) {
- if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+ if data[0] != MARSHALED_PACKET_HEADER || len(data) != MARSHALED_TOTAL_SIZE {
return nil, ErrMalformedPeeringRequest
}
peeringRequest := &Request{}
- if unmarshalledPeer, err := peer.Unmarshal(data[ISSUER_START:ISSUER_END]); err != nil {
+ if unmarshaledPeer, err := peer.Unmarshal(data[ISSUER_START:ISSUER_END]); err != nil {
return nil, err
} else {
- peeringRequest.Issuer = unmarshalledPeer
+ peeringRequest.Issuer = unmarshaledPeer
}
now := time.Now()
@@ -89,9 +89,9 @@ func (this *Request) Sign() {
}
func (this *Request) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALED_TOTAL_SIZE)
- result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+ result[PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
copy(result[ISSUER_START:ISSUER_END], this.Issuer.Marshal())
copy(result[SIGNATURE_START:SIGNATURE_END], this.Signature[:SIGNATURE_SIZE])
diff --git a/plugins/autopeering/types/response/constants.go b/plugins/autopeering/types/response/constants.go
index b5f8db12..9ef796fe 100644
--- a/plugins/autopeering/types/response/constants.go
+++ b/plugins/autopeering/types/response/constants.go
@@ -9,27 +9,27 @@ const (
TYPE_REJECT = Type(0)
TYPE_ACCEPT = Type(1)
- MARSHALLED_PEERS_AMOUNT = constants.NEIGHBOR_COUNT + constants.NEIGHBOR_COUNT*constants.NEIGHBOR_COUNT
+ MARSHALED_PEERS_AMOUNT = constants.NEIGHBOR_COUNT + constants.NEIGHBOR_COUNT*constants.NEIGHBOR_COUNT
MARHSALLED_PACKET_HEADER = 0xBC
- MARSHALLED_PACKET_HEADER_START = 0
- MARSHALLED_TYPE_START = MARSHALLED_PACKET_HEADER_END
- MARSHALLED_ISSUER_START = MARSHALLED_TYPE_END
- MARSHALLED_PEERS_START = MARSHALLED_ISSUER_END
- MARSHALLED_SIGNATURE_START = MARSHALLED_PEERS_END
+ MARSHALED_PACKET_HEADER_START = 0
+ MARSHALED_TYPE_START = MARSHALED_PACKET_HEADER_END
+ MARSHALED_ISSUER_START = MARSHALED_TYPE_END
+ MARSHALED_PEERS_START = MARSHALED_ISSUER_END
+ MARSHALED_SIGNATURE_START = MARSHALED_PEERS_END
- MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
- MARSHALLED_TYPE_END = MARSHALLED_TYPE_START + MARSHALLED_TYPE_SIZE
- MARSHALLED_PEERS_END = MARSHALLED_PEERS_START + MARSHALLED_PEERS_SIZE
- MARSHALLED_ISSUER_END = MARSHALLED_ISSUER_START + MARSHALLED_ISSUER_SIZE
- MARSHALLED_SIGNATURE_END = MARSHALLED_SIGNATURE_START + MARSHALLED_SIGNATURE_SIZE
+ MARSHALED_PACKET_HEADER_END = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
+ MARSHALED_TYPE_END = MARSHALED_TYPE_START + MARSHALED_TYPE_SIZE
+ MARSHALED_PEERS_END = MARSHALED_PEERS_START + MARSHALED_PEERS_SIZE
+ MARSHALED_ISSUER_END = MARSHALED_ISSUER_START + MARSHALED_ISSUER_SIZE
+ MARSHALED_SIGNATURE_END = MARSHALED_SIGNATURE_START + MARSHALED_SIGNATURE_SIZE
- MARSHALLED_PACKET_HEADER_SIZE = 1
- MARSHALLED_TYPE_SIZE = 1
- MARSHALLED_ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
- MARSHALLED_PEER_FLAG_SIZE = 1
- MARSHALLED_PEER_SIZE = MARSHALLED_PEER_FLAG_SIZE + peer.MARSHALLED_TOTAL_SIZE
- MARSHALLED_PEERS_SIZE = MARSHALLED_PEERS_AMOUNT * MARSHALLED_PEER_SIZE
- MARSHALLED_SIGNATURE_SIZE = 65
- MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
+ MARSHALED_PACKET_HEADER_SIZE = 1
+ MARSHALED_TYPE_SIZE = 1
+ MARSHALED_ISSUER_SIZE = peer.MARSHALED_TOTAL_SIZE
+ MARSHALED_PEER_FLAG_SIZE = 1
+ MARSHALED_PEER_SIZE = MARSHALED_PEER_FLAG_SIZE + peer.MARSHALED_TOTAL_SIZE
+ MARSHALED_PEERS_SIZE = MARSHALED_PEERS_AMOUNT * MARSHALED_PEER_SIZE
+ MARSHALED_SIGNATURE_SIZE = 65
+ MARSHALED_TOTAL_SIZE = MARSHALED_SIGNATURE_END
)
diff --git a/plugins/autopeering/types/response/response.go b/plugins/autopeering/types/response/response.go
index 7d75b6e0..9ebf4895 100644
--- a/plugins/autopeering/types/response/response.go
+++ b/plugins/autopeering/types/response/response.go
@@ -13,31 +13,31 @@ type Response struct {
Type Type
Issuer *peer.Peer
Peers []*peer.Peer
- Signature [MARSHALLED_SIGNATURE_SIZE]byte
+ Signature [MARSHALED_SIGNATURE_SIZE]byte
}
func Unmarshal(data []byte) (*Response, error) {
- if data[0] != MARHSALLED_PACKET_HEADER || len(data) < MARSHALLED_TOTAL_SIZE {
+ if data[0] != MARHSALLED_PACKET_HEADER || len(data) < MARSHALED_TOTAL_SIZE {
return nil, errors.New("malformed peering response")
}
peeringResponse := &Response{
- Type: data[MARSHALLED_TYPE_START],
+ Type: data[MARSHALED_TYPE_START],
Peers: make([]*peer.Peer, 0),
}
- if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+ if unmarshaledPeer, err := peer.Unmarshal(data[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END]); err != nil {
return nil, err
} else {
- peeringResponse.Issuer = unmarshalledPeer
+ peeringResponse.Issuer = unmarshaledPeer
}
- for i := 0; i < MARSHALLED_PEERS_AMOUNT; i++ {
- PEERING_RESPONSE_MARSHALLED_PEER_START := MARSHALLED_PEERS_START + (i * MARSHALLED_PEER_SIZE)
- PEERING_RESPONSE_MARSHALLED_PEER_END := PEERING_RESPONSE_MARSHALLED_PEER_START + MARSHALLED_PEER_SIZE
+ for i := 0; i < MARSHALED_PEERS_AMOUNT; i++ {
+ PEERING_RESPONSE_MARSHALED_PEER_START := MARSHALED_PEERS_START + (i * MARSHALED_PEER_SIZE)
+ PEERING_RESPONSE_MARSHALED_PEER_END := PEERING_RESPONSE_MARSHALED_PEER_START + MARSHALED_PEER_SIZE
- if data[PEERING_RESPONSE_MARSHALLED_PEER_START] == 1 {
- peer, err := peer.Unmarshal(data[PEERING_RESPONSE_MARSHALLED_PEER_START+1 : PEERING_RESPONSE_MARSHALLED_PEER_END])
+ if data[PEERING_RESPONSE_MARSHALED_PEER_START] == 1 {
+ peer, err := peer.Unmarshal(data[PEERING_RESPONSE_MARSHALED_PEER_START+1 : PEERING_RESPONSE_MARSHALED_PEER_END])
if err != nil {
return nil, err
}
@@ -46,20 +46,20 @@ func Unmarshal(data []byte) (*Response, error) {
}
}
- if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_SIGNATURE_START:]); err != nil {
+ if issuer, err := identity.FromSignedData(data[:MARSHALED_SIGNATURE_START], data[MARSHALED_SIGNATURE_START:]); err != nil {
return nil, err
} else {
if !bytes.Equal(issuer.Identifier, peeringResponse.Issuer.Identity.Identifier) {
return nil, ErrInvalidSignature
}
}
- copy(peeringResponse.Signature[:], data[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END])
+ copy(peeringResponse.Signature[:], data[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END])
return peeringResponse, nil
}
func (this *Response) Sign() *Response {
- dataToSign := this.Marshal()[:MARSHALLED_SIGNATURE_START]
+ dataToSign := this.Marshal()[:MARSHALED_SIGNATURE_START]
if signature, err := this.Issuer.Identity.Sign(dataToSign); err != nil {
panic(err)
} else {
@@ -70,24 +70,24 @@ func (this *Response) Sign() *Response {
}
func (this *Response) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALED_TOTAL_SIZE)
- result[MARSHALLED_PACKET_HEADER_START] = MARHSALLED_PACKET_HEADER
- result[MARSHALLED_TYPE_START] = this.Type
+ result[MARSHALED_PACKET_HEADER_START] = MARHSALLED_PACKET_HEADER
+ result[MARSHALED_TYPE_START] = this.Type
- copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], this.Issuer.Marshal())
+ copy(result[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END], this.Issuer.Marshal())
for i, peer := range this.Peers {
if i < constants.NEIGHBOR_COUNT {
- PEERING_RESPONSE_MARSHALLED_PEER_START := MARSHALLED_PEERS_START + (i * MARSHALLED_PEER_SIZE)
- PEERING_RESPONSE_MARSHALLED_PEER_END := PEERING_RESPONSE_MARSHALLED_PEER_START + MARSHALLED_PEER_SIZE
+ PEERING_RESPONSE_MARSHALED_PEER_START := MARSHALED_PEERS_START + (i * MARSHALED_PEER_SIZE)
+ PEERING_RESPONSE_MARSHALED_PEER_END := PEERING_RESPONSE_MARSHALED_PEER_START + MARSHALED_PEER_SIZE
- result[PEERING_RESPONSE_MARSHALLED_PEER_START] = 1
- copy(result[PEERING_RESPONSE_MARSHALLED_PEER_START+1:PEERING_RESPONSE_MARSHALLED_PEER_END], peer.Marshal()[:MARSHALLED_PEER_SIZE-1])
+ result[PEERING_RESPONSE_MARSHALED_PEER_START] = 1
+ copy(result[PEERING_RESPONSE_MARSHALED_PEER_START+1:PEERING_RESPONSE_MARSHALED_PEER_END], peer.Marshal()[:MARSHALED_PEER_SIZE-1])
}
}
- copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], this.Signature[:MARSHALLED_SIGNATURE_SIZE])
+ copy(result[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END], this.Signature[:MARSHALED_SIGNATURE_SIZE])
return result
}
diff --git a/plugins/autopeering/types/salt/constants.go b/plugins/autopeering/types/salt/constants.go
index 5b75dd07..399d6a72 100644
--- a/plugins/autopeering/types/salt/constants.go
+++ b/plugins/autopeering/types/salt/constants.go
@@ -10,5 +10,5 @@ const (
SALT_BYTES_END = SALT_BYTES_START + SALT_BYTES_SIZE
SALT_TIME_END = SALT_TIME_START + SALT_TIME_SIZE
- SALT_MARSHALLED_SIZE = SALT_TIME_END
+ SALT_MARSHALED_SIZE = SALT_TIME_END
)
diff --git a/plugins/autopeering/types/salt/salt.go b/plugins/autopeering/types/salt/salt.go
index 2da93db4..0da78e94 100644
--- a/plugins/autopeering/types/salt/salt.go
+++ b/plugins/autopeering/types/salt/salt.go
@@ -25,17 +25,17 @@ func New(lifetime time.Duration) *Salt {
return salt
}
-func Unmarshal(marshalledSalt []byte) (*Salt, error) {
- if len(marshalledSalt) < SALT_MARSHALLED_SIZE {
- return nil, errors.New("marshalled salt bytes not long enough")
+func Unmarshal(marshaledSalt []byte) (*Salt, error) {
+ if len(marshaledSalt) < SALT_MARSHALED_SIZE {
+ return nil, errors.New("marshaled salt bytes not long enough")
}
salt := &Salt{
Bytes: make([]byte, SALT_BYTES_SIZE),
}
- copy(salt.Bytes, marshalledSalt[SALT_BYTES_START:SALT_BYTES_END])
+ copy(salt.Bytes, marshaledSalt[SALT_BYTES_START:SALT_BYTES_END])
- if err := salt.ExpirationTime.UnmarshalBinary(marshalledSalt[SALT_TIME_START:SALT_TIME_END]); err != nil {
+ if err := salt.ExpirationTime.UnmarshalBinary(marshaledSalt[SALT_TIME_START:SALT_TIME_END]); err != nil {
return nil, err
}
diff --git a/plugins/cli/plugin.go b/plugins/cli/plugin.go
index c77cc835..2f73f239 100644
--- a/plugins/cli/plugin.go
+++ b/plugins/cli/plugin.go
@@ -40,6 +40,4 @@ func init() {
func configure(ctx *node.Plugin) {}
-func run(plugin *node.Plugin) {}
-
var PLUGIN = node.NewPlugin("CLI", configure)
diff --git a/plugins/gossip/neighbors.go b/plugins/gossip/neighbors.go
index 47aacbbd..dd03c22a 100644
--- a/plugins/gossip/neighbors.go
+++ b/plugins/gossip/neighbors.go
@@ -181,7 +181,7 @@ func (neighbor *Neighbor) Marshal() []byte {
}
func (neighbor *Neighbor) Equals(other *Neighbor) bool {
- return neighbor.Identity.StringIdentifier == neighbor.Identity.StringIdentifier &&
+ return neighbor.Identity.StringIdentifier == other.Identity.StringIdentifier &&
neighbor.Port == other.Port && neighbor.Address.String() == other.Address.String()
}
@@ -194,10 +194,10 @@ func AddNeighbor(newNeighbor *Neighbor) {
Events.AddNeighbor.Trigger(newNeighbor)
} else {
- if !newNeighbor.Equals(neighbor) {
- neighbor.Identity = neighbor.Identity
- neighbor.Port = neighbor.Port
- neighbor.Address = neighbor.Address
+ if !neighbor.Equals(newNeighbor) {
+ neighbor.Identity = newNeighbor.Identity
+ neighbor.Port = newNeighbor.Port
+ neighbor.Address = newNeighbor.Address
Events.UpdateNeighbor.Trigger(newNeighbor)
}
diff --git a/plugins/gossip/protocol_v1.go b/plugins/gossip/protocol_v1.go
index 9b7677b3..e177271f 100644
--- a/plugins/gossip/protocol_v1.go
+++ b/plugins/gossip/protocol_v1.go
@@ -72,7 +72,7 @@ type indentificationStateV1 struct {
func newIndentificationStateV1(protocol *protocol) *indentificationStateV1 {
return &indentificationStateV1{
protocol: protocol,
- buffer: make([]byte, MARSHALLED_IDENTITY_TOTAL_SIZE),
+ buffer: make([]byte, MARSHALED_IDENTITY_TOTAL_SIZE),
offset: 0,
}
}
@@ -81,7 +81,7 @@ func (state *indentificationStateV1) Receive(data []byte, offset int, length int
bytesRead := byteutils.ReadAvailableBytesToBuffer(state.buffer, state.offset, data, offset, length)
state.offset += bytesRead
- if state.offset == MARSHALLED_IDENTITY_TOTAL_SIZE {
+ if state.offset == MARSHALED_IDENTITY_TOTAL_SIZE {
if receivedIdentity, err := unmarshalIdentity(state.buffer); err != nil {
return bytesRead, ErrInvalidAuthenticationMessage.Derive(err, "invalid authentication message")
} else {
@@ -125,9 +125,9 @@ func (state *indentificationStateV1) Send(param interface{}) errors.Identifiable
}
func unmarshalIdentity(data []byte) (*identity.Identity, error) {
- identifier := data[MARSHALLED_IDENTITY_START:MARSHALLED_IDENTITY_END]
+ identifier := data[MARSHALED_IDENTITY_START:MARSHALED_IDENTITY_END]
- if restoredIdentity, err := identity.FromSignedData(identifier, data[MARSHALLED_IDENTITY_SIGNATURE_START:MARSHALLED_IDENTITY_SIGNATURE_END]); err != nil {
+ if restoredIdentity, err := identity.FromSignedData(identifier, data[MARSHALED_IDENTITY_SIGNATURE_START:MARSHALED_IDENTITY_SIGNATURE_END]); err != nil {
return nil, err
} else {
if bytes.Equal(identifier, restoredIdentity.Identifier) {
@@ -303,7 +303,7 @@ type transactionStateV1 struct {
func newTransactionStateV1(protocol *protocol) *transactionStateV1 {
return &transactionStateV1{
protocol: protocol,
- buffer: make([]byte, transaction.MARSHALLED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE),
+ buffer: make([]byte, transaction.MARSHALED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE),
offset: 0,
}
}
@@ -312,10 +312,10 @@ func (state *transactionStateV1) Receive(data []byte, offset int, length int) (i
bytesRead := byteutils.ReadAvailableBytesToBuffer(state.buffer, state.offset, data, offset, length)
state.offset += bytesRead
- if state.offset == transaction.MARSHALLED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE {
+ if state.offset == transaction.MARSHALED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE {
protocol := state.protocol
- transactionData := make([]byte, transaction.MARSHALLED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+ transactionData := make([]byte, transaction.MARSHALED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE)
copy(transactionData, state.buffer)
protocol.Events.ReceiveTransactionData.Trigger(transactionData)
@@ -383,16 +383,16 @@ const (
DISPATCH_TRANSACTION = byte(1)
DISPATCH_REQUEST = byte(2)
- MARSHALLED_IDENTITY_START = 0
- MARSHALLED_IDENTITY_SIGNATURE_START = MARSHALLED_IDENTITY_END
+ MARSHALED_IDENTITY_START = 0
+ MARSHALED_IDENTITY_SIGNATURE_START = MARSHALED_IDENTITY_END
- MARSHALLED_IDENTITY_SIZE = 20
- MARSHALLED_IDENTITY_SIGNATURE_SIZE = 65
+ MARSHALED_IDENTITY_SIZE = 20
+ MARSHALED_IDENTITY_SIGNATURE_SIZE = 65
- MARSHALLED_IDENTITY_END = MARSHALLED_IDENTITY_START + MARSHALLED_IDENTITY_SIZE
- MARSHALLED_IDENTITY_SIGNATURE_END = MARSHALLED_IDENTITY_SIGNATURE_START + MARSHALLED_IDENTITY_SIGNATURE_SIZE
+ MARSHALED_IDENTITY_END = MARSHALED_IDENTITY_START + MARSHALED_IDENTITY_SIZE
+ MARSHALED_IDENTITY_SIGNATURE_END = MARSHALED_IDENTITY_SIGNATURE_START + MARSHALED_IDENTITY_SIGNATURE_SIZE
- MARSHALLED_IDENTITY_TOTAL_SIZE = MARSHALLED_IDENTITY_SIGNATURE_END
+ MARSHALED_IDENTITY_TOTAL_SIZE = MARSHALED_IDENTITY_SIGNATURE_END
)
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/gossip/transaction_processor_test.go b/plugins/gossip/transaction_processor_test.go
index 76862140..b970119a 100644
--- a/plugins/gossip/transaction_processor_test.go
+++ b/plugins/gossip/transaction_processor_test.go
@@ -9,7 +9,7 @@ import (
)
func BenchmarkProcessSimilarTransactionsFiltered(b *testing.B) {
- byteArray := setupTransaction(transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+ byteArray := setupTransaction(transaction.MARSHALED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
b.ResetTimer()
@@ -19,7 +19,7 @@ func BenchmarkProcessSimilarTransactionsFiltered(b *testing.B) {
}
func BenchmarkProcessSimilarTransactionsUnfiltered(b *testing.B) {
- byteArray := setupTransaction(transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+ byteArray := setupTransaction(transaction.MARSHALED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
b.ResetTimer()
diff --git a/plugins/statusscreen/ui_header_bar.go b/plugins/statusscreen/ui_header_bar.go
index 4089d415..8ea81c06 100644
--- a/plugins/statusscreen/ui_header_bar.go
+++ b/plugins/statusscreen/ui_header_bar.go
@@ -56,7 +56,7 @@ func NewUIHeaderBar() *UIHeaderBar {
}
func (headerBar *UIHeaderBar) Update() {
- duration := time.Now().Sub(start)
+ duration := time.Since(start)
headerBar.InfoContainer.Clear()
@@ -106,7 +106,6 @@ func (headerBar *UIHeaderBar) Update() {
if !padded {
fmt.Fprintf(headerBar.InfoContainer, "%37v", "")
- padded = true
}
fmt.Fprintf(headerBar.InfoContainer, "%02ds ", int(duration.Seconds())%60)
}
diff --git a/plugins/tangle/approvers.go b/plugins/tangle/approvers.go
index b7480dce..1fa2f0fb 100644
--- a/plugins/tangle/approvers.go
+++ b/plugins/tangle/approvers.go
@@ -24,7 +24,7 @@ func StoreApprovers(approvers *Approvers) {
func GetApprovers(transactionHash ternary.Trinary, computeIfAbsent ...func(ternary.Trinary) *Approvers) (result *Approvers, err errors.IdentifiableError) {
if approvers := approversCache.ComputeIfAbsent(transactionHash, func() (result interface{}) {
- if result, err = getApproversFromDatabase(transactionHash); err == nil && (result == nil || result.(*Approvers) == nil) && len(computeIfAbsent) >= 1 {
+ if result, err = getApproversFromDatabase(transactionHash); err == nil && (result.(*Approvers) == nil) && len(computeIfAbsent) >= 1 {
result = computeIfAbsent[0](transactionHash)
}
@@ -94,18 +94,18 @@ func (approvers *Approvers) GetHash() (result ternary.Trinary) {
}
func (approvers *Approvers) Marshal() (result []byte) {
- result = make([]byte, MARSHALLED_APPROVERS_MIN_SIZE+len(approvers.hashes)*MARSHALLED_APPROVERS_HASH_SIZE)
+ result = make([]byte, MARSHALED_APPROVERS_MIN_SIZE+len(approvers.hashes)*MARSHALED_APPROVERS_HASH_SIZE)
approvers.hashesMutex.RLock()
- binary.BigEndian.PutUint64(result[MARSHALLED_APPROVERS_HASHES_COUNT_START:MARSHALLED_APPROVERS_HASHES_COUNT_END], uint64(len(approvers.hashes)))
+ binary.BigEndian.PutUint64(result[MARSHALED_APPROVERS_HASHES_COUNT_START:MARSHALED_APPROVERS_HASHES_COUNT_END], uint64(len(approvers.hashes)))
- copy(result[MARSHALLED_APPROVERS_HASH_START:MARSHALLED_APPROVERS_HASH_END], approvers.hash.CastToBytes())
+ copy(result[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END], approvers.hash.CastToBytes())
i := 0
- for hash, _ := range approvers.hashes {
- var HASH_START = MARSHALLED_APPROVERS_HASHES_START + i*(MARSHALLED_APPROVERS_HASH_SIZE)
- var HASH_END = HASH_START * MARSHALLED_APPROVERS_HASH_SIZE
+ for hash := range approvers.hashes {
+ var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE)
+ var HASH_END = HASH_START * MARSHALED_APPROVERS_HASH_SIZE
copy(result[HASH_START:HASH_END], hash.CastToBytes())
@@ -120,23 +120,23 @@ func (approvers *Approvers) Marshal() (result []byte) {
func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError) {
dataLen := len(data)
- if dataLen <= MARSHALLED_APPROVERS_MIN_SIZE {
- return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshalled approvers are too short")
+ if dataLen <= MARSHALED_APPROVERS_MIN_SIZE {
+ return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshaled approvers are too short")
}
- hashesCount := binary.BigEndian.Uint64(data[MARSHALLED_APPROVERS_HASHES_COUNT_START:MARSHALLED_APPROVERS_HASHES_COUNT_END])
+ hashesCount := binary.BigEndian.Uint64(data[MARSHALED_APPROVERS_HASHES_COUNT_START:MARSHALED_APPROVERS_HASHES_COUNT_END])
- if dataLen <= MARSHALLED_APPROVERS_MIN_SIZE+int(hashesCount)*MARSHALLED_APPROVERS_HASH_SIZE {
- return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshalled approvers are too short for "+strconv.FormatUint(hashesCount, 10)+" approvers")
+ if dataLen <= MARSHALED_APPROVERS_MIN_SIZE+int(hashesCount)*MARSHALED_APPROVERS_HASH_SIZE {
+ return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshaled approvers are too short for "+strconv.FormatUint(hashesCount, 10)+" approvers")
}
approvers.hashesMutex.Lock()
- approvers.hash = ternary.Trinary(typeconversion.BytesToString(data[MARSHALLED_APPROVERS_HASH_START:MARSHALLED_APPROVERS_HASH_END]))
+ approvers.hash = ternary.Trinary(typeconversion.BytesToString(data[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END]))
approvers.hashes = make(map[ternary.Trinary]bool, hashesCount)
for i := uint64(0); i < hashesCount; i++ {
- var HASH_START = MARSHALLED_APPROVERS_HASHES_START + i*(MARSHALLED_APPROVERS_HASH_SIZE)
- var HASH_END = HASH_START * MARSHALLED_APPROVERS_HASH_SIZE
+ var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE)
+ var HASH_END = HASH_START * MARSHALED_APPROVERS_HASH_SIZE
approvers.hashes[ternary.Trinary(typeconversion.BytesToString(data[HASH_START:HASH_END]))] = true
}
@@ -149,16 +149,16 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
const (
- MARSHALLED_APPROVERS_HASHES_COUNT_START = 0
- MARSHALLED_APPROVERS_HASH_START = MARSHALLED_APPROVERS_HASHES_COUNT_END
- MARSHALLED_APPROVERS_HASHES_START = MARSHALLED_APPROVERS_HASH_END
+ MARSHALED_APPROVERS_HASHES_COUNT_START = 0
+ MARSHALED_APPROVERS_HASH_START = MARSHALED_APPROVERS_HASHES_COUNT_END
+ MARSHALED_APPROVERS_HASHES_START = MARSHALED_APPROVERS_HASH_END
- MARSHALLED_APPROVERS_HASHES_COUNT_END = MARSHALLED_APPROVERS_HASHES_COUNT_START + MARSHALLED_APPROVERS_HASHES_COUNT_SIZE
- MARSHALLED_APPROVERS_HASH_END = MARSHALLED_APPROVERS_HASH_START + MARSHALLED_APPROVERS_HASH_SIZE
+ MARSHALED_APPROVERS_HASHES_COUNT_END = MARSHALED_APPROVERS_HASHES_COUNT_START + MARSHALED_APPROVERS_HASHES_COUNT_SIZE
+ MARSHALED_APPROVERS_HASH_END = MARSHALED_APPROVERS_HASH_START + MARSHALED_APPROVERS_HASH_SIZE
- MARSHALLED_APPROVERS_HASHES_COUNT_SIZE = 8
- MARSHALLED_APPROVERS_HASH_SIZE = 81
- MARSHALLED_APPROVERS_MIN_SIZE = MARSHALLED_APPROVERS_HASHES_COUNT_SIZE + MARSHALLED_APPROVERS_HASH_SIZE
+ MARSHALED_APPROVERS_HASHES_COUNT_SIZE = 8
+ MARSHALED_APPROVERS_HASH_SIZE = 81
+ MARSHALED_APPROVERS_MIN_SIZE = MARSHALED_APPROVERS_HASHES_COUNT_SIZE + MARSHALED_APPROVERS_HASH_SIZE
)
// region private methods without locking //////////////////////////////////////////////////////////////////////////////
@@ -181,7 +181,7 @@ func (approvers *Approvers) getHashes() (result []ternary.Trinary) {
result = make([]ternary.Trinary, len(approvers.hashes))
counter := 0
- for hash, _ := range approvers.hashes {
+ for hash := range approvers.hashes {
result[counter] = hash
counter++
@@ -219,9 +219,10 @@ func getApproversFromDatabase(transactionHash ternary.Trinary) (result *Approver
}
func databaseContainsApprovers(transactionHash ternary.Trinary) (bool, errors.IdentifiableError) {
- if result, err := approversDatabase.Contains(transactionHash.CastToBytes()); err != nil {
+ result, err := approversDatabase.Contains(transactionHash.CastToBytes())
+ if err != nil {
return false, ErrDatabaseError.Derive(err, "failed to check if the transaction exists")
- } else {
- return result, nil
}
+
+ return result, nil
}
diff --git a/plugins/tangle/solidifier.go b/plugins/tangle/solidifier.go
index 8f7033cb..d662d7cc 100644
--- a/plugins/tangle/solidifier.go
+++ b/plugins/tangle/solidifier.go
@@ -23,7 +23,7 @@ func configureSolidifier(plugin *node.Plugin) {
func checkSolidity(transaction *Transaction) (result bool, err errors.IdentifiableError) {
// abort if transaction is solid already
txMetadata, metaDataErr := transaction.GetMetaData()
- if err != nil {
+ if metaDataErr != nil {
err = metaDataErr
return
@@ -36,7 +36,7 @@ func checkSolidity(transaction *Transaction) (result bool, err errors.Identifiab
// check solidity of branch transaction if it is not genesis
if branchTransactionHash := transaction.GetBranchTransactionHash(); branchTransactionHash != TRANSACTION_NULL_HASH {
// abort if branch transaction is missing
- if branchTransaction, branchErr := GetTransaction(branchTransactionHash); err != nil {
+ if branchTransaction, branchErr := GetTransaction(branchTransactionHash); branchErr != nil {
err = branchErr
return
diff --git a/plugins/tangle/transaction.go b/plugins/tangle/transaction.go
index 6ee98b52..daa166c4 100644
--- a/plugins/tangle/transaction.go
+++ b/plugins/tangle/transaction.go
@@ -19,30 +19,28 @@ type Transaction struct {
rawMetaDataMutex sync.RWMutex
// mapped raw transaction properties
- hash *ternary.Trinary
- hashMutex sync.RWMutex
- signatureMessageFragment *ternary.Trinary
- signatureMessageFragmentMutex sync.RWMutex
- address *ternary.Trinary
- addressMutex sync.RWMutex
- value *int64
- valueMutex sync.RWMutex
- timestamp *uint64
- timestampMutex sync.RWMutex
- currentIndex *uint64
- currentIndexMutex sync.RWMutex
- latestIndex *uint64
- latestIndexMutex sync.RWMutex
- bundleHash *ternary.Trinary
- bundleHashMutex sync.RWMutex
- trunkTransactionHash *ternary.Trinary
- trunkTransactionHashMutex sync.RWMutex
- branchTransactionHash *ternary.Trinary
- branchTransactionHashMutex sync.RWMutex
- tag *ternary.Trinary
- tagMutex sync.RWMutex
- nonce *ternary.Trinary
- nonceMutex sync.RWMutex
+ hash *ternary.Trinary
+ hashMutex sync.RWMutex
+ address *ternary.Trinary
+ addressMutex sync.RWMutex
+ value *int64
+ valueMutex sync.RWMutex
+ timestamp *uint64
+ timestampMutex sync.RWMutex
+ currentIndex *uint64
+ currentIndexMutex sync.RWMutex
+ latestIndex *uint64
+ latestIndexMutex sync.RWMutex
+ bundleHash *ternary.Trinary
+ bundleHashMutex sync.RWMutex
+ trunkTransactionHash *ternary.Trinary
+ trunkTransactionHashMutex sync.RWMutex
+ branchTransactionHash *ternary.Trinary
+ branchTransactionHashMutex sync.RWMutex
+ tag *ternary.Trinary
+ tagMutex sync.RWMutex
+ nonce *ternary.Trinary
+ nonceMutex sync.RWMutex
// additional runtime specific metadata
modified bool
@@ -51,7 +49,7 @@ type Transaction struct {
func NewTransaction(rawTransaction *transaction.Transaction) *Transaction {
if rawTransaction == nil {
- rawTransaction = transaction.FromBytes(make([]byte, int(math.Ceil(float64(transaction.MARSHALLED_TOTAL_SIZE)/ternary.NUMBER_OF_TRITS_IN_A_BYTE))))
+ rawTransaction = transaction.FromBytes(make([]byte, int(math.Ceil(float64(transaction.MARSHALED_TOTAL_SIZE)/ternary.NUMBER_OF_TRITS_IN_A_BYTE))))
}
return &Transaction{rawTransaction: rawTransaction}
diff --git a/plugins/tangle/transaction_metadata.go b/plugins/tangle/transaction_metadata.go
index 97869f88..d21b5ef8 100644
--- a/plugins/tangle/transaction_metadata.go
+++ b/plugins/tangle/transaction_metadata.go
@@ -42,122 +42,122 @@ func NewTransactionMetadata(hash ternary.Trinary) *TransactionMetadata {
// region getters and setters //////////////////////////////////////////////////////////////////////////////////////////
-func (metaData *TransactionMetadata) GetHash() ternary.Trinary {
- metaData.hashMutex.RLock()
- defer metaData.hashMutex.RUnlock()
+func (metadata *TransactionMetadata) GetHash() ternary.Trinary {
+ metadata.hashMutex.RLock()
+ defer metadata.hashMutex.RUnlock()
- return metaData.hash
+ return metadata.hash
}
-func (metaData *TransactionMetadata) SetHash(hash ternary.Trinary) {
- metaData.hashMutex.RLock()
- if metaData.hash != hash {
- metaData.hashMutex.RUnlock()
- metaData.hashMutex.Lock()
- defer metaData.hashMutex.Unlock()
- if metaData.hash != hash {
- metaData.hash = hash
+func (metadata *TransactionMetadata) SetHash(hash ternary.Trinary) {
+ metadata.hashMutex.RLock()
+ if metadata.hash != hash {
+ metadata.hashMutex.RUnlock()
+ metadata.hashMutex.Lock()
+ defer metadata.hashMutex.Unlock()
+ if metadata.hash != hash {
+ metadata.hash = hash
- metaData.SetModified(true)
+ metadata.SetModified(true)
}
} else {
- metaData.hashMutex.RUnlock()
+ metadata.hashMutex.RUnlock()
}
}
-func (metaData *TransactionMetadata) GetReceivedTime() time.Time {
- metaData.receivedTimeMutex.RLock()
- defer metaData.receivedTimeMutex.RUnlock()
+func (metadata *TransactionMetadata) GetReceivedTime() time.Time {
+ metadata.receivedTimeMutex.RLock()
+ defer metadata.receivedTimeMutex.RUnlock()
- return metaData.receivedTime
+ return metadata.receivedTime
}
-func (metaData *TransactionMetadata) SetReceivedTime(receivedTime time.Time) {
- metaData.receivedTimeMutex.RLock()
- if metaData.receivedTime != receivedTime {
- metaData.receivedTimeMutex.RUnlock()
- metaData.receivedTimeMutex.Lock()
- defer metaData.receivedTimeMutex.Unlock()
- if metaData.receivedTime != receivedTime {
- metaData.receivedTime = receivedTime
-
- metaData.SetModified(true)
+func (metadata *TransactionMetadata) SetReceivedTime(receivedTime time.Time) {
+ metadata.receivedTimeMutex.RLock()
+ if metadata.receivedTime != receivedTime {
+ metadata.receivedTimeMutex.RUnlock()
+ metadata.receivedTimeMutex.Lock()
+ defer metadata.receivedTimeMutex.Unlock()
+ if metadata.receivedTime != receivedTime {
+ metadata.receivedTime = receivedTime
+
+ metadata.SetModified(true)
}
} else {
- metaData.receivedTimeMutex.RUnlock()
+ metadata.receivedTimeMutex.RUnlock()
}
}
-func (metaData *TransactionMetadata) GetSolid() bool {
- metaData.solidMutex.RLock()
- defer metaData.solidMutex.RUnlock()
+func (metadata *TransactionMetadata) GetSolid() bool {
+ metadata.solidMutex.RLock()
+ defer metadata.solidMutex.RUnlock()
- return metaData.solid
+ return metadata.solid
}
-func (metaData *TransactionMetadata) SetSolid(solid bool) bool {
- metaData.solidMutex.RLock()
- if metaData.solid != solid {
- metaData.solidMutex.RUnlock()
- metaData.solidMutex.Lock()
- defer metaData.solidMutex.Unlock()
- if metaData.solid != solid {
- metaData.solid = solid
+func (metadata *TransactionMetadata) SetSolid(solid bool) bool {
+ metadata.solidMutex.RLock()
+ if metadata.solid != solid {
+ metadata.solidMutex.RUnlock()
+ metadata.solidMutex.Lock()
+ defer metadata.solidMutex.Unlock()
+ if metadata.solid != solid {
+ metadata.solid = solid
- metaData.SetModified(true)
+ metadata.SetModified(true)
return true
}
} else {
- metaData.solidMutex.RUnlock()
+ metadata.solidMutex.RUnlock()
}
return false
}
-func (metaData *TransactionMetadata) GetLiked() bool {
- metaData.likedMutex.RLock()
- defer metaData.likedMutex.RUnlock()
+func (metadata *TransactionMetadata) GetLiked() bool {
+ metadata.likedMutex.RLock()
+ defer metadata.likedMutex.RUnlock()
- return metaData.liked
+ return metadata.liked
}
-func (metaData *TransactionMetadata) SetLiked(liked bool) {
- metaData.likedMutex.RLock()
- if metaData.liked != liked {
- metaData.likedMutex.RUnlock()
- metaData.likedMutex.Lock()
- defer metaData.likedMutex.Unlock()
- if metaData.liked != liked {
- metaData.liked = liked
-
- metaData.SetModified(true)
+func (metadata *TransactionMetadata) SetLiked(liked bool) {
+ metadata.likedMutex.RLock()
+ if metadata.liked != liked {
+ metadata.likedMutex.RUnlock()
+ metadata.likedMutex.Lock()
+ defer metadata.likedMutex.Unlock()
+ if metadata.liked != liked {
+ metadata.liked = liked
+
+ metadata.SetModified(true)
}
} else {
- metaData.likedMutex.RUnlock()
+ metadata.likedMutex.RUnlock()
}
}
-func (metaData *TransactionMetadata) GetFinalized() bool {
- metaData.finalizedMutex.RLock()
- defer metaData.finalizedMutex.RUnlock()
+func (metadata *TransactionMetadata) GetFinalized() bool {
+ metadata.finalizedMutex.RLock()
+ defer metadata.finalizedMutex.RUnlock()
- return metaData.finalized
+ return metadata.finalized
}
-func (metaData *TransactionMetadata) SetFinalized(finalized bool) {
- metaData.finalizedMutex.RLock()
- if metaData.finalized != finalized {
- metaData.finalizedMutex.RUnlock()
- metaData.finalizedMutex.Lock()
- defer metaData.finalizedMutex.Unlock()
- if metaData.finalized != finalized {
- metaData.finalized = finalized
-
- metaData.SetModified(true)
+func (metadata *TransactionMetadata) SetFinalized(finalized bool) {
+ metadata.finalizedMutex.RLock()
+ if metadata.finalized != finalized {
+ metadata.finalizedMutex.RUnlock()
+ metadata.finalizedMutex.Lock()
+ defer metadata.finalizedMutex.Unlock()
+ if metadata.finalized != finalized {
+ metadata.finalized = finalized
+
+ metadata.SetModified(true)
}
} else {
- metaData.finalizedMutex.RUnlock()
+ metadata.finalizedMutex.RUnlock()
}
}
@@ -179,10 +179,10 @@ func (metadata *TransactionMetadata) SetModified(modified bool) {
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
-// region marshalling functions ////////////////////////////////////////////////////////////////////////////////////////
+// region marshaling functions ////////////////////////////////////////////////////////////////////////////////////////
func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError) {
- marshalledMetadata := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshaledMetadata := make([]byte, MARSHALED_TOTAL_SIZE)
metadata.receivedTimeMutex.RLock()
defer metadata.receivedTimeMutex.RUnlock()
@@ -193,13 +193,13 @@ func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError
metadata.finalizedMutex.RLock()
defer metadata.finalizedMutex.RUnlock()
- copy(marshalledMetadata[MARSHALLED_HASH_START:MARSHALLED_HASH_END], metadata.hash.CastToBytes())
+ copy(marshaledMetadata[MARSHALED_HASH_START:MARSHALED_HASH_END], metadata.hash.CastToBytes())
- marshalledReceivedTime, err := metadata.receivedTime.MarshalBinary()
+ marshaledReceivedTime, err := metadata.receivedTime.MarshalBinary()
if err != nil {
return nil, ErrMarshallFailed.Derive(err, "failed to marshal received time")
}
- copy(marshalledMetadata[MARSHALLED_RECEIVED_TIME_START:MARSHALLED_RECEIVED_TIME_END], marshalledReceivedTime)
+ copy(marshaledMetadata[MARSHALED_RECEIVED_TIME_START:MARSHALED_RECEIVED_TIME_END], marshaledReceivedTime)
var booleanFlags bitutils.BitMask
if metadata.solid {
@@ -211,9 +211,9 @@ func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError
if metadata.finalized {
booleanFlags = booleanFlags.SetFlag(2)
}
- marshalledMetadata[MARSHALLED_FLAGS_START] = byte(booleanFlags)
+ marshaledMetadata[MARSHALED_FLAGS_START] = byte(booleanFlags)
- return marshalledMetadata, nil
+ return marshaledMetadata, nil
}
func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableError {
@@ -228,13 +228,13 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE
metadata.finalizedMutex.Lock()
defer metadata.finalizedMutex.Unlock()
- metadata.hash = ternary.Trinary(typeconversion.BytesToString(data[MARSHALLED_HASH_START:MARSHALLED_HASH_END]))
+ metadata.hash = ternary.Trinary(typeconversion.BytesToString(data[MARSHALED_HASH_START:MARSHALED_HASH_END]))
- if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALLED_RECEIVED_TIME_START:MARSHALLED_RECEIVED_TIME_END]); err != nil {
+ if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALED_RECEIVED_TIME_START:MARSHALED_RECEIVED_TIME_END]); err != nil {
return ErrUnmarshalFailed.Derive(err, "could not unmarshal the received time")
}
- booleanFlags := bitutils.BitMask(data[MARSHALLED_FLAGS_START])
+ booleanFlags := bitutils.BitMask(data[MARSHALED_FLAGS_START])
if booleanFlags.HasFlag(0) {
metadata.solid = true
}
@@ -254,12 +254,12 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE
func (metadata *TransactionMetadata) Store() errors.IdentifiableError {
if metadata.GetModified() {
- marshalledMetadata, err := metadata.Marshal()
+ marshaledMetadata, err := metadata.Marshal()
if err != nil {
return err
}
- if err := transactionMetadataDatabase.Set(metadata.GetHash().CastToBytes(), marshalledMetadata); err != nil {
+ if err := transactionMetadataDatabase.Set(metadata.GetHash().CastToBytes(), marshaledMetadata); err != nil {
return ErrDatabaseError.Derive(err, "failed to store the transaction")
}
@@ -274,19 +274,19 @@ func (metadata *TransactionMetadata) Store() errors.IdentifiableError {
// region constants and variables //////////////////////////////////////////////////////////////////////////////////////
const (
- MARSHALLED_HASH_START = 0
- MARSHALLED_RECEIVED_TIME_START = MARSHALLED_HASH_END
- MARSHALLED_FLAGS_START = MARSHALLED_RECEIVED_TIME_END
+ MARSHALED_HASH_START = 0
+ MARSHALED_RECEIVED_TIME_START = MARSHALED_HASH_END
+ MARSHALED_FLAGS_START = MARSHALED_RECEIVED_TIME_END
- MARSHALLED_HASH_END = MARSHALLED_HASH_START + MARSHALLED_HASH_SIZE
- MARSHALLED_RECEIVED_TIME_END = MARSHALLED_RECEIVED_TIME_START + MARSHALLED_RECEIVED_TIME_SIZE
- MARSHALLED_FLAGS_END = MARSHALLED_FLAGS_START + MARSHALLED_FLAGS_SIZE
+ MARSHALED_HASH_END = MARSHALED_HASH_START + MARSHALED_HASH_SIZE
+ MARSHALED_RECEIVED_TIME_END = MARSHALED_RECEIVED_TIME_START + MARSHALED_RECEIVED_TIME_SIZE
+ MARSHALED_FLAGS_END = MARSHALED_FLAGS_START + MARSHALED_FLAGS_SIZE
- MARSHALLED_HASH_SIZE = 81
- MARSHALLED_RECEIVED_TIME_SIZE = 15
- MARSHALLED_FLAGS_SIZE = 1
+ MARSHALED_HASH_SIZE = 81
+ MARSHALED_RECEIVED_TIME_SIZE = 15
+ MARSHALED_FLAGS_SIZE = 1
- MARSHALLED_TOTAL_SIZE = MARSHALLED_FLAGS_END
+ MARSHALED_TOTAL_SIZE = MARSHALED_FLAGS_END
)
// endregion ////////////////////////////////////////////////////////////////////////////////////////////////////////////
--
GitLab