event

type AppHandlers struct {
	EventSource chan Event
	EventSink   chan targettedEvent
	// contains filtered or unexported fields
}

type CtrlMsg struct {
	// SerialNumber specifies an id unique for the message
	// sender. Together with the sender address it creates
	// an unique identifier for the message.
	SerialNumber uint64
	// Type specifies the type of the message and should be
	// one of Ctrl... constants defined in this file.
	Type CtrlMsgType
	// AppPort is the application protocol port of the CtrlMsg sender.
	// It is used to calculate the peer unique identifier when required.
	AppPort uint16
	// Addr represents a node in a form of the address and port.
	// This field is used in CtrlConnectTo message to indicate where
	// the receiver node should connect to.
	Addr netip.AddrPort
	// EventType indicates what event the message refers to.
	// It is used in CtrlSubscribe and CtrlUnsubscribe messages.
	EventType EventType
}

type CtrlMsgType = int

type DefaultLoggerFactory struct {
}

type Event struct {
	Type    EventType
	AppData []byte
}

type EventHandler = func(e Event, publisher Publisher)

type EventType = int

type IdCtrlMsg struct {
	Source   net.Addr
	SourceId uint32
	Msg      CtrlMsg
}

type Listener interface {
	// Returns a channel that the events from
	// other nodes are passed to
	EventSink() chan Event
	// Runs the network listener and starts
	// passing events to the EventSink()
	Run()
	// Stops the network listener
	Stop()
}

type LoggerFactory interface {
	NewLogger() LoggerImpl
}

type LoggerImpl = *zap.SugaredLogger

type PeerId = uint32

type Publisher interface {
	// ToAll publishes the event to the network. It guarantees
	// that the order in which the events are published is the
	// preserved upon delivery.
	ToAll(e Event)
	// ToSelf publishes the event only to the node that
	// executes the event where the Publisher is used.
	ToSelf(e Event)
	// BackgroundTask asynchronously executes the task
	// and publishes the notification event to self when
	// the task finishes. The task can be any function that
	// accepts no parameters and returns no value.
	//
	// The task is ran outside the event handlers path of
	// execution and is fully asynchronous. If the task needs
	// to access any variable that the event handler accesses,
	// this action must be protected with a mutual exclusion
	// mechanism.
	BackgroundTask(finishNotification Event, task func())
}

type Sender interface {
	// EventSource returns the channel from which the sender
	// picks up events to publish
	EventSource() chan targettedEvent
	// Run activates a background worker that receives events
	// from the channel accesed by Sender.EventSource()
	// and sends them to the subscribed nodes.
	Run()
	// Stop halts the background worker and closes all
	// the established connections
	Stop()
	// Connect establishes a connection to other event system node
	// (specifically to the other node's Listener)
	Connect(addr string) error
	// RegisterSub registers a subscription for the
	// specified address. The cluster.Node structure uses the
	// register/unregister functionality to optimise the
	// number of messages passed through the network.
	RegisterSub(t EventType, addr net.Addr)
	// UnregisterSub removes the subscription on the
	// specified event. After unregistering a subscription
	// the node at addr will no longer get notified about
	// the event with type t.
	UnregisterSub(t EventType, addr net.Addr)
	GetPeers() []net.Addr
}

type SerializedConn struct {
	io.ReadWriteCloser
	// contains filtered or unexported fields
}

type Serializer struct {
	// contains filtered or unexported fields
}

type TcpListener struct {
	// contains filtered or unexported fields
}

type TcpSender struct {
	// contains filtered or unexported fields
}