socket

package
v1.3.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 13, 2023 License: MIT Imports: 28 Imported by: 12

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	SOCKET_RESERVED_EVENTS = types.NewSet("connect", "connect_error", "disconnect", "disconnecting", "newListener", "removeListener")

	RECOVERABLE_DISCONNECT_REASONS = types.NewSet("transport error", "transport close", "forced close", "ping timeout", "server shutting down", "forced server close")
)
View Source 
var NAMESPACE_RESERVED_EVENTS = types.NewSet("connect", "connection", "new_namespace")

Functions

This section is empty.

Types

type Adapter 

type Adapter interface {
	events.EventEmitter

	Rooms() *types.Map[Room, *types.Set[SocketId]]
	Sids() *types.Map[SocketId, *types.Set[Room]]
	Nsp() NamespaceInterface

	// To be overridden
	Init()

	// To be overridden
	Close()

	// Returns the number of Socket.IO servers in the cluster
	ServerCount() int64

	// Adds a socket to a list of room.
	AddAll(SocketId, *types.Set[Room])

	// Removes a socket from a room.
	Del(SocketId, Room)

	// Removes a socket from all rooms it's joined.
	DelAll(SocketId)

	SetBroadcast(func(*parser.Packet, *BroadcastOptions))
	GetBroadcast() func(*parser.Packet, *BroadcastOptions)
	// Broadcasts a packet.
	//
	// Options:
	//  - `Flags` {*BroadcastFlags} flags for this packet
	//  - `Except` {*types.Set[Room]} sids that should be excluded
	//  - `Rooms` {*types.Set[Room]} list of rooms to broadcast to
	Broadcast(*parser.Packet, *BroadcastOptions)

	// Broadcasts a packet and expects multiple acknowledgements.
	//
	// Options:
	//  - `Flags` {*BroadcastFlags} flags for this packet
	//  - `Except` {*types.Set[Room]} sids that should be excluded
	//  - `Rooms` {*types.Set[Room]} list of rooms to broadcast to
	BroadcastWithAck(*parser.Packet, *BroadcastOptions, func(uint64), func([]any, error))

	// Gets a list of sockets by sid.
	Sockets(*types.Set[Room]) *types.Set[SocketId]

	// Gets the list of rooms a given socket has joined.
	SocketRooms(SocketId) *types.Set[Room]

	// Returns the matching socket instances
	FetchSockets(*BroadcastOptions) []SocketDetails

	// Makes the matching socket instances join the specified rooms
	AddSockets(*BroadcastOptions, []Room)

	// Makes the matching socket instances leave the specified rooms
	DelSockets(*BroadcastOptions, []Room)

	// Makes the matching socket instances disconnect
	DisconnectSockets(*BroadcastOptions, bool)

	// Send a packet to the other Socket.IO servers in the cluster
	ServerSideEmit([]any) error

	// Save the client session in order to restore it upon reconnection.
	PersistSession(*SessionToPersist)

	// Restore the session and find the packets that were missed by the client.
	RestoreSession(PrivateSessionId, string) (*Session, error)
}

type AdapterBuilder added in v1.1.0 

type AdapterBuilder struct {
}

func (*AdapterBuilder) New added in v1.1.0 

func (*AdapterBuilder) New(nsp NamespaceInterface) Adapter

type AdapterConstructor added in v1.1.0 

type AdapterConstructor interface {
	New(NamespaceInterface) Adapter
}

type BroadcastFlags 

type BroadcastFlags struct {
	WriteOptions

	Local     bool
	Broadcast bool
	Binary    bool
	Timeout   *time.Duration

	ExpectSingleResponse bool
}

type BroadcastOperator 

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

func NewBroadcastOperator 

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

func (*BroadcastOperator) AllSockets deprecated 

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

Gets a list of clients.

Deprecated: this method will be removed in the next major release, please use *Server.ServerSideEmit or *BroadcastOperator.FetchSockets instead.

func (*BroadcastOperator) Compress 

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

Sets the compress flag. 

io.Compress(false).Emit("hello")

func (*BroadcastOperator) DisconnectSockets 

func (b *BroadcastOperator) DisconnectSockets(status bool)

Makes the matching socket instances disconnect.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances disconnect (the connections might be kept alive for other namespaces)
io.DisconnectSockets(false)

// make all socket instances in the "room1" room disconnect and close the underlying connections
io.In("room1").DisconnectSockets(true)

func (*BroadcastOperator) Emit 

func (b *BroadcastOperator) Emit(ev string, args ...any) error

Emits to all clients. 

// the “foo” event will be broadcast to all connected clients
io.Emit("foo", "bar")

// the “foo” event will be broadcast to all connected clients in the “room-101” room
io.To("room-101").Emit("foo", "bar")

// with an acknowledgement expected from all connected clients
io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args []any, err error) {
	if err != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args) // one response per client
	}
})

func (*BroadcastOperator) EmitWithAck added in v1.1.0 

func (b *BroadcastOperator) EmitWithAck(ev string, args ...any) func(func([]any, error))

Emits an event and waits for an acknowledgement from all clients. 

io.Timeout(1000 * time.Millisecond).EmitWithAck("some-event")(func(args []any, err error) {
	if err == nil {
		fmt.Println(args) // one response per client
	} else {
		// some clients did not acknowledge the event in the given delay
	}
})

Return: a `func(func([]any, error))` that will be fulfilled when all clients have acknowledged the event

func (*BroadcastOperator) Except 

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

Excludes a room when emitting. 

// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
io.Except("room-101").Emit("foo", "bar")

// with an array of rooms
io.Except(["room-101", "room-102"]).Emit("foo", "bar")
io.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.Except("room-101").Except("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) FetchSockets 

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

Returns the matching socket instances. This method works across a cluster of several Socket.IO servers.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// return all Socket instances
sockets := io.FetchSockets()

// return all Socket instances in the "room1" room
sockets := io.In("room1").FetchSockets()

for _, socket := range sockets {
	fmt.Println(socket.Id())
	fmt.Println(socket.Handshake())
	fmt.Println(socket.Rooms())
	fmt.Println(socket.Data())

	socket.Emit("hello")
	socket.Join("room1")
	socket.Leave("room2")
	socket.Disconnect()
}

func (*BroadcastOperator) In 

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

Targets a room when emitting. Similar to `to()`, but might feel clearer in some cases: 

// disconnect all clients in the "room-101" room
io.In("room-101").DisconnectSockets(false)

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) Local 

