orbit

type CallFunc func(ctx context.Context, s *Session, args *Data) (ret interface{}, err error)

type Config struct {
	Log   *zerolog.Logger
	Codec codec.Codec

	PrintPanicStackTraces bool
	SendErrToCaller       bool

	// InitTimeout specifies the connection initialization timeout.
	InitTimeout time.Duration

	// CallTimeout specifies the default timeout for any Call.
	// This value can be overridden per call in the .orbit file.
	// A value < 0 means no timeout.
	// A value of 0 will take the default call timeout value.
	CallTimeout time.Duration
}

type Conn interface {
	closer.Closer

	// AcceptStream returns the next stream opened by the peer, blocking until one is available.
	AcceptStream(context.Context) (Stream, error)

	// OpenStream opens a new bidirectional stream.
	// There is no signaling to the peer about new streams:
	// The peer can only accept the stream after data has been sent on the stream.
	OpenStream(context.Context) (Stream, error)

	// LocalAddr returns the local address.
	LocalAddr() net.Addr

	// RemoteAddr returns the address of the peer.
	RemoteAddr() net.Addr
}

type Data struct {

	// Raw is the byte representation of the encoded data.
	Raw []byte
	// contains filtered or unexported fields
}

type Error interface {
	// Embeds the standard go error interface.
	error

	// Msg returns a textual explanation of the error and should
	// NOT contain sensitive information about the application.
	Msg() string

	// Code returns an integer that can give a hint about the
	// type of error that occurred.
	Code() int
}

type ErrorCode struct {
	// The code is used to identify common errors.
	Code int
	// contains filtered or unexported fields
}

type Hook interface {

	// Called after the session has established a first stream and
	// performed the handshake.
	// If the returned err != nil, the new session is closed immediately.
	OnNewSession(s *Session, stream Stream) error

	// todo:
	// If the returned err != nil, the call is aborted.
	OnCall(s *Session, service, id string) error
	// todo:
	// If err == nil, then the call completed successfully.
	OnCallCompleted(s *Session, service, id string, err error)

	// If the returned err != nil, the stream is aborted.
	OnNewStream(s *Session, service, id string) error
}

type Listener interface {
	closer.Closer

	// Accept waits for and returns the next connection to the listener.
	Accept() (Conn, error)

	// Addr returns the listener's network address.
	Addr() net.Addr
}

type Server struct {
	closer.Closer
	// contains filtered or unexported fields
}

type ServerConfig struct {
	*Config

	// The number of goroutines that handle incoming connections on the server.
	// If not set, defaults to defaultNewConnNumberWorkers.
	NewConnNumberWorkers int

	// The size of the channel on which new connections are passed to the
	// server workers.
	// Should not be less than NewConnNumberWorkers.
	// If not set, defaults to defaultNewConnChanSize.
	NewConnChanSize int

	// The size of the channel on which new server sessions are passed into,
	// so that a user of this package can read them from it.
	// Should not be less than NewConnNumberWorkers.
	// If not set, defaults to defaultNewSessionChanSize.
	NewSessionChanSize int
}

type ServerHandler interface {
	SessionHandler

	InitServer(s *Server)
}

type Session struct {
	closer.Closer
	// contains filtered or unexported fields
}

type SessionHandler interface {
	InitSession(s *Session)
}

type Stream interface {
	net.Conn

	// IsClosed returns true, if the stream has been closed locally or by the remote peer.
	IsClosed() bool
}

type StreamFunc func(s *Session, stream net.Conn)