netx

type AddrRemovedInfo struct {
	Id   string
	Addr string
}

type AddressProxy struct {
	eventx.EventDispatcher
	// contains filtered or unexported fields
}

type ConnNilError string

type EmptyAddrError string

type FuncPackHandler func(data []byte, senderAddress string, other interface{}) (catch bool)

type HttpServer struct {
	Network  string
	ServeMux *http.ServeMux
	Server   *http.Server
}

type IAddressProxy interface {
	eventx.IEventDispatcher
	// GetId
	// 能过地址找id
	GetId(address string) (id string, ok bool)
	// GetAddress
	// 能过id找地址
	GetAddress(id string) (address string, ok bool)
	// MapIdAddress
	// 把id和地址加入映射表
	MapIdAddress(id string, address string)
	// RemoveById
	// 移除id相关映射
	RemoveById(id string)
	// RemoveByAddress
	// 移除地址相关映射
	RemoveByAddress(address string)
	// Reset
	// 重置
	Reset()
}

type IAddressProxyGetter interface {
	GetAddressProxy() IAddressProxy
}

type IAddressProxySetter interface {
	SetAddressProxy(proxy IAddressProxy)
}

type IClient interface {
	// IsOpening
	// 连接是否打开中
	IsOpening() bool
	// OpenClient
	// 打开
	OpenClient(params SockParams) error
	// CloseClient
	// 关闭
	CloseClient() error
}

type IConnReadWriterAdapter interface {
	IRemoteAddress
	// contains filtered or unexported methods
}

type IConnReaderAdapter interface {
	IRemoteAddress
	// contains filtered or unexported methods
}

type IConnWriterAdapter interface {
	IRemoteAddress
	// contains filtered or unexported methods
}

type IHttpServer interface {
	// Running
	// 启动中
	Running() bool
	// StartServer
	// 启动Http服务
	StartServer(addr string) error
	// StopServer
	// 停止Http服务
	StopServer() error
	// MapHandle
	// 映射请求响应处理器
	MapHandle(pattern string, handler http.Handler)
	// MapFunc
	// 映射请求响应函数
	MapFunc(pattern string, f func(w http.ResponseWriter, r *http.Request))
	// ClearMaps
	// 清除映射
	ClearMaps()
}

type IPackHandlerContainer interface {
	// Size Handler size
	// 处理函数数量
	Size() int
	// FirstHandler
	// 由第一个处理
	FirstHandler(first func(handler FuncPackHandler) bool)
	// LastHandler
	// 由最后一个处理
	LastHandler(last func(handler FuncPackHandler) bool)
	// ForEachHandler
	// 依顺序遍历处理
	// each返回true，则中断遍历
	ForEachHandler(each func(handler FuncPackHandler) bool)

	// AppendPackHandler
	// 追加消息处理函数
	AppendPackHandler(handler FuncPackHandler) error
	// ClearHandler
	// 清除消息处理函数
	ClearHandler(handler FuncPackHandler) error
	// ClearHandlers
	// 清除全部消息处理函数
	ClearHandlers() error
	// SetPackHandlers
	// 设置消息处理函数列表
	SetPackHandlers(handlers []FuncPackHandler) error
}

type IPackHandlerContainerGetter interface {
	GetPackHandlerContainer() IPackHandlerContainer
}

type IPackHandlerContainerSetter interface {
	SetPackHandlerContainer(packHandlerContainer IPackHandlerContainer)
}

type IPackReceiver interface {
	logx.ILoggerSupport
	// contains filtered or unexported methods
}

type IPackReceiverGetter interface {
	GetPackReceiver() IPackReceiver
}

type IPackReceiverSetter interface {
	SetPackReceiver(receiver IPackReceiver)
}

type IPackSendReceiver interface {
	logx.ILoggerSupport
	// contains filtered or unexported methods
}

type IPackSender interface {
	logx.ILoggerSupport
	// contains filtered or unexported methods
}

type IPackSenderGetter interface {
	GetPackSender() IPackSender
}

type IPackSenderSetter interface {
	SetPackSender(sender IPackSender)
}

type IRPCClient interface {
	// Dial
	// 连接远程RPC服务
	Dial(address string) error
	// IsConnected
	// RPC是否处理连接状态
	IsConnected() bool
	// Call
	// 调用RPC服务
	Call(serviceMethod string, args interface{}, reply interface{}) error
	// Close
	// 关闭远程RPC服务
	Close()
}

