stompserver

type ApplicationRequestHandlerFunction func(destination string, message []byte, connectionId string)

type AuthInfo struct {
	Username string
	Id       int
	Roles    []string
}

type ConnEvent struct {
	ConnId string
	// contains filtered or unexported fields
}

type Connection struct {
	Source string
}

type FrameHandlerFunc func(conn StompConn, f *frame.Frame) error

type HTTPHandlerRegistrar interface {
	HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))
}

type IPBlockingChecker interface {
	IsIPBlocked(ip string) (bool, string) // returns blocked status and reason
	TrackConnection(ip string, sessionID string)
	TrackDisconnection(ip string, sessionID string)
	ExtractRealIP(remoteAddr string, headers map[string][]string) string
}

type MiddlewareFunc func(FrameHandlerFunc) FrameHandlerFunc

type MiddlewareRegistry map[string][]MiddlewareFunc

type RawConnResult struct {
	Conn RawConnection
	Err  error
}

type RawConnection interface {
	// ReadFrame Reads a single frame object
	ReadFrame() (*frame.Frame, error)
	// WriteFrame Sends a single frame object
	WriteFrame(frame *frame.Frame) error
	// SetReadDeadline Set deadline for reading frames
	SetReadDeadline(t time.Time)
	// GetRemoteAddr Returns the remote address of the connection
	GetRemoteAddr() string
	// Close the connection
	Close() error
}

type RawConnectionListener interface {
	// Accept Blocks until a new RawConnection is established.
	Accept() (RawConnection, error)
	// Close Stops the connection listener.
	Close() error

	// GetConnectionOpenChannel will return a channel that emits connection results when clients connect.
	GetConnectionOpenChannel() chan *Connection

	// GetConnectionCloseChannel will return a channel the emits connection result when clients disconnect.
	GetConnectionCloseChannel() chan *Connection
}

type StompConfig interface {
	HeartBeat() int64
	AppDestinationPrefix() []string
	IsAppRequestDestination(destination string) bool
	Logger() *slog.Logger
	SetLogger(logger *slog.Logger)
	GetMiddlewareRegistry() MiddlewareRegistry
	SetMiddlewareRegistry(registry MiddlewareRegistry)
}

type StompConn interface {
	// Return unique connection Id string
	GetId() string
	// Return IP address of the connection
	GetIPAddress() string
	SendFrameToSubscription(f *frame.Frame, sub *Subscription)
	Close()
	GetSubscriptions() map[string]*Subscription
	AddSubscription(id string, destination string) (*Subscription, bool)
	RemoveSubscription(id string) (*Subscription, bool)
	GetEventsChannel() chan *ConnEvent
	SendError(err error)
	SendMessage(msg string)
}

type StompServer interface {
	// starts the server
	Start()
	// stops the server
	Stop()
	// Ready is closed when the server is about to consume accepted connections.
	Ready() <-chan struct{}
	// sends a message to a given stomp topic destination
	SendMessage(destination string, messageBody []byte)
	// sends a message to a single connection client
	SendMessageToClient(connectionId string, destination string, messageBody []byte)
	// closes all connections from a specific IP address with a custom error message
	CloseConnectionsByIP(ip string, errorMessage string)
	// sets the IP blocking checker that gets called before allowing connections
	SetIPBlockingChecker(checker IPBlockingChecker)
	// registers a callback for stomp subscribe events
	OnSubscribeEvent(callback SubscribeHandlerFunction)
	// registers a callback for stomp unsubscribe events
	OnUnsubscribeEvent(callback UnsubscribeHandlerFunction)
	// registers a callback for application requests
	OnApplicationRequest(callback ApplicationRequestHandlerFunction)
	// SetConnectionEventCallback is used to set up a callback when certain STOMP session events happen
	// such as ConnectionStarting, ConnectionClosed, SubscribeToTopic, UnsubscribeFromTopic and IncomingMessage.
	SetConnectionEventCallback(connEventType StompSessionEventType, cb func(connEvent *ConnEvent))
}

type StompSessionEventType int

type SubscribeHandlerFunction func(conId string, subId string, destination string, frame *frame.Frame)

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

type UnsubscribeHandlerFunction func(conId string, subId string, destination string)

type WebSocketStompConnection struct {
	WSCon *websocket.Conn
	// contains filtered or unexported fields
}