sockets

type Client ¶

type Client interface {
	JoinChannel(host, channelID string, headers http.Header, params map[string]string) error
	LeaveChannel(channelID string, headers http.Header)
	RegisterListener(msgType string, fn HandlerFunc)
}

Client can be used to implement a client which will send and listen to messages on channels.

type ClientErrorHandlerFunc ¶

type ClientErrorHandlerFunc func(err error, msg *Message)

ClientErrorHandlerFunc is raised when the client itself returns an error when processing a message. It can be logged, retried etc.

type ClientErrorMsgHandlerFunc ¶

type ClientErrorMsgHandlerFunc func(err ErrorMessage)

ClientErrorMsgHandlerFunc is triggered when a server returns an error message in response to a client message. It will contain the detail of the error and the client can decide to log, re-send or do something else.

type ClientPublisher ¶

type ClientPublisher interface {
	Publish(req Request)
}

ClientPublisher can be implemented to allow a client to send messages to a connected server and channel.

type ErrorDetail ¶

type ErrorDetail struct {
	Title       string
	Description string
	ErrCode     string
}

ErrorDetail is returned as the message body in the event of an error.

type ErrorMessage ¶

type ErrorMessage struct {
	CorrelationID string          `json:"correlationId"`
	AppID         string          `json:"appId"`
	UserID        string          `json:"userId"`
	Key           string          `json:"type"`
	OriginKey     string          `json:"originType"`
	OriginBody    json.RawMessage `json:"originBody"`
	ErrorBody     json.RawMessage `json:"errorBody"`
	ChannelID     string          `json:"channelId"`
	ClientID      string          `json:"clientId"`
	Headers       http.Header     `json:"headers"`
}

ErrorMessage is a message type returned on error, it contains a copy of the original key and body but will have a key of "error" allowing this to be checked for in error handlers. ErrorBody is optional but if supplied can be marhsaled to a struct using Bind() to get the detail of the error.

func (e *ErrorMessage) Bind(v interface{}) error

func (e *ErrorMessage) BindOriginBody(v interface{}) error

type HandlerFunc ¶

type HandlerFunc func(ctx context.Context, msg *Message) (*Message, error)

HandlerFunc defines listeners on both the server and clients. When registered these will be triggered when a message is received matching the key.

type Message ¶

type Message struct {
	CorrelationID string
	AppID         string
	UserID        string
	Expiration    *time.Time
	Body          json.RawMessage

	Headers  http.Header
	ClientID string
	// contains filtered or unexported fields
}

Message is the underlying message type used by the protocol to transmit metadata and the message bodies.

func NewMessage(msgType, clientID, channelID string) *Message

func (m Message) Bind(v interface{}) error

func (m *Message) ChannelID() string

func (m *Message) ID() string

func (m *Message) Key() string

func (m *Message) MarshalJSON() ([]byte, error)

func (m *Message) NewFrom(key string) *Message

func (m *Message) NoContent() (*Message, error)

func (m *Message) Timestamp() time.Time

func (m *Message) ToError(err interface{}) *ErrorMessage

func (m *Message) UnmarshalJSON(bb []byte) error

func (m *Message) WithBody(v interface{}) error

type MiddlewareFunc ¶

type MiddlewareFunc func(next HandlerFunc) HandlerFunc

MiddlewareFunc defines a common middleware signature that can be used to create middleware that executes before the HandlerFunc.

type Publisher ¶

type Publisher interface {
	Publish(req Request) error
}

Publisher is used by clients to send messages to a server.

type Request ¶

type Request struct {
	ChannelID  string
	MessageKey string
	Body       interface{}
	Headers    http.Header
}

Request is used to send a message to a channel with a specific key.

type ServerChannelBroadcaster ¶

type ServerChannelBroadcaster interface {
	// Broadcast will send a message to all connected peers on a channel.
	// To handle these messages you should register a handler using server.RegisterChannelHandler.
	Broadcast(channelID string, msg *Message)
	// BroadcastAwait will broadcast a message to all peers but handle only the first one and return
	// it to the caller. This is a blocking call.
	BroadcastAwait(ctx context.Context, channelID string, msg *Message) (*Message, error)
}

ServerChannelBroadcaster is used to send a message from a server to all clients connected to a channel.

type ServerDirectBroadcaster ¶

type ServerDirectBroadcaster interface {
	BroadcastDirect(clientID string, msg *Message)
}

ServerDirectBroadcaster is used to send a message from a server directly to a client.

type ServerErrorHandlerFunc ¶

type ServerErrorHandlerFunc func(msg *Message, e error) *ErrorMessage

ServerErrorHandlerFunc defines an error handler for a server.

The message can be handled, logged, and returned to clients.