hub

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

type CloseStatus struct {
	StatusCode websocket.StatusCode
	Reason     string
}

type Config[ID comparable, IM any] struct {
	// Tag is an arbitrary string used to identify this hub in log messages.
	// Useful if the application creates multiple hubs.
	// If unspecified, defaults to "hub"
	Tag string

	AcceptOptions *websocket.AcceptOptions

	// Set to non-zero value enable periodic ping from server -> client
	PingInterval time.Duration

	// Callback that returns a status code and reason based on the given
	// cause of closure.
	GetCloseStatus func(cause int, err error) CloseStatus

	SendQueue     SendQueue
	SendQueueSize int

	// Maximum number of outgoing messages that can be queued for
	// any connection. Currently this must be set; an unbounded
	// queue is not supported. This may change in the future.
	PerConnectionSendBufferSize int

	// Authentication callback; this function should use the provided
	// websocket and HTTP request to authenticate the client, returning
	// the user's credentials on success, and a non-zero close status/reason
	// on failure.
	//
	// The first argument is the server/hub context; the callback should abort
	// if this context is cancelled before completion. In this situation it
	// is not necessary to return a meaningful close status as one will be
	// selected by the hub.
	//
	// If the HTTP request's context is cancelled it is the responsibility of
	// the callback to provide a meaningful close status.
	Authenticate func(context.Context, *websocket.Conn, *http.Request) (ID, any, CloseStatus)

	// Callback to determine if a new, authenticated connection should be
	// accepted for registration. Use this function to implement connection
	// policies for multiple instances of a single client ID, based on
	// inspection of the provided Roster.
	//
	// First return value is a list of pre-existing connections
	// that should be cancelled - this can be used, for example, to terminate
	// any existing connections with a matching client ID.
	//
	// Second return value indicates whether conn should be registered with
	// the server; nil indicates that the connection is accepted, non-nil
	// that it is rejected. The default close status generator uses the
	// error's string representation as the socket close reason.
	//
	// This function is called from the server's main loop so should complete
	// quickly. The provided Roster instance is valid for this invocation only
	// and must not be retained for use elsewhere as it is not threadsafe.
	Accept func(conn *Conn[ID, IM], roster *Roster[ID, IM]) ([]*Conn[ID, IM], error)

	// Decode an incoming message into an instance of IM
	ReadIncomingMessage func(websocket.MessageType, io.Reader) (IM, error)

	// Get the websocket message type for the outgoing message
	OutgoingMessageType func(any) (websocket.MessageType, error)

	// Write an outgoing message
	WriteOutgoingMessage func(io.Writer, any) error

	// Logger - defaults to log.Println(). Use hub.NullLogger to silence output.
	Logger func(...any)
}

type Conn[ID comparable, IM any] struct {
	// contains filtered or unexported fields
}

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

type Hub[ID comparable, IM any] struct {
	// contains filtered or unexported fields
}

type IncomingMessage[ID comparable, IM any] struct {
	ReceivedAt time.Time     // Time message was received
	Conn       *Conn[ID, IM] // Connection from which message was received
	Msg        IM            // Decoded message
}

type Roster[ID comparable, IM any] struct {
	// contains filtered or unexported fields
}

type RunnableSendQueue interface {
	SendQueue
	Run(ctx context.Context)
}

type SendQueue interface {
	Envelopes() <-chan Envelope
	Put(env Envelope) bool
}