core

type AsyncResult struct {
	StartTime int64
	Done      chan *AsyncResult
	Reply     interface{}
	Error     error
}

type Attachment interface {
	GetAttachments() map[string]string
	GetAttachment(key string) string
	SetAttachment(key string, value string)
}

type Caller interface {
	WithURL
	Status
	Call(request Request) Response
	Destroyable
}

type ClusterFilter interface {
	Filter
	SetNext(nextFilter ClusterFilter)
	GetNext() ClusterFilter
	//Filter for Cluster
	Filter(haStrategy HaStrategy, loadBalance LoadBalance, request Request) Response
}

type CommandNotifyListener interface {
	Identity
	NotifyCommand(registryURL *URL, commandType int, commandInfo string)
}

type Context struct {
	ConfigFile       string
	Config           *cfg.Config
	RegistryURLs     map[string]*URL
	RefersURLs       map[string]*URL
	BasicRefers      map[string]*URL
	ServiceURLs      map[string]*URL
	BasicServiceURLs map[string]*URL
	AgentURL         *URL
	ClientURL        *URL
	ServerURL        *URL
}

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

type DefaultFilterFunc func() Filter

type DeserializableValue struct {
	Serialization Serialization
	Body          []byte
}

type Destroyable interface {
	Destroy()
}

type DiscoverCommand interface {
	SubscribeCommand(url *URL, listener CommandNotifyListener)
	UnSubscribeCommand(url *URL, listener CommandNotifyListener)
	DiscoverCommand(url *URL) string
}

type DiscoverService interface {
	Subscribe(url *URL, listener NotifyListener)

	Unsubscribe(url *URL, listener NotifyListener)

	Discover(url *URL) []*URL
}

type EndPoint interface {
	Name
	Caller
	SetSerialization(s Serialization)
	SetProxy(proxy bool)
}

type EndPointFilter interface {
	Filter
	SetNext(nextFilter EndPointFilter)
	GetNext() EndPointFilter
	//Filter for endpoint
	Filter(caller Caller, request Request) Response
}

type Exception struct {
	ErrCode int    `json:"errcode"`
	ErrMsg  string `json:"errmsg"`
	ErrType int    `json:"errtype"`
}

type Exporter interface {
	Export(server Server) error
	Unexport() error
	SetProvider(provider Provider)
	GetProvider() Provider
	WithURL
}

type ExtentionFactory interface {
	GetHa(url *URL) HaStrategy
	GetLB(url *URL) LoadBalance
	GetFilter(name string) Filter
	GetRegistry(url *URL) Registry
	GetEndPoint(url *URL) EndPoint
	GetProvider(url *URL) Provider
	GetServer(url *URL) Server
	GetMessageHandler(name string) MessageHandler
	GetSerialization(name string, id int) Serialization
	RegistExtFilter(name string, newFilter DefaultFilterFunc)
	RegistExtHa(name string, newHa NewHaFunc)
	RegistExtLb(name string, newLb NewLbFunc)
	RegistExtEndpoint(name string, newEndpoint NewEndpointFunc)
	RegistExtProvider(name string, newProvider NewProviderFunc)
	RegistExtRegistry(name string, newRegistry NewRegistryFunc)
	RegistExtServer(name string, newServer NewServerFunc)
	RegistryExtMessageHandler(name string, newMessage NewMessageHandlerFunc)
	RegistryExtSerialization(name string, id int, newSerialization NewSerializationFunc)
}

type Filter interface {
	Name
	// filter must be prototype
	NewFilter(url *URL) Filter
	HasNext() bool
	GetIndex() int
	GetType() int32
}

type FilterEndPoint struct {
	URL           *URL
	Filter        EndPointFilter
	StatusFilters []Status
	Caller        Caller
}

type HaStrategy interface {
	Name
	WithURL
	Call(request Request, loadBalance LoadBalance) Response
}

type Identity interface {
	GetIdentity() string
}

type Initializable interface {
	Initialize()
}

type LoadBalance interface {
	OnRefresh(endpoints []EndPoint)

	Select(request Request) EndPoint

	SelectArray(request Request) []EndPoint

	SetWeight(weight string)
}

