README
¶
golang socket.io 
golang socket.io is an implementation for the socket.io protocol in Go. There is a lack of specification for the socket.io protocol, so reverse engineering is the easiest way to find out how it works.
This is a work in progress. Many features, such as middleware and binary support, are missing.
golang socket.io is an adapted work from github.com/graarh/golang-socketio.
on "connection", "error", and "disconnection"
socket.io has three special events it triggers on the client-side and you should not emit them on your own programs.
Wait for the socket.io connection event before emitting messages or you risk losing them due in an unpredictable fashion (due to concurrency: connection latency, server load, etc.). For the default namespace this is automatically handled on gosocketio.Connect.
However, before emitting a message on a custom namespace, you want to wait for the ready signal, like so:
ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second)
defer cancel()
select {
case <-ctx.Done():
return ctx.Err()
case <-exampleNamespace.Ready():
// don't need to do anything
}
if err := exampleNamespace.Emit("fleet", 100); err != nil {
return err
}
The reason why you probably want to use a select receiving a second channel, such as context.Done() on all non-trivial programs is to avoid program loop, leak memory, or both in case of failure.
The default namespace is automatically ready after establishing the socket.io session. Therefore, *gosocketio.Client doesn't expose a Ready() method.
Connecting to a socket.io server with a custom namespace
You can connect to a namespace and start emitting messages to it with:
c, err := gosocketio.Connect(u, websocket.NewTransport())
if err != nil {
return err
}
// ...
exampleNamespace, err := c.Of("example")
If err != nil {
return err
}
<-exampleNamespace.Ready() // don't do this, use a select like shown above instead!
If err := exampleNamespace.Emit("list", "friends"); err != nil {
return err
}
Running the example
npm installto install the dependencies for the example servernode server.jsgo run example.go
If you need to improve this library you should consider using these tools:
This library is used by the WeDeploy Command-Line Interface tool to open a shell and execute commands on Docker container services.
Documentation
¶
Index ¶
- Constants
- type Client
- func (c *Client) Ack(ctx context.Context, method string, args interface{}, ret interface{}) error
- func (c *Client) Close()
- func (c *Client) Emit(method string, args ...interface{}) error
- func (c *Client) ID() string
- func (c *Client) Listeners() (list []string)
- func (c *Client) Of(namespace string) (*Namespace, error)
- func (c *Client) Off(method string)
- func (c *Client) On(method string, f interface{}) error
- func (c *Client) Run()
- type ErrorArgument
- type ErrorInvalidInterface
- type ErrorNotFunction
- type Handler
- type Header
- type Namespace
- func (n *Namespace) Ack(ctx context.Context, method string, args interface{}, v interface{}) error
- func (n *Namespace) Emit(method string, args ...interface{}) error
- func (n *Namespace) Listeners() (list []string)
- func (n *Namespace) Off(method string)
- func (n *Namespace) On(method string, f interface{}) error
- func (n *Namespace) Ready() <-chan struct{}
Constants ¶
const ( // OnConnection for "connection" messages. OnConnection = protocol.OnConnection // OnDisconnect for "disconnect" messages. OnDisconnect = protocol.OnDisconnect // OnError for "error" messages. OnError = protocol.OnError )
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Client ¶
type Client struct {
// contains filtered or unexported fields
}
Client to handle socket.io connections
func ConnectSync ¶
Connect dials and waits for the "connection" event. It blocks for the timeout duration. If the connection is not established in time, it closes the connection and returns an error.
func DialOnly ¶
DialOnly connects to the host and initializes the socket.io protocol. It doesn't wait for socket.io connection handshake. You probably want to use Connect instead. Only exposed for debugging.
type ErrorArgument ¶
type ErrorArgument struct {
// contains filtered or unexported fields
}
ErrorArgument is used when trying to create a non-function listener with an invalid parameter
func (ErrorArgument) Error ¶
func (e ErrorArgument) Error() string
type ErrorInvalidInterface ¶
type ErrorInvalidInterface struct {
// contains filtered or unexported fields
}
func (ErrorInvalidInterface) Error ¶
func (e ErrorInvalidInterface) Error() string
func (ErrorInvalidInterface) Method ¶
func (e ErrorInvalidInterface) Method() string
type ErrorNotFunction ¶
type ErrorNotFunction struct {
// contains filtered or unexported fields
}
ErrorNotFunction is used when trying to create a non-function listener
func (ErrorNotFunction) Error ¶
func (e ErrorNotFunction) Error() string
type Handler ¶
type Handler struct {
Func reflect.Value
Out bool
Variadic bool
// contains filtered or unexported fields
}
Handler for the message
func NewHandler ¶
NewHandler creates a new listener
type Header ¶
type Header struct {
Sid string `json:"sid"`
Upgrades []string `json:"upgrades"`
PingInterval int `json:"pingInterval"`
PingTimeout int `json:"pingTimeout"`
}
Header of engine.io to send and receive packets
type Namespace ¶
type Namespace struct {
// contains filtered or unexported fields
}
Namespace for the connection.
func NewNamespace ¶
NewNamespace creates a namespace.
Source Files
Directories