engineio

README

go-engine.io

go-engine.io is the implement of engine.io in golang, which is transport-based cross-browser/cross-device bi-directional communication layer for go-socket.io.

It is compatible with node.js implement, and supported long-polling and websocket transport.

Install

Install the package with:

go get github.com/avayayu/go-socket.io/engineio@v1

Import it with:

import "github.com/avayayu/go-socket.io/engineio"

and use engineio as the package name inside the code.

Example

Please check example folder for details.

package main

import (
	"encoding/hex"
	"io/ioutil"
	"log"
	"net/http"

	"github.com/avayayu/go-socket.io/engineio"
)

func main() {
	server, _ := engineio.NewServer(nil)

	go func() {
		for {
			conn, _ := server.Accept()
			go func() {
				defer conn.Close()
				for {
					t, r, _ := conn.NextReader()
					b, _ := ioutil.ReadAll(r)
					r.Close()

					w, _ := conn.NextWriter(t)
					w.Write(b)
					w.Close()
				}
			}()
		}
	}()

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

License

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

Documentation

Index

• Constants
• type Conn
• type Dialer
  • func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (Conn, error)
• type FrameType
• type Options
• type Server
  • func NewServer(opts *Options) (*Server, error)
  • func (s *Server) Accept() (Conn, error)
  • func (s *Server) Close() error
  • func (s *Server) Count() int
  • func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request)
• type SessionIDGenerator

Examples

• Server

Constants

const (
	// TEXT is text type message.
	TEXT = FrameType(base.FrameString)
	// BINARY is binary type message.
	BINARY = FrameType(base.FrameBinary)
)

Types

type Conn

type Conn interface {
	ID() string
	NextReader() (FrameType, io.ReadCloser, error)
	NextWriter(typ FrameType) (io.WriteCloser, error)
	Close() error
	URL() url.URL
	LocalAddr() net.Addr
	RemoteAddr() net.Addr
	RemoteHeader() http.Header
	SetContext(v interface{})
	Context() interface{}
}

Conn is connection.

type Dialer

type Dialer struct {
	Transports []transport.Transport
}

Dialer is dialer configure.

func (*Dialer) Dial

func (d *Dialer) Dial(urlStr string, requestHeader http.Header) (Conn, error)

Dial returns a connection which dials to url with requestHeader.

type FrameType

type FrameType base.FrameType

FrameType is type of a message frame.

type Options

type Options struct {
	RequestChecker     func(*http.Request) (http.Header, error)
	ConnInitor         func(*http.Request, Conn)
	PingTimeout        time.Duration
	PingInterval       time.Duration
	Transports         []transport.Transport
	SessionIDGenerator SessionIDGenerator
}

Options is options to create a server.

type Server

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

Server is server.

Example

eio, err := NewServer(nil)
if err != nil {
	log.Fatalln("server error:", err)
}
httpSvr := httptest.NewServer(eio)
defer httpSvr.Close()

for {
	conn, err := eio.Accept()
	if err != nil {
		log.Fatalln("accept error:", err)
		return
	}
	go func(conn Conn) {
		defer conn.Close()
		fmt.Println(conn.ID(), conn.RemoteAddr(), "->", conn.LocalAddr(), "with", conn.RemoteHeader())

		for {
			typ, r, err := conn.NextReader()
			if err != nil {
				log.Fatalln("read error:", err)
				return
			}
			w, err := conn.NextWriter(typ)
			if err != nil {
				r.Close()
				log.Fatalln("write error:", err)
				return
			}
			_, err = io.Copy(w, r)
			if err != nil {
				r.Close()
				w.Close()
				log.Fatalln("copy error:", err)
				return
			}
			if err = w.Close(); err != nil {
				log.Fatalln("close writer error:", err)
				return
			}
			if err = r.Close(); err != nil {
				log.Fatalln("close reader error:", err)
				return
			}
		}
	}(conn)
}

func NewServer

func NewServer(opts *Options) (*Server, error)

NewServer returns a server.

func (*Server) Accept

func (s *Server) Accept() (Conn, error)

Accept accepts a connection.

func (*Server) Close

func (s *Server) Close() error

Close closes server.

func (*Server) Count

func (s *Server) Count() int

Count counts connected

func (*Server) ServeHTTP

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

type SessionIDGenerator

type SessionIDGenerator interface {
	NewID() string
}

SessionIDGenerator generates new session id. Default behavior is simple increasing number. If you need custom session id, for example using local ip as perfix, you can implement SessionIDGenerator and save in Configure. Engine.io will use custom one to generate new session id.