type MessageHandler interface {
	Call(request Request) (res Response)
	AddProvider(p Provider) error
	RmProvider(p Provider)
	GetProvider(serviceName string) Provider
}

type MotanRequest struct {
	RequestID   uint64
	ServiceName string
	Method      string
	MethodDesc  string
	Arguments   []interface{}
	Attachment  map[string]string
	RPCContext  *RPCContext
}

type MotanResponse struct {
	RequestID   uint64
	Value       interface{}
	Exception   *Exception
	ProcessTime int64
	Attachment  map[string]string
	RPCContext  *RPCContext
}

type Name interface {
	GetName() string
}

type NewEndpointFunc func(url *URL) EndPoint

type NewHaFunc func(url *URL) HaStrategy

type NewLbFunc func(url *URL) LoadBalance

type NewMessageHandlerFunc func() MessageHandler

type NewProviderFunc func(url *URL) Provider

type NewRegistryFunc func(url *URL) Registry

type NewSerializationFunc func() Serialization

type NewServerFunc func(url *URL) Server

type NotifyListener interface {
	Identity
	Notify(registryURL *URL, urls []*URL)
}

type Provider interface {
	SetService(s interface{})
	Caller
	GetPath() string
}

type RPCContext struct {
	ExtFactory      ExtentionFactory
	OriginalMessage interface{}
	Oneway          bool
	Proxy           bool
	GzipSize        int
	SerializeNum    int
	Serialized      bool

	// for call
	AsyncCall bool
	Result    *AsyncResult
	Reply     interface{}
}

type RegisterService interface {
	Register(serverURL *URL)
	UnRegister(serverURL *URL)
	Available(serverURL *URL)
	Unavailable(serverURL *URL)
	GetRegisteredServices() []*URL
}

type Registry interface {
	Name
	WithURL
	DiscoverService
	RegisterService
	SnapshotService
}

type Request interface {
	Attachment
	GetServiceName() string // service name  e.g. request path.or interface name
	GetMethod() string
	GetMethodDesc() string
	GetArguments() []interface{}
	GetRequestID() uint64
	GetRPCContext(canCreate bool) *RPCContext
	ProcessDeserializable(toTypes []interface{}) error
}

type Response interface {
	Attachment
	GetValue() interface{}
	GetException() *Exception
	GetRequestID() uint64
	GetProcessTime() int64
	SetProcessTime(time int64)
	GetRPCContext(canCreate bool) *RPCContext
	ProcessDeserializable(toType interface{}) error
}

type Serialization interface {
	GetSerialNum() int
	Serialize(v interface{}) ([]byte, error)
	DeSerialize(b []byte, v interface{}) (interface{}, error)
	SerializeMulti(v []interface{}) ([]byte, error)
	DeSerializeMulti(b []byte, v []interface{}) ([]interface{}, error)
}

type Server interface {
	WithURL
	Name
	Destroyable
	SetMessageHandler(mh MessageHandler)
	GetMessageHandler() MessageHandler
	Open(block bool, proxy bool, handler MessageHandler, extFactory ExtentionFactory) error
}

type SetContext interface {
	SetContext(context *Context)
}

type SnapshotConf struct {
	// SnapshotInterval is the interval of creating snapshot
	SnapshotInterval time.Duration
	SnapshotDir      string
}

type SnapshotService interface {
	StartSnapshot(conf *SnapshotConf)
}

type Status interface {
	IsAvailable() bool
}

type TestEndPoint struct {
	URL *URL
}

type TestEndPointFilter struct {
	Index int
	URL   *URL
	// contains filtered or unexported fields
}

type TestFilter struct {
	Index int
	URL   *URL
	// contains filtered or unexported fields
}

type TestHaStrategy struct {
	URL *URL
}

type TestLoadBalance struct {
	Endpoints []EndPoint
}

type TestObject struct {
	Str string
}

type TestRegistry struct {
	URL *URL
}

type URL struct {
	Protocol   string
	Host       string
	Port       int
	Path       string //e.g. service name
	Group      string
	Parameters map[string]string
	// contains filtered or unexported fields
}

type WithURL interface {
	GetURL() *URL
	SetURL(url *URL)
}