socket

Apr 23, 2023

Changes in this version

+ var RECOVERABLE_DISCONNECT_REASONS = types.NewSet("transport error", "transport close", "forced close", "ping timeout", ...)

type Adapter

+ GetBroadcast func() func(*parser.Packet, *BroadcastOptions)

+ PersistSession func(*SessionToPersist)

+ RestoreSession func(PrivateSessionId, string) (*Session, error)

+ type AdapterBuilder struct

+ func (*AdapterBuilder) New(nsp NamespaceInterface) Adapter

+ type AdapterConstructor interface

+ New func(NamespaceInterface) Adapter

type BroadcastFlags

+ ExpectSingleResponse bool

type BroadcastOperator

+ func (b *BroadcastOperator) EmitWithAck(ev string, args ...any) func(func(...any))

+ type ConnectionStateRecovery struct

+ func (c *ConnectionStateRecovery) GetRawMaxDisconnectionDuration() *int64

+ func (c *ConnectionStateRecovery) GetRawSkipMiddlewares() *bool

+ func (c *ConnectionStateRecovery) MaxDisconnectionDuration() int64

+ func (c *ConnectionStateRecovery) SetMaxDisconnectionDuration(maxDisconnectionDuration int64)

+ func (c *ConnectionStateRecovery) SetSkipMiddlewares(skipMiddlewares bool)

+ func (c *ConnectionStateRecovery) SkipMiddlewares() bool

type Namespace

+ func (n *Namespace) EmitWithAck(ev string, args ...any) func(func(...any))

+ func (n *Namespace) ServerSideEmitWithAck(ev string, args ...any) func(func(...any))

type NamespaceInterface

+ EmitWithAck func(string, ...any) func(func(...any))

+ ServerSideEmitWithAck func(string, ...any) func(func(...any))

+ type PersistedPacket struct

+ Data any

+ EmittedAt int64

+ Id string

+ Opts *BroadcastOptions

+ type PrivateSessionId string

type RemoteSocket

+ func (r *RemoteSocket) Timeout(timeout time.Duration) *BroadcastOperator

+ type SeesionData struct

+ Offset any

+ Pid any

+ func (s *SeesionData) GetOffset() (offset string, ok bool)

+ func (s *SeesionData) GetPid() (pid string, ok bool)

type Server

+ func (s *Server) EmitWithAck(ev string, args ...any) func(func(...any))

+ func (s *Server) Opts() *ServerOptions

+ func (s *Server) ServerSideEmitWithAck(ev string, args ...any) func(func(...any))

type ServerOptions

+ func (s *ServerOptions) CleanupEmptyChildNamespaces() bool

+ func (s *ServerOptions) ConnectionStateRecovery() *ConnectionStateRecovery

+ func (s *ServerOptions) GetRawCleanupEmptyChildNamespaces() *bool

+ func (s *ServerOptions) GetRawConnectionStateRecovery() *ConnectionStateRecovery

+ func (s *ServerOptions) SetCleanupEmptyChildNamespaces(cleanupEmptyChildNamespaces bool)

+ func (s *ServerOptions) SetConnectionStateRecovery(connectionStateRecovery *ConnectionStateRecovery)

type ServerOptionsInterface

+ CleanupEmptyChildNamespaces func() bool

+ ConnectionStateRecovery func() *ConnectionStateRecovery

+ GetRawCleanupEmptyChildNamespaces func() *bool

+ GetRawConnectionStateRecovery func() *ConnectionStateRecovery

+ SetCleanupEmptyChildNamespaces func(bool)

+ SetConnectionStateRecovery func(*ConnectionStateRecovery)

+ type Session struct

+ MissedPackets []any

+ type SessionAwareAdapterBuilder struct

+ func (*SessionAwareAdapterBuilder) New(nsp NamespaceInterface) Adapter

+ type SessionToPersist struct

+ Data any

+ Pid PrivateSessionId

+ Rooms *types.Set[Room]

