remoting

type AsyncCallbackResponse struct {
	common.CallbackResponse
	Opts      Options
	Cause     error
	Start     time.Time // invoke(call) start time == write start time
	ReadStart time.Time // read start time, write duration = ReadStart - Start
	Reply     interface{}
}

type Client interface {
	SetExchangeClient(client *ExchangeClient)
	// connect url
	Connect(url *common.URL) error
	// close
	Close()
	// send request to server.
	Request(request *Request, timeout time.Duration, response *PendingResponse) error
	// check if the client is still available
	IsAvailable() bool
}

type Codec interface {
	EncodeRequest(request *Request) (*bytes.Buffer, error)
	EncodeResponse(response *Response) (*bytes.Buffer, error)
	Decode(data []byte) (DecodeResult, int, error)
}

type DataListener interface {
	DataChange(event Event) bool // bool is return for interface implement is interesting
}

type DecodeResult struct {
	// IsRequest indicates whether the current request is a heartbeat request
	IsRequest bool
	Result    interface{}
}

type Event struct {
	Path    string
	Action  EventType
	Content string
}

type EventType int

type ExchangeClient struct {
	// connect server timeout
	ConnectTimeout time.Duration
	// contains filtered or unexported fields
}

type ExchangeServer struct {
	Server Server
	URL    *common.URL
}

type Options struct {
	// connect timeout
	ConnectTimeout time.Duration
}

type PendingResponse struct {
	Err error

	ReadStart time.Time
	Callback  common.AsyncCallback

	Reply interface{}
	Done  chan struct{}
	// contains filtered or unexported fields
}

type Request struct {
	ID int64
	// protocol version
	Version string
	// serial ID (ignore)
	SerialID byte
	// Data
	Data   interface{}
	TwoWay bool
	Event  bool
}

type Response struct {
	ID       int64
	Version  string
	SerialID byte
	Status   uint8
	Event    bool
	Error    error
	Result   interface{}
}

type SequenceType int64

type Server interface {
	// invoke once for connection
	Start()
	// it is for destroy
	Stop()
}