func (b *BroadcastOperator) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

// the “foo” event will be broadcast to all connected clients on this node
io.Local().Emit("foo", "bar")

Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) SocketsJoin 

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

Makes the matching socket instances join the specified rooms.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances join the "room1" room
io.SocketsJoin("room1")

// make all socket instances in the "room1" room join the "room2" and "room3" rooms
io.In("room1").SocketsJoin([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*BroadcastOperator) SocketsLeave 

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

Makes the matching socket instances leave the specified rooms.

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances leave the "room1" room
io.SocketsLeave("room1")

// make all socket instances in the "room1" room leave the "room2" and "room3" rooms
io.In("room1").SocketsLeave([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*BroadcastOperator) Timeout 

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

Adds a timeout in milliseconds for the next operation 

io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args []any, err error) {
	if err != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args) // one response per client
	}
})

func (*BroadcastOperator) To 

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

Targets a room when emitting. 

// the “foo” event will be broadcast to all connected clients in the “room-101” room
io.To("room-101").Emit("foo", "bar")

// with an array of rooms (a client will be notified at most once)
io.To("room-101", "room-102").Emit("foo", "bar")
io.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.To("room-101").To("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*BroadcastOperator) Volatile 

func (b *BroadcastOperator) Volatile() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.Volatile().Emit("hello") // the clients may or may not receive it

type BroadcastOptions 

type BroadcastOptions struct {
	Rooms  *types.Set[Room]
	Except *types.Set[Room]
	Flags  *BroadcastFlags
}

type Client 

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

func NewClient 

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

Client constructor.

func (*Client) Conn added in v1.0.2 

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

func (*Client) Request 

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

func (*Client) WriteToEngine 

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

type ConnectionStateRecovery added in v1.1.0 

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

func (*ConnectionStateRecovery) GetRawMaxDisconnectionDuration added in v1.1.0 

func (c *ConnectionStateRecovery) GetRawMaxDisconnectionDuration() *int64

func (*ConnectionStateRecovery) GetRawSkipMiddlewares added in v1.1.0 

func (c *ConnectionStateRecovery) GetRawSkipMiddlewares() *bool

func (*ConnectionStateRecovery) MaxDisconnectionDuration added in v1.1.0 

func (c *ConnectionStateRecovery) MaxDisconnectionDuration() int64

func (*ConnectionStateRecovery) SetMaxDisconnectionDuration added in v1.1.0 

func (c *ConnectionStateRecovery) SetMaxDisconnectionDuration(maxDisconnectionDuration int64)

func (*ConnectionStateRecovery) SetSkipMiddlewares added in v1.1.0 

func (c *ConnectionStateRecovery) SetSkipMiddlewares(skipMiddlewares bool)

func (*ConnectionStateRecovery) SkipMiddlewares added in v1.1.0 

func (c *ConnectionStateRecovery) SkipMiddlewares() bool

type ExtendedError 

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

func NewExtendedError 

func NewExtendedError(message string, data any) *ExtendedError

func (*ExtendedError) Data 

func (e *ExtendedError) Data() any

func (*ExtendedError) Err 

func (e *ExtendedError) Err() error

func (*ExtendedError) Error 

func (e *ExtendedError) Error() string

type Handshake 

type Handshake struct {
	// The headers sent as part of the handshake
	Headers *utils.ParameterBag `json:"headers,omitempty"`
	// The date of creation (as string)
	Time string `json:"time,omitempty"`
	// The ip of the client
	Address string `json:"address,omitempty"`
	// Whether the connection is cross-domain
	Xdomain bool `json:"xdomain,omitempty"`
	// Whether the connection is secure
	Secure bool `json:"secure,omitempty"`
	// The date of creation (as unix timestamp)
	Issued int64 `json:"issued,omitempty"`
	// The request URL string
	Url string `json:"url,omitempty"`
	// The query object
	Query *utils.ParameterBag `json:"query,omitempty"`
	// The auth object
	Auth any `json:"auth,omitempty"`
}

type Namespace 

type Namespace struct {
	*StrictEventEmitter
	// contains filtered or unexported fields
}

func NewNamespace 

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

A Namespace is a communication channel that allows you to split the logic of your application over a single shared connection.

Each namespace has its own:

- event handlers 

io.Of("/orders").On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.On("order:list", func(...any){})
	socket.On("order:create", func(...any){})
})

io.Of("/users").On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.On("user:list", func(...any){})
})

- rooms 

orderNamespace := io.Of("/orders")

orderNamespace.On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.Join("room1")
	orderNamespace.To("room1").Emit("hello")
})

userNamespace := io.Of("/users")

userNamespace.On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.Join("room1") // distinct from the room in the "orders" namespace
	userNamespace.To("room1").Emit("holà")
})

- middlewares 

orderNamespace := io.Of("/orders")

orderNamespace.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ensure the socket has access to the "orders" namespace
})

userNamespace := io.Of("/users")

userNamespace.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ensure the socket has access to the "users" namespace
})

func (*Namespace) Adapter 

func (n *Namespace) Adapter() Adapter

func (*Namespace) Add 

func (n *Namespace) Add(client *Client, auth any, fn func(*Socket))

Adds a new client.

func (*Namespace) AllSockets deprecated 

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

Gets a list of socket ids.

Deprecated: this method will be removed in the next major release, please use *Server.ServerSideEmit or *BroadcastOperator.FetchSockets instead.

func (*Namespace) Compress 

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

Sets the compress flag. 

io.Compress(false).Emit("hello")

Param: bool - if `true`, compresses the sending data Return: a new *BroadcastOperator instance for chaining

func (*Namespace) DisconnectSockets 

func (n *Namespace) DisconnectSockets(status bool)

