protocols

type Addr interface {
	net.Addr
	IP() net.IP
}

type CircuitBreaker interface {
	Client

	Error() error
	Online() bool
	AddCallback(callback FaultDetectorCallback, key interface{})
}

type Client interface {
	Close() error
	Closed() bool
	ResetConnection() // Will open new connection next time it's required

	SetServer(server_addr string) error
	Server() Addr
	SetTimeout(timeout time.Duration)
	Protocol() Protocol
	String() string

	SendPacket(packet *Packet) error
	Send(code Code, val interface{}) error
	SendRequest(code Code, val interface{}) (*Packet, error)
	SendRequestPacket(packet *Packet) (reply *Packet, err error)
	CheckReply(reply *Packet) error
	CheckError(reply *Packet, expectedCode Code) error
}

type Code uint

type Conn interface {
	Send(packet *Packet, timeout time.Duration) error
	UnreliableSend(packet *Packet) error
	Receive(timeout time.Duration) (*Packet, error)

	RemoteAddr() Addr
	LocalAddr() Addr
	Close() error
}

type Decoder func(decoder *gob.Decoder) (interface{}, error)

type DecoderMap map[Code]Decoder

type FaultDetector interface {
	Close() error
	Check()

	// Implemented by *FaultDetectorBase
	Error() error
	Online() bool
	ErrorDetected(err error)
	ObservedServer() Addr
	AddCallback(callback FaultDetectorCallback, key interface{})
}

type FaultDetectorBase struct {
	Closed golib.StopChan
	// contains filtered or unexported fields
}

type FaultDetectorCallback func(key interface{})

type Listener interface {
	Accept() (Conn, error)
	LocalAddr() Addr
	Close() error
}

type MarshallingProvider interface {
	MarshalPacket(packet *Packet) ([]byte, error)
	UnmarshalPacket([]byte, Protocol) (*Packet, error)
}

type Packet struct {
	Code       Code
	Val        interface{}
	SourceAddr Addr
}

type Plugin interface {
	Start(server *PluginServer)
	Stop() error

	// Create and fully initialize new session. The param data is passed from
	// plugin to plugin, enabling one plugin to modify the input data for the next plugin.
	// Modify param if necessary and copy values from it. Do not store it.
	NewSession(param SessionParameter) (PluginSessionHandler, error)
}

type PluginServer struct {
	*Server

	SessionStartedCallback func(session *PluginSession)
	SessionStoppedCallback func(session *PluginSession)
	// contains filtered or unexported fields
}

type PluginSession struct {
	Base    *SessionBase
	Client  string // From the originating SessionParameter
	Server  *PluginServer
	Plugins []PluginSessionHandler
}

type PluginSessionHandler interface {
	Start(sendingSession PluginSessionHandler)
	Tasks() []golib.Task
	Cleanup() error
	String() string
}

type Protocol interface {
	Name() string
	CheckIncludesFragment(fragmentName string) error
	Transport() TransportProvider
	// contains filtered or unexported methods
}

type ProtocolFragment interface {
	Name() string
	Decoders() DecoderMap
}

type Server struct {
	Stopped bool
	// contains filtered or unexported fields
}

type ServerHandlerMap map[Code]ServerRequestHandler

type ServerProtocolFragment interface {
	ProtocolFragment
	ServerHandlers(server *Server) ServerHandlerMap
}

type ServerRequestHandler func(packet *Packet) (reply *Packet)

type ServerStopper func()

type Session interface {
	Start(base *SessionBase)
	Tasks() []golib.Task
	Cleanup()
}

type SessionBase struct {
	Wg         *sync.WaitGroup
	Stopped    golib.StopChan
	CleanupErr error
	Session    Session
}

type SessionParameter interface {
	// This string will be used as key in the sessions dictionary
	Client() string
}

type Sessions map[interface{}]*SessionBase

type TransportProvider interface {
	Resolve(addr string) (Addr, error)
	ResolveIP(ip string) (Addr, error)
	ResolveLocal(remote_addr string) (Addr, error)
	Listen(local Addr, protocol Protocol) (Listener, error)
	Dial(remote Addr, protocol Protocol) (Conn, error)
	String() string
}