+ Sid SocketId

+ type SessionWithTimestamp struct

+ DisconnectedAt int64

type Socket

+ func (s *Socket) EmitWithAck(ev string, args ...any) func(func(...any))

+ func (s *Socket) Recovered() bool

Sep 7, 2022

Changes in this version

type Server

+ func (s *Server) ServeHandler(opts *ServerOptions) http.Handler

Jul 18, 2022

Changes in this version

type Server

+ func (s *Server) Sockets() NamespaceInterface

Jul 18, 2022

Changes in this version

type Client

+ func (c *Client) Conn() engine.Socket

type Server

+ func (s *Server) Engine() engine.Server

Jul 16, 2022

Changes in this version

+ var NAMESPACE_RESERVED_EVENTS = types.NewSet("connect", "connection", "new_namespace")

+ var SOCKET_RESERVED_EVENTS = types.NewSet("connect", "connect_error", "disconnect", "disconnecting", "newListener", ...)

+ type Adapter interface

+ AddAll func(SocketId, *types.Set[Room])

+ AddSockets func(*BroadcastOptions, []Room)

+ Broadcast func(*parser.Packet, *BroadcastOptions)

+ BroadcastWithAck func(*parser.Packet, *BroadcastOptions, func(uint64), func(...interface{}))

+ Close func()

+ Del func(SocketId, Room)

+ DelAll func(SocketId)

+ DelSockets func(*BroadcastOptions, []Room)

+ DisconnectSockets func(*BroadcastOptions, bool)

+ FetchSockets func(*BroadcastOptions) []interface{}

+ Init func()

+ New func(NamespaceInterface) Adapter

+ Nsp func() NamespaceInterface

+ Rooms func() *sync.Map

+ ServerCount func() int64

+ ServerSideEmit func(string, ...interface{}) error

+ SetBroadcast func(func(*parser.Packet, *BroadcastOptions))

+ Sids func() *sync.Map

+ SocketRooms func(SocketId) *types.Set[Room]

+ Sockets func(*types.Set[Room]) *types.Set[SocketId]

+ func NewAdapter(nsp NamespaceInterface) Adapter

+ type BroadcastFlags struct

+ Binary bool

+ Broadcast bool

+ Local bool

+ Timeout *time.Duration

+ type BroadcastOperator struct

+ func NewBroadcastOperator(adapter Adapter, rooms *types.Set[Room], exceptRooms *types.Set[Room], ...) *BroadcastOperator

+ func (b *BroadcastOperator) AllSockets() (*types.Set[SocketId], error)

+ func (b *BroadcastOperator) Compress(compress bool) *BroadcastOperator

+ func (b *BroadcastOperator) DisconnectSockets(status bool)

+ func (b *BroadcastOperator) Emit(ev string, args ...interface{}) error

+ func (b *BroadcastOperator) Except(room ...Room) *BroadcastOperator

+ func (b *BroadcastOperator) FetchSockets() (remoteSockets []*RemoteSocket)

+ func (b *BroadcastOperator) In(room ...Room) *BroadcastOperator

+ func (b *BroadcastOperator) Local() *BroadcastOperator

+ func (b *BroadcastOperator) SocketsJoin(room ...Room)

+ func (b *BroadcastOperator) SocketsLeave(room ...Room)

+ func (b *BroadcastOperator) Timeout(timeout time.Duration) *BroadcastOperator

+ func (b *BroadcastOperator) To(room ...Room) *BroadcastOperator

+ func (b *BroadcastOperator) Volatile() *BroadcastOperator

+ type BroadcastOptions struct

+ Except *types.Set[Room]

+ Flags *BroadcastFlags

+ Rooms *types.Set[Room]

+ type Client struct

+ func NewClient(server *Server, conn engine.Socket) *Client

+ func (c *Client) Request() *types.HttpContext

+ func (c *Client) WriteToEngine(encodedPackets []types.BufferInterface, opts *WriteOptions)