Makes the matching socket instances disconnect

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances disconnect (the connections might be kept alive for other namespaces)
io.DisconnectSockets(false)

// make all socket instances in the "room1" room disconnect and close the underlying connections
io.In("room1").DisconnectSockets(true)

func (*Namespace) Emit 

func (n *Namespace) Emit(ev string, args ...any) error

Emits to all clients. 

myNamespace := io.Of("/my-namespace")

// the “foo” event will be broadcast to all connected clients
myNamespace.Emit("foo", "bar")

// the “foo” event will be broadcast to all connected clients in the “room-101” room
myNamespace.To("room-101").Emit("foo", "bar")

// with an acknowledgement expected from all connected clients
myNamespace.Timeout(1000 * time.Millisecond).Emit("some-event", func(args []any, err error) {
	if err != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args) // one response per client
	}
})

func (*Namespace) EmitWithAck added in v1.1.0 

func (n *Namespace) EmitWithAck(ev string, args ...any) func(func([]any, error))

Emits an event and waits for an acknowledgement from all clients. 

myNamespace := io.Of("/my-namespace")

myNamespace.Timeout(1000 * time.Millisecond).EmitWithAck("some-event")(func(args []any, err error) {
	if err == nil {
		fmt.Println(args) // one response per client
	} else {
		// some servers did not acknowledge the event in the given delay
	}
})

Return: a `func(func([]any, error))` that will be fulfilled when all clients have acknowledged the event

func (*Namespace) EventEmitter 

func (n *Namespace) EventEmitter() *StrictEventEmitter

func (*Namespace) Except 

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

Excludes a room when emitting. 

myNamespace := io.Of("/my-namespace")

// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
myNamespace.Except("room-101").Emit("foo", "bar")

// with an array of rooms
myNamespace.Except(["room-101", "room-102"]).Emit("foo", "bar")
myNamespace.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
myNamespace.Except("room-101").Except("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) FetchSockets 

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

Returns the matching socket instances

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// return all Socket instances
sockets := io.FetchSockets()

// return all Socket instances in the "room1" room
sockets := io.In("room1").FetchSockets()

for _, socket := range sockets {
	fmt.Println(socket.Id())
	fmt.Println(socket.Handshake())
	fmt.Println(socket.Rooms())
	fmt.Println(socket.Data())

	socket.Emit("hello")
	socket.Join("room1")
	socket.Leave("room2")
	socket.Disconnect()
}

func (*Namespace) Ids 

func (n *Namespace) Ids() uint64

func (*Namespace) In 

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

Targets a room when emitting. 

myNamespace := io.Of("/my-namespace")

// disconnect all clients in the "room-101" room
myNamespace.In("room-101").DisconnectSockets(false)

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) Local 

func (n *Namespace) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

// the “foo” event will be broadcast to all connected clients on this node
io.Local().Emit("foo", "bar")

Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) Name 

func (n *Namespace) Name() string

func (*Namespace) Send 

func (n *Namespace) Send(args ...any) NamespaceInterface

Sends a `message` event to all clients.

This method mimics the WebSocket.send() method.

See: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send 

myNamespace := io.Of("/my-namespace")

myNamespace.Send("hello")

// this is equivalent to
myNamespace.Emit("message", "hello")

func (*Namespace) Server 

func (n *Namespace) Server() *Server

func (*Namespace) ServerSideEmit 

func (n *Namespace) ServerSideEmit(ev string, args ...any) error

Emit a packet to other Socket.IO servers 

myNamespace := io.Of("/my-namespace")

myNamespace.ServerSideEmit("hello", "world")

myNamespace.On("hello", func(args ...any) {
	fmt.Println(args) // prints "world"
})

// acknowledgements (without binary content) are supported too:
myNamespace.ServerSideEmit("ping", func(args []any, err error) {
	if err != nil {
		// some servers did not acknowledge the event in the given delay
	} else {
		fmt.Println(args) // one response per server (except the current one)
	}
})

myNamespace.On("ping", func(args ...any) {
	args[0]("pong")
})

func (*Namespace) ServerSideEmitWithAck added in v1.1.0 

func (n *Namespace) ServerSideEmitWithAck(ev string, args ...any) func(func([]any, error))

Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster. 

myNamespace := io.Of("/my-namespace")

myNamespace.Timeout(1000 * time.Millisecond).ServerSideEmitWithAck("some-event")(func(args []any, err error) {
	if err == nil {
		fmt.Println(args) // one response per client
	} else {
		// some servers did not acknowledge the event in the given delay
	}
})

Return: a `func(func([]any, error))` that will be fulfilled when all servers have acknowledged the event

func (*Namespace) Sockets 

func (n *Namespace) Sockets() *types.Map[SocketId, *Socket]

func (*Namespace) SocketsJoin 

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

Makes the matching socket instances join the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances join the "room1" room
io.SocketsJoin("room1")

// make all socket instances in the "room1" room join the "room2" and "room3" rooms
io.In("room1").SocketsJoin([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Namespace) SocketsLeave 

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

Makes the matching socket instances leave the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances leave the "room1" room
io.SocketsLeave("room1")

// make all socket instances in the "room1" room leave the "room2" and "room3" rooms
io.In("room1").SocketsLeave([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Namespace) Timeout 

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

Adds a timeout in milliseconds for the next operation 

io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args []any, err error) {
	if err != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args) // one response per client
	}
})

func (*Namespace) To 

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

Targets a room when emitting. 

myNamespace := io.Of("/my-namespace")

// the “foo” event will be broadcast to all connected clients in the “room-101” room
myNamespace.To("room-101").Emit("foo", "bar")

// with an array of rooms (a client will be notified at most once)
myNamespace.To("room-101", "room-102").Emit("foo", "bar")
myNamespace.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
myNamespace.To("room-101").To("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Namespace) Use 

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

Registers a middleware, which is a function that gets executed for every incoming {@link Socket}. 

myNamespace := io.Of("/my-namespace")

myNamespace.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ...
	next(nil)
})

Param: func(*ExtendedError) - the middleware function

func (*Namespace) Volatile 

func (n *Namespace) Volatile() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.Volatile().Emit("hello") // the clients may or may not receive it