type IRPCServer interface {
	// Register
	// publishes in the server the set of methods of the receiver value that satisfy the following conditions:
	Register(rcvr interface{}) error
	// RegisterName
	// is like Register but uses the provided name for the type instead of the receiver's concrete type.
	RegisterName(name string, rcvr interface{}) error
	// StartServer
	// 启动RPC服务,会阻塞
	StartServer(addr string)
	// StopServer
	// 停止RPC服务
	StopServer()
}

type IRemoteAddress interface {
	RemoteAddress() string
}

type IServer interface {
	// IsRunning
	// 服务是否启动中
	IsRunning() bool
	// StartServer
	// 启动服务，会阻塞
	StartServer(params SockParams) error
	// StopServer
	// 停止服务，会阻塞
	StopServer() error
}

type IServerConn interface {
	// ClientAddress
	// 客户端连接地址
	ClientAddress() string
	// SendBytes
	// 发送二进制数据, 不会重新打包
	SendBytes(bytes []byte) error
	// SendPack
	// 发送二进制消息包(把数据打包，补充长度信息)
	SendPack(data []byte) error
	// CloseConn
	// 关闭连接
	CloseConn() error
}

type IServerConnSet interface {
	// SetMaxConn
	// 设置最大连接数量
	SetMaxConn(max int)
	// Connections
	// 连接数
	Connections() int
	// CloseConnection
	// 关闭指定连接
	CloseConnection(address string) (err error, ok bool)
	// FindConnection
	// 查找连接
	FindConnection(address string) (conn IServerConn, ok bool)
}

type ISockClient interface {
	ISockName
	IClient
	IPackReceiver
	ISockSender

	LocalAddress() string
}

type ISockClientGetter interface {
	GetClient() ISockClient
}

type ISockClientSetter interface {
	SetClient(client ISockClient)
}

type ISockConn interface {
	// Close
	// 关闭
	Close() error
	// LocalAddr
	// 本地连接地址
	LocalAddr() net.Addr
	// RemoteAddr
	// 远程连接地址
	RemoteAddr() net.Addr
}

type ISockEventClient interface {
	eventx.IEventDispatcher
	ISockClient
}

type ISockEventServer interface {
	eventx.IEventDispatcher
	ISockServer
}

type ISockName interface {
	// SetName
	// 设置标识名称
	SetName(name string)
	// GetName
	// 获取标识名称
	GetName() string
}

type ISockSender interface {
	// SendBytesTo
	// 发送二进制数据, 不会重新打包
	SendBytesTo(bytes []byte, rAddress ...string) error
	// SendPackTo
	// 发送二进制消息包(把数据打包，补充长度信息)
	SendPackTo(data []byte, rAddress ...string) error
}

type ISockSenderGetter interface {
	GetSockSender() ISockSender
}

type ISockSenderSetter interface {
	SetSockSender(sockSender ISockSender)
}

type ISockServer interface {
	ISockName
	IServer
	IServerConnSet

	ISockSender
	IPackHandlerContainerSetter
	IPackHandlerContainerGetter

	logx.ILoggerSupport
}

type ISockServerGetter interface {
	GetSockServer() ISockServer
}

type ISockServerSetter interface {
	SetSockServer(server ISockServer)
}

type NoAddrError string

type PackHandlerContainer struct {
	RWMutex sync.RWMutex
	// contains filtered or unexported fields
}

type RPCClient struct {
	Network string
	// contains filtered or unexported fields
}

type RPCServer struct {
	logx.LoggerSupport

	Network  string
	Server   *rpc.Server
	Listener net.Listener
}

type ReadWriterAdapter struct {
	Reader     io.Reader
	Writer     io.Writer
	RemoteAddr net.Addr
}

type ReaderUnSupportError string

type ReqCallBack func(res *http.Response, body *[]byte)

type SockClientBase struct {
	Name     string
	Network  SockNetwork
	ClientMu sync.RWMutex
	Opening  bool

	LocalAddr string
	Conn      ISockConn

	PackProxy IPackSendReceiver
	Logger    logx.ILogger

	PackHandler IPackHandlerContainer
}

type SockNetwork string

type SockParams struct {
	Network SockNetwork
	// E.g
	// tcp,udp,quic:	127.0.0.1:9999
	LocalAddress string
	// E.g
	// websocket:	ws://127.0.0.1:9999
	// tcp,udp,quic:	127.0.0.1:9999
	RemoteAddress string

	// E.g: /,/echo
	WSPattern string
	// E.g: http://127.0.0.1/，最后的"/"必须
	WSOrigin string
	// E.g: ""
	WSProtocol string
}

type SockServerBase struct {
	Name     string
	Network  SockNetwork
	ServerMu sync.RWMutex
	Running  bool

	Logger logx.ILogger

	PackHandlerContainer IPackHandlerContainer
}