gorpc

type Acceptor struct {
	gslogger.Log // mixin log APIs
	// contains filtered or unexported fields
}

type CallSite struct {
	ID    uint32
	Trace uint64
}

type Channel interface {
	Post(call *Request) error
	Send(call *Request) (Future, error)
}

type Client interface {
	Close()
	Pipeline() Pipeline
}

type ClientBuilder struct {
	gslogger.Log // Mixin Log APIs
	// contains filtered or unexported fields
}

type ClosableChannel interface {
	CloseChannel()
}

type ConnectF func() (io.ReadWriteCloser, error)

type Context interface {
	// current handler name
	Name() string
	// Pipeline current channel pipeline
	Pipeline() Pipeline
	// OnActive
	FireActive()
	// Send create new send pipeline message
	Send(message *Message)
	// Close close current pipeline
	Close()
}

type Dispatcher interface {
	Dispatch(call *Request) (callReturn *Response, err error)
	ID() uint16
	String() string
}

type Future interface {
	Wait() (callReturn *Response, err error)
}

type Handler interface {
	// Register when handler had been add into one pipeline,
	// system call this function notify handler
	Register(context Context) error
	// Unregister sysm call this function when handler had been removed from
	// pipeline,you can get this pipeline object by Context#Pipeline function
	Unregister(context Context)
	// Active system call this function when pipline state trans to active
	Active(context Context) error
	// Inactive system call this function when pipeline state trans to inactive
	Inactive(context Context)
	// MessageReceived
	MessageReceived(context Context, message *Message) (*Message, error)
	// MessageSending
	MessageSending(context Context, message *Message) (*Message, error)
	// Panic handle async pipline method error
	Panic(context Context, err error)
}

type HandlerF func() Handler

type MessageChannel interface {
	SendMessage(message *Message) error
}

type Pipeline interface {
	String() string
	// Name pipeline name
	Name() string
	// Close close pipeline
	Close()
	// Active trans pipeline state to active state
	Active() error
	// Inactive trans pipeline state to inactive state
	Inactive()
	// Received .
	Received(message *Message) error
	// TimeWheel invoke handle after timeout
	TimeWheel() *timer.Wheel
	// After invoke handle after timeout
	After(timeout time.Duration, f func()) *timer.Timer
	// Channel implement channel interface
	Channel
	// SendMessage .
	SendMessage(message *Message) error
	// AddService add new service
	AddService(dispatcher Dispatcher)
	// RemoveService remove service
	RemoveService(dispatcher Dispatcher)
	// Get Handler by name
	Handler(name string) (Handler, bool)
	// Get Sending message
	Sending() (*Message, error)
}

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

type Profile struct {
	Timestamp time.Time // profile timestamp
	Pipelines int32     // register pipelines
	Actives   int32     // actived pipelines
	Received  uint64    // received messages
	Send      uint64    // send messages
	Errors    uint64    // panic times
}

type Promise interface {
	Wait() (callReturn *Response, err error)
	Notify(callReturn *Response, err error)
	Timeout()
	Cancel()
}

type Reader interface {
	io.ByteReader
	io.Reader
}

type Registry interface {
	// Update update the registry
	Update(items map[string]uint16)
	// ServiceName get service name by service id
	ServiceName(id uint16) string
	// ServiceID get service id by service name
	ServiceID(name string) uint16
	// Load load registry from io.Reader
	Load(r io.Reader, name string)
}

type Send func(call *Request) (Future, error)

type SharedHandler interface {
	// Lock lock this handler
	HandlerLock()
	// Unlock unlock this handler
	HandlerUnlock()
}

type Sink interface {
	Channel
	AddService(dispatcher Dispatcher)
	RemoveService(dispatcher Dispatcher)
	ClearServices()
	MessageReceived(message *Message) error
}

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

type Wait func() (callReturn *Response, err error)

type Writer interface {
	io.ByteWriter
	io.Writer
}