func (*Namespace) Write 

func (n *Namespace) Write(args ...any) NamespaceInterface

Sends a `message` event to all clients. Alias of Send.

type NamespaceInterface 

type NamespaceInterface interface {
	EventEmitter() *StrictEventEmitter

	On(string, ...events.Listener) error
	Once(string, ...events.Listener) error
	EmitReserved(string, ...any)
	EmitUntyped(string, ...any)
	Listeners(string) []events.Listener

	Sockets() *types.Map[SocketId, *Socket]
	Server() *Server
	Adapter() Adapter
	Name() string
	Ids() uint64

	// Sets up namespace middleware.
	Use(func(*Socket, func(*ExtendedError))) NamespaceInterface

	// Targets a room when emitting.
	To(...Room) *BroadcastOperator

	// Targets a room when emitting.
	In(...Room) *BroadcastOperator

	// Excludes a room when emitting.
	Except(...Room) *BroadcastOperator

	// Adds a new client.
	Add(*Client, any, func(*Socket))

	// Emits to all clients.
	Emit(string, ...any) error

	// Emits an event and waits for an acknowledgement from all clients.
	EmitWithAck(string, ...any) func(func([]any, error))

	// Sends a `message` event to all clients.
	Send(...any) NamespaceInterface

	// Sends a `message` event to all clients.
	Write(...any) NamespaceInterface

	// Emit a packet to other Socket.IO servers
	ServerSideEmit(string, ...any) error

	// Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster.
	ServerSideEmitWithAck(string, ...any) func(func([]any, error))

	// Gets a list of clients.
	AllSockets() (*types.Set[SocketId], error)

	// Sets the compress flag.
	Compress(bool) *BroadcastOperator

	// Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to
	// receive messages (because of network slowness or other issues, or because they’re connected through long polling
	// and is in the middle of a request-response cycle).
	Volatile() *BroadcastOperator

	// Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node.
	Local() *BroadcastOperator

	// Adds a timeout in milliseconds for the next operation
	Timeout(time.Duration) *BroadcastOperator

	// Returns the matching socket instances
	FetchSockets() ([]*RemoteSocket, error)

	// Makes the matching socket instances join the specified rooms
	SocketsJoin(...Room)

	// Makes the matching socket instances leave the specified rooms
	SocketsLeave(...Room)

	// Makes the matching socket instances disconnect
	DisconnectSockets(bool)
}

type ParentNamespace 

type ParentNamespace struct {
	*Namespace
	// contains filtered or unexported fields
}

func NewParentNamespace 

func NewParentNamespace(server *Server) *ParentNamespace

A parent namespace is a special {@link Namespace} that holds a list of child namespaces which were created either with a regular expression or with a function. 

parentNamespace := io.Of(regexp.MustCompile(`/dynamic-\d+`))

parentNamespace.On("connection", func(clients ...any) {
	client := clients[0].(*socket.Socket)
	childNamespace := client.Nsp()
}

// will reach all the clients that are in one of the child namespaces, like "/dynamic-101"

parentNamespace.Emit("hello", "world")

func (*ParentNamespace) CreateChild 

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

func (*ParentNamespace) Emit 

func (p *ParentNamespace) Emit(ev string, args ...any) error

func (*ParentNamespace) FetchSockets 

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

type ParentNspNameMatchFn 

type ParentNspNameMatchFn *func(string, any, func(error, bool))

type PersistedPacket added in v1.1.0 

type PersistedPacket struct {
	Id        string
	EmittedAt int64
	Data      any
	Opts      *BroadcastOptions
}

type PrivateSessionId added in v1.1.0 

type PrivateSessionId string

A private ID, sent by the server at the beginning of the Socket.IO session and used for connection state recovery upon reconnection

type RemoteSocket 

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

func NewRemoteSocket 

func NewRemoteSocket(adapter Adapter, details SocketDetails) *RemoteSocket

func (*RemoteSocket) Data 

func (r *RemoteSocket) Data() any

func (*RemoteSocket) Disconnect 

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

Disconnects this client.

func (*RemoteSocket) Emit 

func (r *RemoteSocket) Emit(ev string, args ...any) error

func (*RemoteSocket) Handshake 

func (r *RemoteSocket) Handshake() *Handshake

func (*RemoteSocket) Id 

func (r *RemoteSocket) Id() SocketId

func (*RemoteSocket) Join 

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

Joins a room.

func (*RemoteSocket) Leave 

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

Leaves a room.

func (*RemoteSocket) Rooms 

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

func (*RemoteSocket) Timeout added in v1.1.0 

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

Adds a timeout in milliseconds for the next operation. 

sockets :=  io.FetchSockets()

for _, socket := range sockets {
	if (someCondition) {
		socket.Timeout(1000 * time.Millisecond).Emit("some-event", func(args []any, err error) {
			if err != nil {
				// the client did not acknowledge the event in the given delay
			}
		})
	}
}

// Note: if possible, using a room instead of looping over all sockets is preferable

io.Timeout(1000 * time.Millisecond).To(someConditionRoom).Emit("some-event", func(error, args []any) {
	// ...
})

Param: time.Duration - timeout

type Room 

type Room string

we could extend the Room type to "string | number", but that would be a breaking change Related: https://github.com/socketio/socket.io-redis-adapter/issues/418

type SeesionData added in v1.1.0 

type SeesionData struct {
	Pid    any `json:"pid" mapstructure:"pid"`
	Offset any `json:"offset" mapstructure:"offset"`
}

func (*SeesionData) GetOffset added in v1.1.0 

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

func (*SeesionData) GetPid added in v1.1.0 

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

type Server 

type Server struct {
	*StrictEventEmitter
	// contains filtered or unexported fields
}

func NewServer 

func NewServer(srv any, opts *ServerOptions) *Server

Represents a Socket.IO server. 

import (
	"github.com/zishang520/engine.io/utils"
	"github.com/zishang520/socket.io/socket"
)

io := socket.NewServer(nil, nil)

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)

	utils.Log().Info(`socket %s connected`, socket.Id())

	// send an event to the client
	socket.Emit("foo", "bar")

	socket.On("foobar", func(...any) {
		// an event was received from the client
	})

	// upon disconnection
	socket.On("disconnect", func(reason ...any) {
		utils.Log().Info(`socket %s disconnected due to %s`, socket.Id(), reason[0])
	})
})
io.Listen(3000, nil)

