socketio

package module
Version: v0.0.0-...-e507d8c Latest Latest
Warning

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

Go to latest
Published: Apr 7, 2016 License: BSD-3-Clause Imports: 13 Imported by: 0

README

socket.io

GoDoc Build Status

go-socket.io is an implementation of socket.io in golang, which is a realtime application framework.

It is compatible with latest implementation of socket.io in node.js, and supports room and namespace.

  • for compatability with socket.io 0.9.x, please use branch 0.9.x *

Install

Install the package with:

go get github.com/nkovacs/go-socket.io

Import it with:

import "github.com/nkovacs/go-socket.io"

and use socketio as the package name inside the code.

Example

Please check the example folder for details.

package main

import (
	"log"
	"net/http"

	"github.com/nkovacs/go-socket.io"
)

func main() {
	server, err := socketio.NewServer(nil)
	if err != nil {
		log.Fatal(err)
	}
	server.On("connection", func(so socketio.Socket) {
		log.Println("on connection")
		so.Join("chat")
		so.On("chat message", func(msg string) {
			log.Println("emit:", so.Emit("chat message", msg))
			so.BroadcastTo("chat", "chat message", msg)
		})
		so.On("disconnection", func() {
			log.Println("on disconnect")
		})
	})
	server.On("error", func(so socketio.Socket, err error) {
		log.Println("error:", err)
	})

	http.Handle("/socket.io/", server)
	http.Handle("/", http.FileServer(http.Dir("./asset")))
	log.Println("Serving at localhost:5000...")
	log.Fatal(http.ListenAndServe(":5000", nil))
}

License

The 3-clause BSD License - see LICENSE for more details

Documentation

Overview

go-socket.io is a server implementation of socket.io in golang.

It is compatible with the official Node.js implementation.

Index

Constants

View Source
const Protocol = 4

Variables

This section is empty.

Functions

This section is empty.

Types

type Attachment

type Attachment struct {
	Data io.ReadWriter
	// contains filtered or unexported fields
}

Attachment is an attachment handler used in emit args. All attachments will be sent as binary data in the transport layer. When using an attachment, make sure it is a pointer.

For example:

type Arg struct {
    Title string `json:"title"`
    File *Attachment `json:"file"`
}

f, _ := os.Open("./some_file")
arg := Arg{
    Title: "some_file",
    File: &Attachment{
        Data: f,
    }
}

socket.Emit("send file", arg)
socket.On("get file", func(so Socket, arg Arg) {
    b, _ := ioutil.ReadAll(arg.File.Data)
})

func (Attachment) MarshalJSON

func (a Attachment) MarshalJSON() ([]byte, error)

func (*Attachment) UnmarshalJSON

func (a *Attachment) UnmarshalJSON(b []byte) error

type BroadcastAdaptor

type BroadcastAdaptor interface {

	// Join causes the socket to join a room.
	Join(room string, socket Socket) error

	// Leave causes the socket to leave a room.
	Leave(room string, socket Socket) error

	// Send will send an event with args to the room. If "ignore" is not nil, the event will be excluded from being sent to "ignore".
	Send(ignore Socket, room, event string, args ...interface{}) error
}

BroadcastAdaptor is the adaptor to handle broadcasts.

type Namespace

type Namespace interface {

	// Name returns the name of the namespace.
	Name() string

	// Of returns the namespace with given name.
	Of(name string) Namespace

	// On registers the function f to handle an event.
	On(event string, f interface{}) error
}

Namespace is the name space of a socket.io handler.

type Server

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

Server is the server of socket.io.

func NewServer

func NewServer(transportNames []string) (*Server, error)

NewServer returns the server supported given transports. If transports is nil, the server will use ["polling", "websocket"] as default.

func (*Server) BroadcastTo

func (s *Server) BroadcastTo(room, message string, args ...interface{})

BroadcastTo is a server level broadcast function.

func (*Server) Count

func (s *Server) Count() int

Count returns the current number of connected clients in session

func (*Server) GetMaxConnection

func (s *Server) GetMaxConnection() int

GetMaxConnection returns the current max connection

func (Server) Name

func (n Server) Name() string

func (Server) Of

func (n Server) Of(name string) Namespace

func (*Server) ServeHTTP

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP handles http requests.

func (*Server) SetAdaptor

func (s *Server) SetAdaptor(adaptor BroadcastAdaptor)

SetAdaptor sets the adaptor of broadcast. Default is an in-process broadcast implementation.

func (*Server) SetAllowRequest

func (s *Server) SetAllowRequest(f func(*http.Request) error)

SetAllowRequest sets the middleware function when a connection is established. If a non-nil value is returned, the connection won't be established. Default will allow all connections.

func (*Server) SetAllowUpgrades

func (s *Server) SetAllowUpgrades(allow bool)

SetAllowUpgrades sets whether server allows transport upgrades. Default is true.

func (*Server) SetCookie

func (s *Server) SetCookie(prefix string)

SetCookie sets the name of the cookie used by engine.io. Default is "io".

func (*Server) SetMaxConnection

func (s *Server) SetMaxConnection(n int)

SetMaxConnection sets the maximum number of connections with clients. Default is 1000.

func (*Server) SetNewId

func (s *Server) SetNewId(f func(*http.Request) string)

SetNewId sets the callback func to generate new connection id. By default, id is generated from remote address + current time stamp

func (*Server) SetPingInterval

func (s *Server) SetPingInterval(t time.Duration)

SetPingInterval sets the interval of pings. Default is 25s.

func (*Server) SetPingTimeout

func (s *Server) SetPingTimeout(t time.Duration)

SetPingTimeout sets the timeout of a connection ping. When it times out, the server will close the connection with the client. Default is 60s.

func (*Server) SetSessionManager

func (s *Server) SetSessionManager(sessions engineio.Sessions)

SetSessionsManager sets the sessions as server's session manager. Default sessions is a single process manager. You can customize it as a load balancer.

type Socket

type Socket interface {

	// Id returns the session id of socket.
	Id() string

	// Rooms returns the rooms name joined now.
	Rooms() []string

	// Request returns the first http request when established connection.
	Request() *http.Request

	// On registers the function f to handle an event.
	On(event string, f interface{}) error

	// Emit emits an event with given args.
	Emit(event string, args ...interface{}) error

	// Join joins the room.
	Join(room string) error

	// Leave leaves the room.
	Leave(room string) error

	// BroadcastTo broadcasts an event to the room with given args.
	BroadcastTo(room, event string, args ...interface{}) error
}

Socket is the socket object of socket.io.

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
t or T : Toggle theme light dark auto
y or Y : Canonical URL