Skip to content
Snippets Groups Projects
Select Git revision
  • 78d174c6e44d3fa808d9fb3be70f240841858b2b
  • develop default protected
  • congestioncontrol
  • merge-v-data-collection-spammer-0.8.2
  • WIP-merge-v-data-collection-spammer-0.8.2
  • merge-v-data-collection-spammer-0.7.7
  • tmp
  • test-masterpow-fixing
  • test-masterpow
  • test-echo
  • v-data-collection
  • v-data-collection-spammer
  • tmp-dump-spam-info
  • dump-msg-info-0.3.1
  • test-dump-message-info
  • spammer-exprandom
  • extra/tutorial
  • without_tipselection
  • hacking-docker-network
  • hacking-docker-network-0.2.3
  • master
  • v0.2.3
22 results

events.go

Blame
  • user avatar
    Hans Moog authored
    2c6c6d45
    History
    events.go 3.07 KiB
    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/model/meta_transaction"
    	"github.com/iotaledger/goshimmer/packages/network"
    )
    
    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),
    }
    
    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
    }
    
    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
    }
    
    type neighborEvents struct {
    	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 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 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 dataCaller(handler interface{}, params ...interface{}) {
    	handler.(func([]byte))(params[0].([]byte))
    }
    
    func transactionCaller(handler interface{}, params ...interface{}) {
    	handler.(func(*meta_transaction.MetaTransaction))(params[0].(*meta_transaction.MetaTransaction))
    }