func (*Server) Adapter 

func (s *Server) Adapter() AdapterConstructor

func (*Server) AllSockets deprecated 

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

Gets a list of socket ids.

Deprecated: this method will be removed in the next major release, please use *Server.ServerSideEmit or *BroadcastOperator.FetchSockets instead.

func (*Server) Attach 

func (s *Server) Attach(srv any, opts *ServerOptions) *Server

Attaches socket.io to a server or port.

func (*Server) Bind 

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

Binds socket.io to an engine.io instance.

func (*Server) Close 

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

Closes server connection

func (*Server) Compress 

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

Sets the compress flag. 

io.Compress(false).Emit("hello")

Param: bool - if `true`, compresses the sending data Return: a new *BroadcastOperator instance for chaining

func (*Server) ConnectTimeout 

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

func (*Server) DisconnectSockets 

func (s *Server) DisconnectSockets(status bool)

Makes the matching socket instances disconnect

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances disconnect (the connections might be kept alive for other namespaces)
io.DisconnectSockets(false)

// make all socket instances in the "room1" room disconnect and close the underlying connections
io.In("room1").DisconnectSockets(true)

func (*Server) EmitWithAck added in v1.1.0 

func (s *Server) EmitWithAck(ev string, args ...any) func(func([]any, error))

Emits an event and waits for an acknowledgement from all clients. 

io.Timeout(1000 * time.Millisecond).EmitWithAck("some-event")(func(args []any, err error) {
	if err == nil {
		fmt.Println(args) // one response per client
	} else {
		// some servers did not acknowledge the event in the given delay
	}
})

Return: a `func(func([]any, error))` that will be fulfilled when all servers have acknowledged the event

func (*Server) Encoder 

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

func (*Server) Engine added in v1.0.2 

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

func (*Server) Except 

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

Excludes a room when emitting. 

// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
io.Except("room-101").Emit("foo", "bar")

// with an array of rooms
io.Except(["room-101", "room-102"]).Emit("foo", "bar")
io.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.Except("room-101").Except("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Server) FetchSockets 

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

Returns the matching socket instances

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// return all Socket instances
sockets := io.FetchSockets()

// return all Socket instances in the "room1" room
sockets := io.In("room1").FetchSockets()

for _, socket := range sockets {
	fmt.Println(socket.Id())
	fmt.Println(socket.Handshake())
	fmt.Println(socket.Rooms())
	fmt.Println(socket.Data())

	socket.Emit("hello")
	socket.Join("room1")
	socket.Leave("room2")
	socket.Disconnect()
}

func (*Server) In 

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

Targets a room when emitting. 

// disconnect all clients in the "room-101" room
io.In("room-101").DisconnectSockets(false)

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Server) Listen 

func (s *Server) Listen(srv any, opts *ServerOptions) *Server

Attaches socket.io to a server or port.

func (*Server) Local 

func (s *Server) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

// the “foo” event will be broadcast to all connected clients on this node
io.Local().Emit("foo", "bar")

Return: a new `*BroadcastOperator` instance for chaining

func (*Server) Of 

func (s *Server) Of(name any, fn func(...any)) NamespaceInterface

Looks up a namespace. 

// with a simple string
myNamespace := io.Of("/my-namespace")

// with a regex
const dynamicNsp = io.Of(regexp.MustCompile(`^\/dynamic-\d+$`), nil).On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	namespace := socket.Nsp() // newNamespace.Name() === "/dynamic-101"

	// broadcast to all clients in the given sub-namespace
	namespace.Emit("hello")
})

Param: any - nsp name Param: func(...any) - nsp `connection` ev handler

func (*Server) Opts added in v1.1.0 

func (s *Server) Opts() *ServerOptions

func (*Server) Path 

func (s *Server) Path() string

func (*Server) Send 

func (s *Server) Send(args ...any) *Server

Sends a `message` event to all clients.

This method mimics the WebSocket.send() method.

See: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send 

io.Send("hello")

// this is equivalent to
io.Emit("message", "hello")

func (*Server) ServeClient 

func (s *Server) ServeClient() bool

func (*Server) ServeHandler added in v1.0.11 

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

func (*Server) ServerSideEmit 

func (s *Server) ServerSideEmit(ev string, args ...any) error

Sends a message to the other Socket.IO servers of the cluster. 

io.ServerSideEmit("hello", "world")

io.On("hello", func(args ...any) {
	fmt.Println(args) // prints "world"
})

// acknowledgements (without binary content) are supported too:
io.ServerSideEmit("ping", func(args []any, err error) {
	if err != nil {
		// some servers did not acknowledge the event in the given delay
	} else {
		fmt.Println(args) // one response per server (except the current one)
	}
})

io.On("ping", func(args ...any) {
	args[0]("pong")
})

func (*Server) ServerSideEmitWithAck added in v1.1.0 

func (s *Server) ServerSideEmitWithAck(ev string, args ...any) func(func([]any, error))

Sends a message and expect an acknowledgement from the other Socket.IO servers of the cluster. 

io.Timeout(1000 * time.Millisecond).ServerSideEmitWithAck("some-event")(func(args []any, err error) {
	if err == nil {
		fmt.Println(args) // one response per client
	} else {
		// some servers did not acknowledge the event in the given delay
	}
})

Return: a `func(func([]any, error))` that will be fulfilled when all servers have acknowledged the event

func (*Server) SetAdapter 

func (s *Server) SetAdapter(v AdapterConstructor) *Server

Sets the adapter for rooms.

func (*Server) SetConnectTimeout 

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

Set the delay after which a client without namespace is closed

func (*Server) SetPath 

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

Sets the client serving path.

func (*Server) SetServeClient 

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

Sets/gets whether client code is being served.

func (*Server) Sockets added in v1.0.3 

func (s *Server) Sockets() NamespaceInterface

func (*Server) SocketsJoin 

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

