diff --git a/main.go b/main.go
index bbbed59c3fea26cbc043d54ea39efe8273aad224..514f031a620ef1fd5af3b65c3178aa0f4c8a0300 100644
--- a/main.go
+++ b/main.go
@@ -1,24 +1,24 @@
package main
import (
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/analysis"
- "github.com/iotaledger/goshimmer/plugins/autopeering"
- "github.com/iotaledger/goshimmer/plugins/cli"
- "github.com/iotaledger/goshimmer/plugins/gossip"
- "github.com/iotaledger/goshimmer/plugins/gracefulshutdown"
- "github.com/iotaledger/goshimmer/plugins/statusscreen"
- "github.com/iotaledger/goshimmer/plugins/tangle"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/analysis"
+ "github.com/iotaledger/goshimmer/plugins/autopeering"
+ "github.com/iotaledger/goshimmer/plugins/cli"
+ "github.com/iotaledger/goshimmer/plugins/gossip"
+ "github.com/iotaledger/goshimmer/plugins/gracefulshutdown"
+ "github.com/iotaledger/goshimmer/plugins/statusscreen"
+ "github.com/iotaledger/goshimmer/plugins/tangle"
)
func main() {
- node.Run(
- cli.PLUGIN,
- autopeering.PLUGIN,
- gossip.PLUGIN,
- tangle.PLUGIN,
- analysis.PLUGIN,
- statusscreen.PLUGIN,
- gracefulshutdown.PLUGIN,
- )
+ node.Run(
+ cli.PLUGIN,
+ autopeering.PLUGIN,
+ gossip.PLUGIN,
+ tangle.PLUGIN,
+ analysis.PLUGIN,
+ statusscreen.PLUGIN,
+ gracefulshutdown.PLUGIN,
+ )
}
diff --git a/packages/accountability/accountability.go b/packages/accountability/accountability.go
index b34a5f74decb48b5cecf878506a198ed40068fbb..e4974c4f844866633bf9eab4526fdbdf20a2c1ab 100644
--- a/packages/accountability/accountability.go
+++ b/packages/accountability/accountability.go
@@ -1,10 +1,11 @@
package accountability
import (
- "github.com/dgraph-io/badger"
- "github.com/iotaledger/goshimmer/packages/settings"
- "github.com/iotaledger/goshimmer/packages/identity"
"sync"
+
+ "github.com/dgraph-io/badger"
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/packages/settings"
)
var ownId *identity.Identity
@@ -22,37 +23,37 @@ func initOwnId() {
}
func generateNewIdentity() *identity.Identity {
- newIdentity := identity.GenerateRandomIdentity()
+ newIdentity := identity.GenerateRandomIdentity()
- if err := settings.Set([]byte("ACCOUNTABILITY_PUBLIC_KEY"), newIdentity.PublicKey); err != nil {
- panic(err)
- }
+ if err := settings.Set([]byte("ACCOUNTABILITY_PUBLIC_KEY"), newIdentity.PublicKey); err != nil {
+ panic(err)
+ }
- if err := settings.Set([]byte("ACCOUNTABILITY_PRIVATE_KEY"), newIdentity.PrivateKey); err != nil {
- panic(err)
- }
+ if err := settings.Set([]byte("ACCOUNTABILITY_PRIVATE_KEY"), newIdentity.PrivateKey); err != nil {
+ panic(err)
+ }
- return newIdentity
+ return newIdentity
}
func getIdentity() *identity.Identity {
- publicKey, err := settings.Get([]byte("ACCOUNTABILITY_PUBLIC_KEY"))
- if err != nil {
- if err == badger.ErrKeyNotFound {
- return generateNewIdentity()
- } else {
- panic(err)
- }
- }
-
- privateKey, err := settings.Get([]byte("ACCOUNTABILITY_PRIVATE_KEY"))
- if err != nil {
- if err == badger.ErrKeyNotFound {
- return generateNewIdentity()
- } else {
- panic(err)
- }
- }
-
- return identity.NewIdentity(publicKey, privateKey)
+ publicKey, err := settings.Get([]byte("ACCOUNTABILITY_PUBLIC_KEY"))
+ if err != nil {
+ if err == badger.ErrKeyNotFound {
+ return generateNewIdentity()
+ } else {
+ panic(err)
+ }
+ }
+
+ privateKey, err := settings.Get([]byte("ACCOUNTABILITY_PRIVATE_KEY"))
+ if err != nil {
+ if err == badger.ErrKeyNotFound {
+ return generateNewIdentity()
+ } else {
+ panic(err)
+ }
+ }
+
+ return identity.NewIdentity(publicKey, privateKey)
}
diff --git a/packages/bitutils/bitmask.go b/packages/bitutils/bitmask.go
index ac3a34bb6dcf1406f85464c944014337caeb0e2d..64bc50672386cd6b265709782c1c5622b3622a5f 100644
--- a/packages/bitutils/bitmask.go
+++ b/packages/bitutils/bitmask.go
@@ -3,13 +3,13 @@ package bitutils
type BitMask byte
func (bitmask BitMask) SetFlag(pos uint) BitMask {
- return bitmask | (1 << pos)
+ return bitmask | (1 << pos)
}
func (bitmask BitMask) ClearFlag(pos uint) BitMask {
- return bitmask & ^(1 << pos)
+ return bitmask & ^(1 << pos)
}
func (bitmask BitMask) HasFlag(pos uint) bool {
- return (bitmask & (1 << pos) > 0)
-}
\ No newline at end of file
+ return (bitmask&(1<<pos) > 0)
+}
diff --git a/packages/bitutils/bitmask_test.go b/packages/bitutils/bitmask_test.go
index 38dfb40839793724f40291c70d86e7b86e7865b4..1d04a895465299f3e6445417a8a2aa7908ef4272 100644
--- a/packages/bitutils/bitmask_test.go
+++ b/packages/bitutils/bitmask_test.go
@@ -1,35 +1,34 @@
package bitutils
import (
- "testing"
+ "testing"
)
func TestBitmask(t *testing.T) {
- var b BitMask
+ var b BitMask
- if b.HasFlag(0) {
- t.Error("flag at pos 0 should not be set")
- }
- if b.HasFlag(1) {
- t.Error("flag at pos 1 should not be set")
- }
+ if b.HasFlag(0) {
+ t.Error("flag at pos 0 should not be set")
+ }
+ if b.HasFlag(1) {
+ t.Error("flag at pos 1 should not be set")
+ }
- b = b.SetFlag(0)
- if !b.HasFlag(0) {
- t.Error("flag at pos 0 should be set")
- }
- b = b.SetFlag(1)
- if !b.HasFlag(1) {
- t.Error("flag at pos 1 should be set")
- }
+ b = b.SetFlag(0)
+ if !b.HasFlag(0) {
+ t.Error("flag at pos 0 should be set")
+ }
+ b = b.SetFlag(1)
+ if !b.HasFlag(1) {
+ t.Error("flag at pos 1 should be set")
+ }
- b = b.ClearFlag(0)
- if b.HasFlag(0) {
- t.Error("flag at pos 0 should not be set")
- }
- b = b.ClearFlag(1)
- if b.HasFlag(1) {
- t.Error("flag at pos 1 should not be set")
- }
+ b = b.ClearFlag(0)
+ if b.HasFlag(0) {
+ t.Error("flag at pos 0 should not be set")
+ }
+ b = b.ClearFlag(1)
+ if b.HasFlag(1) {
+ t.Error("flag at pos 1 should not be set")
+ }
}
-
diff --git a/packages/byteutils/byteutils.go b/packages/byteutils/byteutils.go
index ccf1b5f53ba055660e8143cd5264145f9dfb05dc..1f5311f07d9b2240b7267e26fda45a9a69ac20eb 100644
--- a/packages/byteutils/byteutils.go
+++ b/packages/byteutils/byteutils.go
@@ -1,17 +1,17 @@
package byteutils
func ReadAvailableBytesToBuffer(target []byte, targetOffset int, source []byte, sourceOffset int, sourceLength int) int {
- availableBytes := sourceLength - sourceOffset
- requiredBytes := len(target) - targetOffset
+ availableBytes := sourceLength - sourceOffset
+ requiredBytes := len(target) - targetOffset
- var bytesToRead int
- if availableBytes < requiredBytes {
- bytesToRead = availableBytes
- } else {
- bytesToRead = requiredBytes
- }
+ var bytesToRead int
+ if availableBytes < requiredBytes {
+ bytesToRead = availableBytes
+ } else {
+ bytesToRead = requiredBytes
+ }
- copy(target[targetOffset:], source[sourceOffset:sourceOffset + bytesToRead])
+ copy(target[targetOffset:], source[sourceOffset:sourceOffset+bytesToRead])
- return bytesToRead
+ return bytesToRead
}
diff --git a/packages/curl/batch_hasher.go b/packages/curl/batch_hasher.go
index f379583e00aa5eb3e826494890e2859c8da73449..649550a0c1266d0d6a0b2b7f704e8745997c5f79 100644
--- a/packages/curl/batch_hasher.go
+++ b/packages/curl/batch_hasher.go
@@ -1,103 +1,104 @@
package curl
import (
- "fmt"
- "github.com/iotaledger/goshimmer/packages/ternary"
- "strconv"
- "time"
+ "fmt"
+ "strconv"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/ternary"
)
type HashRequest struct {
- input ternary.Trits
- output chan ternary.Trits
+ input ternary.Trits
+ output chan ternary.Trits
}
type BatchHasher struct {
- hashRequests chan HashRequest
- hashLength int
- rounds int
+ hashRequests chan HashRequest
+ hashLength int
+ rounds int
}
func NewBatchHasher(hashLength int, rounds int) *BatchHasher {
- this := &BatchHasher{
- hashLength: hashLength,
- rounds: rounds,
- hashRequests: make(chan HashRequest),
- }
+ this := &BatchHasher{
+ hashLength: hashLength,
+ rounds: rounds,
+ hashRequests: make(chan HashRequest),
+ }
- go this.startDispatcher()
+ go this.startDispatcher()
- return this
+ return this
}
func (this *BatchHasher) startDispatcher() {
- for {
- collectedHashRequests := make([]HashRequest, 0)
-
- // wait for first request to start processing at all
- collectedHashRequests = append(collectedHashRequests, <- this.hashRequests)
-
- // collect additional requests that arrive within the timeout
- CollectAdditionalRequests:
- for {
- select {
- case hashRequest := <- this.hashRequests:
- collectedHashRequests = append(collectedHashRequests, hashRequest)
-
- if len(collectedHashRequests) == strconv.IntSize {
- break CollectAdditionalRequests
- }
- case <- time.After(50 * time.Millisecond):
- break CollectAdditionalRequests
- }
- }
-
- go this.processHashes(collectedHashRequests)
- }
+ for {
+ collectedHashRequests := make([]HashRequest, 0)
+
+ // wait for first request to start processing at all
+ collectedHashRequests = append(collectedHashRequests, <-this.hashRequests)
+
+ // collect additional requests that arrive within the timeout
+ CollectAdditionalRequests:
+ for {
+ select {
+ case hashRequest := <-this.hashRequests:
+ collectedHashRequests = append(collectedHashRequests, hashRequest)
+
+ if len(collectedHashRequests) == strconv.IntSize {
+ break CollectAdditionalRequests
+ }
+ case <-time.After(50 * time.Millisecond):
+ break CollectAdditionalRequests
+ }
+ }
+
+ go this.processHashes(collectedHashRequests)
+ }
}
func (this *BatchHasher) processHashes(collectedHashRequests []HashRequest) {
- if len(collectedHashRequests) > 1 {
- // multiplex the requests
- multiplexer := ternary.NewBCTernaryMultiplexer()
- for _, hashRequest := range collectedHashRequests {
- multiplexer.Add(hashRequest.input)
- }
- bcTrinary, err := multiplexer.Extract()
- if err != nil {
- fmt.Println(err)
- }
-
- // calculate the hash
- bctCurl := NewBCTCurl(this.hashLength, this.rounds)
- bctCurl.Reset()
- bctCurl.Absorb(bcTrinary)
-
- // extract the results from the demultiplexer
- demux := ternary.NewBCTernaryDemultiplexer(bctCurl.Squeeze(243))
- for i, hashRequest := range collectedHashRequests {
- hashRequest.output <- demux.Get(i)
- close(hashRequest.output)
- }
- } else {
- var resp = make(ternary.Trits, this.hashLength)
-
- curl := NewCurl(this.hashLength, this.rounds)
- curl.Absorb(collectedHashRequests[0].input, 0, len(collectedHashRequests[0].input))
- curl.Squeeze(resp, 0, this.hashLength)
-
- collectedHashRequests[0].output <- resp
- close(collectedHashRequests[0].output)
- }
+ if len(collectedHashRequests) > 1 {
+ // multiplex the requests
+ multiplexer := ternary.NewBCTernaryMultiplexer()
+ for _, hashRequest := range collectedHashRequests {
+ multiplexer.Add(hashRequest.input)
+ }
+ bcTrinary, err := multiplexer.Extract()
+ if err != nil {
+ fmt.Println(err)
+ }
+
+ // calculate the hash
+ bctCurl := NewBCTCurl(this.hashLength, this.rounds)
+ bctCurl.Reset()
+ bctCurl.Absorb(bcTrinary)
+
+ // extract the results from the demultiplexer
+ demux := ternary.NewBCTernaryDemultiplexer(bctCurl.Squeeze(243))
+ for i, hashRequest := range collectedHashRequests {
+ hashRequest.output <- demux.Get(i)
+ close(hashRequest.output)
+ }
+ } else {
+ var resp = make(ternary.Trits, this.hashLength)
+
+ curl := NewCurl(this.hashLength, this.rounds)
+ curl.Absorb(collectedHashRequests[0].input, 0, len(collectedHashRequests[0].input))
+ curl.Squeeze(resp, 0, this.hashLength)
+
+ collectedHashRequests[0].output <- resp
+ close(collectedHashRequests[0].output)
+ }
}
func (this *BatchHasher) Hash(trinary ternary.Trits) chan ternary.Trits {
- hashRequest := HashRequest{
- input: trinary,
- output: make(chan ternary.Trits, 1),
- }
+ hashRequest := HashRequest{
+ input: trinary,
+ output: make(chan ternary.Trits, 1),
+ }
- this.hashRequests <- hashRequest
+ this.hashRequests <- hashRequest
- return hashRequest.output
-}
\ No newline at end of file
+ return hashRequest.output
+}
diff --git a/packages/curl/bct_curl.go b/packages/curl/bct_curl.go
index 5fef944527e9274512566cb6f425fb49b7953fe1..90045cef861639ea202d3f1272ed2d3b69919513 100644
--- a/packages/curl/bct_curl.go
+++ b/packages/curl/bct_curl.go
@@ -3,114 +3,114 @@ package curl
import "github.com/iotaledger/goshimmer/packages/ternary"
const (
- HIGH_LONG_BITS = 0xFFFFFFFFFFFFFFFF
+ HIGH_LONG_BITS = 0xFFFFFFFFFFFFFFFF
)
type BCTCurl struct {
- hashLength int
- numberOfRounds int
- stateLength int
- state ternary.BCTrinary
- cTransform func()
+ hashLength int
+ numberOfRounds int
+ stateLength int
+ state ternary.BCTrinary
+ cTransform func()
}
func NewBCTCurl(hashLength int, numberOfRounds int) *BCTCurl {
- this := &BCTCurl{
- hashLength: hashLength,
- numberOfRounds: numberOfRounds,
- stateLength: ternary.NUMBER_OF_TRITS_IN_A_TRYTE * hashLength,
- state: ternary.BCTrinary{
- Lo: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE * hashLength),
- Hi: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE * hashLength),
- },
- cTransform: nil,
- }
-
- this.Reset()
-
- return this
+ this := &BCTCurl{
+ hashLength: hashLength,
+ numberOfRounds: numberOfRounds,
+ stateLength: ternary.NUMBER_OF_TRITS_IN_A_TRYTE * hashLength,
+ state: ternary.BCTrinary{
+ Lo: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
+ Hi: make([]uint, ternary.NUMBER_OF_TRITS_IN_A_TRYTE*hashLength),
+ },
+ cTransform: nil,
+ }
+
+ this.Reset()
+
+ return this
}
func (this *BCTCurl) Reset() {
- for i:= 0; i < this.stateLength; i++ {
- this.state.Lo[i] = HIGH_LONG_BITS
- this.state.Hi[i] = HIGH_LONG_BITS
- }
+ for i := 0; i < this.stateLength; i++ {
+ this.state.Lo[i] = HIGH_LONG_BITS
+ this.state.Hi[i] = HIGH_LONG_BITS
+ }
}
func (this *BCTCurl) Transform() {
- scratchPadLo := make([]uint, this.stateLength)
- scratchPadHi := make([]uint, this.stateLength)
- scratchPadIndex := 0
-
- for round := this.numberOfRounds; round > 0; round-- {
- copy(scratchPadLo, this.state.Lo)
- copy(scratchPadHi, this.state.Hi)
- for stateIndex := 0; stateIndex < this.stateLength; stateIndex++ {
- alpha := scratchPadLo[scratchPadIndex]
- beta := scratchPadHi[scratchPadIndex]
-
- if scratchPadIndex < 365 {
- scratchPadIndex += 364
- } else {
- scratchPadIndex -= 365
- }
-
- delta := beta ^ scratchPadLo[scratchPadIndex]
-
- this.state.Lo[stateIndex] = ^(delta & alpha)
- this.state.Hi[stateIndex] = delta | (alpha ^ scratchPadHi[scratchPadIndex])
- }
- }
+ scratchPadLo := make([]uint, this.stateLength)
+ scratchPadHi := make([]uint, this.stateLength)
+ scratchPadIndex := 0
+
+ for round := this.numberOfRounds; round > 0; round-- {
+ copy(scratchPadLo, this.state.Lo)
+ copy(scratchPadHi, this.state.Hi)
+ for stateIndex := 0; stateIndex < this.stateLength; stateIndex++ {
+ alpha := scratchPadLo[scratchPadIndex]
+ beta := scratchPadHi[scratchPadIndex]
+
+ if scratchPadIndex < 365 {
+ scratchPadIndex += 364
+ } else {
+ scratchPadIndex -= 365
+ }
+
+ delta := beta ^ scratchPadLo[scratchPadIndex]
+
+ this.state.Lo[stateIndex] = ^(delta & alpha)
+ this.state.Hi[stateIndex] = delta | (alpha ^ scratchPadHi[scratchPadIndex])
+ }
+ }
}
func (this *BCTCurl) Absorb(bcTrits ternary.BCTrinary) {
- length := len(bcTrits.Lo)
- offset := 0
-
- for {
- var lengthToCopy int
- if length < this.hashLength {
- lengthToCopy = length
- } else {
- lengthToCopy = this.hashLength
- }
-
- copy(this.state.Lo[0:lengthToCopy], bcTrits.Lo[offset:offset + lengthToCopy])
- copy(this.state.Hi[0:lengthToCopy], bcTrits.Hi[offset:offset + lengthToCopy])
- this.Transform()
-
- offset += lengthToCopy
- length -= lengthToCopy
-
- if length <= 0 {
- break
- }
- }
+ length := len(bcTrits.Lo)
+ offset := 0
+
+ for {
+ var lengthToCopy int
+ if length < this.hashLength {
+ lengthToCopy = length
+ } else {
+ lengthToCopy = this.hashLength
+ }
+
+ copy(this.state.Lo[0:lengthToCopy], bcTrits.Lo[offset:offset+lengthToCopy])
+ copy(this.state.Hi[0:lengthToCopy], bcTrits.Hi[offset:offset+lengthToCopy])
+ this.Transform()
+
+ offset += lengthToCopy
+ length -= lengthToCopy
+
+ if length <= 0 {
+ break
+ }
+ }
}
func (this *BCTCurl) Squeeze(tritCount int) ternary.BCTrinary {
- result := ternary.BCTrinary{
- Lo: make([]uint, tritCount),
- Hi: make([]uint, tritCount),
- }
- hashCount := tritCount / this.hashLength
+ result := ternary.BCTrinary{
+ Lo: make([]uint, tritCount),
+ Hi: make([]uint, tritCount),
+ }
+ hashCount := tritCount / this.hashLength
- for i := 0; i < hashCount; i++ {
- copy(result.Lo[i*this.hashLength:(i+1)*this.hashLength], this.state.Lo[0:this.hashLength])
- copy(result.Hi[i*this.hashLength:(i+1)*this.hashLength], this.state.Hi[0:this.hashLength])
+ for i := 0; i < hashCount; i++ {
+ copy(result.Lo[i*this.hashLength:(i+1)*this.hashLength], this.state.Lo[0:this.hashLength])
+ copy(result.Hi[i*this.hashLength:(i+1)*this.hashLength], this.state.Hi[0:this.hashLength])
- this.Transform()
- }
+ this.Transform()
+ }
- last := tritCount - hashCount*this.hashLength
+ last := tritCount - hashCount*this.hashLength
- copy(result.Lo[tritCount-last:], this.state.Lo[0:last])
- copy(result.Hi[tritCount-last:], this.state.Hi[0:last])
+ copy(result.Lo[tritCount-last:], this.state.Lo[0:last])
+ copy(result.Hi[tritCount-last:], this.state.Hi[0:last])
- if tritCount % this.hashLength != 0 {
- this.Transform()
- }
+ if tritCount%this.hashLength != 0 {
+ this.Transform()
+ }
- return result
+ return result
}
diff --git a/packages/curl/curl.go b/packages/curl/curl.go
index 6ef01ac878881e288229403c46f87e1a98d283f1..4c19bb3170c0c4c4b8dd4f0dac48f18f45064b2d 100644
--- a/packages/curl/curl.go
+++ b/packages/curl/curl.go
@@ -1,104 +1,103 @@
package curl
import (
- "github.com/iotaledger/goshimmer/packages/ternary"
- "math"
+ "math"
+
+ "github.com/iotaledger/goshimmer/packages/ternary"
)
const (
- HASH_LENGTH = 243
- STATE_LENGTH = ternary.NUMBER_OF_TRITS_IN_A_TRYTE * HASH_LENGTH
+ HASH_LENGTH = 243
+ STATE_LENGTH = ternary.NUMBER_OF_TRITS_IN_A_TRYTE * HASH_LENGTH
)
var (
- TRUTH_TABLE = ternary.Trits{1, 0, -1, 2, 1, -1, 0, 2, -1, 1, 0}
+ TRUTH_TABLE = ternary.Trits{1, 0, -1, 2, 1, -1, 0, 2, -1, 1, 0}
)
-
type Hash interface {
- Initialize()
- InitializeCurl(trits *[]int8, length int, rounds int)
- Reset()
- Absorb(trits *[]int8, offset int, length int)
- Squeeze(resp []int8, offset int, length int) []int
+ Initialize()
+ InitializeCurl(trits *[]int8, length int, rounds int)
+ Reset()
+ Absorb(trits *[]int8, offset int, length int)
+ Squeeze(resp []int8, offset int, length int) []int
}
-
type Curl struct {
- Hash
- state ternary.Trits
- hashLength int
- rounds int
+ Hash
+ state ternary.Trits
+ hashLength int
+ rounds int
}
func NewCurl(hashLength int, rounds int) *Curl {
- this := &Curl{
- hashLength: hashLength,
- rounds: rounds,
- }
+ this := &Curl{
+ hashLength: hashLength,
+ rounds: rounds,
+ }
- this.Reset()
+ this.Reset()
- return this
+ return this
}
func (curl *Curl) Initialize() {
- curl.InitializeCurl(nil, 0, curl.rounds)
+ curl.InitializeCurl(nil, 0, curl.rounds)
}
func (curl *Curl) InitializeCurl(trinary ternary.Trits, length int, rounds int) {
- curl.rounds = rounds
- if trinary != nil {
- curl.state = trinary
- } else {
- curl.state = make(ternary.Trits, STATE_LENGTH)
- }
+ curl.rounds = rounds
+ if trinary != nil {
+ curl.state = trinary
+ } else {
+ curl.state = make(ternary.Trits, STATE_LENGTH)
+ }
}
func (curl *Curl) Reset() {
- curl.InitializeCurl(nil, 0, curl.rounds)
+ curl.InitializeCurl(nil, 0, curl.rounds)
}
func (curl *Curl) Absorb(trinary ternary.Trits, offset int, length int) {
- for {
- limit := int(math.Min(HASH_LENGTH, float64(length)))
- copy(curl.state, trinary[offset:offset+limit])
- curl.Transform()
- offset += HASH_LENGTH
- length -= HASH_LENGTH
- if length <= 0 {
- break
- }
- }
+ for {
+ limit := int(math.Min(HASH_LENGTH, float64(length)))
+ copy(curl.state, trinary[offset:offset+limit])
+ curl.Transform()
+ offset += HASH_LENGTH
+ length -= HASH_LENGTH
+ if length <= 0 {
+ break
+ }
+ }
}
func (curl *Curl) Squeeze(resp ternary.Trits, offset int, length int) ternary.Trits {
- for {
- limit := int(math.Min(HASH_LENGTH, float64(length)))
- copy(resp[offset:offset+limit], curl.state)
- curl.Transform()
- offset += HASH_LENGTH
- length -= HASH_LENGTH
- if length <= 0 {
- break
- }
- }
- return resp
+ for {
+ limit := int(math.Min(HASH_LENGTH, float64(length)))
+ copy(resp[offset:offset+limit], curl.state)
+ curl.Transform()
+ offset += HASH_LENGTH
+ length -= HASH_LENGTH
+ if length <= 0 {
+ break
+ }
+ }
+ return resp
}
func (curl *Curl) Transform() {
- var index = 0
- for round := 0; round < curl.rounds; round++ {
- stateCopy := make(ternary.Trits, STATE_LENGTH)
- copy(stateCopy, curl.state)
- for i := 0; i < STATE_LENGTH; i++ {
- incr := 364
- if index >= 365 {
- incr = -365
- }
- index2 := index + incr
- curl.state[i] = TRUTH_TABLE[stateCopy[index]+(stateCopy[index2]<<2)+5]
- index = index2
- }
- }
-}
\ No newline at end of file
+ var index = 0
+ for round := 0; round < curl.rounds; round++ {
+ stateCopy := make(ternary.Trits, STATE_LENGTH)
+ copy(stateCopy, curl.state)
+ for i := 0; i < STATE_LENGTH; i++ {
+ incr := 364
+ if index >= 365 {
+ incr = -365
+ }
+ index2 := index + incr
+ curl.state[i] = TRUTH_TABLE[stateCopy[index]+(stateCopy[index2]<<2)+5]
+ index = index2
+ }
+ }
+}
diff --git a/packages/curl/curlp81.go b/packages/curl/curlp81.go
index 7e6ed0b3434eaea6780e58a241dd776968a41b4a..579271500b19e802cf94a11c665f6308cb2b8016 100644
--- a/packages/curl/curlp81.go
+++ b/packages/curl/curlp81.go
@@ -1,10 +1,10 @@
package curl
const (
- CURLP81_HASH_LENGTH = 243
- CURLP81_ROUNDS = 81
+ CURLP81_HASH_LENGTH = 243
+ CURLP81_ROUNDS = 81
)
var (
- CURLP81 = NewBatchHasher(CURLP81_HASH_LENGTH, CURLP81_ROUNDS)
+ CURLP81 = NewBatchHasher(CURLP81_HASH_LENGTH, CURLP81_ROUNDS)
)
diff --git a/packages/daemon/daemon.go b/packages/daemon/daemon.go
index ceeea026850e1e2c66cba58ef9f1b01364b7593a..404fccd00b25674bc39961c87bcd7ffcc6ca7994 100644
--- a/packages/daemon/daemon.go
+++ b/packages/daemon/daemon.go
@@ -1,77 +1,77 @@
package daemon
import (
- "sync"
+ "sync"
)
var (
- running bool
- wg sync.WaitGroup
- ShutdownSignal = make(chan int, 1)
- backgroundWorkers = make([]func(), 0)
- lock = sync.Mutex{}
+ running bool
+ wg sync.WaitGroup
+ ShutdownSignal = make(chan int, 1)
+ backgroundWorkers = make([]func(), 0)
+ lock = sync.Mutex{}
)
func runBackgroundWorker(backgroundWorker func()) {
- wg.Add(1)
+ wg.Add(1)
- go func() {
- backgroundWorker()
+ go func() {
+ backgroundWorker()
- wg.Done()
- }()
+ wg.Done()
+ }()
}
func BackgroundWorker(handler func()) {
- lock.Lock()
+ lock.Lock()
- if IsRunning() {
- runBackgroundWorker(handler)
- } else {
- backgroundWorkers = append(backgroundWorkers, handler)
- }
+ if IsRunning() {
+ runBackgroundWorker(handler)
+ } else {
+ backgroundWorkers = append(backgroundWorkers, handler)
+ }
- lock.Unlock()
+ lock.Unlock()
}
func Run() {
- if !running {
- lock.Lock()
+ if !running {
+ lock.Lock()
- if !running {
- ShutdownSignal = make(chan int, 1)
+ if !running {
+ ShutdownSignal = make(chan int, 1)
- running = true
+ running = true
- Events.Run.Trigger()
+ Events.Run.Trigger()
- for _, backgroundWorker := range backgroundWorkers {
- runBackgroundWorker(backgroundWorker)
- }
- }
+ for _, backgroundWorker := range backgroundWorkers {
+ runBackgroundWorker(backgroundWorker)
+ }
+ }
- lock.Unlock()
- }
+ lock.Unlock()
+ }
- wg.Wait()
+ wg.Wait()
}
func Shutdown() {
- if running {
- lock.Lock()
+ if running {
+ lock.Lock()
- if running {
- close(ShutdownSignal)
+ if running {
+ close(ShutdownSignal)
- running = false
+ running = false
- Events.Shutdown.Trigger()
- }
+ Events.Shutdown.Trigger()
+ }
- lock.Unlock()
- }
+ lock.Unlock()
+ }
}
func IsRunning() bool {
- return running
+ return running
}
diff --git a/packages/daemon/events.go b/packages/daemon/events.go
index cebf3a8924f433e7b3488bbfc7b5374157c3de83..dd3953287de61468d50a613d8eb3b7d466474d56 100644
--- a/packages/daemon/events.go
+++ b/packages/daemon/events.go
@@ -1,13 +1,13 @@
package daemon
import (
- "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/events"
)
var Events = struct {
- Run *events.Event
- Shutdown *events.Event
+ Run *events.Event
+ Shutdown *events.Event
}{
- Run: events.NewEvent(events.CallbackCaller),
- Shutdown: events.NewEvent(events.CallbackCaller),
+ Run: events.NewEvent(events.CallbackCaller),
+ Shutdown: events.NewEvent(events.CallbackCaller),
}
diff --git a/packages/database/database.go b/packages/database/database.go
index 70f1f54429616a351959f4d6081a7fddb3a8ddac..9ac44a31685a017dd62785b16996f089540b15c8 100644
--- a/packages/database/database.go
+++ b/packages/database/database.go
@@ -1,10 +1,11 @@
package database
import (
- "github.com/dgraph-io/badger"
- "os"
- "path/filepath"
- "sync"
+ "os"
+ "path/filepath"
+ "sync"
+
+ "github.com/dgraph-io/badger"
)
var databasesByName = make(map[string]*databaseImpl)
@@ -13,117 +14,117 @@ var getLock sync.Mutex
var ErrKeyNotFound = badger.ErrKeyNotFound
type databaseImpl struct {
- db *badger.DB
- name string
- openLock sync.Mutex
+ db *badger.DB
+ name string
+ openLock sync.Mutex
}
func Get(name string) (Database, error) {
- getLock.Lock()
- defer getLock.Unlock()
+ getLock.Lock()
+ defer getLock.Unlock()
- if database, exists := databasesByName[name]; exists {
- return database, nil
- }
+ if database, exists := databasesByName[name]; exists {
+ return database, nil
+ }
- database := &databaseImpl{
- db: nil,
- name: name,
- }
- if err := database.Open(); err != nil {
- return nil, err
- }
+ database := &databaseImpl{
+ db: nil,
+ name: name,
+ }
+ if err := database.Open(); err != nil {
+ return nil, err
+ }
- databasesByName[name] = database
+ databasesByName[name] = database
- return databasesByName[name], nil
+ return databasesByName[name], nil
}
func (this *databaseImpl) Open() error {
- this.openLock.Lock()
- defer this.openLock.Unlock()
-
- if this.db == nil {
- directory := *DIRECTORY.Value
-
- if _, err := os.Stat(directory); os.IsNotExist(err) {
- if err := os.Mkdir(directory, 0700); err != nil {
- return err
- }
- }
-
- opts := badger.DefaultOptions
- opts.Dir = directory + string(filepath.Separator) + this.name
- opts.ValueDir = opts.Dir
- opts.Logger = &logger{}
- opts.Truncate = true
-
- db, err := badger.Open(opts)
- if err != nil {
- return err
- }
- this.db = db
- }
-
- return nil
+ this.openLock.Lock()
+ defer this.openLock.Unlock()
+
+ if this.db == nil {
+ directory := *DIRECTORY.Value
+
+ if _, err := os.Stat(directory); os.IsNotExist(err) {
+ if err := os.Mkdir(directory, 0700); err != nil {
+ return err
+ }
+ }
+
+ opts := badger.DefaultOptions
+ opts.Dir = directory + string(filepath.Separator) + this.name
+ opts.ValueDir = opts.Dir
+ opts.Logger = &logger{}
+ opts.Truncate = true
+
+ db, err := badger.Open(opts)
+ if err != nil {
+ return err
+ }
+ this.db = db
+ }
+
+ return nil
}
func (this *databaseImpl) Set(key []byte, value []byte) error {
- if err := this.db.Update(func(txn *badger.Txn) error { return txn.Set(key, value) }); err != nil {
- return err
- }
+ if err := this.db.Update(func(txn *badger.Txn) error { return txn.Set(key, value) }); err != nil {
+ return err
+ }
- return nil
+ return nil
}
func (this *databaseImpl) Contains(key []byte) (bool, error) {
- if err := this.db.View(func(txn *badger.Txn) error {
- _, err := txn.Get(key)
- if err != nil {
- return err
- }
-
- return nil
- }); err == ErrKeyNotFound {
- return false, nil
- } else {
- return err == nil, err
- }
+ if err := this.db.View(func(txn *badger.Txn) error {
+ _, err := txn.Get(key)
+ if err != nil {
+ return err
+ }
+
+ return nil
+ }); err == ErrKeyNotFound {
+ return false, nil
+ } else {
+ return err == nil, err
+ }
}
func (this *databaseImpl) Get(key []byte) ([]byte, error) {
- var result []byte = nil
- var err error = nil
+ var result []byte = nil
+ var err error = nil
- err = this.db.View(func(txn *badger.Txn) error {
- item, err := txn.Get(key)
- if err != nil {
- return err
- }
+ err = this.db.View(func(txn *badger.Txn) error {
+ item, err := txn.Get(key)
+ if err != nil {
+ return err
+ }
- return item.Value(func(val []byte) error {
- result = append([]byte{}, val...)
+ return item.Value(func(val []byte) error {
+ result = append([]byte{}, val...)
- return nil
- })
- })
+ return nil
+ })
+ })
- return result, err
+ return result, err
}
func (this *databaseImpl) Close() error {
- this.openLock.Lock()
- defer this.openLock.Unlock()
+ this.openLock.Lock()
+ defer this.openLock.Unlock()
- if this.db != nil {
- err := this.db.Close()
+ if this.db != nil {
+ err := this.db.Close()
- this.db = nil
+ this.db = nil
- if err != nil {
- return err
- }
- }
+ if err != nil {
+ return err
+ }
+ }
- return nil
+ return nil
}
diff --git a/packages/database/interfaces.go b/packages/database/interfaces.go
index c3ff1c35b0a1463314b615404c4d9d2036f2d216..26b3a5863a360404ac48baff94f41ed3423bc2a4 100644
--- a/packages/database/interfaces.go
+++ b/packages/database/interfaces.go
@@ -1,9 +1,9 @@
package database
type Database interface {
- Open() error
- Set(key []byte, value []byte) error
- Get(key []byte) ([]byte, error)
- Contains(key []byte) (bool, error)
- Close() error
+ Open() error
+ Set(key []byte, value []byte) error
+ Get(key []byte) ([]byte, error)
+ Contains(key []byte) (bool, error)
+ Close() error
}
diff --git a/packages/database/logger.go b/packages/database/logger.go
index 72b6a72ea4d5c89a7ce16a7b1c8aaa703221c358..ac1de091452794ddb04857acd94df5ff87df72d7 100644
--- a/packages/database/logger.go
+++ b/packages/database/logger.go
@@ -1,17 +1,17 @@
package database
-type logger struct {}
+type logger struct{}
func (this *logger) Errorf(string, ...interface{}) {
- // disable logging
+ // disable logging
}
func (this *logger) Infof(string, ...interface{}) {
- // disable logging
+ // disable logging
}
func (this *logger) Warningf(string, ...interface{}) {
- // disable logging
+ // disable logging
}
func (this *logger) Debugf(string, ...interface{}) {
diff --git a/packages/database/parameters.go b/packages/database/parameters.go
index ac364c8f39c2f24e5437c217dc02270b7799039a..fb6e1c2c26fc6065f2ae74485f5ca29afc7aa54a 100644
--- a/packages/database/parameters.go
+++ b/packages/database/parameters.go
@@ -1,7 +1,7 @@
package database
import (
- "github.com/iotaledger/goshimmer/packages/parameter"
+ "github.com/iotaledger/goshimmer/packages/parameter"
)
var DIRECTORY = parameter.AddString("DATABASE/DIRECTORY", "mainnetdb", "path to the database folder")
diff --git a/packages/datastructure/doubly_linked_list.go b/packages/datastructure/doubly_linked_list.go
index 724a5e3a20509542e7ab29d209bba080ba6013f3..34793818e926a513d659b71fec5afcf53a0565fd 100644
--- a/packages/datastructure/doubly_linked_list.go
+++ b/packages/datastructure/doubly_linked_list.go
@@ -1,8 +1,9 @@
package datastructure
import (
- "github.com/iotaledger/goshimmer/packages/errors"
"sync"
+
+ "github.com/iotaledger/goshimmer/packages/errors"
)
type DoublyLinkedList struct {
diff --git a/packages/datastructure/lru_cache.go b/packages/datastructure/lru_cache.go
index 7b4e2a2dbc746dcd45d157739bc47d26af2209c9..b8ac09177b58c1a8a0c58674f8031a86539a8644 100644
--- a/packages/datastructure/lru_cache.go
+++ b/packages/datastructure/lru_cache.go
@@ -59,7 +59,7 @@ func (cache *LRUCache) Set(key interface{}, value interface{}) {
}
}
-func (cache *LRUCache) Contains(key interface{}, optionalCallback ... func(interface{}, bool)) bool {
+func (cache *LRUCache) Contains(key interface{}, optionalCallback ...func(interface{}, bool)) bool {
var callback func(interface{}, bool)
if len(optionalCallback) >= 1 {
diff --git a/packages/errors/errors.go b/packages/errors/errors.go
index 4be504c850bd54efeebc72fa53152f648d15103e..738ed629704070ce452d025deebb90905098128d 100644
--- a/packages/errors/errors.go
+++ b/packages/errors/errors.go
@@ -93,8 +93,8 @@
package errors
import (
- "fmt"
- "io"
+ "fmt"
+ "io"
)
var idCounter = 0
@@ -102,234 +102,234 @@ var idCounter = 0
// New returns an error with the supplied message.
// New also records the stack trace at the point it was called.
func New(message string) *fundamental {
- idCounter++
+ idCounter++
- return &fundamental{
- id: idCounter,
- msg: message,
- stack: Callers(),
- }
+ return &fundamental{
+ id: idCounter,
+ msg: message,
+ stack: Callers(),
+ }
}
// Errorf formats according to a format specifier and returns the string
// as a value that satisfies error.
// Errorf also records the stack trace at the point it was called.
func Errorf(format string, args ...interface{}) IdentifiableError {
- idCounter++
+ idCounter++
- return &fundamental{
- id: idCounter,
- msg: fmt.Sprintf(format, args...),
- stack: Callers(),
- }
+ return &fundamental{
+ id: idCounter,
+ msg: fmt.Sprintf(format, args...),
+ stack: Callers(),
+ }
}
// fundamental is an error that has a message and a stack, but no caller.
type fundamental struct {
- id int
- msg string
- *stack
+ id int
+ msg string
+ *stack
}
func (f *fundamental) Derive(msg string) *fundamental {
- return &fundamental{
- id: f.id,
- msg: msg,
- stack: Callers(),
- }
+ return &fundamental{
+ id: f.id,
+ msg: msg,
+ stack: Callers(),
+ }
}
func (f *fundamental) Error() string { return f.msg }
func (f *fundamental) Equals(err IdentifiableError) bool {
- return f.id == err.Id()
+ return f.id == err.Id()
}
func (f *fundamental) Id() int {
- return f.id
+ return f.id
}
func (f *fundamental) Format(s fmt.State, verb rune) {
- switch verb {
- case 'v':
- if s.Flag('+') {
- io.WriteString(s, f.msg)
- f.stack.Format(s, verb)
- return
- }
- fallthrough
- case 's':
- io.WriteString(s, f.msg)
- case 'q':
- fmt.Fprintf(s, "%q", f.msg)
- }
+ switch verb {
+ case 'v':
+ if s.Flag('+') {
+ io.WriteString(s, f.msg)
+ f.stack.Format(s, verb)
+ return
+ }
+ fallthrough
+ case 's':
+ io.WriteString(s, f.msg)
+ case 'q':
+ fmt.Fprintf(s, "%q", f.msg)
+ }
}
// WithStack annotates err with a stack trace at the point WithStack was called.
// If err is nil, WithStack returns nil.
func WithStack(err error) IdentifiableError {
- if err == nil {
- return nil
- }
+ if err == nil {
+ return nil
+ }
- idCounter++
+ idCounter++
- return &withStack{
- idCounter,
- err,
- Callers(),
- }
+ return &withStack{
+ idCounter,
+ err,
+ Callers(),
+ }
}
type withStack struct {
- int
- error
- *stack
+ int
+ error
+ *stack
}
func (w *withStack) Equals(err IdentifiableError) bool {
- return w.int == err.Id()
+ return w.int == err.Id()
}
func (w *withStack) Id() int {
- return w.int
+ return w.int
}
func (w *withStack) Derive(err error, message string) *withStack {
- if err == nil {
- return nil
- }
- return &withStack{
- w.int,
- &withMessage{
- cause: err,
- msg: message,
- },
- Callers(),
- }
+ if err == nil {
+ return nil
+ }
+ return &withStack{
+ w.int,
+ &withMessage{
+ cause: err,
+ msg: message,
+ },
+ Callers(),
+ }
}
func (w *withStack) Cause() error { return w.error }
func (w *withStack) Format(s fmt.State, verb rune) {
- switch verb {
- case 'v':
- if s.Flag('+') {
- fmt.Fprintf(s, "%+v", w.Cause())
- w.stack.Format(s, verb)
- return
- }
- fallthrough
- case 's':
- io.WriteString(s, w.Error())
- case 'q':
- fmt.Fprintf(s, "%q", w.Error())
- }
+ switch verb {
+ case 'v':
+ if s.Flag('+') {
+ fmt.Fprintf(s, "%+v", w.Cause())
+ w.stack.Format(s, verb)
+ return
+ }
+ fallthrough
+ case 's':
+ io.WriteString(s, w.Error())
+ case 'q':
+ fmt.Fprintf(s, "%q", w.Error())
+ }
}
// Wrap returns an error annotating err with a stack trace
// at the point Wrap is called, and the supplied message.
// If err is nil, Wrap returns nil.
func Wrap(err error, message string) *withStack {
- if err == nil {
- return nil
- }
- err = &withMessage{
- cause: err,
- msg: message,
- }
-
- idCounter++
-
- return &withStack{
- idCounter,
- err,
- Callers(),
- }
+ if err == nil {
+ return nil
+ }
+ err = &withMessage{
+ cause: err,
+ msg: message,
+ }
+
+ idCounter++
+
+ return &withStack{
+ idCounter,
+ err,
+ Callers(),
+ }
}
// Wrapf returns an error annotating err with a stack trace
// at the point Wrapf is called, and the format specifier.
// If err is nil, Wrapf returns nil.
func Wrapf(err error, format string, args ...interface{}) IdentifiableError {
- if err == nil {
- return nil
- }
- err = &withMessage{
- cause: err,
- msg: fmt.Sprintf(format, args...),
- }
-
- idCounter++
-
- return &withStack{
- idCounter,
- err,
- Callers(),
- }
+ if err == nil {
+ return nil
+ }
+ err = &withMessage{
+ cause: err,
+ msg: fmt.Sprintf(format, args...),
+ }
+
+ idCounter++
+
+ return &withStack{
+ idCounter,
+ err,
+ Callers(),
+ }
}
// WithMessage annotates err with a new message.
// If err is nil, WithMessage returns nil.
func WithMessage(err error, message string) IdentifiableError {
- if err == nil {
- return nil
- }
+ if err == nil {
+ return nil
+ }
- idCounter++
+ idCounter++
- return &withMessage{
- id: idCounter,
- cause: err,
- msg: message,
- }
+ return &withMessage{
+ id: idCounter,
+ cause: err,
+ msg: message,
+ }
}
// WithMessagef annotates err with the format specifier.
// If err is nil, WithMessagef returns nil.
func WithMessagef(err error, format string, args ...interface{}) IdentifiableError {
- if err == nil {
- return nil
- }
+ if err == nil {
+ return nil
+ }
- idCounter++
+ idCounter++
- return &withMessage{
- id: idCounter,
- cause: err,
- msg: fmt.Sprintf(format, args...),
- }
+ return &withMessage{
+ id: idCounter,
+ cause: err,
+ msg: fmt.Sprintf(format, args...),
+ }
}
type withMessage struct {
- id int
- cause error
- msg string
+ id int
+ cause error
+ msg string
}
func (w *withMessage) Equals(err IdentifiableError) bool {
- return w.id == err.Id()
+ return w.id == err.Id()
}
func (w *withMessage) Id() int {
- return w.id
+ return w.id
}
func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() }
func (w *withMessage) Cause() error { return w.cause }
func (w *withMessage) Format(s fmt.State, verb rune) {
- switch verb {
- case 'v':
- if s.Flag('+') {
- fmt.Fprintf(s, "%+v\n", w.Cause())
- io.WriteString(s, w.msg)
- return
- }
- fallthrough
- case 's', 'q':
- io.WriteString(s, w.Error())
- }
+ switch verb {
+ case 'v':
+ if s.Flag('+') {
+ fmt.Fprintf(s, "%+v\n", w.Cause())
+ io.WriteString(s, w.msg)
+ return
+ }
+ fallthrough
+ case 's', 'q':
+ io.WriteString(s, w.Error())
+ }
}
// Cause returns the underlying cause of the error, if possible.
@@ -344,22 +344,22 @@ func (w *withMessage) Format(s fmt.State, verb rune) {
// be returned. If the error is nil, nil will be returned without further
// investigation.
func Cause(err error) error {
- type causer interface {
- Cause() error
- }
-
- for err != nil {
- cause, ok := err.(causer)
- if !ok {
- break
- }
- err = cause.Cause()
- }
- return err
+ type causer interface {
+ Cause() error
+ }
+
+ for err != nil {
+ cause, ok := err.(causer)
+ if !ok {
+ break
+ }
+ err = cause.Cause()
+ }
+ return err
}
type IdentifiableError interface {
- Error() string
- Equals(identifiableError IdentifiableError) bool
- Id() int
-}
\ No newline at end of file
+ Error() string
+ Equals(identifiableError IdentifiableError) bool
+ Id() int
+}
diff --git a/packages/errors/stack.go b/packages/errors/stack.go
index c9ca045690e254be760e181d75e14609185e1b38..875216879918d050cf26196e1fb6581a4d7768c3 100644
--- a/packages/errors/stack.go
+++ b/packages/errors/stack.go
@@ -1,12 +1,12 @@
package errors
import (
- "fmt"
- "io"
- "path"
- "runtime"
- "strconv"
- "strings"
+ "fmt"
+ "io"
+ "path"
+ "runtime"
+ "strconv"
+ "strings"
)
// Frame represents a program counter inside a stack frame.
@@ -21,32 +21,32 @@ func (f Frame) pc() uintptr { return uintptr(f) - 1 }
// file returns the full path to the file that contains the
// function for this Frame's pc.
func (f Frame) file() string {
- fn := runtime.FuncForPC(f.pc())
- if fn == nil {
- return "unknown"
- }
- file, _ := fn.FileLine(f.pc())
- return file
+ fn := runtime.FuncForPC(f.pc())
+ if fn == nil {
+ return "unknown"
+ }
+ file, _ := fn.FileLine(f.pc())
+ return file
}
// line returns the line number of source code of the
// function for this Frame's pc.
func (f Frame) line() int {
- fn := runtime.FuncForPC(f.pc())
- if fn == nil {
- return 0
- }
- _, line := fn.FileLine(f.pc())
- return line
+ fn := runtime.FuncForPC(f.pc())
+ if fn == nil {
+ return 0
+ }
+ _, line := fn.FileLine(f.pc())
+ return line
}
// name returns the name of this function, if known.
func (f Frame) name() string {
- fn := runtime.FuncForPC(f.pc())
- if fn == nil {
- return "unknown"
- }
- return fn.Name()
+ fn := runtime.FuncForPC(f.pc())
+ if fn == nil {
+ return "unknown"
+ }
+ return fn.Name()
}
// Format formats the frame according to the fmt.Formatter interface.
@@ -62,35 +62,35 @@ func (f Frame) name() string {
// GOPATH separated by \n\t (<funcname>\n\t<path>)
// %+v equivalent to %+s:%d
func (f Frame) Format(s fmt.State, verb rune) {
- switch verb {
- case 's':
- switch {
- case s.Flag('+'):
- io.WriteString(s, f.name())
- io.WriteString(s, "\n\t")
- io.WriteString(s, f.file())
- default:
- io.WriteString(s, path.Base(f.file()))
- }
- case 'd':
- io.WriteString(s, strconv.Itoa(f.line()))
- case 'n':
- io.WriteString(s, funcname(f.name()))
- case 'v':
- f.Format(s, 's')
- io.WriteString(s, ":")
- f.Format(s, 'd')
- }
+ switch verb {
+ case 's':
+ switch {
+ case s.Flag('+'):
+ io.WriteString(s, f.name())
+ io.WriteString(s, "\n\t")
+ io.WriteString(s, f.file())
+ default:
+ io.WriteString(s, path.Base(f.file()))
+ }
+ case 'd':
+ io.WriteString(s, strconv.Itoa(f.line()))
+ case 'n':
+ io.WriteString(s, funcname(f.name()))
+ case 'v':
+ f.Format(s, 's')
+ io.WriteString(s, ":")
+ f.Format(s, 'd')
+ }
}
// MarshalText formats a stacktrace Frame as a text string. The output is the
// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
func (f Frame) MarshalText() ([]byte, error) {
- name := f.name()
- if name == "unknown" {
- return []byte(name), nil
- }
- return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
+ name := f.name()
+ if name == "unknown" {
+ return []byte(name), nil
+ }
+ return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
}
// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
@@ -105,73 +105,73 @@ type StackTrace []Frame
//
// %+v Prints filename, function, and line number for each Frame in the stack.
func (st StackTrace) Format(s fmt.State, verb rune) {
- switch verb {
- case 'v':
- switch {
- case s.Flag('+'):
- for _, f := range st {
- io.WriteString(s, "\n")
- f.Format(s, verb)
- }
- case s.Flag('#'):
- fmt.Fprintf(s, "%#v", []Frame(st))
- default:
- st.formatSlice(s, verb)
- }
- case 's':
- st.formatSlice(s, verb)
- }
+ switch verb {
+ case 'v':
+ switch {
+ case s.Flag('+'):
+ for _, f := range st {
+ io.WriteString(s, "\n")
+ f.Format(s, verb)
+ }
+ case s.Flag('#'):
+ fmt.Fprintf(s, "%#v", []Frame(st))
+ default:
+ st.formatSlice(s, verb)
+ }
+ case 's':
+ st.formatSlice(s, verb)
+ }
}
// formatSlice will format this StackTrace into the given buffer as a slice of
// Frame, only valid when called with '%s' or '%v'.
func (st StackTrace) formatSlice(s fmt.State, verb rune) {
- io.WriteString(s, "[")
- for i, f := range st {
- if i > 0 {
- io.WriteString(s, " ")
- }
- f.Format(s, verb)
- }
- io.WriteString(s, "]")
+ io.WriteString(s, "[")
+ for i, f := range st {
+ if i > 0 {
+ io.WriteString(s, " ")
+ }
+ f.Format(s, verb)
+ }
+ io.WriteString(s, "]")
}
// stack represents a stack of program counters.
type stack []uintptr
func (s *stack) Format(st fmt.State, verb rune) {
- switch verb {
- case 'v':
- switch {
- case st.Flag('+'):
- for _, pc := range *s {
- f := Frame(pc)
- fmt.Fprintf(st, "\n%+v", f)
- }
- }
- }
+ switch verb {
+ case 'v':
+ switch {
+ case st.Flag('+'):
+ for _, pc := range *s {
+ f := Frame(pc)
+ fmt.Fprintf(st, "\n%+v", f)
+ }
+ }
+ }
}
func (s *stack) StackTrace() StackTrace {
- f := make([]Frame, len(*s))
- for i := 0; i < len(f); i++ {
- f[i] = Frame((*s)[i])
- }
- return f
+ f := make([]Frame, len(*s))
+ for i := 0; i < len(f); i++ {
+ f[i] = Frame((*s)[i])
+ }
+ return f
}
func Callers() *stack {
- const depth = 32
- var pcs [depth]uintptr
- n := runtime.Callers(3, pcs[:])
- var st stack = pcs[0:n]
- return &st
+ const depth = 32
+ var pcs [depth]uintptr
+ n := runtime.Callers(3, pcs[:])
+ var st stack = pcs[0:n]
+ return &st
}
// funcname removes the path prefix component of a function's name reported by func.Name().
func funcname(name string) string {
- i := strings.LastIndex(name, "/")
- name = name[i+1:]
- i = strings.Index(name, ".")
- return name[i+1:]
-}
\ No newline at end of file
+ i := strings.LastIndex(name, "/")
+ name = name[i+1:]
+ i = strings.Index(name, ".")
+ return name[i+1:]
+}
diff --git a/packages/events/closure.go b/packages/events/closure.go
index 109725b18a8c6257d59387b0093c23888cc498b6..9777b5556853b380399cdf58a61217c2a0c2cb23 100644
--- a/packages/events/closure.go
+++ b/packages/events/closure.go
@@ -3,16 +3,16 @@ package events
import "reflect"
type Closure struct {
- Id uintptr
- Fnc interface{}
+ Id uintptr
+ Fnc interface{}
}
func NewClosure(f interface{}) *Closure {
- closure := &Closure{
- Fnc: f,
- }
+ closure := &Closure{
+ Fnc: f,
+ }
- closure.Id = reflect.ValueOf(closure).Pointer()
+ closure.Id = reflect.ValueOf(closure).Pointer()
- return closure
-}
\ No newline at end of file
+ return closure
+}
diff --git a/packages/events/event.go b/packages/events/event.go
index 7a19722e571c645e68dff0429ab54ffc3422401f..d35788bcf8a7e39054a22a223eb12226ed9cba66 100644
--- a/packages/events/event.go
+++ b/packages/events/event.go
@@ -1,27 +1,27 @@
package events
type Event struct {
- triggerFunc func(handler interface{}, params ...interface{})
- callbacks map[uintptr]interface{}
+ triggerFunc func(handler interface{}, params ...interface{})
+ callbacks map[uintptr]interface{}
}
func (this *Event) Attach(closure *Closure) {
- this.callbacks[closure.Id] = closure.Fnc
+ this.callbacks[closure.Id] = closure.Fnc
}
func (this *Event) Detach(closure *Closure) {
- delete(this.callbacks, closure.Id)
+ delete(this.callbacks, closure.Id)
}
func (this *Event) Trigger(params ...interface{}) {
- for _, handler := range this.callbacks {
- this.triggerFunc(handler, params...)
- }
+ for _, handler := range this.callbacks {
+ this.triggerFunc(handler, params...)
+ }
}
func NewEvent(triggerFunc func(handler interface{}, params ...interface{})) *Event {
- return &Event{
- triggerFunc: triggerFunc,
- callbacks: make(map[uintptr]interface{}),
- }
+ return &Event{
+ triggerFunc: triggerFunc,
+ callbacks: make(map[uintptr]interface{}),
+ }
}
diff --git a/packages/filter/byte_array_filter.go b/packages/filter/byte_array_filter.go
index c879cc8869e3df236eb55a28c695e0ca25632582..ba5aca0a4910142c3c570849b2861203466367b8 100644
--- a/packages/filter/byte_array_filter.go
+++ b/packages/filter/byte_array_filter.go
@@ -1,53 +1,54 @@
package filter
import (
- "github.com/iotaledger/goshimmer/packages/typeconversion"
- "sync"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/typeconversion"
)
type ByteArrayFilter struct {
- byteArrays [][]byte
- byteArraysByKey map[string]bool
- size int
- mutex sync.RWMutex
+ byteArrays [][]byte
+ byteArraysByKey map[string]bool
+ size int
+ mutex sync.RWMutex
}
func NewByteArrayFilter(size int) *ByteArrayFilter {
- return &ByteArrayFilter{
- byteArrays: make([][]byte, 0, size),
- byteArraysByKey: make(map[string]bool, size),
- size: size,
- }
+ return &ByteArrayFilter{
+ byteArrays: make([][]byte, 0, size),
+ byteArraysByKey: make(map[string]bool, size),
+ size: size,
+ }
}
func (filter *ByteArrayFilter) Contains(byteArray []byte) bool {
- filter.mutex.RLock()
- defer filter.mutex.RUnlock()
+ filter.mutex.RLock()
+ defer filter.mutex.RUnlock()
- _, exists := filter.byteArraysByKey[typeconversion.BytesToString(byteArray)]
+ _, exists := filter.byteArraysByKey[typeconversion.BytesToString(byteArray)]
- return exists
+ return exists
}
func (filter *ByteArrayFilter) Add(byteArray []byte) bool {
- key := typeconversion.BytesToString(byteArray)
+ key := typeconversion.BytesToString(byteArray)
- filter.mutex.Lock()
- defer filter.mutex.Unlock()
+ filter.mutex.Lock()
+ defer filter.mutex.Unlock()
- if _, exists := filter.byteArraysByKey[key]; !exists {
- if len(filter.byteArrays) == filter.size {
- delete(filter.byteArraysByKey, typeconversion.BytesToString(filter.byteArrays[0]))
+ if _, exists := filter.byteArraysByKey[key]; !exists {
+ if len(filter.byteArrays) == filter.size {
+ delete(filter.byteArraysByKey, typeconversion.BytesToString(filter.byteArrays[0]))
- filter.byteArrays = append(filter.byteArrays[1:], byteArray)
- } else {
- filter.byteArrays = append(filter.byteArrays, byteArray)
- }
+ filter.byteArrays = append(filter.byteArrays[1:], byteArray)
+ } else {
+ filter.byteArrays = append(filter.byteArrays, byteArray)
+ }
- filter.byteArraysByKey[key] = true
+ filter.byteArraysByKey[key] = true
- return true
- } else {
- return false
- }
+ return true
+ } else {
+ return false
+ }
}
diff --git a/packages/filter/byte_array_filter_test.go b/packages/filter/byte_array_filter_test.go
index c2031bd1df0c6ceecd4a90f7f8b14759dae7aee3..a017866b4ea40ccc079d37f0fea83fa59f42efb4 100644
--- a/packages/filter/byte_array_filter_test.go
+++ b/packages/filter/byte_array_filter_test.go
@@ -3,43 +3,43 @@ package filter
import "testing"
func BenchmarkAdd(b *testing.B) {
- filter, byteArray := setupFilter(15000, 1604)
+ filter, byteArray := setupFilter(15000, 1604)
- b.ResetTimer()
+ b.ResetTimer()
- for i := 0; i < b.N; i++ {
- filter.Add(byteArray)
- }
+ for i := 0; i < b.N; i++ {
+ filter.Add(byteArray)
+ }
}
func BenchmarkContains(b *testing.B) {
- filter, byteArray := setupFilter(15000, 1604)
+ filter, byteArray := setupFilter(15000, 1604)
- b.ResetTimer()
+ b.ResetTimer()
- for i := 0; i < b.N; i++ {
- filter.Contains(byteArray)
- }
+ for i := 0; i < b.N; i++ {
+ filter.Contains(byteArray)
+ }
}
func setupFilter(filterSize int, byteArraySize int) (*ByteArrayFilter, []byte) {
- filter := NewByteArrayFilter(filterSize)
+ filter := NewByteArrayFilter(filterSize)
- for j := 0; j < filterSize; j++ {
- byteArray := make([]byte, byteArraySize)
+ for j := 0; j < filterSize; j++ {
+ byteArray := make([]byte, byteArraySize)
- for i := 0; i < len(byteArray); i++ {
- byteArray[(i + j) % byteArraySize] = byte((i + j) % 128)
- }
+ for i := 0; i < len(byteArray); i++ {
+ byteArray[(i+j)%byteArraySize] = byte((i + j) % 128)
+ }
- filter.Add(byteArray)
- }
+ filter.Add(byteArray)
+ }
- byteArray := make([]byte, byteArraySize)
+ byteArray := make([]byte, byteArraySize)
- for i := 0; i < len(byteArray); i++ {
- byteArray[i] = byte(i % 128)
- }
+ for i := 0; i < len(byteArray); i++ {
+ byteArray[i] = byte(i % 128)
+ }
- return filter, byteArray
+ return filter, byteArray
}
diff --git a/packages/identity/constants.go b/packages/identity/constants.go
index 0d7a5b986b1b57d5a3774256154d08898f7950f3..e7440a45d085b8a9c8dbf4bfbe75e297c9fee5c2 100644
--- a/packages/identity/constants.go
+++ b/packages/identity/constants.go
@@ -1,8 +1,8 @@
package identity
const (
- PRIVATE_TYPE = IdentityType(0)
- PUBLIC_TYPE = IdentityType(1)
+ PRIVATE_TYPE = IdentityType(0)
+ PUBLIC_TYPE = IdentityType(1)
- PUBLIC_KEY_BYTE_LENGTH = 65
+ PUBLIC_KEY_BYTE_LENGTH = 65
)
diff --git a/packages/identity/identity.go b/packages/identity/identity.go
index 0aa55efdb8077d653fddac57bf516b23d6d3d204..ac5a417ec6881829c8eaa06d4c6a743498929cd3 100644
--- a/packages/identity/identity.go
+++ b/packages/identity/identity.go
@@ -1,86 +1,87 @@
package identity
import (
- "crypto/ecdsa"
- "crypto/elliptic"
- "crypto/rand"
- "crypto/sha256"
- "fmt"
- "github.com/ethereum/go-ethereum/crypto/secp256k1"
- "github.com/iotaledger/goshimmer/packages/crypto"
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "crypto/rand"
+ "crypto/sha256"
+ "fmt"
+
+ "github.com/ethereum/go-ethereum/crypto/secp256k1"
+ "github.com/iotaledger/goshimmer/packages/crypto"
)
type Identity struct {
- Type IdentityType
- Identifier []byte
- StringIdentifier string
- PublicKey []byte
- PrivateKey []byte
+ Type IdentityType
+ Identifier []byte
+ StringIdentifier string
+ PublicKey []byte
+ PrivateKey []byte
}
-func NewIdentity(publicKey []byte, optionalPrivateKey ... []byte) *Identity {
- this := &Identity{
- Identifier: crypto.Hash20(publicKey),
- PublicKey: publicKey,
- }
+func NewIdentity(publicKey []byte, optionalPrivateKey ...[]byte) *Identity {
+ this := &Identity{
+ Identifier: crypto.Hash20(publicKey),
+ PublicKey: publicKey,
+ }
- this.StringIdentifier = fmt.Sprintf("%x", this.Identifier)
+ this.StringIdentifier = fmt.Sprintf("%x", this.Identifier)
- if len(optionalPrivateKey) == 1 {
- this.Type = PRIVATE_TYPE
- this.PrivateKey = optionalPrivateKey[0]
- } else {
- this.Type = PUBLIC_TYPE
- }
+ if len(optionalPrivateKey) == 1 {
+ this.Type = PRIVATE_TYPE
+ this.PrivateKey = optionalPrivateKey[0]
+ } else {
+ this.Type = PUBLIC_TYPE
+ }
- return this
+ return this
}
func (this *Identity) Sign(data []byte) ([]byte, error) {
- sha256Hasher := sha256.New()
- sha256Hasher.Write(data)
+ sha256Hasher := sha256.New()
+ sha256Hasher.Write(data)
- sig, err := secp256k1.Sign(sha256Hasher.Sum(nil), this.PrivateKey)
- if err != nil {
- return nil, err
- }
+ sig, err := secp256k1.Sign(sha256Hasher.Sum(nil), this.PrivateKey)
+ if err != nil {
+ return nil, err
+ }
- return sig, nil
+ return sig, nil
}
func (this *Identity) VerifySignature(data []byte, signature []byte) bool {
- sha256Hasher := sha256.New()
- sha256Hasher.Write(data)
+ sha256Hasher := sha256.New()
+ sha256Hasher.Write(data)
- return secp256k1.VerifySignature(this.PublicKey, sha256Hasher.Sum(nil), signature[:64])
+ return secp256k1.VerifySignature(this.PublicKey, sha256Hasher.Sum(nil), signature[:64])
}
func GenerateRandomIdentity() *Identity {
- // generate key pair
- keyPair, err := ecdsa.GenerateKey(secp256k1.S256(), rand.Reader)
- if err != nil {
- panic(err)
- }
+ // generate key pair
+ keyPair, err := ecdsa.GenerateKey(secp256k1.S256(), rand.Reader)
+ if err != nil {
+ panic(err)
+ }
- // build public key bytes
- publicKey := elliptic.Marshal(secp256k1.S256(), keyPair.X, keyPair.Y)
+ // build public key bytes
+ publicKey := elliptic.Marshal(secp256k1.S256(), keyPair.X, keyPair.Y)
- // build private key bytes
- privkey := make([]byte, 32)
- blob := keyPair.D.Bytes()
- copy(privkey[32-len(blob):], blob)
+ // build private key bytes
+ privkey := make([]byte, 32)
+ blob := keyPair.D.Bytes()
+ copy(privkey[32-len(blob):], blob)
- return NewIdentity(publicKey, privkey)
+ return NewIdentity(publicKey, privkey)
}
func FromSignedData(data []byte, signature []byte) (*Identity, error) {
- sha256Hasher := sha256.New()
- sha256Hasher.Write(data)
+ sha256Hasher := sha256.New()
+ sha256Hasher.Write(data)
- pubKey, err := secp256k1.RecoverPubkey(sha256Hasher.Sum(nil), signature)
- if err != nil {
- return nil, err
- }
+ pubKey, err := secp256k1.RecoverPubkey(sha256Hasher.Sum(nil), signature)
+ if err != nil {
+ return nil, err
+ }
- return NewIdentity(pubKey), nil
+ return NewIdentity(pubKey), nil
}
diff --git a/packages/network/events.go b/packages/network/events.go
index 14785389435ba77af1587639ee86340a7322805d..0096c1b59f36ce2fe4fa350ce774a6f26eed7c80 100644
--- a/packages/network/events.go
+++ b/packages/network/events.go
@@ -1,13 +1,15 @@
package network
import (
- "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/events"
)
type BufferedConnectionEvents struct {
- ReceiveData *events.Event
- Close *events.Event
- Error *events.Event
+ ReceiveData *events.Event
+ Close *events.Event
+ Error *events.Event
}
-func dataCaller(handler interface{}, params ...interface{}) { handler.(func([]byte))(params[0].([]byte)) }
\ No newline at end of file
+func dataCaller(handler interface{}, params ...interface{}) {
+ handler.(func([]byte))(params[0].([]byte))
+}
diff --git a/packages/network/managed_connection.go b/packages/network/managed_connection.go
index 9fb42fd072db76f28d6ca3ffe0f9645f8d34e689..30b48a894cd6cfdc10933fce3aa61731edf2b962 100644
--- a/packages/network/managed_connection.go
+++ b/packages/network/managed_connection.go
@@ -1,160 +1,161 @@
package network
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "io"
- "net"
- "sync"
- "time"
+ "io"
+ "net"
+ "sync"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/events"
)
type ManagedConnection struct {
- Conn net.Conn
- Events BufferedConnectionEvents
- readTimeout time.Duration
- writeTimeout time.Duration
- closeOnce sync.Once
+ Conn net.Conn
+ Events BufferedConnectionEvents
+ readTimeout time.Duration
+ writeTimeout time.Duration
+ closeOnce sync.Once
}
func NewManagedConnection(conn net.Conn) *ManagedConnection {
- bufferedConnection := &ManagedConnection{
- Conn: conn,
- Events: BufferedConnectionEvents{
- ReceiveData: events.NewEvent(dataCaller),
- Close: events.NewEvent(events.CallbackCaller),
- Error: events.NewEvent(events.ErrorCaller),
- },
- }
-
- return bufferedConnection
+ bufferedConnection := &ManagedConnection{
+ Conn: conn,
+ Events: BufferedConnectionEvents{
+ ReceiveData: events.NewEvent(dataCaller),
+ Close: events.NewEvent(events.CallbackCaller),
+ Error: events.NewEvent(events.ErrorCaller),
+ },
+ }
+
+ return bufferedConnection
}
func (this *ManagedConnection) Read(receiveBuffer []byte) (n int, err error) {
- defer this.Close()
+ defer this.Close()
- totalReadBytes := 0
- for {
- if err := this.setReadTimeoutBasedDeadline(); err != nil {
- return totalReadBytes, err
- }
+ totalReadBytes := 0
+ for {
+ if err := this.setReadTimeoutBasedDeadline(); err != nil {
+ return totalReadBytes, err
+ }
- byteCount, err := this.Conn.Read(receiveBuffer)
- if byteCount > 0 {
- totalReadBytes += byteCount
+ byteCount, err := this.Conn.Read(receiveBuffer)
+ if byteCount > 0 {
+ totalReadBytes += byteCount
- receivedData := make([]byte, byteCount)
- copy(receivedData, receiveBuffer)
+ receivedData := make([]byte, byteCount)
+ copy(receivedData, receiveBuffer)
- this.Events.ReceiveData.Trigger(receivedData)
- }
+ this.Events.ReceiveData.Trigger(receivedData)
+ }
- if err != nil {
- if err != io.EOF {
- this.Events.Error.Trigger(err)
- }
+ if err != nil {
+ if err != io.EOF {
+ this.Events.Error.Trigger(err)
+ }
- return totalReadBytes, err
- }
- }
+ return totalReadBytes, err
+ }
+ }
}
func (this *ManagedConnection) Write(data []byte) (n int, err error) {
- if err := this.setWriteTimeoutBasedDeadline(); err != nil {
- return 0, err
- }
+ if err := this.setWriteTimeoutBasedDeadline(); err != nil {
+ return 0, err
+ }
- return this.Conn.Write(data)
+ return this.Conn.Write(data)
}
func (this *ManagedConnection) Close() error {
- err := this.Conn.Close()
- if err != nil {
- this.Events.Error.Trigger(err)
- }
+ err := this.Conn.Close()
+ if err != nil {
+ this.Events.Error.Trigger(err)
+ }
- this.closeOnce.Do(func() {
- this.Events.Close.Trigger()
- })
+ this.closeOnce.Do(func() {
+ this.Events.Close.Trigger()
+ })
- return err
+ return err
}
func (this *ManagedConnection) LocalAddr() net.Addr {
- return this.Conn.LocalAddr()
+ return this.Conn.LocalAddr()
}
func (this *ManagedConnection) RemoteAddr() net.Addr {
- return this.Conn.RemoteAddr()
+ return this.Conn.RemoteAddr()
}
func (this *ManagedConnection) SetDeadline(t time.Time) error {
- return this.Conn.SetDeadline(t)
+ return this.Conn.SetDeadline(t)
}
func (this *ManagedConnection) SetReadDeadline(t time.Time) error {
- return this.Conn.SetReadDeadline(t)
+ return this.Conn.SetReadDeadline(t)
}
func (this *ManagedConnection) SetWriteDeadline(t time.Time) error {
- return this.Conn.SetWriteDeadline(t)
+ return this.Conn.SetWriteDeadline(t)
}
func (this *ManagedConnection) SetTimeout(d time.Duration) error {
- if err := this.SetReadTimeout(d); err != nil {
- return err
- }
+ if err := this.SetReadTimeout(d); err != nil {
+ return err
+ }
- if err := this.SetWriteTimeout(d); err != nil {
- return err
- }
+ if err := this.SetWriteTimeout(d); err != nil {
+ return err
+ }
- return nil
+ return nil
}
func (this *ManagedConnection) SetReadTimeout(d time.Duration) error {
- this.readTimeout = d
+ this.readTimeout = d
- if err := this.setReadTimeoutBasedDeadline(); err != nil {
- return err
- }
+ if err := this.setReadTimeoutBasedDeadline(); err != nil {
+ return err
+ }
- return nil
+ return nil
}
func (this *ManagedConnection) SetWriteTimeout(d time.Duration) error {
- this.writeTimeout = d
+ this.writeTimeout = d
- if err := this.setWriteTimeoutBasedDeadline(); err != nil {
- return err
- }
+ if err := this.setWriteTimeoutBasedDeadline(); err != nil {
+ return err
+ }
- return nil
+ return nil
}
func (this *ManagedConnection) setReadTimeoutBasedDeadline() error {
- if this.readTimeout != 0 {
- if err := this.Conn.SetReadDeadline(time.Now().Add(this.readTimeout)); err != nil {
- return err
- }
- } else {
- if err := this.Conn.SetReadDeadline(time.Time{}); err != nil {
- return err
- }
- }
-
- return nil
+ if this.readTimeout != 0 {
+ if err := this.Conn.SetReadDeadline(time.Now().Add(this.readTimeout)); err != nil {
+ return err
+ }
+ } else {
+ if err := this.Conn.SetReadDeadline(time.Time{}); err != nil {
+ return err
+ }
+ }
+
+ return nil
}
func (this *ManagedConnection) setWriteTimeoutBasedDeadline() error {
- if this.writeTimeout != 0 {
- if err := this.Conn.SetWriteDeadline(time.Now().Add(this.writeTimeout)); err != nil {
- return err
- }
- } else {
- if err := this.Conn.SetWriteDeadline(time.Time{}); err != nil {
- return err
- }
- }
-
- return nil
+ if this.writeTimeout != 0 {
+ if err := this.Conn.SetWriteDeadline(time.Now().Add(this.writeTimeout)); err != nil {
+ return err
+ }
+ } else {
+ if err := this.Conn.SetWriteDeadline(time.Time{}); err != nil {
+ return err
+ }
+ }
+
+ return nil
}
diff --git a/packages/network/parameters.go b/packages/network/parameters.go
index 65200679dc22d3777e39a8b3cb80613e7cb8f41b..bad4b1bab0265b334f737698e67f3e150848497b 100644
--- a/packages/network/parameters.go
+++ b/packages/network/parameters.go
@@ -1,5 +1,5 @@
package network
const (
- READ_BUFFER_SIZE = 81920
+ READ_BUFFER_SIZE = 81920
)
diff --git a/packages/network/tcp/server.go b/packages/network/tcp/server.go
index 3f8a3d0c177d408523207a349722af3f6df71765..6725d7532e3ee35da4dbcae992171cba49d2a632 100644
--- a/packages/network/tcp/server.go
+++ b/packages/network/tcp/server.go
@@ -1,61 +1,62 @@
package tcp
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/network"
- "net"
- "strconv"
+ "net"
+ "strconv"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/network"
)
type Server struct {
- Socket net.Listener
- Events serverEvents
+ Socket net.Listener
+ Events serverEvents
}
func (this *Server) Shutdown() {
- if this.Socket != nil {
- socket := this.Socket
- this.Socket = nil
+ if this.Socket != nil {
+ socket := this.Socket
+ this.Socket = nil
- socket.Close()
- }
+ socket.Close()
+ }
}
func (this *Server) Listen(port int) *Server {
- socket, err := net.Listen("tcp4", "0.0.0.0:"+strconv.Itoa(port))
- if err != nil {
- this.Events.Error.Trigger(err)
-
- return this
- } else {
- this.Socket = socket
- }
-
- this.Events.Start.Trigger()
- defer this.Events.Shutdown.Trigger()
-
- for this.Socket != nil {
- if socket, err := this.Socket.Accept(); err != nil {
- if this.Socket != nil {
- this.Events.Error.Trigger(err)
- }
- } else {
- peer := network.NewManagedConnection(socket)
-
- go this.Events.Connect.Trigger(peer)
- }
- }
-
- return this
+ socket, err := net.Listen("tcp4", "0.0.0.0:"+strconv.Itoa(port))
+ if err != nil {
+ this.Events.Error.Trigger(err)
+
+ return this
+ } else {
+ this.Socket = socket
+ }
+
+ this.Events.Start.Trigger()
+ defer this.Events.Shutdown.Trigger()
+
+ for this.Socket != nil {
+ if socket, err := this.Socket.Accept(); err != nil {
+ if this.Socket != nil {
+ this.Events.Error.Trigger(err)
+ }
+ } else {
+ peer := network.NewManagedConnection(socket)
+
+ go this.Events.Connect.Trigger(peer)
+ }
+ }
+
+ return this
}
func NewServer() *Server {
- return &Server{
- Events: serverEvents{
- Start: events.NewEvent(events.CallbackCaller),
- Shutdown: events.NewEvent(events.CallbackCaller),
- Connect: events.NewEvent(managedConnectionCaller),
- Error: events.NewEvent(events.ErrorCaller),
- },
- }
+ return &Server{
+ Events: serverEvents{
+ Start: events.NewEvent(events.CallbackCaller),
+ Shutdown: events.NewEvent(events.CallbackCaller),
+ Connect: events.NewEvent(managedConnectionCaller),
+ Error: events.NewEvent(events.ErrorCaller),
+ },
+ }
}
diff --git a/packages/network/tcp/server_events.go b/packages/network/tcp/server_events.go
index d3b6a57d6d710a11054327acc41c22670d284c5c..b5f3fbbeabf7b710b517a2984abc828171dda41b 100644
--- a/packages/network/tcp/server_events.go
+++ b/packages/network/tcp/server_events.go
@@ -1,15 +1,17 @@
package tcp
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/network"
)
type serverEvents struct {
- Start *events.Event
- Shutdown *events.Event
- Connect *events.Event
- Error *events.Event
+ Start *events.Event
+ Shutdown *events.Event
+ Connect *events.Event
+ Error *events.Event
}
-func managedConnectionCaller(handler interface{}, params ...interface{}) { handler.(func(*network.ManagedConnection))(params[0].(*network.ManagedConnection)) }
+func managedConnectionCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*network.ManagedConnection))(params[0].(*network.ManagedConnection))
+}
diff --git a/packages/network/types.go b/packages/network/types.go
index 2b985b7d83101a7992c097f25f2c97552ebe3ef1..1a31faf507dc59e0d61d3980ce5920815ce37a89 100644
--- a/packages/network/types.go
+++ b/packages/network/types.go
@@ -5,4 +5,3 @@ type Callback func()
type ErrorConsumer func(err error)
type DataConsumer func(data []byte)
-
diff --git a/packages/network/udp/events.go b/packages/network/udp/events.go
index f90162998664b01977ca0c787b10b781d4bbfc15..dc797d0e5caebe5d6a136b36d3aa609aabad1c76 100644
--- a/packages/network/udp/events.go
+++ b/packages/network/udp/events.go
@@ -1,15 +1,18 @@
package udp
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "net"
+ "net"
+
+ "github.com/iotaledger/goshimmer/packages/events"
)
type serverEvents struct {
- Start *events.Event
- Shutdown *events.Event
- ReceiveData *events.Event
- Error *events.Event
+ Start *events.Event
+ Shutdown *events.Event
+ ReceiveData *events.Event
+ Error *events.Event
}
-func dataCaller(handler interface{}, params ...interface{}) { handler.(func(*net.UDPAddr, []byte))(params[0].(*net.UDPAddr), params[1].([]byte)) }
+func dataCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*net.UDPAddr, []byte))(params[0].(*net.UDPAddr), params[1].([]byte))
+}
diff --git a/packages/network/udp/server.go b/packages/network/udp/server.go
index 0e3a6afecba8fdf99c0941a461ebfb3e38b216da..71ab5846a8c7156d09c18334cc7d1b1e50e93330 100644
--- a/packages/network/udp/server.go
+++ b/packages/network/udp/server.go
@@ -1,58 +1,59 @@
package udp
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "net"
- "strconv"
+ "net"
+ "strconv"
+
+ "github.com/iotaledger/goshimmer/packages/events"
)
type Server struct {
- Socket net.PacketConn
- ReceiveBufferSize int
- Events serverEvents
+ Socket net.PacketConn
+ ReceiveBufferSize int
+ Events serverEvents
}
func (this *Server) Shutdown() {
- if this.Socket != nil {
- socket := this.Socket
- this.Socket = nil
+ if this.Socket != nil {
+ socket := this.Socket
+ this.Socket = nil
- socket.Close()
- }
+ socket.Close()
+ }
}
func (this *Server) Listen(address string, port int) {
- if socket, err := net.ListenPacket("udp", address + ":" + strconv.Itoa(port)); err != nil {
- this.Events.Error.Trigger(err)
-
- return
- } else {
- this.Socket = socket
- }
-
- this.Events.Start.Trigger()
- defer this.Events.Shutdown.Trigger()
-
- buf := make([]byte, this.ReceiveBufferSize)
- for this.Socket != nil {
- if bytesRead, addr, err := this.Socket.ReadFrom(buf); err != nil {
- if this.Socket != nil {
- this.Events.Error.Trigger(err)
- }
- } else {
- this.Events.ReceiveData.Trigger(addr.(*net.UDPAddr), buf[:bytesRead])
- }
- }
+ if socket, err := net.ListenPacket("udp", address+":"+strconv.Itoa(port)); err != nil {
+ this.Events.Error.Trigger(err)
+
+ return
+ } else {
+ this.Socket = socket
+ }
+
+ this.Events.Start.Trigger()
+ defer this.Events.Shutdown.Trigger()
+
+ buf := make([]byte, this.ReceiveBufferSize)
+ for this.Socket != nil {
+ if bytesRead, addr, err := this.Socket.ReadFrom(buf); err != nil {
+ if this.Socket != nil {
+ this.Events.Error.Trigger(err)
+ }
+ } else {
+ this.Events.ReceiveData.Trigger(addr.(*net.UDPAddr), buf[:bytesRead])
+ }
+ }
}
func NewServer(receiveBufferSize int) *Server {
- return &Server{
- ReceiveBufferSize: receiveBufferSize,
- Events: serverEvents{
- Start: events.NewEvent(events.CallbackCaller),
- Shutdown: events.NewEvent(events.CallbackCaller),
- ReceiveData: events.NewEvent(dataCaller),
- Error: events.NewEvent(events.ErrorCaller),
- },
- }
+ return &Server{
+ ReceiveBufferSize: receiveBufferSize,
+ Events: serverEvents{
+ Start: events.NewEvent(events.CallbackCaller),
+ Shutdown: events.NewEvent(events.CallbackCaller),
+ ReceiveData: events.NewEvent(dataCaller),
+ Error: events.NewEvent(events.ErrorCaller),
+ },
+ }
}
diff --git a/packages/node/constants.go b/packages/node/constants.go
index 52ad490ffebffbf795c62773d1d121bbc67f7911..4e90679ec100c341892573c4c5966649cc8e193f 100644
--- a/packages/node/constants.go
+++ b/packages/node/constants.go
@@ -1,9 +1,9 @@
package node
const (
- LOG_LEVEL_FAILURE = 0
- LOG_LEVEL_WARNING = 1
- LOG_LEVEL_SUCCESS = 2
- LOG_LEVEL_INFO = 3
- LOG_LEVEL_DEBUG = 4
+ LOG_LEVEL_FAILURE = 0
+ LOG_LEVEL_WARNING = 1
+ LOG_LEVEL_SUCCESS = 2
+ LOG_LEVEL_INFO = 3
+ LOG_LEVEL_DEBUG = 4
)
diff --git a/packages/node/events.go b/packages/node/events.go
index 39784286cbe04f6fd96f95d642c250298ff88eef..4b5a8e80d1d915e40fa7932a28cc09966a969ed8 100644
--- a/packages/node/events.go
+++ b/packages/node/events.go
@@ -1,12 +1,14 @@
package node
import (
- "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/events"
)
type pluginEvents struct {
- Configure *events.Event
- Run *events.Event
+ Configure *events.Event
+ Run *events.Event
}
-func pluginCaller(handler interface{}, params ...interface{}) { handler.(func(*Plugin))(params[0].(*Plugin)) }
\ No newline at end of file
+func pluginCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*Plugin))(params[0].(*Plugin))
+}
diff --git a/packages/node/logger.go b/packages/node/logger.go
index 6a206f888e9af0528c27b7e61c77093e4edd5dfa..28723044c8d48c6b0f3dd05b29d334f843adcb18 100644
--- a/packages/node/logger.go
+++ b/packages/node/logger.go
@@ -3,40 +3,40 @@ package node
import "fmt"
type Logger struct {
- Enabled bool
- LogInfo func(pluginName string, message string)
- LogSuccess func(pluginName string, message string)
- LogWarning func(pluginName string, message string)
- LogFailure func(pluginName string, message string)
- LogDebug func(pluginName string, message string)
+ Enabled bool
+ LogInfo func(pluginName string, message string)
+ LogSuccess func(pluginName string, message string)
+ LogWarning func(pluginName string, message string)
+ LogFailure func(pluginName string, message string)
+ LogDebug func(pluginName string, message string)
}
func pluginPrefix(pluginName string) string {
- var pluginPrefix string
- if pluginName == "Node" {
- pluginPrefix = ""
- } else {
- pluginPrefix = pluginName + ": "
- }
+ var pluginPrefix string
+ if pluginName == "Node" {
+ pluginPrefix = ""
+ } else {
+ pluginPrefix = pluginName + ": "
+ }
- return pluginPrefix
+ return pluginPrefix
}
var DEFAULT_LOGGER = &Logger{
- Enabled: true,
- LogSuccess: func(pluginName string, message string) {
- fmt.Println("[ OK ] " + pluginPrefix(pluginName) + message)
- },
- LogInfo: func(pluginName string, message string) {
- fmt.Println("[ INFO ] " + pluginPrefix(pluginName) + message)
- },
- LogWarning: func(pluginName string, message string) {
- fmt.Println("[ WARN ] " + pluginPrefix(pluginName) + message)
- },
- LogFailure: func(pluginName string, message string) {
- fmt.Println("[ FAIL ] " + pluginPrefix(pluginName) + message)
- },
- LogDebug: func(pluginName string, message string) {
- fmt.Println("[ NOTE ] " + pluginPrefix(pluginName) + message)
- },
+ Enabled: true,
+ LogSuccess: func(pluginName string, message string) {
+ fmt.Println("[ OK ] " + pluginPrefix(pluginName) + message)
+ },
+ LogInfo: func(pluginName string, message string) {
+ fmt.Println("[ INFO ] " + pluginPrefix(pluginName) + message)
+ },
+ LogWarning: func(pluginName string, message string) {
+ fmt.Println("[ WARN ] " + pluginPrefix(pluginName) + message)
+ },
+ LogFailure: func(pluginName string, message string) {
+ fmt.Println("[ FAIL ] " + pluginPrefix(pluginName) + message)
+ },
+ LogDebug: func(pluginName string, message string) {
+ fmt.Println("[ NOTE ] " + pluginPrefix(pluginName) + message)
+ },
}
diff --git a/packages/node/node.go b/packages/node/node.go
index e5ff4299b95d37fb09310d2c9d3e0f5343d03732..5811b8af675c87d4425dd38f72eabcddfb4e43ee 100644
--- a/packages/node/node.go
+++ b/packages/node/node.go
@@ -1,143 +1,144 @@
package node
import (
- "fmt"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "strings"
- "sync"
+ "fmt"
+ "strings"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
)
type Node struct {
- wg *sync.WaitGroup
- loggers []*Logger
- loadedPlugins []*Plugin
- logLevel int
+ wg *sync.WaitGroup
+ loggers []*Logger
+ loadedPlugins []*Plugin
+ logLevel int
}
var disabledPlugins = make(map[string]bool)
func Load(plugins ...*Plugin) *Node {
- for _, disabledPlugin := range strings.Fields(*DISABLE_PLUGINS.Value) {
- disabledPlugins[strings.ToLower(disabledPlugin)] = true
- }
-
- fmt.Println(" _____ _ _ ________ ______ ___ ___________ ")
- fmt.Println(" / ___| | | |_ _| \\/ || \\/ || ___| ___ \\")
- fmt.Println(" \\ `--.| |_| | | | | . . || . . || |__ | |_/ /")
- fmt.Println(" `--. \\ _ | | | | |\\/| || |\\/| || __|| / ")
- fmt.Println(" /\\__/ / | | |_| |_| | | || | | || |___| |\\ \\ ")
- fmt.Println(" \\____/\\_| |_/\\___/\\_| |_/\\_| |_/\\____/\\_| \\_| fullnode 1.0")
- fmt.Println()
-
- node := &Node{
- logLevel: *LOG_LEVEL.Value,
- loggers: make([]*Logger, 0),
- wg: &sync.WaitGroup{},
- loadedPlugins: make([]*Plugin, 0),
- }
-
- node.AddLogger(DEFAULT_LOGGER)
- node.Load(plugins...)
-
- return node
+ for _, disabledPlugin := range strings.Fields(*DISABLE_PLUGINS.Value) {
+ disabledPlugins[strings.ToLower(disabledPlugin)] = true
+ }
+
+ fmt.Println(" _____ _ _ ________ ______ ___ ___________ ")
+ fmt.Println(" / ___| | | |_ _| \\/ || \\/ || ___| ___ \\")
+ fmt.Println(" \\ `--.| |_| | | | | . . || . . || |__ | |_/ /")
+ fmt.Println(" `--. \\ _ | | | | |\\/| || |\\/| || __|| / ")
+ fmt.Println(" /\\__/ / | | |_| |_| | | || | | || |___| |\\ \\ ")
+ fmt.Println(" \\____/\\_| |_/\\___/\\_| |_/\\_| |_/\\____/\\_| \\_| fullnode 1.0")
+ fmt.Println()
+
+ node := &Node{
+ logLevel: *LOG_LEVEL.Value,
+ loggers: make([]*Logger, 0),
+ wg: &sync.WaitGroup{},
+ loadedPlugins: make([]*Plugin, 0),
+ }
+
+ node.AddLogger(DEFAULT_LOGGER)
+ node.Load(plugins...)
+
+ return node
}
func Run(plugins ...*Plugin) *Node {
- node := Load(plugins...)
- node.Run()
+ node := Load(plugins...)
+ node.Run()
- return node
+ return node
}
func (node *Node) AddLogger(logger *Logger) {
- node.loggers = append(node.loggers, logger)
+ node.loggers = append(node.loggers, logger)
}
func (node *Node) LogSuccess(pluginName string, message string) {
- if node.logLevel >= LOG_LEVEL_SUCCESS {
- for _, logger := range node.loggers {
- if logger.Enabled {
- logger.LogSuccess(pluginName, message)
- }
- }
- }
+ if node.logLevel >= LOG_LEVEL_SUCCESS {
+ for _, logger := range node.loggers {
+ if logger.Enabled {
+ logger.LogSuccess(pluginName, message)
+ }
+ }
+ }
}
func (node *Node) LogInfo(pluginName string, message string) {
- if node.logLevel >= LOG_LEVEL_INFO {
- for _, logger := range node.loggers {
- if logger.Enabled {
- logger.LogInfo(pluginName, message)
- }
- }
- }
+ if node.logLevel >= LOG_LEVEL_INFO {
+ for _, logger := range node.loggers {
+ if logger.Enabled {
+ logger.LogInfo(pluginName, message)
+ }
+ }
+ }
}
func (node *Node) LogDebug(pluginName string, message string) {
- if node.logLevel >= LOG_LEVEL_DEBUG {
- for _, logger := range node.loggers {
- if logger.Enabled {
- logger.LogDebug(pluginName, message)
- }
- }
- }
+ if node.logLevel >= LOG_LEVEL_DEBUG {
+ for _, logger := range node.loggers {
+ if logger.Enabled {
+ logger.LogDebug(pluginName, message)
+ }
+ }
+ }
}
func (node *Node) LogWarning(pluginName string, message string) {
- if node.logLevel >= LOG_LEVEL_WARNING {
- for _, logger := range node.loggers {
- if logger.Enabled {
- logger.LogWarning(pluginName, message)
- }
- }
- }
+ if node.logLevel >= LOG_LEVEL_WARNING {
+ for _, logger := range node.loggers {
+ if logger.Enabled {
+ logger.LogWarning(pluginName, message)
+ }
+ }
+ }
}
func (node *Node) LogFailure(pluginName string, message string) {
- if node.logLevel >= LOG_LEVEL_FAILURE {
- for _, logger := range node.loggers {
- if logger.Enabled {
- logger.LogFailure(pluginName, message)
- }
- }
- }
+ if node.logLevel >= LOG_LEVEL_FAILURE {
+ for _, logger := range node.loggers {
+ if logger.Enabled {
+ logger.LogFailure(pluginName, message)
+ }
+ }
+ }
}
func (node *Node) Load(plugins ...*Plugin) {
- node.LogInfo("Node", "Loading plugins ...")
+ node.LogInfo("Node", "Loading plugins ...")
- if len(plugins) >= 1 {
- for _, plugin := range plugins {
- if _, exists := disabledPlugins[strings.ToLower(strings.Replace(plugin.Name, " ", "", -1))]; !exists {
- plugin.wg = node.wg
- plugin.Node = node
+ if len(plugins) >= 1 {
+ for _, plugin := range plugins {
+ if _, exists := disabledPlugins[strings.ToLower(strings.Replace(plugin.Name, " ", "", -1))]; !exists {
+ plugin.wg = node.wg
+ plugin.Node = node
- plugin.Events.Configure.Trigger(plugin)
+ plugin.Events.Configure.Trigger(plugin)
- node.LogInfo("Node", "Loading Plugin: " + plugin.Name + " ... done")
+ node.LogInfo("Node", "Loading Plugin: "+plugin.Name+" ... done")
- node.loadedPlugins = append(node.loadedPlugins, plugin)
- }
- }
- }
+ node.loadedPlugins = append(node.loadedPlugins, plugin)
+ }
+ }
+ }
- //node.loadedPlugins = append(node.loadedPlugins, plugins...)
+ //node.loadedPlugins = append(node.loadedPlugins, plugins...)
}
func (node *Node) Run() {
- node.LogInfo("Node", "Executing plugins ...")
+ node.LogInfo("Node", "Executing plugins ...")
- if len(node.loadedPlugins) >= 1 {
- for _, plugin := range node.loadedPlugins {
- plugin.Events.Run.Trigger(plugin)
+ if len(node.loadedPlugins) >= 1 {
+ for _, plugin := range node.loadedPlugins {
+ plugin.Events.Run.Trigger(plugin)
- node.LogSuccess("Node", "Starting Plugin: "+plugin.Name+" ... done")
- }
- }
+ node.LogSuccess("Node", "Starting Plugin: "+plugin.Name+" ... done")
+ }
+ }
- node.LogSuccess("Node", "Starting background workers ...")
+ node.LogSuccess("Node", "Starting background workers ...")
- daemon.Run()
+ daemon.Run()
- node.LogSuccess("Node", "Shutdown complete!")
+ node.LogSuccess("Node", "Shutdown complete!")
}
diff --git a/packages/node/parameters.go b/packages/node/parameters.go
index 23d890d9b3b91a20b3fe45d2ffcabfe0a873757e..d94f31e901131a2f4bb3ddd7a6202ee691467244 100644
--- a/packages/node/parameters.go
+++ b/packages/node/parameters.go
@@ -3,6 +3,6 @@ package node
import "github.com/iotaledger/goshimmer/packages/parameter"
var (
- LOG_LEVEL = parameter.AddInt("NODE/LOG_LEVEL", LOG_LEVEL_INFO, "controls the log types that are shown")
- DISABLE_PLUGINS = parameter.AddString("NODE/DISABLE_PLUGINS", "", "a list of plugins that shall be disabled")
+ LOG_LEVEL = parameter.AddInt("NODE/LOG_LEVEL", LOG_LEVEL_INFO, "controls the log types that are shown")
+ DISABLE_PLUGINS = parameter.AddString("NODE/DISABLE_PLUGINS", "", "a list of plugins that shall be disabled")
)
diff --git a/packages/node/plugin.go b/packages/node/plugin.go
index a723d517b81a0e512d55755fafc09476a9c9138a..a98a22beff880d7b73b210c14e38f0f6730a1ce1 100644
--- a/packages/node/plugin.go
+++ b/packages/node/plugin.go
@@ -1,56 +1,57 @@
package node
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "sync"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/events"
)
type Plugin struct {
- Node *Node
- Name string
- Events pluginEvents
- wg *sync.WaitGroup
+ Node *Node
+ Name string
+ Events pluginEvents
+ wg *sync.WaitGroup
}
func NewPlugin(name string, callback Callback, callbacks ...Callback) *Plugin {
- plugin := &Plugin{
- Name: name,
- Events: pluginEvents{
- Configure: events.NewEvent(pluginCaller),
- Run: events.NewEvent(pluginCaller),
- },
- }
-
- if len(callbacks) >= 1 {
- plugin.Events.Configure.Attach(events.NewClosure(callback))
- for _, callback = range callbacks[:len(callbacks)-1] {
- plugin.Events.Configure.Attach(events.NewClosure(callback))
- }
-
- plugin.Events.Run.Attach(events.NewClosure(callbacks[len(callbacks)-1]))
- } else {
- plugin.Events.Run.Attach(events.NewClosure(callback))
- }
-
- return plugin
+ plugin := &Plugin{
+ Name: name,
+ Events: pluginEvents{
+ Configure: events.NewEvent(pluginCaller),
+ Run: events.NewEvent(pluginCaller),
+ },
+ }
+
+ if len(callbacks) >= 1 {
+ plugin.Events.Configure.Attach(events.NewClosure(callback))
+ for _, callback = range callbacks[:len(callbacks)-1] {
+ plugin.Events.Configure.Attach(events.NewClosure(callback))
+ }
+
+ plugin.Events.Run.Attach(events.NewClosure(callbacks[len(callbacks)-1]))
+ } else {
+ plugin.Events.Run.Attach(events.NewClosure(callback))
+ }
+
+ return plugin
}
func (plugin *Plugin) LogSuccess(message string) {
- plugin.Node.LogSuccess(plugin.Name, message)
+ plugin.Node.LogSuccess(plugin.Name, message)
}
func (plugin *Plugin) LogInfo(message string) {
- plugin.Node.LogInfo(plugin.Name, message)
+ plugin.Node.LogInfo(plugin.Name, message)
}
func (plugin *Plugin) LogWarning(message string) {
- plugin.Node.LogWarning(plugin.Name, message)
+ plugin.Node.LogWarning(plugin.Name, message)
}
func (plugin *Plugin) LogFailure(message string) {
- plugin.Node.LogFailure(plugin.Name, message)
+ plugin.Node.LogFailure(plugin.Name, message)
}
func (plugin *Plugin) LogDebug(message string) {
- plugin.Node.LogDebug(plugin.Name, message)
+ plugin.Node.LogDebug(plugin.Name, message)
}
diff --git a/packages/parameter/events.go b/packages/parameter/events.go
index 8a23da1cbbc3c1bb7665f6fa8a755cb4a211188a..7de04ada3a8e2d4785de26e99dd1cc8f4b5d21f7 100644
--- a/packages/parameter/events.go
+++ b/packages/parameter/events.go
@@ -1,16 +1,20 @@
package parameter
import (
- "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/events"
)
var Events = struct {
- AddInt *events.Event
- AddString *events.Event
+ AddInt *events.Event
+ AddString *events.Event
}{
- events.NewEvent(intParameterCaller),
- events.NewEvent(stringParameterCaller),
+ events.NewEvent(intParameterCaller),
+ events.NewEvent(stringParameterCaller),
}
-func intParameterCaller(handler interface{}, params ...interface{}) { handler.(func(*IntParameter))(params[0].(*IntParameter)) }
-func stringParameterCaller(handler interface{}, params ...interface{}) { handler.(func(*StringParameter))(params[0].(*StringParameter)) }
+func intParameterCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*IntParameter))(params[0].(*IntParameter))
+}
+func stringParameterCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*StringParameter))(params[0].(*StringParameter))
+}
diff --git a/packages/parameter/parameter.go b/packages/parameter/parameter.go
index 2de309abcc39bd8f41a8c3ab250062c48cb762bf..8588e73a427783c5feb8bf58dfaa732d21591a3f 100644
--- a/packages/parameter/parameter.go
+++ b/packages/parameter/parameter.go
@@ -3,57 +3,57 @@ package parameter
var intParameters = make(map[string]*IntParameter)
func AddInt(name string, defaultValue int, description string) *IntParameter {
- if intParameters[name] != nil {
- panic("duplicate parameter - \"" + name + "\" was defined already")
- }
+ if intParameters[name] != nil {
+ panic("duplicate parameter - \"" + name + "\" was defined already")
+ }
- newParameter := &IntParameter{
- Name: name,
- DefaultValue: defaultValue,
- Value: &defaultValue,
- Description: description,
- }
+ newParameter := &IntParameter{
+ Name: name,
+ DefaultValue: defaultValue,
+ Value: &defaultValue,
+ Description: description,
+ }
- intParameters[name] = newParameter
+ intParameters[name] = newParameter
- Events.AddInt.Trigger(newParameter)
+ Events.AddInt.Trigger(newParameter)
- return newParameter
+ return newParameter
}
func GetInt(name string) *IntParameter {
- return intParameters[name]
+ return intParameters[name]
}
func GetInts() map[string]*IntParameter {
- return intParameters
+ return intParameters
}
-var stringParameters = make(map[string]*StringParameter)
+var stringParameters = make(map[string]*StringParameter)
func AddString(name string, defaultValue string, description string) *StringParameter {
- if intParameters[name] != nil {
- panic("duplicate parameter - \"" + name + "\" was defined already")
- }
+ if intParameters[name] != nil {
+ panic("duplicate parameter - \"" + name + "\" was defined already")
+ }
- newParameter := &StringParameter{
- Name: name,
- DefaultValue: defaultValue,
- Value: &defaultValue,
- Description: description,
- }
+ newParameter := &StringParameter{
+ Name: name,
+ DefaultValue: defaultValue,
+ Value: &defaultValue,
+ Description: description,
+ }
- stringParameters[name] = newParameter
+ stringParameters[name] = newParameter
- Events.AddString.Trigger(newParameter)
+ Events.AddString.Trigger(newParameter)
- return stringParameters[name]
+ return stringParameters[name]
}
func GetString(name string) *StringParameter {
- return stringParameters[name]
+ return stringParameters[name]
}
func GetStrings() map[string]*StringParameter {
- return stringParameters
+ return stringParameters
}
diff --git a/packages/parameter/types.go b/packages/parameter/types.go
index 3c5f3c62d835ea3060a483a1275d89a89f993cd9..8a044680b8703fc1f1b8b19b5a58152d4dbcd4e7 100644
--- a/packages/parameter/types.go
+++ b/packages/parameter/types.go
@@ -1,17 +1,17 @@
package parameter
type IntParameter struct {
- Name string
- Value *int
- DefaultValue int
- Description string
+ Name string
+ Value *int
+ DefaultValue int
+ Description string
}
type StringParameter struct {
- Name string
- Value *string
- DefaultValue string
- Description string
+ Name string
+ Value *string
+ DefaultValue string
+ Description string
}
type IntParameterConsumer = func(param *IntParameter)
diff --git a/packages/settings/settings.go b/packages/settings/settings.go
index b23c7dfa1e7858dd6fe463386b371f8b12fb8800..df0ad335fab42ad718807dafe59a5693c9c9fea3 100644
--- a/packages/settings/settings.go
+++ b/packages/settings/settings.go
@@ -1,8 +1,9 @@
package settings
import (
- "github.com/iotaledger/goshimmer/packages/database"
"sync"
+
+ "github.com/iotaledger/goshimmer/packages/database"
)
var settingsDatabase database.Database
diff --git a/packages/ternary/bc_ternary.go b/packages/ternary/bc_ternary.go
index 75843830bdda5e6a4616357b3239d8b0b129fc21..d18258c03e4b290d66646f118400be8ff8d03f10 100644
--- a/packages/ternary/bc_ternary.go
+++ b/packages/ternary/bc_ternary.go
@@ -2,12 +2,12 @@ package ternary
// a Binary Coded Trit encodes a Trit in 2 bits with -1 => 00, 0 => 01 and 1 => 10
type BCTrit struct {
- Lo uint
- Hi uint
+ Lo uint
+ Hi uint
}
// a Binary Coded Trinary consists out of many Binary Coded Trits
type BCTrinary struct {
- Lo []uint
- Hi []uint
+ Lo []uint
+ Hi []uint
}
diff --git a/packages/ternary/bc_ternary_demultiplexer.go b/packages/ternary/bc_ternary_demultiplexer.go
index 02221f6eefa1575e87d03a2afb4d82b3dfc8cc23..6030f7a29958db990bc0bc098b3c2cd88a4bef5d 100644
--- a/packages/ternary/bc_ternary_demultiplexer.go
+++ b/packages/ternary/bc_ternary_demultiplexer.go
@@ -1,37 +1,37 @@
package ternary
type BCTernaryDemultiplexer struct {
- bcTrinary BCTrinary
+ bcTrinary BCTrinary
}
func NewBCTernaryDemultiplexer(bcTrinary BCTrinary) *BCTernaryDemultiplexer {
- this := &BCTernaryDemultiplexer{bcTrinary: bcTrinary}
+ this := &BCTernaryDemultiplexer{bcTrinary: bcTrinary}
- return this
+ return this
}
func (this *BCTernaryDemultiplexer) Get(index int) Trits {
- length := len(this.bcTrinary.Lo)
- result := make(Trits, length)
+ length := len(this.bcTrinary.Lo)
+ result := make(Trits, length)
- for i := 0; i < length; i++ {
- low := (this.bcTrinary.Lo[i] >> uint(index)) & 1
- hi := (this.bcTrinary.Hi[i] >> uint(index)) & 1
+ for i := 0; i < length; i++ {
+ low := (this.bcTrinary.Lo[i] >> uint(index)) & 1
+ hi := (this.bcTrinary.Hi[i] >> uint(index)) & 1
- switch true {
- case low == 1 && hi == 0:
- result[i] = -1
+ switch true {
+ case low == 1 && hi == 0:
+ result[i] = -1
- case low == 0 && hi == 1:
- result[i] = 1
+ case low == 0 && hi == 1:
+ result[i] = 1
- case low == 1 && hi == 1:
- result[i] = 0
+ case low == 1 && hi == 1:
+ result[i] = 0
- default:
- result[i] = 0
- }
- }
+ default:
+ result[i] = 0
+ }
+ }
- return result
+ return result
}
diff --git a/packages/ternary/bc_ternary_multiplexer.go b/packages/ternary/bc_ternary_multiplexer.go
index 93a0eb57e5e83b644a3a4b740180ad59c704ae42..d84e5a782e5a74b10f315fd6b71895beef64d280 100644
--- a/packages/ternary/bc_ternary_multiplexer.go
+++ b/packages/ternary/bc_ternary_multiplexer.go
@@ -1,62 +1,62 @@
package ternary
import (
- "errors"
- "strconv"
+ "errors"
+ "strconv"
)
type BCTernaryMultiplexer struct {
- trinaries []Trits
+ trinaries []Trits
}
func NewBCTernaryMultiplexer() *BCTernaryMultiplexer {
- this := &BCTernaryMultiplexer{make([]Trits, 0)}
+ this := &BCTernaryMultiplexer{make([]Trits, 0)}
- return this
+ return this
}
func (this *BCTernaryMultiplexer) Add(trinary Trits) int {
- this.trinaries = append(this.trinaries, trinary)
+ this.trinaries = append(this.trinaries, trinary)
- return len(this.trinaries) - 1
+ return len(this.trinaries) - 1
}
func (this *BCTernaryMultiplexer) Get(index int) Trits {
- return this.trinaries[index]
+ return this.trinaries[index]
}
func (this *BCTernaryMultiplexer) Extract() (BCTrinary, error) {
- trinariesCount := len(this.trinaries)
- tritsCount := len(this.trinaries[0])
+ trinariesCount := len(this.trinaries)
+ tritsCount := len(this.trinaries[0])
- result := BCTrinary{
- Lo: make([]uint, tritsCount),
- Hi: make([]uint, tritsCount),
- }
+ result := BCTrinary{
+ Lo: make([]uint, tritsCount),
+ Hi: make([]uint, tritsCount),
+ }
- for i := 0; i < tritsCount; i++ {
- bcTrit := &BCTrit{0, 0}
+ for i := 0; i < tritsCount; i++ {
+ bcTrit := &BCTrit{0, 0}
- for j := 0; j < trinariesCount; j++ {
- switch this.trinaries[j][i] {
- case -1:
- bcTrit.Lo |= 1 << uint(j)
+ for j := 0; j < trinariesCount; j++ {
+ switch this.trinaries[j][i] {
+ case -1:
+ bcTrit.Lo |= 1 << uint(j)
- case 1:
- bcTrit.Hi |= 1 << uint(j)
+ case 1:
+ bcTrit.Hi |= 1 << uint(j)
- case 0:
- bcTrit.Lo |= 1 << uint(j)
- bcTrit.Hi |= 1 << uint(j)
+ case 0:
+ bcTrit.Lo |= 1 << uint(j)
+ bcTrit.Hi |= 1 << uint(j)
- default:
- return result, errors.New("Invalid trit #" + strconv.Itoa(i) + " in trinary #" + strconv.Itoa(j))
- }
- }
+ default:
+ return result, errors.New("Invalid trit #" + strconv.Itoa(i) + " in trinary #" + strconv.Itoa(j))
+ }
+ }
- result.Lo[i] = bcTrit.Lo
- result.Hi[i] = bcTrit.Hi
- }
+ result.Lo[i] = bcTrit.Lo
+ result.Hi[i] = bcTrit.Hi
+ }
- return result, nil
+ return result, nil
}
diff --git a/packages/ternary/conversion.go b/packages/ternary/conversion.go
index 05d7b358d5234b6fbdea06e82df244b1419967f6..afb96cf790d4f97d15a465aac25df8cfc03f804a 100644
--- a/packages/ternary/conversion.go
+++ b/packages/ternary/conversion.go
@@ -3,124 +3,123 @@ package ternary
import "bytes"
const (
- NUMBER_OF_TRITS_IN_A_BYTE = 5
- NUMBER_OF_TRITS_IN_A_TRYTE = 3
+ NUMBER_OF_TRITS_IN_A_BYTE = 5
+ NUMBER_OF_TRITS_IN_A_TRYTE = 3
)
var (
- TRYTES_TO_TRITS_MAP = map[rune][]int8{
- '9': Trits{0, 0, 0},
- 'A': Trits{1, 0, 0},
- 'B': Trits{-1, 1, 0},
- 'C': Trits{0, 1, 0},
- 'D': Trits{1, 1, 0},
- 'E': Trits{-1, -1, 1},
- 'F': Trits{0, -1, 1},
- 'G': Trits{1, -1, 1},
- 'H': Trits{-1, 0, 1},
- 'I': Trits{0, 0, 1},
- 'J': Trits{1, 0, 1},
- 'K': Trits{-1, 1, 1},
- 'L': Trits{0, 1, 1},
- 'M': Trits{1, 1, 1},
- 'N': Trits{-1, -1, -1},
- 'O': Trits{0, -1, -1},
- 'P': Trits{1, -1, -1},
- 'Q': Trits{-1, 0, -1},
- 'R': Trits{0, 0, -1},
- 'S': Trits{1, 0, -1},
- 'T': Trits{-1, 1, -1},
- 'U': Trits{0, 1, -1},
- 'V': Trits{1, 1, -1},
- 'W': Trits{-1, -1, 0},
- 'X': Trits{0, -1, 0},
- 'Y': Trits{1, -1, 0},
- 'Z': Trits{-1, 0, 0},
- }
+ TRYTES_TO_TRITS_MAP = map[rune][]int8{
+ '9': Trits{0, 0, 0},
+ 'A': Trits{1, 0, 0},
+ 'B': Trits{-1, 1, 0},
+ 'C': Trits{0, 1, 0},
+ 'D': Trits{1, 1, 0},
+ 'E': Trits{-1, -1, 1},
+ 'F': Trits{0, -1, 1},
+ 'G': Trits{1, -1, 1},
+ 'H': Trits{-1, 0, 1},
+ 'I': Trits{0, 0, 1},
+ 'J': Trits{1, 0, 1},
+ 'K': Trits{-1, 1, 1},
+ 'L': Trits{0, 1, 1},
+ 'M': Trits{1, 1, 1},
+ 'N': Trits{-1, -1, -1},
+ 'O': Trits{0, -1, -1},
+ 'P': Trits{1, -1, -1},
+ 'Q': Trits{-1, 0, -1},
+ 'R': Trits{0, 0, -1},
+ 'S': Trits{1, 0, -1},
+ 'T': Trits{-1, 1, -1},
+ 'U': Trits{0, 1, -1},
+ 'V': Trits{1, 1, -1},
+ 'W': Trits{-1, -1, 0},
+ 'X': Trits{0, -1, 0},
+ 'Y': Trits{1, -1, 0},
+ 'Z': Trits{-1, 0, 0},
+ }
+ TRYTE_ALPHABET = []string{
+ "9", "A", "B", "C", "D", "E", "F", "G", "H",
+ "I", "J", "K", "L", "M", "N", "O", "P", "Q",
+ "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+ }
- TRYTE_ALPHABET = []string{
- "9", "A", "B","C", "D", "E", "F", "G", "H",
- "I", "J", "K", "L", "M", "N", "O", "P", "Q",
- "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
- }
-
- BYTES_TO_TRITS = []Trit {
- 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, -1, -1,
- 1, 0, 0, 0, -1, 1, 0, 0, 1, -1, 1, 0, 0, -1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0,
- 0, -1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, -1, -1, -1, 1, 0, 0, -1, -1, 1, 0, 1,
- -1, -1, 1, 0, -1, 0, -1, 1, 0, 0, 0, -1, 1, 0, 1, 0, -1, 1, 0, -1, 1, -1, 1, 0, 0, 1, -1,
- 1, 0, 1, 1, -1, 1, 0, -1, -1, 0, 1, 0, 0, -1, 0, 1, 0, 1, -1, 0, 1, 0, -1, 0, 0, 1, 0,
- 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, -1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, -1, -1,
- 1, 1, 0, 0, -1, 1, 1, 0, 1, -1, 1, 1, 0, -1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1,
- 0, -1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, -1, -1, -1, -1, 1, 0, -1, -1, -1, 1, 1,
- -1, -1, -1, 1, -1, 0, -1, -1, 1, 0, 0, -1, -1, 1, 1, 0, -1, -1, 1, -1, 1, -1, -1, 1, 0, 1, -1,
- -1, 1, 1, 1, -1, -1, 1, -1, -1, 0, -1, 1, 0, -1, 0, -1, 1, 1, -1, 0, -1, 1, -1, 0, 0, -1, 1,
- 0, 0, 0, -1, 1, 1, 0, 0, -1, 1, -1, 1, 0, -1, 1, 0, 1, 0, -1, 1, 1, 1, 0, -1, 1, -1, -1,
- 1, -1, 1, 0, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 0, 1, -1, 1, 0, 0, 1, -1, 1, 1, 0, 1, -1,
- 1, -1, 1, 1, -1, 1, 0, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 0, 1, 0, -1, -1, 0, 1, 1,
- -1, -1, 0, 1, -1, 0, -1, 0, 1, 0, 0, -1, 0, 1, 1, 0, -1, 0, 1, -1, 1, -1, 0, 1, 0, 1, -1,
- 0, 1, 1, 1, -1, 0, 1, -1, -1, 0, 0, 1, 0, -1, 0, 0, 1, 1, -1, 0, 0, 1, -1, 0, 0, 0, 1,
- 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, -1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, -1, -1,
- 1, 0, 1, 0, -1, 1, 0, 1, 1, -1, 1, 0, 1, -1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0,
- 1, -1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, -1, -1, -1, 1, 1, 0, -1, -1, 1, 1, 1,
- -1, -1, 1, 1, -1, 0, -1, 1, 1, 0, 0, -1, 1, 1, 1, 0, -1, 1, 1, -1, 1, -1, 1, 1, 0, 1, -1,
- 1, 1, 1, 1, -1, 1, 1, -1, -1, 0, 1, 1, 0, -1, 0, 1, 1, 1, -1, 0, 1, 1, -1, 0, 0, 1, 1,
- 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, -1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, -1, -1,
- 1, 1, 1, 0, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1,
- 1, -1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, 1,
- -1, -1, -1, -1, -1, 0, -1, -1, -1, 0, 0, -1, -1, -1, 1, 0, -1, -1, -1, -1, 1, -1, -1, -1, 0, 1, -1,
- -1, -1, 1, 1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, 0, -1, -1, 1, -1, 0, -1, -1, -1, 0, 0, -1, -1,
- 0, 0, 0, -1, -1, 1, 0, 0, -1, -1, -1, 1, 0, -1, -1, 0, 1, 0, -1, -1, 1, 1, 0, -1, -1, -1, -1,
- 1, -1, -1, 0, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 0, 1, -1, -1, 0, 0, 1, -1, -1, 1, 0, 1, -1,
- -1, -1, 1, 1, -1, -1, 0, 1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 0, -1, 0, -1, -1, 0, -1, 1,
- -1, -1, 0, -1, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 1, 0, -1, 0, -1, -1, 1, -1, 0, -1, 0, 1, -1,
- 0, -1, 1, 1, -1, 0, -1, -1, -1, 0, 0, -1, 0, -1, 0, 0, -1, 1, -1, 0, 0, -1, -1, 0, 0, 0, -1,
- 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, -1, 1, 0, 0, -1, 0, 1, 0, 0, -1, 1, 1, 0, 0, -1, -1, -1,
- 1, 0, -1, 0, -1, 1, 0, -1, 1, -1, 1, 0, -1, -1, 0, 1, 0, -1, 0, 0, 1, 0, -1, 1, 0, 1, 0,
- -1, -1, 1, 1, 0, -1, 0, 1, 1, 0, -1, 1, 1, 1, 0, -1, -1, -1, -1, 1, -1, 0, -1, -1, 1, -1, 1,
- -1, -1, 1, -1, -1, 0, -1, 1, -1, 0, 0, -1, 1, -1, 1, 0, -1, 1, -1, -1, 1, -1, 1, -1, 0, 1, -1,
- 1, -1, 1, 1, -1, 1, -1, -1, -1, 0, 1, -1, 0, -1, 0, 1, -1, 1, -1, 0, 1, -1, -1, 0, 0, 1, -1,
- 0, 0, 0, 1, -1, 1, 0, 0, 1, -1, -1, 1, 0, 1, -1, 0, 1, 0, 1, -1, 1, 1, 0, 1, -1, -1, -1,
- 1, 1, -1, 0, -1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 0, 1, 1, -1, 0, 0, 1, 1, -1, 1, 0, 1, 1,
- -1, -1, 1, 1, 1, -1, 0, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 0, 0, -1, -1, -1, 0, 1,
- -1, -1, -1, 0, -1, 0, -1, -1, 0, 0, 0, -1, -1, 0, 1, 0, -1, -1, 0, -1, 1, -1, -1, 0, 0, 1, -1,
- -1, 0, 1, 1, -1, -1, 0, -1, -1, 0, -1, 0, 0, -1, 0, -1, 0, 1, -1, 0, -1, 0, -1, 0, 0, -1, 0,
- 0, 0, 0, -1, 0, 1, 0, 0, -1, 0, -1, 1, 0, -1, 0, 0, 1, 0, -1, 0, 1, 1, 0, -1, 0, -1, -1,
- 1, -1, 0, 0, -1, 1, -1, 0, 1, -1, 1, -1, 0, -1, 0, 1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, -1,
- 0, -1, 1, 1, -1, 0, 0, 1, 1, -1, 0, 1, 1, 1, -1, 0, -1, -1, -1, 0, 0, 0, -1, -1, 0, 0, 1,
- -1, -1, 0, 0, -1, 0, -1, 0, 0, 0, 0, -1, 0, 0, 1, 0, -1, 0, 0, -1, 1, -1, 0, 0, 0, 1, -1,
- 0, 0, 1, 1, -1, 0, 0, -1, -1, 0, 0, 0, 0, -1, 0, 0, 0, 1, -1, 0, 0, 0, -1, 0, 0, 0, 0,
- }
+ BYTES_TO_TRITS = []Trit{
+ 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, -1, -1,
+ 1, 0, 0, 0, -1, 1, 0, 0, 1, -1, 1, 0, 0, -1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0,
+ 0, -1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, -1, -1, -1, 1, 0, 0, -1, -1, 1, 0, 1,
+ -1, -1, 1, 0, -1, 0, -1, 1, 0, 0, 0, -1, 1, 0, 1, 0, -1, 1, 0, -1, 1, -1, 1, 0, 0, 1, -1,
+ 1, 0, 1, 1, -1, 1, 0, -1, -1, 0, 1, 0, 0, -1, 0, 1, 0, 1, -1, 0, 1, 0, -1, 0, 0, 1, 0,
+ 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, -1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, -1, -1,
+ 1, 1, 0, 0, -1, 1, 1, 0, 1, -1, 1, 1, 0, -1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1,
+ 0, -1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, -1, -1, -1, -1, 1, 0, -1, -1, -1, 1, 1,
+ -1, -1, -1, 1, -1, 0, -1, -1, 1, 0, 0, -1, -1, 1, 1, 0, -1, -1, 1, -1, 1, -1, -1, 1, 0, 1, -1,
+ -1, 1, 1, 1, -1, -1, 1, -1, -1, 0, -1, 1, 0, -1, 0, -1, 1, 1, -1, 0, -1, 1, -1, 0, 0, -1, 1,
+ 0, 0, 0, -1, 1, 1, 0, 0, -1, 1, -1, 1, 0, -1, 1, 0, 1, 0, -1, 1, 1, 1, 0, -1, 1, -1, -1,
+ 1, -1, 1, 0, -1, 1, -1, 1, 1, -1, 1, -1, 1, -1, 0, 1, -1, 1, 0, 0, 1, -1, 1, 1, 0, 1, -1,
+ 1, -1, 1, 1, -1, 1, 0, 1, 1, -1, 1, 1, 1, 1, -1, 1, -1, -1, -1, 0, 1, 0, -1, -1, 0, 1, 1,
+ -1, -1, 0, 1, -1, 0, -1, 0, 1, 0, 0, -1, 0, 1, 1, 0, -1, 0, 1, -1, 1, -1, 0, 1, 0, 1, -1,
+ 0, 1, 1, 1, -1, 0, 1, -1, -1, 0, 0, 1, 0, -1, 0, 0, 1, 1, -1, 0, 0, 1, -1, 0, 0, 0, 1,
+ 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, -1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, -1, -1,
+ 1, 0, 1, 0, -1, 1, 0, 1, 1, -1, 1, 0, 1, -1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0,
+ 1, -1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, -1, -1, -1, 1, 1, 0, -1, -1, 1, 1, 1,
+ -1, -1, 1, 1, -1, 0, -1, 1, 1, 0, 0, -1, 1, 1, 1, 0, -1, 1, 1, -1, 1, -1, 1, 1, 0, 1, -1,
+ 1, 1, 1, 1, -1, 1, 1, -1, -1, 0, 1, 1, 0, -1, 0, 1, 1, 1, -1, 0, 1, 1, -1, 0, 0, 1, 1,
+ 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, -1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, -1, -1,
+ 1, 1, 1, 0, -1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1,
+ 1, -1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, 1,
+ -1, -1, -1, -1, -1, 0, -1, -1, -1, 0, 0, -1, -1, -1, 1, 0, -1, -1, -1, -1, 1, -1, -1, -1, 0, 1, -1,
+ -1, -1, 1, 1, -1, -1, -1, -1, -1, 0, -1, -1, 0, -1, 0, -1, -1, 1, -1, 0, -1, -1, -1, 0, 0, -1, -1,
+ 0, 0, 0, -1, -1, 1, 0, 0, -1, -1, -1, 1, 0, -1, -1, 0, 1, 0, -1, -1, 1, 1, 0, -1, -1, -1, -1,
+ 1, -1, -1, 0, -1, 1, -1, -1, 1, -1, 1, -1, -1, -1, 0, 1, -1, -1, 0, 0, 1, -1, -1, 1, 0, 1, -1,
+ -1, -1, 1, 1, -1, -1, 0, 1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 0, -1, 0, -1, -1, 0, -1, 1,
+ -1, -1, 0, -1, -1, 0, -1, 0, -1, 0, 0, -1, 0, -1, 1, 0, -1, 0, -1, -1, 1, -1, 0, -1, 0, 1, -1,
+ 0, -1, 1, 1, -1, 0, -1, -1, -1, 0, 0, -1, 0, -1, 0, 0, -1, 1, -1, 0, 0, -1, -1, 0, 0, 0, -1,
+ 0, 0, 0, 0, -1, 1, 0, 0, 0, -1, -1, 1, 0, 0, -1, 0, 1, 0, 0, -1, 1, 1, 0, 0, -1, -1, -1,
+ 1, 0, -1, 0, -1, 1, 0, -1, 1, -1, 1, 0, -1, -1, 0, 1, 0, -1, 0, 0, 1, 0, -1, 1, 0, 1, 0,
+ -1, -1, 1, 1, 0, -1, 0, 1, 1, 0, -1, 1, 1, 1, 0, -1, -1, -1, -1, 1, -1, 0, -1, -1, 1, -1, 1,
+ -1, -1, 1, -1, -1, 0, -1, 1, -1, 0, 0, -1, 1, -1, 1, 0, -1, 1, -1, -1, 1, -1, 1, -1, 0, 1, -1,
+ 1, -1, 1, 1, -1, 1, -1, -1, -1, 0, 1, -1, 0, -1, 0, 1, -1, 1, -1, 0, 1, -1, -1, 0, 0, 1, -1,
+ 0, 0, 0, 1, -1, 1, 0, 0, 1, -1, -1, 1, 0, 1, -1, 0, 1, 0, 1, -1, 1, 1, 0, 1, -1, -1, -1,
+ 1, 1, -1, 0, -1, 1, 1, -1, 1, -1, 1, 1, -1, -1, 0, 1, 1, -1, 0, 0, 1, 1, -1, 1, 0, 1, 1,
+ -1, -1, 1, 1, 1, -1, 0, 1, 1, 1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 0, 0, -1, -1, -1, 0, 1,
+ -1, -1, -1, 0, -1, 0, -1, -1, 0, 0, 0, -1, -1, 0, 1, 0, -1, -1, 0, -1, 1, -1, -1, 0, 0, 1, -1,
+ -1, 0, 1, 1, -1, -1, 0, -1, -1, 0, -1, 0, 0, -1, 0, -1, 0, 1, -1, 0, -1, 0, -1, 0, 0, -1, 0,
+ 0, 0, 0, -1, 0, 1, 0, 0, -1, 0, -1, 1, 0, -1, 0, 0, 1, 0, -1, 0, 1, 1, 0, -1, 0, -1, -1,
+ 1, -1, 0, 0, -1, 1, -1, 0, 1, -1, 1, -1, 0, -1, 0, 1, -1, 0, 0, 0, 1, -1, 0, 1, 0, 1, -1,
+ 0, -1, 1, 1, -1, 0, 0, 1, 1, -1, 0, 1, 1, 1, -1, 0, -1, -1, -1, 0, 0, 0, -1, -1, 0, 0, 1,
+ -1, -1, 0, 0, -1, 0, -1, 0, 0, 0, 0, -1, 0, 0, 1, 0, -1, 0, 0, -1, 1, -1, 0, 0, 0, 1, -1,
+ 0, 0, 1, 1, -1, 0, 0, -1, -1, 0, 0, 0, 0, -1, 0, 0, 0, 1, -1, 0, 0, 0, -1, 0, 0, 0, 0,
+ }
)
func BytesToTrits(bytes []byte) Trits {
- size := len(bytes)
- trits := make([]Trit, size*NUMBER_OF_TRITS_IN_A_BYTE)
+ size := len(bytes)
+ trits := make([]Trit, size*NUMBER_OF_TRITS_IN_A_BYTE)
- for i := 0; i < size; i++ {
- v := int(bytes[i])
- if int8(bytes[i]) < 0 {
- v -= 13
- }
+ for i := 0; i < size; i++ {
+ v := int(bytes[i])
+ if int8(bytes[i]) < 0 {
+ v -= 13
+ }
- for j := 0; j < NUMBER_OF_TRITS_IN_A_BYTE; j++ {
- trits[i*NUMBER_OF_TRITS_IN_A_BYTE+j] = BYTES_TO_TRITS[v*NUMBER_OF_TRITS_IN_A_BYTE+j]
- }
- }
+ for j := 0; j < NUMBER_OF_TRITS_IN_A_BYTE; j++ {
+ trits[i*NUMBER_OF_TRITS_IN_A_BYTE+j] = BYTES_TO_TRITS[v*NUMBER_OF_TRITS_IN_A_BYTE+j]
+ }
+ }
- return trits
+ return trits
}
func TritsToString(trits Trits, offset int, size int) string {
- var buffer bytes.Buffer
- for i := 0; i < (size + NUMBER_OF_TRITS_IN_A_TRYTE - 1) / NUMBER_OF_TRITS_IN_A_TRYTE; i++ {
- j := int(trits[offset + i * NUMBER_OF_TRITS_IN_A_TRYTE]) + int(trits[offset + i * NUMBER_OF_TRITS_IN_A_TRYTE + 1]) * NUMBER_OF_TRITS_IN_A_TRYTE + int(trits[offset + i * NUMBER_OF_TRITS_IN_A_TRYTE + 2]) * NUMBER_OF_TRITS_IN_A_TRYTE * NUMBER_OF_TRITS_IN_A_TRYTE;
- if j < 0 {
- j += len(TRYTE_ALPHABET)
- }
- buffer.WriteString(TRYTE_ALPHABET[j]);
- }
+ var buffer bytes.Buffer
+ for i := 0; i < (size+NUMBER_OF_TRITS_IN_A_TRYTE-1)/NUMBER_OF_TRITS_IN_A_TRYTE; i++ {
+ j := int(trits[offset+i*NUMBER_OF_TRITS_IN_A_TRYTE]) + int(trits[offset+i*NUMBER_OF_TRITS_IN_A_TRYTE+1])*NUMBER_OF_TRITS_IN_A_TRYTE + int(trits[offset+i*NUMBER_OF_TRITS_IN_A_TRYTE+2])*NUMBER_OF_TRITS_IN_A_TRYTE*NUMBER_OF_TRITS_IN_A_TRYTE
+ if j < 0 {
+ j += len(TRYTE_ALPHABET)
+ }
+ buffer.WriteString(TRYTE_ALPHABET[j])
+ }
- return buffer.String()
-}
\ No newline at end of file
+ return buffer.String()
+}
diff --git a/packages/ternary/ternary.go b/packages/ternary/ternary.go
index a94517fc829a3b62fe158467e97439a300a758bd..3b8fa42607afa6f77268b52050db0d3eaec06ab4 100644
--- a/packages/ternary/ternary.go
+++ b/packages/ternary/ternary.go
@@ -1,8 +1,8 @@
package ternary
import (
- "reflect"
- "unsafe"
+ "reflect"
+ "unsafe"
)
// a Trit can have the values 0, 1 and -1
@@ -16,79 +16,78 @@ type Trinary string
// simply changes the type of this Trinary to a byte array without copying any data
func (trinary Trinary) CastToBytes() []byte {
- hdr := (*reflect.StringHeader)(unsafe.Pointer(&trinary))
+ hdr := (*reflect.StringHeader)(unsafe.Pointer(&trinary))
- return *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{Data: hdr.Data, Len: hdr.Len, Cap: hdr.Len}))
+ return *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{Data: hdr.Data, Len: hdr.Len, Cap: hdr.Len}))
}
func (trinary Trinary) ToTrits() Trits {
- trits := make(Trits, len(trinary) * 3)
- for _, char := range trinary {
- trits = append(trits, TRYTES_TO_TRITS_MAP[char]...)
- }
+ trits := make(Trits, len(trinary)*3)
+ for _, char := range trinary {
+ trits = append(trits, TRYTES_TO_TRITS_MAP[char]...)
+ }
- return trits
+ return trits
}
-
func (this Trits) ToBytes() []byte {
- tritsLength := len(this)
- bytesLength := (tritsLength + NUMBER_OF_TRITS_IN_A_BYTE - 1) / NUMBER_OF_TRITS_IN_A_BYTE
+ tritsLength := len(this)
+ bytesLength := (tritsLength + NUMBER_OF_TRITS_IN_A_BYTE - 1) / NUMBER_OF_TRITS_IN_A_BYTE
- bytes := make([]byte, bytesLength)
- radix := int8(3)
+ bytes := make([]byte, bytesLength)
+ radix := int8(3)
- tritIdx := bytesLength * NUMBER_OF_TRITS_IN_A_BYTE
- for byteNum := bytesLength - 1; byteNum >= 0; byteNum-- {
- var value int8 = 0
+ tritIdx := bytesLength * NUMBER_OF_TRITS_IN_A_BYTE
+ for byteNum := bytesLength - 1; byteNum >= 0; byteNum-- {
+ var value int8 = 0
- for i := 0; i < NUMBER_OF_TRITS_IN_A_BYTE; i++ {
- tritIdx--
+ for i := 0; i < NUMBER_OF_TRITS_IN_A_BYTE; i++ {
+ tritIdx--
- if tritIdx < tritsLength {
- value = value * radix + this[tritIdx]
- }
- }
- bytes[byteNum] = byte(value)
- }
+ if tritIdx < tritsLength {
+ value = value*radix + this[tritIdx]
+ }
+ }
+ bytes[byteNum] = byte(value)
+ }
- return bytes
+ return bytes
}
func (this Trits) TrailingZeroes() int {
- zeros := 0
- index := len(this) - 1
- for this[index] == 0 {
- zeros++
+ zeros := 0
+ index := len(this) - 1
+ for this[index] == 0 {
+ zeros++
- index--
- }
+ index--
+ }
- return zeros
+ return zeros
}
func (this Trits) ToInt64() int64 {
- var val int64
- for i := len(this) - 1; i >= 0; i-- {
- val = val * 3 + int64(this[i])
- }
+ var val int64
+ for i := len(this) - 1; i >= 0; i-- {
+ val = val*3 + int64(this[i])
+ }
- return val
+ return val
}
func (this Trits) ToUint64() uint64 {
- var val uint64
- for i := len(this) - 1; i >= 0; i-- {
- val = val * 3 + uint64(this[i])
- }
+ var val uint64
+ for i := len(this) - 1; i >= 0; i-- {
+ val = val*3 + uint64(this[i])
+ }
- return val
+ return val
}
func (this Trits) ToString() string {
- return TritsToString(this, 0, len(this))
+ return TritsToString(this, 0, len(this))
}
func (this Trits) ToTrinary() Trinary {
- return Trinary(TritsToString(this, 0, len(this)))
+ return Trinary(TritsToString(this, 0, len(this)))
}
diff --git a/packages/timeutil/sleep.go b/packages/timeutil/sleep.go
index 68facd320d528cede103eb981fff18d206b9d154..0f2577f22f2d7be0974693ad11be15052094782b 100644
--- a/packages/timeutil/sleep.go
+++ b/packages/timeutil/sleep.go
@@ -1,16 +1,17 @@
package timeutil
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
)
func Sleep(interval time.Duration) bool {
- select {
- case <-daemon.ShutdownSignal:
- return false
+ select {
+ case <-daemon.ShutdownSignal:
+ return false
- case <-time.After(interval):
- return true
- }
-}
\ No newline at end of file
+ case <-time.After(interval):
+ return true
+ }
+}
diff --git a/packages/timeutil/ticker.go b/packages/timeutil/ticker.go
index 0a7536941bd43f252b7ddfdf283c8c43f77c1b84..eb076521b6ff79a9b63f4d8cafdb58b4e437c8b3 100644
--- a/packages/timeutil/ticker.go
+++ b/packages/timeutil/ticker.go
@@ -1,19 +1,20 @@
package timeutil
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
)
func Ticker(handler func(), interval time.Duration) {
- ticker := time.NewTicker(interval)
- ticker:
- for {
- select {
- case <- daemon.ShutdownSignal:
- break ticker
- case <- ticker.C:
- handler()
- }
- }
+ ticker := time.NewTicker(interval)
+ticker:
+ for {
+ select {
+ case <-daemon.ShutdownSignal:
+ break ticker
+ case <-ticker.C:
+ handler()
+ }
+ }
}
diff --git a/packages/transaction/constants.go b/packages/transaction/constants.go
index 594890c09a6ee1ded5b8e16409a7125adb305a9d..dd329015491c5beafd5d43b57b88760fca05dca1 100644
--- a/packages/transaction/constants.go
+++ b/packages/transaction/constants.go
@@ -1,45 +1,45 @@
package transaction
const (
- // sizes of the transaction fields
- SIGNATURE_MESSAGE_FRAGMENT_SIZE = 6561
- ADDRESS_SIZE = 243
- VALUE_SIZE = 81
- TIMESTAMP_SIZE = 27
- CURRENT_INDEX_SIZE = 27
- LATEST_INDEX_SIZE = 27
- BUNDLE_HASH_SIZE = 243
- TRUNK_TRANSACTION_HASH_SIZE = 243
- BRANCH_TRANSACTION_HASH_SIZE = 243
- TAG_SIZE = 81
- NONCE_SIZE = 81
+ // sizes of the transaction fields
+ SIGNATURE_MESSAGE_FRAGMENT_SIZE = 6561
+ ADDRESS_SIZE = 243
+ VALUE_SIZE = 81
+ TIMESTAMP_SIZE = 27
+ CURRENT_INDEX_SIZE = 27
+ LATEST_INDEX_SIZE = 27
+ BUNDLE_HASH_SIZE = 243
+ TRUNK_TRANSACTION_HASH_SIZE = 243
+ BRANCH_TRANSACTION_HASH_SIZE = 243
+ TAG_SIZE = 81
+ NONCE_SIZE = 81
- // offsets of the transaction fields
- SIGNATURE_MESSAGE_FRAGMENT_OFFSET = 0
- ADDRESS_OFFSET = SIGNATURE_MESSAGE_FRAGMENT_END
- VALUE_OFFSET = ADDRESS_END
- TIMESTAMP_OFFSET = VALUE_END
- CURRENT_INDEX_OFFSET = TIMESTAMP_END
- LATEST_INDEX_OFFSET = CURRENT_INDEX_END
- BUNDLE_HASH_OFFSET = LATEST_INDEX_END
- TRUNK_TRANSACTION_HASH_OFFSET = BUNDLE_HASH_END
- BRANCH_TRANSACTION_HASH_OFFSET = TRUNK_TRANSACTION_HASH_END
- TAG_OFFSET = BRANCH_TRANSACTION_HASH_END
- NONCE_OFFSET = TAG_END
+ // offsets of the transaction fields
+ SIGNATURE_MESSAGE_FRAGMENT_OFFSET = 0
+ ADDRESS_OFFSET = SIGNATURE_MESSAGE_FRAGMENT_END
+ VALUE_OFFSET = ADDRESS_END
+ TIMESTAMP_OFFSET = VALUE_END
+ CURRENT_INDEX_OFFSET = TIMESTAMP_END
+ LATEST_INDEX_OFFSET = CURRENT_INDEX_END
+ BUNDLE_HASH_OFFSET = LATEST_INDEX_END
+ TRUNK_TRANSACTION_HASH_OFFSET = BUNDLE_HASH_END
+ BRANCH_TRANSACTION_HASH_OFFSET = TRUNK_TRANSACTION_HASH_END
+ TAG_OFFSET = BRANCH_TRANSACTION_HASH_END
+ NONCE_OFFSET = TAG_END
- // ends of the transaction fields
- SIGNATURE_MESSAGE_FRAGMENT_END = SIGNATURE_MESSAGE_FRAGMENT_OFFSET + SIGNATURE_MESSAGE_FRAGMENT_SIZE
- ADDRESS_END = ADDRESS_OFFSET + ADDRESS_SIZE
- VALUE_END = VALUE_OFFSET + VALUE_SIZE
- TIMESTAMP_END = TIMESTAMP_OFFSET + TIMESTAMP_SIZE
- CURRENT_INDEX_END = CURRENT_INDEX_OFFSET + CURRENT_INDEX_SIZE
- LATEST_INDEX_END = LATEST_INDEX_OFFSET + LATEST_INDEX_SIZE
- BUNDLE_HASH_END = BUNDLE_HASH_OFFSET + BUNDLE_HASH_SIZE
- TRUNK_TRANSACTION_HASH_END = TRUNK_TRANSACTION_HASH_OFFSET + TRUNK_TRANSACTION_HASH_SIZE
- BRANCH_TRANSACTION_HASH_END = BRANCH_TRANSACTION_HASH_OFFSET + BRANCH_TRANSACTION_HASH_SIZE
- TAG_END = TAG_OFFSET + TAG_SIZE
- NONCE_END = NONCE_OFFSET + NONCE_SIZE
+ // ends of the transaction fields
+ SIGNATURE_MESSAGE_FRAGMENT_END = SIGNATURE_MESSAGE_FRAGMENT_OFFSET + SIGNATURE_MESSAGE_FRAGMENT_SIZE
+ ADDRESS_END = ADDRESS_OFFSET + ADDRESS_SIZE
+ VALUE_END = VALUE_OFFSET + VALUE_SIZE
+ TIMESTAMP_END = TIMESTAMP_OFFSET + TIMESTAMP_SIZE
+ CURRENT_INDEX_END = CURRENT_INDEX_OFFSET + CURRENT_INDEX_SIZE
+ LATEST_INDEX_END = LATEST_INDEX_OFFSET + LATEST_INDEX_SIZE
+ BUNDLE_HASH_END = BUNDLE_HASH_OFFSET + BUNDLE_HASH_SIZE
+ TRUNK_TRANSACTION_HASH_END = TRUNK_TRANSACTION_HASH_OFFSET + TRUNK_TRANSACTION_HASH_SIZE
+ BRANCH_TRANSACTION_HASH_END = BRANCH_TRANSACTION_HASH_OFFSET + BRANCH_TRANSACTION_HASH_SIZE
+ TAG_END = TAG_OFFSET + TAG_SIZE
+ NONCE_END = NONCE_OFFSET + NONCE_SIZE
- // the full size of a transaction
- MARSHALLED_TOTAL_SIZE = NONCE_END
+ // the full size of a transaction
+ MARSHALLED_TOTAL_SIZE = NONCE_END
)
diff --git a/packages/transaction/transaction.go b/packages/transaction/transaction.go
index 871f6b2924484bbdfa6d9a2c48d88c53cfccac47..9d7033099776a812cb7aded48dc3345fc9c9f841 100644
--- a/packages/transaction/transaction.go
+++ b/packages/transaction/transaction.go
@@ -1,56 +1,56 @@
package transaction
import (
- "github.com/iotaledger/goshimmer/packages/curl"
- "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/curl"
+ "github.com/iotaledger/goshimmer/packages/ternary"
)
type Transaction struct {
- SignatureMessageFragment ternary.Trits
- Address ternary.Trits
- Value ternary.Trits
- Timestamp ternary.Trits
- CurrentIndex ternary.Trits
- LatestIndex ternary.Trits
- BundleHash ternary.Trits
- TrunkTransactionHash ternary.Trits
- BranchTransactionHash ternary.Trits
- Tag ternary.Trits
- Nonce ternary.Trits
-
- Hash ternary.Trits
- WeightMagnitude int
- Bytes []byte
- Trits ternary.Trits
+ SignatureMessageFragment ternary.Trits
+ Address ternary.Trits
+ Value ternary.Trits
+ Timestamp ternary.Trits
+ CurrentIndex ternary.Trits
+ LatestIndex ternary.Trits
+ BundleHash ternary.Trits
+ TrunkTransactionHash ternary.Trits
+ BranchTransactionHash ternary.Trits
+ Tag ternary.Trits
+ Nonce ternary.Trits
+
+ Hash ternary.Trits
+ WeightMagnitude int
+ Bytes []byte
+ Trits ternary.Trits
}
func FromTrits(trits ternary.Trits, optionalHash ...ternary.Trits) *Transaction {
- hash := <- curl.CURLP81.Hash(trits)
-
- transaction := &Transaction{
- SignatureMessageFragment: trits[SIGNATURE_MESSAGE_FRAGMENT_OFFSET:SIGNATURE_MESSAGE_FRAGMENT_END],
- Address: trits[ADDRESS_OFFSET:ADDRESS_END],
- Value: trits[VALUE_OFFSET:VALUE_END],
- Timestamp: trits[TIMESTAMP_OFFSET:TIMESTAMP_END],
- CurrentIndex: trits[CURRENT_INDEX_OFFSET:CURRENT_INDEX_END],
- LatestIndex: trits[LATEST_INDEX_OFFSET:LATEST_INDEX_END],
- BundleHash: trits[BUNDLE_HASH_OFFSET:BUNDLE_HASH_END],
- TrunkTransactionHash: trits[TRUNK_TRANSACTION_HASH_OFFSET:TRUNK_TRANSACTION_HASH_END],
- BranchTransactionHash: trits[BRANCH_TRANSACTION_HASH_OFFSET:BRANCH_TRANSACTION_HASH_END],
- Tag: trits[TAG_OFFSET:TAG_END],
- Nonce: trits[NONCE_OFFSET:NONCE_END],
-
- Hash: hash,
- WeightMagnitude: hash.TrailingZeroes(),
- Trits: trits,
- }
-
- return transaction
+ hash := <-curl.CURLP81.Hash(trits)
+
+ transaction := &Transaction{
+ SignatureMessageFragment: trits[SIGNATURE_MESSAGE_FRAGMENT_OFFSET:SIGNATURE_MESSAGE_FRAGMENT_END],
+ Address: trits[ADDRESS_OFFSET:ADDRESS_END],
+ Value: trits[VALUE_OFFSET:VALUE_END],
+ Timestamp: trits[TIMESTAMP_OFFSET:TIMESTAMP_END],
+ CurrentIndex: trits[CURRENT_INDEX_OFFSET:CURRENT_INDEX_END],
+ LatestIndex: trits[LATEST_INDEX_OFFSET:LATEST_INDEX_END],
+ BundleHash: trits[BUNDLE_HASH_OFFSET:BUNDLE_HASH_END],
+ TrunkTransactionHash: trits[TRUNK_TRANSACTION_HASH_OFFSET:TRUNK_TRANSACTION_HASH_END],
+ BranchTransactionHash: trits[BRANCH_TRANSACTION_HASH_OFFSET:BRANCH_TRANSACTION_HASH_END],
+ Tag: trits[TAG_OFFSET:TAG_END],
+ Nonce: trits[NONCE_OFFSET:NONCE_END],
+
+ Hash: hash,
+ WeightMagnitude: hash.TrailingZeroes(),
+ Trits: trits,
+ }
+
+ return transaction
}
func FromBytes(bytes []byte) *Transaction {
- transaction := FromTrits(ternary.BytesToTrits(bytes)[:MARSHALLED_TOTAL_SIZE])
- transaction.Bytes = bytes
+ transaction := FromTrits(ternary.BytesToTrits(bytes)[:MARSHALLED_TOTAL_SIZE])
+ transaction.Bytes = bytes
- return transaction
-}
\ No newline at end of file
+ return transaction
+}
diff --git a/packages/typeconversion/typeconversion.go b/packages/typeconversion/typeconversion.go
index 729b48d96a1cb1606cf131d6f558df1428f3970e..ed053ee8bc431c7c652a23774d381d0a06ce3c71 100644
--- a/packages/typeconversion/typeconversion.go
+++ b/packages/typeconversion/typeconversion.go
@@ -1,18 +1,18 @@
package typeconversion
import (
- "reflect"
- "unsafe"
+ "reflect"
+ "unsafe"
)
func BytesToString(b []byte) string {
- bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
+ bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
- return *(*string)(unsafe.Pointer(&reflect.StringHeader{bh.Data, bh.Len}))
+ return *(*string)(unsafe.Pointer(&reflect.StringHeader{bh.Data, bh.Len}))
}
func StringToBytes(str string) []byte {
- hdr := (*reflect.StringHeader)(unsafe.Pointer(&str))
+ hdr := (*reflect.StringHeader)(unsafe.Pointer(&str))
- return *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{Data: hdr.Data, Len: hdr.Len, Cap: hdr.Len}))
-}
\ No newline at end of file
+ return *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{Data: hdr.Data, Len: hdr.Len, Cap: hdr.Len}))
+}
diff --git a/plugins/analysis/client/parameters.go b/plugins/analysis/client/parameters.go
index 18558bbba542e07979c095d3e7f9d047489e020a..952e3e9999d48954a98dda486d5d476bc4a762fc 100644
--- a/plugins/analysis/client/parameters.go
+++ b/plugins/analysis/client/parameters.go
@@ -3,5 +3,5 @@ package client
import "github.com/iotaledger/goshimmer/packages/parameter"
var (
- SERVER_ADDRESS = parameter.AddString("ANALYSIS/SERVER-ADDRESS", "82.165.29.179:188", "tcp server for collecting analysis information")
+ SERVER_ADDRESS = parameter.AddString("ANALYSIS/SERVER-ADDRESS", "82.165.29.179:188", "tcp server for collecting analysis information")
)
diff --git a/plugins/analysis/client/plugin.go b/plugins/analysis/client/plugin.go
index 7925cae5d5dda284bdcb796676a26cc7bfdcfd1f..3a42c55ae0a0af094e138b446b3ddcadb5f11e73 100644
--- a/plugins/analysis/client/plugin.go
+++ b/plugins/analysis/client/plugin.go
@@ -1,140 +1,141 @@
package client
import (
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/network"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/timeutil"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/addnode"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/connectnodes"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/disconnectnodes"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/ping"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "net"
- "time"
+ "net"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/timeutil"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/addnode"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/connectnodes"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/disconnectnodes"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
func Run(plugin *node.Plugin) {
- daemon.BackgroundWorker(func() {
- shuttingDown := false
-
- for !shuttingDown {
- select {
- case <-daemon.ShutdownSignal:
- return
-
- default:
- if conn, err := net.Dial("tcp", *SERVER_ADDRESS.Value); err != nil {
- plugin.LogDebug("Could not connect to reporting server: " + err.Error())
-
- timeutil.Sleep(1 * time.Second)
- } else {
- managedConn := network.NewManagedConnection(conn)
- eventDispatchers := getEventDispatchers(managedConn)
-
- reportCurrentStatus(eventDispatchers)
- setupHooks(managedConn, eventDispatchers)
-
- shuttingDown = keepConnectionAlive(managedConn)
- }
- }
- }
- })
+ daemon.BackgroundWorker(func() {
+ shuttingDown := false
+
+ for !shuttingDown {
+ select {
+ case <-daemon.ShutdownSignal:
+ return
+
+ default:
+ if conn, err := net.Dial("tcp", *SERVER_ADDRESS.Value); err != nil {
+ plugin.LogDebug("Could not connect to reporting server: " + err.Error())
+
+ timeutil.Sleep(1 * time.Second)
+ } else {
+ managedConn := network.NewManagedConnection(conn)
+ eventDispatchers := getEventDispatchers(managedConn)
+
+ reportCurrentStatus(eventDispatchers)
+ setupHooks(managedConn, eventDispatchers)
+
+ shuttingDown = keepConnectionAlive(managedConn)
+ }
+ }
+ }
+ })
}
func getEventDispatchers(conn *network.ManagedConnection) *EventDispatchers {
- return &EventDispatchers{
- AddNode: func(nodeId []byte) {
- conn.Write((&addnode.Packet{ NodeId: nodeId }).Marshal())
- },
- ConnectNodes: func(sourceId []byte, targetId []byte) {
- conn.Write((&connectnodes.Packet{ SourceId: sourceId, TargetId: targetId }).Marshal())
- },
- DisconnectNodes: func(sourceId []byte, targetId []byte) {
- conn.Write((&disconnectnodes.Packet{ SourceId: sourceId, TargetId: targetId }).Marshal())
- },
- }
+ return &EventDispatchers{
+ AddNode: func(nodeId []byte) {
+ conn.Write((&addnode.Packet{NodeId: nodeId}).Marshal())
+ },
+ ConnectNodes: func(sourceId []byte, targetId []byte) {
+ conn.Write((&connectnodes.Packet{SourceId: sourceId, TargetId: targetId}).Marshal())
+ },
+ DisconnectNodes: func(sourceId []byte, targetId []byte) {
+ conn.Write((&disconnectnodes.Packet{SourceId: sourceId, TargetId: targetId}).Marshal())
+ },
+ }
}
func reportCurrentStatus(eventDispatchers *EventDispatchers) {
- eventDispatchers.AddNode(accountability.OwnId().Identifier)
+ eventDispatchers.AddNode(accountability.OwnId().Identifier)
- reportChosenNeighbors(eventDispatchers)
+ reportChosenNeighbors(eventDispatchers)
}
func setupHooks(conn *network.ManagedConnection, eventDispatchers *EventDispatchers) {
- // define hooks ////////////////////////////////////////////////////////////////////////////////////////////////////
+ // define hooks ////////////////////////////////////////////////////////////////////////////////////////////////////
- onDiscoverPeer := events.NewClosure(func(p *peer.Peer) {
- go eventDispatchers.AddNode(p.Identity.Identifier)
- })
+ onDiscoverPeer := events.NewClosure(func(p *peer.Peer) {
+ go eventDispatchers.AddNode(p.Identity.Identifier)
+ })
- onAddAcceptedNeighbor := events.NewClosure(func(p *peer.Peer) {
- eventDispatchers.ConnectNodes(p.Identity.Identifier, accountability.OwnId().Identifier)
- })
+ onAddAcceptedNeighbor := events.NewClosure(func(p *peer.Peer) {
+ eventDispatchers.ConnectNodes(p.Identity.Identifier, accountability.OwnId().Identifier)
+ })
- onRemoveAcceptedNeighbor := events.NewClosure(func(p *peer.Peer) {
- eventDispatchers.DisconnectNodes(p.Identity.Identifier, accountability.OwnId().Identifier)
- })
+ onRemoveAcceptedNeighbor := events.NewClosure(func(p *peer.Peer) {
+ eventDispatchers.DisconnectNodes(p.Identity.Identifier, accountability.OwnId().Identifier)
+ })
- onAddChosenNeighbor := events.NewClosure(func(p *peer.Peer) {
- eventDispatchers.ConnectNodes(accountability.OwnId().Identifier, p.Identity.Identifier)
- })
+ onAddChosenNeighbor := events.NewClosure(func(p *peer.Peer) {
+ eventDispatchers.ConnectNodes(accountability.OwnId().Identifier, p.Identity.Identifier)
+ })
- onRemoveChosenNeighbor := events.NewClosure(func(p *peer.Peer) {
- eventDispatchers.DisconnectNodes(accountability.OwnId().Identifier, p.Identity.Identifier)
- })
+ onRemoveChosenNeighbor := events.NewClosure(func(p *peer.Peer) {
+ eventDispatchers.DisconnectNodes(accountability.OwnId().Identifier, p.Identity.Identifier)
+ })
- // setup hooks /////////////////////////////////////////////////////////////////////////////////////////////////////
+ // setup hooks /////////////////////////////////////////////////////////////////////////////////////////////////////
- knownpeers.INSTANCE.Events.Add.Attach(onDiscoverPeer)
- acceptedneighbors.INSTANCE.Events.Add.Attach(onAddAcceptedNeighbor)
- acceptedneighbors.INSTANCE.Events.Remove.Attach(onRemoveAcceptedNeighbor)
- chosenneighbors.INSTANCE.Events.Add.Attach(onAddChosenNeighbor)
- chosenneighbors.INSTANCE.Events.Remove.Attach(onRemoveChosenNeighbor)
+ knownpeers.INSTANCE.Events.Add.Attach(onDiscoverPeer)
+ acceptedneighbors.INSTANCE.Events.Add.Attach(onAddAcceptedNeighbor)
+ acceptedneighbors.INSTANCE.Events.Remove.Attach(onRemoveAcceptedNeighbor)
+ chosenneighbors.INSTANCE.Events.Add.Attach(onAddChosenNeighbor)
+ chosenneighbors.INSTANCE.Events.Remove.Attach(onRemoveChosenNeighbor)
- // clean up hooks on close /////////////////////////////////////////////////////////////////////////////////////////
+ // clean up hooks on close /////////////////////////////////////////////////////////////////////////////////////////
- var onClose *events.Closure
- onClose = events.NewClosure(func() {
- knownpeers.INSTANCE.Events.Add.Detach(onDiscoverPeer)
- acceptedneighbors.INSTANCE.Events.Add.Detach(onAddAcceptedNeighbor)
- acceptedneighbors.INSTANCE.Events.Remove.Detach(onRemoveAcceptedNeighbor)
- chosenneighbors.INSTANCE.Events.Add.Detach(onAddChosenNeighbor)
- chosenneighbors.INSTANCE.Events.Remove.Detach(onRemoveChosenNeighbor)
+ var onClose *events.Closure
+ onClose = events.NewClosure(func() {
+ knownpeers.INSTANCE.Events.Add.Detach(onDiscoverPeer)
+ acceptedneighbors.INSTANCE.Events.Add.Detach(onAddAcceptedNeighbor)
+ acceptedneighbors.INSTANCE.Events.Remove.Detach(onRemoveAcceptedNeighbor)
+ chosenneighbors.INSTANCE.Events.Add.Detach(onAddChosenNeighbor)
+ chosenneighbors.INSTANCE.Events.Remove.Detach(onRemoveChosenNeighbor)
- conn.Events.Close.Detach(onClose)
- })
- conn.Events.Close.Attach(onClose)
+ conn.Events.Close.Detach(onClose)
+ })
+ conn.Events.Close.Attach(onClose)
}
func reportChosenNeighbors(dispatchers *EventDispatchers) {
- for _, chosenNeighbor := range chosenneighbors.INSTANCE.Peers {
- dispatchers.AddNode(chosenNeighbor.Identity.Identifier)
- }
- for _, chosenNeighbor := range chosenneighbors.INSTANCE.Peers {
- dispatchers.ConnectNodes(accountability.OwnId().Identifier, chosenNeighbor.Identity.Identifier)
- }
+ for _, chosenNeighbor := range chosenneighbors.INSTANCE.Peers {
+ dispatchers.AddNode(chosenNeighbor.Identity.Identifier)
+ }
+ for _, chosenNeighbor := range chosenneighbors.INSTANCE.Peers {
+ dispatchers.ConnectNodes(accountability.OwnId().Identifier, chosenNeighbor.Identity.Identifier)
+ }
}
func keepConnectionAlive(conn *network.ManagedConnection) bool {
- go conn.Read(make([]byte, 1))
-
- ticker := time.NewTicker(1 * time.Second)
- for {
- select {
- case <- daemon.ShutdownSignal:
- return true
-
- case <- ticker.C:
- if _, err := conn.Write((&ping.Packet{}).Marshal()); err != nil {
- return false
- }
- }
- }
+ go conn.Read(make([]byte, 1))
+
+ ticker := time.NewTicker(1 * time.Second)
+ for {
+ select {
+ case <-daemon.ShutdownSignal:
+ return true
+
+ case <-ticker.C:
+ if _, err := conn.Write((&ping.Packet{}).Marshal()); err != nil {
+ return false
+ }
+ }
+ }
}
diff --git a/plugins/analysis/client/types.go b/plugins/analysis/client/types.go
index 8d24a99d4e991325c4207e8d3cb0f8d2711e6734..1af7c8f102f699a3268ae78cc1c810918a7b8958 100644
--- a/plugins/analysis/client/types.go
+++ b/plugins/analysis/client/types.go
@@ -1,7 +1,7 @@
package client
type EventDispatchers struct {
- AddNode func(nodeId []byte)
- ConnectNodes func(sourceId []byte, targetId []byte)
- DisconnectNodes func(sourceId []byte, targetId []byte)
+ AddNode func(nodeId []byte)
+ ConnectNodes func(sourceId []byte, targetId []byte)
+ DisconnectNodes func(sourceId []byte, targetId []byte)
}
diff --git a/plugins/analysis/plugin.go b/plugins/analysis/plugin.go
index e8446869097e194187ec04f35f4923356aa3641c..ee40ed44c39499b3336a428f390b1d21b58d9cea 100644
--- a/plugins/analysis/plugin.go
+++ b/plugins/analysis/plugin.go
@@ -1,38 +1,38 @@
package analysis
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/analysis/client"
- "github.com/iotaledger/goshimmer/plugins/analysis/server"
- "github.com/iotaledger/goshimmer/plugins/analysis/webinterface"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/analysis/client"
+ "github.com/iotaledger/goshimmer/plugins/analysis/server"
+ "github.com/iotaledger/goshimmer/plugins/analysis/webinterface"
)
var PLUGIN = node.NewPlugin("Analysis", configure, run)
func configure(plugin *node.Plugin) {
- if *server.SERVER_PORT.Value != 0 {
- webinterface.Configure(plugin)
- server.Configure(plugin)
+ if *server.SERVER_PORT.Value != 0 {
+ webinterface.Configure(plugin)
+ server.Configure(plugin)
- daemon.Events.Shutdown.Attach(events.NewClosure(func() {
- server.Shutdown(plugin)
- }))
- }
+ daemon.Events.Shutdown.Attach(events.NewClosure(func() {
+ server.Shutdown(plugin)
+ }))
+ }
}
func run(plugin *node.Plugin) {
- if *server.SERVER_PORT.Value != 0 {
- webinterface.Run(plugin)
- server.Run(plugin)
- } else {
- plugin.Node.LogSuccess("Node", "Starting Plugin: Analysis ... server is disabled (server-port is 0)")
- }
+ if *server.SERVER_PORT.Value != 0 {
+ webinterface.Run(plugin)
+ server.Run(plugin)
+ } else {
+ plugin.Node.LogSuccess("Node", "Starting Plugin: Analysis ... server is disabled (server-port is 0)")
+ }
- if *client.SERVER_ADDRESS.Value != "" {
- client.Run(plugin)
- } else {
- plugin.Node.LogSuccess("Node", "Starting Plugin: Analysis ... client is disabled (server-address is empty)")
- }
+ if *client.SERVER_ADDRESS.Value != "" {
+ client.Run(plugin)
+ } else {
+ plugin.Node.LogSuccess("Node", "Starting Plugin: Analysis ... client is disabled (server-address is empty)")
+ }
}
diff --git a/plugins/analysis/server/constants.go b/plugins/analysis/server/constants.go
index a0cd26fc768a99d5b096f9b9d0023c5997a01a30..63083804f01cf4f4b15aa1811b8e59f115c8fb55 100644
--- a/plugins/analysis/server/constants.go
+++ b/plugins/analysis/server/constants.go
@@ -1,23 +1,24 @@
package server
import (
- "github.com/iotaledger/goshimmer/plugins/analysis/types/addnode"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/connectnodes"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/disconnectnodes"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/ping"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/removenode"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/addnode"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/connectnodes"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/disconnectnodes"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/removenode"
)
const (
- IDLE_TIMEOUT = 5 * time.Second
+ IDLE_TIMEOUT = 5 * time.Second
- 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_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
)
diff --git a/plugins/analysis/server/events.go b/plugins/analysis/server/events.go
index 4fd4714f6aa034f6ab0f280f442aca316ffea3ed..e66359ff38a60031c0c12e9e1cf30314704c176d 100644
--- a/plugins/analysis/server/events.go
+++ b/plugins/analysis/server/events.go
@@ -1,27 +1,31 @@
package server
import (
- "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/events"
)
var Events = struct {
- AddNode *events.Event
- RemoveNode *events.Event
- ConnectNodes *events.Event
- DisconnectNodes *events.Event
- NodeOnline *events.Event
- NodeOffline *events.Event
- Error *events.Event
+ AddNode *events.Event
+ RemoveNode *events.Event
+ ConnectNodes *events.Event
+ DisconnectNodes *events.Event
+ NodeOnline *events.Event
+ NodeOffline *events.Event
+ Error *events.Event
}{
- events.NewEvent(stringCaller),
- events.NewEvent(stringCaller),
- events.NewEvent(stringStringCaller),
- events.NewEvent(stringStringCaller),
- events.NewEvent(stringCaller),
- events.NewEvent(stringCaller),
- events.NewEvent(errorCaller),
+ events.NewEvent(stringCaller),
+ events.NewEvent(stringCaller),
+ events.NewEvent(stringStringCaller),
+ events.NewEvent(stringStringCaller),
+ events.NewEvent(stringCaller),
+ events.NewEvent(stringCaller),
+ events.NewEvent(errorCaller),
}
-func stringCaller(handler interface{}, params ...interface{}) { handler.(func(string))(params[0].(string)) }
-func stringStringCaller(handler interface{}, params ...interface{}) { handler.(func(string, string))(params[0].(string), params[1].(string)) }
-func errorCaller(handler interface{}, params ...interface{}) { handler.(func(error))(params[0].(error)) }
+func stringCaller(handler interface{}, params ...interface{}) {
+ handler.(func(string))(params[0].(string))
+}
+func stringStringCaller(handler interface{}, params ...interface{}) {
+ handler.(func(string, string))(params[0].(string), params[1].(string))
+}
+func errorCaller(handler interface{}, params ...interface{}) { handler.(func(error))(params[0].(error)) }
diff --git a/plugins/analysis/server/parameters.go b/plugins/analysis/server/parameters.go
index 63fcaab93da502d8442d71d2446441fbf1da39f3..ccab973ea0242f83b022e3a4bfc82c3ccf1acd37 100644
--- a/plugins/analysis/server/parameters.go
+++ b/plugins/analysis/server/parameters.go
@@ -3,5 +3,5 @@ package server
import "github.com/iotaledger/goshimmer/packages/parameter"
var (
- SERVER_PORT = parameter.AddInt("ANALYSIS/SERVER-PORT", 0, "tcp port for incoming analysis packets")
+ SERVER_PORT = parameter.AddInt("ANALYSIS/SERVER-PORT", 0, "tcp port for incoming analysis packets")
)
diff --git a/plugins/analysis/server/plugin.go b/plugins/analysis/server/plugin.go
index 88beeba8b905cd45872349695995250155251c77..c8e9f0b72859a8d79629787fecf779b442bb2873 100644
--- a/plugins/analysis/server/plugin.go
+++ b/plugins/analysis/server/plugin.go
@@ -1,310 +1,311 @@
package server
import (
- "encoding/hex"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/network"
- "github.com/iotaledger/goshimmer/packages/network/tcp"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/addnode"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/connectnodes"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/disconnectnodes"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/ping"
- "github.com/iotaledger/goshimmer/plugins/analysis/types/removenode"
- "github.com/pkg/errors"
- "math"
- "strconv"
+ "encoding/hex"
+ "math"
+ "strconv"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/packages/network/tcp"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/addnode"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/connectnodes"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/disconnectnodes"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/analysis/types/removenode"
+ "github.com/pkg/errors"
)
var server *tcp.Server
func Configure(plugin *node.Plugin) {
- server = tcp.NewServer()
-
- server.Events.Connect.Attach(events.NewClosure(HandleConnection))
- server.Events.Error.Attach(events.NewClosure(func(err error) {
- plugin.LogFailure("error in server: " + err.Error())
- }))
- server.Events.Start.Attach(events.NewClosure(func() {
- plugin.LogSuccess("Starting Server (port " + strconv.Itoa(*SERVER_PORT.Value) + ") ... done")
- }))
- server.Events.Shutdown.Attach(events.NewClosure(func() {
- plugin.LogSuccess("Stopping Server ... done")
- }))
+ server = tcp.NewServer()
+
+ server.Events.Connect.Attach(events.NewClosure(HandleConnection))
+ server.Events.Error.Attach(events.NewClosure(func(err error) {
+ plugin.LogFailure("error in server: " + err.Error())
+ }))
+ server.Events.Start.Attach(events.NewClosure(func() {
+ plugin.LogSuccess("Starting Server (port " + strconv.Itoa(*SERVER_PORT.Value) + ") ... done")
+ }))
+ server.Events.Shutdown.Attach(events.NewClosure(func() {
+ plugin.LogSuccess("Stopping Server ... done")
+ }))
}
func Run(plugin *node.Plugin) {
- daemon.BackgroundWorker(func() {
- plugin.LogInfo("Starting Server (port " + strconv.Itoa(*SERVER_PORT.Value) + ") ...")
+ daemon.BackgroundWorker(func() {
+ plugin.LogInfo("Starting Server (port " + strconv.Itoa(*SERVER_PORT.Value) + ") ...")
- server.Listen(*SERVER_PORT.Value)
- })
+ server.Listen(*SERVER_PORT.Value)
+ })
}
func Shutdown(plugin *node.Plugin) {
- plugin.LogInfo("Stopping Server ...")
+ plugin.LogInfo("Stopping Server ...")
- server.Shutdown()
+ server.Shutdown()
}
func HandleConnection(conn *network.ManagedConnection) {
- conn.SetTimeout(IDLE_TIMEOUT)
+ conn.SetTimeout(IDLE_TIMEOUT)
- var connectionState = STATE_INITIAL
- var receiveBuffer []byte
- var offset int
- var connectedNodeId string
+ var connectionState = STATE_INITIAL
+ var receiveBuffer []byte
+ var offset int
+ var connectedNodeId string
- var onDisconnect *events.Closure
+ var onDisconnect *events.Closure
- onReceiveData := events.NewClosure(func(data []byte) {
- processIncomingPacket(&connectionState, &receiveBuffer, conn, data, &offset, &connectedNodeId)
- })
- onDisconnect = events.NewClosure(func() {
- Events.NodeOffline.Trigger(connectedNodeId)
+ onReceiveData := events.NewClosure(func(data []byte) {
+ processIncomingPacket(&connectionState, &receiveBuffer, conn, data, &offset, &connectedNodeId)
+ })
+ onDisconnect = events.NewClosure(func() {
+ Events.NodeOffline.Trigger(connectedNodeId)
- conn.Events.ReceiveData.Detach(onReceiveData)
- conn.Events.Close.Detach(onDisconnect)
- })
+ conn.Events.ReceiveData.Detach(onReceiveData)
+ conn.Events.Close.Detach(onDisconnect)
+ })
- conn.Events.ReceiveData.Attach(onReceiveData)
- conn.Events.Close.Attach(onDisconnect)
+ conn.Events.ReceiveData.Attach(onReceiveData)
+ 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,
- )
+ maxPacketsSize := getMaxPacketSize(
+ ping.MARSHALLED_TOTAL_SIZE,
+ addnode.MARSHALLED_TOTAL_SIZE,
+ removenode.MARSHALLED_TOTAL_SIZE,
+ connectnodes.MARSHALLED_TOTAL_SIZE,
+ disconnectnodes.MARSHALLED_PACKET_HEADER,
+ )
- go conn.Read(make([]byte, maxPacketsSize))
+ go conn.Read(make([]byte, maxPacketsSize))
}
func getMaxPacketSize(packetSizes ...int) int {
- maxPacketSize := 0
+ maxPacketSize := 0
- for _, packetSize := range packetSizes {
- if packetSize > maxPacketSize {
- maxPacketSize = packetSize
- }
- }
+ for _, packetSize := range packetSizes {
+ if packetSize > maxPacketSize {
+ maxPacketSize = packetSize
+ }
+ }
- return maxPacketSize
+ return maxPacketSize
}
func processIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
- firstPackage := *connectionState == STATE_INITIAL
+ firstPackage := *connectionState == STATE_INITIAL
- if firstPackage || *connectionState == STATE_CONSECUTIVE {
- var err error
- if *connectionState, *receiveBuffer, err = parsePackageHeader(data); err != nil {
- Events.Error.Trigger(err)
+ if firstPackage || *connectionState == STATE_CONSECUTIVE {
+ var err error
+ if *connectionState, *receiveBuffer, err = parsePackageHeader(data); err != nil {
+ Events.Error.Trigger(err)
- conn.Close()
+ conn.Close()
- return
- }
+ return
+ }
- *offset = 0
+ *offset = 0
- switch *connectionState {
- case STATE_ADD_NODE:
- *receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
+ switch *connectionState {
+ case STATE_ADD_NODE:
+ *receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
- case STATE_PING:
- *receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ case STATE_PING:
+ *receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
- case STATE_CONNECT_NODES:
- *receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
+ case STATE_CONNECT_NODES:
+ *receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
- case STATE_DISCONNECT_NODES:
- *receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
+ case STATE_DISCONNECT_NODES:
+ *receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
- case STATE_REMOVE_NODE:
- *receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
- }
- }
+ case STATE_REMOVE_NODE:
+ *receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
+ }
+ }
- if firstPackage {
- if *connectionState != STATE_ADD_NODE {
- Events.Error.Trigger(errors.New("expected initial add node package"))
- } else {
- *connectionState = STATE_INITIAL_ADDNODE
- }
- }
+ if firstPackage {
+ if *connectionState != STATE_ADD_NODE {
+ Events.Error.Trigger(errors.New("expected initial add node package"))
+ } else {
+ *connectionState = STATE_INITIAL_ADDNODE
+ }
+ }
- switch *connectionState {
- case STATE_INITIAL_ADDNODE:
- processIncomingAddNodePacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
+ switch *connectionState {
+ case STATE_INITIAL_ADDNODE:
+ processIncomingAddNodePacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
- case STATE_ADD_NODE:
- processIncomingAddNodePacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
+ case STATE_ADD_NODE:
+ processIncomingAddNodePacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
- case STATE_PING:
- processIncomingPingPacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
+ case STATE_PING:
+ processIncomingPingPacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
- case STATE_CONNECT_NODES:
- processIncomingConnectNodesPacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
+ case STATE_CONNECT_NODES:
+ processIncomingConnectNodesPacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
- case STATE_DISCONNECT_NODES:
- processIncomingDisconnectNodesPacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
+ case STATE_DISCONNECT_NODES:
+ processIncomingDisconnectNodesPacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
- case STATE_REMOVE_NODE:
- processIncomingAddNodePacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
- }
+ case STATE_REMOVE_NODE:
+ processIncomingAddNodePacket(connectionState, receiveBuffer, conn, data, offset, connectedNodeId)
+ }
}
func parsePackageHeader(data []byte) (ConnectionState, []byte, error) {
- var connectionState ConnectionState
- var receiveBuffer []byte
+ var connectionState ConnectionState
+ var receiveBuffer []byte
- switch data[0] {
- case ping.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ switch data[0] {
+ case ping.MARSHALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_PING
+ connectionState = STATE_PING
- case addnode.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
+ case addnode.MARSHALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_ADD_NODE
+ connectionState = STATE_ADD_NODE
- case connectnodes.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
+ case connectnodes.MARSHALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_CONNECT_NODES
+ connectionState = STATE_CONNECT_NODES
- case disconnectnodes.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
+ case disconnectnodes.MARSHALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_DISCONNECT_NODES
+ connectionState = STATE_DISCONNECT_NODES
- case removenode.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
+ case removenode.MARSHALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_REMOVE_NODE
+ connectionState = STATE_REMOVE_NODE
- default:
- return 0, nil, errors.New("invalid package header")
- }
+ default:
+ return 0, nil, errors.New("invalid package header")
+ }
- return connectionState, receiveBuffer, nil
+ return connectionState, receiveBuffer, nil
}
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.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
- copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
+ copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset + len(data) < addnode.MARSHALLED_TOTAL_SIZE {
- *offset += len(data)
- } else {
- if addNodePacket, err := addnode.Unmarshal(*receiveBuffer); err != nil {
- Events.Error.Trigger(err)
+ if *offset+len(data) < addnode.MARSHALLED_TOTAL_SIZE {
+ *offset += len(data)
+ } else {
+ if addNodePacket, err := addnode.Unmarshal(*receiveBuffer); err != nil {
+ Events.Error.Trigger(err)
- conn.Close()
+ conn.Close()
- return
- } else {
- nodeId := hex.EncodeToString(addNodePacket.NodeId)
+ return
+ } else {
+ nodeId := hex.EncodeToString(addNodePacket.NodeId)
- Events.AddNode.Trigger(nodeId)
+ Events.AddNode.Trigger(nodeId)
- if *connectionState == STATE_INITIAL_ADDNODE {
- *connectedNodeId = nodeId
+ if *connectionState == STATE_INITIAL_ADDNODE {
+ *connectedNodeId = nodeId
- Events.NodeOnline.Trigger(nodeId)
- }
- }
+ Events.NodeOnline.Trigger(nodeId)
+ }
+ }
- *connectionState = STATE_CONSECUTIVE
+ *connectionState = STATE_CONSECUTIVE
- if *offset + len(data) > addnode.MARSHALLED_TOTAL_SIZE {
- processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
- }
- }
+ if *offset+len(data) > addnode.MARSHALLED_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.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
- copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
+ copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset + len(data) < ping.MARSHALLED_TOTAL_SIZE {
- *offset += len(data)
- } else {
- if _, err := ping.Unmarshal(*receiveBuffer); err != nil {
- Events.Error.Trigger(err)
+ if *offset+len(data) < ping.MARSHALLED_TOTAL_SIZE {
+ *offset += len(data)
+ } else {
+ if _, err := ping.Unmarshal(*receiveBuffer); err != nil {
+ Events.Error.Trigger(err)
- conn.Close()
+ conn.Close()
- return
- }
+ return
+ }
- *connectionState = STATE_CONSECUTIVE
+ *connectionState = STATE_CONSECUTIVE
- if *offset + len(data) > ping.MARSHALLED_TOTAL_SIZE {
- processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
- }
- }
+ if *offset+len(data) > ping.MARSHALLED_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.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
- copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
+ copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset + len(data) < connectnodes.MARSHALLED_TOTAL_SIZE {
- *offset += len(data)
- } else {
- if connectNodesPacket, err := connectnodes.Unmarshal(*receiveBuffer); err != nil {
- Events.Error.Trigger(err)
+ if *offset+len(data) < connectnodes.MARSHALLED_TOTAL_SIZE {
+ *offset += len(data)
+ } else {
+ if connectNodesPacket, err := connectnodes.Unmarshal(*receiveBuffer); err != nil {
+ Events.Error.Trigger(err)
- conn.Close()
+ conn.Close()
- return
- } else {
- sourceNodeId := hex.EncodeToString(connectNodesPacket.SourceId)
- targetNodeId := hex.EncodeToString(connectNodesPacket.TargetId)
+ return
+ } else {
+ sourceNodeId := hex.EncodeToString(connectNodesPacket.SourceId)
+ targetNodeId := hex.EncodeToString(connectNodesPacket.TargetId)
- Events.ConnectNodes.Trigger(sourceNodeId, targetNodeId)
- }
+ Events.ConnectNodes.Trigger(sourceNodeId, targetNodeId)
+ }
- *connectionState = STATE_CONSECUTIVE
+ *connectionState = STATE_CONSECUTIVE
- if *offset + len(data) > connectnodes.MARSHALLED_TOTAL_SIZE {
- processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
- }
- }
+ if *offset+len(data) > connectnodes.MARSHALLED_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.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
- copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
+ copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset + len(data) < disconnectnodes.MARSHALLED_TOTAL_SIZE {
- *offset += len(data)
- } else {
- if disconnectNodesPacket, err := disconnectnodes.Unmarshal(*receiveBuffer); err != nil {
- Events.Error.Trigger(err)
+ if *offset+len(data) < disconnectnodes.MARSHALLED_TOTAL_SIZE {
+ *offset += len(data)
+ } else {
+ if disconnectNodesPacket, err := disconnectnodes.Unmarshal(*receiveBuffer); err != nil {
+ Events.Error.Trigger(err)
- conn.Close()
+ conn.Close()
- return
- } else {
- sourceNodeId := hex.EncodeToString(disconnectNodesPacket.SourceId)
- targetNodeId := hex.EncodeToString(disconnectNodesPacket.TargetId)
+ return
+ } else {
+ sourceNodeId := hex.EncodeToString(disconnectNodesPacket.SourceId)
+ targetNodeId := hex.EncodeToString(disconnectNodesPacket.TargetId)
- Events.DisconnectNodes.Trigger(sourceNodeId, targetNodeId)
- }
+ Events.DisconnectNodes.Trigger(sourceNodeId, targetNodeId)
+ }
- *connectionState = STATE_CONSECUTIVE
+ *connectionState = STATE_CONSECUTIVE
- if *offset + len(data) > disconnectnodes.MARSHALLED_TOTAL_SIZE {
- processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
- }
- }
+ if *offset+len(data) > disconnectnodes.MARSHALLED_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 c1154439c25cfb35475ebeb46a405db8b821690b..43636315d3945f1a95b981617c6a02397e1afc7e 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
+ MARSHALLED_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
+ MARSHALLED_PACKET_HEADER_START = 0
+ MARSHALLED_PACKET_HEADER_SIZE = 1
+ MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
- MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
- MARSHALLED_ID_SIZE = 20
- MARSHALLED_ID_END = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
+ MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
+ MARSHALLED_ID_SIZE = 20
+ MARSHALLED_ID_END = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
)
diff --git a/plugins/analysis/types/addnode/packet.go b/plugins/analysis/types/addnode/packet.go
index 0fba847ffd1cb891db9ada1e0603052fe55a788d..d378b677f1ee33b96fd0dde80724901d476350bd 100644
--- a/plugins/analysis/types/addnode/packet.go
+++ b/plugins/analysis/types/addnode/packet.go
@@ -3,28 +3,28 @@ package addnode
import "github.com/pkg/errors"
type Packet struct {
- NodeId []byte
+ NodeId []byte
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
- return nil, errors.New("malformed add node packet")
- }
+ if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+ return nil, errors.New("malformed add node packet")
+ }
- unmarshalledPackage := &Packet{
- NodeId: make([]byte, MARSHALLED_ID_SIZE),
- }
+ unmarshalledPackage := &Packet{
+ NodeId: make([]byte, MARSHALLED_ID_SIZE),
+ }
- copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
+ copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
- return unmarshalledPackage, nil
+ return unmarshalledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
+ marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+ copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
- return marshalledPackage
+ return marshalledPackage
}
diff --git a/plugins/analysis/types/connectnodes/constants.go b/plugins/analysis/types/connectnodes/constants.go
index ce98f5747e3c3ef807ad71359ea9ed8c66e87908..564264dfc3f9b23dc71237d6f87d469c4011deeb 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
+ MARSHALLED_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
+ MARSHALLED_PACKET_HEADER_START = 0
+ MARSHALLED_PACKET_HEADER_SIZE = 1
+ MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_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
+ 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
- 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
+ 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
- MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
)
diff --git a/plugins/analysis/types/connectnodes/packet.go b/plugins/analysis/types/connectnodes/packet.go
index 19ff5cf9244efd6dad09213cefcbd0c779e335ce..954c560744f58d9931d3948bcc0ef777baa397dd 100644
--- a/plugins/analysis/types/connectnodes/packet.go
+++ b/plugins/analysis/types/connectnodes/packet.go
@@ -3,32 +3,32 @@ package connectnodes
import "github.com/pkg/errors"
type Packet struct {
- SourceId []byte
- TargetId []byte
+ SourceId []byte
+ TargetId []byte
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
- return nil, errors.New("malformed connect nodes packet")
- }
+ if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_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),
- }
+ unmarshalledPackage := &Packet{
+ SourceId: make([]byte, MARSHALLED_SOURCE_ID_SIZE),
+ TargetId: make([]byte, MARSHALLED_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(unmarshalledPackage.SourceId, data[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END])
+ copy(unmarshalledPackage.TargetId, data[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END])
- return unmarshalledPackage, nil
+ return unmarshalledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshalledPackage := make([]byte, MARSHALLED_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])
+ 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])
- return marshalledPackage
+ return marshalledPackage
}
diff --git a/plugins/analysis/types/disconnectnodes/constants.go b/plugins/analysis/types/disconnectnodes/constants.go
index 986d8aca56c0879e05b5ea318f2437baec2d535b..5145c9090ddc53e41e60e9dd57cfd1048bd91b85 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
+ MARSHALLED_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
+ MARSHALLED_PACKET_HEADER_START = 0
+ MARSHALLED_PACKET_HEADER_SIZE = 1
+ MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_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
+ 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
- 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
+ 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
- MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
)
diff --git a/plugins/analysis/types/disconnectnodes/packet.go b/plugins/analysis/types/disconnectnodes/packet.go
index 59b413d1a40917f5fb9964a0cf0ae0f3bd2a3c27..bf7086452f6229ddcb129e643df8c9278e1b7572 100644
--- a/plugins/analysis/types/disconnectnodes/packet.go
+++ b/plugins/analysis/types/disconnectnodes/packet.go
@@ -3,32 +3,32 @@ package disconnectnodes
import "github.com/pkg/errors"
type Packet struct {
- SourceId []byte
- TargetId []byte
+ SourceId []byte
+ TargetId []byte
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
- return nil, errors.New("malformed disconnect nodes packet")
- }
+ if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_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),
- }
+ unmarshalledPackage := &Packet{
+ SourceId: make([]byte, MARSHALLED_SOURCE_ID_SIZE),
+ TargetId: make([]byte, MARSHALLED_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(unmarshalledPackage.SourceId, data[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END])
+ copy(unmarshalledPackage.TargetId, data[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END])
- return unmarshalledPackage, nil
+ return unmarshalledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshalledPackage := make([]byte, MARSHALLED_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])
+ 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])
- return marshalledPackage
+ return marshalledPackage
}
diff --git a/plugins/analysis/types/ping/constants.go b/plugins/analysis/types/ping/constants.go
index 09141e175e733488fcd252dd50a837d1efc81cde..f3fd24bfe29b3abde21bdc786a77600c452e5916 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
+ MARSHALLED_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
+ MARSHALLED_PACKET_HEADER_START = 0
+ MARSHALLED_PACKET_HEADER_SIZE = 1
+ MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_PACKET_HEADER_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_PACKET_HEADER_END
)
diff --git a/plugins/analysis/types/ping/packet.go b/plugins/analysis/types/ping/packet.go
index 27fc47d8c6bf2e0fbeb6abce74bf8a3d8b34b4c0..89728d17e8c1eb0adb7aafdf41c9405dfd880475 100644
--- a/plugins/analysis/types/ping/packet.go
+++ b/plugins/analysis/types/ping/packet.go
@@ -2,22 +2,22 @@ package ping
import "github.com/pkg/errors"
-type Packet struct {}
+type Packet struct{}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[MARSHALLED_PACKET_HEADER_START] != MARSHALLED_PACKET_HEADER {
- return nil, errors.New("malformed ping packet")
- }
+ if len(data) < MARSHALLED_TOTAL_SIZE || data[MARSHALLED_PACKET_HEADER_START] != MARSHALLED_PACKET_HEADER {
+ return nil, errors.New("malformed ping packet")
+ }
- unmarshalledPacket := &Packet{}
+ unmarshalledPacket := &Packet{}
- return unmarshalledPacket, nil
+ return unmarshalledPacket, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+ marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- return marshalledPackage
-}
\ No newline at end of file
+ return marshalledPackage
+}
diff --git a/plugins/analysis/types/removenode/constants.go b/plugins/analysis/types/removenode/constants.go
index 91115401cff43c8d795de1b73e1738f985c55d38..269d4becb15ca1f2013f5651a03eda83888ce34f 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
+ MARSHALLED_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
+ MARSHALLED_PACKET_HEADER_START = 0
+ MARSHALLED_PACKET_HEADER_SIZE = 1
+ MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
- MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
- MARSHALLED_ID_SIZE = 20
- MARSHALLED_ID_END = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
+ MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
+ MARSHALLED_ID_SIZE = 20
+ MARSHALLED_ID_END = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
- MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
)
diff --git a/plugins/analysis/types/removenode/packet.go b/plugins/analysis/types/removenode/packet.go
index 52095b9bef3285eb0031fe05a3778af450018f33..504f3f3cb3550de7df8a356c4225d4f555f30ee0 100644
--- a/plugins/analysis/types/removenode/packet.go
+++ b/plugins/analysis/types/removenode/packet.go
@@ -3,29 +3,28 @@ package removenode
import "github.com/pkg/errors"
type Packet struct {
- NodeId []byte
+ NodeId []byte
}
func Unmarshal(data []byte) (*Packet, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
- return nil, errors.New("malformed remove node packet")
- }
+ if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+ return nil, errors.New("malformed remove node packet")
+ }
- unmarshalledPackage := &Packet{
- NodeId: make([]byte, MARSHALLED_ID_SIZE),
- }
+ unmarshalledPackage := &Packet{
+ NodeId: make([]byte, MARSHALLED_ID_SIZE),
+ }
- copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
+ copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
- return unmarshalledPackage, nil
+ return unmarshalledPackage, nil
}
func (packet *Packet) Marshal() []byte {
- marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+ marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
- marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
+ marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+ copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
- return marshalledPackage
+ return marshalledPackage
}
-
diff --git a/plugins/analysis/webinterface/httpserver/data_stream.go b/plugins/analysis/webinterface/httpserver/data_stream.go
index 296bbc3e90c18d7a15c71e950b091c312406c890..66f611279705543af71733b10c1aa6a54fcc5ea0 100644
--- a/plugins/analysis/webinterface/httpserver/data_stream.go
+++ b/plugins/analysis/webinterface/httpserver/data_stream.go
@@ -1,56 +1,57 @@
package httpserver
import (
- "fmt"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/analysis/server"
- "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/recordedevents"
- "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/types"
- "golang.org/x/net/websocket"
+ "fmt"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/analysis/server"
+ "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/recordedevents"
+ "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/types"
+ "golang.org/x/net/websocket"
)
func dataStream(ws *websocket.Conn) {
- func() {
- eventHandlers := &types.EventHandlers{
- AddNode: func(nodeId string) { fmt.Fprint(ws, "A"+nodeId) },
- RemoveNode: func(nodeId string) { fmt.Fprint(ws, "a"+nodeId) },
- ConnectNodes: func(sourceId string, targetId string) { fmt.Fprint(ws, "C"+sourceId+targetId) },
- DisconnectNodes: func(sourceId string, targetId string) { fmt.Fprint(ws, "c"+sourceId+targetId) },
- NodeOnline: func(nodeId string) { fmt.Fprint(ws, "O"+nodeId) },
- NodeOffline: func(nodeId string) { fmt.Fprint(ws, "o"+nodeId) },
- }
-
- addNodeClosure := events.NewClosure(eventHandlers.AddNode)
- removeNodeClosure := events.NewClosure(eventHandlers.RemoveNode)
- connectNodesClosure := events.NewClosure(eventHandlers.ConnectNodes)
- disconnectNodesClosure := events.NewClosure(eventHandlers.DisconnectNodes)
- nodeOnlineClosure := events.NewClosure(eventHandlers.NodeOnline)
- nodeOfflineClosure := events.NewClosure(eventHandlers.NodeOffline)
-
- server.Events.AddNode.Attach(addNodeClosure)
- server.Events.RemoveNode.Attach(removeNodeClosure)
- server.Events.ConnectNodes.Attach(connectNodesClosure)
- server.Events.DisconnectNodes.Attach(disconnectNodesClosure)
- server.Events.NodeOnline.Attach(nodeOnlineClosure)
- server.Events.NodeOffline.Attach(nodeOfflineClosure)
-
- go recordedevents.Replay(eventHandlers)
-
- buf := make([]byte, 1)
- readFromWebsocket:
- for {
- if _, err := ws.Read(buf); err != nil {
- break readFromWebsocket
- }
-
- fmt.Fprint(ws, "_")
- }
-
- server.Events.AddNode.Detach(addNodeClosure)
- server.Events.RemoveNode.Detach(removeNodeClosure)
- server.Events.ConnectNodes.Detach(connectNodesClosure)
- server.Events.DisconnectNodes.Detach(disconnectNodesClosure)
- server.Events.NodeOnline.Detach(nodeOnlineClosure)
- server.Events.NodeOffline.Detach(nodeOfflineClosure)
- }()
+ func() {
+ eventHandlers := &types.EventHandlers{
+ AddNode: func(nodeId string) { fmt.Fprint(ws, "A"+nodeId) },
+ RemoveNode: func(nodeId string) { fmt.Fprint(ws, "a"+nodeId) },
+ ConnectNodes: func(sourceId string, targetId string) { fmt.Fprint(ws, "C"+sourceId+targetId) },
+ DisconnectNodes: func(sourceId string, targetId string) { fmt.Fprint(ws, "c"+sourceId+targetId) },
+ NodeOnline: func(nodeId string) { fmt.Fprint(ws, "O"+nodeId) },
+ NodeOffline: func(nodeId string) { fmt.Fprint(ws, "o"+nodeId) },
+ }
+
+ addNodeClosure := events.NewClosure(eventHandlers.AddNode)
+ removeNodeClosure := events.NewClosure(eventHandlers.RemoveNode)
+ connectNodesClosure := events.NewClosure(eventHandlers.ConnectNodes)
+ disconnectNodesClosure := events.NewClosure(eventHandlers.DisconnectNodes)
+ nodeOnlineClosure := events.NewClosure(eventHandlers.NodeOnline)
+ nodeOfflineClosure := events.NewClosure(eventHandlers.NodeOffline)
+
+ server.Events.AddNode.Attach(addNodeClosure)
+ server.Events.RemoveNode.Attach(removeNodeClosure)
+ server.Events.ConnectNodes.Attach(connectNodesClosure)
+ server.Events.DisconnectNodes.Attach(disconnectNodesClosure)
+ server.Events.NodeOnline.Attach(nodeOnlineClosure)
+ server.Events.NodeOffline.Attach(nodeOfflineClosure)
+
+ go recordedevents.Replay(eventHandlers)
+
+ buf := make([]byte, 1)
+ readFromWebsocket:
+ for {
+ if _, err := ws.Read(buf); err != nil {
+ break readFromWebsocket
+ }
+
+ fmt.Fprint(ws, "_")
+ }
+
+ server.Events.AddNode.Detach(addNodeClosure)
+ server.Events.RemoveNode.Detach(removeNodeClosure)
+ server.Events.ConnectNodes.Detach(connectNodesClosure)
+ server.Events.DisconnectNodes.Detach(disconnectNodesClosure)
+ server.Events.NodeOnline.Detach(nodeOnlineClosure)
+ server.Events.NodeOffline.Detach(nodeOfflineClosure)
+ }()
}
diff --git a/plugins/analysis/webinterface/httpserver/index.go b/plugins/analysis/webinterface/httpserver/index.go
index e1da2e2623a7eee28cb34a150049b96d4910b51e..b0d791ebd5253e7684653214d744f8ae5fae7f95 100644
--- a/plugins/analysis/webinterface/httpserver/index.go
+++ b/plugins/analysis/webinterface/httpserver/index.go
@@ -1,12 +1,12 @@
package httpserver
import (
- "fmt"
- "net/http"
+ "fmt"
+ "net/http"
)
func index(w http.ResponseWriter, r *http.Request) {
- fmt.Fprintf(w, `<head>
+ fmt.Fprintf(w, `<head>
<style> body { margin: 0; } </style>
<script src="https://unpkg.com/3d-force-graph"></script>
diff --git a/plugins/analysis/webinterface/httpserver/plugin.go b/plugins/analysis/webinterface/httpserver/plugin.go
index 44d844cae1886f3ba5cfd27390578854f09e4f28..6f5edbb8ea736c8be04d5176ce5bf9e24f2b324d 100644
--- a/plugins/analysis/webinterface/httpserver/plugin.go
+++ b/plugins/analysis/webinterface/httpserver/plugin.go
@@ -1,37 +1,38 @@
package httpserver
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "golang.org/x/net/context"
- "golang.org/x/net/websocket"
- "net/http"
- "time"
+ "net/http"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "golang.org/x/net/context"
+ "golang.org/x/net/websocket"
)
var (
- httpServer *http.Server
- router *http.ServeMux
+ httpServer *http.Server
+ router *http.ServeMux
)
func Configure(plugin *node.Plugin) {
- router = http.NewServeMux()
- httpServer = &http.Server{Addr: ":80", Handler: router}
+ router = http.NewServeMux()
+ httpServer = &http.Server{Addr: ":80", Handler: router}
- router.Handle("/datastream", websocket.Handler(dataStream))
- router.HandleFunc("/", index)
+ router.Handle("/datastream", websocket.Handler(dataStream))
+ router.HandleFunc("/", index)
- daemon.Events.Shutdown.Attach(events.NewClosure(func() {
- ctx, cancel := context.WithTimeout(context.Background(), 0 * time.Second)
- defer cancel()
+ daemon.Events.Shutdown.Attach(events.NewClosure(func() {
+ ctx, cancel := context.WithTimeout(context.Background(), 0*time.Second)
+ defer cancel()
- httpServer.Shutdown(ctx)
- }))
+ httpServer.Shutdown(ctx)
+ }))
}
func Run(plugin *node.Plugin) {
- daemon.BackgroundWorker(func() {
- httpServer.ListenAndServe()
- })
+ daemon.BackgroundWorker(func() {
+ httpServer.ListenAndServe()
+ })
}
diff --git a/plugins/analysis/webinterface/plugin.go b/plugins/analysis/webinterface/plugin.go
index ef71b18c87919f6c120022f102807a006bd54246..9719472c2ad8253e61a1176ea03f3cf1d6f395d2 100644
--- a/plugins/analysis/webinterface/plugin.go
+++ b/plugins/analysis/webinterface/plugin.go
@@ -1,16 +1,16 @@
package webinterface
import (
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/httpserver"
- "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/recordedevents"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/httpserver"
+ "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/recordedevents"
)
func Configure(plugin *node.Plugin) {
- httpserver.Configure(plugin)
- recordedevents.Configure(plugin)
+ httpserver.Configure(plugin)
+ recordedevents.Configure(plugin)
}
func Run(plugin *node.Plugin) {
- httpserver.Run(plugin)
+ httpserver.Run(plugin)
}
diff --git a/plugins/analysis/webinterface/recordedevents/recorded_events.go b/plugins/analysis/webinterface/recordedevents/recorded_events.go
index f9c23b200379c3cb0e6ffa25b1c9896f79ae43e0..19aa2035b7b42e95ffe0eb2d9d770a1e46eeb25c 100644
--- a/plugins/analysis/webinterface/recordedevents/recorded_events.go
+++ b/plugins/analysis/webinterface/recordedevents/recorded_events.go
@@ -1,11 +1,12 @@
package recordedevents
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/analysis/server"
- "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/types"
- "sync"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/analysis/server"
+ "github.com/iotaledger/goshimmer/plugins/analysis/webinterface/types"
)
var recordedEvents = make([]types.EventHandlersConsumer, 0)
@@ -16,75 +17,75 @@ var links = make(map[string]map[string]bool)
var lock sync.Mutex
func Configure(plugin *node.Plugin) {
- server.Events.AddNode.Attach(events.NewClosure(func(nodeId string) {
- if _, exists := nodes[nodeId]; !exists {
- lock.Lock()
- defer lock.Unlock()
-
- if _, exists := nodes[nodeId]; !exists {
- nodes[nodeId] = false
- }
- }
- }))
-
- server.Events.RemoveNode.Attach(events.NewClosure(func(nodeId string) {
- lock.Lock()
- defer lock.Unlock()
-
- delete(nodes, nodeId)
- }))
-
- server.Events.NodeOnline.Attach(events.NewClosure(func(nodeId string) {
- lock.Lock()
- defer lock.Unlock()
-
- nodes[nodeId] = true
- }))
-
- server.Events.NodeOffline.Attach(events.NewClosure(func(nodeId string) {
- lock.Lock()
- defer lock.Unlock()
-
- nodes[nodeId] = false
- }))
-
- server.Events.ConnectNodes.Attach(events.NewClosure(func(sourceId string, targetId string) {
- lock.Lock()
- defer lock.Unlock()
-
- connectionMap, connectionMapExists := links[sourceId]
- if !connectionMapExists {
- connectionMap = make(map[string]bool)
-
- links[sourceId] = connectionMap
- }
- connectionMap[targetId] = true
- }))
-
- server.Events.DisconnectNodes.Attach(events.NewClosure(func(sourceId string, targetId string) {
- lock.Lock()
- defer lock.Unlock()
-
- connectionMap, connectionMapExists := links[sourceId]
- if connectionMapExists {
- delete(connectionMap, targetId)
- }
- }))
+ server.Events.AddNode.Attach(events.NewClosure(func(nodeId string) {
+ if _, exists := nodes[nodeId]; !exists {
+ lock.Lock()
+ defer lock.Unlock()
+
+ if _, exists := nodes[nodeId]; !exists {
+ nodes[nodeId] = false
+ }
+ }
+ }))
+
+ server.Events.RemoveNode.Attach(events.NewClosure(func(nodeId string) {
+ lock.Lock()
+ defer lock.Unlock()
+
+ delete(nodes, nodeId)
+ }))
+
+ server.Events.NodeOnline.Attach(events.NewClosure(func(nodeId string) {
+ lock.Lock()
+ defer lock.Unlock()
+
+ nodes[nodeId] = true
+ }))
+
+ server.Events.NodeOffline.Attach(events.NewClosure(func(nodeId string) {
+ lock.Lock()
+ defer lock.Unlock()
+
+ nodes[nodeId] = false
+ }))
+
+ server.Events.ConnectNodes.Attach(events.NewClosure(func(sourceId string, targetId string) {
+ lock.Lock()
+ defer lock.Unlock()
+
+ connectionMap, connectionMapExists := links[sourceId]
+ if !connectionMapExists {
+ connectionMap = make(map[string]bool)
+
+ links[sourceId] = connectionMap
+ }
+ connectionMap[targetId] = true
+ }))
+
+ server.Events.DisconnectNodes.Attach(events.NewClosure(func(sourceId string, targetId string) {
+ lock.Lock()
+ defer lock.Unlock()
+
+ connectionMap, connectionMapExists := links[sourceId]
+ if connectionMapExists {
+ delete(connectionMap, targetId)
+ }
+ }))
}
func Replay(handlers *types.EventHandlers) {
- for nodeId, online := range nodes {
- handlers.AddNode(nodeId)
- if online {
- handlers.NodeOnline(nodeId)
- } else {
- handlers.NodeOffline(nodeId)
- }
- }
-
- for sourceId, targetMap := range links {
- for targetId, _ := range targetMap {
- handlers.ConnectNodes(sourceId, targetId)
- }
- }
+ for nodeId, online := range nodes {
+ handlers.AddNode(nodeId)
+ if online {
+ handlers.NodeOnline(nodeId)
+ } else {
+ handlers.NodeOffline(nodeId)
+ }
+ }
+
+ for sourceId, targetMap := range links {
+ for targetId, _ := range targetMap {
+ handlers.ConnectNodes(sourceId, targetId)
+ }
+ }
}
diff --git a/plugins/analysis/webinterface/types/types.go b/plugins/analysis/webinterface/types/types.go
index 3f3ebed88657773ea01d8902028302a037f9b959..475da9ad04a9b8b575313dea63f66d1108a2389f 100644
--- a/plugins/analysis/webinterface/types/types.go
+++ b/plugins/analysis/webinterface/types/types.go
@@ -1,12 +1,12 @@
package types
type EventHandlers = struct {
- AddNode func(nodeId string)
- RemoveNode func(nodeId string)
- ConnectNodes func(sourceId string, targetId string)
- DisconnectNodes func(sourceId string, targetId string)
- NodeOnline func(nodeId string)
- NodeOffline func(nodeId string)
+ AddNode func(nodeId string)
+ RemoveNode func(nodeId string)
+ ConnectNodes func(sourceId string, targetId string)
+ DisconnectNodes func(sourceId string, targetId string)
+ NodeOnline func(nodeId string)
+ NodeOffline func(nodeId string)
}
type EventHandlersConsumer = func(handler *EventHandlers)
diff --git a/plugins/autopeering/instances/acceptedneighbors/distance.go b/plugins/autopeering/instances/acceptedneighbors/distance.go
index 0dd0aac9926446118fdba415e764b57f5e708cdf..a5c9f3d74884e04164f52624207c87656f43361b 100644
--- a/plugins/autopeering/instances/acceptedneighbors/distance.go
+++ b/plugins/autopeering/instances/acceptedneighbors/distance.go
@@ -1,32 +1,32 @@
package acceptedneighbors
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "hash/fnv"
+ "hash/fnv"
+
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
var DISTANCE = func(anchor *peer.Peer) func(p *peer.Peer) uint64 {
- return func(p *peer.Peer) uint64 {
- saltedIdentifier := make([]byte, len(anchor.Identity.Identifier) + len(saltmanager.PRIVATE_SALT.Bytes))
- copy(saltedIdentifier[0:], anchor.Identity.Identifier)
- copy(saltedIdentifier[len(anchor.Identity.Identifier):], saltmanager.PRIVATE_SALT.Bytes)
+ return func(p *peer.Peer) uint64 {
+ saltedIdentifier := make([]byte, len(anchor.Identity.Identifier)+len(saltmanager.PRIVATE_SALT.Bytes))
+ copy(saltedIdentifier[0:], anchor.Identity.Identifier)
+ copy(saltedIdentifier[len(anchor.Identity.Identifier):], saltmanager.PRIVATE_SALT.Bytes)
- return hash(saltedIdentifier) ^ hash(p.Identity.Identifier)
- }
+ return hash(saltedIdentifier) ^ hash(p.Identity.Identifier)
+ }
}
var OWN_DISTANCE func(p *peer.Peer) uint64
func configureOwnDistance() {
- OWN_DISTANCE = DISTANCE(ownpeer.INSTANCE)
+ OWN_DISTANCE = DISTANCE(ownpeer.INSTANCE)
}
func hash(data []byte) uint64 {
- h := fnv.New64a()
- h.Write(data)
+ h := fnv.New64a()
+ h.Write(data)
- return h.Sum64()
+ return h.Sum64()
}
-
diff --git a/plugins/autopeering/instances/acceptedneighbors/furthest_neighbor.go b/plugins/autopeering/instances/acceptedneighbors/furthest_neighbor.go
index 462e9d087619262b6f90e99b3d3b8a1054beead0..3a62d2ce8933cd9c753e85da98f9c97c4632379e 100644
--- a/plugins/autopeering/instances/acceptedneighbors/furthest_neighbor.go
+++ b/plugins/autopeering/instances/acceptedneighbors/furthest_neighbor.go
@@ -1,9 +1,10 @@
package acceptedneighbors
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "sync"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
var FURTHEST_NEIGHBOR *peer.Peer
@@ -13,32 +14,32 @@ var FURTHEST_NEIGHBOR_DISTANCE = uint64(0)
var FurthestNeighborLock sync.RWMutex
func configureFurthestNeighbor() {
- INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
- FurthestNeighborLock.Lock()
- defer FurthestNeighborLock.Unlock()
-
- updateFurthestNeighbor(p)
- }))
-
- INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
- FurthestNeighborLock.Lock()
- defer FurthestNeighborLock.Unlock()
-
- if p.Identity.StringIdentifier == FURTHEST_NEIGHBOR.Identity.StringIdentifier {
- FURTHEST_NEIGHBOR_DISTANCE = uint64(0)
- FURTHEST_NEIGHBOR = nil
-
- for _, furthestNeighborCandidate := range INSTANCE.Peers {
- updateFurthestNeighbor(furthestNeighborCandidate)
- }
- }
- }))
+ INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
+ FurthestNeighborLock.Lock()
+ defer FurthestNeighborLock.Unlock()
+
+ updateFurthestNeighbor(p)
+ }))
+
+ INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
+ FurthestNeighborLock.Lock()
+ defer FurthestNeighborLock.Unlock()
+
+ if p.Identity.StringIdentifier == FURTHEST_NEIGHBOR.Identity.StringIdentifier {
+ FURTHEST_NEIGHBOR_DISTANCE = uint64(0)
+ FURTHEST_NEIGHBOR = nil
+
+ for _, furthestNeighborCandidate := range INSTANCE.Peers {
+ updateFurthestNeighbor(furthestNeighborCandidate)
+ }
+ }
+ }))
}
func updateFurthestNeighbor(p *peer.Peer) {
- distance := OWN_DISTANCE(p)
- if distance > FURTHEST_NEIGHBOR_DISTANCE {
- FURTHEST_NEIGHBOR = p
- FURTHEST_NEIGHBOR_DISTANCE = distance
- }
+ distance := OWN_DISTANCE(p)
+ if distance > FURTHEST_NEIGHBOR_DISTANCE {
+ FURTHEST_NEIGHBOR = p
+ FURTHEST_NEIGHBOR_DISTANCE = distance
+ }
}
diff --git a/plugins/autopeering/instances/acceptedneighbors/plugin.go b/plugins/autopeering/instances/acceptedneighbors/plugin.go
index 13cd3a858cb20feeed811ea6502f5177a43802ba..9870c182bb37f7d7e3cb5dd8c6a58d5c6086ffc8 100644
--- a/plugins/autopeering/instances/acceptedneighbors/plugin.go
+++ b/plugins/autopeering/instances/acceptedneighbors/plugin.go
@@ -3,6 +3,6 @@ package acceptedneighbors
import "github.com/iotaledger/goshimmer/packages/node"
func Configure(plugin *node.Plugin) {
- configureOwnDistance()
- configureFurthestNeighbor()
+ configureOwnDistance()
+ configureFurthestNeighbor()
}
diff --git a/plugins/autopeering/instances/chosenneighbors/candidates.go b/plugins/autopeering/instances/chosenneighbors/candidates.go
index e26edf16c4a0ce14f6e695a21116255a24aedf41..a58ae6dfa21933a2ade227a2f5c27a908743476f 100644
--- a/plugins/autopeering/instances/chosenneighbors/candidates.go
+++ b/plugins/autopeering/instances/chosenneighbors/candidates.go
@@ -1,19 +1,19 @@
package chosenneighbors
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
)
var CANDIDATES peerlist.PeerList
func configureCandidates() {
- updateNeighborCandidates()
+ updateNeighborCandidates()
- neighborhood.Events.Update.Attach(updateNeighborCandidates)
+ neighborhood.Events.Update.Attach(updateNeighborCandidates)
}
func updateNeighborCandidates() {
- CANDIDATES = neighborhood.LIST_INSTANCE.Sort(DISTANCE(ownpeer.INSTANCE))
+ CANDIDATES = neighborhood.LIST_INSTANCE.Sort(DISTANCE(ownpeer.INSTANCE))
}
diff --git a/plugins/autopeering/instances/chosenneighbors/distance.go b/plugins/autopeering/instances/chosenneighbors/distance.go
index cd06265a5dcbe181eb598486ba4b4ffaf6d3d870..26b7ff2dadc9eb47dadfad61361619d5b5eb4ff1 100644
--- a/plugins/autopeering/instances/chosenneighbors/distance.go
+++ b/plugins/autopeering/instances/chosenneighbors/distance.go
@@ -1,30 +1,31 @@
package chosenneighbors
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "hash/fnv"
+ "hash/fnv"
+
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
var DISTANCE = func(anchor *peer.Peer) func(p *peer.Peer) uint64 {
- return func(p *peer.Peer) uint64 {
- saltedIdentifier := make([]byte, len(anchor.Identity.Identifier) + len(anchor.Salt.Bytes))
- copy(saltedIdentifier[0:], anchor.Identity.Identifier)
- copy(saltedIdentifier[len(anchor.Identity.Identifier):], anchor.Salt.Bytes)
+ return func(p *peer.Peer) uint64 {
+ saltedIdentifier := make([]byte, len(anchor.Identity.Identifier)+len(anchor.Salt.Bytes))
+ copy(saltedIdentifier[0:], anchor.Identity.Identifier)
+ copy(saltedIdentifier[len(anchor.Identity.Identifier):], anchor.Salt.Bytes)
- return hash(anchor.Identity.Identifier) ^ hash(p.Identity.Identifier)
- }
+ return hash(anchor.Identity.Identifier) ^ hash(p.Identity.Identifier)
+ }
}
var OWN_DISTANCE func(p *peer.Peer) uint64
func configureOwnDistance() {
- OWN_DISTANCE = DISTANCE(ownpeer.INSTANCE)
+ OWN_DISTANCE = DISTANCE(ownpeer.INSTANCE)
}
func hash(data []byte) uint64 {
- h := fnv.New64a()
- h.Write(data)
+ h := fnv.New64a()
+ h.Write(data)
- return h.Sum64()
+ return h.Sum64()
}
diff --git a/plugins/autopeering/instances/chosenneighbors/furthest_neighbor.go b/plugins/autopeering/instances/chosenneighbors/furthest_neighbor.go
index 7767ca0b5c480c5ebfba2e5da9e9a97d58d43873..0dc9a4d0b0a275f22aee5960746313ef343a78a2 100644
--- a/plugins/autopeering/instances/chosenneighbors/furthest_neighbor.go
+++ b/plugins/autopeering/instances/chosenneighbors/furthest_neighbor.go
@@ -1,9 +1,10 @@
package chosenneighbors
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "sync"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
var FURTHEST_NEIGHBOR *peer.Peer
@@ -13,32 +14,32 @@ var FURTHEST_NEIGHBOR_DISTANCE = uint64(0)
var FurthestNeighborLock sync.RWMutex
func configureFurthestNeighbor() {
- INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
- FurthestNeighborLock.Lock()
- defer FurthestNeighborLock.Unlock()
-
- distance := OWN_DISTANCE(p)
- if distance > FURTHEST_NEIGHBOR_DISTANCE {
- FURTHEST_NEIGHBOR = p
- FURTHEST_NEIGHBOR_DISTANCE = distance
- }
- }))
-
- INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
- FurthestNeighborLock.Lock()
- defer FurthestNeighborLock.Unlock()
-
- if p == FURTHEST_NEIGHBOR {
- FURTHEST_NEIGHBOR_DISTANCE = uint64(0)
- FURTHEST_NEIGHBOR = nil
-
- for _, furthestNeighborCandidate := range INSTANCE.Peers {
- distance := OWN_DISTANCE(furthestNeighborCandidate)
- if distance > FURTHEST_NEIGHBOR_DISTANCE {
- FURTHEST_NEIGHBOR = furthestNeighborCandidate
- FURTHEST_NEIGHBOR_DISTANCE = distance
- }
- }
- }
- }))
-}
\ No newline at end of file
+ INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
+ FurthestNeighborLock.Lock()
+ defer FurthestNeighborLock.Unlock()
+
+ distance := OWN_DISTANCE(p)
+ if distance > FURTHEST_NEIGHBOR_DISTANCE {
+ FURTHEST_NEIGHBOR = p
+ FURTHEST_NEIGHBOR_DISTANCE = distance
+ }
+ }))
+
+ INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
+ FurthestNeighborLock.Lock()
+ defer FurthestNeighborLock.Unlock()
+
+ if p == FURTHEST_NEIGHBOR {
+ FURTHEST_NEIGHBOR_DISTANCE = uint64(0)
+ FURTHEST_NEIGHBOR = nil
+
+ for _, furthestNeighborCandidate := range INSTANCE.Peers {
+ distance := OWN_DISTANCE(furthestNeighborCandidate)
+ if distance > FURTHEST_NEIGHBOR_DISTANCE {
+ FURTHEST_NEIGHBOR = furthestNeighborCandidate
+ FURTHEST_NEIGHBOR_DISTANCE = distance
+ }
+ }
+ }
+ }))
+}
diff --git a/plugins/autopeering/instances/chosenneighbors/plugin.go b/plugins/autopeering/instances/chosenneighbors/plugin.go
index d28bc57dd8a13352b15f4137396791661697d110..0e1224fc75ae8dbb594d1938d14c442e04832214 100644
--- a/plugins/autopeering/instances/chosenneighbors/plugin.go
+++ b/plugins/autopeering/instances/chosenneighbors/plugin.go
@@ -1,11 +1,11 @@
package chosenneighbors
import (
- "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/node"
)
func Configure(plugin *node.Plugin) {
- configureCandidates()
- configureOwnDistance()
- configureFurthestNeighbor()
+ configureCandidates()
+ configureOwnDistance()
+ configureFurthestNeighbor()
}
diff --git a/plugins/autopeering/instances/entrynodes/instance.go b/plugins/autopeering/instances/entrynodes/instance.go
index 51d1e220c78f66813148e818745f16347341fb03..e6bb4c8919c16a4ce8354182153464551ed895d3 100644
--- a/plugins/autopeering/instances/entrynodes/instance.go
+++ b/plugins/autopeering/instances/entrynodes/instance.go
@@ -1,84 +1,85 @@
package entrynodes
import (
- "encoding/hex"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
- "net"
- "strconv"
- "strings"
+ "encoding/hex"
+ "net"
+ "strconv"
+ "strings"
+
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
)
var INSTANCE peerlist.PeerList
func Configure(node *node.Plugin) {
- INSTANCE = parseEntryNodes()
+ INSTANCE = parseEntryNodes()
}
func parseEntryNodes() peerlist.PeerList {
- result := make(peerlist.PeerList, 0)
+ result := make(peerlist.PeerList, 0)
- for _, entryNodeDefinition := range strings.Fields(*parameters.ENTRY_NODES.Value) {
- if entryNodeDefinition == "" {
- continue
- }
+ for _, entryNodeDefinition := range strings.Fields(*parameters.ENTRY_NODES.Value) {
+ if entryNodeDefinition == "" {
+ continue
+ }
- entryNode := &peer.Peer{
- Identity: nil,
- }
+ entryNode := &peer.Peer{
+ Identity: nil,
+ }
- identityBits := strings.Split(entryNodeDefinition, "@")
- if len(identityBits) != 2 {
- panic("error while parsing identity of entry node: " + entryNodeDefinition)
- }
- if decodedIdentifier, err := hex.DecodeString(identityBits[0]); err != nil {
- panic("error while parsing identity of entry node: " + entryNodeDefinition)
- } else {
- entryNode.Identity = &identity.Identity{
- Identifier: decodedIdentifier,
- StringIdentifier: identityBits[0],
- }
- }
+ identityBits := strings.Split(entryNodeDefinition, "@")
+ if len(identityBits) != 2 {
+ panic("error while parsing identity of entry node: " + entryNodeDefinition)
+ }
+ if decodedIdentifier, err := hex.DecodeString(identityBits[0]); err != nil {
+ panic("error while parsing identity of entry node: " + entryNodeDefinition)
+ } else {
+ entryNode.Identity = &identity.Identity{
+ Identifier: decodedIdentifier,
+ StringIdentifier: identityBits[0],
+ }
+ }
- addressBits := strings.Split(identityBits[1], ":")
- switch len(addressBits) {
- case 2:
- host := addressBits[0]
- port, err := strconv.Atoi(addressBits[1])
- if err != nil {
- panic("error while parsing port of entry in list of entry nodes")
- }
+ addressBits := strings.Split(identityBits[1], ":")
+ switch len(addressBits) {
+ case 2:
+ host := addressBits[0]
+ port, err := strconv.Atoi(addressBits[1])
+ if err != nil {
+ panic("error while parsing port of entry in list of entry nodes")
+ }
- ip := net.ParseIP(host)
- if ip == nil {
- panic("error while parsing ip of entry in list of entry nodes")
- }
+ ip := net.ParseIP(host)
+ if ip == nil {
+ panic("error while parsing ip of entry in list of entry nodes")
+ }
- entryNode.Address = ip
- entryNode.PeeringPort = uint16(port)
- case 6:
- host := strings.Join(addressBits[:5], ":")
- port, err := strconv.Atoi(addressBits[5])
- if err != nil {
- panic("error while parsing port of entry in list of entry nodes")
- }
+ entryNode.Address = ip
+ entryNode.PeeringPort = uint16(port)
+ case 6:
+ host := strings.Join(addressBits[:5], ":")
+ port, err := strconv.Atoi(addressBits[5])
+ if err != nil {
+ panic("error while parsing port of entry in list of entry nodes")
+ }
- ip := net.ParseIP(host)
- if ip == nil {
- panic("error while parsing ip of entry in list of entry nodes")
- }
+ ip := net.ParseIP(host)
+ if ip == nil {
+ panic("error while parsing ip of entry in list of entry nodes")
+ }
- entryNode.Address = ip
- entryNode.PeeringPort = uint16(port)
- default:
- panic("invalid entry in list of trusted entry nodes: " + entryNodeDefinition)
- }
+ entryNode.Address = ip
+ entryNode.PeeringPort = uint16(port)
+ default:
+ panic("invalid entry in list of trusted entry nodes: " + entryNodeDefinition)
+ }
- result = append(result, entryNode)
- }
+ result = append(result, entryNode)
+ }
- return result
+ return result
}
diff --git a/plugins/autopeering/instances/neighborhood/events.go b/plugins/autopeering/instances/neighborhood/events.go
index 3796ec2d60ec93d9bcd213c0e54fa54e0a63facd..b748822f6067a9cd1317e1e9407556d8b616dd90 100644
--- a/plugins/autopeering/instances/neighborhood/events.go
+++ b/plugins/autopeering/instances/neighborhood/events.go
@@ -3,29 +3,29 @@ package neighborhood
import "reflect"
var Events = moduleEvents{
- Update: &callbackEvent{make(map[uintptr]Callback)},
+ Update: &callbackEvent{make(map[uintptr]Callback)},
}
type moduleEvents struct {
- Update *callbackEvent
+ Update *callbackEvent
}
type callbackEvent struct {
- callbacks map[uintptr]Callback
+ callbacks map[uintptr]Callback
}
func (this *callbackEvent) Attach(callback Callback) {
- this.callbacks[reflect.ValueOf(callback).Pointer()] = callback
+ this.callbacks[reflect.ValueOf(callback).Pointer()] = callback
}
func (this *callbackEvent) Detach(callback Callback) {
- delete(this.callbacks, reflect.ValueOf(callback).Pointer())
+ delete(this.callbacks, reflect.ValueOf(callback).Pointer())
}
func (this *callbackEvent) Trigger() {
- for _, callback := range this.callbacks {
- callback()
- }
+ for _, callback := range this.callbacks {
+ callback()
+ }
}
type Callback = func()
diff --git a/plugins/autopeering/instances/neighborhood/instance.go b/plugins/autopeering/instances/neighborhood/instance.go
index 0df5bb00a1d27c0b318ea9677fad05afa1fd099b..5a94afd36cdc4f2906a51593c6b2f5ea06e7aa18 100644
--- a/plugins/autopeering/instances/neighborhood/instance.go
+++ b/plugins/autopeering/instances/neighborhood/instance.go
@@ -1,15 +1,16 @@
package neighborhood
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/timeutil"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/outgoingrequest"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerregister"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/timeutil"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/outgoingrequest"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerregister"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
)
var INSTANCE *peerregister.PeerRegister
@@ -19,33 +20,33 @@ var LIST_INSTANCE peerlist.PeerList
// Selects a fixed neighborhood from all known peers - this allows nodes to "stay in the same circles" that share their
// view on the ledger an is a preparation for economic clustering
var NEIGHBORHOOD_SELECTOR = func(this *peerregister.PeerRegister, req *request.Request) *peerregister.PeerRegister {
- filteredPeers := peerregister.New()
- for id, peer := range this.Peers {
- filteredPeers.Peers[id] = peer
- }
+ filteredPeers := peerregister.New()
+ for id, peer := range this.Peers {
+ filteredPeers.Peers[id] = peer
+ }
- return filteredPeers
+ return filteredPeers
}
var lastUpdate = time.Now()
func Configure(plugin *node.Plugin) {
- updateNeighborHood()
+ updateNeighborHood()
}
func Run(plugin *node.Plugin) {
- daemon.BackgroundWorker(func() {
- timeutil.Ticker(updateNeighborHood, 1 * time.Second)
- })
+ daemon.BackgroundWorker(func() {
+ timeutil.Ticker(updateNeighborHood, 1*time.Second)
+ })
}
func updateNeighborHood() {
- if INSTANCE == nil || float64(len(INSTANCE.Peers)) * 1.2 <= float64(len(knownpeers.INSTANCE.Peers)) || lastUpdate.Before(time.Now().Add(-300 * time.Second)) {
- INSTANCE = knownpeers.INSTANCE.Filter(NEIGHBORHOOD_SELECTOR, outgoingrequest.INSTANCE)
- LIST_INSTANCE = INSTANCE.List()
+ if INSTANCE == nil || float64(len(INSTANCE.Peers))*1.2 <= float64(len(knownpeers.INSTANCE.Peers)) || lastUpdate.Before(time.Now().Add(-300*time.Second)) {
+ INSTANCE = knownpeers.INSTANCE.Filter(NEIGHBORHOOD_SELECTOR, outgoingrequest.INSTANCE)
+ LIST_INSTANCE = INSTANCE.List()
- lastUpdate = time.Now()
+ lastUpdate = time.Now()
- Events.Update.Trigger()
- }
+ Events.Update.Trigger()
+ }
}
diff --git a/plugins/autopeering/instances/outgoingrequest/instance.go b/plugins/autopeering/instances/outgoingrequest/instance.go
index 1ffc8b96de6567113fd5523b4a037951d5b615d6..6fdf7a79e31f3efc999741703a7483f2384092eb 100644
--- a/plugins/autopeering/instances/outgoingrequest/instance.go
+++ b/plugins/autopeering/instances/outgoingrequest/instance.go
@@ -1,23 +1,23 @@
package outgoingrequest
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
)
var INSTANCE *request.Request
func Configure(plugin *node.Plugin) {
- INSTANCE = &request.Request{
- Issuer: ownpeer.INSTANCE,
- }
- INSTANCE.Sign()
+ INSTANCE = &request.Request{
+ Issuer: ownpeer.INSTANCE,
+ }
+ INSTANCE.Sign()
- saltmanager.Events.UpdatePublicSalt.Attach(events.NewClosure(func(salt *salt.Salt) {
- INSTANCE.Sign()
- }))
+ saltmanager.Events.UpdatePublicSalt.Attach(events.NewClosure(func(salt *salt.Salt) {
+ INSTANCE.Sign()
+ }))
}
diff --git a/plugins/autopeering/instances/ownpeer/instance.go b/plugins/autopeering/instances/ownpeer/instance.go
index 558491adfe34ca937edac419608b37bfd4dd1ed0..cc6909001171bc86a9c60a6b330d01e831879a99 100644
--- a/plugins/autopeering/instances/ownpeer/instance.go
+++ b/plugins/autopeering/instances/ownpeer/instance.go
@@ -1,23 +1,24 @@
package ownpeer
import (
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
- "github.com/iotaledger/goshimmer/plugins/gossip"
- "net"
+ "net"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/gossip"
)
var INSTANCE *peer.Peer
func Configure(plugin *node.Plugin) {
- INSTANCE = &peer.Peer{
- Identity: accountability.OwnId(),
- PeeringPort: uint16(*parameters.PORT.Value),
- GossipPort: uint16(*gossip.PORT.Value),
- Address: net.IPv4(0, 0, 0, 0),
- Salt: saltmanager.PUBLIC_SALT,
- }
+ INSTANCE = &peer.Peer{
+ Identity: accountability.OwnId(),
+ PeeringPort: uint16(*parameters.PORT.Value),
+ GossipPort: uint16(*gossip.PORT.Value),
+ Address: net.IPv4(0, 0, 0, 0),
+ Salt: saltmanager.PUBLIC_SALT,
+ }
}
diff --git a/plugins/autopeering/instances/plugin.go b/plugins/autopeering/instances/plugin.go
index ee110e249ec615bbab0b86e52c485640b5646ac1..ed02fdf6abf9db47f53daa712f406ecb36578883 100644
--- a/plugins/autopeering/instances/plugin.go
+++ b/plugins/autopeering/instances/plugin.go
@@ -1,26 +1,26 @@
package instances
import (
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/entrynodes"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/outgoingrequest"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/entrynodes"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/outgoingrequest"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
)
func Configure(plugin *node.Plugin) {
- ownpeer.Configure(plugin)
- entrynodes.Configure(plugin)
- knownpeers.Configure(plugin)
- neighborhood.Configure(plugin)
- outgoingrequest.Configure(plugin)
- chosenneighbors.Configure(plugin)
- acceptedneighbors.Configure(plugin)
+ ownpeer.Configure(plugin)
+ entrynodes.Configure(plugin)
+ knownpeers.Configure(plugin)
+ neighborhood.Configure(plugin)
+ outgoingrequest.Configure(plugin)
+ chosenneighbors.Configure(plugin)
+ acceptedneighbors.Configure(plugin)
}
func Run(plugin *node.Plugin) {
- neighborhood.Run(plugin)
+ neighborhood.Run(plugin)
}
diff --git a/plugins/autopeering/parameters/parameters.go b/plugins/autopeering/parameters/parameters.go
index 092ff6f452489a50617af06abfb2188057889be4..7f365c60d81efae5894574dd762f042a811c39d9 100644
--- a/plugins/autopeering/parameters/parameters.go
+++ b/plugins/autopeering/parameters/parameters.go
@@ -3,7 +3,7 @@ package parameters
import "github.com/iotaledger/goshimmer/packages/parameter"
var (
- ADDRESS = parameter.AddString("AUTOPEERING/ADDRESS", "0.0.0.0", "address to bind for incoming peering requests")
- ENTRY_NODES = parameter.AddString("AUTOPEERING/ENTRY_NODES", "0d828930890386f036eb77982cc067c5429f7b8f@82.165.29.179:14626", "list of trusted entry nodes for auto peering")
- PORT = parameter.AddInt("AUTOPEERING/PORT", 14626, "tcp port for incoming peering requests")
+ ADDRESS = parameter.AddString("AUTOPEERING/ADDRESS", "0.0.0.0", "address to bind for incoming peering requests")
+ ENTRY_NODES = parameter.AddString("AUTOPEERING/ENTRY_NODES", "0d828930890386f036eb77982cc067c5429f7b8f@82.165.29.179:14626", "list of trusted entry nodes for auto peering")
+ PORT = parameter.AddInt("AUTOPEERING/PORT", 14626, "tcp port for incoming peering requests")
)
diff --git a/plugins/autopeering/plugin.go b/plugins/autopeering/plugin.go
index 769c37eeeb0912cef5ce01739e2696d506388faa..ce2a0cde4e34e3c9372170882ed0adac0b792871 100644
--- a/plugins/autopeering/plugin.go
+++ b/plugins/autopeering/plugin.go
@@ -1,81 +1,81 @@
package autopeering
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
- "github.com/iotaledger/goshimmer/plugins/autopeering/server"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/gossip"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/server"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/gossip"
)
var PLUGIN = node.NewPlugin("Auto Peering", configure, run)
func configure(plugin *node.Plugin) {
- saltmanager.Configure(plugin)
- instances.Configure(plugin)
- server.Configure(plugin)
- protocol.Configure(plugin)
+ saltmanager.Configure(plugin)
+ instances.Configure(plugin)
+ server.Configure(plugin)
+ protocol.Configure(plugin)
- daemon.Events.Shutdown.Attach(events.NewClosure(func() {
- server.Shutdown(plugin)
- }))
+ daemon.Events.Shutdown.Attach(events.NewClosure(func() {
+ server.Shutdown(plugin)
+ }))
- configureLogging(plugin)
+ configureLogging(plugin)
}
func run(plugin *node.Plugin) {
- instances.Run(plugin)
- server.Run(plugin)
- protocol.Run(plugin)
+ instances.Run(plugin)
+ server.Run(plugin)
+ protocol.Run(plugin)
}
func configureLogging(plugin *node.Plugin) {
- gossip.Events.RemoveNeighbor.Attach(events.NewClosure(func(peer *gossip.Neighbor) {
- chosenneighbors.INSTANCE.Remove(peer.Identity.StringIdentifier)
- acceptedneighbors.INSTANCE.Remove(peer.Identity.StringIdentifier)
- }))
-
- acceptedneighbors.INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
- plugin.LogDebug("accepted neighbor added: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
-
- gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
- }))
- acceptedneighbors.INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
- plugin.LogDebug("accepted neighbor removed: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
-
- gossip.RemoveNeighbor(p.Identity.StringIdentifier)
- }))
-
- chosenneighbors.INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
- plugin.LogDebug("chosen neighbor added: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
-
- gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
- }))
- chosenneighbors.INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
- plugin.LogDebug("chosen neighbor removed: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
-
- gossip.RemoveNeighbor(p.Identity.StringIdentifier)
- }))
-
- knownpeers.INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
- plugin.LogInfo("new peer discovered: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
-
- if _, exists := gossip.GetNeighbor(p.Identity.StringIdentifier); exists {
- gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
- }
- }))
- knownpeers.INSTANCE.Events.Update.Attach(events.NewClosure(func(p *peer.Peer) {
- plugin.LogDebug("peer updated: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
-
- if _, exists := gossip.GetNeighbor(p.Identity.StringIdentifier); exists {
- gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
- }
- }))
+ gossip.Events.RemoveNeighbor.Attach(events.NewClosure(func(peer *gossip.Neighbor) {
+ chosenneighbors.INSTANCE.Remove(peer.Identity.StringIdentifier)
+ acceptedneighbors.INSTANCE.Remove(peer.Identity.StringIdentifier)
+ }))
+
+ acceptedneighbors.INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
+ plugin.LogDebug("accepted neighbor added: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
+
+ gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
+ }))
+ acceptedneighbors.INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
+ plugin.LogDebug("accepted neighbor removed: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
+
+ gossip.RemoveNeighbor(p.Identity.StringIdentifier)
+ }))
+
+ chosenneighbors.INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
+ plugin.LogDebug("chosen neighbor added: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
+
+ gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
+ }))
+ chosenneighbors.INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
+ plugin.LogDebug("chosen neighbor removed: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
+
+ gossip.RemoveNeighbor(p.Identity.StringIdentifier)
+ }))
+
+ knownpeers.INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
+ plugin.LogInfo("new peer discovered: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
+
+ if _, exists := gossip.GetNeighbor(p.Identity.StringIdentifier); exists {
+ gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
+ }
+ }))
+ knownpeers.INSTANCE.Events.Update.Attach(events.NewClosure(func(p *peer.Peer) {
+ plugin.LogDebug("peer updated: " + p.Address.String() + " / " + p.Identity.StringIdentifier)
+
+ if _, exists := gossip.GetNeighbor(p.Identity.StringIdentifier); exists {
+ gossip.AddNeighbor(gossip.NewNeighbor(p.Identity, p.Address, p.GossipPort))
+ }
+ }))
}
diff --git a/plugins/autopeering/protocol/accepted_neighbor_dropper.go b/plugins/autopeering/protocol/accepted_neighbor_dropper.go
index 360ee603c2fdcbde812d8c9df5a4f453ade36b45..981dc32cafcad8f4140914ba824e3b6000d2a2ed 100644
--- a/plugins/autopeering/protocol/accepted_neighbor_dropper.go
+++ b/plugins/autopeering/protocol/accepted_neighbor_dropper.go
@@ -1,39 +1,40 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/timeutil"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/timeutil"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
)
func createAcceptedNeighborDropper(plugin *node.Plugin) func() {
- return func() {
- timeutil.Ticker(func() {
- if len(acceptedneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT / 2 {
- defer acceptedneighbors.INSTANCE.Lock()()
- for len(acceptedneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT / 2 {
- acceptedneighbors.FurthestNeighborLock.RLock()
- furthestNeighbor := acceptedneighbors.FURTHEST_NEIGHBOR
- acceptedneighbors.FurthestNeighborLock.RUnlock()
+ return func() {
+ timeutil.Ticker(func() {
+ if len(acceptedneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT/2 {
+ defer acceptedneighbors.INSTANCE.Lock()()
+ for len(acceptedneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT/2 {
+ acceptedneighbors.FurthestNeighborLock.RLock()
+ furthestNeighbor := acceptedneighbors.FURTHEST_NEIGHBOR
+ acceptedneighbors.FurthestNeighborLock.RUnlock()
- if furthestNeighbor != nil {
- dropMessage := &drop.Drop{Issuer: ownpeer.INSTANCE}
- dropMessage.Sign()
+ if furthestNeighbor != nil {
+ dropMessage := &drop.Drop{Issuer: ownpeer.INSTANCE}
+ dropMessage.Sign()
- acceptedneighbors.INSTANCE.Remove(furthestNeighbor.Identity.StringIdentifier, false)
- go func() {
- if _, err := furthestNeighbor.Send(dropMessage.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
- plugin.LogDebug("error when sending drop message to" + acceptedneighbors.FURTHEST_NEIGHBOR.String())
- }
- }()
- }
- }
- }
- }, 1 * time.Second)
- }
+ acceptedneighbors.INSTANCE.Remove(furthestNeighbor.Identity.StringIdentifier, false)
+ go func() {
+ if _, err := furthestNeighbor.Send(dropMessage.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
+ plugin.LogDebug("error when sending drop message to" + acceptedneighbors.FURTHEST_NEIGHBOR.String())
+ }
+ }()
+ }
+ }
+ }
+ }, 1*time.Second)
+ }
}
diff --git a/plugins/autopeering/protocol/chosen_neighbor_dropper.go b/plugins/autopeering/protocol/chosen_neighbor_dropper.go
index 1e070d17970bd34a4425515c6f75b30a1d90c909..b0be97a96787eb3e90177a8581b11c5eebd88c06 100644
--- a/plugins/autopeering/protocol/chosen_neighbor_dropper.go
+++ b/plugins/autopeering/protocol/chosen_neighbor_dropper.go
@@ -1,39 +1,40 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/timeutil"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/timeutil"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
)
func createChosenNeighborDropper(plugin *node.Plugin) func() {
- return func() {
- timeutil.Ticker(func() {
- if len(chosenneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT / 2 {
- defer chosenneighbors.INSTANCE.Lock()()
- for len(chosenneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT / 2 {
- chosenneighbors.FurthestNeighborLock.RLock()
- furthestNeighbor := chosenneighbors.FURTHEST_NEIGHBOR
- chosenneighbors.FurthestNeighborLock.RUnlock()
+ return func() {
+ timeutil.Ticker(func() {
+ if len(chosenneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT/2 {
+ defer chosenneighbors.INSTANCE.Lock()()
+ for len(chosenneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT/2 {
+ chosenneighbors.FurthestNeighborLock.RLock()
+ furthestNeighbor := chosenneighbors.FURTHEST_NEIGHBOR
+ chosenneighbors.FurthestNeighborLock.RUnlock()
- if furthestNeighbor != nil {
- dropMessage := &drop.Drop{Issuer: ownpeer.INSTANCE}
- dropMessage.Sign()
+ if furthestNeighbor != nil {
+ dropMessage := &drop.Drop{Issuer: ownpeer.INSTANCE}
+ dropMessage.Sign()
- chosenneighbors.INSTANCE.Remove(furthestNeighbor.Identity.StringIdentifier, false)
- go func() {
- if _, err := furthestNeighbor.Send(dropMessage.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
- plugin.LogDebug("error when sending drop message to" + chosenneighbors.FURTHEST_NEIGHBOR.String())
- }
- }()
- }
- }
- }
- }, 1 * time.Second)
- }
+ chosenneighbors.INSTANCE.Remove(furthestNeighbor.Identity.StringIdentifier, false)
+ go func() {
+ if _, err := furthestNeighbor.Send(dropMessage.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
+ plugin.LogDebug("error when sending drop message to" + chosenneighbors.FURTHEST_NEIGHBOR.String())
+ }
+ }()
+ }
+ }
+ }
+ }, 1*time.Second)
+ }
}
diff --git a/plugins/autopeering/protocol/constants/constants.go b/plugins/autopeering/protocol/constants/constants.go
index a95747d811ce8c70fb3ed20428025ef514dc3dd2..10e60f30ca34dd5ddc7d3f7ed6bf8aba8fa6d4c9 100644
--- a/plugins/autopeering/protocol/constants/constants.go
+++ b/plugins/autopeering/protocol/constants/constants.go
@@ -3,16 +3,16 @@ package constants
import "time"
const (
- NEIGHBOR_COUNT = 8
+ NEIGHBOR_COUNT = 8
- FIND_NEIGHBOR_INTERVAL = 10 * time.Second
+ FIND_NEIGHBOR_INTERVAL = 10 * time.Second
- // How often does the outgoing ping processor check if new pings should be sent.
- PING_PROCESS_INTERVAL = 1 * time.Second
+ // How often does the outgoing ping processor check if new pings should be sent.
+ PING_PROCESS_INTERVAL = 1 * time.Second
- // The amount of times each neighbor should be contacted in this cycle.
- PING_CONTACT_COUNT_PER_CYCLE = 2
+ // The amount of times each neighbor should be contacted in this cycle.
+ PING_CONTACT_COUNT_PER_CYCLE = 2
- // The length of a ping cycle (after this time we have sent randomized pings to all of our neighbors).
- PING_CYCLE_LENGTH = 900 * time.Second
+ // The length of a ping cycle (after this time we have sent randomized pings to all of our neighbors).
+ PING_CYCLE_LENGTH = 900 * time.Second
)
diff --git a/plugins/autopeering/protocol/error_handler.go b/plugins/autopeering/protocol/error_handler.go
index 9319aa8d0e788cccf2da6689f686610628219f06..a97e5bf76216a731cb82d8e03a5c707aef732558 100644
--- a/plugins/autopeering/protocol/error_handler.go
+++ b/plugins/autopeering/protocol/error_handler.go
@@ -1,13 +1,14 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "net"
+ "net"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
)
func createErrorHandler(plugin *node.Plugin) *events.Closure {
- return events.NewClosure(func(ip net.IP, err error) {
- plugin.LogDebug("error when communicating with " + ip.String() + ": " + err.Error())
- })
+ return events.NewClosure(func(ip net.IP, err error) {
+ plugin.LogDebug("error when communicating with " + ip.String() + ": " + err.Error())
+ })
}
diff --git a/plugins/autopeering/protocol/incoming_drop_processor.go b/plugins/autopeering/protocol/incoming_drop_processor.go
index 732ce97b1f84769b88a45101d1c8a7de0ff3646b..9f55f63bb3ce4b5ea45b41b2cfa5503c73f6bcc3 100644
--- a/plugins/autopeering/protocol/incoming_drop_processor.go
+++ b/plugins/autopeering/protocol/incoming_drop_processor.go
@@ -1,18 +1,18 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
)
func createIncomingDropProcessor(plugin *node.Plugin) *events.Closure {
- return events.NewClosure(func(drop *drop.Drop) {
- plugin.LogDebug("received drop message from " + drop.Issuer.String())
+ return events.NewClosure(func(drop *drop.Drop) {
+ plugin.LogDebug("received drop message from " + drop.Issuer.String())
- chosenneighbors.INSTANCE.Remove(drop.Issuer.Identity.StringIdentifier)
- acceptedneighbors.INSTANCE.Remove(drop.Issuer.Identity.StringIdentifier)
- })
+ chosenneighbors.INSTANCE.Remove(drop.Issuer.Identity.StringIdentifier)
+ acceptedneighbors.INSTANCE.Remove(drop.Issuer.Identity.StringIdentifier)
+ })
}
diff --git a/plugins/autopeering/protocol/incoming_ping_processor.go b/plugins/autopeering/protocol/incoming_ping_processor.go
index d0fa1a1f6036a20ed0783793688e625037f89f2a..c8fdf381540e61a2026bf1e126f3551c275db018 100644
--- a/plugins/autopeering/protocol/incoming_ping_processor.go
+++ b/plugins/autopeering/protocol/incoming_ping_processor.go
@@ -1,19 +1,19 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
)
func createIncomingPingProcessor(plugin *node.Plugin) *events.Closure {
- return events.NewClosure(func(ping *ping.Ping) {
- plugin.LogDebug("received ping from " + ping.Issuer.String())
+ return events.NewClosure(func(ping *ping.Ping) {
+ plugin.LogDebug("received ping from " + ping.Issuer.String())
- knownpeers.INSTANCE.AddOrUpdate(ping.Issuer)
- for _, neighbor := range ping.Neighbors {
- knownpeers.INSTANCE.AddOrUpdate(neighbor)
- }
- })
+ knownpeers.INSTANCE.AddOrUpdate(ping.Issuer)
+ for _, neighbor := range ping.Neighbors {
+ knownpeers.INSTANCE.AddOrUpdate(neighbor)
+ }
+ })
}
diff --git a/plugins/autopeering/protocol/incoming_request_processor.go b/plugins/autopeering/protocol/incoming_request_processor.go
index 61fa17d6863793715e0a964274de9884d8eb0d5c..460caedb0643fa908c6c7875775e9465ee7849e8 100644
--- a/plugins/autopeering/protocol/incoming_request_processor.go
+++ b/plugins/autopeering/protocol/incoming_request_processor.go
@@ -1,75 +1,76 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "math/rand"
+ "math/rand"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
)
func createIncomingRequestProcessor(plugin *node.Plugin) *events.Closure {
- return events.NewClosure(func(req *request.Request) {
- go processIncomingRequest(plugin, req)
- })
+ return events.NewClosure(func(req *request.Request) {
+ go processIncomingRequest(plugin, req)
+ })
}
func processIncomingRequest(plugin *node.Plugin, req *request.Request) {
- plugin.LogDebug("received peering request from " + req.Issuer.String())
+ plugin.LogDebug("received peering request from " + req.Issuer.String())
- knownpeers.INSTANCE.AddOrUpdate(req.Issuer)
+ knownpeers.INSTANCE.AddOrUpdate(req.Issuer)
- if requestShouldBeAccepted(req) {
- defer acceptedneighbors.INSTANCE.Lock()()
+ if requestShouldBeAccepted(req) {
+ defer acceptedneighbors.INSTANCE.Lock()()
- if requestShouldBeAccepted(req) {
- acceptedneighbors.INSTANCE.AddOrUpdate(req.Issuer, false)
+ if requestShouldBeAccepted(req) {
+ acceptedneighbors.INSTANCE.AddOrUpdate(req.Issuer, false)
- acceptRequest(plugin, req)
+ acceptRequest(plugin, req)
- return
- }
- }
+ return
+ }
+ }
- rejectRequest(plugin, req)
+ rejectRequest(plugin, req)
}
func requestShouldBeAccepted(req *request.Request) bool {
- return len(acceptedneighbors.INSTANCE.Peers) < constants.NEIGHBOR_COUNT / 2 ||
- acceptedneighbors.INSTANCE.Contains(req.Issuer.Identity.StringIdentifier) ||
- acceptedneighbors.OWN_DISTANCE(req.Issuer) < acceptedneighbors.FURTHEST_NEIGHBOR_DISTANCE
+ return len(acceptedneighbors.INSTANCE.Peers) < constants.NEIGHBOR_COUNT/2 ||
+ acceptedneighbors.INSTANCE.Contains(req.Issuer.Identity.StringIdentifier) ||
+ acceptedneighbors.OWN_DISTANCE(req.Issuer) < acceptedneighbors.FURTHEST_NEIGHBOR_DISTANCE
}
func acceptRequest(plugin *node.Plugin, req *request.Request) {
- if err := req.Accept(generateProposedPeeringCandidates(req)); err != nil {
- plugin.LogDebug("error when sending response to" + req.Issuer.String())
- }
+ if err := req.Accept(generateProposedPeeringCandidates(req)); err != nil {
+ plugin.LogDebug("error when sending response to" + req.Issuer.String())
+ }
- plugin.LogDebug("sent positive peering response to " + req.Issuer.String())
+ plugin.LogDebug("sent positive peering response to " + req.Issuer.String())
- acceptedneighbors.INSTANCE.AddOrUpdate(req.Issuer, false)
+ acceptedneighbors.INSTANCE.AddOrUpdate(req.Issuer, false)
}
func rejectRequest(plugin *node.Plugin, req *request.Request) {
- if err := req.Reject(generateProposedPeeringCandidates(req)); err != nil {
- plugin.LogDebug("error when sending response to" + req.Issuer.String())
- }
+ if err := req.Reject(generateProposedPeeringCandidates(req)); err != nil {
+ plugin.LogDebug("error when sending response to" + req.Issuer.String())
+ }
- plugin.LogDebug("sent negative peering response to " + req.Issuer.String())
+ plugin.LogDebug("sent negative peering response to " + req.Issuer.String())
}
func generateProposedPeeringCandidates(req *request.Request) peerlist.PeerList {
- proposedPeers := neighborhood.LIST_INSTANCE.Filter(func(p *peer.Peer) bool {
- return p.Identity.PublicKey != nil
- })
- rand.Shuffle(len(proposedPeers), func(i, j int) {
- proposedPeers[i], proposedPeers[j] = proposedPeers[j], proposedPeers[i]
- })
-
- return proposedPeers
-}
\ No newline at end of file
+ proposedPeers := neighborhood.LIST_INSTANCE.Filter(func(p *peer.Peer) bool {
+ return p.Identity.PublicKey != nil
+ })
+ rand.Shuffle(len(proposedPeers), func(i, j int) {
+ proposedPeers[i], proposedPeers[j] = proposedPeers[j], proposedPeers[i]
+ })
+
+ return proposedPeers
+}
diff --git a/plugins/autopeering/protocol/incoming_response_processor.go b/plugins/autopeering/protocol/incoming_response_processor.go
index ee581478b018945f4636cdec10304c2a3f538bd7..1bec1044722132eda13f3f8d1f7edd37d3637824 100644
--- a/plugins/autopeering/protocol/incoming_response_processor.go
+++ b/plugins/autopeering/protocol/incoming_response_processor.go
@@ -1,46 +1,46 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
)
func createIncomingResponseProcessor(plugin *node.Plugin) *events.Closure {
- return events.NewClosure(func(peeringResponse *response.Response) {
- go processIncomingResponse(plugin, peeringResponse)
- })
+ return events.NewClosure(func(peeringResponse *response.Response) {
+ go processIncomingResponse(plugin, peeringResponse)
+ })
}
func processIncomingResponse(plugin *node.Plugin, peeringResponse *response.Response) {
- plugin.LogDebug("received peering response from " + peeringResponse.Issuer.String())
-
- peeringResponse.Issuer.Conn.Close()
-
- knownpeers.INSTANCE.AddOrUpdate(peeringResponse.Issuer)
- for _, peer := range peeringResponse.Peers {
- knownpeers.INSTANCE.AddOrUpdate(peer)
- }
-
- if peeringResponse.Type == response.TYPE_ACCEPT {
- defer chosenneighbors.INSTANCE.Lock()()
-
- chosenneighbors.INSTANCE.AddOrUpdate(peeringResponse.Issuer, false)
-
- /*
- if len(chosenneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT / 2 {
- dropMessage := &drop.Drop{Issuer:ownpeer.INSTANCE}
- dropMessage.Sign()
-
- chosenneighbors.FurthestNeighborLock.RLock()
- if _, err := chosenneighbors.FURTHEST_NEIGHBOR.Send(dropMessage.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
- plugin.LogDebug("error when sending drop message to" + chosenneighbors.FURTHEST_NEIGHBOR.String())
- }
- chosenneighbors.INSTANCE.Remove(chosenneighbors.FURTHEST_NEIGHBOR.Identity.StringIdentifier, false)
- chosenneighbors.FurthestNeighborLock.RUnlock()
- }
- */
- }
-}
\ No newline at end of file
+ plugin.LogDebug("received peering response from " + peeringResponse.Issuer.String())
+
+ peeringResponse.Issuer.Conn.Close()
+
+ knownpeers.INSTANCE.AddOrUpdate(peeringResponse.Issuer)
+ for _, peer := range peeringResponse.Peers {
+ knownpeers.INSTANCE.AddOrUpdate(peer)
+ }
+
+ if peeringResponse.Type == response.TYPE_ACCEPT {
+ defer chosenneighbors.INSTANCE.Lock()()
+
+ chosenneighbors.INSTANCE.AddOrUpdate(peeringResponse.Issuer, false)
+
+ /*
+ if len(chosenneighbors.INSTANCE.Peers) > constants.NEIGHBOR_COUNT / 2 {
+ dropMessage := &drop.Drop{Issuer:ownpeer.INSTANCE}
+ dropMessage.Sign()
+
+ chosenneighbors.FurthestNeighborLock.RLock()
+ if _, err := chosenneighbors.FURTHEST_NEIGHBOR.Send(dropMessage.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
+ plugin.LogDebug("error when sending drop message to" + chosenneighbors.FURTHEST_NEIGHBOR.String())
+ }
+ chosenneighbors.INSTANCE.Remove(chosenneighbors.FURTHEST_NEIGHBOR.Identity.StringIdentifier, false)
+ chosenneighbors.FurthestNeighborLock.RUnlock()
+ }
+ */
+ }
+}
diff --git a/plugins/autopeering/protocol/outgoing_ping_processor.go b/plugins/autopeering/protocol/outgoing_ping_processor.go
index 8fb0916cd6a118f150c6bdfbdf521e1d70e7f2cb..e1312fca7e0991384d980484c3b92f1f5176591a 100644
--- a/plugins/autopeering/protocol/outgoing_ping_processor.go
+++ b/plugins/autopeering/protocol/outgoing_ping_processor.go
@@ -1,85 +1,86 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
- "math/rand"
- "time"
+ "math/rand"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
)
var lastPing time.Time
func createOutgoingPingProcessor(plugin *node.Plugin) func() {
- return func() {
- plugin.LogInfo("Starting Ping Processor ...")
- plugin.LogSuccess("Starting Ping Processor ... done")
-
- lastPing = time.Now().Add(-constants.PING_CYCLE_LENGTH)
-
- outgoingPing := &ping.Ping{
- Issuer: ownpeer.INSTANCE,
- }
- outgoingPing.Sign()
-
- saltmanager.Events.UpdatePublicSalt.Attach(events.NewClosure(func(salt *salt.Salt) {
- outgoingPing.Sign()
- }))
-
- pingPeers(plugin, outgoingPing)
-
- ticker := time.NewTicker(constants.PING_PROCESS_INTERVAL)
- ticker:
- for {
- select {
- case <- daemon.ShutdownSignal:
- plugin.LogInfo("Stopping Ping Processor ...")
-
- break ticker
- case <- ticker.C:
- pingPeers(plugin, outgoingPing)
- }
- }
-
- plugin.LogSuccess("Stopping Ping Processor ... done")
- }
+ return func() {
+ plugin.LogInfo("Starting Ping Processor ...")
+ plugin.LogSuccess("Starting Ping Processor ... done")
+
+ lastPing = time.Now().Add(-constants.PING_CYCLE_LENGTH)
+
+ outgoingPing := &ping.Ping{
+ Issuer: ownpeer.INSTANCE,
+ }
+ outgoingPing.Sign()
+
+ saltmanager.Events.UpdatePublicSalt.Attach(events.NewClosure(func(salt *salt.Salt) {
+ outgoingPing.Sign()
+ }))
+
+ pingPeers(plugin, outgoingPing)
+
+ ticker := time.NewTicker(constants.PING_PROCESS_INTERVAL)
+ ticker:
+ for {
+ select {
+ case <-daemon.ShutdownSignal:
+ plugin.LogInfo("Stopping Ping Processor ...")
+
+ break ticker
+ case <-ticker.C:
+ pingPeers(plugin, outgoingPing)
+ }
+ }
+
+ plugin.LogSuccess("Stopping Ping Processor ... done")
+ }
}
func pingPeers(plugin *node.Plugin, outgoingPing *ping.Ping) {
- if len(neighborhood.LIST_INSTANCE) >= 1 {
- pingDelay := constants.PING_CYCLE_LENGTH / time.Duration(len(neighborhood.LIST_INSTANCE))
-
- if lastPing.Add(pingDelay).Before(time.Now()) {
- chosenPeers := make(map[string]*peer.Peer)
-
- for i := 0; i < constants.PING_CONTACT_COUNT_PER_CYCLE; i++ {
- randomNeighborHoodPeer := neighborhood.LIST_INSTANCE[rand.Intn(len(neighborhood.LIST_INSTANCE))]
-
- if randomNeighborHoodPeer.Identity.StringIdentifier != accountability.OwnId().StringIdentifier {
- chosenPeers[randomNeighborHoodPeer.Identity.StringIdentifier] = randomNeighborHoodPeer
- }
- }
-
- for _, chosenPeer := range chosenPeers {
- go func(chosenPeer *peer.Peer) {
- if _, err := chosenPeer.Send(outgoingPing.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
- plugin.LogDebug("error when sending ping to " + chosenPeer.String() + ": " + err.Error())
- } else {
- plugin.LogDebug("sent ping to " + chosenPeer.String())
- }
- }(chosenPeer)
- }
-
- lastPing = time.Now()
- }
- }
-}
\ No newline at end of file
+ if len(neighborhood.LIST_INSTANCE) >= 1 {
+ pingDelay := constants.PING_CYCLE_LENGTH / time.Duration(len(neighborhood.LIST_INSTANCE))
+
+ if lastPing.Add(pingDelay).Before(time.Now()) {
+ chosenPeers := make(map[string]*peer.Peer)
+
+ for i := 0; i < constants.PING_CONTACT_COUNT_PER_CYCLE; i++ {
+ randomNeighborHoodPeer := neighborhood.LIST_INSTANCE[rand.Intn(len(neighborhood.LIST_INSTANCE))]
+
+ if randomNeighborHoodPeer.Identity.StringIdentifier != accountability.OwnId().StringIdentifier {
+ chosenPeers[randomNeighborHoodPeer.Identity.StringIdentifier] = randomNeighborHoodPeer
+ }
+ }
+
+ for _, chosenPeer := range chosenPeers {
+ go func(chosenPeer *peer.Peer) {
+ if _, err := chosenPeer.Send(outgoingPing.Marshal(), types.PROTOCOL_TYPE_UDP, false); err != nil {
+ plugin.LogDebug("error when sending ping to " + chosenPeer.String() + ": " + err.Error())
+ } else {
+ plugin.LogDebug("sent ping to " + chosenPeer.String())
+ }
+ }(chosenPeer)
+ }
+
+ lastPing = time.Now()
+ }
+ }
+}
diff --git a/plugins/autopeering/protocol/outgoing_request_processor.go b/plugins/autopeering/protocol/outgoing_request_processor.go
index 7d6879331d5d94597fa25532552d255de16f4a14..cec618cb4827d68a59239e0d8d4dff916969da4c 100644
--- a/plugins/autopeering/protocol/outgoing_request_processor.go
+++ b/plugins/autopeering/protocol/outgoing_request_processor.go
@@ -1,66 +1,66 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/outgoingrequest"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
- "github.com/iotaledger/goshimmer/plugins/autopeering/server/tcp"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/outgoingrequest"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/server/tcp"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
func createOutgoingRequestProcessor(plugin *node.Plugin) func() {
- return func() {
- plugin.LogInfo("Starting Chosen Neighbor Processor ...")
- plugin.LogSuccess("Starting Chosen Neighbor Processor ... done")
+ return func() {
+ plugin.LogInfo("Starting Chosen Neighbor Processor ...")
+ plugin.LogSuccess("Starting Chosen Neighbor Processor ... done")
- sendOutgoingRequests(plugin)
+ sendOutgoingRequests(plugin)
- ticker := time.NewTicker(constants.FIND_NEIGHBOR_INTERVAL)
- ticker:
- for {
- select {
- case <- daemon.ShutdownSignal:
- plugin.LogInfo("Stopping Chosen Neighbor Processor ...")
+ ticker := time.NewTicker(constants.FIND_NEIGHBOR_INTERVAL)
+ ticker:
+ for {
+ select {
+ case <-daemon.ShutdownSignal:
+ plugin.LogInfo("Stopping Chosen Neighbor Processor ...")
- break ticker
- case <- ticker.C:
- sendOutgoingRequests(plugin)
- }
- }
+ break ticker
+ case <-ticker.C:
+ sendOutgoingRequests(plugin)
+ }
+ }
- plugin.LogSuccess("Stopping Chosen Neighbor Processor ... done")
- }
+ plugin.LogSuccess("Stopping Chosen Neighbor Processor ... done")
+ }
}
func sendOutgoingRequests(plugin *node.Plugin) {
- for _, chosenNeighborCandidate := range chosenneighbors.CANDIDATES.Clone() {
- time.Sleep(5 * time.Second)
+ for _, chosenNeighborCandidate := range chosenneighbors.CANDIDATES.Clone() {
+ time.Sleep(5 * time.Second)
- if candidateShouldBeContacted(chosenNeighborCandidate) {
- if dialed, err := chosenNeighborCandidate.Send(outgoingrequest.INSTANCE.Marshal(), types.PROTOCOL_TYPE_TCP, true); err != nil {
- plugin.LogDebug(err.Error())
- } else {
- plugin.LogDebug("sent peering request to " + chosenNeighborCandidate.String())
+ if candidateShouldBeContacted(chosenNeighborCandidate) {
+ if dialed, err := chosenNeighborCandidate.Send(outgoingrequest.INSTANCE.Marshal(), types.PROTOCOL_TYPE_TCP, true); err != nil {
+ plugin.LogDebug(err.Error())
+ } else {
+ plugin.LogDebug("sent peering request to " + chosenNeighborCandidate.String())
- if dialed {
- tcp.HandleConnection(chosenNeighborCandidate.Conn)
- }
- }
- }
- }
+ if dialed {
+ tcp.HandleConnection(chosenNeighborCandidate.Conn)
+ }
+ }
+ }
+ }
}
func candidateShouldBeContacted(candidate *peer.Peer) bool {
- nodeId := candidate.Identity.StringIdentifier
+ nodeId := candidate.Identity.StringIdentifier
- return (!acceptedneighbors.INSTANCE.Contains(nodeId) &&!chosenneighbors.INSTANCE.Contains(nodeId) &&
- accountability.OwnId().StringIdentifier != nodeId) && (
- len(chosenneighbors.INSTANCE.Peers) < constants.NEIGHBOR_COUNT / 2 ||
- chosenneighbors.OWN_DISTANCE(candidate) < chosenneighbors.FURTHEST_NEIGHBOR_DISTANCE)
+ return (!acceptedneighbors.INSTANCE.Contains(nodeId) && !chosenneighbors.INSTANCE.Contains(nodeId) &&
+ accountability.OwnId().StringIdentifier != nodeId) && (len(chosenneighbors.INSTANCE.Peers) < constants.NEIGHBOR_COUNT/2 ||
+ chosenneighbors.OWN_DISTANCE(candidate) < chosenneighbors.FURTHEST_NEIGHBOR_DISTANCE)
}
diff --git a/plugins/autopeering/protocol/plugin.go b/plugins/autopeering/protocol/plugin.go
index e875ad2761a2f5f2699283d365a54eb6ccb5462e..fce222652b9d551a6aa84c8c15617795e68ba592 100644
--- a/plugins/autopeering/protocol/plugin.go
+++ b/plugins/autopeering/protocol/plugin.go
@@ -1,27 +1,27 @@
package protocol
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/server/tcp"
- "github.com/iotaledger/goshimmer/plugins/autopeering/server/udp"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/server/tcp"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/server/udp"
)
func Configure(plugin *node.Plugin) {
- errorHandler := createErrorHandler(plugin)
+ errorHandler := createErrorHandler(plugin)
- udp.Events.ReceiveDrop.Attach(createIncomingDropProcessor(plugin))
- udp.Events.ReceivePing.Attach(createIncomingPingProcessor(plugin))
- udp.Events.Error.Attach(errorHandler)
+ udp.Events.ReceiveDrop.Attach(createIncomingDropProcessor(plugin))
+ udp.Events.ReceivePing.Attach(createIncomingPingProcessor(plugin))
+ udp.Events.Error.Attach(errorHandler)
- tcp.Events.ReceiveRequest.Attach(createIncomingRequestProcessor(plugin))
- tcp.Events.ReceiveResponse.Attach(createIncomingResponseProcessor(plugin))
- tcp.Events.Error.Attach(errorHandler)
+ tcp.Events.ReceiveRequest.Attach(createIncomingRequestProcessor(plugin))
+ tcp.Events.ReceiveResponse.Attach(createIncomingResponseProcessor(plugin))
+ tcp.Events.Error.Attach(errorHandler)
}
func Run(plugin *node.Plugin) {
- daemon.BackgroundWorker(createChosenNeighborDropper(plugin))
- daemon.BackgroundWorker(createAcceptedNeighborDropper(plugin))
- daemon.BackgroundWorker(createOutgoingRequestProcessor(plugin))
- daemon.BackgroundWorker(createOutgoingPingProcessor(plugin))
+ daemon.BackgroundWorker(createChosenNeighborDropper(plugin))
+ daemon.BackgroundWorker(createAcceptedNeighborDropper(plugin))
+ daemon.BackgroundWorker(createOutgoingRequestProcessor(plugin))
+ daemon.BackgroundWorker(createOutgoingPingProcessor(plugin))
}
diff --git a/plugins/autopeering/protocol/types/constants.go b/plugins/autopeering/protocol/types/constants.go
index f17ad2320186975a0b89b78ad796202641855653..a4dc301c991c8288a112721f126052b8bb17630d 100644
--- a/plugins/autopeering/protocol/types/constants.go
+++ b/plugins/autopeering/protocol/types/constants.go
@@ -1,9 +1,9 @@
package types
const (
- PROTOCOL_TYPE_TCP = ProtocolType(0)
- PROTOCOL_TYPE_UDP = ProtocolType(1)
+ PROTOCOL_TYPE_TCP = ProtocolType(0)
+ PROTOCOL_TYPE_UDP = ProtocolType(1)
- ADDRESS_TYPE_IPV4 = AddressType(0)
- ADDRESS_TYPE_IPV6 = AddressType(1)
+ ADDRESS_TYPE_IPV4 = AddressType(0)
+ ADDRESS_TYPE_IPV6 = AddressType(1)
)
diff --git a/plugins/autopeering/protocol/types/types.go b/plugins/autopeering/protocol/types/types.go
index fb6e24658eb3af95298e0429caa0b0c1a3fff257..3b68f5dae31ea0b1180bfc5f4f95c8d643e57067 100644
--- a/plugins/autopeering/protocol/types/types.go
+++ b/plugins/autopeering/protocol/types/types.go
@@ -2,4 +2,4 @@ package types
type AddressType = byte
-type ProtocolType = byte
\ No newline at end of file
+type ProtocolType = byte
diff --git a/plugins/autopeering/saltmanager/constants.go b/plugins/autopeering/saltmanager/constants.go
index 20bd690699594d36bef7a91e0f02d125b8a5e6f0..4fe475f4015a05d60958f918a0be9f1463e5e009 100644
--- a/plugins/autopeering/saltmanager/constants.go
+++ b/plugins/autopeering/saltmanager/constants.go
@@ -3,11 +3,11 @@ package saltmanager
import "time"
const (
- PUBLIC_SALT_LIFETIME = 1800 * time.Second
- PRIVATE_SALT_LIFETIME = 1800 * time.Second
+ PUBLIC_SALT_LIFETIME = 1800 * time.Second
+ PRIVATE_SALT_LIFETIME = 1800 * time.Second
)
var (
- PUBLIC_SALT_SETTINGS_KEY = []byte("PUBLIC_SALT")
- PRIVATE_SALT_SETTINGS_KEY = []byte("PRIVATE_SALT")
+ PUBLIC_SALT_SETTINGS_KEY = []byte("PUBLIC_SALT")
+ PRIVATE_SALT_SETTINGS_KEY = []byte("PRIVATE_SALT")
)
diff --git a/plugins/autopeering/saltmanager/errors.go b/plugins/autopeering/saltmanager/errors.go
index bb2ec0d4192a275471ac46fba282557b8f3c66f6..4436630107263c49a75104f29cfa3aae70c807ec 100644
--- a/plugins/autopeering/saltmanager/errors.go
+++ b/plugins/autopeering/saltmanager/errors.go
@@ -3,6 +3,6 @@ package saltmanager
import "github.com/pkg/errors"
var (
- ErrPublicSaltExpired = errors.New("expired public salt in ping")
- ErrPublicSaltInvalidLifetime = errors.New("invalid public salt lifetime in ping")
+ ErrPublicSaltExpired = errors.New("expired public salt in ping")
+ ErrPublicSaltInvalidLifetime = errors.New("invalid public salt lifetime in ping")
)
diff --git a/plugins/autopeering/saltmanager/events.go b/plugins/autopeering/saltmanager/events.go
index 18315773eaf443e8ebaea0a74db7c43a84f8d9aa..26f207e7385adc9a280bb1aacd297f6c66075b34 100644
--- a/plugins/autopeering/saltmanager/events.go
+++ b/plugins/autopeering/saltmanager/events.go
@@ -1,16 +1,18 @@
package saltmanager
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
)
var Events = struct {
- UpdatePublicSalt *events.Event
- UpdatePrivateSalt *events.Event
+ UpdatePublicSalt *events.Event
+ UpdatePrivateSalt *events.Event
}{
- UpdatePublicSalt: events.NewEvent(saltCaller),
- UpdatePrivateSalt: events.NewEvent(saltCaller),
+ UpdatePublicSalt: events.NewEvent(saltCaller),
+ UpdatePrivateSalt: events.NewEvent(saltCaller),
}
-func saltCaller(handler interface{}, params ...interface{}) { handler.(func(*salt.Salt))(params[0].(*salt.Salt)) }
+func saltCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*salt.Salt))(params[0].(*salt.Salt))
+}
diff --git a/plugins/autopeering/saltmanager/saltmanager.go b/plugins/autopeering/saltmanager/saltmanager.go
index a18a1ebb24a9b3d03a13b07d81ab57ba2e694823..5127646aeb0c3da71350732861d9fbb70c0a381e 100644
--- a/plugins/autopeering/saltmanager/saltmanager.go
+++ b/plugins/autopeering/saltmanager/saltmanager.go
@@ -1,87 +1,88 @@
package saltmanager
import (
- "github.com/dgraph-io/badger"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/settings"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
- "time"
+ "time"
+
+ "github.com/dgraph-io/badger"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/settings"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
)
var (
- PRIVATE_SALT *salt.Salt
- PUBLIC_SALT *salt.Salt
+ PRIVATE_SALT *salt.Salt
+ PUBLIC_SALT *salt.Salt
)
func Configure(plugin *node.Plugin) {
- PRIVATE_SALT = createSalt(PRIVATE_SALT_SETTINGS_KEY, PRIVATE_SALT_LIFETIME, Events.UpdatePrivateSalt.Trigger)
- PUBLIC_SALT = createSalt(PUBLIC_SALT_SETTINGS_KEY, PUBLIC_SALT_LIFETIME, Events.UpdatePublicSalt.Trigger)
+ PRIVATE_SALT = createSalt(PRIVATE_SALT_SETTINGS_KEY, PRIVATE_SALT_LIFETIME, Events.UpdatePrivateSalt.Trigger)
+ PUBLIC_SALT = createSalt(PUBLIC_SALT_SETTINGS_KEY, PUBLIC_SALT_LIFETIME, Events.UpdatePublicSalt.Trigger)
}
func generateNewSalt(key []byte, lifetime time.Duration) *salt.Salt {
- newSalt := salt.New(lifetime)
+ newSalt := salt.New(lifetime)
- if err := settings.Set(key, newSalt.Marshal()); err != nil {
- panic(err)
- }
+ if err := settings.Set(key, newSalt.Marshal()); err != nil {
+ panic(err)
+ }
- return newSalt
+ return newSalt
}
func getSalt(key []byte, lifetime time.Duration) *salt.Salt {
- saltBytes, err := settings.Get(key)
- if err != nil {
- if err == badger.ErrKeyNotFound {
- return generateNewSalt(key, lifetime)
- } else {
- panic(err)
- }
- }
-
- if resultingSalt, err := salt.Unmarshal(saltBytes); err != nil {
- panic(err)
- } else {
- return resultingSalt
- }
+ saltBytes, err := settings.Get(key)
+ if err != nil {
+ if err == badger.ErrKeyNotFound {
+ return generateNewSalt(key, lifetime)
+ } else {
+ panic(err)
+ }
+ }
+
+ if resultingSalt, err := salt.Unmarshal(saltBytes); err != nil {
+ panic(err)
+ } else {
+ return resultingSalt
+ }
}
func updatePublicSalt(saltToUpdate *salt.Salt, settingsKey []byte, lifeSpan time.Duration, updateCallback func(params ...interface{})) {
- newSalt := salt.New(lifeSpan)
+ newSalt := salt.New(lifeSpan)
- saltToUpdate.Bytes = newSalt.Bytes
- saltToUpdate.ExpirationTime = newSalt.ExpirationTime
+ saltToUpdate.Bytes = newSalt.Bytes
+ saltToUpdate.ExpirationTime = newSalt.ExpirationTime
- if err := settings.Set(settingsKey, saltToUpdate.Marshal()); err != nil {
- panic(err)
- }
+ if err := settings.Set(settingsKey, saltToUpdate.Marshal()); err != nil {
+ panic(err)
+ }
- updateCallback(saltToUpdate)
+ updateCallback(saltToUpdate)
- scheduleUpdateForSalt(saltToUpdate, settingsKey, lifeSpan, updateCallback)
+ scheduleUpdateForSalt(saltToUpdate, settingsKey, lifeSpan, updateCallback)
}
func scheduleUpdateForSalt(saltToUpdate *salt.Salt, settingsKey []byte, lifeSpan time.Duration, callback func(params ...interface{})) {
- now := time.Now()
-
- if saltToUpdate.ExpirationTime.Before(now) {
- updatePublicSalt(saltToUpdate, settingsKey, lifeSpan, callback)
- } else {
- daemon.BackgroundWorker(func() {
- select {
- case <-time.After(saltToUpdate.ExpirationTime.Sub(now)):
- updatePublicSalt(saltToUpdate, settingsKey, lifeSpan, callback)
- case <-daemon.ShutdownSignal:
- return
- }
- })
- }
+ now := time.Now()
+
+ if saltToUpdate.ExpirationTime.Before(now) {
+ updatePublicSalt(saltToUpdate, settingsKey, lifeSpan, callback)
+ } else {
+ daemon.BackgroundWorker(func() {
+ select {
+ case <-time.After(saltToUpdate.ExpirationTime.Sub(now)):
+ updatePublicSalt(saltToUpdate, settingsKey, lifeSpan, callback)
+ case <-daemon.ShutdownSignal:
+ return
+ }
+ })
+ }
}
func createSalt(settingsKey []byte, lifeSpan time.Duration, updateCallback func(params ...interface{})) *salt.Salt {
- newSalt := getSalt(settingsKey, lifeSpan)
+ newSalt := getSalt(settingsKey, lifeSpan)
- scheduleUpdateForSalt(newSalt, settingsKey, lifeSpan, updateCallback)
+ scheduleUpdateForSalt(newSalt, settingsKey, lifeSpan, updateCallback)
- return newSalt
+ return newSalt
}
diff --git a/plugins/autopeering/saltmanager/utils.go b/plugins/autopeering/saltmanager/utils.go
index 755b07db4f20d7b00fbdefcd89e64681308be393..8bda9e47f0bd5b02fb113f3af14ec43fcb053068 100644
--- a/plugins/autopeering/saltmanager/utils.go
+++ b/plugins/autopeering/saltmanager/utils.go
@@ -1,18 +1,19 @@
package saltmanager
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
)
func CheckSalt(saltToCheck *salt.Salt) error {
- now := time.Now()
- if saltToCheck.ExpirationTime.Before(now.Add(-1 * time.Minute)) {
- return ErrPublicSaltExpired
- }
- if saltToCheck.ExpirationTime.After(now.Add(PUBLIC_SALT_LIFETIME + 1 * time.Minute)) {
- return ErrPublicSaltInvalidLifetime
- }
+ now := time.Now()
+ if saltToCheck.ExpirationTime.Before(now.Add(-1 * time.Minute)) {
+ return ErrPublicSaltExpired
+ }
+ if saltToCheck.ExpirationTime.After(now.Add(PUBLIC_SALT_LIFETIME + 1*time.Minute)) {
+ return ErrPublicSaltInvalidLifetime
+ }
- return nil
+ return nil
}
diff --git a/plugins/autopeering/server/server.go b/plugins/autopeering/server/server.go
index 212a6ca5e864ae79543e0393ade580a9c9c4d25a..cf51cd303e76dffd36b7d8e3c980e712a6a13b56 100644
--- a/plugins/autopeering/server/server.go
+++ b/plugins/autopeering/server/server.go
@@ -1,22 +1,22 @@
package server
import (
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/server/tcp"
- "github.com/iotaledger/goshimmer/plugins/autopeering/server/udp"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/server/tcp"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/server/udp"
)
func Configure(plugin *node.Plugin) {
- udp.ConfigureServer(plugin)
- tcp.ConfigureServer(plugin)
+ udp.ConfigureServer(plugin)
+ tcp.ConfigureServer(plugin)
}
func Run(plugin *node.Plugin) {
- udp.RunServer(plugin)
- tcp.RunServer(plugin)
+ udp.RunServer(plugin)
+ tcp.RunServer(plugin)
}
func Shutdown(plugin *node.Plugin) {
- udp.ShutdownUDPServer(plugin)
- tcp.ShutdownServer(plugin)
+ udp.ShutdownUDPServer(plugin)
+ tcp.ShutdownServer(plugin)
}
diff --git a/plugins/autopeering/server/tcp/constants.go b/plugins/autopeering/server/tcp/constants.go
index 85b2f705559a1de8d8215fe7e3c24a23ffda1568..c108d820e10625eb646069507b9d716c1e7a0044 100644
--- a/plugins/autopeering/server/tcp/constants.go
+++ b/plugins/autopeering/server/tcp/constants.go
@@ -3,10 +3,10 @@ package tcp
import "time"
const (
- IDLE_TIMEOUT = 5 * time.Second
+ IDLE_TIMEOUT = 5 * time.Second
- STATE_INITIAL = byte(0)
- STATE_REQUEST = byte(1)
- STATE_RESPONSE = byte(2)
- STATE_PING = byte(3)
+ STATE_INITIAL = byte(0)
+ STATE_REQUEST = byte(1)
+ STATE_RESPONSE = byte(2)
+ STATE_PING = byte(3)
)
diff --git a/plugins/autopeering/server/tcp/events.go b/plugins/autopeering/server/tcp/events.go
index 47e063e1a7c037b61ed2f510ea504e05d615ae6c..2b9110fa4089961cc4956f0347adeb86cd060b83 100644
--- a/plugins/autopeering/server/tcp/events.go
+++ b/plugins/autopeering/server/tcp/events.go
@@ -1,26 +1,35 @@
package tcp
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
- "net"
+ "net"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
)
var Events = struct {
- ReceivePing *events.Event
- ReceiveRequest *events.Event
- ReceiveResponse *events.Event
- Error *events.Event
+ ReceivePing *events.Event
+ ReceiveRequest *events.Event
+ ReceiveResponse *events.Event
+ Error *events.Event
}{
- events.NewEvent(pingCaller),
- events.NewEvent(requestCaller),
- events.NewEvent(responseCaller),
- events.NewEvent(errorCaller),
+ events.NewEvent(pingCaller),
+ events.NewEvent(requestCaller),
+ events.NewEvent(responseCaller),
+ events.NewEvent(errorCaller),
}
-func pingCaller(handler interface{}, params ...interface{}) { handler.(func(*ping.Ping))(params[0].(*ping.Ping)) }
-func requestCaller(handler interface{}, params ...interface{}) { handler.(func(*request.Request))(params[0].(*request.Request)) }
-func responseCaller(handler interface{}, params ...interface{}) { handler.(func(*response.Response))(params[0].(*response.Response)) }
-func errorCaller(handler interface{}, params ...interface{}) { handler.(func(net.IP, error))(params[0].(net.IP), params[1].(error)) }
+func pingCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*ping.Ping))(params[0].(*ping.Ping))
+}
+func requestCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*request.Request))(params[0].(*request.Request))
+}
+func responseCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*response.Response))(params[0].(*response.Response))
+}
+func errorCaller(handler interface{}, params ...interface{}) {
+ handler.(func(net.IP, error))(params[0].(net.IP), params[1].(error))
+}
diff --git a/plugins/autopeering/server/tcp/server.go b/plugins/autopeering/server/tcp/server.go
index 6f0e3d8412d4584864e947da38ab3e345cd96445..570b80754576ae4816ad1b3e5f45edbf0efd30ff 100644
--- a/plugins/autopeering/server/tcp/server.go
+++ b/plugins/autopeering/server/tcp/server.go
@@ -1,224 +1,225 @@
package tcp
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/network"
- "github.com/iotaledger/goshimmer/packages/network/tcp"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
- "github.com/pkg/errors"
- "math"
- "net"
- "strconv"
+ "math"
+ "net"
+ "strconv"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/packages/network/tcp"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
+ "github.com/pkg/errors"
)
var server = tcp.NewServer()
func ConfigureServer(plugin *node.Plugin) {
- server.Events.Connect.Attach(events.NewClosure(HandleConnection))
- server.Events.Error.Attach(events.NewClosure(func(err error) {
- plugin.LogFailure("error in tcp server: " + err.Error())
- }))
- server.Events.Start.Attach(events.NewClosure(func() {
- if *parameters.ADDRESS.Value == "0.0.0.0" {
- plugin.LogSuccess("Starting TCP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
- } else {
- plugin.LogSuccess("Starting TCP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
- }
- }))
- server.Events.Shutdown.Attach(events.NewClosure(func() {
- plugin.LogSuccess("Stopping TCP Server ... done")
- }))
+ server.Events.Connect.Attach(events.NewClosure(HandleConnection))
+ server.Events.Error.Attach(events.NewClosure(func(err error) {
+ plugin.LogFailure("error in tcp server: " + err.Error())
+ }))
+ server.Events.Start.Attach(events.NewClosure(func() {
+ if *parameters.ADDRESS.Value == "0.0.0.0" {
+ plugin.LogSuccess("Starting TCP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
+ } else {
+ plugin.LogSuccess("Starting TCP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
+ }
+ }))
+ server.Events.Shutdown.Attach(events.NewClosure(func() {
+ plugin.LogSuccess("Stopping TCP Server ... done")
+ }))
}
func RunServer(plugin *node.Plugin) {
- daemon.BackgroundWorker(func() {
- if *parameters.ADDRESS.Value == "0.0.0.0" {
- plugin.LogInfo("Starting TCP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ...")
- } else {
- plugin.LogInfo("Starting TCP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ...")
- }
-
- server.Listen(*parameters.PORT.Value)
- })
+ daemon.BackgroundWorker(func() {
+ if *parameters.ADDRESS.Value == "0.0.0.0" {
+ plugin.LogInfo("Starting TCP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ...")
+ } else {
+ plugin.LogInfo("Starting TCP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ...")
+ }
+
+ server.Listen(*parameters.PORT.Value)
+ })
}
func ShutdownServer(plugin *node.Plugin) {
- plugin.LogInfo("Stopping TCP Server ...")
+ plugin.LogInfo("Stopping TCP Server ...")
- server.Shutdown()
+ server.Shutdown()
}
func HandleConnection(conn *network.ManagedConnection) {
- conn.SetTimeout(IDLE_TIMEOUT)
+ conn.SetTimeout(IDLE_TIMEOUT)
- var connectionState = STATE_INITIAL
- var receiveBuffer []byte
- var offset int
+ var connectionState = STATE_INITIAL
+ var receiveBuffer []byte
+ var offset int
- conn.Events.ReceiveData.Attach(events.NewClosure(func(data []byte) {
- ProcessIncomingPacket(&connectionState, &receiveBuffer, conn, data, &offset)
- }))
+ conn.Events.ReceiveData.Attach(events.NewClosure(func(data []byte) {
+ 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.MARSHALLED_TOTAL_SIZE, math.Max(request.MARSHALLED_TOTAL_SIZE, response.MARSHALLED_TOTAL_SIZE)))))
}
func ProcessIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
- if *connectionState == STATE_INITIAL {
- var err error
- if *connectionState, *receiveBuffer, err = parsePackageHeader(data); err != nil {
- Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
-
- conn.Close()
-
- return
- }
-
- *offset = 0
-
- switch *connectionState {
- case STATE_REQUEST:
- *receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
- case STATE_RESPONSE:
- *receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
- case STATE_PING:
- *receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
- }
- }
-
- switch *connectionState {
- case STATE_REQUEST:
- processIncomingRequestPacket(connectionState, receiveBuffer, conn, data, offset)
- case STATE_RESPONSE:
- processIncomingResponsePacket(connectionState, receiveBuffer, conn, data, offset)
- case STATE_PING:
- processIncomingPingPacket(connectionState, receiveBuffer, conn, data, offset)
- }
+ if *connectionState == STATE_INITIAL {
+ var err error
+ if *connectionState, *receiveBuffer, err = parsePackageHeader(data); err != nil {
+ Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
+
+ conn.Close()
+
+ return
+ }
+
+ *offset = 0
+
+ switch *connectionState {
+ case STATE_REQUEST:
+ *receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
+ case STATE_RESPONSE:
+ *receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
+ case STATE_PING:
+ *receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ }
+ }
+
+ switch *connectionState {
+ case STATE_REQUEST:
+ processIncomingRequestPacket(connectionState, receiveBuffer, conn, data, offset)
+ case STATE_RESPONSE:
+ processIncomingResponsePacket(connectionState, receiveBuffer, conn, data, offset)
+ case STATE_PING:
+ processIncomingPingPacket(connectionState, receiveBuffer, conn, data, offset)
+ }
}
func parsePackageHeader(data []byte) (byte, []byte, error) {
- var connectionState byte
- var receiveBuffer []byte
+ var connectionState byte
+ var receiveBuffer []byte
- switch data[0] {
- case request.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
+ switch data[0] {
+ case request.MARSHALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_REQUEST
- case response.MARHSALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
+ connectionState = STATE_REQUEST
+ case response.MARHSALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_RESPONSE
- case ping.MARSHALLED_PACKET_HEADER:
- receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+ connectionState = STATE_RESPONSE
+ case ping.MARSHALLED_PACKET_HEADER:
+ receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
- connectionState = STATE_PING
- default:
- return 0, nil, errors.New("invalid package header")
- }
+ connectionState = STATE_PING
+ default:
+ return 0, nil, errors.New("invalid package header")
+ }
- return connectionState, receiveBuffer, nil
+ return connectionState, receiveBuffer, nil
}
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.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
- copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
+ copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset + len(data) < request.MARSHALLED_TOTAL_SIZE {
- *offset += len(data)
- } else {
- if req, err := request.Unmarshal(*receiveBuffer); err != nil {
- Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
+ if *offset+len(data) < request.MARSHALLED_TOTAL_SIZE {
+ *offset += len(data)
+ } else {
+ if req, err := request.Unmarshal(*receiveBuffer); err != nil {
+ Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
- conn.Close()
+ conn.Close()
- return
- } else {
- req.Issuer.Conn = conn
- req.Issuer.Address = conn.RemoteAddr().(*net.TCPAddr).IP
+ return
+ } else {
+ req.Issuer.Conn = conn
+ req.Issuer.Address = conn.RemoteAddr().(*net.TCPAddr).IP
- req.Issuer.Conn.Events.Close.Attach(events.NewClosure(func() {
- req.Issuer.Conn = nil
- }))
+ req.Issuer.Conn.Events.Close.Attach(events.NewClosure(func() {
+ req.Issuer.Conn = nil
+ }))
- Events.ReceiveRequest.Trigger(req)
- }
+ Events.ReceiveRequest.Trigger(req)
+ }
- *connectionState = STATE_INITIAL
+ *connectionState = STATE_INITIAL
- if *offset + len(data) > request.MARSHALLED_TOTAL_SIZE {
- ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
- }
- }
+ if *offset+len(data) > request.MARSHALLED_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.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
- copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
+ copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset + len(data) < response.MARSHALLED_TOTAL_SIZE {
- *offset += len(data)
- } else {
- if res, err := response.Unmarshal(*receiveBuffer); err != nil {
- Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
+ if *offset+len(data) < response.MARSHALLED_TOTAL_SIZE {
+ *offset += len(data)
+ } else {
+ if res, err := response.Unmarshal(*receiveBuffer); err != nil {
+ Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
- conn.Close()
+ conn.Close()
- return
- } else {
- res.Issuer.Conn = conn
- res.Issuer.Address = conn.RemoteAddr().(*net.TCPAddr).IP
+ return
+ } else {
+ res.Issuer.Conn = conn
+ res.Issuer.Address = conn.RemoteAddr().(*net.TCPAddr).IP
- res.Issuer.Conn.Events.Close.Attach(events.NewClosure(func() {
- res.Issuer.Conn = nil
- }))
+ res.Issuer.Conn.Events.Close.Attach(events.NewClosure(func() {
+ res.Issuer.Conn = nil
+ }))
- Events.ReceiveResponse.Trigger(res)
- }
+ Events.ReceiveResponse.Trigger(res)
+ }
- *connectionState = STATE_INITIAL
+ *connectionState = STATE_INITIAL
- if *offset + len(data) > response.MARSHALLED_TOTAL_SIZE {
- ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
- }
- }
+ if *offset+len(data) > response.MARSHALLED_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.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
- copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
+ copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
- if *offset + len(data) < ping.MARSHALLED_TOTAL_SIZE {
- *offset += len(data)
- } else {
- if ping, err := ping.Unmarshal(*receiveBuffer); err != nil {
- Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
+ if *offset+len(data) < ping.MARSHALLED_TOTAL_SIZE {
+ *offset += len(data)
+ } else {
+ if ping, err := ping.Unmarshal(*receiveBuffer); err != nil {
+ Events.Error.Trigger(conn.RemoteAddr().(*net.TCPAddr).IP, err)
- conn.Close()
+ conn.Close()
- return
- } else {
- ping.Issuer.Conn = conn
- ping.Issuer.Address = conn.RemoteAddr().(*net.TCPAddr).IP
+ return
+ } else {
+ ping.Issuer.Conn = conn
+ ping.Issuer.Address = conn.RemoteAddr().(*net.TCPAddr).IP
- ping.Issuer.Conn.Events.Close.Attach(events.NewClosure(func() {
- ping.Issuer.Conn = nil
- }))
+ ping.Issuer.Conn.Events.Close.Attach(events.NewClosure(func() {
+ ping.Issuer.Conn = nil
+ }))
- Events.ReceivePing.Trigger(ping)
- }
+ Events.ReceivePing.Trigger(ping)
+ }
- *connectionState = STATE_INITIAL
+ *connectionState = STATE_INITIAL
- if *offset + len(data) > ping.MARSHALLED_TOTAL_SIZE {
- ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
- }
- }
+ if *offset+len(data) > ping.MARSHALLED_TOTAL_SIZE {
+ ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
+ }
+ }
}
diff --git a/plugins/autopeering/server/udp/events.go b/plugins/autopeering/server/udp/events.go
index d69667c4e1b4062af4e92de56d91979a63f03b46..6db7f3fc961c6a13d5260744a5383f77451d31e8 100644
--- a/plugins/autopeering/server/udp/events.go
+++ b/plugins/autopeering/server/udp/events.go
@@ -1,30 +1,41 @@
package udp
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
- "net"
+ "net"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
)
var Events = struct {
- ReceiveDrop *events.Event
- ReceivePing *events.Event
- ReceiveRequest *events.Event
- ReceiveResponse *events.Event
- Error *events.Event
+ ReceiveDrop *events.Event
+ ReceivePing *events.Event
+ ReceiveRequest *events.Event
+ ReceiveResponse *events.Event
+ Error *events.Event
}{
- events.NewEvent(dropCaller),
- events.NewEvent(pingCaller),
- events.NewEvent(requestCaller),
- events.NewEvent(responseCaller),
- events.NewEvent(errorCaller),
+ events.NewEvent(dropCaller),
+ events.NewEvent(pingCaller),
+ events.NewEvent(requestCaller),
+ events.NewEvent(responseCaller),
+ events.NewEvent(errorCaller),
}
-func dropCaller(handler interface{}, params ...interface{}) { handler.(func(*drop.Drop))(params[0].(*drop.Drop)) }
-func pingCaller(handler interface{}, params ...interface{}) { handler.(func(*ping.Ping))(params[0].(*ping.Ping)) }
-func requestCaller(handler interface{}, params ...interface{}) { handler.(func(*request.Request))(params[0].(*request.Request)) }
-func responseCaller(handler interface{}, params ...interface{}) { handler.(func(*response.Response))(params[0].(*response.Response)) }
-func errorCaller(handler interface{}, params ...interface{}) { handler.(func(net.IP, error))(params[0].(net.IP), params[1].(error)) }
+func dropCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*drop.Drop))(params[0].(*drop.Drop))
+}
+func pingCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*ping.Ping))(params[0].(*ping.Ping))
+}
+func requestCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*request.Request))(params[0].(*request.Request))
+}
+func responseCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*response.Response))(params[0].(*response.Response))
+}
+func errorCaller(handler interface{}, params ...interface{}) {
+ handler.(func(net.IP, error))(params[0].(net.IP), params[1].(error))
+}
diff --git a/plugins/autopeering/server/udp/server.go b/plugins/autopeering/server/udp/server.go
index 72ed9cdb1b408bc360492e21f154035eaf45a844..563a9d88bd6bb5be29019d9b0479f3b43d9b9c3f 100644
--- a/plugins/autopeering/server/udp/server.go
+++ b/plugins/autopeering/server/udp/server.go
@@ -1,98 +1,98 @@
package udp
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/network/udp"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
- "github.com/pkg/errors"
- "math"
- "net"
- "strconv"
+ "math"
+ "net"
+ "strconv"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/network/udp"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/parameters"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/drop"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/ping"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
+ "github.com/pkg/errors"
)
var udpServer = udp.NewServer(int(math.Max(float64(request.MARSHALLED_TOTAL_SIZE), float64(response.MARSHALLED_TOTAL_SIZE))))
func ConfigureServer(plugin *node.Plugin) {
- Events.Error.Attach(events.NewClosure(func(ip net.IP, err error) {
- plugin.LogFailure(err.Error())
- }))
+ Events.Error.Attach(events.NewClosure(func(ip net.IP, err error) {
+ plugin.LogFailure(err.Error())
+ }))
- udpServer.Events.ReceiveData.Attach(events.NewClosure(processReceivedData))
- udpServer.Events.Error.Attach(events.NewClosure(func(err error) {
- plugin.LogFailure("error in udp server: " + err.Error())
- }))
- udpServer.Events.Start.Attach(events.NewClosure(func() {
- if *parameters.ADDRESS.Value == "0.0.0.0" {
- plugin.LogSuccess("Starting UDP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
- } else {
- plugin.LogSuccess("Starting UDP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
- }
- }))
- udpServer.Events.Shutdown.Attach(events.NewClosure(func() {
- plugin.LogSuccess("Stopping UDP Server ... done")
- }))
+ udpServer.Events.ReceiveData.Attach(events.NewClosure(processReceivedData))
+ udpServer.Events.Error.Attach(events.NewClosure(func(err error) {
+ plugin.LogFailure("error in udp server: " + err.Error())
+ }))
+ udpServer.Events.Start.Attach(events.NewClosure(func() {
+ if *parameters.ADDRESS.Value == "0.0.0.0" {
+ plugin.LogSuccess("Starting UDP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
+ } else {
+ plugin.LogSuccess("Starting UDP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ... done")
+ }
+ }))
+ udpServer.Events.Shutdown.Attach(events.NewClosure(func() {
+ plugin.LogSuccess("Stopping UDP Server ... done")
+ }))
}
func RunServer(plugin *node.Plugin) {
- daemon.BackgroundWorker(func() {
- if *parameters.ADDRESS.Value == "0.0.0.0" {
- plugin.LogInfo("Starting UDP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ...")
- } else {
- plugin.LogInfo("Starting UDP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ...")
- }
+ daemon.BackgroundWorker(func() {
+ if *parameters.ADDRESS.Value == "0.0.0.0" {
+ plugin.LogInfo("Starting UDP Server (port " + strconv.Itoa(*parameters.PORT.Value) + ") ...")
+ } else {
+ plugin.LogInfo("Starting UDP Server (" + *parameters.ADDRESS.Value + ":" + strconv.Itoa(*parameters.PORT.Value) + ") ...")
+ }
- udpServer.Listen(*parameters.ADDRESS.Value, *parameters.PORT.Value)
- })
+ udpServer.Listen(*parameters.ADDRESS.Value, *parameters.PORT.Value)
+ })
}
func ShutdownUDPServer(plugin *node.Plugin) {
- plugin.LogInfo("Stopping UDP Server ...")
+ plugin.LogInfo("Stopping UDP Server ...")
- udpServer.Shutdown()
+ udpServer.Shutdown()
}
func processReceivedData(addr *net.UDPAddr, data []byte) {
- switch data[0] {
- case request.MARSHALLED_PACKET_HEADER:
- if peeringRequest, err := request.Unmarshal(data); err != nil {
- Events.Error.Trigger(addr.IP, err)
- } else {
- peeringRequest.Issuer.Address = addr.IP
+ switch data[0] {
+ case request.MARSHALLED_PACKET_HEADER:
+ if peeringRequest, err := request.Unmarshal(data); err != nil {
+ Events.Error.Trigger(addr.IP, err)
+ } else {
+ peeringRequest.Issuer.Address = addr.IP
- Events.ReceiveRequest.Trigger(peeringRequest)
- }
- case response.MARHSALLED_PACKET_HEADER:
- if peeringResponse, err := response.Unmarshal(data); err != nil {
- Events.Error.Trigger(addr.IP, err)
- } else {
- peeringResponse.Issuer.Address = addr.IP
+ Events.ReceiveRequest.Trigger(peeringRequest)
+ }
+ case response.MARHSALLED_PACKET_HEADER:
+ if peeringResponse, err := response.Unmarshal(data); err != nil {
+ Events.Error.Trigger(addr.IP, err)
+ } else {
+ peeringResponse.Issuer.Address = addr.IP
- Events.ReceiveResponse.Trigger(peeringResponse)
- }
- case ping.MARSHALLED_PACKET_HEADER:
- if ping, err := ping.Unmarshal(data); err != nil {
- Events.Error.Trigger(addr.IP, err)
- } else {
- ping.Issuer.Address = addr.IP
+ Events.ReceiveResponse.Trigger(peeringResponse)
+ }
+ case ping.MARSHALLED_PACKET_HEADER:
+ if ping, err := ping.Unmarshal(data); err != nil {
+ Events.Error.Trigger(addr.IP, err)
+ } else {
+ ping.Issuer.Address = addr.IP
- Events.ReceivePing.Trigger(ping)
- }
- case drop.MARSHALLED_PACKET_HEADER:
- if drop, err := drop.Unmarshal(data); err != nil {
- Events.Error.Trigger(addr.IP, err)
- } else {
- drop.Issuer.Address = addr.IP
+ Events.ReceivePing.Trigger(ping)
+ }
+ case drop.MARSHALLED_PACKET_HEADER:
+ if drop, err := drop.Unmarshal(data); err != nil {
+ Events.Error.Trigger(addr.IP, err)
+ } else {
+ drop.Issuer.Address = addr.IP
- Events.ReceiveDrop.Trigger(drop)
- }
- default:
- Events.Error.Trigger(addr.IP, errors.New("invalid UDP peering packet from " + addr.IP.String()))
- }
+ Events.ReceiveDrop.Trigger(drop)
+ }
+ default:
+ Events.Error.Trigger(addr.IP, errors.New("invalid UDP peering packet from "+addr.IP.String()))
+ }
}
-
diff --git a/plugins/autopeering/types/drop/constants.go b/plugins/autopeering/types/drop/constants.go
index 09c7b3c1b250d2f4212e469166e7bc15d17b66d9..ccc3c1d60615068835bca901a118aa43b745f479 100644
--- a/plugins/autopeering/types/drop/constants.go
+++ b/plugins/autopeering/types/drop/constants.go
@@ -1,23 +1,23 @@
package drop
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
const (
- MARSHALLED_PACKET_HEADER = 0x05
+ MARSHALLED_PACKET_HEADER = 0x05
- PACKET_HEADER_START = 0
- MARSHALLED_ISSUER_START = PACKET_HEADER_END
- MARSHALLED_SIGNATURE_START = MARSHALLED_ISSUER_END
+ PACKET_HEADER_START = 0
+ MARSHALLED_ISSUER_START = PACKET_HEADER_END
+ MARSHALLED_SIGNATURE_START = MARSHALLED_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
+ MARSHALLED_ISSUER_END = MARSHALLED_ISSUER_START + MARSHALLED_ISSUER_SIZE
+ MARSHALLED_SIGNATURE_END = MARSHALLED_SIGNATURE_START + MARSHALLED_SIGNATURE_SIZE
- PACKET_HEADER_SIZE = 1
- MARSHALLED_ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
- MARSHALLED_SIGNATURE_SIZE = 65
+ PACKET_HEADER_SIZE = 1
+ MARSHALLED_ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
+ MARSHALLED_SIGNATURE_SIZE = 65
- MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
)
diff --git a/plugins/autopeering/types/drop/drop.go b/plugins/autopeering/types/drop/drop.go
index 374be520b70150a05751c381da9240f7f6f66013..e86b5cfad5c5b4b693594a98df70e033f74c24ab 100644
--- a/plugins/autopeering/types/drop/drop.go
+++ b/plugins/autopeering/types/drop/drop.go
@@ -1,59 +1,60 @@
package drop
import (
- "bytes"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "bytes"
+
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
type Drop struct {
- Issuer *peer.Peer
- Signature [MARSHALLED_SIGNATURE_SIZE]byte
+ Issuer *peer.Peer
+ Signature [MARSHALLED_SIGNATURE_SIZE]byte
}
func Unmarshal(data []byte) (*Drop, error) {
- if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
- return nil, ErrMalformedDropMessage
- }
-
- ping := &Drop{}
-
- if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
- return nil, err
- } else {
- ping.Issuer = unmarshalledPeer
- }
- 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 {
- 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])
-
- return ping, nil
+ if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+ return nil, ErrMalformedDropMessage
+ }
+
+ ping := &Drop{}
+
+ if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+ return nil, err
+ } else {
+ ping.Issuer = unmarshalledPeer
+ }
+ 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 {
+ 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])
+
+ return ping, nil
}
func (ping *Drop) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALLED_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] = 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])
- return result
+ return result
}
func (this *Drop) Sign() {
- if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_SIGNATURE_START]); err != nil {
- panic(err)
- } else {
- copy(this.Signature[:], signature)
- }
+ if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_SIGNATURE_START]); err != nil {
+ panic(err)
+ } else {
+ copy(this.Signature[:], signature)
+ }
}
diff --git a/plugins/autopeering/types/drop/errors.go b/plugins/autopeering/types/drop/errors.go
index 4c7db5bb411b5f19d46c67ad493b818fa8345dd7..d2878718dd96e805ef30aeb0dbbce7bf854aaadf 100644
--- a/plugins/autopeering/types/drop/errors.go
+++ b/plugins/autopeering/types/drop/errors.go
@@ -3,6 +3,6 @@ package drop
import "github.com/pkg/errors"
var (
- ErrInvalidSignature = errors.New("invalid signature in drop message")
- ErrMalformedDropMessage = errors.New("malformed drop message")
+ ErrInvalidSignature = errors.New("invalid signature in drop message")
+ ErrMalformedDropMessage = errors.New("malformed drop message")
)
diff --git a/plugins/autopeering/types/peer/constants.go b/plugins/autopeering/types/peer/constants.go
index aa1567093ab5d9c4e243164596a454f1c4db45ef..28e0461127f5405e414b1c6cd52373747432ffd9 100644
--- a/plugins/autopeering/types/peer/constants.go
+++ b/plugins/autopeering/types/peer/constants.go
@@ -1,30 +1,30 @@
package peer
import (
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
)
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
+ 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
- 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
+ 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
- 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
+ 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
)
diff --git a/plugins/autopeering/types/peer/peer.go b/plugins/autopeering/types/peer/peer.go
index 088ea1afa1fb24680e02df4814ed209d972f69dd..bd3605d868712fe77d71a7333f2d8dc4a772084a 100644
--- a/plugins/autopeering/types/peer/peer.go
+++ b/plugins/autopeering/types/peer/peer.go
@@ -1,147 +1,148 @@
package peer
import (
- "encoding/binary"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/packages/network"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
- "github.com/pkg/errors"
- "net"
- "strconv"
- "sync"
+ "encoding/binary"
+ "net"
+ "strconv"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/salt"
+ "github.com/pkg/errors"
)
type Peer struct {
- Identity *identity.Identity
- Address net.IP
- PeeringPort uint16
- GossipPort uint16
- Salt *salt.Salt
- Conn *network.ManagedConnection
- connectMutex sync.Mutex
+ Identity *identity.Identity
+ Address net.IP
+ PeeringPort uint16
+ GossipPort uint16
+ Salt *salt.Salt
+ Conn *network.ManagedConnection
+ connectMutex sync.Mutex
}
func Unmarshal(data []byte) (*Peer, error) {
- if len(data) < MARSHALLED_TOTAL_SIZE {
- return nil, errors.New("size of marshalled peer is too small")
- }
-
- peer := &Peer{
- Identity: identity.NewIdentity(data[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END]),
- }
-
- switch data[MARSHALLED_ADDRESS_TYPE_START] {
- case types.ADDRESS_TYPE_IPV4:
- peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END]).To4()
- case types.ADDRESS_TYPE_IPV6:
- peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_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])
-
- if unmarshalledSalt, err := salt.Unmarshal(data[MARSHALLED_SALT_START:MARSHALLED_SALT_END]); err != nil {
- return nil, err
- } else {
- peer.Salt = unmarshalledSalt
- }
-
- return peer, nil
+ if len(data) < MARSHALLED_TOTAL_SIZE {
+ return nil, errors.New("size of marshalled peer is too small")
+ }
+
+ peer := &Peer{
+ Identity: identity.NewIdentity(data[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END]),
+ }
+
+ switch data[MARSHALLED_ADDRESS_TYPE_START] {
+ case types.ADDRESS_TYPE_IPV4:
+ peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END]).To4()
+ case types.ADDRESS_TYPE_IPV6:
+ peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_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])
+
+ if unmarshalledSalt, err := salt.Unmarshal(data[MARSHALLED_SALT_START:MARSHALLED_SALT_END]); err != nil {
+ return nil, err
+ } else {
+ peer.Salt = unmarshalledSalt
+ }
+
+ return peer, nil
}
// sends data and
func (peer *Peer) Send(data []byte, protocol types.ProtocolType, responseExpected bool) (bool, error) {
- conn, dialed, err := peer.Connect(protocol)
- if err != nil {
- return false, err
- }
+ conn, dialed, err := peer.Connect(protocol)
+ if err != nil {
+ return false, err
+ }
- if _, err := conn.Write(data); err != nil {
- return false, err
- }
+ if _, err := conn.Write(data); err != nil {
+ return false, err
+ }
- if dialed && !responseExpected {
- conn.Close()
- }
+ if dialed && !responseExpected {
+ conn.Close()
+ }
- return dialed, nil
+ return dialed, nil
}
func (peer *Peer) ConnectTCP() (*network.ManagedConnection, bool, error) {
- if peer.Conn == nil {
- peer.connectMutex.Lock()
- defer peer.connectMutex.Unlock()
-
- if peer.Conn == nil {
- conn, err := net.Dial("tcp", peer.Address.String() + ":" + strconv.Itoa(int(peer.PeeringPort)))
- if err != nil {
- return nil, false, errors.New("error when connecting to " + peer.String() + ": " + err.Error())
- } else {
- peer.Conn = network.NewManagedConnection(conn)
-
- peer.Conn.Events.Close.Attach(events.NewClosure(func() {
- peer.Conn = nil
- }))
-
- return peer.Conn, true, nil
- }
- }
- }
-
- return peer.Conn, false, nil
+ if peer.Conn == nil {
+ peer.connectMutex.Lock()
+ defer peer.connectMutex.Unlock()
+
+ if peer.Conn == nil {
+ conn, err := net.Dial("tcp", peer.Address.String()+":"+strconv.Itoa(int(peer.PeeringPort)))
+ if err != nil {
+ return nil, false, errors.New("error when connecting to " + peer.String() + ": " + err.Error())
+ } else {
+ peer.Conn = network.NewManagedConnection(conn)
+
+ peer.Conn.Events.Close.Attach(events.NewClosure(func() {
+ peer.Conn = nil
+ }))
+
+ return peer.Conn, true, nil
+ }
+ }
+ }
+
+ return peer.Conn, false, nil
}
func (peer *Peer) ConnectUDP() (*network.ManagedConnection, bool, error) {
- conn, err := net.Dial("udp", peer.Address.String() + ":" + strconv.Itoa(int(peer.PeeringPort)))
- if err != nil {
- return nil, false, errors.New("error when connecting to " + peer.Address.String() + ": " + err.Error())
- }
+ conn, err := net.Dial("udp", peer.Address.String()+":"+strconv.Itoa(int(peer.PeeringPort)))
+ if err != nil {
+ return nil, false, errors.New("error when connecting to " + peer.Address.String() + ": " + err.Error())
+ }
- return network.NewManagedConnection(conn), true, nil
+ return network.NewManagedConnection(conn), true, nil
}
func (peer *Peer) Connect(protocol types.ProtocolType) (*network.ManagedConnection, bool, error) {
- switch protocol {
- case types.PROTOCOL_TYPE_TCP:
- return peer.ConnectTCP()
- case types.PROTOCOL_TYPE_UDP:
- return peer.ConnectUDP()
- default:
- return nil, false, errors.New("unsupported peering protocol in peer " + peer.Address.String())
- }
+ switch protocol {
+ case types.PROTOCOL_TYPE_TCP:
+ return peer.ConnectTCP()
+ case types.PROTOCOL_TYPE_UDP:
+ return peer.ConnectUDP()
+ default:
+ return nil, false, errors.New("unsupported peering protocol in peer " + peer.Address.String())
+ }
}
func (peer *Peer) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALLED_TOTAL_SIZE)
- copy(result[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END],
- peer.Identity.PublicKey[:MARSHALLED_PUBLIC_KEY_SIZE])
+ copy(result[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END],
+ peer.Identity.PublicKey[:MARSHALLED_PUBLIC_KEY_SIZE])
- switch len(peer.Address) {
- case net.IPv4len:
- result[MARSHALLED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV4
- case net.IPv6len:
- result[MARSHALLED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV6
- default:
- panic("invalid address in peer")
- }
+ switch len(peer.Address) {
+ case net.IPv4len:
+ result[MARSHALLED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV4
+ case net.IPv6len:
+ result[MARSHALLED_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[MARSHALLED_ADDRESS_START:MARSHALLED_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[MARSHALLED_PEERING_PORT_START:MARSHALLED_PEERING_PORT_END], peer.PeeringPort)
+ binary.BigEndian.PutUint16(result[MARSHALLED_GOSSIP_PORT_START:MARSHALLED_GOSSIP_PORT_END], peer.GossipPort)
- copy(result[MARSHALLED_SALT_START:MARSHALLED_SALT_END], peer.Salt.Marshal())
+ copy(result[MARSHALLED_SALT_START:MARSHALLED_SALT_END], peer.Salt.Marshal())
- return result
+ return result
}
func (peer *Peer) String() string {
- if peer.Identity != nil {
- return peer.Address.String() + ":" + strconv.Itoa(int(peer.PeeringPort)) + " / " + peer.Identity.StringIdentifier
- } else {
- return peer.Address.String() + ":" + strconv.Itoa(int(peer.PeeringPort))
- }
+ if peer.Identity != nil {
+ return peer.Address.String() + ":" + strconv.Itoa(int(peer.PeeringPort)) + " / " + peer.Identity.StringIdentifier
+ } else {
+ return peer.Address.String() + ":" + strconv.Itoa(int(peer.PeeringPort))
+ }
}
diff --git a/plugins/autopeering/types/peerlist/peer_list.go b/plugins/autopeering/types/peerlist/peer_list.go
index f31af2f4c9502d1d3cf3cdb684cdf964854f0180..d33e15fc566e563956851c5fe4d440f5b58c4519 100644
--- a/plugins/autopeering/types/peerlist/peer_list.go
+++ b/plugins/autopeering/types/peerlist/peer_list.go
@@ -1,42 +1,41 @@
package peerlist
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "sort"
+ "sort"
+
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
type PeerList []*peer.Peer
func (this PeerList) Clone() PeerList {
- result := make(PeerList, len(this))
- for i, entry := range this {
- result[i] = entry
- }
+ result := make(PeerList, len(this))
+ for i, entry := range this {
+ result[i] = entry
+ }
- return result
+ return result
}
func (this PeerList) Filter(predicate func(p *peer.Peer) bool) PeerList {
- peerList := make(PeerList, len(this))
+ peerList := make(PeerList, len(this))
- counter := 0
- for _, peer := range this {
- if predicate(peer) {
- peerList[counter] = peer
- counter++
- }
- }
+ counter := 0
+ for _, peer := range this {
+ if predicate(peer) {
+ peerList[counter] = peer
+ counter++
+ }
+ }
- return peerList[:counter]
+ return peerList[:counter]
}
// Sorts the PeerRegister by their distance to an anchor.
func (this PeerList) Sort(distance func(p *peer.Peer) uint64) PeerList {
- sort.Slice(this, func(i, j int) bool {
- return distance(this[i]) < distance(this[j])
- })
+ sort.Slice(this, func(i, j int) bool {
+ return distance(this[i]) < distance(this[j])
+ })
- return this
+ return this
}
-
-
diff --git a/plugins/autopeering/types/peerregister/events.go b/plugins/autopeering/types/peerregister/events.go
index 1bf6ca25f97e105d899bfd2683104a6ae0a63937..ee3479673755c479c745f281e74514ffd718ae52 100644
--- a/plugins/autopeering/types/peerregister/events.go
+++ b/plugins/autopeering/types/peerregister/events.go
@@ -1,14 +1,16 @@
package peerregister
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
type peerRegisterEvents struct {
- Add *events.Event
- Update *events.Event
- Remove *events.Event
+ Add *events.Event
+ Update *events.Event
+ Remove *events.Event
}
-func peerCaller(handler interface{}, params ...interface{}) { handler.(func(*peer.Peer))(params[0].(*peer.Peer)) }
+func peerCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*peer.Peer))(params[0].(*peer.Peer))
+}
diff --git a/plugins/autopeering/types/peerregister/peer_register.go b/plugins/autopeering/types/peerregister/peer_register.go
index 1ab502c507bb8116347388ad0814b29949b7a5f3..abb97e52c96669afc18bc150f1c377a28a233ba1 100644
--- a/plugins/autopeering/types/peerregister/peer_register.go
+++ b/plugins/autopeering/types/peerregister/peer_register.go
@@ -1,104 +1,105 @@
package peerregister
import (
- "bytes"
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
- "sync"
+ "bytes"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/request"
)
type PeerRegister struct {
- Peers map[string]*peer.Peer
- Events peerRegisterEvents
- lock sync.RWMutex
+ Peers map[string]*peer.Peer
+ Events peerRegisterEvents
+ lock sync.RWMutex
}
func New() *PeerRegister {
- return &PeerRegister{
- Peers: make(map[string]*peer.Peer),
- Events: peerRegisterEvents{
- Add: events.NewEvent(peerCaller),
- Update: events.NewEvent(peerCaller),
- Remove: events.NewEvent(peerCaller),
- },
- }
+ return &PeerRegister{
+ Peers: make(map[string]*peer.Peer),
+ Events: peerRegisterEvents{
+ Add: events.NewEvent(peerCaller),
+ Update: events.NewEvent(peerCaller),
+ Remove: events.NewEvent(peerCaller),
+ },
+ }
}
// returns true if a new entry was added
-func (this *PeerRegister) AddOrUpdate(peer *peer.Peer, lock... bool) bool {
- if len(lock) == 0 || lock[0] {
- defer this.Lock()()
- }
+func (this *PeerRegister) AddOrUpdate(peer *peer.Peer, lock ...bool) bool {
+ if len(lock) == 0 || lock[0] {
+ defer this.Lock()()
+ }
- if peer.Identity == nil || bytes.Equal(peer.Identity.Identifier, accountability.OwnId().Identifier) {
- return false
- }
+ if peer.Identity == nil || bytes.Equal(peer.Identity.Identifier, accountability.OwnId().Identifier) {
+ return false
+ }
- if existingPeer, exists := this.Peers[peer.Identity.StringIdentifier]; exists {
- existingPeer.Address = peer.Address
- existingPeer.GossipPort = peer.GossipPort
- existingPeer.PeeringPort = peer.PeeringPort
+ if existingPeer, exists := this.Peers[peer.Identity.StringIdentifier]; exists {
+ existingPeer.Address = peer.Address
+ existingPeer.GossipPort = peer.GossipPort
+ existingPeer.PeeringPort = peer.PeeringPort
- this.Events.Update.Trigger(existingPeer)
+ this.Events.Update.Trigger(existingPeer)
- return false
- } else {
- this.Peers[peer.Identity.StringIdentifier] = peer
+ return false
+ } else {
+ this.Peers[peer.Identity.StringIdentifier] = peer
- this.Events.Add.Trigger(peer)
+ this.Events.Add.Trigger(peer)
- return true
- }
+ return true
+ }
}
// by calling defer peerRegister.Lock()() we can auto-lock AND unlock (note: two parentheses)
func (this *PeerRegister) Lock() func() {
- this.lock.Lock()
+ this.lock.Lock()
- return this.lock.Unlock
+ return this.lock.Unlock
}
-func (this *PeerRegister) Remove(key string, lock... bool) {
- if peerEntry, exists := this.Peers[key]; exists {
- if len(lock) == 0 || lock[0] {
- defer this.Lock()()
+func (this *PeerRegister) Remove(key string, lock ...bool) {
+ if peerEntry, exists := this.Peers[key]; exists {
+ if len(lock) == 0 || lock[0] {
+ defer this.Lock()()
- if peerEntry, exists := this.Peers[key]; exists {
- delete(this.Peers, key)
+ if peerEntry, exists := this.Peers[key]; exists {
+ delete(this.Peers, key)
- this.Events.Remove.Trigger(peerEntry)
- }
- } else {
- delete(this.Peers, key)
+ this.Events.Remove.Trigger(peerEntry)
+ }
+ } else {
+ delete(this.Peers, key)
- this.Events.Remove.Trigger(peerEntry)
- }
- }
+ this.Events.Remove.Trigger(peerEntry)
+ }
+ }
}
func (this *PeerRegister) Contains(key string) bool {
- if _, exists := this.Peers[key]; exists {
- return true
- } else {
- return false
- }
+ if _, exists := this.Peers[key]; exists {
+ return true
+ } else {
+ return false
+ }
}
func (this *PeerRegister) Filter(filterFn func(this *PeerRegister, req *request.Request) *PeerRegister, req *request.Request) *PeerRegister {
- return filterFn(this, req)
+ return filterFn(this, req)
}
func (this *PeerRegister) List() peerlist.PeerList {
- peerList := make(peerlist.PeerList, len(this.Peers))
+ peerList := make(peerlist.PeerList, len(this.Peers))
- counter := 0
- for _, currentPeer := range this.Peers {
- peerList[counter] = currentPeer
- counter++
- }
+ counter := 0
+ for _, currentPeer := range this.Peers {
+ peerList[counter] = currentPeer
+ counter++
+ }
- return peerList
+ return peerList
}
diff --git a/plugins/autopeering/types/ping/constants.go b/plugins/autopeering/types/ping/constants.go
index f43adf9557ff61a6d8147986f1b7a1afa5dbcb97..6d37911b040aec78350655f6f90e96a0409af76a 100644
--- a/plugins/autopeering/types/ping/constants.go
+++ b/plugins/autopeering/types/ping/constants.go
@@ -1,29 +1,29 @@
package ping
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
const (
- MARSHALLED_PACKET_HEADER = 0x04
+ MARSHALLED_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
+ MARSHALLED_ISSUER_START = PACKET_HEADER_END
+ MARSHALLED_PEERS_START = MARSHALLED_ISSUER_END
+ MARSHALLED_SIGNATURE_START = MARSHALLED_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
+ 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_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
+ 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
- MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
)
diff --git a/plugins/autopeering/types/ping/errors.go b/plugins/autopeering/types/ping/errors.go
index 218d60917a52a4080f5a2ed142b44ed43e23099f..51825205c449771cbc0feb3222adce9305fff6ad 100644
--- a/plugins/autopeering/types/ping/errors.go
+++ b/plugins/autopeering/types/ping/errors.go
@@ -3,6 +3,6 @@ package ping
import "github.com/pkg/errors"
var (
- ErrInvalidSignature = errors.New("invalid signature in ping")
- ErrMalformedPing = errors.New("malformed ping")
+ ErrInvalidSignature = errors.New("invalid signature in ping")
+ ErrMalformedPing = errors.New("malformed ping")
)
diff --git a/plugins/autopeering/types/ping/ping.go b/plugins/autopeering/types/ping/ping.go
index 3b25656d021e255f241304e132dbb3741903ca9e..3153d66034e37b0cf9e61141372bd1cd2ad69f83 100644
--- a/plugins/autopeering/types/ping/ping.go
+++ b/plugins/autopeering/types/ping/ping.go
@@ -1,84 +1,85 @@
package ping
import (
- "bytes"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
+ "bytes"
+
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peerlist"
)
type Ping struct {
- Issuer *peer.Peer
- Neighbors peerlist.PeerList
- Signature [MARSHALLED_SIGNATURE_SIZE]byte
+ Issuer *peer.Peer
+ Neighbors peerlist.PeerList
+ Signature [MARSHALLED_SIGNATURE_SIZE]byte
}
func Unmarshal(data []byte) (*Ping, error) {
- if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
- return nil, ErrMalformedPing
- }
-
- ping := &Ping{
- Neighbors: make(peerlist.PeerList, 0),
- }
-
- if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
- return nil, err
- } else {
- ping.Issuer = unmarshalledPeer
- }
- if err := saltmanager.CheckSalt(ping.Issuer.Salt); err != nil {
- return nil, err
- }
-
- offset := MARSHALLED_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 {
- return nil, err
- } else {
- ping.Neighbors = append(ping.Neighbors, unmarshalledPing)
- }
- }
-
- offset += MARSHALLED_PEER_ENTRY_SIZE
- }
-
- if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_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])
-
- return ping, nil
+ if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+ return nil, ErrMalformedPing
+ }
+
+ ping := &Ping{
+ Neighbors: make(peerlist.PeerList, 0),
+ }
+
+ if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+ return nil, err
+ } else {
+ ping.Issuer = unmarshalledPeer
+ }
+ if err := saltmanager.CheckSalt(ping.Issuer.Salt); err != nil {
+ return nil, err
+ }
+
+ offset := MARSHALLED_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 {
+ return nil, err
+ } else {
+ ping.Neighbors = append(ping.Neighbors, unmarshalledPing)
+ }
+ }
+
+ offset += MARSHALLED_PEER_ENTRY_SIZE
+ }
+
+ if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_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])
+
+ return ping, nil
}
func (ping *Ping) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALLED_TOTAL_SIZE)
- result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], ping.Issuer.Marshal())
- for i, neighbor := range ping.Neighbors {
- entryStartOffset := MARSHALLED_PEERS_START + i * MARSHALLED_PEER_ENTRY_SIZE
+ result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+ copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], ping.Issuer.Marshal())
+ for i, neighbor := range ping.Neighbors {
+ entryStartOffset := MARSHALLED_PEERS_START + i*MARSHALLED_PEER_ENTRY_SIZE
- result[entryStartOffset] = 1
+ result[entryStartOffset] = 1
- copy(result[entryStartOffset + 1:entryStartOffset + MARSHALLED_PEER_ENTRY_SIZE], neighbor.Marshal())
- }
- copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], ping.Signature[:MARSHALLED_SIGNATURE_SIZE])
+ copy(result[entryStartOffset+1:entryStartOffset+MARSHALLED_PEER_ENTRY_SIZE], neighbor.Marshal())
+ }
+ copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], ping.Signature[:MARSHALLED_SIGNATURE_SIZE])
- return result
+ return result
}
func (this *Ping) Sign() {
- if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_SIGNATURE_START]); err != nil {
- panic(err)
- } else {
- copy(this.Signature[:], signature)
- }
+ if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_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 b08423729828044b743e0794b2bd084f595830d5..c70d8427768f1fa52fa52b94dc52183b8b3284fd 100644
--- a/plugins/autopeering/types/request/constants.go
+++ b/plugins/autopeering/types/request/constants.go
@@ -1,23 +1,23 @@
package request
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
const (
- PACKET_HEADER_SIZE = 1
- ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
- SIGNATURE_SIZE = 65
+ PACKET_HEADER_SIZE = 1
+ ISSUER_SIZE = peer.MARSHALLED_TOTAL_SIZE
+ SIGNATURE_SIZE = 65
- PACKET_HEADER_START = 0
- ISSUER_START = PACKET_HEADER_END
- SIGNATURE_START = ISSUER_END
+ PACKET_HEADER_START = 0
+ ISSUER_START = PACKET_HEADER_END
+ SIGNATURE_START = ISSUER_END
- PACKET_HEADER_END = PACKET_HEADER_START + PACKET_HEADER_SIZE
- ISSUER_END = ISSUER_START + ISSUER_SIZE
- SIGNATURE_END = SIGNATURE_START + SIGNATURE_SIZE
+ PACKET_HEADER_END = PACKET_HEADER_START + PACKET_HEADER_SIZE
+ ISSUER_END = ISSUER_START + ISSUER_SIZE
+ SIGNATURE_END = SIGNATURE_START + SIGNATURE_SIZE
- MARSHALLED_TOTAL_SIZE = SIGNATURE_END
+ MARSHALLED_TOTAL_SIZE = SIGNATURE_END
- MARSHALLED_PACKET_HEADER = 0xBE
+ MARSHALLED_PACKET_HEADER = 0xBE
)
diff --git a/plugins/autopeering/types/request/errors.go b/plugins/autopeering/types/request/errors.go
index 8895aa9eb0057273f39d25e6da8eae94ce3c86a9..34831a9420ca5d18f44ea58d629b8503b840af95 100644
--- a/plugins/autopeering/types/request/errors.go
+++ b/plugins/autopeering/types/request/errors.go
@@ -3,8 +3,8 @@ package request
import "github.com/pkg/errors"
var (
- ErrPublicSaltExpired = errors.New("expired public salt in peering request")
- ErrPublicSaltInvalidLifetime = errors.New("invalid public salt lifetime")
- ErrInvalidSignature = errors.New("invalid signature in peering request")
- ErrMalformedPeeringRequest = errors.New("malformed peering request")
+ ErrPublicSaltExpired = errors.New("expired public salt in peering request")
+ ErrPublicSaltInvalidLifetime = errors.New("invalid public salt lifetime")
+ ErrInvalidSignature = errors.New("invalid signature in peering request")
+ ErrMalformedPeeringRequest = errors.New("malformed peering request")
)
diff --git a/plugins/autopeering/types/request/request.go b/plugins/autopeering/types/request/request.go
index b82c69ab49f2868aa193a9248a312b960d80618d..139765485b7d48379ce2c1c91a2815c923d03384 100644
--- a/plugins/autopeering/types/request/request.go
+++ b/plugins/autopeering/types/request/request.go
@@ -1,98 +1,99 @@
package request
import (
- "bytes"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
- "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
- "time"
+ "bytes"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/ownpeer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/types"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/response"
)
type Request struct {
- Issuer *peer.Peer
- Signature [SIGNATURE_SIZE]byte
+ Issuer *peer.Peer
+ Signature [SIGNATURE_SIZE]byte
}
func Unmarshal(data []byte) (*Request, error) {
- if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
- return nil, ErrMalformedPeeringRequest
- }
-
- peeringRequest := &Request{}
-
- if unmarshalledPeer, err := peer.Unmarshal(data[ISSUER_START:ISSUER_END]); err != nil {
- return nil, err
- } else {
- peeringRequest.Issuer = unmarshalledPeer
- }
-
- now := time.Now()
- if peeringRequest.Issuer.Salt.ExpirationTime.Before(now.Add(-1 * time.Minute)) {
- return nil, ErrPublicSaltExpired
- }
- if peeringRequest.Issuer.Salt.ExpirationTime.After(now.Add(saltmanager.PUBLIC_SALT_LIFETIME + 1*time.Minute)) {
- return nil, ErrPublicSaltInvalidLifetime
- }
-
- if issuer, err := identity.FromSignedData(data[:SIGNATURE_START], data[SIGNATURE_START:]); err != nil {
- return nil, err
- } else {
- if !bytes.Equal(issuer.Identifier, peeringRequest.Issuer.Identity.Identifier) {
- return nil, ErrInvalidSignature
- }
- }
- copy(peeringRequest.Signature[:], data[SIGNATURE_START:SIGNATURE_END])
-
- return peeringRequest, nil
+ if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+ return nil, ErrMalformedPeeringRequest
+ }
+
+ peeringRequest := &Request{}
+
+ if unmarshalledPeer, err := peer.Unmarshal(data[ISSUER_START:ISSUER_END]); err != nil {
+ return nil, err
+ } else {
+ peeringRequest.Issuer = unmarshalledPeer
+ }
+
+ now := time.Now()
+ if peeringRequest.Issuer.Salt.ExpirationTime.Before(now.Add(-1 * time.Minute)) {
+ return nil, ErrPublicSaltExpired
+ }
+ if peeringRequest.Issuer.Salt.ExpirationTime.After(now.Add(saltmanager.PUBLIC_SALT_LIFETIME + 1*time.Minute)) {
+ return nil, ErrPublicSaltInvalidLifetime
+ }
+
+ if issuer, err := identity.FromSignedData(data[:SIGNATURE_START], data[SIGNATURE_START:]); err != nil {
+ return nil, err
+ } else {
+ if !bytes.Equal(issuer.Identifier, peeringRequest.Issuer.Identity.Identifier) {
+ return nil, ErrInvalidSignature
+ }
+ }
+ copy(peeringRequest.Signature[:], data[SIGNATURE_START:SIGNATURE_END])
+
+ return peeringRequest, nil
}
func (this *Request) Accept(peers []*peer.Peer) error {
- peeringResponse := &response.Response{
- Type: response.TYPE_ACCEPT,
- Issuer: ownpeer.INSTANCE,
- Peers: peers,
- }
- peeringResponse.Sign()
-
- if _, err := this.Issuer.Send(peeringResponse.Marshal(), types.PROTOCOL_TYPE_TCP, false); err != nil {
- return err
- }
-
- return nil
+ peeringResponse := &response.Response{
+ Type: response.TYPE_ACCEPT,
+ Issuer: ownpeer.INSTANCE,
+ Peers: peers,
+ }
+ peeringResponse.Sign()
+
+ if _, err := this.Issuer.Send(peeringResponse.Marshal(), types.PROTOCOL_TYPE_TCP, false); err != nil {
+ return err
+ }
+
+ return nil
}
func (this *Request) Reject(peers []*peer.Peer) error {
- peeringResponse := &response.Response{
- Type: response.TYPE_REJECT,
- Issuer: ownpeer.INSTANCE,
- Peers: peers,
- }
- peeringResponse.Sign()
-
- if _, err := this.Issuer.Send(peeringResponse.Marshal(), types.PROTOCOL_TYPE_TCP, false); err != nil {
- return err
- }
-
- return nil
+ peeringResponse := &response.Response{
+ Type: response.TYPE_REJECT,
+ Issuer: ownpeer.INSTANCE,
+ Peers: peers,
+ }
+ peeringResponse.Sign()
+
+ if _, err := this.Issuer.Send(peeringResponse.Marshal(), types.PROTOCOL_TYPE_TCP, false); err != nil {
+ return err
+ }
+
+ return nil
}
func (this *Request) Sign() {
- if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:SIGNATURE_START]); err != nil {
- panic(err)
- } else {
- copy(this.Signature[:], signature)
- }
+ if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:SIGNATURE_START]); err != nil {
+ panic(err)
+ } else {
+ copy(this.Signature[:], signature)
+ }
}
func (this *Request) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALLED_TOTAL_SIZE)
- result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
- copy(result[ISSUER_START:ISSUER_END], this.Issuer.Marshal())
- copy(result[SIGNATURE_START:SIGNATURE_END], this.Signature[:SIGNATURE_SIZE])
+ result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+ copy(result[ISSUER_START:ISSUER_END], this.Issuer.Marshal())
+ copy(result[SIGNATURE_START:SIGNATURE_END], this.Signature[:SIGNATURE_SIZE])
- return result
+ return result
}
diff --git a/plugins/autopeering/types/response/constants.go b/plugins/autopeering/types/response/constants.go
index 86f65ef94b71838d606bd6a0afc8b5d33beb86b2..b5f8db127ab8b0a522d0fbfde05f9d671431acea 100644
--- a/plugins/autopeering/types/response/constants.go
+++ b/plugins/autopeering/types/response/constants.go
@@ -1,35 +1,35 @@
package response
import (
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
)
const (
- TYPE_REJECT = Type(0)
- TYPE_ACCEPT = Type(1)
+ TYPE_REJECT = Type(0)
+ TYPE_ACCEPT = Type(1)
- MARSHALLED_PEERS_AMOUNT = constants.NEIGHBOR_COUNT + constants.NEIGHBOR_COUNT * constants.NEIGHBOR_COUNT
- MARHSALLED_PACKET_HEADER = 0xBC
+ MARSHALLED_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
+ 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
- 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
+ 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
- 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
+ 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
)
diff --git a/plugins/autopeering/types/response/errors.go b/plugins/autopeering/types/response/errors.go
index abda4d1fda24555173735923dabd7b968ad2cd9e..34d823a8666483d7bc3b0e1a7b113a581244825e 100644
--- a/plugins/autopeering/types/response/errors.go
+++ b/plugins/autopeering/types/response/errors.go
@@ -3,5 +3,5 @@ package response
import "github.com/pkg/errors"
var (
- ErrInvalidSignature = errors.New("invalid signature in peering request")
+ ErrInvalidSignature = errors.New("invalid signature in peering request")
)
diff --git a/plugins/autopeering/types/response/response.go b/plugins/autopeering/types/response/response.go
index 4151bb3da64f1d1322110c38687961e77b6978fe..7d75b6e0a3c0c26b142648698dfe27d6f6e9ca6c 100644
--- a/plugins/autopeering/types/response/response.go
+++ b/plugins/autopeering/types/response/response.go
@@ -1,92 +1,93 @@
package response
import (
- "bytes"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
- "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
- "github.com/pkg/errors"
+ "bytes"
+
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/protocol/constants"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+ "github.com/pkg/errors"
)
type Response struct {
- Type Type
- Issuer *peer.Peer
- Peers []*peer.Peer
- Signature [MARSHALLED_SIGNATURE_SIZE]byte
+ Type Type
+ Issuer *peer.Peer
+ Peers []*peer.Peer
+ Signature [MARSHALLED_SIGNATURE_SIZE]byte
}
func Unmarshal(data []byte) (*Response, error) {
- if data[0] != MARHSALLED_PACKET_HEADER || len(data) < MARSHALLED_TOTAL_SIZE {
- return nil, errors.New("malformed peering response")
- }
-
- peeringResponse := &Response{
- Type: data[MARSHALLED_TYPE_START],
- Peers: make([]*peer.Peer, 0),
- }
-
- if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
- return nil, err
- } else {
- peeringResponse.Issuer = unmarshalledPeer
- }
-
- 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
-
- 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 err != nil {
- return nil, err
- }
-
- peeringResponse.Peers = append(peeringResponse.Peers, peer)
- }
- }
-
- if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_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])
-
- return peeringResponse, nil
+ if data[0] != MARHSALLED_PACKET_HEADER || len(data) < MARSHALLED_TOTAL_SIZE {
+ return nil, errors.New("malformed peering response")
+ }
+
+ peeringResponse := &Response{
+ Type: data[MARSHALLED_TYPE_START],
+ Peers: make([]*peer.Peer, 0),
+ }
+
+ if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+ return nil, err
+ } else {
+ peeringResponse.Issuer = unmarshalledPeer
+ }
+
+ 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
+
+ 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 err != nil {
+ return nil, err
+ }
+
+ peeringResponse.Peers = append(peeringResponse.Peers, peer)
+ }
+ }
+
+ if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_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])
+
+ return peeringResponse, nil
}
func (this *Response) Sign() *Response {
- dataToSign := this.Marshal()[:MARSHALLED_SIGNATURE_START]
- if signature, err := this.Issuer.Identity.Sign(dataToSign); err != nil {
- panic(err)
- } else {
- copy(this.Signature[:], signature)
- }
-
- return this
+ dataToSign := this.Marshal()[:MARSHALLED_SIGNATURE_START]
+ if signature, err := this.Issuer.Identity.Sign(dataToSign); err != nil {
+ panic(err)
+ } else {
+ copy(this.Signature[:], signature)
+ }
+
+ return this
}
func (this *Response) Marshal() []byte {
- result := make([]byte, MARSHALLED_TOTAL_SIZE)
+ result := make([]byte, MARSHALLED_TOTAL_SIZE)
- result[MARSHALLED_PACKET_HEADER_START] = MARHSALLED_PACKET_HEADER
- result[MARSHALLED_TYPE_START] = this.Type
+ result[MARSHALLED_PACKET_HEADER_START] = MARHSALLED_PACKET_HEADER
+ result[MARSHALLED_TYPE_START] = this.Type
- copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], this.Issuer.Marshal())
+ copy(result[MARSHALLED_ISSUER_START:MARSHALLED_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
+ 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
- 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_MARSHALLED_PEER_START] = 1
+ copy(result[PEERING_RESPONSE_MARSHALLED_PEER_START+1:PEERING_RESPONSE_MARSHALLED_PEER_END], peer.Marshal()[:MARSHALLED_PEER_SIZE-1])
+ }
+ }
- copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], this.Signature[:MARSHALLED_SIGNATURE_SIZE])
+ copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], this.Signature[:MARSHALLED_SIGNATURE_SIZE])
- return result
+ return result
}
diff --git a/plugins/autopeering/types/salt/constants.go b/plugins/autopeering/types/salt/constants.go
index 6c5d016d590f6b142ed1f93331d7d827f8978451..5b75dd07131c32e4f1ee1bc51a4a0d8a3a498a04 100644
--- a/plugins/autopeering/types/salt/constants.go
+++ b/plugins/autopeering/types/salt/constants.go
@@ -1,14 +1,14 @@
package salt
const (
- SALT_BYTES_SIZE = 20
- SALT_TIME_SIZE = 15
+ SALT_BYTES_SIZE = 20
+ SALT_TIME_SIZE = 15
- SALT_BYTES_START = 0
- SALT_TIME_START = SALT_BYTES_END
+ SALT_BYTES_START = 0
+ SALT_TIME_START = SALT_BYTES_END
- SALT_BYTES_END = SALT_BYTES_START + SALT_BYTES_SIZE
- SALT_TIME_END = SALT_TIME_START + SALT_TIME_SIZE
+ 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_MARSHALLED_SIZE = SALT_TIME_END
)
diff --git a/plugins/autopeering/types/salt/salt.go b/plugins/autopeering/types/salt/salt.go
index bc1555de1360bdeff87a101539ad58dc41f6b0d3..2da93db44ca1fbcc808d367da0967c658128df59 100644
--- a/plugins/autopeering/types/salt/salt.go
+++ b/plugins/autopeering/types/salt/salt.go
@@ -1,56 +1,57 @@
package salt
import (
- "crypto/rand"
- "github.com/pkg/errors"
- "time"
+ "crypto/rand"
+ "time"
+
+ "github.com/pkg/errors"
)
type Salt struct {
- Bytes []byte
- ExpirationTime time.Time
+ Bytes []byte
+ ExpirationTime time.Time
}
func New(lifetime time.Duration) *Salt {
- salt := &Salt{
- Bytes: make([]byte, SALT_BYTES_SIZE),
- ExpirationTime: time.Now().Add(lifetime),
- }
+ salt := &Salt{
+ Bytes: make([]byte, SALT_BYTES_SIZE),
+ ExpirationTime: time.Now().Add(lifetime),
+ }
- if _, err := rand.Read(salt.Bytes); err != nil {
- panic(err)
- }
+ if _, err := rand.Read(salt.Bytes); err != nil {
+ panic(err)
+ }
- return 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")
- }
+ if len(marshalledSalt) < SALT_MARSHALLED_SIZE {
+ return nil, errors.New("marshalled salt bytes not long enough")
+ }
- salt := &Salt{
- Bytes: make([]byte, SALT_BYTES_SIZE),
- }
- copy(salt.Bytes, marshalledSalt[SALT_BYTES_START:SALT_BYTES_END])
+ salt := &Salt{
+ Bytes: make([]byte, SALT_BYTES_SIZE),
+ }
+ copy(salt.Bytes, marshalledSalt[SALT_BYTES_START:SALT_BYTES_END])
- if err := salt.ExpirationTime.UnmarshalBinary(marshalledSalt[SALT_TIME_START:SALT_TIME_END]); err != nil {
- return nil, err
- }
+ if err := salt.ExpirationTime.UnmarshalBinary(marshalledSalt[SALT_TIME_START:SALT_TIME_END]); err != nil {
+ return nil, err
+ }
- return salt, nil
+ return salt, nil
}
func (this *Salt) Marshal() []byte {
- result := make([]byte, SALT_BYTES_SIZE+SALT_TIME_SIZE)
+ result := make([]byte, SALT_BYTES_SIZE+SALT_TIME_SIZE)
- copy(result[SALT_BYTES_START:SALT_BYTES_END], this.Bytes)
+ copy(result[SALT_BYTES_START:SALT_BYTES_END], this.Bytes)
- if bytes, err := this.ExpirationTime.MarshalBinary(); err != nil {
- panic(err)
- } else {
- copy(result[SALT_TIME_START:SALT_TIME_END], bytes)
- }
+ if bytes, err := this.ExpirationTime.MarshalBinary(); err != nil {
+ panic(err)
+ } else {
+ copy(result[SALT_TIME_START:SALT_TIME_END], bytes)
+ }
- return result
-}
\ No newline at end of file
+ return result
+}
diff --git a/plugins/cli/cli.go b/plugins/cli/cli.go
index 5676ae7269da776d04f1c4c1e64e2b1c15627392..ddb29b6ba76a65a41ed2a6e0f2956e5ebfe53015 100644
--- a/plugins/cli/cli.go
+++ b/plugins/cli/cli.go
@@ -1,34 +1,34 @@
package cli
import (
- "flag"
- "fmt"
- "os"
- "path/filepath"
+ "flag"
+ "fmt"
+ "os"
+ "path/filepath"
)
func AddIntParameter(p *int, name string, usage string) {
- flag.IntVar(p, name, *p, usage)
+ flag.IntVar(p, name, *p, usage)
}
func AddStringParameter(p *string, name string, usage string) {
- flag.StringVar(p, name, *p, usage)
+ flag.StringVar(p, name, *p, usage)
}
func printUsage() {
- _, err := fmt.Fprintf(
- os.Stderr,
- "\n" +
- "SHIMMER 1.0\n\n" +
- " A lightweight modular IOTA node.\n\n" +
- "Usage:\n\n" +
- " %s [OPTIONS]\n\n" +
- "Options:\n\n",
- filepath.Base(os.Args[0]),
- )
- if err != nil {
- panic(err)
- }
+ _, err := fmt.Fprintf(
+ os.Stderr,
+ "\n"+
+ "SHIMMER 1.0\n\n"+
+ " A lightweight modular IOTA node.\n\n"+
+ "Usage:\n\n"+
+ " %s [OPTIONS]\n\n"+
+ "Options:\n\n",
+ filepath.Base(os.Args[0]),
+ )
+ if err != nil {
+ panic(err)
+ }
- flag.PrintDefaults()
+ flag.PrintDefaults()
}
diff --git a/plugins/cli/plugin.go b/plugins/cli/plugin.go
index ff13c2d8dd09f7b6075d7e4fa62190c3a9873a83..c77cc83556bba49c9025c56d41092980865e7d6e 100644
--- a/plugins/cli/plugin.go
+++ b/plugins/cli/plugin.go
@@ -1,40 +1,41 @@
package cli
import (
- "flag"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/parameter"
- "strings"
+ "flag"
+ "strings"
+
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/parameter"
)
func onAddIntParameter(param *parameter.IntParameter) {
- flagName := strings.Replace(strings.Replace(strings.ToLower(param.Name), "/", "-", 1), "_", "-", -1)
+ flagName := strings.Replace(strings.Replace(strings.ToLower(param.Name), "/", "-", 1), "_", "-", -1)
- AddIntParameter(param.Value, flagName, param.Description)
+ AddIntParameter(param.Value, flagName, param.Description)
}
func onAddStringParameter(param *parameter.StringParameter) {
- flagName := strings.Replace(strings.Replace(strings.ToLower(param.Name), "/", "-", 1), "_", "-", -1)
+ flagName := strings.Replace(strings.Replace(strings.ToLower(param.Name), "/", "-", 1), "_", "-", -1)
- AddStringParameter(param.Value, flagName, param.Description)
+ AddStringParameter(param.Value, flagName, param.Description)
}
func init() {
- for _, param := range parameter.GetInts() {
- onAddIntParameter(param)
- }
+ for _, param := range parameter.GetInts() {
+ onAddIntParameter(param)
+ }
- for _, param := range parameter.GetStrings() {
- onAddStringParameter(param)
- }
+ for _, param := range parameter.GetStrings() {
+ onAddStringParameter(param)
+ }
- parameter.Events.AddInt.Attach(events.NewClosure(onAddIntParameter))
- parameter.Events.AddString.Attach(events.NewClosure(onAddStringParameter))
+ parameter.Events.AddInt.Attach(events.NewClosure(onAddIntParameter))
+ parameter.Events.AddString.Attach(events.NewClosure(onAddStringParameter))
- flag.Usage = printUsage
+ flag.Usage = printUsage
- flag.Parse()
+ flag.Parse()
}
func configure(ctx *node.Plugin) {}
diff --git a/plugins/gossip/errors.go b/plugins/gossip/errors.go
index d2c5de99276d7415426a58d4590978974b355eb2..8da04cfa7c762c9c7697152c44abcb46bd2f9947 100644
--- a/plugins/gossip/errors.go
+++ b/plugins/gossip/errors.go
@@ -3,10 +3,10 @@ package gossip
import "github.com/iotaledger/goshimmer/packages/errors"
var (
- ErrConnectionFailed = errors.Wrap(errors.New("connection error"), "could not connect to neighbor")
- ErrInvalidAuthenticationMessage = errors.Wrap(errors.New("protocol error"), "invalid authentication message")
- ErrInvalidIdentity = errors.Wrap(errors.New("protocol error"), "invalid identity message")
- ErrInvalidStateTransition = errors.New("protocol error: invalid state transition message")
- ErrSendFailed = errors.Wrap(errors.New("protocol error"), "failed to send message")
- ErrInvalidSendParam = errors.New("invalid parameter passed to send")
+ ErrConnectionFailed = errors.Wrap(errors.New("connection error"), "could not connect to neighbor")
+ ErrInvalidAuthenticationMessage = errors.Wrap(errors.New("protocol error"), "invalid authentication message")
+ ErrInvalidIdentity = errors.Wrap(errors.New("protocol error"), "invalid identity message")
+ ErrInvalidStateTransition = errors.New("protocol error: invalid state transition message")
+ ErrSendFailed = errors.Wrap(errors.New("protocol error"), "failed to send message")
+ ErrInvalidSendParam = errors.New("invalid parameter passed to send")
)
diff --git a/plugins/gossip/events.go b/plugins/gossip/events.go
index 130da4f8cb91c19a0708dac91c9bdaa7a35ed73b..765e106f0509a7856685c04b3f96d02d28fe4366 100644
--- a/plugins/gossip/events.go
+++ b/plugins/gossip/events.go
@@ -1,83 +1,97 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/packages/network"
- "github.com/iotaledger/goshimmer/packages/transaction"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
var Events = pluginEvents{
- // neighbor events
- AddNeighbor: events.NewEvent(neighborCaller),
- UpdateNeighbor: events.NewEvent(neighborCaller),
- RemoveNeighbor: events.NewEvent(neighborCaller),
-
- // low level network events
- IncomingConnection: events.NewEvent(connectionCaller),
-
- // high level protocol events
- DropNeighbor: events.NewEvent(neighborCaller),
- SendTransaction: events.NewEvent(transactionCaller),
- SendTransactionRequest: events.NewEvent(transactionCaller), // TODO
- ReceiveTransaction: events.NewEvent(transactionCaller),
- ReceiveTransactionRequest: events.NewEvent(transactionCaller), // TODO
- ProtocolError: events.NewEvent(transactionCaller), // TODO
-
- // generic events
- Error: events.NewEvent(errorCaller),
+ // neighbor events
+ AddNeighbor: events.NewEvent(neighborCaller),
+ UpdateNeighbor: events.NewEvent(neighborCaller),
+ RemoveNeighbor: events.NewEvent(neighborCaller),
+
+ // low level network events
+ IncomingConnection: events.NewEvent(connectionCaller),
+
+ // high level protocol events
+ DropNeighbor: events.NewEvent(neighborCaller),
+ SendTransaction: events.NewEvent(transactionCaller),
+ SendTransactionRequest: events.NewEvent(transactionCaller), // TODO
+ ReceiveTransaction: events.NewEvent(transactionCaller),
+ ReceiveTransactionRequest: events.NewEvent(transactionCaller), // TODO
+ ProtocolError: events.NewEvent(transactionCaller), // TODO
+
+ // generic events
+ Error: events.NewEvent(errorCaller),
}
type pluginEvents struct {
- // neighbor events
- AddNeighbor *events.Event
- UpdateNeighbor *events.Event
- RemoveNeighbor *events.Event
-
- // low level network events
- IncomingConnection *events.Event
-
- // high level protocol events
- DropNeighbor *events.Event
- SendTransaction *events.Event
- SendTransactionRequest *events.Event
- ReceiveTransaction *events.Event
- ReceiveTransactionRequest *events.Event
- ProtocolError *events.Event
-
- // generic events
- Error *events.Event
+ // neighbor events
+ AddNeighbor *events.Event
+ UpdateNeighbor *events.Event
+ RemoveNeighbor *events.Event
+
+ // low level network events
+ IncomingConnection *events.Event
+
+ // high level protocol events
+ DropNeighbor *events.Event
+ SendTransaction *events.Event
+ SendTransactionRequest *events.Event
+ ReceiveTransaction *events.Event
+ ReceiveTransactionRequest *events.Event
+ ProtocolError *events.Event
+
+ // generic events
+ Error *events.Event
}
type protocolEvents struct {
- ReceiveVersion *events.Event
- ReceiveIdentification *events.Event
- ReceiveConnectionAccepted *events.Event
- ReceiveConnectionRejected *events.Event
- ReceiveDropConnection *events.Event
- ReceiveTransactionData *events.Event
- ReceiveRequestData *events.Event
- HandshakeCompleted *events.Event
- Error *events.Event
+ ReceiveVersion *events.Event
+ ReceiveIdentification *events.Event
+ ReceiveConnectionAccepted *events.Event
+ ReceiveConnectionRejected *events.Event
+ ReceiveDropConnection *events.Event
+ ReceiveTransactionData *events.Event
+ ReceiveRequestData *events.Event
+ HandshakeCompleted *events.Event
+ Error *events.Event
}
type neighborEvents struct {
- ProtocolConnectionEstablished *events.Event
+ ProtocolConnectionEstablished *events.Event
}
func intCaller(handler interface{}, params ...interface{}) { handler.(func(int))(params[0].(int)) }
-func identityCaller(handler interface{}, params ...interface{}) { handler.(func(*identity.Identity))(params[0].(*identity.Identity)) }
+func identityCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*identity.Identity))(params[0].(*identity.Identity))
+}
-func connectionCaller(handler interface{}, params ...interface{}) { handler.(func(*network.ManagedConnection))(params[0].(*network.ManagedConnection)) }
+func connectionCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*network.ManagedConnection))(params[0].(*network.ManagedConnection))
+}
-func protocolCaller(handler interface{}, params ...interface{}) { handler.(func(*protocol))(params[0].(*protocol)) }
+func protocolCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*protocol))(params[0].(*protocol))
+}
-func neighborCaller(handler interface{}, params ...interface{}) { handler.(func(*Neighbor))(params[0].(*Neighbor)) }
+func neighborCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*Neighbor))(params[0].(*Neighbor))
+}
-func errorCaller(handler interface{}, params ...interface{}) { handler.(func(errors.IdentifiableError))(params[0].(errors.IdentifiableError)) }
+func errorCaller(handler interface{}, params ...interface{}) {
+ handler.(func(errors.IdentifiableError))(params[0].(errors.IdentifiableError))
+}
-func dataCaller(handler interface{}, params ...interface{}) { handler.(func([]byte))(params[0].([]byte)) }
+func dataCaller(handler interface{}, params ...interface{}) {
+ handler.(func([]byte))(params[0].([]byte))
+}
-func transactionCaller(handler interface{}, params ...interface{}) { handler.(func(*transaction.Transaction))(params[0].(*transaction.Transaction)) }
+func transactionCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*transaction.Transaction))(params[0].(*transaction.Transaction))
+}
diff --git a/plugins/gossip/neighbors.go b/plugins/gossip/neighbors.go
index eb1a82252db31d4154a6b3879a34b689465f2781..47aacbbdb1d2451fabc810330ab5bd3c0f44eeb2 100644
--- a/plugins/gossip/neighbors.go
+++ b/plugins/gossip/neighbors.go
@@ -1,245 +1,246 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/packages/network"
- "github.com/iotaledger/goshimmer/packages/node"
- "math"
- "net"
- "strconv"
- "sync"
- "time"
+ "math"
+ "net"
+ "strconv"
+ "sync"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/packages/node"
)
func configureNeighbors(plugin *node.Plugin) {
- Events.AddNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
- plugin.LogSuccess("new neighbor added " + neighbor.Identity.StringIdentifier + "@" + neighbor.Address.String() + ":" + strconv.Itoa(int(neighbor.Port)))
- }))
+ Events.AddNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
+ plugin.LogSuccess("new neighbor added " + neighbor.Identity.StringIdentifier + "@" + neighbor.Address.String() + ":" + strconv.Itoa(int(neighbor.Port)))
+ }))
- Events.UpdateNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
- plugin.LogSuccess("existing neighbor updated " + neighbor.Identity.StringIdentifier + "@" + neighbor.Address.String() + ":" + strconv.Itoa(int(neighbor.Port)))
- }))
+ Events.UpdateNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
+ plugin.LogSuccess("existing neighbor updated " + neighbor.Identity.StringIdentifier + "@" + neighbor.Address.String() + ":" + strconv.Itoa(int(neighbor.Port)))
+ }))
- Events.RemoveNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
- plugin.LogSuccess("existing neighbor removed " + neighbor.Identity.StringIdentifier + "@" + neighbor.Address.String() + ":" + strconv.Itoa(int(neighbor.Port)))
- }))
+ Events.RemoveNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
+ plugin.LogSuccess("existing neighbor removed " + neighbor.Identity.StringIdentifier + "@" + neighbor.Address.String() + ":" + strconv.Itoa(int(neighbor.Port)))
+ }))
}
func runNeighbors(plugin *node.Plugin) {
- plugin.LogInfo("Starting Neighbor Connection Manager ...")
+ plugin.LogInfo("Starting Neighbor Connection Manager ...")
- neighborLock.RLock()
- for _, neighbor := range GetNeighbors() {
- manageConnection(plugin, neighbor)
- }
- neighborLock.RUnlock()
+ neighborLock.RLock()
+ for _, neighbor := range GetNeighbors() {
+ manageConnection(plugin, neighbor)
+ }
+ neighborLock.RUnlock()
- Events.AddNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
- manageConnection(plugin, neighbor)
- }))
+ Events.AddNeighbor.Attach(events.NewClosure(func(neighbor *Neighbor) {
+ manageConnection(plugin, neighbor)
+ }))
- plugin.LogSuccess("Starting Neighbor Connection Manager ... done")
+ plugin.LogSuccess("Starting Neighbor Connection Manager ... done")
}
func manageConnection(plugin *node.Plugin, neighbor *Neighbor) {
- daemon.BackgroundWorker(func() {
- failedConnectionAttempts := 0
-
- for _, exists := GetNeighbor(neighbor.Identity.StringIdentifier); exists && failedConnectionAttempts < CONNECTION_MAX_ATTEMPTS; {
- protocol, dialed, err := neighbor.Connect()
- if err != nil {
- failedConnectionAttempts++
-
- plugin.LogFailure("connection attempt [" + strconv.Itoa(int(failedConnectionAttempts)) + "/" + strconv.Itoa(CONNECTION_MAX_ATTEMPTS) + "] " + err.Error())
-
- if failedConnectionAttempts <= CONNECTION_MAX_ATTEMPTS {
- select {
- case <-daemon.ShutdownSignal:
- return
-
- case <-time.After(time.Duration(int(math.Pow(2, float64(failedConnectionAttempts-1)))) * CONNECTION_BASE_TIMEOUT):
- continue
- }
- }
- }
-
- failedConnectionAttempts = 0
-
- disconnectSignal := make(chan int, 1)
- protocol.Conn.Events.Close.Attach(events.NewClosure(func() {
- close(disconnectSignal)
- }))
-
- if dialed {
- go protocol.Init()
- }
-
- // wait for shutdown or
- select {
- case <-daemon.ShutdownSignal:
- return
-
- case <-disconnectSignal:
- continue
- }
- }
-
- RemoveNeighbor(neighbor.Identity.StringIdentifier)
- })
+ daemon.BackgroundWorker(func() {
+ failedConnectionAttempts := 0
+
+ for _, exists := GetNeighbor(neighbor.Identity.StringIdentifier); exists && failedConnectionAttempts < CONNECTION_MAX_ATTEMPTS; {
+ protocol, dialed, err := neighbor.Connect()
+ if err != nil {
+ failedConnectionAttempts++
+
+ plugin.LogFailure("connection attempt [" + strconv.Itoa(int(failedConnectionAttempts)) + "/" + strconv.Itoa(CONNECTION_MAX_ATTEMPTS) + "] " + err.Error())
+
+ if failedConnectionAttempts <= CONNECTION_MAX_ATTEMPTS {
+ select {
+ case <-daemon.ShutdownSignal:
+ return
+
+ case <-time.After(time.Duration(int(math.Pow(2, float64(failedConnectionAttempts-1)))) * CONNECTION_BASE_TIMEOUT):
+ continue
+ }
+ }
+ }
+
+ failedConnectionAttempts = 0
+
+ disconnectSignal := make(chan int, 1)
+ protocol.Conn.Events.Close.Attach(events.NewClosure(func() {
+ close(disconnectSignal)
+ }))
+
+ if dialed {
+ go protocol.Init()
+ }
+
+ // wait for shutdown or
+ select {
+ case <-daemon.ShutdownSignal:
+ return
+
+ case <-disconnectSignal:
+ continue
+ }
+ }
+
+ RemoveNeighbor(neighbor.Identity.StringIdentifier)
+ })
}
type Neighbor struct {
- Identity *identity.Identity
- Address net.IP
- Port uint16
- InitiatedProtocol *protocol
- AcceptedProtocol *protocol
- Events neighborEvents
- initiatedProtocolMutex sync.RWMutex
- acceptedProtocolMutex sync.RWMutex
+ Identity *identity.Identity
+ Address net.IP
+ Port uint16
+ InitiatedProtocol *protocol
+ AcceptedProtocol *protocol
+ Events neighborEvents
+ initiatedProtocolMutex sync.RWMutex
+ acceptedProtocolMutex sync.RWMutex
}
func NewNeighbor(identity *identity.Identity, address net.IP, port uint16) *Neighbor {
- return &Neighbor{
- Identity: identity,
- Address: address,
- Port: port,
- Events: neighborEvents{
- ProtocolConnectionEstablished: events.NewEvent(protocolCaller),
- },
- }
+ return &Neighbor{
+ Identity: identity,
+ Address: address,
+ Port: port,
+ Events: neighborEvents{
+ ProtocolConnectionEstablished: events.NewEvent(protocolCaller),
+ },
+ }
}
func UnmarshalPeer(data []byte) (*Neighbor, error) {
- return &Neighbor{}, nil
+ return &Neighbor{}, nil
}
func (neighbor *Neighbor) Connect() (*protocol, bool, errors.IdentifiableError) {
- neighbor.initiatedProtocolMutex.Lock()
- defer neighbor.initiatedProtocolMutex.Unlock()
-
- // return existing connections first
- if neighbor.InitiatedProtocol != nil {
- return neighbor.InitiatedProtocol, false, nil
- }
-
- // if we already have an accepted connection -> use it instead
- if neighbor.AcceptedProtocol != nil {
- neighbor.acceptedProtocolMutex.RLock()
- if neighbor.AcceptedProtocol != nil {
- defer neighbor.acceptedProtocolMutex.RUnlock()
-
- return neighbor.AcceptedProtocol, false, nil
- }
- neighbor.acceptedProtocolMutex.RUnlock()
- }
-
- // otherwise try to dial
- conn, err := net.Dial("tcp", neighbor.Address.String()+":"+strconv.Itoa(int(neighbor.Port)))
- if err != nil {
- return nil, false, ErrConnectionFailed.Derive(err, "error when connecting to neighbor "+
- neighbor.Identity.StringIdentifier+"@"+neighbor.Address.String()+":"+strconv.Itoa(int(neighbor.Port)))
- }
-
- neighbor.InitiatedProtocol = newProtocol(network.NewManagedConnection(conn))
-
- neighbor.InitiatedProtocol.Conn.Events.Close.Attach(events.NewClosure(func() {
- neighbor.initiatedProtocolMutex.Lock()
- defer neighbor.initiatedProtocolMutex.Unlock()
-
- neighbor.InitiatedProtocol = nil
- }))
-
- // drop the "secondary" connection upon successful handshake
- neighbor.InitiatedProtocol.Events.HandshakeCompleted.Attach(events.NewClosure(func() {
- if accountability.OwnId().StringIdentifier <= neighbor.Identity.StringIdentifier {
- neighbor.acceptedProtocolMutex.Lock()
- var acceptedProtocolConn *network.ManagedConnection
- if neighbor.AcceptedProtocol != nil {
- acceptedProtocolConn = neighbor.AcceptedProtocol.Conn
- }
- neighbor.acceptedProtocolMutex.Unlock()
-
- if acceptedProtocolConn != nil {
- _ = acceptedProtocolConn.Close()
- }
- }
-
- neighbor.Events.ProtocolConnectionEstablished.Trigger(neighbor.InitiatedProtocol)
- }))
-
- return neighbor.InitiatedProtocol, true, nil
+ neighbor.initiatedProtocolMutex.Lock()
+ defer neighbor.initiatedProtocolMutex.Unlock()
+
+ // return existing connections first
+ if neighbor.InitiatedProtocol != nil {
+ return neighbor.InitiatedProtocol, false, nil
+ }
+
+ // if we already have an accepted connection -> use it instead
+ if neighbor.AcceptedProtocol != nil {
+ neighbor.acceptedProtocolMutex.RLock()
+ if neighbor.AcceptedProtocol != nil {
+ defer neighbor.acceptedProtocolMutex.RUnlock()
+
+ return neighbor.AcceptedProtocol, false, nil
+ }
+ neighbor.acceptedProtocolMutex.RUnlock()
+ }
+
+ // otherwise try to dial
+ conn, err := net.Dial("tcp", neighbor.Address.String()+":"+strconv.Itoa(int(neighbor.Port)))
+ if err != nil {
+ return nil, false, ErrConnectionFailed.Derive(err, "error when connecting to neighbor "+
+ neighbor.Identity.StringIdentifier+"@"+neighbor.Address.String()+":"+strconv.Itoa(int(neighbor.Port)))
+ }
+
+ neighbor.InitiatedProtocol = newProtocol(network.NewManagedConnection(conn))
+
+ neighbor.InitiatedProtocol.Conn.Events.Close.Attach(events.NewClosure(func() {
+ neighbor.initiatedProtocolMutex.Lock()
+ defer neighbor.initiatedProtocolMutex.Unlock()
+
+ neighbor.InitiatedProtocol = nil
+ }))
+
+ // drop the "secondary" connection upon successful handshake
+ neighbor.InitiatedProtocol.Events.HandshakeCompleted.Attach(events.NewClosure(func() {
+ if accountability.OwnId().StringIdentifier <= neighbor.Identity.StringIdentifier {
+ neighbor.acceptedProtocolMutex.Lock()
+ var acceptedProtocolConn *network.ManagedConnection
+ if neighbor.AcceptedProtocol != nil {
+ acceptedProtocolConn = neighbor.AcceptedProtocol.Conn
+ }
+ neighbor.acceptedProtocolMutex.Unlock()
+
+ if acceptedProtocolConn != nil {
+ _ = acceptedProtocolConn.Close()
+ }
+ }
+
+ neighbor.Events.ProtocolConnectionEstablished.Trigger(neighbor.InitiatedProtocol)
+ }))
+
+ return neighbor.InitiatedProtocol, true, nil
}
func (neighbor *Neighbor) Marshal() []byte {
- return nil
+ return nil
}
func (neighbor *Neighbor) Equals(other *Neighbor) bool {
- return neighbor.Identity.StringIdentifier == neighbor.Identity.StringIdentifier &&
- neighbor.Port == other.Port && neighbor.Address.String() == other.Address.String()
+ return neighbor.Identity.StringIdentifier == neighbor.Identity.StringIdentifier &&
+ neighbor.Port == other.Port && neighbor.Address.String() == other.Address.String()
}
func AddNeighbor(newNeighbor *Neighbor) {
- neighborLock.Lock()
- defer neighborLock.Unlock()
-
- if neighbor, exists := neighbors[newNeighbor.Identity.StringIdentifier]; !exists {
- neighbors[newNeighbor.Identity.StringIdentifier] = newNeighbor
-
- Events.AddNeighbor.Trigger(newNeighbor)
- } else {
- if !newNeighbor.Equals(neighbor) {
- neighbor.Identity = neighbor.Identity
- neighbor.Port = neighbor.Port
- neighbor.Address = neighbor.Address
-
- Events.UpdateNeighbor.Trigger(newNeighbor)
- }
- }
+ neighborLock.Lock()
+ defer neighborLock.Unlock()
+
+ if neighbor, exists := neighbors[newNeighbor.Identity.StringIdentifier]; !exists {
+ neighbors[newNeighbor.Identity.StringIdentifier] = newNeighbor
+
+ Events.AddNeighbor.Trigger(newNeighbor)
+ } else {
+ if !newNeighbor.Equals(neighbor) {
+ neighbor.Identity = neighbor.Identity
+ neighbor.Port = neighbor.Port
+ neighbor.Address = neighbor.Address
+
+ Events.UpdateNeighbor.Trigger(newNeighbor)
+ }
+ }
}
func RemoveNeighbor(identifier string) {
- if _, exists := neighbors[identifier]; exists {
- neighborLock.Lock()
- defer neighborLock.Unlock()
+ if _, exists := neighbors[identifier]; exists {
+ neighborLock.Lock()
+ defer neighborLock.Unlock()
- if neighbor, exists := neighbors[identifier]; exists {
- delete(neighbors, identifier)
+ if neighbor, exists := neighbors[identifier]; exists {
+ delete(neighbors, identifier)
- Events.RemoveNeighbor.Trigger(neighbor)
- }
- }
+ Events.RemoveNeighbor.Trigger(neighbor)
+ }
+ }
}
func GetNeighbor(identifier string) (*Neighbor, bool) {
- neighborLock.RLock()
- defer neighborLock.RUnlock()
+ neighborLock.RLock()
+ defer neighborLock.RUnlock()
- neighbor, exists := neighbors[identifier]
+ neighbor, exists := neighbors[identifier]
- return neighbor, exists
+ return neighbor, exists
}
func GetNeighbors() map[string]*Neighbor {
- neighborLock.RLock()
- defer neighborLock.RUnlock()
+ neighborLock.RLock()
+ defer neighborLock.RUnlock()
- result := make(map[string]*Neighbor)
- for id, neighbor := range neighbors {
- result[id] = neighbor
- }
+ result := make(map[string]*Neighbor)
+ for id, neighbor := range neighbors {
+ result[id] = neighbor
+ }
- return result
+ return result
}
const (
- CONNECTION_MAX_ATTEMPTS = 5
- CONNECTION_BASE_TIMEOUT = 10 * time.Second
+ CONNECTION_MAX_ATTEMPTS = 5
+ CONNECTION_BASE_TIMEOUT = 10 * time.Second
)
var neighbors = make(map[string]*Neighbor)
diff --git a/plugins/gossip/parameters.go b/plugins/gossip/parameters.go
index 6e962612fb448087e69d882f5b98ad3d7657535d..88ac73da6e57374a06159df00e14984f2770c8ef 100644
--- a/plugins/gossip/parameters.go
+++ b/plugins/gossip/parameters.go
@@ -3,5 +3,5 @@ package gossip
import "github.com/iotaledger/goshimmer/packages/parameter"
var (
- PORT = parameter.AddInt("GOSSIP/PORT", 14666, "tcp port for gossip connection")
+ PORT = parameter.AddInt("GOSSIP/PORT", 14666, "tcp port for gossip connection")
)
diff --git a/plugins/gossip/plugin.go b/plugins/gossip/plugin.go
index 33b8524770a8b434d5cbe03954b4b6b35a87bafd..d647a90686f3108ad7b1d6bac86617281ec68779 100644
--- a/plugins/gossip/plugin.go
+++ b/plugins/gossip/plugin.go
@@ -1,25 +1,25 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/transaction"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
var PLUGIN = node.NewPlugin("Gossip", configure, run)
func configure(plugin *node.Plugin) {
- configureNeighbors(plugin)
- configureServer(plugin)
- configureSendQueue(plugin)
+ configureNeighbors(plugin)
+ configureServer(plugin)
+ configureSendQueue(plugin)
- Events.ReceiveTransaction.Attach(events.NewClosure(func(transaction *transaction.Transaction) {
+ Events.ReceiveTransaction.Attach(events.NewClosure(func(transaction *transaction.Transaction) {
- }))
+ }))
}
func run(plugin *node.Plugin) {
- runNeighbors(plugin)
- runServer(plugin)
- runSendQueue(plugin)
+ runNeighbors(plugin)
+ runServer(plugin)
+ runSendQueue(plugin)
}
diff --git a/plugins/gossip/protocol.go b/plugins/gossip/protocol.go
index bc9f1e695581ba43402452d6f7f3acbed64423e5..f51d11b718911beeb6bec9a7bae22247d9bc715b 100644
--- a/plugins/gossip/protocol.go
+++ b/plugins/gossip/protocol.go
@@ -1,18 +1,19 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/network"
- "strconv"
- "sync"
+ "strconv"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/network"
)
// region constants and variables //////////////////////////////////////////////////////////////////////////////////////
var DEFAULT_PROTOCOL = protocolDefinition{
- version: VERSION_1,
- initializer: protocolV1,
+ version: VERSION_1,
+ initializer: protocolV1,
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -20,121 +21,121 @@ var DEFAULT_PROTOCOL = protocolDefinition{
// region protocol /////////////////////////////////////////////////////////////////////////////////////////////////////
type protocol struct {
- Conn *network.ManagedConnection
- Neighbor *Neighbor
- Version byte
- sendHandshakeCompleted bool
- receiveHandshakeCompleted bool
- SendState protocolState
- ReceivingState protocolState
- Events protocolEvents
- sendMutex sync.Mutex
- handshakeMutex sync.Mutex
+ Conn *network.ManagedConnection
+ Neighbor *Neighbor
+ Version byte
+ sendHandshakeCompleted bool
+ receiveHandshakeCompleted bool
+ SendState protocolState
+ ReceivingState protocolState
+ Events protocolEvents
+ sendMutex sync.Mutex
+ handshakeMutex sync.Mutex
}
func newProtocol(conn *network.ManagedConnection) *protocol {
- protocol := &protocol{
- Conn: conn,
- Events: protocolEvents{
- ReceiveVersion: events.NewEvent(intCaller),
- ReceiveIdentification: events.NewEvent(identityCaller),
- ReceiveConnectionAccepted: events.NewEvent(events.CallbackCaller),
- ReceiveConnectionRejected: events.NewEvent(events.CallbackCaller),
- ReceiveTransactionData: events.NewEvent(dataCaller),
- HandshakeCompleted: events.NewEvent(events.CallbackCaller),
- Error: events.NewEvent(errorCaller),
- },
- sendHandshakeCompleted: false,
- receiveHandshakeCompleted: false,
- }
-
- protocol.SendState = &versionState{protocol: protocol}
- protocol.ReceivingState = &versionState{protocol: protocol}
-
- return protocol
+ protocol := &protocol{
+ Conn: conn,
+ Events: protocolEvents{
+ ReceiveVersion: events.NewEvent(intCaller),
+ ReceiveIdentification: events.NewEvent(identityCaller),
+ ReceiveConnectionAccepted: events.NewEvent(events.CallbackCaller),
+ ReceiveConnectionRejected: events.NewEvent(events.CallbackCaller),
+ ReceiveTransactionData: events.NewEvent(dataCaller),
+ HandshakeCompleted: events.NewEvent(events.CallbackCaller),
+ Error: events.NewEvent(errorCaller),
+ },
+ sendHandshakeCompleted: false,
+ receiveHandshakeCompleted: false,
+ }
+
+ protocol.SendState = &versionState{protocol: protocol}
+ protocol.ReceivingState = &versionState{protocol: protocol}
+
+ return protocol
}
func (protocol *protocol) Init() {
- // setup event handlers
- onReceiveData := events.NewClosure(protocol.Receive)
- onConnectionAccepted := events.NewClosure(func() {
- protocol.handshakeMutex.Lock()
- defer protocol.handshakeMutex.Unlock()
-
- protocol.receiveHandshakeCompleted = true
- if protocol.sendHandshakeCompleted {
- protocol.Events.HandshakeCompleted.Trigger()
- }
- })
- var onClose *events.Closure
- onClose = events.NewClosure(func() {
- protocol.Conn.Events.ReceiveData.Detach(onReceiveData)
- protocol.Conn.Events.Close.Detach(onClose)
- protocol.Events.ReceiveConnectionAccepted.Detach(onConnectionAccepted)
- })
-
- // region register event handlers
- protocol.Conn.Events.ReceiveData.Attach(onReceiveData)
- protocol.Conn.Events.Close.Attach(onClose)
- protocol.Events.ReceiveConnectionAccepted.Attach(onConnectionAccepted)
-
- // send protocol version
- if err := protocol.Send(DEFAULT_PROTOCOL.version); err != nil {
- return
- }
-
- // initialize default protocol
- if err := DEFAULT_PROTOCOL.initializer(protocol); err != nil {
- protocol.SendState = nil
-
- _ = protocol.Conn.Close()
-
- protocol.Events.Error.Trigger(err)
-
- return
- }
-
- // start reading from the connection
- _, _ = protocol.Conn.Read(make([]byte, 1000))
+ // setup event handlers
+ onReceiveData := events.NewClosure(protocol.Receive)
+ onConnectionAccepted := events.NewClosure(func() {
+ protocol.handshakeMutex.Lock()
+ defer protocol.handshakeMutex.Unlock()
+
+ protocol.receiveHandshakeCompleted = true
+ if protocol.sendHandshakeCompleted {
+ protocol.Events.HandshakeCompleted.Trigger()
+ }
+ })
+ var onClose *events.Closure
+ onClose = events.NewClosure(func() {
+ protocol.Conn.Events.ReceiveData.Detach(onReceiveData)
+ protocol.Conn.Events.Close.Detach(onClose)
+ protocol.Events.ReceiveConnectionAccepted.Detach(onConnectionAccepted)
+ })
+
+ // region register event handlers
+ protocol.Conn.Events.ReceiveData.Attach(onReceiveData)
+ protocol.Conn.Events.Close.Attach(onClose)
+ protocol.Events.ReceiveConnectionAccepted.Attach(onConnectionAccepted)
+
+ // send protocol version
+ if err := protocol.Send(DEFAULT_PROTOCOL.version); err != nil {
+ return
+ }
+
+ // initialize default protocol
+ if err := DEFAULT_PROTOCOL.initializer(protocol); err != nil {
+ protocol.SendState = nil
+
+ _ = protocol.Conn.Close()
+
+ protocol.Events.Error.Trigger(err)
+
+ return
+ }
+
+ // start reading from the connection
+ _, _ = protocol.Conn.Read(make([]byte, 1000))
}
func (protocol *protocol) Receive(data []byte) {
- offset := 0
- length := len(data)
- for offset < length && protocol.ReceivingState != nil {
- if readBytes, err := protocol.ReceivingState.Receive(data, offset, length); err != nil {
- Events.Error.Trigger(err)
-
- _ = protocol.Conn.Close()
-
- return
- } else {
- offset += readBytes
- }
- }
+ offset := 0
+ length := len(data)
+ for offset < length && protocol.ReceivingState != nil {
+ if readBytes, err := protocol.ReceivingState.Receive(data, offset, length); err != nil {
+ Events.Error.Trigger(err)
+
+ _ = protocol.Conn.Close()
+
+ return
+ } else {
+ offset += readBytes
+ }
+ }
}
func (protocol *protocol) Send(data interface{}) errors.IdentifiableError {
- protocol.sendMutex.Lock()
- defer protocol.sendMutex.Unlock()
+ protocol.sendMutex.Lock()
+ defer protocol.sendMutex.Unlock()
- return protocol.send(data)
+ return protocol.send(data)
}
func (protocol *protocol) send(data interface{}) errors.IdentifiableError {
- if protocol.SendState != nil {
- if err := protocol.SendState.Send(data); err != nil {
- protocol.SendState = nil
+ if protocol.SendState != nil {
+ if err := protocol.SendState.Send(data); err != nil {
+ protocol.SendState = nil
- _ = protocol.Conn.Close()
+ _ = protocol.Conn.Close()
- protocol.Events.Error.Trigger(err)
+ protocol.Events.Error.Trigger(err)
- return err
- }
- }
+ return err
+ }
+ }
- return nil
+ return nil
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -142,43 +143,43 @@ func (protocol *protocol) send(data interface{}) errors.IdentifiableError {
// region versionState /////////////////////////////////////////////////////////////////////////////////////////////////
type versionState struct {
- protocol *protocol
+ protocol *protocol
}
func (state *versionState) Receive(data []byte, offset int, length int) (int, errors.IdentifiableError) {
- switch data[offset] {
- case 1:
- protocol := state.protocol
+ switch data[offset] {
+ case 1:
+ protocol := state.protocol
- protocol.Version = 1
- protocol.Events.ReceiveVersion.Trigger(1)
+ protocol.Version = 1
+ protocol.Events.ReceiveVersion.Trigger(1)
- protocol.ReceivingState = newIndentificationStateV1(protocol)
+ protocol.ReceivingState = newIndentificationStateV1(protocol)
- return 1, nil
+ return 1, nil
- default:
- return 1, ErrInvalidStateTransition.Derive("invalid version state transition (" + strconv.Itoa(int(data[offset])) + ")")
- }
+ default:
+ return 1, ErrInvalidStateTransition.Derive("invalid version state transition (" + strconv.Itoa(int(data[offset])) + ")")
+ }
}
func (state *versionState) Send(param interface{}) errors.IdentifiableError {
- if version, ok := param.(byte); ok {
- switch version {
- case VERSION_1:
- protocol := state.protocol
+ if version, ok := param.(byte); ok {
+ switch version {
+ case VERSION_1:
+ protocol := state.protocol
- if _, err := protocol.Conn.Write([]byte{version}); err != nil {
- return ErrSendFailed.Derive(err, "failed to send version byte")
- }
+ if _, err := protocol.Conn.Write([]byte{version}); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send version byte")
+ }
- protocol.SendState = newIndentificationStateV1(protocol)
+ protocol.SendState = newIndentificationStateV1(protocol)
- return nil
- }
- }
+ return nil
+ }
+ }
- return ErrInvalidSendParam.Derive("passed in parameter is not a valid version byte")
+ return ErrInvalidSendParam.Derive("passed in parameter is not a valid version byte")
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -186,13 +187,13 @@ func (state *versionState) Send(param interface{}) errors.IdentifiableError {
// region types and interfaces /////////////////////////////////////////////////////////////////////////////////////////
type protocolState interface {
- Send(param interface{}) errors.IdentifiableError
- Receive(data []byte, offset int, length int) (int, errors.IdentifiableError)
+ Send(param interface{}) errors.IdentifiableError
+ Receive(data []byte, offset int, length int) (int, errors.IdentifiableError)
}
type protocolDefinition struct {
- version byte
- initializer func(*protocol) errors.IdentifiableError
+ version byte
+ initializer func(*protocol) errors.IdentifiableError
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/gossip/protocol_v1.go b/plugins/gossip/protocol_v1.go
index 74687858ed42efd45b9e2415ffe7c2bd7224816f..9b7677b3b8df0e73286ffcc1ad8fafa4edf6a0b7 100644
--- a/plugins/gossip/protocol_v1.go
+++ b/plugins/gossip/protocol_v1.go
@@ -1,61 +1,62 @@
package gossip
import (
- "bytes"
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/byteutils"
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/packages/ternary"
- "github.com/iotaledger/goshimmer/packages/transaction"
- "strconv"
+ "bytes"
+ "strconv"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/byteutils"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
// region protocolV1 ///////////////////////////////////////////////////////////////////////////////////////////////////
func protocolV1(protocol *protocol) errors.IdentifiableError {
- if err := protocol.Send(accountability.OwnId()); err != nil {
- return err
- }
-
- onReceiveIdentification := events.NewClosure(func(identity *identity.Identity) {
- if protocol.Neighbor == nil {
- if err := protocol.Send(CONNECTION_REJECT); err != nil {
- return
- }
- } else {
- if err := protocol.Send(CONNECTION_ACCEPT); err != nil {
- return
- }
-
- protocol.handshakeMutex.Lock()
- defer protocol.handshakeMutex.Unlock()
-
- protocol.sendHandshakeCompleted = true
- if protocol.receiveHandshakeCompleted {
- protocol.Events.HandshakeCompleted.Trigger()
- }
- }
- })
-
- protocol.Events.ReceiveIdentification.Attach(onReceiveIdentification)
-
- return nil
+ if err := protocol.Send(accountability.OwnId()); err != nil {
+ return err
+ }
+
+ onReceiveIdentification := events.NewClosure(func(identity *identity.Identity) {
+ if protocol.Neighbor == nil {
+ if err := protocol.Send(CONNECTION_REJECT); err != nil {
+ return
+ }
+ } else {
+ if err := protocol.Send(CONNECTION_ACCEPT); err != nil {
+ return
+ }
+
+ protocol.handshakeMutex.Lock()
+ defer protocol.handshakeMutex.Unlock()
+
+ protocol.sendHandshakeCompleted = true
+ if protocol.receiveHandshakeCompleted {
+ protocol.Events.HandshakeCompleted.Trigger()
+ }
+ }
+ })
+
+ protocol.Events.ReceiveIdentification.Attach(onReceiveIdentification)
+
+ return nil
}
func sendTransactionV1(protocol *protocol, tx *transaction.Transaction) {
- if _, ok := protocol.SendState.(*dispatchStateV1); ok {
- protocol.sendMutex.Lock()
- defer protocol.sendMutex.Unlock()
-
- if err := protocol.send(DISPATCH_TRANSACTION); err != nil {
- return
- }
- if err := protocol.send(tx); err != nil {
- return
- }
- }
+ if _, ok := protocol.SendState.(*dispatchStateV1); ok {
+ protocol.sendMutex.Lock()
+ defer protocol.sendMutex.Unlock()
+
+ if err := protocol.send(DISPATCH_TRANSACTION); err != nil {
+ return
+ }
+ if err := protocol.send(tx); err != nil {
+ return
+ }
+ }
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -63,78 +64,78 @@ func sendTransactionV1(protocol *protocol, tx *transaction.Transaction) {
// region indentificationStateV1 ///////////////////////////////////////////////////////////////////////////////////////
type indentificationStateV1 struct {
- protocol *protocol
- buffer []byte
- offset int
+ protocol *protocol
+ buffer []byte
+ offset int
}
func newIndentificationStateV1(protocol *protocol) *indentificationStateV1 {
- return &indentificationStateV1{
- protocol: protocol,
- buffer: make([]byte, MARSHALLED_IDENTITY_TOTAL_SIZE),
- offset: 0,
- }
+ return &indentificationStateV1{
+ protocol: protocol,
+ buffer: make([]byte, MARSHALLED_IDENTITY_TOTAL_SIZE),
+ offset: 0,
+ }
}
func (state *indentificationStateV1) Receive(data []byte, offset int, length int) (int, errors.IdentifiableError) {
- bytesRead := byteutils.ReadAvailableBytesToBuffer(state.buffer, state.offset, data, offset, length)
+ bytesRead := byteutils.ReadAvailableBytesToBuffer(state.buffer, state.offset, data, offset, length)
- state.offset += bytesRead
- if state.offset == MARSHALLED_IDENTITY_TOTAL_SIZE {
- if receivedIdentity, err := unmarshalIdentity(state.buffer); err != nil {
- return bytesRead, ErrInvalidAuthenticationMessage.Derive(err, "invalid authentication message")
- } else {
- protocol := state.protocol
+ state.offset += bytesRead
+ if state.offset == MARSHALLED_IDENTITY_TOTAL_SIZE {
+ if receivedIdentity, err := unmarshalIdentity(state.buffer); err != nil {
+ return bytesRead, ErrInvalidAuthenticationMessage.Derive(err, "invalid authentication message")
+ } else {
+ protocol := state.protocol
- if neighbor, exists := GetNeighbor(receivedIdentity.StringIdentifier); exists {
- protocol.Neighbor = neighbor
- } else {
- protocol.Neighbor = nil
- }
+ if neighbor, exists := GetNeighbor(receivedIdentity.StringIdentifier); exists {
+ protocol.Neighbor = neighbor
+ } else {
+ protocol.Neighbor = nil
+ }
- protocol.Events.ReceiveIdentification.Trigger(receivedIdentity)
+ protocol.Events.ReceiveIdentification.Trigger(receivedIdentity)
- protocol.ReceivingState = newacceptanceStateV1(protocol)
- state.offset = 0
- }
- }
+ protocol.ReceivingState = newacceptanceStateV1(protocol)
+ state.offset = 0
+ }
+ }
- return bytesRead, nil
+ return bytesRead, nil
}
func (state *indentificationStateV1) Send(param interface{}) errors.IdentifiableError {
- if id, ok := param.(*identity.Identity); ok {
- if signature, err := id.Sign(id.Identifier); err == nil {
- protocol := state.protocol
+ if id, ok := param.(*identity.Identity); ok {
+ if signature, err := id.Sign(id.Identifier); err == nil {
+ protocol := state.protocol
- if _, err := protocol.Conn.Write(id.Identifier); err != nil {
- return ErrSendFailed.Derive(err, "failed to send identifier")
- }
- if _, err := protocol.Conn.Write(signature); err != nil {
- return ErrSendFailed.Derive(err, "failed to send signature")
- }
+ if _, err := protocol.Conn.Write(id.Identifier); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send identifier")
+ }
+ if _, err := protocol.Conn.Write(signature); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send signature")
+ }
- protocol.SendState = newacceptanceStateV1(protocol)
+ protocol.SendState = newacceptanceStateV1(protocol)
- return nil
- }
- }
+ return nil
+ }
+ }
- return ErrInvalidSendParam.Derive("passed in parameter is not a valid identity")
+ return ErrInvalidSendParam.Derive("passed in parameter is not a valid identity")
}
func unmarshalIdentity(data []byte) (*identity.Identity, error) {
- identifier := data[MARSHALLED_IDENTITY_START:MARSHALLED_IDENTITY_END]
-
- if restoredIdentity, err := identity.FromSignedData(identifier, data[MARSHALLED_IDENTITY_SIGNATURE_START:MARSHALLED_IDENTITY_SIGNATURE_END]); err != nil {
- return nil, err
- } else {
- if bytes.Equal(identifier, restoredIdentity.Identifier) {
- return restoredIdentity, nil
- } else {
- return nil, errors.New("signature does not match claimed identity")
- }
- }
+ identifier := data[MARSHALLED_IDENTITY_START:MARSHALLED_IDENTITY_END]
+
+ if restoredIdentity, err := identity.FromSignedData(identifier, data[MARSHALLED_IDENTITY_SIGNATURE_START:MARSHALLED_IDENTITY_SIGNATURE_END]); err != nil {
+ return nil, err
+ } else {
+ if bytes.Equal(identifier, restoredIdentity.Identifier) {
+ return restoredIdentity, nil
+ } else {
+ return nil, errors.New("signature does not match claimed identity")
+ }
+ }
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -142,66 +143,66 @@ func unmarshalIdentity(data []byte) (*identity.Identity, error) {
// region acceptanceStateV1 ////////////////////////////////////////////////////////////////////////////////////////////
type acceptanceStateV1 struct {
- protocol *protocol
+ protocol *protocol
}
func newacceptanceStateV1(protocol *protocol) *acceptanceStateV1 {
- return &acceptanceStateV1{protocol: protocol}
+ return &acceptanceStateV1{protocol: protocol}
}
func (state *acceptanceStateV1) Receive(data []byte, offset int, length int) (int, errors.IdentifiableError) {
- protocol := state.protocol
+ protocol := state.protocol
- switch data[offset] {
- case 0:
- protocol.Events.ReceiveConnectionRejected.Trigger()
+ switch data[offset] {
+ case 0:
+ protocol.Events.ReceiveConnectionRejected.Trigger()
- _ = protocol.Conn.Close()
+ _ = protocol.Conn.Close()
- protocol.ReceivingState = nil
+ protocol.ReceivingState = nil
- case 1:
- protocol.Events.ReceiveConnectionAccepted.Trigger()
+ case 1:
+ protocol.Events.ReceiveConnectionAccepted.Trigger()
- protocol.ReceivingState = newDispatchStateV1(protocol)
+ protocol.ReceivingState = newDispatchStateV1(protocol)
- default:
- return 1, ErrInvalidStateTransition.Derive("invalid acceptance state transition (" + strconv.Itoa(int(data[offset])) + ")")
- }
+ default:
+ return 1, ErrInvalidStateTransition.Derive("invalid acceptance state transition (" + strconv.Itoa(int(data[offset])) + ")")
+ }
- return 1, nil
+ return 1, nil
}
func (state *acceptanceStateV1) Send(param interface{}) errors.IdentifiableError {
- if responseType, ok := param.(byte); ok {
- switch responseType {
- case CONNECTION_REJECT:
- protocol := state.protocol
+ if responseType, ok := param.(byte); ok {
+ switch responseType {
+ case CONNECTION_REJECT:
+ protocol := state.protocol
- if _, err := protocol.Conn.Write([]byte{CONNECTION_REJECT}); err != nil {
- return ErrSendFailed.Derive(err, "failed to send reject message")
- }
+ if _, err := protocol.Conn.Write([]byte{CONNECTION_REJECT}); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send reject message")
+ }
- _ = protocol.Conn.Close()
+ _ = protocol.Conn.Close()
- protocol.SendState = nil
+ protocol.SendState = nil
- return nil
+ return nil
- case CONNECTION_ACCEPT:
- protocol := state.protocol
+ case CONNECTION_ACCEPT:
+ protocol := state.protocol
- if _, err := protocol.Conn.Write([]byte{CONNECTION_ACCEPT}); err != nil {
- return ErrSendFailed.Derive(err, "failed to send accept message")
- }
+ if _, err := protocol.Conn.Write([]byte{CONNECTION_ACCEPT}); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send accept message")
+ }
- protocol.SendState = newDispatchStateV1(protocol)
+ protocol.SendState = newDispatchStateV1(protocol)
- return nil
- }
- }
+ return nil
+ }
+ }
- return ErrInvalidSendParam.Derive("passed in parameter is not a valid acceptance byte")
+ return ErrInvalidSendParam.Derive("passed in parameter is not a valid acceptance byte")
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -209,84 +210,84 @@ func (state *acceptanceStateV1) Send(param interface{}) errors.IdentifiableError
// region dispatchStateV1 //////////////////////////////////////////////////////////////////////////////////////////////
type dispatchStateV1 struct {
- protocol *protocol
+ protocol *protocol
}
func newDispatchStateV1(protocol *protocol) *dispatchStateV1 {
- return &dispatchStateV1{
- protocol: protocol,
- }
+ return &dispatchStateV1{
+ protocol: protocol,
+ }
}
func (state *dispatchStateV1) Receive(data []byte, offset int, length int) (int, errors.IdentifiableError) {
- switch data[0] {
- case DISPATCH_DROP:
- protocol := state.protocol
+ switch data[0] {
+ case DISPATCH_DROP:
+ protocol := state.protocol
- protocol.Events.ReceiveConnectionRejected.Trigger()
+ protocol.Events.ReceiveConnectionRejected.Trigger()
- _ = protocol.Conn.Close()
+ _ = protocol.Conn.Close()
- protocol.ReceivingState = nil
+ protocol.ReceivingState = nil
- case DISPATCH_TRANSACTION:
- protocol := state.protocol
+ case DISPATCH_TRANSACTION:
+ protocol := state.protocol
- protocol.ReceivingState = newTransactionStateV1(protocol)
+ protocol.ReceivingState = newTransactionStateV1(protocol)
- case DISPATCH_REQUEST:
- protocol := state.protocol
+ case DISPATCH_REQUEST:
+ protocol := state.protocol
- protocol.ReceivingState = newRequestStateV1(protocol)
+ protocol.ReceivingState = newRequestStateV1(protocol)
- default:
- return 1, ErrInvalidStateTransition.Derive("invalid dispatch state transition (" + strconv.Itoa(int(data[offset])) + ")")
- }
+ default:
+ return 1, ErrInvalidStateTransition.Derive("invalid dispatch state transition (" + strconv.Itoa(int(data[offset])) + ")")
+ }
- return 1, nil
+ return 1, nil
}
func (state *dispatchStateV1) Send(param interface{}) errors.IdentifiableError {
- if dispatchByte, ok := param.(byte); ok {
- switch dispatchByte {
- case DISPATCH_DROP:
- protocol := state.protocol
+ if dispatchByte, ok := param.(byte); ok {
+ switch dispatchByte {
+ case DISPATCH_DROP:
+ protocol := state.protocol
- if _, err := protocol.Conn.Write([]byte{DISPATCH_DROP}); err != nil {
- return ErrSendFailed.Derive(err, "failed to send drop message")
- }
+ if _, err := protocol.Conn.Write([]byte{DISPATCH_DROP}); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send drop message")
+ }
- _ = protocol.Conn.Close()
+ _ = protocol.Conn.Close()
- protocol.SendState = nil
+ protocol.SendState = nil
- return nil
+ return nil
- case DISPATCH_TRANSACTION:
- protocol := state.protocol
+ case DISPATCH_TRANSACTION:
+ protocol := state.protocol
- if _, err := protocol.Conn.Write([]byte{DISPATCH_TRANSACTION}); err != nil {
- return ErrSendFailed.Derive(err, "failed to send transaction dispatch byte")
- }
+ if _, err := protocol.Conn.Write([]byte{DISPATCH_TRANSACTION}); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send transaction dispatch byte")
+ }
- protocol.SendState = newTransactionStateV1(protocol)
+ protocol.SendState = newTransactionStateV1(protocol)
- return nil
+ return nil
- case DISPATCH_REQUEST:
- protocol := state.protocol
+ case DISPATCH_REQUEST:
+ protocol := state.protocol
- if _, err := protocol.Conn.Write([]byte{DISPATCH_REQUEST}); err != nil {
- return ErrSendFailed.Derive(err, "failed to send request dispatch byte")
- }
+ if _, err := protocol.Conn.Write([]byte{DISPATCH_REQUEST}); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send request dispatch byte")
+ }
- protocol.SendState = newTransactionStateV1(protocol)
+ protocol.SendState = newTransactionStateV1(protocol)
- return nil
- }
- }
+ return nil
+ }
+ }
- return ErrInvalidSendParam.Derive("passed in parameter is not a valid dispatch byte")
+ return ErrInvalidSendParam.Derive("passed in parameter is not a valid dispatch byte")
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -294,54 +295,54 @@ func (state *dispatchStateV1) Send(param interface{}) errors.IdentifiableError {
// region transactionStateV1 ///////////////////////////////////////////////////////////////////////////////////////////
type transactionStateV1 struct {
- protocol *protocol
- buffer []byte
- offset int
+ protocol *protocol
+ buffer []byte
+ offset int
}
func newTransactionStateV1(protocol *protocol) *transactionStateV1 {
- return &transactionStateV1{
- protocol: protocol,
- buffer: make([]byte, transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE),
- offset: 0,
- }
+ return &transactionStateV1{
+ protocol: protocol,
+ buffer: make([]byte, transaction.MARSHALLED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE),
+ offset: 0,
+ }
}
func (state *transactionStateV1) Receive(data []byte, offset int, length int) (int, errors.IdentifiableError) {
- bytesRead := byteutils.ReadAvailableBytesToBuffer(state.buffer, state.offset, data, offset, length)
+ 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 {
- protocol := state.protocol
+ state.offset += bytesRead
+ if state.offset == transaction.MARSHALLED_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)
- copy(transactionData, state.buffer)
+ transactionData := make([]byte, transaction.MARSHALLED_TOTAL_SIZE/ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+ copy(transactionData, state.buffer)
- protocol.Events.ReceiveTransactionData.Trigger(transactionData)
+ protocol.Events.ReceiveTransactionData.Trigger(transactionData)
- go ProcessReceivedTransactionData(transactionData)
+ go ProcessReceivedTransactionData(transactionData)
- protocol.ReceivingState = newDispatchStateV1(protocol)
- state.offset = 0
- }
+ protocol.ReceivingState = newDispatchStateV1(protocol)
+ state.offset = 0
+ }
- return bytesRead, nil
+ return bytesRead, nil
}
func (state *transactionStateV1) Send(param interface{}) errors.IdentifiableError {
- if tx, ok := param.(*transaction.Transaction); ok {
- protocol := state.protocol
+ if tx, ok := param.(*transaction.Transaction); ok {
+ protocol := state.protocol
- if _, err := protocol.Conn.Write(tx.Bytes); err != nil {
- return ErrSendFailed.Derive(err, "failed to send transaction")
- }
+ if _, err := protocol.Conn.Write(tx.Bytes); err != nil {
+ return ErrSendFailed.Derive(err, "failed to send transaction")
+ }
- protocol.SendState = newDispatchStateV1(protocol)
+ protocol.SendState = newDispatchStateV1(protocol)
- return nil
- }
+ return nil
+ }
- return ErrInvalidSendParam.Derive("passed in parameter is not a valid transaction")
+ return ErrInvalidSendParam.Derive("passed in parameter is not a valid transaction")
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -349,23 +350,23 @@ func (state *transactionStateV1) Send(param interface{}) errors.IdentifiableErro
// region requestStateV1 ///////////////////////////////////////////////////////////////////////////////////////////////
type requestStateV1 struct {
- buffer []byte
- offset int
+ buffer []byte
+ offset int
}
func newRequestStateV1(protocol *protocol) *requestStateV1 {
- return &requestStateV1{
- buffer: make([]byte, 1),
- offset: 0,
- }
+ return &requestStateV1{
+ buffer: make([]byte, 1),
+ offset: 0,
+ }
}
func (state *requestStateV1) Receive(data []byte, offset int, length int) (int, errors.IdentifiableError) {
- return 0, nil
+ return 0, nil
}
func (state *requestStateV1) Send(param interface{}) errors.IdentifiableError {
- return nil
+ return nil
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -373,25 +374,25 @@ func (state *requestStateV1) Send(param interface{}) errors.IdentifiableError {
// region constants and variables //////////////////////////////////////////////////////////////////////////////////////
const (
- VERSION_1 = byte(1)
+ VERSION_1 = byte(1)
- CONNECTION_REJECT = byte(0)
- CONNECTION_ACCEPT = byte(1)
+ CONNECTION_REJECT = byte(0)
+ CONNECTION_ACCEPT = byte(1)
- DISPATCH_DROP = byte(0)
- DISPATCH_TRANSACTION = byte(1)
- DISPATCH_REQUEST = byte(2)
+ DISPATCH_DROP = byte(0)
+ DISPATCH_TRANSACTION = byte(1)
+ DISPATCH_REQUEST = byte(2)
- MARSHALLED_IDENTITY_START = 0
- MARSHALLED_IDENTITY_SIGNATURE_START = MARSHALLED_IDENTITY_END
+ MARSHALLED_IDENTITY_START = 0
+ MARSHALLED_IDENTITY_SIGNATURE_START = MARSHALLED_IDENTITY_END
- MARSHALLED_IDENTITY_SIZE = 20
- MARSHALLED_IDENTITY_SIGNATURE_SIZE = 65
+ MARSHALLED_IDENTITY_SIZE = 20
+ MARSHALLED_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
+ MARSHALLED_IDENTITY_END = MARSHALLED_IDENTITY_START + MARSHALLED_IDENTITY_SIZE
+ MARSHALLED_IDENTITY_SIGNATURE_END = MARSHALLED_IDENTITY_SIGNATURE_START + MARSHALLED_IDENTITY_SIGNATURE_SIZE
- MARSHALLED_IDENTITY_TOTAL_SIZE = MARSHALLED_IDENTITY_SIGNATURE_END
+ MARSHALLED_IDENTITY_TOTAL_SIZE = MARSHALLED_IDENTITY_SIGNATURE_END
)
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/gossip/send_queue.go b/plugins/gossip/send_queue.go
index 736c32bea3f0103f9f27e12eb3836c9c83a612f2..337095271bf49fa1d7d1eb705307ac9e11418368 100644
--- a/plugins/gossip/send_queue.go
+++ b/plugins/gossip/send_queue.go
@@ -1,61 +1,62 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/transaction"
- "sync"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
// region plugin module setup //////////////////////////////////////////////////////////////////////////////////////////
func configureSendQueue(plugin *node.Plugin) {
- for _, neighbor := range GetNeighbors() {
- setupEventHandlers(neighbor)
- }
+ for _, neighbor := range GetNeighbors() {
+ setupEventHandlers(neighbor)
+ }
- Events.AddNeighbor.Attach(events.NewClosure(setupEventHandlers))
+ Events.AddNeighbor.Attach(events.NewClosure(setupEventHandlers))
- daemon.Events.Shutdown.Attach(events.NewClosure(func() {
- plugin.LogInfo("Stopping Send Queue Dispatcher ...")
- }))
+ daemon.Events.Shutdown.Attach(events.NewClosure(func() {
+ plugin.LogInfo("Stopping Send Queue Dispatcher ...")
+ }))
}
func runSendQueue(plugin *node.Plugin) {
- plugin.LogInfo("Starting Send Queue Dispatcher ...")
-
- daemon.BackgroundWorker(func() {
- plugin.LogSuccess("Starting Send Queue Dispatcher ... done")
-
- for {
- select {
- case <-daemon.ShutdownSignal:
- plugin.LogSuccess("Stopping Send Queue Dispatcher ... done")
-
- return
-
- case tx := <-sendQueue:
- connectedNeighborsMutex.RLock()
- for _, neighborQueue := range neighborQueues {
- select {
- case neighborQueue.queue <- tx:
- // log sth
-
- default:
- // log sth
- }
- }
- connectedNeighborsMutex.RUnlock()
- }
- }
- })
-
- connectedNeighborsMutex.Lock()
- for _, neighborQueue := range neighborQueues {
- startNeighborSendQueue(neighborQueue)
- }
- connectedNeighborsMutex.Unlock()
+ plugin.LogInfo("Starting Send Queue Dispatcher ...")
+
+ daemon.BackgroundWorker(func() {
+ plugin.LogSuccess("Starting Send Queue Dispatcher ... done")
+
+ for {
+ select {
+ case <-daemon.ShutdownSignal:
+ plugin.LogSuccess("Stopping Send Queue Dispatcher ... done")
+
+ return
+
+ case tx := <-sendQueue:
+ connectedNeighborsMutex.RLock()
+ for _, neighborQueue := range neighborQueues {
+ select {
+ case neighborQueue.queue <- tx:
+ // log sth
+
+ default:
+ // log sth
+ }
+ }
+ connectedNeighborsMutex.RUnlock()
+ }
+ }
+ })
+
+ connectedNeighborsMutex.Lock()
+ for _, neighborQueue := range neighborQueues {
+ startNeighborSendQueue(neighborQueue)
+ }
+ connectedNeighborsMutex.Unlock()
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -63,19 +64,19 @@ func runSendQueue(plugin *node.Plugin) {
// region public api ///////////////////////////////////////////////////////////////////////////////////////////////////
func SendTransaction(transaction *transaction.Transaction) {
- sendQueue <- transaction
+ sendQueue <- transaction
}
func (neighbor *Neighbor) SendTransaction(transaction *transaction.Transaction) {
- if queue, exists := neighborQueues[neighbor.Identity.StringIdentifier]; exists {
- select {
- case queue.queue <- transaction:
- return
-
- default:
- return
- }
- }
+ if queue, exists := neighborQueues[neighbor.Identity.StringIdentifier]; exists {
+ select {
+ case queue.queue <- transaction:
+ return
+
+ default:
+ return
+ }
+ }
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -83,49 +84,49 @@ func (neighbor *Neighbor) SendTransaction(transaction *transaction.Transaction)
// region utility methods //////////////////////////////////////////////////////////////////////////////////////////////
func setupEventHandlers(neighbor *Neighbor) {
- neighbor.Events.ProtocolConnectionEstablished.Attach(events.NewClosure(func(protocol *protocol) {
- queue := &neighborQueue{
- protocol: protocol,
- queue: make(chan *transaction.Transaction, SEND_QUEUE_SIZE),
- disconnectChan: make(chan int, 1),
- }
-
- connectedNeighborsMutex.Lock()
- neighborQueues[neighbor.Identity.StringIdentifier] = queue
- connectedNeighborsMutex.Unlock()
-
- protocol.Conn.Events.Close.Attach(events.NewClosure(func() {
- close(queue.disconnectChan)
-
- connectedNeighborsMutex.Lock()
- delete(neighborQueues, neighbor.Identity.StringIdentifier)
- connectedNeighborsMutex.Unlock()
- }))
-
- if(daemon.IsRunning()) {
- startNeighborSendQueue(queue)
- }
- }))
+ neighbor.Events.ProtocolConnectionEstablished.Attach(events.NewClosure(func(protocol *protocol) {
+ queue := &neighborQueue{
+ protocol: protocol,
+ queue: make(chan *transaction.Transaction, SEND_QUEUE_SIZE),
+ disconnectChan: make(chan int, 1),
+ }
+
+ connectedNeighborsMutex.Lock()
+ neighborQueues[neighbor.Identity.StringIdentifier] = queue
+ connectedNeighborsMutex.Unlock()
+
+ protocol.Conn.Events.Close.Attach(events.NewClosure(func() {
+ close(queue.disconnectChan)
+
+ connectedNeighborsMutex.Lock()
+ delete(neighborQueues, neighbor.Identity.StringIdentifier)
+ connectedNeighborsMutex.Unlock()
+ }))
+
+ if daemon.IsRunning() {
+ startNeighborSendQueue(queue)
+ }
+ }))
}
func startNeighborSendQueue(neighborQueue *neighborQueue) {
- daemon.BackgroundWorker(func() {
- for {
- select {
- case <-daemon.ShutdownSignal:
- return
-
- case <-neighborQueue.disconnectChan:
- return
-
- case tx := <-neighborQueue.queue:
- switch neighborQueue.protocol.Version {
- case VERSION_1:
- sendTransactionV1(neighborQueue.protocol, tx)
- }
- }
- }
- })
+ daemon.BackgroundWorker(func() {
+ for {
+ select {
+ case <-daemon.ShutdownSignal:
+ return
+
+ case <-neighborQueue.disconnectChan:
+ return
+
+ case tx := <-neighborQueue.queue:
+ switch neighborQueue.protocol.Version {
+ case VERSION_1:
+ sendTransactionV1(neighborQueue.protocol, tx)
+ }
+ }
+ }
+ })
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -133,9 +134,9 @@ func startNeighborSendQueue(neighborQueue *neighborQueue) {
// region types and interfaces /////////////////////////////////////////////////////////////////////////////////////////
type neighborQueue struct {
- protocol *protocol
- queue chan *transaction.Transaction
- disconnectChan chan int
+ protocol *protocol
+ queue chan *transaction.Transaction
+ disconnectChan chan int
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -149,7 +150,7 @@ var connectedNeighborsMutex sync.RWMutex
var sendQueue = make(chan *transaction.Transaction, SEND_QUEUE_SIZE)
const (
- SEND_QUEUE_SIZE = 500
+ SEND_QUEUE_SIZE = 500
)
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/gossip/server.go b/plugins/gossip/server.go
index a8125e612b71297633ba06c36a4cf973fd16c1f1..37ebc20ddd75f018ad016cb641ce9e87816d02c2 100644
--- a/plugins/gossip/server.go
+++ b/plugins/gossip/server.go
@@ -1,82 +1,83 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/identity"
- "github.com/iotaledger/goshimmer/packages/network"
- "github.com/iotaledger/goshimmer/packages/network/tcp"
- "github.com/iotaledger/goshimmer/packages/node"
- "strconv"
+ "strconv"
+
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/identity"
+ "github.com/iotaledger/goshimmer/packages/network"
+ "github.com/iotaledger/goshimmer/packages/network/tcp"
+ "github.com/iotaledger/goshimmer/packages/node"
)
var TCPServer = tcp.NewServer()
func configureServer(plugin *node.Plugin) {
- TCPServer.Events.Connect.Attach(events.NewClosure(func(conn *network.ManagedConnection) {
- protocol := newProtocol(conn)
-
- // print protocol errors
- protocol.Events.Error.Attach(events.NewClosure(func(err errors.IdentifiableError) {
- plugin.LogFailure(err.Error())
- }))
-
- // store protocol in neighbor if its a neighbor calling
- protocol.Events.ReceiveIdentification.Attach(events.NewClosure(func(identity *identity.Identity) {
- if protocol.Neighbor != nil {
- protocol.Neighbor.acceptedProtocolMutex.Lock()
- if protocol.Neighbor.AcceptedProtocol == nil {
- protocol.Neighbor.AcceptedProtocol = protocol
-
- protocol.Conn.Events.Close.Attach(events.NewClosure(func() {
- protocol.Neighbor.acceptedProtocolMutex.Lock()
- defer protocol.Neighbor.acceptedProtocolMutex.Unlock()
-
- protocol.Neighbor.AcceptedProtocol = nil
- }))
- }
- protocol.Neighbor.acceptedProtocolMutex.Unlock()
- }
- }))
-
- // drop the "secondary" connection upon successful handshake
- protocol.Events.HandshakeCompleted.Attach(events.NewClosure(func() {
- if protocol.Neighbor.Identity.StringIdentifier <= accountability.OwnId().StringIdentifier {
- protocol.Neighbor.initiatedProtocolMutex.Lock()
- var initiatedProtocolConn *network.ManagedConnection
- if protocol.Neighbor.InitiatedProtocol != nil {
- initiatedProtocolConn = protocol.Neighbor.InitiatedProtocol.Conn
- }
- protocol.Neighbor.initiatedProtocolMutex.Unlock()
-
- if initiatedProtocolConn != nil {
- _ = initiatedProtocolConn.Close()
- }
- }
-
- protocol.Neighbor.Events.ProtocolConnectionEstablished.Trigger(protocol)
- }))
-
- go protocol.Init()
- }))
-
- daemon.Events.Shutdown.Attach(events.NewClosure(func() {
- plugin.LogInfo("Stopping TCP Server ...")
-
- TCPServer.Shutdown()
- }))
+ TCPServer.Events.Connect.Attach(events.NewClosure(func(conn *network.ManagedConnection) {
+ protocol := newProtocol(conn)
+
+ // print protocol errors
+ protocol.Events.Error.Attach(events.NewClosure(func(err errors.IdentifiableError) {
+ plugin.LogFailure(err.Error())
+ }))
+
+ // store protocol in neighbor if its a neighbor calling
+ protocol.Events.ReceiveIdentification.Attach(events.NewClosure(func(identity *identity.Identity) {
+ if protocol.Neighbor != nil {
+ protocol.Neighbor.acceptedProtocolMutex.Lock()
+ if protocol.Neighbor.AcceptedProtocol == nil {
+ protocol.Neighbor.AcceptedProtocol = protocol
+
+ protocol.Conn.Events.Close.Attach(events.NewClosure(func() {
+ protocol.Neighbor.acceptedProtocolMutex.Lock()
+ defer protocol.Neighbor.acceptedProtocolMutex.Unlock()
+
+ protocol.Neighbor.AcceptedProtocol = nil
+ }))
+ }
+ protocol.Neighbor.acceptedProtocolMutex.Unlock()
+ }
+ }))
+
+ // drop the "secondary" connection upon successful handshake
+ protocol.Events.HandshakeCompleted.Attach(events.NewClosure(func() {
+ if protocol.Neighbor.Identity.StringIdentifier <= accountability.OwnId().StringIdentifier {
+ protocol.Neighbor.initiatedProtocolMutex.Lock()
+ var initiatedProtocolConn *network.ManagedConnection
+ if protocol.Neighbor.InitiatedProtocol != nil {
+ initiatedProtocolConn = protocol.Neighbor.InitiatedProtocol.Conn
+ }
+ protocol.Neighbor.initiatedProtocolMutex.Unlock()
+
+ if initiatedProtocolConn != nil {
+ _ = initiatedProtocolConn.Close()
+ }
+ }
+
+ protocol.Neighbor.Events.ProtocolConnectionEstablished.Trigger(protocol)
+ }))
+
+ go protocol.Init()
+ }))
+
+ daemon.Events.Shutdown.Attach(events.NewClosure(func() {
+ plugin.LogInfo("Stopping TCP Server ...")
+
+ TCPServer.Shutdown()
+ }))
}
func runServer(plugin *node.Plugin) {
- plugin.LogInfo("Starting TCP Server (port " + strconv.Itoa(*PORT.Value) + ") ...")
+ plugin.LogInfo("Starting TCP Server (port " + strconv.Itoa(*PORT.Value) + ") ...")
- daemon.BackgroundWorker(func() {
- plugin.LogSuccess("Starting TCP Server (port " + strconv.Itoa(*PORT.Value) + ") ... done")
+ daemon.BackgroundWorker(func() {
+ plugin.LogSuccess("Starting TCP Server (port " + strconv.Itoa(*PORT.Value) + ") ... done")
- TCPServer.Listen(*PORT.Value)
+ TCPServer.Listen(*PORT.Value)
- plugin.LogSuccess("Stopping TCP Server ... done")
- })
+ plugin.LogSuccess("Stopping TCP Server ... done")
+ })
}
diff --git a/plugins/gossip/transaction_processor.go b/plugins/gossip/transaction_processor.go
index 269f493b9f38ac82761202edc71a7a76b1b433b4..9a96fdb25f475b11b64b77c74da22f215de03843 100644
--- a/plugins/gossip/transaction_processor.go
+++ b/plugins/gossip/transaction_processor.go
@@ -1,16 +1,16 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/filter"
- "github.com/iotaledger/goshimmer/packages/transaction"
+ "github.com/iotaledger/goshimmer/packages/filter"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
// region public api ///////////////////////////////////////////////////////////////////////////////////////////////////
func ProcessReceivedTransactionData(transactionData []byte) {
- if transactionFilter.Add(transactionData) {
- Events.ReceiveTransaction.Trigger(transaction.FromBytes(transactionData))
- }
+ if transactionFilter.Add(transactionData) {
+ Events.ReceiveTransaction.Trigger(transaction.FromBytes(transactionData))
+ }
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -20,7 +20,7 @@ func ProcessReceivedTransactionData(transactionData []byte) {
var transactionFilter = filter.NewByteArrayFilter(TRANSACTION_FILTER_SIZE)
const (
- TRANSACTION_FILTER_SIZE = 5000
+ TRANSACTION_FILTER_SIZE = 5000
)
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/gossip/transaction_processor_test.go b/plugins/gossip/transaction_processor_test.go
index 0434864165f145e3b49a38c4feda43313e3e9b83..7686214081166a086ce050385460c22a399af20a 100644
--- a/plugins/gossip/transaction_processor_test.go
+++ b/plugins/gossip/transaction_processor_test.go
@@ -1,48 +1,49 @@
package gossip
import (
- "github.com/iotaledger/goshimmer/packages/ternary"
- "github.com/iotaledger/goshimmer/packages/transaction"
- "sync"
- "testing"
+ "sync"
+ "testing"
+
+ "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
func BenchmarkProcessSimilarTransactionsFiltered(b *testing.B) {
- byteArray := setupTransaction(transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+ byteArray := setupTransaction(transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
- b.ResetTimer()
+ b.ResetTimer()
- for i := 0; i < b.N; i++ {
- ProcessReceivedTransactionData(byteArray)
- }
+ for i := 0; i < b.N; i++ {
+ ProcessReceivedTransactionData(byteArray)
+ }
}
func BenchmarkProcessSimilarTransactionsUnfiltered(b *testing.B) {
- byteArray := setupTransaction(transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+ byteArray := setupTransaction(transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
- b.ResetTimer()
+ b.ResetTimer()
- var wg sync.WaitGroup
+ var wg sync.WaitGroup
- for i := 0; i < b.N; i++ {
- wg.Add(1)
+ for i := 0; i < b.N; i++ {
+ wg.Add(1)
- go func() {
- Events.ReceiveTransaction.Trigger(transaction.FromBytes(byteArray))
+ go func() {
+ Events.ReceiveTransaction.Trigger(transaction.FromBytes(byteArray))
- wg.Done()
- }()
- }
+ wg.Done()
+ }()
+ }
- wg.Wait()
+ wg.Wait()
}
func setupTransaction(byteArraySize int) []byte {
- byteArray := make([]byte, byteArraySize)
+ byteArray := make([]byte, byteArraySize)
- for i := 0; i < len(byteArray); i++ {
- byteArray[i] = byte(i % 128)
- }
+ for i := 0; i < len(byteArray); i++ {
+ byteArray[i] = byte(i % 128)
+ }
- return byteArray
+ return byteArray
}
diff --git a/plugins/gracefulshutdown/plugin.go b/plugins/gracefulshutdown/plugin.go
index e09f87f9ba75b75cc8e4f60f5696513098a5a93b..babf75718afa7bd702d3dd1e17e29d51f15fa171 100644
--- a/plugins/gracefulshutdown/plugin.go
+++ b/plugins/gracefulshutdown/plugin.go
@@ -1,44 +1,45 @@
package gracefulshutdown
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/node"
- "os"
- "os/signal"
- "strconv"
- "syscall"
- "time"
+ "os"
+ "os/signal"
+ "strconv"
+ "syscall"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/node"
)
// maximum amount of time to wait for background processes to terminate. After that the process is killed.
const WAIT_TO_KILL_TIME_IN_SECONDS = 10
var PLUGIN = node.NewPlugin("Graceful Shutdown", func(plugin *node.Plugin) {
- gracefulStop := make(chan os.Signal)
+ gracefulStop := make(chan os.Signal)
- signal.Notify(gracefulStop, syscall.SIGTERM)
- signal.Notify(gracefulStop, syscall.SIGINT)
+ signal.Notify(gracefulStop, syscall.SIGTERM)
+ signal.Notify(gracefulStop, syscall.SIGINT)
- go func() {
- <- gracefulStop
+ go func() {
+ <-gracefulStop
- plugin.LogWarning("Received shutdown request - waiting (max " + strconv.Itoa(WAIT_TO_KILL_TIME_IN_SECONDS) + " seconds) to finish processing ...")
+ plugin.LogWarning("Received shutdown request - waiting (max " + strconv.Itoa(WAIT_TO_KILL_TIME_IN_SECONDS) + " seconds) to finish processing ...")
- go func() {
- start := time.Now()
- for x := range time.Tick(1 * time.Second) {
- secondsSinceStart := x.Sub(start).Seconds()
+ go func() {
+ start := time.Now()
+ for x := range time.Tick(1 * time.Second) {
+ secondsSinceStart := x.Sub(start).Seconds()
- if secondsSinceStart <= WAIT_TO_KILL_TIME_IN_SECONDS {
- plugin.LogWarning("Received shutdown request - waiting (max " + strconv.Itoa(WAIT_TO_KILL_TIME_IN_SECONDS-int(secondsSinceStart)) + " seconds) to finish processing ...")
- } else {
- plugin.LogFailure("Background processes did not terminate in time! Forcing shutdown ...")
+ if secondsSinceStart <= WAIT_TO_KILL_TIME_IN_SECONDS {
+ plugin.LogWarning("Received shutdown request - waiting (max " + strconv.Itoa(WAIT_TO_KILL_TIME_IN_SECONDS-int(secondsSinceStart)) + " seconds) to finish processing ...")
+ } else {
+ plugin.LogFailure("Background processes did not terminate in time! Forcing shutdown ...")
- os.Exit(1)
- }
- }
- }()
+ os.Exit(1)
+ }
+ }
+ }()
- daemon.Shutdown()
- }()
+ daemon.Shutdown()
+ }()
})
diff --git a/plugins/statusscreen/constants.go b/plugins/statusscreen/constants.go
index d34a8a8ac4fe849d8706704a7d15ef96dedf1921..1fa6c46dac0ec691e0323e9e753952a2a7139b96 100644
--- a/plugins/statusscreen/constants.go
+++ b/plugins/statusscreen/constants.go
@@ -3,5 +3,5 @@ package statusscreen
import "time"
const (
- REPAINT_INTERVAL = 500 * time.Millisecond
+ REPAINT_INTERVAL = 500 * time.Millisecond
)
diff --git a/plugins/statusscreen/logger.go b/plugins/statusscreen/logger.go
index 18c3155dbb5a65c3b57cbb3f41a8e42cab09ef28..9a524fc12c8d563944eb5a9b8b687cd4b9af1534 100644
--- a/plugins/statusscreen/logger.go
+++ b/plugins/statusscreen/logger.go
@@ -1,47 +1,48 @@
package statusscreen
import (
- "github.com/iotaledger/goshimmer/packages/node"
- "time"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/node"
)
func storeStatusMessage(pluginName string, message string, logLevel int) {
- messageLog = append(messageLog, &StatusMessage{
- Source: pluginName,
- LogLevel: logLevel,
- Message: message,
- Time: time.Now(),
- })
+ messageLog = append(messageLog, &StatusMessage{
+ Source: pluginName,
+ LogLevel: logLevel,
+ Message: message,
+ Time: time.Now(),
+ })
- if statusMessage, exists := statusMessages[pluginName]; !exists {
- statusMessages[pluginName] = &StatusMessage{
- Source: pluginName,
- LogLevel: logLevel,
- Message: message,
- Time: time.Now(),
- }
- } else {
- statusMessage.LogLevel = logLevel
- statusMessage.Message = message
- statusMessage.Time = time.Now()
- }
+ if statusMessage, exists := statusMessages[pluginName]; !exists {
+ statusMessages[pluginName] = &StatusMessage{
+ Source: pluginName,
+ LogLevel: logLevel,
+ Message: message,
+ Time: time.Now(),
+ }
+ } else {
+ statusMessage.LogLevel = logLevel
+ statusMessage.Message = message
+ statusMessage.Time = time.Now()
+ }
}
var DEFAULT_LOGGER = &node.Logger{
- Enabled: true,
- LogInfo: func(pluginName string, message string) {
- storeStatusMessage(pluginName, message, node.LOG_LEVEL_INFO)
- },
- LogSuccess: func(pluginName string, message string) {
- storeStatusMessage(pluginName, message, node.LOG_LEVEL_SUCCESS)
- },
- LogWarning: func(pluginName string, message string) {
- storeStatusMessage(pluginName, message, node.LOG_LEVEL_WARNING)
- },
- LogFailure: func(pluginName string, message string) {
- storeStatusMessage(pluginName, message, node.LOG_LEVEL_FAILURE)
- },
- LogDebug: func(pluginName string, message string) {
- storeStatusMessage(pluginName, message, node.LOG_LEVEL_DEBUG)
- },
+ Enabled: true,
+ LogInfo: func(pluginName string, message string) {
+ storeStatusMessage(pluginName, message, node.LOG_LEVEL_INFO)
+ },
+ LogSuccess: func(pluginName string, message string) {
+ storeStatusMessage(pluginName, message, node.LOG_LEVEL_SUCCESS)
+ },
+ LogWarning: func(pluginName string, message string) {
+ storeStatusMessage(pluginName, message, node.LOG_LEVEL_WARNING)
+ },
+ LogFailure: func(pluginName string, message string) {
+ storeStatusMessage(pluginName, message, node.LOG_LEVEL_FAILURE)
+ },
+ LogDebug: func(pluginName string, message string) {
+ storeStatusMessage(pluginName, message, node.LOG_LEVEL_DEBUG)
+ },
}
diff --git a/plugins/statusscreen/status_message.go b/plugins/statusscreen/status_message.go
index 5f2a9ecdf058ed962104802be6b90ea8ea6a9b67..8e3c1538ca6c5ab033f34dfd95023ed40eb74ec8 100644
--- a/plugins/statusscreen/status_message.go
+++ b/plugins/statusscreen/status_message.go
@@ -3,8 +3,8 @@ package statusscreen
import "time"
type StatusMessage struct {
- Source string
- LogLevel int
- Message string
- Time time.Time
+ Source string
+ LogLevel int
+ Message string
+ Time time.Time
}
diff --git a/plugins/statusscreen/statusscreen.go b/plugins/statusscreen/statusscreen.go
index 7f7c7b30141cfbb60734c3ebf32122498e6c2c77..31b00d08edc337ddb5afccb897e3fc39322c243d 100644
--- a/plugins/statusscreen/statusscreen.go
+++ b/plugins/statusscreen/statusscreen.go
@@ -1,12 +1,13 @@
package statusscreen
import (
- "github.com/gdamore/tcell"
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/rivo/tview"
- "time"
+ "time"
+
+ "github.com/gdamore/tcell"
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/rivo/tview"
)
var statusMessages = make(map[string]*StatusMessage)
@@ -15,106 +16,106 @@ var messageLog = make([]*StatusMessage, 0)
var app *tview.Application
func configure(plugin *node.Plugin) {
- node.DEFAULT_LOGGER.Enabled = false
+ node.DEFAULT_LOGGER.Enabled = false
- plugin.Node.AddLogger(DEFAULT_LOGGER)
+ plugin.Node.AddLogger(DEFAULT_LOGGER)
- daemon.Events.Shutdown.Attach(events.NewClosure(func() {
- node.DEFAULT_LOGGER.Enabled = true
+ daemon.Events.Shutdown.Attach(events.NewClosure(func() {
+ node.DEFAULT_LOGGER.Enabled = true
- if app != nil {
- app.Stop()
- }
- }))
+ if app != nil {
+ app.Stop()
+ }
+ }))
}
func run(plugin *node.Plugin) {
- newPrimitive := func(text string) *tview.TextView {
- textView := tview.NewTextView()
-
- textView.
- SetTextAlign(tview.AlignLeft).
- SetText(" " + text)
-
- return textView
- }
-
- app = tview.NewApplication()
-
- headerBar := NewUIHeaderBar()
-
- content := tview.NewGrid()
- content.SetBackgroundColor(tcell.ColorWhite)
- content.SetColumns(0)
-
- footer := newPrimitive("")
- footer.SetBackgroundColor(tcell.ColorDarkMagenta)
- footer.SetTextColor(tcell.ColorWhite)
-
- grid := tview.NewGrid().
- SetRows(10, 0, 1).
- SetColumns(0).
- SetBorders(false).
- AddItem(headerBar.Primitive, 0, 0, 1, 1, 0, 0, false).
- AddItem(content, 1, 0, 1, 1, 0, 0, false).
- AddItem(footer, 2, 0, 1, 1, 0, 0, false)
-
- frame := tview.NewFrame(grid).
- SetBorders(1, 1, 0, 0, 2, 2)
- frame.SetBackgroundColor(tcell.ColorDarkGray)
-
- app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
- if event.Key() == tcell.KeyCtrlC || event.Key() == tcell.KeyESC{
- daemon.Shutdown()
-
- return nil
- }
-
- return event
- })
-
- app.SetBeforeDrawFunc(func(screen tcell.Screen) bool {
- headerBar.Update()
-
- rows := make([]int, 1)
- rows[0] = 1
- _, _, _, height := content.GetRect()
- for i := 0; i < len(messageLog) && i < height - 2; i++ {
- rows = append(rows, 1)
- }
-
- content.Clear()
- content.SetRows(rows...)
-
- blankLine := newPrimitive("")
- blankLine.SetBackgroundColor(tcell.ColorWhite)
- content.AddItem(blankLine, 0, 0, 1, 1, 0, 0, false)
-
- for i, message := range messageLog[len(messageLog) - len(rows) - 1 + 2:] {
- if i < height - 2 {
- content.AddItem(NewUILogEntry(*message).Primitive, i+1, 0, 1, 1, 0, 0, false)
- }
- }
-
- return false
- })
-
- daemon.BackgroundWorker(func() {
- for {
- select {
- case <- daemon.ShutdownSignal:
- return
- case <- time.After(1 * time.Second):
- app.QueueUpdateDraw(func() {})
- }
- }
- })
-
- daemon.BackgroundWorker(func() {
- if err := app.SetRoot(frame, true).SetFocus(frame).Run(); err != nil {
- panic(err)
- }
- })
+ newPrimitive := func(text string) *tview.TextView {
+ textView := tview.NewTextView()
+
+ textView.
+ SetTextAlign(tview.AlignLeft).
+ SetText(" " + text)
+
+ return textView
+ }
+
+ app = tview.NewApplication()
+
+ headerBar := NewUIHeaderBar()
+
+ content := tview.NewGrid()
+ content.SetBackgroundColor(tcell.ColorWhite)
+ content.SetColumns(0)
+
+ footer := newPrimitive("")
+ footer.SetBackgroundColor(tcell.ColorDarkMagenta)
+ footer.SetTextColor(tcell.ColorWhite)
+
+ grid := tview.NewGrid().
+ SetRows(10, 0, 1).
+ SetColumns(0).
+ SetBorders(false).
+ AddItem(headerBar.Primitive, 0, 0, 1, 1, 0, 0, false).
+ AddItem(content, 1, 0, 1, 1, 0, 0, false).
+ AddItem(footer, 2, 0, 1, 1, 0, 0, false)
+
+ frame := tview.NewFrame(grid).
+ SetBorders(1, 1, 0, 0, 2, 2)
+ frame.SetBackgroundColor(tcell.ColorDarkGray)
+
+ app.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
+ if event.Key() == tcell.KeyCtrlC || event.Key() == tcell.KeyESC {
+ daemon.Shutdown()
+
+ return nil
+ }
+
+ return event
+ })
+
+ app.SetBeforeDrawFunc(func(screen tcell.Screen) bool {
+ headerBar.Update()
+
+ rows := make([]int, 1)
+ rows[0] = 1
+ _, _, _, height := content.GetRect()
+ for i := 0; i < len(messageLog) && i < height-2; i++ {
+ rows = append(rows, 1)
+ }
+
+ content.Clear()
+ content.SetRows(rows...)
+
+ blankLine := newPrimitive("")
+ blankLine.SetBackgroundColor(tcell.ColorWhite)
+ content.AddItem(blankLine, 0, 0, 1, 1, 0, 0, false)
+
+ for i, message := range messageLog[len(messageLog)-len(rows)-1+2:] {
+ if i < height-2 {
+ content.AddItem(NewUILogEntry(*message).Primitive, i+1, 0, 1, 1, 0, 0, false)
+ }
+ }
+
+ return false
+ })
+
+ daemon.BackgroundWorker(func() {
+ for {
+ select {
+ case <-daemon.ShutdownSignal:
+ return
+ case <-time.After(1 * time.Second):
+ app.QueueUpdateDraw(func() {})
+ }
+ }
+ })
+
+ daemon.BackgroundWorker(func() {
+ if err := app.SetRoot(frame, true).SetFocus(frame).Run(); err != nil {
+ panic(err)
+ }
+ })
}
var PLUGIN = node.NewPlugin("Status Screen", configure, run)
diff --git a/plugins/statusscreen/ui_header_bar.go b/plugins/statusscreen/ui_header_bar.go
index 0404c159d26a15de20123bab4e5d5ba0842d768d..4089d415078ee8f7b02b3a5bd289dbb9f1411ca3 100644
--- a/plugins/statusscreen/ui_header_bar.go
+++ b/plugins/statusscreen/ui_header_bar.go
@@ -1,124 +1,124 @@
package statusscreen
import (
- "fmt"
- "github.com/gdamore/tcell"
- "github.com/iotaledger/goshimmer/packages/accountability"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
- "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
- "github.com/rivo/tview"
- "math"
- "strconv"
- "time"
+ "fmt"
+ "math"
+ "strconv"
+ "time"
+
+ "github.com/gdamore/tcell"
+ "github.com/iotaledger/goshimmer/packages/accountability"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+ "github.com/iotaledger/goshimmer/plugins/autopeering/instances/neighborhood"
+ "github.com/rivo/tview"
)
var start = time.Now()
type UIHeaderBar struct {
- Primitive *tview.Grid
- LogoContainer *tview.TextView
- InfoContainer *tview.TextView
+ Primitive *tview.Grid
+ LogoContainer *tview.TextView
+ InfoContainer *tview.TextView
}
func NewUIHeaderBar() *UIHeaderBar {
- headerBar := &UIHeaderBar{
- Primitive: tview.NewGrid(),
- LogoContainer: tview.NewTextView(),
- InfoContainer: tview.NewTextView(),
- }
-
- headerBar.LogoContainer.
- SetTextAlign(tview.AlignLeft).
- SetTextColor(tcell.ColorWhite).
- SetDynamicColors(true).
- SetBackgroundColor(tcell.ColorDarkMagenta)
-
- headerBar.InfoContainer.
- SetTextAlign(tview.AlignRight).
- SetTextColor(tcell.ColorWhite).
- SetDynamicColors(true).
- SetBackgroundColor(tcell.ColorDarkMagenta)
-
- headerBar.Primitive.
- SetColumns(17, 0).
- SetRows(0).
- SetBorders(false).
- AddItem(headerBar.LogoContainer, 0, 0, 1, 1, 0, 0, false).
- AddItem(headerBar.InfoContainer, 0, 1, 1, 1, 0, 0, false)
-
-
- headerBar.printLogo()
- headerBar.Update()
-
- return headerBar
+ headerBar := &UIHeaderBar{
+ Primitive: tview.NewGrid(),
+ LogoContainer: tview.NewTextView(),
+ InfoContainer: tview.NewTextView(),
+ }
+
+ headerBar.LogoContainer.
+ SetTextAlign(tview.AlignLeft).
+ SetTextColor(tcell.ColorWhite).
+ SetDynamicColors(true).
+ SetBackgroundColor(tcell.ColorDarkMagenta)
+
+ headerBar.InfoContainer.
+ SetTextAlign(tview.AlignRight).
+ SetTextColor(tcell.ColorWhite).
+ SetDynamicColors(true).
+ SetBackgroundColor(tcell.ColorDarkMagenta)
+
+ headerBar.Primitive.
+ SetColumns(17, 0).
+ SetRows(0).
+ SetBorders(false).
+ AddItem(headerBar.LogoContainer, 0, 0, 1, 1, 0, 0, false).
+ AddItem(headerBar.InfoContainer, 0, 1, 1, 1, 0, 0, false)
+
+ headerBar.printLogo()
+ headerBar.Update()
+
+ return headerBar
}
func (headerBar *UIHeaderBar) Update() {
- duration := time.Now().Sub(start)
-
- headerBar.InfoContainer.Clear()
-
- fmt.Fprintln(headerBar.InfoContainer)
- fmt.Fprintln(headerBar.InfoContainer, "[::d]COO-LESS IOTA PROTOTYPE - [::b]Status: [green::b]SYNCED ")
- fmt.Fprintln(headerBar.InfoContainer)
- fmt.Fprintln(headerBar.InfoContainer)
- fmt.Fprintln(headerBar.InfoContainer)
- fmt.Fprintf(headerBar.InfoContainer, "[::b]Node ID: [::d]%40v ", accountability.OwnId().StringIdentifier)
- fmt.Fprintln(headerBar.InfoContainer)
- fmt.Fprintf(headerBar.InfoContainer, "[::b]Neighbors: [::d]%40v ", strconv.Itoa(len(chosenneighbors.INSTANCE.Peers)) + " chosen / " + strconv.Itoa(len(acceptedneighbors.INSTANCE.Peers)) + " accepted")
- fmt.Fprintln(headerBar.InfoContainer)
- fmt.Fprintf(headerBar.InfoContainer, "[::b]Known Peers: [::d]%40v ", strconv.Itoa(len(knownpeers.INSTANCE.Peers)) + " total / " + strconv.Itoa(len(neighborhood.INSTANCE.Peers)) + " neighborhood")
- fmt.Fprintln(headerBar.InfoContainer)
- fmt.Fprintf(headerBar.InfoContainer, "[::b]Uptime: [::d]");
-
- padded := false
- if int(duration.Seconds()) / (60 * 60 * 24) > 0 {
- days := int(duration.Hours()) / 24
-
- numberLength := int(math.Log10(float64(days))) + 1
- padLength := 31 - numberLength
-
- fmt.Fprintf(headerBar.InfoContainer, "%*v", padLength, "")
-
- padded = true
-
- // d
- fmt.Fprintf(headerBar.InfoContainer, "%02dd ", days)
- }
-
- if int(duration.Seconds()) / (60 * 60) > 0 {
- if !padded {
- fmt.Fprintf(headerBar.InfoContainer, "%29v", "")
- padded = true
- }
- fmt.Fprintf(headerBar.InfoContainer, "%02dh ", int(duration.Hours()) % 24)
- }
-
- if int(duration.Seconds()) / 60 > 0 {
- if !padded {
- fmt.Fprintf(headerBar.InfoContainer, "%33v", "")
- padded = true
- }
- fmt.Fprintf(headerBar.InfoContainer, "%02dm ", int(duration.Minutes()) % 60)
- }
-
- if !padded {
- fmt.Fprintf(headerBar.InfoContainer, "%37v", "")
- padded = true
- }
- fmt.Fprintf(headerBar.InfoContainer, "%02ds ", int(duration.Seconds()) % 60)
+ duration := time.Now().Sub(start)
+
+ headerBar.InfoContainer.Clear()
+
+ fmt.Fprintln(headerBar.InfoContainer)
+ fmt.Fprintln(headerBar.InfoContainer, "[::d]COO-LESS IOTA PROTOTYPE - [::b]Status: [green::b]SYNCED ")
+ fmt.Fprintln(headerBar.InfoContainer)
+ fmt.Fprintln(headerBar.InfoContainer)
+ fmt.Fprintln(headerBar.InfoContainer)
+ fmt.Fprintf(headerBar.InfoContainer, "[::b]Node ID: [::d]%40v ", accountability.OwnId().StringIdentifier)
+ fmt.Fprintln(headerBar.InfoContainer)
+ fmt.Fprintf(headerBar.InfoContainer, "[::b]Neighbors: [::d]%40v ", strconv.Itoa(len(chosenneighbors.INSTANCE.Peers))+" chosen / "+strconv.Itoa(len(acceptedneighbors.INSTANCE.Peers))+" accepted")
+ fmt.Fprintln(headerBar.InfoContainer)
+ fmt.Fprintf(headerBar.InfoContainer, "[::b]Known Peers: [::d]%40v ", strconv.Itoa(len(knownpeers.INSTANCE.Peers))+" total / "+strconv.Itoa(len(neighborhood.INSTANCE.Peers))+" neighborhood")
+ fmt.Fprintln(headerBar.InfoContainer)
+ fmt.Fprintf(headerBar.InfoContainer, "[::b]Uptime: [::d]")
+
+ padded := false
+ if int(duration.Seconds())/(60*60*24) > 0 {
+ days := int(duration.Hours()) / 24
+
+ numberLength := int(math.Log10(float64(days))) + 1
+ padLength := 31 - numberLength
+
+ fmt.Fprintf(headerBar.InfoContainer, "%*v", padLength, "")
+
+ padded = true
+
+ // d
+ fmt.Fprintf(headerBar.InfoContainer, "%02dd ", days)
+ }
+
+ if int(duration.Seconds())/(60*60) > 0 {
+ if !padded {
+ fmt.Fprintf(headerBar.InfoContainer, "%29v", "")
+ padded = true
+ }
+ fmt.Fprintf(headerBar.InfoContainer, "%02dh ", int(duration.Hours())%24)
+ }
+
+ if int(duration.Seconds())/60 > 0 {
+ if !padded {
+ fmt.Fprintf(headerBar.InfoContainer, "%33v", "")
+ padded = true
+ }
+ fmt.Fprintf(headerBar.InfoContainer, "%02dm ", int(duration.Minutes())%60)
+ }
+
+ if !padded {
+ fmt.Fprintf(headerBar.InfoContainer, "%37v", "")
+ padded = true
+ }
+ fmt.Fprintf(headerBar.InfoContainer, "%02ds ", int(duration.Seconds())%60)
}
func (headerBar *UIHeaderBar) printLogo() {
- fmt.Fprintln(headerBar.LogoContainer, "")
- fmt.Fprintln(headerBar.LogoContainer, " SHIMMER 1.0.0")
- fmt.Fprintln(headerBar.LogoContainer, " ┌──────┬──────┐")
- fmt.Fprintln(headerBar.LogoContainer, " ───┐ │ ┌───")
- fmt.Fprintln(headerBar.LogoContainer, " ┐ │ │ │ ┌")
- fmt.Fprintln(headerBar.LogoContainer, " │ └ │ ┘ │")
- fmt.Fprintln(headerBar.LogoContainer, " └ ┌ │ ┐ ┘")
- fmt.Fprintln(headerBar.LogoContainer, " │ │ │")
- fmt.Fprintln(headerBar.LogoContainer, " ┴")
+ fmt.Fprintln(headerBar.LogoContainer, "")
+ fmt.Fprintln(headerBar.LogoContainer, " SHIMMER 1.0.0")
+ fmt.Fprintln(headerBar.LogoContainer, " ┌──────┬──────┐")
+ fmt.Fprintln(headerBar.LogoContainer, " ───┐ │ ┌───")
+ fmt.Fprintln(headerBar.LogoContainer, " ┐ │ │ │ ┌")
+ fmt.Fprintln(headerBar.LogoContainer, " │ └ │ ┘ │")
+ fmt.Fprintln(headerBar.LogoContainer, " └ ┌ │ ┐ ┘")
+ fmt.Fprintln(headerBar.LogoContainer, " │ │ │")
+ fmt.Fprintln(headerBar.LogoContainer, " ┴")
}
diff --git a/plugins/statusscreen/ui_log.go b/plugins/statusscreen/ui_log.go
index 3f0826aee15b914d1949b3b85a49c6d6e5301eca..6dae65662bd2b2b100d954409c7435e558443587 100644
--- a/plugins/statusscreen/ui_log.go
+++ b/plugins/statusscreen/ui_log.go
@@ -3,13 +3,13 @@ package statusscreen
import "github.com/rivo/tview"
type UILog struct {
- Primitive *tview.Grid
+ Primitive *tview.Grid
}
func NewUILog() *UILog {
- uiLog := &UILog{
- Primitive: tview.NewGrid(),
- }
+ uiLog := &UILog{
+ Primitive: tview.NewGrid(),
+ }
- return uiLog
+ return uiLog
}
diff --git a/plugins/statusscreen/ui_log_entry.go b/plugins/statusscreen/ui_log_entry.go
index 4c5bceae1df133737f1bd5daad44d15ea1e2f8b9..df9a608d2e85a45d91b7673fedb746fbd4bd0b45 100644
--- a/plugins/statusscreen/ui_log_entry.go
+++ b/plugins/statusscreen/ui_log_entry.go
@@ -1,73 +1,74 @@
package statusscreen
import (
- "fmt"
- "github.com/gdamore/tcell"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/rivo/tview"
+ "fmt"
+
+ "github.com/gdamore/tcell"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/rivo/tview"
)
type UILogEntry struct {
- Primitive *tview.Grid
- TimeContainer *tview.TextView
- MessageContainer *tview.TextView
- LogLevelContainer *tview.TextView
+ Primitive *tview.Grid
+ TimeContainer *tview.TextView
+ MessageContainer *tview.TextView
+ LogLevelContainer *tview.TextView
}
func NewUILogEntry(message StatusMessage) *UILogEntry {
- logEntry := &UILogEntry{
- Primitive: tview.NewGrid(),
- TimeContainer: tview.NewTextView(),
- MessageContainer: tview.NewTextView(),
- LogLevelContainer: tview.NewTextView(),
- }
+ logEntry := &UILogEntry{
+ Primitive: tview.NewGrid(),
+ TimeContainer: tview.NewTextView(),
+ MessageContainer: tview.NewTextView(),
+ LogLevelContainer: tview.NewTextView(),
+ }
- logEntry.TimeContainer.SetBackgroundColor(tcell.ColorWhite)
- logEntry.TimeContainer.SetTextColor(tcell.ColorBlack)
- logEntry.TimeContainer.SetDynamicColors(true)
+ logEntry.TimeContainer.SetBackgroundColor(tcell.ColorWhite)
+ logEntry.TimeContainer.SetTextColor(tcell.ColorBlack)
+ logEntry.TimeContainer.SetDynamicColors(true)
- logEntry.MessageContainer.SetBackgroundColor(tcell.ColorWhite)
- logEntry.MessageContainer.SetTextColor(tcell.ColorBlack)
- logEntry.MessageContainer.SetDynamicColors(true)
+ logEntry.MessageContainer.SetBackgroundColor(tcell.ColorWhite)
+ logEntry.MessageContainer.SetTextColor(tcell.ColorBlack)
+ logEntry.MessageContainer.SetDynamicColors(true)
- logEntry.LogLevelContainer.SetBackgroundColor(tcell.ColorWhite)
- logEntry.LogLevelContainer.SetTextColor(tcell.ColorBlack)
- logEntry.LogLevelContainer.SetDynamicColors(true)
+ logEntry.LogLevelContainer.SetBackgroundColor(tcell.ColorWhite)
+ logEntry.LogLevelContainer.SetTextColor(tcell.ColorBlack)
+ logEntry.LogLevelContainer.SetDynamicColors(true)
- textColor := "black::d"
- switch message.LogLevel {
- case node.LOG_LEVEL_INFO:
- fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [blue::d]INFO [black::d]]")
- case node.LOG_LEVEL_SUCCESS:
- fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [green::d]OK [black::d]]")
- case node.LOG_LEVEL_WARNING:
- fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [yellow::d]WARN [black::d]]")
+ textColor := "black::d"
+ switch message.LogLevel {
+ case node.LOG_LEVEL_INFO:
+ fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [blue::d]INFO [black::d]]")
+ case node.LOG_LEVEL_SUCCESS:
+ fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [green::d]OK [black::d]]")
+ case node.LOG_LEVEL_WARNING:
+ fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [yellow::d]WARN [black::d]]")
- textColor = "yellow::d"
- case node.LOG_LEVEL_FAILURE:
- fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [red::d]FAIL [black::d]]")
+ textColor = "yellow::d"
+ case node.LOG_LEVEL_FAILURE:
+ fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [red::d]FAIL [black::d]]")
- textColor = "red::d"
- case node.LOG_LEVEL_DEBUG:
- fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [black::b]NOTE [black::d]]")
+ textColor = "red::d"
+ case node.LOG_LEVEL_DEBUG:
+ fmt.Fprintf(logEntry.LogLevelContainer, " [black::d][ [black::b]NOTE [black::d]]")
- textColor = "black::b"
- }
+ textColor = "black::b"
+ }
- fmt.Fprintf(logEntry.TimeContainer, " [black::b]" + message.Time.Format("15:04:05"))
- if message.Source == "Node" {
- fmt.Fprintf(logEntry.MessageContainer, "[" + textColor + "]" + message.Message)
- } else {
- fmt.Fprintf(logEntry.MessageContainer, "[" + textColor + "]" + message.Source + ": " + message.Message)
- }
+ fmt.Fprintf(logEntry.TimeContainer, " [black::b]"+message.Time.Format("15:04:05"))
+ if message.Source == "Node" {
+ fmt.Fprintf(logEntry.MessageContainer, "["+textColor+"]"+message.Message)
+ } else {
+ fmt.Fprintf(logEntry.MessageContainer, "["+textColor+"]"+message.Source+": "+message.Message)
+ }
- logEntry.Primitive.
- SetColumns(11, 0, 11).
- SetRows(1).
- SetBorders(false).
- AddItem(logEntry.TimeContainer, 0, 0, 1, 1, 0, 0, false).
- AddItem(logEntry.MessageContainer, 0, 1, 1, 1, 0, 0, false).
- AddItem(logEntry.LogLevelContainer, 0, 2, 1, 1, 0, 0, false)
+ logEntry.Primitive.
+ SetColumns(11, 0, 11).
+ SetRows(1).
+ SetBorders(false).
+ AddItem(logEntry.TimeContainer, 0, 0, 1, 1, 0, 0, false).
+ AddItem(logEntry.MessageContainer, 0, 1, 1, 1, 0, 0, false).
+ AddItem(logEntry.LogLevelContainer, 0, 2, 1, 1, 0, 0, false)
- return logEntry
+ return logEntry
}
diff --git a/plugins/tangle/api.go b/plugins/tangle/api.go
index c184762e75f348a8755156296d889d1f94f098e8..c78d108475171846071952bf23145d2bca232ae6 100644
--- a/plugins/tangle/api.go
+++ b/plugins/tangle/api.go
@@ -1,26 +1,26 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/ternary"
)
// region transaction api //////////////////////////////////////////////////////////////////////////////////////////////
func GetTransaction(transactionHash ternary.Trinary) (*Transaction, errors.IdentifiableError) {
- if transaction := getTransactionFromMemPool(transactionHash); transaction != nil {
- return transaction, nil
- }
+ if transaction := getTransactionFromMemPool(transactionHash); transaction != nil {
+ return transaction, nil
+ }
- return getTransactionFromDatabase(transactionHash)
+ return getTransactionFromDatabase(transactionHash)
}
func ContainsTransaction(transactionHash ternary.Trinary) (bool, errors.IdentifiableError) {
- if memPoolContainsTransaction(transactionHash) {
- return true, nil
- }
+ if memPoolContainsTransaction(transactionHash) {
+ return true, nil
+ }
- return databaseContainsTransaction(transactionHash)
+ return databaseContainsTransaction(transactionHash)
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -28,19 +28,19 @@ func ContainsTransaction(transactionHash ternary.Trinary) (bool, errors.Identifi
// region transactionmetadata api //////////////////////////////////////////////////////////////////////////////////////
func GetTransactionMetadata(transactionHash ternary.Trinary) (*TransactionMetadata, errors.IdentifiableError) {
- if transaction := getTransactionFromMemPool(transactionHash); transaction != nil {
- return transaction.GetMetaData()
- }
+ if transaction := getTransactionFromMemPool(transactionHash); transaction != nil {
+ return transaction.GetMetaData()
+ }
- return getTransactionMetadataFromDatabase(transactionHash)
+ return getTransactionMetadataFromDatabase(transactionHash)
}
func ContainsTransactionMetadata(transactionHash ternary.Trinary) (bool, errors.IdentifiableError) {
- if memPoolContainsTransaction(transactionHash) {
- return true, nil
- }
+ if memPoolContainsTransaction(transactionHash) {
+ return true, nil
+ }
- return databaseContainsTransactionMetadata(transactionHash)
+ return databaseContainsTransactionMetadata(transactionHash)
}
-// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
\ No newline at end of file
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/tangle/approvers.go b/plugins/tangle/approvers.go
index 3606330f6dee88cb31b96625ffd254d1a740bb40..e8fd82f0d3b8f5ef9a485851cc4d27efad6b5f1f 100644
--- a/plugins/tangle/approvers.go
+++ b/plugins/tangle/approvers.go
@@ -1,8 +1,9 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/ternary"
"sync"
+
+ "github.com/iotaledger/goshimmer/packages/ternary"
)
type Approvers struct {
diff --git a/plugins/tangle/database.go b/plugins/tangle/database.go
index 88fca65165a8eab6f97540216046668ada7b2e43..54183760d44d8fb8fbc22aa04826fc2ff1006e1d 100644
--- a/plugins/tangle/database.go
+++ b/plugins/tangle/database.go
@@ -1,29 +1,30 @@
package tangle
import (
- "fmt"
- "github.com/dgraph-io/badger"
- "github.com/iotaledger/goshimmer/packages/database"
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/ternary"
- "github.com/iotaledger/goshimmer/packages/transaction"
+ "fmt"
+
+ "github.com/dgraph-io/badger"
+ "github.com/iotaledger/goshimmer/packages/database"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
// region plugin module setup //////////////////////////////////////////////////////////////////////////////////////////
func configureDatabase(plugin *node.Plugin) {
- if db, err := database.Get("transaction"); err != nil {
- panic(err)
- } else {
- transactionDatabase = db
- }
-
- if db, err := database.Get("transactionMetadata"); err != nil {
- panic(err)
- } else {
- transactionMetadataDatabase = db
- }
+ if db, err := database.Get("transaction"); err != nil {
+ panic(err)
+ } else {
+ transactionDatabase = db
+ }
+
+ if db, err := database.Get("transactionMetadata"); err != nil {
+ panic(err)
+ } else {
+ transactionMetadataDatabase = db
+ }
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -31,51 +32,51 @@ func configureDatabase(plugin *node.Plugin) {
// region internal utility functions ///////////////////////////////////////////////////////////////////////////////////
func getTransactionFromDatabase(transactionHash ternary.Trinary) (*Transaction, errors.IdentifiableError) {
- txData, err := transactionDatabase.Get(transactionHash.CastToBytes())
- if err != nil {
- if err == badger.ErrKeyNotFound {
- return nil, nil
- } else {
- return nil, ErrDatabaseError.Derive(err, "failed to retrieve transaction")
- }
- }
-
- return &Transaction{
- rawTransaction: transaction.FromBytes(txData),
- }, nil
+ txData, err := transactionDatabase.Get(transactionHash.CastToBytes())
+ if err != nil {
+ if err == badger.ErrKeyNotFound {
+ return nil, nil
+ } else {
+ return nil, ErrDatabaseError.Derive(err, "failed to retrieve transaction")
+ }
+ }
+
+ return &Transaction{
+ rawTransaction: transaction.FromBytes(txData),
+ }, nil
}
func databaseContainsTransaction(transactionHash ternary.Trinary) (bool, errors.IdentifiableError) {
- if contains, err := transactionDatabase.Contains(transactionHash.CastToBytes()); err != nil {
- return contains, ErrDatabaseError.Derive(err, "failed to check if the transaction exists")
- } else {
- return contains, nil
- }
+ if contains, err := transactionDatabase.Contains(transactionHash.CastToBytes()); err != nil {
+ return contains, ErrDatabaseError.Derive(err, "failed to check if the transaction exists")
+ } else {
+ return contains, nil
+ }
}
func getTransactionMetadataFromDatabase(transactionHash ternary.Trinary) (*TransactionMetadata, errors.IdentifiableError) {
- txMetadata, err := transactionMetadataDatabase.Get(transactionHash.CastToBytes())
- if err != nil {
- if err == badger.ErrKeyNotFound {
- return nil, nil
- } else {
- return nil, ErrDatabaseError.Derive(err, "failed to retrieve transaction")
- }
- }
-
- if false {
- fmt.Println(txMetadata)
- }
-
- return &TransactionMetadata{}, nil
+ txMetadata, err := transactionMetadataDatabase.Get(transactionHash.CastToBytes())
+ if err != nil {
+ if err == badger.ErrKeyNotFound {
+ return nil, nil
+ } else {
+ return nil, ErrDatabaseError.Derive(err, "failed to retrieve transaction")
+ }
+ }
+
+ if false {
+ fmt.Println(txMetadata)
+ }
+
+ return &TransactionMetadata{}, nil
}
func databaseContainsTransactionMetadata(transactionHash ternary.Trinary) (bool, errors.IdentifiableError) {
- if contains, err := transactionMetadataDatabase.Contains(transactionHash.CastToBytes()); err != nil {
- return contains, ErrDatabaseError.Derive(err, "failed to check if the transaction metadata exists")
- } else {
- return contains, nil
- }
+ if contains, err := transactionMetadataDatabase.Contains(transactionHash.CastToBytes()); err != nil {
+ return contains, ErrDatabaseError.Derive(err, "failed to check if the transaction metadata exists")
+ } else {
+ return contains, nil
+ }
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/tangle/errors.go b/plugins/tangle/errors.go
index 809e6a6587827ee71d979f76d9e30640753967be..ffde1bcc9d30ac5d6e22f2d6806c17be41973af6 100644
--- a/plugins/tangle/errors.go
+++ b/plugins/tangle/errors.go
@@ -3,7 +3,7 @@ package tangle
import "github.com/iotaledger/goshimmer/packages/errors"
var (
- ErrDatabaseError = errors.Wrap(errors.New("database error"), "failed to access the database")
- ErrUnmarshalFailed = errors.Wrap(errors.New("unmarshall failed"), "input data is corrupted")
- ErrMarshallFailed = errors.Wrap(errors.New("marshal failed"), "the source object contains invalid values")
+ ErrDatabaseError = errors.Wrap(errors.New("database error"), "failed to access the database")
+ ErrUnmarshalFailed = errors.Wrap(errors.New("unmarshall failed"), "input data is corrupted")
+ ErrMarshallFailed = errors.Wrap(errors.New("marshal failed"), "the source object contains invalid values")
)
diff --git a/plugins/tangle/events.go b/plugins/tangle/events.go
index cc58a4898181793fa9f5f79c6957693ebba73743..bb8883a58a14f6fada96135e0a5cc24d36a29afc 100644
--- a/plugins/tangle/events.go
+++ b/plugins/tangle/events.go
@@ -1,17 +1,19 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/events"
)
var Events = pluginEvents{
- TransactionStored: events.NewEvent(transactionCaller),
- TransactionSolid: events.NewEvent(transactionCaller),
+ TransactionStored: events.NewEvent(transactionCaller),
+ TransactionSolid: events.NewEvent(transactionCaller),
}
type pluginEvents struct {
- TransactionStored *events.Event
- TransactionSolid *events.Event
+ TransactionStored *events.Event
+ TransactionSolid *events.Event
}
-func transactionCaller(handler interface{}, params ...interface{}) { handler.(func(*Transaction))(params[0].(*Transaction)) }
+func transactionCaller(handler interface{}, params ...interface{}) {
+ handler.(func(*Transaction))(params[0].(*Transaction))
+}
diff --git a/plugins/tangle/mempool.go b/plugins/tangle/mempool.go
index 7f80d5bcaf54e95bda754e114bfd6e55ba93941a..25c65754531bfc0c82f807c9277ff01cd934dbf0 100644
--- a/plugins/tangle/mempool.go
+++ b/plugins/tangle/mempool.go
@@ -1,28 +1,29 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/daemon"
- "github.com/iotaledger/goshimmer/packages/events"
- "github.com/iotaledger/goshimmer/packages/node"
- "github.com/iotaledger/goshimmer/packages/ternary"
- "github.com/iotaledger/goshimmer/packages/transaction"
- "github.com/iotaledger/goshimmer/plugins/gossip"
- "sync"
- "time"
+ "sync"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/daemon"
+ "github.com/iotaledger/goshimmer/packages/events"
+ "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/transaction"
+ "github.com/iotaledger/goshimmer/plugins/gossip"
)
// region plugin module setup //////////////////////////////////////////////////////////////////////////////////////////
func configureMemPool(plugin *node.Plugin) {
- gossip.Events.ReceiveTransaction.Attach(events.NewClosure(func(transaction *transaction.Transaction) {
- memPoolQueue <- &Transaction{rawTransaction: transaction}
- }))
+ gossip.Events.ReceiveTransaction.Attach(events.NewClosure(func(transaction *transaction.Transaction) {
+ memPoolQueue <- &Transaction{rawTransaction: transaction}
+ }))
}
func runMemPool(plugin *node.Plugin) {
- plugin.LogInfo("Starting Mempool ...")
+ plugin.LogInfo("Starting Mempool ...")
- daemon.BackgroundWorker(createMemPoolWorker(plugin))
+ daemon.BackgroundWorker(createMemPoolWorker(plugin))
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -30,85 +31,85 @@ func runMemPool(plugin *node.Plugin) {
// region internal utility functions ///////////////////////////////////////////////////////////////////////////////////
func createMemPoolWorker(plugin *node.Plugin) func() {
- return func() {
- plugin.LogSuccess("Starting Mempool ... done")
+ return func() {
+ plugin.LogSuccess("Starting Mempool ... done")
- shuttingDown := false
+ shuttingDown := false
- for !shuttingDown {
- flushTimer := time.After(MEMPOOL_FLUSH_INTERVAL)
+ for !shuttingDown {
+ flushTimer := time.After(MEMPOOL_FLUSH_INTERVAL)
- select {
- case <-daemon.ShutdownSignal:
- plugin.LogInfo("Stopping Mempool ...")
+ select {
+ case <-daemon.ShutdownSignal:
+ plugin.LogInfo("Stopping Mempool ...")
- shuttingDown = true
+ shuttingDown = true
- continue
+ continue
- case <-flushTimer:
- // store transactions in database
+ case <-flushTimer:
+ // store transactions in database
- case tx := <-memPoolQueue:
- // skip transactions that we have processed already
- if transactionStoredAlready, err := ContainsTransaction(tx.GetHash()); err != nil {
- plugin.LogFailure(err.Error())
+ case tx := <-memPoolQueue:
+ // skip transactions that we have processed already
+ if transactionStoredAlready, err := ContainsTransaction(tx.GetHash()); err != nil {
+ plugin.LogFailure(err.Error())
- return
- } else if transactionStoredAlready {
- continue
- }
+ return
+ } else if transactionStoredAlready {
+ continue
+ }
- // store tx in memPool
- memPoolMutex.Lock()
- memPool[tx.GetHash()] = tx
- memPoolMutex.Unlock()
+ // store tx in memPool
+ memPoolMutex.Lock()
+ memPool[tx.GetHash()] = tx
+ memPoolMutex.Unlock()
- // update solidity of transactions
- _, err := UpdateSolidity(tx)
- if err != nil {
- plugin.LogFailure(err.Error())
+ // update solidity of transactions
+ _, err := UpdateSolidity(tx)
+ if err != nil {
+ plugin.LogFailure(err.Error())
- return
- }
+ return
+ }
- go func() {
- <-time.After(1 * time.Minute)
+ go func() {
+ <-time.After(1 * time.Minute)
- err := tx.Store()
- if err != nil {
- plugin.LogFailure(err.Error())
- }
+ err := tx.Store()
+ if err != nil {
+ plugin.LogFailure(err.Error())
+ }
- memPoolMutex.Lock()
- delete(memPool, tx.GetHash())
- memPoolMutex.Unlock()
- }()
- }
- }
+ memPoolMutex.Lock()
+ delete(memPool, tx.GetHash())
+ memPoolMutex.Unlock()
+ }()
+ }
+ }
- plugin.LogSuccess("Stopping Mempool ... done")
- }
+ plugin.LogSuccess("Stopping Mempool ... done")
+ }
}
func getTransactionFromMemPool(transactionHash ternary.Trinary) *Transaction {
- memPoolMutex.RLock()
- defer memPoolMutex.RUnlock()
+ memPoolMutex.RLock()
+ defer memPoolMutex.RUnlock()
- if cacheEntry, exists := memPool[transactionHash]; exists {
- return cacheEntry
- }
+ if cacheEntry, exists := memPool[transactionHash]; exists {
+ return cacheEntry
+ }
- return nil
+ return nil
}
func memPoolContainsTransaction(transactionHash ternary.Trinary) bool {
- memPoolMutex.RLock()
- defer memPoolMutex.RUnlock()
+ memPoolMutex.RLock()
+ defer memPoolMutex.RUnlock()
- _, exists := memPool[transactionHash]
+ _, exists := memPool[transactionHash]
- return exists
+ return exists
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -122,9 +123,9 @@ var memPool = make(map[ternary.Trinary]*Transaction)
var memPoolMutex sync.RWMutex
const (
- MEM_POOL_QUEUE_SIZE = 1000
+ MEM_POOL_QUEUE_SIZE = 1000
- MEMPOOL_FLUSH_INTERVAL = 500 * time.Millisecond
+ MEMPOOL_FLUSH_INTERVAL = 500 * time.Millisecond
)
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/tangle/plugin.go b/plugins/tangle/plugin.go
index e41f763217f87c7c15097bb5b435e7043ec36b2a..7482240a3da8f3b5573d90e60bb38cb68f17e306 100644
--- a/plugins/tangle/plugin.go
+++ b/plugins/tangle/plugin.go
@@ -1,7 +1,7 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/node"
+ "github.com/iotaledger/goshimmer/packages/node"
)
// region plugin module setup //////////////////////////////////////////////////////////////////////////////////////////
@@ -9,12 +9,12 @@ import (
var PLUGIN = node.NewPlugin("Tangle", configure, run)
func configure(plugin *node.Plugin) {
- configureDatabase(plugin)
- configureMemPool(plugin)
+ configureDatabase(plugin)
+ configureMemPool(plugin)
}
func run(plugin *node.Plugin) {
- runMemPool(plugin)
+ runMemPool(plugin)
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/tangle/solidifier.go b/plugins/tangle/solidifier.go
index 4fa57cc29885645c32f4fea38fbc9e4dea1ba6a9..512359a71ed14943d4b7bce24e109c75d3743b83 100644
--- a/plugins/tangle/solidifier.go
+++ b/plugins/tangle/solidifier.go
@@ -1,57 +1,57 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/ternary"
)
func UpdateSolidity(transaction *Transaction) (bool, errors.IdentifiableError) {
- // abort if transaction is solid already
- txMetadata, err := transaction.GetMetaData()
- if err != nil {
- return false, err
- } else if txMetadata.GetSolid() {
- return true, nil
- }
-
- // check solidity of branch transaction if it is not genesis
- if branchTransactionHash := transaction.GetBranchTransactionHash(); branchTransactionHash != ternary.Trinary("999999") {
- // abort if branch transaction is missing
- branchTransaction, err := GetTransaction(branchTransactionHash)
- if err != nil {
- return false, err
- } else if branchTransaction == nil {
- return false, nil
- }
-
- // abort if branch transaction is not solid
- if branchTransactionMetadata, err := branchTransaction.GetMetaData(); err != nil {
- return false, err
- } else if !branchTransactionMetadata.GetSolid() {
- return false, nil
- }
- }
-
- // check solidity of branch transaction if it is not genesis
- if trunkTransactionHash := transaction.GetBranchTransactionHash(); trunkTransactionHash != ternary.Trinary("999999") {
- // abort if trunk transaction is missing
- trunkTransaction, err := GetTransaction(trunkTransactionHash)
- if err != nil {
- return false, err
- } else if trunkTransaction == nil {
- return false, nil
- }
-
- // abort if trunk transaction is not solid
- if trunkTransactionMetadata, err := trunkTransaction.GetMetaData(); err != nil {
- return false, err
- } else if !trunkTransactionMetadata.GetSolid() {
- return false, nil
- }
- }
-
- // propagate solidity to all approvers
- txMetadata.SetSolid(true)
-
- return true, nil
-}
\ No newline at end of file
+ // abort if transaction is solid already
+ txMetadata, err := transaction.GetMetaData()
+ if err != nil {
+ return false, err
+ } else if txMetadata.GetSolid() {
+ return true, nil
+ }
+
+ // check solidity of branch transaction if it is not genesis
+ if branchTransactionHash := transaction.GetBranchTransactionHash(); branchTransactionHash != ternary.Trinary("999999") {
+ // abort if branch transaction is missing
+ branchTransaction, err := GetTransaction(branchTransactionHash)
+ if err != nil {
+ return false, err
+ } else if branchTransaction == nil {
+ return false, nil
+ }
+
+ // abort if branch transaction is not solid
+ if branchTransactionMetadata, err := branchTransaction.GetMetaData(); err != nil {
+ return false, err
+ } else if !branchTransactionMetadata.GetSolid() {
+ return false, nil
+ }
+ }
+
+ // check solidity of branch transaction if it is not genesis
+ if trunkTransactionHash := transaction.GetBranchTransactionHash(); trunkTransactionHash != ternary.Trinary("999999") {
+ // abort if trunk transaction is missing
+ trunkTransaction, err := GetTransaction(trunkTransactionHash)
+ if err != nil {
+ return false, err
+ } else if trunkTransaction == nil {
+ return false, nil
+ }
+
+ // abort if trunk transaction is not solid
+ if trunkTransactionMetadata, err := trunkTransaction.GetMetaData(); err != nil {
+ return false, err
+ } else if !trunkTransactionMetadata.GetSolid() {
+ return false, nil
+ }
+ }
+
+ // propagate solidity to all approvers
+ txMetadata.SetSolid(true)
+
+ return true, nil
+}
diff --git a/plugins/tangle/transaction.go b/plugins/tangle/transaction.go
index 034eb0d177a613a82a05789bd0d57c05cd429021..9fbc2a0b1dcce3e03841bde3aa27e1e786c1a747 100644
--- a/plugins/tangle/transaction.go
+++ b/plugins/tangle/transaction.go
@@ -1,49 +1,50 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/ternary"
- "github.com/iotaledger/goshimmer/packages/transaction"
- "sync"
+ "sync"
+
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/transaction"
)
// region type definition and constructor //////////////////////////////////////////////////////////////////////////////
type Transaction struct {
- // wrapped objects
- rawTransaction *transaction.Transaction
- rawMetaData *TransactionMetadata
- 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
-
- // additional runtime specific metadata
- modified bool
- modifiedMutex sync.RWMutex
+ // wrapped objects
+ rawTransaction *transaction.Transaction
+ rawMetaData *TransactionMetadata
+ 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
+
+ // additional runtime specific metadata
+ modified bool
+ modifiedMutex sync.RWMutex
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -51,582 +52,582 @@ type Transaction struct {
// region getters and setters //////////////////////////////////////////////////////////////////////////////////////////
func (transaction *Transaction) GetMetaData() (*TransactionMetadata, errors.IdentifiableError) {
- transaction.rawMetaDataMutex.RLock()
- if transaction.rawMetaData == nil {
- transaction.rawMetaDataMutex.RUnlock()
- transaction.rawMetaDataMutex.Lock()
- defer transaction.rawMetaDataMutex.Unlock()
- if transaction.rawMetaData == nil {
- if metaData, err := getTransactionMetadataFromDatabase(transaction.GetHash()); err != nil {
- return nil, err
- } else if metaData == nil {
- transaction.rawMetaData = NewTransactionMetadata(transaction.GetHash())
- } else {
- transaction.rawMetaData = metaData
- }
+ transaction.rawMetaDataMutex.RLock()
+ if transaction.rawMetaData == nil {
+ transaction.rawMetaDataMutex.RUnlock()
+ transaction.rawMetaDataMutex.Lock()
+ defer transaction.rawMetaDataMutex.Unlock()
+ if transaction.rawMetaData == nil {
+ if metaData, err := getTransactionMetadataFromDatabase(transaction.GetHash()); err != nil {
+ return nil, err
+ } else if metaData == nil {
+ transaction.rawMetaData = NewTransactionMetadata(transaction.GetHash())
+ } else {
+ transaction.rawMetaData = metaData
+ }
- return transaction.rawMetaData, nil
- }
- }
+ return transaction.rawMetaData, nil
+ }
+ }
- defer transaction.rawMetaDataMutex.RUnlock()
+ defer transaction.rawMetaDataMutex.RUnlock()
- return transaction.rawMetaData, nil
+ return transaction.rawMetaData, nil
}
// getter for the hash (supports concurrency)
func (transaction *Transaction) GetHash() ternary.Trinary {
- transaction.hashMutex.RLock()
- if transaction.hash == nil {
- transaction.hashMutex.RUnlock()
- transaction.hashMutex.Lock()
- defer transaction.hashMutex.Unlock()
- if transaction.hash == nil {
- return transaction.parseHash()
- }
- }
+ transaction.hashMutex.RLock()
+ if transaction.hash == nil {
+ transaction.hashMutex.RUnlock()
+ transaction.hashMutex.Lock()
+ defer transaction.hashMutex.Unlock()
+ if transaction.hash == nil {
+ return transaction.parseHash()
+ }
+ }
- defer transaction.hashMutex.RUnlock()
+ defer transaction.hashMutex.RUnlock()
- return *transaction.hash
+ return *transaction.hash
}
// setter for the hash (supports concurrency)
func (transaction *Transaction) SetHash(hash ternary.Trinary) {
- transaction.hashMutex.RLock()
- if transaction.hash == nil || *transaction.hash != hash {
- transaction.hashMutex.RUnlock()
- transaction.hashMutex.Lock()
- defer transaction.hashMutex.Unlock()
- if transaction.hash == nil || *transaction.hash != hash {
- *transaction.hash = hash
+ transaction.hashMutex.RLock()
+ if transaction.hash == nil || *transaction.hash != hash {
+ transaction.hashMutex.RUnlock()
+ transaction.hashMutex.Lock()
+ defer transaction.hashMutex.Unlock()
+ if transaction.hash == nil || *transaction.hash != hash {
+ *transaction.hash = hash
- transaction.SetModified(true)
- }
- } else {
- transaction.hashMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.hashMutex.RUnlock()
+ }
}
// restores the hash from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseHash() ternary.Trinary {
- transaction.hashMutex.Lock()
- defer transaction.hashMutex.Unlock()
+ transaction.hashMutex.Lock()
+ defer transaction.hashMutex.Unlock()
- return transaction.parseHash()
+ return transaction.parseHash()
}
// parses the hash from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseHash() ternary.Trinary {
- *transaction.hash = transaction.rawTransaction.Hash.ToTrinary()
+ *transaction.hash = transaction.rawTransaction.Hash.ToTrinary()
- return *transaction.hash
+ return *transaction.hash
}
// getter for the address (supports concurrency)
func (transaction *Transaction) GetAddress() ternary.Trinary {
- transaction.addressMutex.RLock()
- if transaction.address == nil {
- transaction.addressMutex.RUnlock()
- transaction.addressMutex.Lock()
- defer transaction.addressMutex.Unlock()
- if transaction.address == nil {
- return transaction.parseAddress()
- }
- }
+ transaction.addressMutex.RLock()
+ if transaction.address == nil {
+ transaction.addressMutex.RUnlock()
+ transaction.addressMutex.Lock()
+ defer transaction.addressMutex.Unlock()
+ if transaction.address == nil {
+ return transaction.parseAddress()
+ }
+ }
- defer transaction.addressMutex.RUnlock()
+ defer transaction.addressMutex.RUnlock()
- return *transaction.address
+ return *transaction.address
}
// setter for the address (supports concurrency)
func (transaction *Transaction) SetAddress(address ternary.Trinary) {
- transaction.addressMutex.RLock()
- if transaction.address == nil || *transaction.address != address {
- transaction.addressMutex.RUnlock()
- transaction.addressMutex.Lock()
- defer transaction.addressMutex.Unlock()
- if transaction.address == nil || *transaction.address != address {
- *transaction.address = address
+ transaction.addressMutex.RLock()
+ if transaction.address == nil || *transaction.address != address {
+ transaction.addressMutex.RUnlock()
+ transaction.addressMutex.Lock()
+ defer transaction.addressMutex.Unlock()
+ if transaction.address == nil || *transaction.address != address {
+ *transaction.address = address
- transaction.SetModified(true)
- }
- } else {
- transaction.addressMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.addressMutex.RUnlock()
+ }
}
// restores the address from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseAddress() ternary.Trinary {
- transaction.addressMutex.Lock()
- defer transaction.addressMutex.Unlock()
+ transaction.addressMutex.Lock()
+ defer transaction.addressMutex.Unlock()
- return transaction.parseAddress()
+ return transaction.parseAddress()
}
// parses the address from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseAddress() ternary.Trinary {
- *transaction.address = transaction.rawTransaction.Hash.ToTrinary()
+ *transaction.address = transaction.rawTransaction.Hash.ToTrinary()
- return *transaction.address
+ return *transaction.address
}
// getter for the value (supports concurrency)
func (transaction *Transaction) GetValue() int64 {
- transaction.valueMutex.RLock()
- if transaction.value == nil {
- transaction.valueMutex.RUnlock()
- transaction.valueMutex.Lock()
- defer transaction.valueMutex.Unlock()
- if transaction.value == nil {
- return transaction.parseValue()
- }
- }
+ transaction.valueMutex.RLock()
+ if transaction.value == nil {
+ transaction.valueMutex.RUnlock()
+ transaction.valueMutex.Lock()
+ defer transaction.valueMutex.Unlock()
+ if transaction.value == nil {
+ return transaction.parseValue()
+ }
+ }
- defer transaction.valueMutex.RUnlock()
+ defer transaction.valueMutex.RUnlock()
- return *transaction.value
+ return *transaction.value
}
// setter for the value (supports concurrency)
func (transaction *Transaction) SetValue(value int64) {
- transaction.valueMutex.RLock()
- if transaction.value == nil || *transaction.value != value {
- transaction.valueMutex.RUnlock()
- transaction.valueMutex.Lock()
- defer transaction.valueMutex.Unlock()
- if transaction.value == nil || *transaction.value != value {
- *transaction.value = value
+ transaction.valueMutex.RLock()
+ if transaction.value == nil || *transaction.value != value {
+ transaction.valueMutex.RUnlock()
+ transaction.valueMutex.Lock()
+ defer transaction.valueMutex.Unlock()
+ if transaction.value == nil || *transaction.value != value {
+ *transaction.value = value
- transaction.SetModified(true)
- }
- } else {
- transaction.valueMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.valueMutex.RUnlock()
+ }
}
// restores the value from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseValue() int64 {
- transaction.valueMutex.Lock()
- defer transaction.valueMutex.Unlock()
+ transaction.valueMutex.Lock()
+ defer transaction.valueMutex.Unlock()
- return transaction.parseValue()
+ return transaction.parseValue()
}
// parses the value from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseValue() int64 {
- *transaction.value = transaction.rawTransaction.Value.ToInt64()
+ *transaction.value = transaction.rawTransaction.Value.ToInt64()
- return *transaction.value
+ return *transaction.value
}
// getter for the timestamp (supports concurrency)
func (transaction *Transaction) GetTimestamp() uint64 {
- transaction.timestampMutex.RLock()
- if transaction.timestamp == nil {
- transaction.timestampMutex.RUnlock()
- transaction.timestampMutex.Lock()
- defer transaction.timestampMutex.Unlock()
- if transaction.timestamp == nil {
- return transaction.parseTimestamp()
- }
- }
+ transaction.timestampMutex.RLock()
+ if transaction.timestamp == nil {
+ transaction.timestampMutex.RUnlock()
+ transaction.timestampMutex.Lock()
+ defer transaction.timestampMutex.Unlock()
+ if transaction.timestamp == nil {
+ return transaction.parseTimestamp()
+ }
+ }
- defer transaction.timestampMutex.RUnlock()
+ defer transaction.timestampMutex.RUnlock()
- return *transaction.timestamp
+ return *transaction.timestamp
}
// setter for the timestamp (supports concurrency)
func (transaction *Transaction) SetTimestamp(timestamp uint64) {
- transaction.timestampMutex.RLock()
- if transaction.timestamp == nil || *transaction.timestamp != timestamp {
- transaction.timestampMutex.RUnlock()
- transaction.timestampMutex.Lock()
- defer transaction.timestampMutex.Unlock()
- if transaction.timestamp == nil || *transaction.timestamp != timestamp {
- *transaction.timestamp = timestamp
+ transaction.timestampMutex.RLock()
+ if transaction.timestamp == nil || *transaction.timestamp != timestamp {
+ transaction.timestampMutex.RUnlock()
+ transaction.timestampMutex.Lock()
+ defer transaction.timestampMutex.Unlock()
+ if transaction.timestamp == nil || *transaction.timestamp != timestamp {
+ *transaction.timestamp = timestamp
- transaction.SetModified(true)
- }
- } else {
- transaction.timestampMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.timestampMutex.RUnlock()
+ }
}
// restores the timestamp from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseTimestamp() uint64 {
- transaction.timestampMutex.Lock()
- defer transaction.timestampMutex.Unlock()
+ transaction.timestampMutex.Lock()
+ defer transaction.timestampMutex.Unlock()
- return transaction.parseTimestamp()
+ return transaction.parseTimestamp()
}
// parses the timestamp from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseTimestamp() uint64 {
- *transaction.timestamp = transaction.rawTransaction.Timestamp.ToUint64()
+ *transaction.timestamp = transaction.rawTransaction.Timestamp.ToUint64()
- return *transaction.timestamp
+ return *transaction.timestamp
}
// getter for the currentIndex (supports concurrency)
func (transaction *Transaction) GetCurrentIndex() uint64 {
- transaction.currentIndexMutex.RLock()
- if transaction.currentIndex == nil {
- transaction.currentIndexMutex.RUnlock()
- transaction.currentIndexMutex.Lock()
- defer transaction.currentIndexMutex.Unlock()
- if transaction.currentIndex == nil {
- return transaction.parseCurrentIndex()
- }
- }
+ transaction.currentIndexMutex.RLock()
+ if transaction.currentIndex == nil {
+ transaction.currentIndexMutex.RUnlock()
+ transaction.currentIndexMutex.Lock()
+ defer transaction.currentIndexMutex.Unlock()
+ if transaction.currentIndex == nil {
+ return transaction.parseCurrentIndex()
+ }
+ }
- defer transaction.currentIndexMutex.RUnlock()
+ defer transaction.currentIndexMutex.RUnlock()
- return *transaction.currentIndex
+ return *transaction.currentIndex
}
// setter for the currentIndex (supports concurrency)
func (transaction *Transaction) SetCurrentIndex(currentIndex uint64) {
- transaction.currentIndexMutex.RLock()
- if transaction.currentIndex == nil || *transaction.currentIndex != currentIndex {
- transaction.currentIndexMutex.RUnlock()
- transaction.currentIndexMutex.Lock()
- defer transaction.currentIndexMutex.Unlock()
- if transaction.currentIndex == nil || *transaction.currentIndex != currentIndex {
- *transaction.currentIndex = currentIndex
+ transaction.currentIndexMutex.RLock()
+ if transaction.currentIndex == nil || *transaction.currentIndex != currentIndex {
+ transaction.currentIndexMutex.RUnlock()
+ transaction.currentIndexMutex.Lock()
+ defer transaction.currentIndexMutex.Unlock()
+ if transaction.currentIndex == nil || *transaction.currentIndex != currentIndex {
+ *transaction.currentIndex = currentIndex
- transaction.SetModified(true)
- }
- } else {
- transaction.currentIndexMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.currentIndexMutex.RUnlock()
+ }
}
// restores the currentIndex from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseCurrentIndex() uint64 {
- transaction.currentIndexMutex.Lock()
- defer transaction.currentIndexMutex.Unlock()
+ transaction.currentIndexMutex.Lock()
+ defer transaction.currentIndexMutex.Unlock()
- return transaction.parseCurrentIndex()
+ return transaction.parseCurrentIndex()
}
// parses the currentIndex from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseCurrentIndex() uint64 {
- *transaction.currentIndex = transaction.rawTransaction.CurrentIndex.ToUint64()
+ *transaction.currentIndex = transaction.rawTransaction.CurrentIndex.ToUint64()
- return *transaction.currentIndex
+ return *transaction.currentIndex
}
// getter for the latestIndex (supports concurrency)
func (transaction *Transaction) GetLatestIndex() uint64 {
- transaction.latestIndexMutex.RLock()
- if transaction.latestIndex == nil {
- transaction.latestIndexMutex.RUnlock()
- transaction.latestIndexMutex.Lock()
- defer transaction.latestIndexMutex.Unlock()
- if transaction.latestIndex == nil {
- return transaction.parseLatestIndex()
- }
- }
+ transaction.latestIndexMutex.RLock()
+ if transaction.latestIndex == nil {
+ transaction.latestIndexMutex.RUnlock()
+ transaction.latestIndexMutex.Lock()
+ defer transaction.latestIndexMutex.Unlock()
+ if transaction.latestIndex == nil {
+ return transaction.parseLatestIndex()
+ }
+ }
- defer transaction.latestIndexMutex.RUnlock()
+ defer transaction.latestIndexMutex.RUnlock()
- return *transaction.latestIndex
+ return *transaction.latestIndex
}
// setter for the latestIndex (supports concurrency)
func (transaction *Transaction) SetLatestIndex(latestIndex uint64) {
- transaction.latestIndexMutex.RLock()
- if transaction.latestIndex == nil || *transaction.latestIndex != latestIndex {
- transaction.latestIndexMutex.RUnlock()
- transaction.latestIndexMutex.Lock()
- defer transaction.latestIndexMutex.Unlock()
- if transaction.latestIndex == nil || *transaction.latestIndex != latestIndex {
- *transaction.latestIndex = latestIndex
+ transaction.latestIndexMutex.RLock()
+ if transaction.latestIndex == nil || *transaction.latestIndex != latestIndex {
+ transaction.latestIndexMutex.RUnlock()
+ transaction.latestIndexMutex.Lock()
+ defer transaction.latestIndexMutex.Unlock()
+ if transaction.latestIndex == nil || *transaction.latestIndex != latestIndex {
+ *transaction.latestIndex = latestIndex
- transaction.SetModified(true)
- }
- } else {
- transaction.latestIndexMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.latestIndexMutex.RUnlock()
+ }
}
// restores the latestIndex from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseLatestIndex() uint64 {
- transaction.latestIndexMutex.Lock()
- defer transaction.latestIndexMutex.Unlock()
+ transaction.latestIndexMutex.Lock()
+ defer transaction.latestIndexMutex.Unlock()
- return transaction.parseLatestIndex()
+ return transaction.parseLatestIndex()
}
// parses the latestIndex from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseLatestIndex() uint64 {
- *transaction.latestIndex = transaction.rawTransaction.LatestIndex.ToUint64()
+ *transaction.latestIndex = transaction.rawTransaction.LatestIndex.ToUint64()
- return *transaction.latestIndex
+ return *transaction.latestIndex
}
// getter for the bundleHash (supports concurrency)
func (transaction *Transaction) GetBundleHash() ternary.Trinary {
- transaction.bundleHashMutex.RLock()
- if transaction.bundleHash == nil {
- transaction.bundleHashMutex.RUnlock()
- transaction.bundleHashMutex.Lock()
- defer transaction.bundleHashMutex.Unlock()
- if transaction.bundleHash == nil {
- return transaction.parseBundleHash()
- }
- }
+ transaction.bundleHashMutex.RLock()
+ if transaction.bundleHash == nil {
+ transaction.bundleHashMutex.RUnlock()
+ transaction.bundleHashMutex.Lock()
+ defer transaction.bundleHashMutex.Unlock()
+ if transaction.bundleHash == nil {
+ return transaction.parseBundleHash()
+ }
+ }
- defer transaction.bundleHashMutex.RUnlock()
+ defer transaction.bundleHashMutex.RUnlock()
- return *transaction.bundleHash
+ return *transaction.bundleHash
}
// setter for the bundleHash (supports concurrency)
func (transaction *Transaction) SetBundleHash(bundleHash ternary.Trinary) {
- transaction.bundleHashMutex.RLock()
- if transaction.bundleHash == nil || *transaction.bundleHash != bundleHash {
- transaction.bundleHashMutex.RUnlock()
- transaction.bundleHashMutex.Lock()
- defer transaction.bundleHashMutex.Unlock()
- if transaction.bundleHash == nil || *transaction.bundleHash != bundleHash {
- *transaction.bundleHash = bundleHash
+ transaction.bundleHashMutex.RLock()
+ if transaction.bundleHash == nil || *transaction.bundleHash != bundleHash {
+ transaction.bundleHashMutex.RUnlock()
+ transaction.bundleHashMutex.Lock()
+ defer transaction.bundleHashMutex.Unlock()
+ if transaction.bundleHash == nil || *transaction.bundleHash != bundleHash {
+ *transaction.bundleHash = bundleHash
- transaction.SetModified(true)
- }
- } else {
- transaction.bundleHashMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.bundleHashMutex.RUnlock()
+ }
}
// restores the bundleHash from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseBundleHash() ternary.Trinary {
- transaction.bundleHashMutex.Lock()
- defer transaction.bundleHashMutex.Unlock()
+ transaction.bundleHashMutex.Lock()
+ defer transaction.bundleHashMutex.Unlock()
- return transaction.parseBundleHash()
+ return transaction.parseBundleHash()
}
// parses the bundleHash from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseBundleHash() ternary.Trinary {
- *transaction.bundleHash = transaction.rawTransaction.BundleHash.ToTrinary()
+ *transaction.bundleHash = transaction.rawTransaction.BundleHash.ToTrinary()
- return *transaction.bundleHash
+ return *transaction.bundleHash
}
// getter for the trunkTransactionHash (supports concurrency)
func (transaction *Transaction) GetTrunkTransactionHash() ternary.Trinary {
- transaction.trunkTransactionHashMutex.RLock()
- if transaction.trunkTransactionHash == nil {
- transaction.trunkTransactionHashMutex.RUnlock()
- transaction.trunkTransactionHashMutex.Lock()
- defer transaction.trunkTransactionHashMutex.Unlock()
- if transaction.trunkTransactionHash == nil {
- return transaction.parseTrunkTransactionHash()
- }
- }
+ transaction.trunkTransactionHashMutex.RLock()
+ if transaction.trunkTransactionHash == nil {
+ transaction.trunkTransactionHashMutex.RUnlock()
+ transaction.trunkTransactionHashMutex.Lock()
+ defer transaction.trunkTransactionHashMutex.Unlock()
+ if transaction.trunkTransactionHash == nil {
+ return transaction.parseTrunkTransactionHash()
+ }
+ }
- defer transaction.trunkTransactionHashMutex.RUnlock()
+ defer transaction.trunkTransactionHashMutex.RUnlock()
- return *transaction.trunkTransactionHash
+ return *transaction.trunkTransactionHash
}
// setter for the trunkTransactionHash (supports concurrency)
func (transaction *Transaction) SetTrunkTransactionHash(trunkTransactionHash ternary.Trinary) {
- transaction.trunkTransactionHashMutex.RLock()
- if transaction.trunkTransactionHash == nil || *transaction.trunkTransactionHash != trunkTransactionHash {
- transaction.trunkTransactionHashMutex.RUnlock()
- transaction.trunkTransactionHashMutex.Lock()
- defer transaction.trunkTransactionHashMutex.Unlock()
- if transaction.trunkTransactionHash == nil || *transaction.trunkTransactionHash != trunkTransactionHash {
- *transaction.trunkTransactionHash = trunkTransactionHash
+ transaction.trunkTransactionHashMutex.RLock()
+ if transaction.trunkTransactionHash == nil || *transaction.trunkTransactionHash != trunkTransactionHash {
+ transaction.trunkTransactionHashMutex.RUnlock()
+ transaction.trunkTransactionHashMutex.Lock()
+ defer transaction.trunkTransactionHashMutex.Unlock()
+ if transaction.trunkTransactionHash == nil || *transaction.trunkTransactionHash != trunkTransactionHash {
+ *transaction.trunkTransactionHash = trunkTransactionHash
- transaction.SetModified(true)
- }
- } else {
- transaction.trunkTransactionHashMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.trunkTransactionHashMutex.RUnlock()
+ }
}
// restores the trunkTransactionHash from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseTrunkTransactionHash() ternary.Trinary {
- transaction.trunkTransactionHashMutex.Lock()
- defer transaction.trunkTransactionHashMutex.Unlock()
+ transaction.trunkTransactionHashMutex.Lock()
+ defer transaction.trunkTransactionHashMutex.Unlock()
- return transaction.parseTrunkTransactionHash()
+ return transaction.parseTrunkTransactionHash()
}
// parses the trunkTransactionHash from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseTrunkTransactionHash() ternary.Trinary {
- *transaction.trunkTransactionHash = transaction.rawTransaction.TrunkTransactionHash.ToTrinary()
+ *transaction.trunkTransactionHash = transaction.rawTransaction.TrunkTransactionHash.ToTrinary()
- return *transaction.trunkTransactionHash
+ return *transaction.trunkTransactionHash
}
// getter for the branchTransactionHash (supports concurrency)
func (transaction *Transaction) GetBranchTransactionHash() ternary.Trinary {
- transaction.branchTransactionHashMutex.RLock()
- if transaction.branchTransactionHash == nil {
- transaction.branchTransactionHashMutex.RUnlock()
- transaction.branchTransactionHashMutex.Lock()
- defer transaction.branchTransactionHashMutex.Unlock()
- if transaction.branchTransactionHash == nil {
- return transaction.parseBranchTransactionHash()
- }
- }
+ transaction.branchTransactionHashMutex.RLock()
+ if transaction.branchTransactionHash == nil {
+ transaction.branchTransactionHashMutex.RUnlock()
+ transaction.branchTransactionHashMutex.Lock()
+ defer transaction.branchTransactionHashMutex.Unlock()
+ if transaction.branchTransactionHash == nil {
+ return transaction.parseBranchTransactionHash()
+ }
+ }
- defer transaction.branchTransactionHashMutex.RUnlock()
+ defer transaction.branchTransactionHashMutex.RUnlock()
- return *transaction.branchTransactionHash
+ return *transaction.branchTransactionHash
}
// setter for the branchTransactionHash (supports concurrency)
func (transaction *Transaction) SetBranchTransactionHash(branchTransactionHash ternary.Trinary) {
- transaction.branchTransactionHashMutex.RLock()
- if transaction.branchTransactionHash == nil || *transaction.branchTransactionHash != branchTransactionHash {
- transaction.branchTransactionHashMutex.RUnlock()
- transaction.branchTransactionHashMutex.Lock()
- defer transaction.branchTransactionHashMutex.Unlock()
- if transaction.branchTransactionHash == nil || *transaction.branchTransactionHash != branchTransactionHash {
- *transaction.branchTransactionHash = branchTransactionHash
+ transaction.branchTransactionHashMutex.RLock()
+ if transaction.branchTransactionHash == nil || *transaction.branchTransactionHash != branchTransactionHash {
+ transaction.branchTransactionHashMutex.RUnlock()
+ transaction.branchTransactionHashMutex.Lock()
+ defer transaction.branchTransactionHashMutex.Unlock()
+ if transaction.branchTransactionHash == nil || *transaction.branchTransactionHash != branchTransactionHash {
+ *transaction.branchTransactionHash = branchTransactionHash
- transaction.SetModified(true)
- }
- } else {
- transaction.branchTransactionHashMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.branchTransactionHashMutex.RUnlock()
+ }
}
// restores the branchTransactionHash from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseBranchTransactionHash() ternary.Trinary {
- transaction.branchTransactionHashMutex.Lock()
- defer transaction.branchTransactionHashMutex.Unlock()
+ transaction.branchTransactionHashMutex.Lock()
+ defer transaction.branchTransactionHashMutex.Unlock()
- return transaction.parseBranchTransactionHash()
+ return transaction.parseBranchTransactionHash()
}
// parses the branchTransactionHash from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseBranchTransactionHash() ternary.Trinary {
- *transaction.branchTransactionHash = transaction.rawTransaction.BranchTransactionHash.ToTrinary()
+ *transaction.branchTransactionHash = transaction.rawTransaction.BranchTransactionHash.ToTrinary()
- return *transaction.branchTransactionHash
+ return *transaction.branchTransactionHash
}
// getter for the tag (supports concurrency)
func (transaction *Transaction) GetTag() ternary.Trinary {
- transaction.tagMutex.RLock()
- if transaction.tag == nil {
- transaction.tagMutex.RUnlock()
- transaction.tagMutex.Lock()
- defer transaction.tagMutex.Unlock()
- if transaction.tag == nil {
- return transaction.parseTag()
- }
- }
+ transaction.tagMutex.RLock()
+ if transaction.tag == nil {
+ transaction.tagMutex.RUnlock()
+ transaction.tagMutex.Lock()
+ defer transaction.tagMutex.Unlock()
+ if transaction.tag == nil {
+ return transaction.parseTag()
+ }
+ }
- defer transaction.tagMutex.RUnlock()
+ defer transaction.tagMutex.RUnlock()
- return *transaction.tag
+ return *transaction.tag
}
// setter for the tag (supports concurrency)
func (transaction *Transaction) SetTag(tag ternary.Trinary) {
- transaction.tagMutex.RLock()
- if transaction.tag == nil || *transaction.tag != tag {
- transaction.tagMutex.RUnlock()
- transaction.tagMutex.Lock()
- defer transaction.tagMutex.Unlock()
- if transaction.tag == nil || *transaction.tag != tag {
- *transaction.tag = tag
+ transaction.tagMutex.RLock()
+ if transaction.tag == nil || *transaction.tag != tag {
+ transaction.tagMutex.RUnlock()
+ transaction.tagMutex.Lock()
+ defer transaction.tagMutex.Unlock()
+ if transaction.tag == nil || *transaction.tag != tag {
+ *transaction.tag = tag
- transaction.SetModified(true)
- }
- } else {
- transaction.tagMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.tagMutex.RUnlock()
+ }
}
// restores the tag from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseTag() ternary.Trinary {
- transaction.tagMutex.Lock()
- defer transaction.tagMutex.Unlock()
+ transaction.tagMutex.Lock()
+ defer transaction.tagMutex.Unlock()
- return transaction.parseTag()
+ return transaction.parseTag()
}
// parses the tag from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseTag() ternary.Trinary {
- *transaction.tag = transaction.rawTransaction.Tag.ToTrinary()
+ *transaction.tag = transaction.rawTransaction.Tag.ToTrinary()
- return *transaction.tag
+ return *transaction.tag
}
// getter for the nonce (supports concurrency)
func (transaction *Transaction) GetNonce() ternary.Trinary {
- transaction.nonceMutex.RLock()
- if transaction.nonce == nil {
- transaction.nonceMutex.RUnlock()
- transaction.nonceMutex.Lock()
- defer transaction.nonceMutex.Unlock()
- if transaction.nonce == nil {
- return transaction.parseNonce()
- }
- }
+ transaction.nonceMutex.RLock()
+ if transaction.nonce == nil {
+ transaction.nonceMutex.RUnlock()
+ transaction.nonceMutex.Lock()
+ defer transaction.nonceMutex.Unlock()
+ if transaction.nonce == nil {
+ return transaction.parseNonce()
+ }
+ }
- defer transaction.nonceMutex.RUnlock()
+ defer transaction.nonceMutex.RUnlock()
- return *transaction.nonce
+ return *transaction.nonce
}
// setter for the nonce (supports concurrency)
func (transaction *Transaction) SetNonce(nonce ternary.Trinary) {
- transaction.nonceMutex.RLock()
- if transaction.nonce == nil || *transaction.nonce != nonce {
- transaction.nonceMutex.RUnlock()
- transaction.nonceMutex.Lock()
- defer transaction.nonceMutex.Unlock()
- if transaction.nonce == nil || *transaction.nonce != nonce {
- *transaction.nonce = nonce
+ transaction.nonceMutex.RLock()
+ if transaction.nonce == nil || *transaction.nonce != nonce {
+ transaction.nonceMutex.RUnlock()
+ transaction.nonceMutex.Lock()
+ defer transaction.nonceMutex.Unlock()
+ if transaction.nonce == nil || *transaction.nonce != nonce {
+ *transaction.nonce = nonce
- transaction.SetModified(true)
- }
- } else {
- transaction.nonceMutex.RUnlock()
- }
+ transaction.SetModified(true)
+ }
+ } else {
+ transaction.nonceMutex.RUnlock()
+ }
}
// restores the nonce from the underlying raw transaction (supports concurrency)
func (transaction *Transaction) ParseNonce() ternary.Trinary {
- transaction.nonceMutex.Lock()
- defer transaction.nonceMutex.Unlock()
+ transaction.nonceMutex.Lock()
+ defer transaction.nonceMutex.Unlock()
- return transaction.parseNonce()
+ return transaction.parseNonce()
}
// parses the nonce from the underlying raw transaction (without locking - internal usage)
func (transaction *Transaction) parseNonce() ternary.Trinary {
- *transaction.nonce = transaction.rawTransaction.Nonce.ToTrinary()
+ *transaction.nonce = transaction.rawTransaction.Nonce.ToTrinary()
- return *transaction.nonce
+ return *transaction.nonce
}
// returns true if the transaction contains unsaved changes (supports concurrency)
func (transaction *Transaction) GetModified() bool {
- transaction.modifiedMutex.RLock()
- defer transaction.modifiedMutex.RUnlock()
+ transaction.modifiedMutex.RLock()
+ defer transaction.modifiedMutex.RUnlock()
- return transaction.modified
+ return transaction.modified
}
// sets the modified flag which controls if a transaction is going to be saved (supports concurrency)
func (transaction *Transaction) SetModified(modified bool) {
- transaction.modifiedMutex.Lock()
- defer transaction.modifiedMutex.Unlock()
+ transaction.modifiedMutex.Lock()
+ defer transaction.modifiedMutex.Unlock()
- transaction.modified = modified
+ transaction.modified = modified
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -634,11 +635,11 @@ func (transaction *Transaction) SetModified(modified bool) {
// region database functions ///////////////////////////////////////////////////////////////////////////////////////////
func (transaction *Transaction) Store() errors.IdentifiableError {
- if err := transactionDatabase.Set(transaction.rawTransaction.Hash.ToBytes(), transaction.rawTransaction.Bytes); err != nil {
- return ErrDatabaseError.Derive(err, "failed to store the transaction")
- }
+ if err := transactionDatabase.Set(transaction.rawTransaction.Hash.ToBytes(), transaction.rawTransaction.Bytes); err != nil {
+ return ErrDatabaseError.Derive(err, "failed to store the transaction")
+ }
- return nil
+ return nil
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/tangle/transaction_metadata.go b/plugins/tangle/transaction_metadata.go
index ce0e7f08ddf00be51c8365aa1d4a39bf10cba000..d9cd8d6ee3dbd490f970bf77d84eddfc6ae48f49 100644
--- a/plugins/tangle/transaction_metadata.go
+++ b/plugins/tangle/transaction_metadata.go
@@ -1,40 +1,41 @@
package tangle
import (
- "github.com/iotaledger/goshimmer/packages/bitutils"
- "github.com/iotaledger/goshimmer/packages/errors"
- "github.com/iotaledger/goshimmer/packages/ternary"
- "github.com/iotaledger/goshimmer/packages/typeconversion"
- "sync"
- "time"
+ "sync"
+ "time"
+
+ "github.com/iotaledger/goshimmer/packages/bitutils"
+ "github.com/iotaledger/goshimmer/packages/errors"
+ "github.com/iotaledger/goshimmer/packages/ternary"
+ "github.com/iotaledger/goshimmer/packages/typeconversion"
)
// region type definition and constructor //////////////////////////////////////////////////////////////////////////////
type TransactionMetadata struct {
- hash ternary.Trinary
- hashMutex sync.RWMutex
- receivedTime time.Time
- receivedTimeMutex sync.RWMutex
- solid bool
- solidMutex sync.RWMutex
- liked bool
- likedMutex sync.RWMutex
- finalized bool
- finalizedMutex sync.RWMutex
- modified bool
- modifiedMutex sync.RWMutex
+ hash ternary.Trinary
+ hashMutex sync.RWMutex
+ receivedTime time.Time
+ receivedTimeMutex sync.RWMutex
+ solid bool
+ solidMutex sync.RWMutex
+ liked bool
+ likedMutex sync.RWMutex
+ finalized bool
+ finalizedMutex sync.RWMutex
+ modified bool
+ modifiedMutex sync.RWMutex
}
func NewTransactionMetadata(hash ternary.Trinary) *TransactionMetadata {
- return &TransactionMetadata{
- hash: hash,
- receivedTime: time.Now(),
- solid: false,
- liked: false,
- finalized: false,
- modified: true,
- }
+ return &TransactionMetadata{
+ hash: hash,
+ receivedTime: time.Now(),
+ solid: false,
+ liked: false,
+ finalized: false,
+ modified: true,
+ }
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -42,134 +43,134 @@ func NewTransactionMetadata(hash ternary.Trinary) *TransactionMetadata {
// region getters and setters //////////////////////////////////////////////////////////////////////////////////////////
func (metaData *TransactionMetadata) GetHash() ternary.Trinary {
- metaData.hashMutex.RLock()
- defer metaData.hashMutex.RUnlock()
+ 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
-
- metaData.SetModified(true)
- }
- } else {
- metaData.hashMutex.RUnlock()
- }
+ 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)
+ }
+ } else {
+ metaData.hashMutex.RUnlock()
+ }
}
func (metaData *TransactionMetadata) GetReceivedTime() time.Time {
- metaData.receivedTimeMutex.RLock()
- defer metaData.receivedTimeMutex.RUnlock()
+ 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)
- }
- } else {
- metaData.receivedTimeMutex.RUnlock()
- }
+ 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()
+ }
}
func (metaData *TransactionMetadata) GetSolid() bool {
- metaData.solidMutex.RLock()
- defer metaData.solidMutex.RUnlock()
+ metaData.solidMutex.RLock()
+ defer metaData.solidMutex.RUnlock()
- return metaData.solid
+ return metaData.solid
}
func (metaData *TransactionMetadata) SetSolid(solid 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)
- }
- } else {
- metaData.solidMutex.RUnlock()
- }
+ 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)
+ }
+ } else {
+ metaData.solidMutex.RUnlock()
+ }
}
func (metaData *TransactionMetadata) GetLiked() bool {
- metaData.likedMutex.RLock()
- defer metaData.likedMutex.RUnlock()
+ 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)
- }
- } else {
- metaData.likedMutex.RUnlock()
- }
+ 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()
+ }
}
func (metaData *TransactionMetadata) GetFinalized() bool {
- metaData.finalizedMutex.RLock()
- defer metaData.finalizedMutex.RUnlock()
+ 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)
- }
- } else {
- metaData.finalizedMutex.RUnlock()
- }
+ 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()
+ }
}
// returns true if the transaction contains unsaved changes (supports concurrency)
func (metadata *TransactionMetadata) GetModified() bool {
- metadata.modifiedMutex.RLock()
- defer metadata.modifiedMutex.RUnlock()
+ metadata.modifiedMutex.RLock()
+ defer metadata.modifiedMutex.RUnlock()
- return metadata.modified
+ return metadata.modified
}
// sets the modified flag which controls if a transaction is going to be saved (supports concurrency)
func (metadata *TransactionMetadata) SetModified(modified bool) {
- metadata.modifiedMutex.Lock()
- defer metadata.modifiedMutex.Unlock()
+ metadata.modifiedMutex.Lock()
+ defer metadata.modifiedMutex.Unlock()
- metadata.modified = modified
+ metadata.modified = modified
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -177,70 +178,70 @@ func (metadata *TransactionMetadata) SetModified(modified bool) {
// region marshalling functions ////////////////////////////////////////////////////////////////////////////////////////
func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError) {
- marshalledMetadata := make([]byte, MARSHALLED_TOTAL_SIZE)
-
- metadata.receivedTimeMutex.RLock()
- defer metadata.receivedTimeMutex.RUnlock()
- metadata.solidMutex.RLock()
- defer metadata.solidMutex.RUnlock()
- metadata.likedMutex.RLock()
- defer metadata.likedMutex.RUnlock()
- metadata.finalizedMutex.RLock()
- defer metadata.finalizedMutex.RUnlock()
-
- copy(marshalledMetadata[MARSHALLED_HASH_START:MARSHALLED_HASH_END], metadata.hash.CastToBytes())
-
- marshalledReceivedTime, 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)
-
- var booleanFlags bitutils.BitMask
- if metadata.solid {
- booleanFlags = booleanFlags.SetFlag(0)
- }
- if metadata.liked {
- booleanFlags = booleanFlags.SetFlag(1)
- }
- if metadata.finalized {
- booleanFlags = booleanFlags.SetFlag(2)
- }
- marshalledMetadata[MARSHALLED_FLAGS_START] = byte(booleanFlags)
-
- return marshalledMetadata, nil
+ marshalledMetadata := make([]byte, MARSHALLED_TOTAL_SIZE)
+
+ metadata.receivedTimeMutex.RLock()
+ defer metadata.receivedTimeMutex.RUnlock()
+ metadata.solidMutex.RLock()
+ defer metadata.solidMutex.RUnlock()
+ metadata.likedMutex.RLock()
+ defer metadata.likedMutex.RUnlock()
+ metadata.finalizedMutex.RLock()
+ defer metadata.finalizedMutex.RUnlock()
+
+ copy(marshalledMetadata[MARSHALLED_HASH_START:MARSHALLED_HASH_END], metadata.hash.CastToBytes())
+
+ marshalledReceivedTime, 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)
+
+ var booleanFlags bitutils.BitMask
+ if metadata.solid {
+ booleanFlags = booleanFlags.SetFlag(0)
+ }
+ if metadata.liked {
+ booleanFlags = booleanFlags.SetFlag(1)
+ }
+ if metadata.finalized {
+ booleanFlags = booleanFlags.SetFlag(2)
+ }
+ marshalledMetadata[MARSHALLED_FLAGS_START] = byte(booleanFlags)
+
+ return marshalledMetadata, nil
}
func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableError {
- metadata.hashMutex.Lock()
- defer metadata.hashMutex.Unlock()
- metadata.receivedTimeMutex.Lock()
- defer metadata.receivedTimeMutex.Unlock()
- metadata.solidMutex.Lock()
- defer metadata.solidMutex.Unlock()
- metadata.likedMutex.Lock()
- defer metadata.likedMutex.Unlock()
- metadata.finalizedMutex.Lock()
- defer metadata.finalizedMutex.Unlock()
-
- metadata.hash = ternary.Trinary(typeconversion.BytesToString(data[MARSHALLED_HASH_START:MARSHALLED_HASH_END]))
-
- if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALLED_RECEIVED_TIME_START:MARSHALLED_RECEIVED_TIME_END]); err != nil {
- return ErrUnmarshalFailed.Derive(err, "could not unmarshal the received time")
- }
-
- booleanFlags := bitutils.BitMask(data[MARSHALLED_FLAGS_START])
- if booleanFlags.HasFlag(0) {
- metadata.solid = true
- }
- if booleanFlags.HasFlag(1) {
- metadata.liked = true
- }
- if booleanFlags.HasFlag(2) {
- metadata.finalized = true
- }
-
- return nil
+ metadata.hashMutex.Lock()
+ defer metadata.hashMutex.Unlock()
+ metadata.receivedTimeMutex.Lock()
+ defer metadata.receivedTimeMutex.Unlock()
+ metadata.solidMutex.Lock()
+ defer metadata.solidMutex.Unlock()
+ metadata.likedMutex.Lock()
+ defer metadata.likedMutex.Unlock()
+ metadata.finalizedMutex.Lock()
+ defer metadata.finalizedMutex.Unlock()
+
+ metadata.hash = ternary.Trinary(typeconversion.BytesToString(data[MARSHALLED_HASH_START:MARSHALLED_HASH_END]))
+
+ if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALLED_RECEIVED_TIME_START:MARSHALLED_RECEIVED_TIME_END]); err != nil {
+ return ErrUnmarshalFailed.Derive(err, "could not unmarshal the received time")
+ }
+
+ booleanFlags := bitutils.BitMask(data[MARSHALLED_FLAGS_START])
+ if booleanFlags.HasFlag(0) {
+ metadata.solid = true
+ }
+ if booleanFlags.HasFlag(1) {
+ metadata.liked = true
+ }
+ if booleanFlags.HasFlag(2) {
+ metadata.finalized = true
+ }
+
+ return nil
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -248,20 +249,20 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE
// region database functions ///////////////////////////////////////////////////////////////////////////////////////////
func (metadata *TransactionMetadata) Store() errors.IdentifiableError {
- if metadata.GetModified() {
- marshalledMetadata, err := metadata.Marshal()
- if err != nil {
- return err
- }
+ if metadata.GetModified() {
+ marshalledMetadata, err := metadata.Marshal()
+ if err != nil {
+ return err
+ }
- if err := transactionMetadataDatabase.Set(metadata.GetHash().CastToBytes(), marshalledMetadata); err != nil {
- return ErrDatabaseError.Derive(err, "failed to store the transaction")
- }
+ if err := transactionMetadataDatabase.Set(metadata.GetHash().CastToBytes(), marshalledMetadata); err != nil {
+ return ErrDatabaseError.Derive(err, "failed to store the transaction")
+ }
- metadata.SetModified(false)
- }
+ metadata.SetModified(false)
+ }
- return nil
+ return nil
}
// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -269,19 +270,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
+ MARSHALLED_HASH_START = 0
+ MARSHALLED_RECEIVED_TIME_START = MARSHALLED_HASH_END
+ MARSHALLED_FLAGS_START = MARSHALLED_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
+ 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
- MARSHALLED_HASH_SIZE = 81
- MARSHALLED_RECEIVED_TIME_SIZE = 15
- MARSHALLED_FLAGS_SIZE = 1
+ MARSHALLED_HASH_SIZE = 81
+ MARSHALLED_RECEIVED_TIME_SIZE = 15
+ MARSHALLED_FLAGS_SIZE = 1
- MARSHALLED_TOTAL_SIZE = MARSHALLED_FLAGS_END
+ MARSHALLED_TOTAL_SIZE = MARSHALLED_FLAGS_END
)
// endregion ////////////////////////////////////////////////////////////////////////////////////////////////////////////