+ type ExtendedError struct

+ func NewExtendedError(message string, data interface{}) *ExtendedError

+ func (e *ExtendedError) Data() interface{}

+ func (e *ExtendedError) Err() error

+ func (e *ExtendedError) Error() string

+ type Handshake struct

+ Address string

+ Auth interface{}

+ Headers *http.Header

+ Issued int64

+ Query *utils.ParameterBag

+ Secure bool

+ Time string

+ Url string

+ Xdomain bool

+ type Namespace struct

+ func NewNamespace(server *Server, name string) *Namespace

+ func (n *Namespace) Adapter() Adapter

+ func (n *Namespace) Add(client *Client, query interface{}, fn func(*Socket)) *Socket

+ func (n *Namespace) AllSockets() (*types.Set[SocketId], error)

+ func (n *Namespace) Compress(compress bool) *BroadcastOperator

+ func (n *Namespace) DisconnectSockets(status bool)

+ func (n *Namespace) Emit(ev string, args ...interface{}) error

+ func (n *Namespace) EventEmitter() *StrictEventEmitter

+ func (n *Namespace) Except(room ...Room) *BroadcastOperator

+ func (n *Namespace) FetchSockets() ([]*RemoteSocket, error)

+ func (n *Namespace) Ids() uint64

+ func (n *Namespace) In(room ...Room) *BroadcastOperator

+ func (n *Namespace) Local() *BroadcastOperator

+ func (n *Namespace) Name() string

+ func (n *Namespace) Send(args ...interface{}) NamespaceInterface

+ func (n *Namespace) Server() *Server

+ func (n *Namespace) ServerSideEmit(ev string, args ...interface{}) error

+ func (n *Namespace) Sockets() *sync.Map

+ func (n *Namespace) SocketsJoin(room ...Room)

+ func (n *Namespace) SocketsLeave(room ...Room)

+ func (n *Namespace) Timeout(timeout time.Duration) *BroadcastOperator

+ func (n *Namespace) To(room ...Room) *BroadcastOperator

+ func (n *Namespace) Use(fn func(*Socket, func(*ExtendedError))) NamespaceInterface

+ func (n *Namespace) Volatile() *BroadcastOperator

+ func (n *Namespace) Write(args ...interface{}) NamespaceInterface

+ type NamespaceInterface interface

+ Adapter func() Adapter

+ Add func(*Client, interface{}, func(*Socket)) *Socket

+ AllSockets func() (*types.Set[SocketId], error)

+ Compress func(bool) *BroadcastOperator

+ DisconnectSockets func(bool)

+ Emit func(string, ...interface{}) error

+ EmitReserved func(string, ...interface{})

+ EmitUntyped func(string, ...interface{})

+ EventEmitter func() *StrictEventEmitter

+ Except func(...Room) *BroadcastOperator

+ FetchSockets func() ([]*RemoteSocket, error)

+ Ids func() uint64

+ In func(...Room) *BroadcastOperator

+ Listeners func(string) []events.Listener

+ Local func() *BroadcastOperator

+ Name func() string

+ On func(string, ...events.Listener) error

+ Once func(string, ...events.Listener) error

+ Send func(...interface{}) NamespaceInterface

+ Server func() *Server

+ ServerSideEmit func(string, ...interface{}) error

+ Sockets func() *sync.Map

+ SocketsJoin func(...Room)

+ SocketsLeave func(...Room)

+ Timeout func(time.Duration) *BroadcastOperator

+ To func(...Room) *BroadcastOperator

+ Use func(func(*Socket, func(*ExtendedError))) NamespaceInterface

+ Volatile func() *BroadcastOperator

+ Write func(...interface{}) NamespaceInterface

+ type ParentNamespace struct

+ func NewParentNamespace(server *Server) *ParentNamespace

+ func (p *ParentNamespace) CreateChild(name string) *Namespace

+ func (p *ParentNamespace) Emit(ev string, args ...interface{}) error