Makes the matching socket instances join the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances join the "room1" room
io.SocketsJoin("room1")

// make all socket instances in the "room1" room join the "room2" and "room3" rooms
io.In("room1").SocketsJoin([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Server) SocketsLeave 

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

Makes the matching socket instances leave the specified rooms

Note: this method also works within a cluster of multiple Socket.IO servers, with a compatible Adapter. 

// make all socket instances leave the "room1" room
io.SocketsLeave("room1")

// make all socket instances in the "room1" room leave the "room2" and "room3" rooms
io.In("room1").SocketsLeave([]Room{"room2", "room3"}...)

Param: Room - a `Room`, or a `Room` slice to expand

func (*Server) Timeout 

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

Adds a timeout in milliseconds for the next operation 

io.Timeout(1000 * time.Millisecond).Emit("some-event", func(args []any, err error) {
	if err != nil {
		// some clients did not acknowledge the event in the given delay
	} else {
		fmt.Println(args) // one response per client
	}
})

func (*Server) To 

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

Targets a room when emitting. 

// the “foo” event will be broadcast to all connected clients in the “room-101” room
io.To("room-101").Emit("foo", "bar")

// with an array of rooms (a client will be notified at most once)
io.To("room-101", "room-102").Emit("foo", "bar")
io.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

// with multiple chained calls
io.To("room-101").To("room-102").Emit("foo", "bar")

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Server) Use 

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

Registers a middleware, which is a function that gets executed for every incoming {@link Socket}. 

io.Use(func(socket *socket.Socket, next func(*socket.ExtendedError)) {
	// ...
	next(nil)
})

Param: func(*ExtendedError) - the middleware function

func (*Server) Volatile 

func (s *Server) Volatile() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.Volatile().Emit("hello") // the clients may or may not receive it

func (*Server) Write 

func (s *Server) Write(args ...any) *Server

Sends a `message` event to all clients. Alias of Send.

type ServerOptions 

type ServerOptions struct {
	config.ServerOptions
	config.AttachOptions
	// contains filtered or unexported fields
}

func DefaultServerOptions 

func DefaultServerOptions() *ServerOptions

func (*ServerOptions) Adapter 

func (s *ServerOptions) Adapter() AdapterConstructor

func (*ServerOptions) Assign 

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

func (*ServerOptions) CleanupEmptyChildNamespaces added in v1.1.0 

func (s *ServerOptions) CleanupEmptyChildNamespaces() bool

func (*ServerOptions) ConnectTimeout 

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

func (*ServerOptions) ConnectionStateRecovery added in v1.1.0 

func (s *ServerOptions) ConnectionStateRecovery() *ConnectionStateRecovery

func (*ServerOptions) GetRawAdapter 

func (s *ServerOptions) GetRawAdapter() AdapterConstructor

func (*ServerOptions) GetRawCleanupEmptyChildNamespaces added in v1.1.0 

func (s *ServerOptions) GetRawCleanupEmptyChildNamespaces() *bool

func (*ServerOptions) GetRawConnectTimeout 

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

func (*ServerOptions) GetRawConnectionStateRecovery added in v1.1.0 

func (s *ServerOptions) GetRawConnectionStateRecovery() *ConnectionStateRecovery

func (*ServerOptions) GetRawParser 

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

func (*ServerOptions) GetRawServeClient 

func (s *ServerOptions) GetRawServeClient() *bool

func (*ServerOptions) Parser 

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

func (*ServerOptions) Path 

func (s *ServerOptions) Path() string

func (*ServerOptions) ServeClient 

func (s *ServerOptions) ServeClient() bool

func (*ServerOptions) SetAdapter 

func (s *ServerOptions) SetAdapter(adapter AdapterConstructor)

func (*ServerOptions) SetCleanupEmptyChildNamespaces added in v1.1.0 

func (s *ServerOptions) SetCleanupEmptyChildNamespaces(cleanupEmptyChildNamespaces bool)

func (*ServerOptions) SetConnectTimeout 

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

func (*ServerOptions) SetConnectionStateRecovery added in v1.1.0 

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

func (*ServerOptions) SetParser 

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

func (*ServerOptions) SetServeClient 

func (s *ServerOptions) SetServeClient(serveClient bool)

type ServerOptionsInterface 

type ServerOptionsInterface interface {
	config.ServerOptionsInterface
	config.AttachOptionsInterface

	SetServeClient(bool)
	GetRawServeClient() *bool
	ServeClient() bool

	SetAdapter(AdapterConstructor)
	GetRawAdapter() AdapterConstructor
	Adapter() AdapterConstructor

	SetParser(parser.Parser)
	GetRawParser() parser.Parser
	Parser() parser.Parser

	SetConnectTimeout(time.Duration)
	GetRawConnectTimeout() *time.Duration
	ConnectTimeout() time.Duration

	SetConnectionStateRecovery(*ConnectionStateRecovery)
	GetRawConnectionStateRecovery() *ConnectionStateRecovery
	ConnectionStateRecovery() *ConnectionStateRecovery

	SetCleanupEmptyChildNamespaces(bool)
	GetRawCleanupEmptyChildNamespaces() *bool
	CleanupEmptyChildNamespaces() bool
}

type Session added in v1.1.0 

type Session struct {
	*SessionToPersist

	MissedPackets []any
}

type SessionAwareAdapterBuilder added in v1.1.0 

type SessionAwareAdapterBuilder struct {
}

func (*SessionAwareAdapterBuilder) New added in v1.1.0 

func (*SessionAwareAdapterBuilder) New(nsp NamespaceInterface) Adapter

type SessionToPersist added in v1.1.0 

type SessionToPersist struct {
	Sid   SocketId
	Pid   PrivateSessionId
	Rooms *types.Set[Room]
	Data  any
}

type SessionWithTimestamp added in v1.1.0 

type SessionWithTimestamp struct {
	*SessionToPersist

	DisconnectedAt int64
}

type Socket 

type Socket struct {
	*StrictEventEmitter
	// contains filtered or unexported fields
}

func NewSocket 

func NewSocket(nsp *Namespace, client *Client, auth any, previousSession *Session) *Socket

