websocket

type Client struct {

	// Headers The headers field can be used to pass custom headers during
	// handshake with server.
	// Any primary header fields ("host", "upgrade", "connection",
	// "sec-websocket-key", "sec-websocket-version") will be deleted
	// before handshake.
	Headers http.Header

	// TLSConfig define custom TLS configuration when connecting to secure
	// WebSocket server.
	// The scheme of Endpoint must be "https" or "wss", or it will be
	// resetting back to nil.
	TLSConfig *tls.Config

	// HandleBin callback that will be called after receiving data
	// frame binary from server.
	HandleBin ClientHandler

	// HandleQuit function that will be called when client connection is
	// closed.
	// Default is nil.
	HandleQuit func()

	// HandleRsvControl function that will be called when client received
	// reserved control frame (opcode 0xB-F) from server.
	// Default handler is nil.
	HandleRsvControl ClientHandler

	// HandleText callback that will be called after receiving data
	// frame text from server.
	HandleText ClientHandler

	// Endpoint the address of remote server.
	// The endpoint use the following format,
	//
	//	ws-URI = "ws://" host [ ":" port ] path [ "?" query ]
	//	wss-URI = "wss://" host [ ":" port ] path [ "?" query ]
	//
	// The port component is OPTIONAL, default is 80 for "ws" scheme, and
	// 443 for "wss" scheme.
	Endpoint string

	// The interval where PING control frame will be send to server.
	// The minimum and default value is 10 seconds.
	PingInterval time.Duration

	sync.Mutex
	// contains filtered or unexported fields
}

type ClientHandler func(cl *Client, frame *Frame) (err error)

type ClientManager struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type CloseCode uint16

type ContextKey byte

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

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

type HandlerAuthFn func(req *Handshake) (ctx context.Context, err error)

type HandlerClientFn func(ctx context.Context, conn int)

type HandlerFrameFn func(conn int, frame *Frame)

type HandlerPayloadFn func(conn int, payload []byte)

type HandlerStatusFn func() (contentType string, data []byte)

type Handshake struct {
	URL        *url.URL
	Header     http.Header
	Host       []byte
	Key        []byte
	Extensions []byte
	Protocol   []byte
	// contains filtered or unexported fields
}

type Opcode byte

type Request struct {
	// Query is Target query.
	Query url.Values `json:"-"`

	// Params are parameters as key-value in Target path that has been
	// parsed.
	Params targetParam `json:"-"`

	// Method is equal to HTTP method.
	Method string `json:"method"`

	// Target is equal to HTTP request RequestURI, e.g. "/path?query".
	Target string `json:"target"`

	// Body is equal to HTTP body on POST/PUT.
	Body string `json:"body"`

	// Path is Target without query.
	Path string `json:"-"`

	//
	// Id is unique between request to differentiate multiple request
	// since each request is asynchronous.  Client can use incremental
	// value or, the recommended way, using Unix timestamp with
	// millisecond.
	//
	ID uint64 `json:"id"`

	// Conn is the client connection, where the request come from.
	Conn int
}

type Response struct {
	Message string `json:"message"`
	Body    string `json:"body"`
	ID      uint64 `json:"id"`
	Code    int32  `json:"code"`
}

type RouteHandler func(ctx context.Context, req *Request) (res Response)

type Server struct {
	Clients *ClientManager

	// Options for server, set by calling NewServer.
	// This field is exported only for reference, for example logging in
	// the Options when server started.
	// Modifying the value of Options after server has been started may
	// cause undefined effects.
	Options *ServerOptions
	// contains filtered or unexported fields
}

type ServerOptions struct {
	// HandleAuth callback that will be called when receiving
	// client handshake.
	HandleAuth HandlerAuthFn

	// HandleClientAdd callback that will called after client handshake
	// and, if HandleAuth is defined, after client is authenticated.
	HandleClientAdd HandlerClientFn

	// HandleClientRemove callback that will be called before client
	// connection being removed and closed by server.
	HandleClientRemove HandlerClientFn

	// HandleRsvControl callback that will be called when server received
	// reserved control frame (opcode 0xB-F) from client.
	// Default handle is nil.
	HandleRsvControl HandlerFrameFn

	// HandleText callback that will be called after receiving data
	// frame(s) text from client.
	// Default handle parse the payload into Request and pass it to
	// registered routes.
	HandleText HandlerPayloadFn

	// HandleBin callback that will be called after receiving data
	// frame(s) binary from client.
	HandleBin HandlerPayloadFn

	// HandleStatus function that will be called when server receive
	// request for status as defined in ServerOptions.StatusPath.
	HandleStatus HandlerStatusFn

	// Address to listen for WebSocket connection.
	// Default to ":80".
	Address string

	// ConnectPath define the HTTP path where WebSocket connection
	// handshake will be processed.
	// Default to "/".
	ConnectPath string

	// StatusPath define a HTTP path to check for server status.
	// Default to ConnectPath +"/status" if its empty.
	// The StatusPath is handled by HandleStatus callback in the server.
	StatusPath string

	// ReadWriteTimeout define the maximum duration the server wait for
	// receiving/sending packet from/to client before considering the
	// connection as broken.
	// Default to 30 seconds.
	ReadWriteTimeout time.Duration
	// contains filtered or unexported fields
}