+ func (p *ParentNamespace) FetchSockets() ([]*RemoteSocket, error)

+ type ParentNspNameMatchFn *func(string, interface{}, func(error, bool))

+ type RemoteSocket struct

+ func NewRemoteSocket(adapter Adapter, details SocketDetails) *RemoteSocket

+ func (r *RemoteSocket) Data() interface{}

+ func (r *RemoteSocket) Disconnect(status bool) *RemoteSocket

+ func (r *RemoteSocket) Emit(ev string, args ...interface{}) error

+ func (r *RemoteSocket) Handshake() *Handshake

+ func (r *RemoteSocket) Id() SocketId

+ func (r *RemoteSocket) Join(room ...Room)

+ func (r *RemoteSocket) Leave(room ...Room)

+ func (r *RemoteSocket) Rooms() *types.Set[Room]

+ type Room string

+ type Server struct

+ func NewServer(srv interface{}, opts *ServerOptions) *Server

+ func (s *Server) Adapter() Adapter

+ func (s *Server) AllSockets() (*types.Set[SocketId], error)

+ func (s *Server) Attach(srv interface{}, opts *ServerOptions) *Server

+ func (s *Server) Bind(egs engine.Server) *Server

+ func (s *Server) Close(fn func())

+ func (s *Server) Compress(compress bool) *BroadcastOperator

+ func (s *Server) ConnectTimeout() time.Duration

+ func (s *Server) DisconnectSockets(status bool)

+ func (s *Server) Encoder() parser.Encoder

+ func (s *Server) Except(room ...Room) *BroadcastOperator

+ func (s *Server) FetchSockets() ([]*RemoteSocket, error)

+ func (s *Server) In(room ...Room) *BroadcastOperator

+ func (s *Server) Listen(srv interface{}, opts *ServerOptions) *Server

+ func (s *Server) Local() *BroadcastOperator

+ func (s *Server) Of(name interface{}, fn func(...interface{})) NamespaceInterface

+ func (s *Server) Path() string

+ func (s *Server) Send(args ...interface{}) *Server

+ func (s *Server) ServeClient() bool

+ func (s *Server) ServerSideEmit(ev string, args ...interface{}) error

+ func (s *Server) SetAdapter(v Adapter) *Server

+ func (s *Server) SetConnectTimeout(v time.Duration) *Server

+ func (s *Server) SetPath(v string) *Server

+ func (s *Server) SetServeClient(v bool) *Server

+ func (s *Server) SocketsJoin(room ...Room)

+ func (s *Server) SocketsLeave(room ...Room)

+ func (s *Server) Timeout(timeout time.Duration) *BroadcastOperator

+ func (s *Server) To(room ...Room) *BroadcastOperator

+ func (s *Server) Use(fn func(*Socket, func(*ExtendedError))) *Server

+ func (s *Server) Volatile() *BroadcastOperator

+ func (s *Server) Write(args ...interface{}) *Server

+ type ServerOptions struct

+ func DefaultServerOptions() *ServerOptions

+ func (s *ServerOptions) Adapter() Adapter

+ func (s *ServerOptions) Assign(data ServerOptionsInterface) (ServerOptionsInterface, error)

+ func (s *ServerOptions) ConnectTimeout() time.Duration

+ func (s *ServerOptions) GetRawAdapter() Adapter

+ func (s *ServerOptions) GetRawConnectTimeout() *time.Duration

+ func (s *ServerOptions) GetRawParser() parser.Parser

+ func (s *ServerOptions) GetRawServeClient() *bool

+ func (s *ServerOptions) Parser() parser.Parser

+ func (s *ServerOptions) Path() string

+ func (s *ServerOptions) ServeClient() bool

+ func (s *ServerOptions) SetAdapter(adapter Adapter)

+ func (s *ServerOptions) SetConnectTimeout(connectTimeout time.Duration)

+ func (s *ServerOptions) SetParser(parser parser.Parser)