This is the main object for interacting with a client.

A Socket belongs to a given *socket.Namespace and uses an underlying *socket.Client to communicate.

Within each *socket.Namespace, you can also define arbitrary channels (called "rooms") that the *socket.Socket can join and leave. That provides a convenient way to broadcast to a group of socket instances. 

io.On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)

	utils.Log().Info(`socket %s connected`, socket.Id())

	// send an event to the client
	socket.Emit("foo", "bar")

	socket.On("foobar", func(...any) {
		// an event was received from the client
	})

	// join the room named "room1"
	socket.Join("room1")

	// broadcast to everyone in the room named "room1"
	io.to("room1").Emit("hello")

	// upon disconnection
	socket.On("disconnect", func(reason ...any) {
		utils.Log().Info(`socket %s disconnected due to %s`, socket.Id(), reason[0])
	})
})

func (*Socket) Acks 

func (s *Socket) Acks() *types.Map[uint64, func([]any, error)]

func (*Socket) Broadcast 

func (s *Socket) Broadcast() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to every sockets but the sender. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the “foo” event will be broadcast to all connected clients, except this socket
	socket.Broadcast().Emit("foo", "bar")
})

Return: a new *BroadcastOperator instance for chaining

func (*Socket) Client 

func (s *Socket) Client() *Client

func (*Socket) Compress 

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

Sets the compress flag. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Compress(false).Emit("hello")
})

func (*Socket) Conn 

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

A reference to the underlying Client transport connection (Engine.IO Socket object). 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	fmt.Println(socket.Conn().Transport().Name()) // prints "polling" or "websocket"

	socket.Conn().Once("upgrade", func(...any) {
		fmt.Println(socket.Conn().Transport().Name()) // prints "websocket"
	})
})

func (*Socket) Connected 

func (s *Socket) Connected() bool

func (*Socket) Data 

func (s *Socket) Data() any

func (*Socket) Disconnect 

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

Disconnects this client. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// disconnect this socket (the connection might be kept alive for other namespaces)
	socket.Disconnect(false)

	// disconnect this socket and close the underlying connection
	socket.Disconnect(true)
})

Param: bool - if `true`, closes the underlying connection
Return: *Socket

func (*Socket) Disconnected 

func (s *Socket) Disconnected() bool

Whether the socket is currently disconnected

func (*Socket) Emit 

func (s *Socket) Emit(ev string, args ...any) error

Emits to this client. 

io.On("connection", func(args ...any) {
	socket := args[0].(*socket.Socket)
	socket.Emit("hello", "world")

	// all serializable datastructures are supported (no need to call json.Marshal, But the map can only be of `map[string]any` type, currently does not support other types of maps)
	socket.Emit("hello", 1, "2", map[string]any{"3": []string{"4"}, "5": types.NewBytesBuffer([]byte{6})})

	// with an acknowledgement from the client
	socket.Emit("hello", "world", func(args []any, err error) {
		// ...
	})
})

func (*Socket) EmitWithAck added in v1.1.0 

func (s *Socket) EmitWithAck(ev string, args ...any) func(func([]any, error))

Emits an event and waits for an acknowledgement 

io.On("connection", func(args ...any) => {
	client := args[0].(*socket.Socket)
	// without timeout
	client.EmitWithAck("hello", "world")(func(args []any, err error) {
		if err == nil {
			fmt.Println(args) // one response per client
		} else {
			// some clients did not acknowledge the event in the given delay
		}
	})

	// with a specific timeout
	client.Timeout(1000 * time.Millisecond).EmitWithAck("hello", "world")(func(args []any, err error) {
		if err == nil {
			fmt.Println(args) // one response per client
		} else {
			// some clients did not acknowledge the event in the given delay
		}
	})
})

Return: a `func(func([]any, error))` that will be fulfilled when all clients have acknowledged the event

func (*Socket) Except 

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

Excludes a room when broadcasting. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the "foo" event will be broadcast to all connected clients, except the ones that are in the "room-101" room
	// and this socket
	socket.Except("room-101").Emit("foo", "bar")

	// with an array of rooms
	socket.Except([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

	// with multiple chained calls
	socket.Except("room-101").Except("room-102").Emit("foo", "bar")
})

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Socket) Handshake 

func (s *Socket) Handshake() *Handshake

func (*Socket) Id 

func (s *Socket) Id() SocketId

func (*Socket) In 

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

Targets a room when broadcasting. Similar to `to()`, but might feel clearer in some cases: 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// disconnect all clients in the "room-101" room, except this socket
	socket.In("room-101").DisconnectSockets(false)
});

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Socket) Join 

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

Joins a room. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// join a single room
	socket.Join("room1")

	// join multiple rooms
	socket.Join([]Room{"room-101", "room-102"}...)
})

Param: Room - a `Room`, or a `Room` slice to expand

func (*Socket) Leave 

func (s *Socket) Leave(room Room)

Leaves a room. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// leave a single room
	socket.Leave("room1")

	// leave multiple rooms
	socket.Leave("room-101")
	socket.Leave("room-102")
})

Param: Room - a `Room`, or a `Room` slice to expand

func (*Socket) ListenersAny 

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

Returns an array of listeners that are listening for any event that is specified. This array can be manipulated, e.g. to remove listeners.

func (*Socket) ListenersAnyOutgoing 

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

Returns an array of listeners that are listening for any event that is specified. This array can be manipulated, e.g. to remove listeners.

func (*Socket) Local 

func (s *Socket) Local() *BroadcastOperator

Sets a modifier for a subsequent event emission that the event data will only be broadcast to the current node. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the “foo” event will be broadcast to all connected clients on this node, except this socket
	socket.Local().Emit("foo", "bar")
})

Return: a new *BroadcastOperator instance for chaining

func (*Socket) NotifyOutgoingListeners 

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

func (*Socket) Nsp 

func (s *Socket) Nsp() *Namespace

func (*Socket) OffAny 

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

Removes the listener that will be fired when any event is received. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	catchAllListener := func(events ...any) {
		fmt.Println(`got event `, events)
	}

	socket.OnAny(catchAllListener)

	// remove a specific listener
	socket.OffAny(catchAllListener)

	// or remove all listeners
	socket.OffAny(nil)
})

func (*Socket) OffAnyOutgoing 

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

Removes the listener that will be fired when any event is sent. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	catchAllListener := func(events ...any) {
		fmt.Println(`sent event `, events)
	}

	socket.OnAnyOutgoing(catchAllListener)

	// remove a specific listener
	socket.OffAnyOutgoing(catchAllListener)

	// or remove all listeners
	socket.OffAnyOutgoing(nil)
})

Param: events.Listener - the catch-all listener

func (*Socket) OnAny 

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

Adds a listener that will be fired when any event is received. The event name is passed as the first argument to the callback. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.OnAny(func(events ...any) {
		fmt.Println(`got event `, events)
	})
})

func (*Socket) OnAnyOutgoing 

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

Adds a listener that will be fired when any event is sent. The event name is passed as the first argument to the callback.

Note: acknowledgements sent to the client are not included. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.onAnyOutgoing(func(events ...any) {
		fmt.Println(`got event `, events)
	})
})

Param: events.Listener

func (*Socket) PrependAny 

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

Adds a listener that will be fired when any event is received. The event name is passed as the first argument to the callback. The listener is added to the beginning of the listeners array.

func (*Socket) PrependAnyOutgoing 

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

Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the callback. The listener is added to the beginning of the listeners array. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.PrependAnyOutgoing(func(events ...any) {
		fmt.Println(`sent event `, events)
	})
})

func (*Socket) Recovered added in v1.1.0 

func (s *Socket) Recovered() bool

func (*Socket) Request 

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

A reference to the request that originated the underlying Engine.IO Socket.

func (*Socket) Rooms 

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

Returns the rooms the socket is currently in. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	fmt.Println(socket.Rooms()) // *types.Set { <socket.id> }

	socket.Join("room1")

	fmt.Println(socket.Rooms()) // *types.Set { <socket.id>, "room1" }
})

func (*Socket) Send 

func (s *Socket) Send(args ...any) *Socket

Sends a `message` event.

This method mimics the WebSocket.send() method.

See: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Send("hello");

	// this is equivalent to
	socket.Emit("message", "hello");
});

func (*Socket) SetData 

func (s *Socket) SetData(data any)

func (*Socket) Timeout 

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

Sets a modifier for a subsequent event emission that the callback will be called with an error when the given number of milliseconds have elapsed without an acknowledgement from the client: 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Timeout(1000 * time.Millisecond).Emit("my-event", func(args []any, err error) {
		if err != nil {
			// the client did not acknowledge the event in the given delay
		}
	})
})

func (*Socket) To 

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

Targets a room when broadcasting. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	// the “foo” event will be broadcast to all connected clients in the “room-101” room, except this socket
	socket.To("room-101").Emit("foo", "bar")

	// the code above is equivalent to:
	io.To("room-101").Except(Room(socket.Id())).Emit("foo", "bar")

	// with an array of rooms (a client will be notified at most once)
	socket.To([]Room{"room-101", "room-102"}...).Emit("foo", "bar")

	// with multiple chained calls
	socket.To("room-101").To("room-102").Emit("foo", "bar")
})

Param: Room - a `Room`, or a `Room` slice to expand Return: a new `*BroadcastOperator` instance for chaining

func (*Socket) Use 

func (s *Socket) Use(fn func([]any, func(error))) *Socket

Sets up socket middleware. 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Use(func(events []any, next func(error)) {
		if isUnauthorized(events[0]) {
			next(error.New("unauthorized event"))
			return
		}
		// do not forget to call next
		next(nil)
	})

	socket.On("error", func(errs ...any) {
		if err, ok := errs[0].(error); ok && err.Error() == "unauthorized event" {
			socket.Disconnect(false)
		}
	});
});

func (*Socket) Volatile 

func (s *Socket) Volatile() *Socket

Sets a modifier for a subsequent event emission that the event data may be lost if the client is not ready to receive messages (because of network slowness or other issues, or because they’re connected through long polling and is in the middle of a request-response cycle). 

io.On("connection", func(clients ...any) {
	socket := clients[0].(*socket.Socket)
	socket.Volatile().Emit("hello") // the client may or may not receive it
})

func (*Socket) Write 

func (s *Socket) Write(args ...any) *Socket

Sends a `message` event. Alias of Send.

type SocketDetails 

type SocketDetails interface {
	Id() SocketId
	Handshake() *Handshake
	Rooms() *types.Set[Room]
	Data() any
}

type SocketId 

type SocketId string

A public ID, sent by the server at the beginning of the Socket.IO session and which can be used for private messaging

type StrictEventEmitter 

type StrictEventEmitter struct {
	events.EventEmitter
}

Strictly typed version of an `EventEmitter`. A `TypedEventEmitter` takes type parameters for mappings of event names to event data types, and strictly types method calls to the `EventEmitter` according to these event maps.

func NewStrictEventEmitter 

func NewStrictEventEmitter() *StrictEventEmitter

func (*StrictEventEmitter) Emit 

func (s *StrictEventEmitter) Emit(ev string, args ...any)

Emits an event.

func (*StrictEventEmitter) EmitReserved 

func (s *StrictEventEmitter) EmitReserved(ev string, args ...any)

Emits a reserved event.

This method is `protected`, so that only a class extending `StrictEventEmitter` can emit its own reserved events.

func (*StrictEventEmitter) EmitUntyped 

func (s *StrictEventEmitter) EmitUntyped(ev string, args ...any)

Emits an event.

This method is `protected`, so that only a class extending `StrictEventEmitter` can get around the strict typing. This is useful for calling `emit.apply`, which can be called as `emitUntyped.apply`.

func (*StrictEventEmitter) Listeners 

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

Returns the listeners listening to an event.

func (*StrictEventEmitter) On 

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

Adds the `listener` function as an event listener for `ev`.

func (*StrictEventEmitter) Once 

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

type WriteOptions 

type WriteOptions struct {
	packet.Options

	Volatile     bool
	PreEncoded   bool
	WsPreEncoded string
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.