+ func (s *ServerOptions) SetServeClient(serveClient bool)

+ type ServerOptionsInterface interface

+ Adapter func() Adapter

+ ConnectTimeout func() time.Duration

+ GetRawAdapter func() Adapter

+ GetRawConnectTimeout func() *time.Duration

+ GetRawParser func() parser.Parser

+ GetRawServeClient func() *bool

+ Parser func() parser.Parser

+ ServeClient func() bool

+ SetAdapter func(adapter Adapter)

+ SetConnectTimeout func(connectTimeout time.Duration)

+ SetParser func(parser parser.Parser)

+ SetServeClient func(serveClient bool)

+ type Socket struct

+ func NewSocket(nsp *Namespace, client *Client, auth interface{}) *Socket

+ func (s *Socket) Acks() *sync.Map

+ func (s *Socket) Broadcast() *BroadcastOperator

+ func (s *Socket) Client() *Client

+ func (s *Socket) Compress(compress bool) *Socket

+ func (s *Socket) Conn() engine.Socket

+ func (s *Socket) Connected() bool

+ func (s *Socket) Data() interface{}

+ func (s *Socket) Disconnect(status bool) *Socket

+ func (s *Socket) Disconnected() bool

+ func (s *Socket) Emit(ev string, args ...interface{}) error

+ func (s *Socket) Except(room ...Room) *BroadcastOperator

+ func (s *Socket) Handshake() *Handshake

+ func (s *Socket) Id() SocketId

+ func (s *Socket) In(room ...Room) *BroadcastOperator

+ func (s *Socket) Join(rooms ...Room)

+ func (s *Socket) Leave(room Room)

+ func (s *Socket) ListenersAny() []events.Listener

+ func (s *Socket) ListenersAnyOutgoing() []events.Listener

+ func (s *Socket) Local() *BroadcastOperator

+ func (s *Socket) NotifyOutgoingListeners() func(*parser.Packet)

+ func (s *Socket) Nsp() *Namespace

+ func (s *Socket) OffAny(listener events.Listener) *Socket

+ func (s *Socket) OffAnyOutgoing(listener events.Listener) *Socket

+ func (s *Socket) OnAny(listener events.Listener) *Socket

+ func (s *Socket) OnAnyOutgoing(listener events.Listener) *Socket

+ func (s *Socket) PrependAny(listener events.Listener) *Socket

+ func (s *Socket) PrependAnyOutgoing(listener events.Listener) *Socket

+ func (s *Socket) Request() *types.HttpContext

+ func (s *Socket) Rooms() *types.Set[Room]

+ func (s *Socket) Send(args ...interface{}) *Socket

+ func (s *Socket) SetData(data interface{})

+ func (s *Socket) Timeout(timeout time.Duration) *Socket

+ func (s *Socket) To(room ...Room) *BroadcastOperator

+ func (s *Socket) Use(fn func([]interface{}, func(error))) *Socket

+ func (s *Socket) Volatile() *Socket

+ func (s *Socket) Write(args ...interface{}) *Socket

+ type SocketDetails interface

+ Data func() interface{}

+ Handshake func() *Handshake

+ Id func() SocketId

+ Rooms func() *types.Set[Room]

+ type SocketId string

+ type StrictEventEmitter struct

+ func NewStrictEventEmitter() *StrictEventEmitter

+ func (s *StrictEventEmitter) Emit(ev string, args ...interface{})

+ func (s *StrictEventEmitter) EmitReserved(ev string, args ...interface{})

+ func (s *StrictEventEmitter) EmitUntyped(ev string, args ...interface{})

+ func (s *StrictEventEmitter) Listeners(ev string) []events.Listener

+ func (s *StrictEventEmitter) On(ev string, listeners ...events.Listener) error

+ func (s *StrictEventEmitter) Once(ev string, listeners ...events.Listener) error

+ type WriteOptions struct

+ PreEncoded bool

+ Volatile bool

+ WsPreEncoded string