project initialized

socket/client-conn-handler.go

@@ -0,0 +1,64 @@
+package socket
+
+import (
+	"sync/atomic"
+	"time"
+
+	"git.loafle.net/overflow/server-go"
+)
+
+type ClientConnHandler interface {
+	server.ConnectionHandler
+
+	GetReconnectInterval() time.Duration
+	GetReconnectTryTime() int
+}
+
+type ClientConnHandlers struct {
+	server.ConnectionHandlers
+
+	ReconnectInterval time.Duration `json:"reconnectInterval,omitempty"`
+	ReconnectTryTime  int           `json:"reconnectTryTime,omitempty"`
+
+	validated atomic.Value
+}
+
+func (cch *ClientConnHandlers) GetReconnectInterval() time.Duration {
+	return cch.ReconnectInterval
+}
+
+func (cch *ClientConnHandlers) GetReconnectTryTime() int {
+	return cch.ReconnectTryTime
+}
+
+func (cch *ClientConnHandlers) Clone() *ClientConnHandlers {
+	return &ClientConnHandlers{
+		ConnectionHandlers: *cch.ConnectionHandlers.Clone(),
+		ReconnectInterval:  cch.ReconnectInterval,
+		ReconnectTryTime:   cch.ReconnectTryTime,
+		validated:          cch.validated,
+	}
+}
+
+func (cch *ClientConnHandlers) Validate() error {
+	if nil != cch.validated.Load() {
+		return nil
+	}
+	cch.validated.Store(true)
+
+	if err := cch.ConnectionHandlers.Validate(); nil != err {
+		return err
+	}
+
+	if cch.ReconnectInterval <= 0 {
+		cch.ReconnectInterval = server.DefaultReconnectInterval
+	} else {
+		cch.ReconnectInterval = cch.ReconnectInterval * time.Second
+	}
+
+	if cch.ReconnectTryTime <= 0 {
+		cch.ReconnectTryTime = server.DefaultReconnectTryTime
+	}
+
+	return nil
+}

socket/client-readwriter.go

@@ -0,0 +1,70 @@
+package socket
+
+import (
+	"io"
+	"sync"
+
+	olog "git.loafle.net/overflow/log-go"
+)
+
+type ClientReadWriter struct {
+	ReadwriteHandler ReadWriteHandler
+	ReadChan         chan<- SocketMessage
+	WriteChan        <-chan SocketMessage
+	DisconnectedChan chan<- struct{}
+	ReconnectedChan  <-chan Conn
+	ClientStopChan   <-chan struct{}
+	ClientStopWg     *sync.WaitGroup
+}
+
+func (crw *ClientReadWriter) HandleConnection(conn Conn) {
+
+	defer func() {
+		if nil != conn {
+			conn.Close()
+		}
+		olog.Logger().Info("disconnected")
+		crw.ClientStopWg.Done()
+	}()
+
+	olog.Logger().Info("connected")
+
+	var err error
+
+	for {
+		if nil != err {
+			if IsUnexpectedCloseError(err) || io.EOF == err || io.ErrUnexpectedEOF == err {
+				crw.DisconnectedChan <- struct{}{}
+				newConn := <-crw.ReconnectedChan
+				if nil == newConn {
+					return
+				}
+				conn = newConn
+			} else {
+				return
+			}
+		}
+
+		stopChan := make(chan struct{})
+
+		readerDoneChan := make(chan error)
+		writerDoneChan := make(chan error)
+
+		go connReadHandler(crw.ReadwriteHandler, conn, stopChan, readerDoneChan, crw.ReadChan)
+		go connWriteHandler(crw.ReadwriteHandler, conn, stopChan, writerDoneChan, crw.WriteChan)
+
+		select {
+		case err = <-readerDoneChan:
+			close(stopChan)
+			<-writerDoneChan
+		case err = <-writerDoneChan:
+			close(stopChan)
+			<-readerDoneChan
+		case <-crw.ClientStopChan:
+			close(stopChan)
+			<-readerDoneChan
+			<-writerDoneChan
+			return
+		}
+	}
+}

socket/client/client-ctx.go

@@ -0,0 +1,19 @@
+package client
+
+import (
+	ouc "git.loafle.net/overflow/util-go/ctx"
+)
+
+type ClientCtx interface {
+	ouc.Ctx
+}
+
+func NewClientCtx(parent ouc.Ctx) ClientCtx {
+	return &clientCtx{
+		Ctx: ouc.NewCtx(parent),
+	}
+}
+
+type clientCtx struct {
+	ouc.Ctx
+}

socket/client/client-handler.go

@@ -0,0 +1,72 @@
+package client
+
+import (
+	"fmt"
+	"sync/atomic"
+)
+
+type ClientHandler interface {
+	GetName() string
+	GetConnector() Connector
+
+	ClientCtx() ClientCtx
+
+	Init(clientCtx ClientCtx) error
+	OnStart(clientCtx ClientCtx) error
+	OnStop(clientCtx ClientCtx)
+	Destroy(clientCtx ClientCtx)
+
+	Validate() error
+}
+
+type ClientHandlers struct {
+	Name      string    `json:"name,omitempty"`
+	Connector Connector `json:"-"`
+
+	validated atomic.Value
+}
+
+func (ch *ClientHandlers) ClientCtx() ClientCtx {
+	return NewClientCtx(nil)
+}
+
+func (ch *ClientHandlers) Init(clientCtx ClientCtx) error {
+	return nil
+}
+
+func (ch *ClientHandlers) OnStart(clientCtx ClientCtx) error {
+	return nil
+}
+
+func (ch *ClientHandlers) OnStop(clientCtx ClientCtx) {
+
+}
+
+func (ch *ClientHandlers) Destroy(clientCtx ClientCtx) {
+
+}
+
+func (ch *ClientHandlers) GetName() string {
+	return ch.Name
+}
+
+func (ch *ClientHandlers) GetConnector() Connector {
+	return ch.Connector
+}
+
+func (ch *ClientHandlers) Validate() error {
+	if nil != ch.validated.Load() {
+		return nil
+	}
+	ch.validated.Store(true)
+
+	if nil == ch.Connector {
+		return fmt.Errorf("Connector is not valid")
+	}
+
+	if err := ch.Connector.Validate(); nil != err {
+		return err
+	}
+
+	return nil
+}

socket/client/connector.go

@@ -0,0 +1,75 @@
+package client
+
+import (
+	"sync/atomic"
+
+	"git.loafle.net/overflow/server-go/socket"
+)
+
+type OnDisconnectedFunc func(connector Connector)
+
+type Connector interface {
+	socket.ClientConnHandler
+	socket.ReadWriteHandler
+
+	Connect() (readChan <-chan socket.SocketMessage, writeChan chan<- socket.SocketMessage, err error)
+	Disconnect() error
+
+	GetName() string
+	GetOnDisconnected() OnDisconnectedFunc
+	SetOnDisconnected(fnc OnDisconnectedFunc)
+
+	Clone() Connector
+	Validate() error
+}
+
+type Connectors struct {
+	socket.ClientConnHandlers
+	socket.ReadWriteHandlers
+
+	Name           string             `json:"name,omitempty"`
+	OnDisconnected OnDisconnectedFunc `json:"-"`
+
+	validated atomic.Value
+}
+
+func (c *Connectors) GetName() string {
+	return c.Name
+}
+
+func (c *Connectors) GetOnDisconnected() OnDisconnectedFunc {
+	return c.OnDisconnected
+}
+
+func (c *Connectors) SetOnDisconnected(fnc OnDisconnectedFunc) {
+	c.OnDisconnected = fnc
+}
+
+func (c *Connectors) Clone() *Connectors {
+	return &Connectors{
+		Name:               c.Name,
+		ClientConnHandlers: *c.ClientConnHandlers.Clone(),
+		ReadWriteHandlers:  *c.ReadWriteHandlers.Clone(),
+		validated:          c.validated,
+	}
+}
+
+func (c *Connectors) Validate() error {
+	if nil != c.validated.Load() {
+		return nil
+	}
+	c.validated.Store(true)
+
+	if err := c.ClientConnHandlers.Validate(); nil != err {
+		return err
+	}
+	if err := c.ReadWriteHandlers.Validate(); nil != err {
+		return err
+	}
+
+	if "" == c.Name {
+		c.Name = "Connector"
+	}
+
+	return nil
+}

socket/conn-compression.go

@@ -0,0 +1,147 @@
+package socket
+
+import (
+	"compress/flate"
+	"errors"
+	"io"
+	"strings"
+	"sync"
+)
+
+const (
+	minCompressionLevel         = -2 // flate.HuffmanOnly not defined in Go < 1.6
+	maxCompressionLevel         = flate.BestCompression
+	defaultCompressionLevel     = 1
+	defaultCompressionThreshold = 1024
+)
+
+var (
+	flateWriterPools [maxCompressionLevel - minCompressionLevel + 1]sync.Pool
+	flateReaderPool  = sync.Pool{New: func() interface{} {
+		return flate.NewReader(nil)
+	}}
+)
+
+func DecompressNoContextTakeover(r io.Reader) io.ReadCloser {
+	const tail =
+	// Add four bytes as specified in RFC
+	"\x00\x00\xff\xff" +
+		// Add final block to squelch unexpected EOF error from flate reader.
+		"\x01\x00\x00\xff\xff"
+
+	fr, _ := flateReaderPool.Get().(io.ReadCloser)
+	fr.(flate.Resetter).Reset(io.MultiReader(r, strings.NewReader(tail)), nil)
+	return &flateReadWrapper{fr}
+}
+
+func IsValidCompressionLevel(level int) bool {
+	return minCompressionLevel <= level && level <= maxCompressionLevel
+}
+
+func CompressNoContextTakeover(w io.WriteCloser, level int) io.WriteCloser {
+	p := &flateWriterPools[level-minCompressionLevel]
+	tw := &truncWriter{w: w}
+	fw, _ := p.Get().(*flate.Writer)
+	if fw == nil {
+		fw, _ = flate.NewWriter(tw, level)
+	} else {
+		fw.Reset(tw)
+	}
+
+	return &flateWriteWrapper{fw: fw, tw: tw, p: p}
+}
+
+// truncWriter is an io.Writer that writes all but the last four bytes of the
+// stream to another io.Writer.
+type truncWriter struct {
+	w io.WriteCloser
+	n int
+	p [4]byte
+}
+
+func (w *truncWriter) Write(p []byte) (int, error) {
+	n := 0
+
+	// fill buffer first for simplicity.
+	if w.n < len(w.p) {
+		n = copy(w.p[w.n:], p)
+		p = p[n:]
+		w.n += n
+		if len(p) == 0 {
+			return n, nil
+		}
+	}
+
+	m := len(p)
+	if m > len(w.p) {
+		m = len(w.p)
+	}
+
+	if nn, err := w.w.Write(w.p[:m]); err != nil {
+		return n + nn, err
+	}
+
+	copy(w.p[:], w.p[m:])
+	copy(w.p[len(w.p)-m:], p[len(p)-m:])
+	nn, err := w.w.Write(p[:len(p)-m])
+	return n + nn, err
+}
+
+type flateWriteWrapper struct {
+	fw *flate.Writer
+	tw *truncWriter
+	p  *sync.Pool
+}
+
+func (w *flateWriteWrapper) Write(p []byte) (int, error) {
+	if w.fw == nil {
+		return 0, errWriteClosed
+	}
+
+	return w.fw.Write(p)
+}
+
+func (w *flateWriteWrapper) Close() error {
+	if w.fw == nil {
+		return errWriteClosed
+	}
+	err1 := w.fw.Flush()
+	w.p.Put(w.fw)
+	w.fw = nil
+	if w.tw.p != [4]byte{0, 0, 0xff, 0xff} {
+		return errors.New("websocket: internal error, unexpected bytes at end of flate stream")
+	}
+	err2 := w.tw.w.Close()
+	if err1 != nil {
+		return err1
+	}
+	return err2
+}
+
+type flateReadWrapper struct {
+	fr io.ReadCloser
+}
+
+func (r *flateReadWrapper) Read(p []byte) (int, error) {
+	if r.fr == nil {
+		return 0, io.ErrClosedPipe
+	}
+	n, err := r.fr.Read(p)
+	if err == io.EOF {
+		// Preemptively place the reader back in the pool. This helps with
+		// scenarios where the application does not call NextReader() soon after
+		// this final read.
+		r.Close()
+	}
+	return n, err
+}
+
+func (r *flateReadWrapper) Close() error {
+	if r.fr == nil {
+		return io.ErrClosedPipe
+	}
+	err := r.fr.Close()
+	flateReaderPool.Put(r.fr)
+	r.fr = nil
+	return err
+}

socket/conn-error.go

@@ -0,0 +1,111 @@
+package socket
+
+import (
+	"errors"
+	"io"
+	"strconv"
+)
+
+// ErrCloseSent is returned when the application writes a message to the
+// connection after sending a close message.
+var ErrCloseSent = errors.New("socket: close sent")
+
+// ErrReadLimit is returned when reading a message that is larger than the
+// read limit set for the connection.
+var ErrReadLimit = errors.New("socket: read limit exceeded")
+
+// netError satisfies the net Error interface.
+type netError struct {
+	msg       string
+	temporary bool
+	timeout   bool
+}
+
+func (e *netError) Error() string   { return e.msg }
+func (e *netError) Temporary() bool { return e.temporary }
+func (e *netError) Timeout() bool   { return e.timeout }
+
+// CloseError represents close frame.
+type CloseError struct {
+
+	// Code is defined in RFC 6455, section 11.7.
+	Code int
+
+	// Text is the optional text payload.
+	Text string
+}
+
+func (e *CloseError) Error() string {
+	s := []byte("socket: close ")
+	s = strconv.AppendInt(s, int64(e.Code), 10)
+	switch e.Code {
+	case CloseNormalClosure:
+		s = append(s, " (normal)"...)
+	case CloseGoingAway:
+		s = append(s, " (going away)"...)
+	case CloseProtocolError:
+		s = append(s, " (protocol error)"...)
+	case CloseUnsupportedData:
+		s = append(s, " (unsupported data)"...)
+	case CloseNoStatusReceived:
+		s = append(s, " (no status)"...)
+	case CloseAbnormalClosure:
+		s = append(s, " (abnormal closure)"...)
+	case CloseInvalidFramePayloadData:
+		s = append(s, " (invalid payload data)"...)
+	case ClosePolicyViolation:
+		s = append(s, " (policy violation)"...)
+	case CloseMessageTooBig:
+		s = append(s, " (message too big)"...)
+	case CloseMandatoryExtension:
+		s = append(s, " (mandatory extension missing)"...)
+	case CloseInternalServerErr:
+		s = append(s, " (internal server error)"...)
+	case CloseTLSHandshake:
+		s = append(s, " (TLS handshake error)"...)
+	}
+	if e.Text != "" {
+		s = append(s, ": "...)
+		s = append(s, e.Text...)
+	}
+	return string(s)
+}
+
+// IsCloseError returns boolean indicating whether the error is a *CloseError
+// with one of the specified codes.
+func IsCloseError(err error, codes ...int) bool {
+	if e, ok := err.(*CloseError); ok {
+		for _, code := range codes {
+			if e.Code == code {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// IsUnexpectedCloseError returns boolean indicating whether the error is a
+// *CloseError with a code not in the list of expected codes.
+func IsUnexpectedCloseError(err error, expectedCodes ...int) bool {
+	if e, ok := err.(*CloseError); ok {
+		for _, code := range expectedCodes {
+			if e.Code == code {
+				return false
+			}
+		}
+		return true
+	}
+	return false
+}
+
+var (
+	errWriteTimeout        = &netError{msg: "socket: write timeout", timeout: true, temporary: true}
+	errUnexpectedEOF       = &CloseError{Code: CloseAbnormalClosure, Text: io.ErrUnexpectedEOF.Error()}
+	errBadWriteOpCode      = errors.New("socket: bad write message type")
+	errWriteClosed         = errors.New("socket: write closed")
+	errInvalidControlFrame = errors.New("socket: invalid control frame")
+	// ErrBadHandshake is returned when the server response to opening handshake is
+	// invalid.
+	ErrBadHandshake       = errors.New("socket: bad handshake")
+	ErrInvalidCompression = errors.New("socket: invalid compression negotiation")
+)

socket/conn-json.go

@@ -0,0 +1,55 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package socket
+
+import (
+	"encoding/json"
+	"io"
+)
+
+// WriteJSON is deprecated, use c.WriteJSON instead.
+func WriteJSON(c *SocketConn, v interface{}) error {
+	return c.WriteJSON(v)
+}
+
+// WriteJSON writes the JSON encoding of v to the connection.
+//
+// See the documentation for encoding/json Marshal for details about the
+// conversion of Go values to JSON.
+func (c *SocketConn) WriteJSON(v interface{}) error {
+	w, err := c.NextWriter(TextMessage)
+	if err != nil {
+		return err
+	}
+	err1 := json.NewEncoder(w).Encode(v)
+	err2 := w.Close()
+	if err1 != nil {
+		return err1
+	}
+	return err2
+}
+
+// ReadJSON is deprecated, use c.ReadJSON instead.
+func ReadJSON(c *SocketConn, v interface{}) error {
+	return c.ReadJSON(v)
+}
+
+// ReadJSON reads the next JSON-encoded message from the connection and stores
+// it in the value pointed to by v.
+//
+// See the documentation for the encoding/json Unmarshal function for details
+// about the conversion of JSON to a Go value.
+func (c *SocketConn) ReadJSON(v interface{}) error {
+	_, r, err := c.NextReader()
+	if err != nil {
+		return err
+	}
+	err = json.NewDecoder(r).Decode(v)
+	if err == io.EOF {
+		// One value is expected in the message.
+		err = io.ErrUnexpectedEOF
+	}
+	return err
+}

socket/conn-mask.go

@@ -0,0 +1,49 @@
+package socket
+
+import "unsafe"
+
+const wordSize = int(unsafe.Sizeof(uintptr(0)))
+
+func maskBytes(key [4]byte, pos int, b []byte) int {
+
+	// Mask one byte at a time for small buffers.
+	if len(b) < 2*wordSize {
+		for i := range b {
+			b[i] ^= key[pos&3]
+			pos++
+		}
+		return pos & 3
+	}
+
+	// Mask one byte at a time to word boundary.
+	if n := int(uintptr(unsafe.Pointer(&b[0]))) % wordSize; n != 0 {
+		n = wordSize - n
+		for i := range b[:n] {
+			b[i] ^= key[pos&3]
+			pos++
+		}
+		b = b[n:]
+	}
+
+	// Create aligned word size key.
+	var k [wordSize]byte
+	for i := range k {
+		k[i] = key[(pos+i)&3]
+	}
+	kw := *(*uintptr)(unsafe.Pointer(&k))
+
+	// Mask one word at a time.
+	n := (len(b) / wordSize) * wordSize
+	for i := 0; i < n; i += wordSize {
+		*(*uintptr)(unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(i))) ^= kw
+	}
+
+	// Mask one byte at a time for remaining bytes.
+	b = b[n:]
+	for i := range b {
+		b[i] ^= key[pos&3]
+		pos++
+	}
+
+	return pos & 3
+}

socket/conn-prepared.go

@@ -0,0 +1,100 @@
+package socket
+
+import (
+	"bytes"
+	"net"
+	"sync"
+	"time"
+)
+
+// PreparedMessage caches on the wire representations of a message payload.
+// Use PreparedMessage to efficiently send a message payload to multiple
+// connections. PreparedMessage is especially useful when compression is used
+// because the CPU and memory expensive compression operation can be executed
+// once for a given set of compression options.
+type PreparedMessage struct {
+	messageType int
+	data        []byte
+	err         error
+	mu          sync.Mutex
+	frames      map[prepareKey]*preparedFrame
+}
+
+// prepareKey defines a unique set of options to cache prepared frames in PreparedMessage.
+type prepareKey struct {
+	isServer         bool
+	compress         bool
+	compressionLevel int
+}
+
+// preparedFrame contains data in wire representation.
+type preparedFrame struct {
+	once sync.Once
+	data []byte
+}
+
+// NewPreparedMessage returns an initialized PreparedMessage. You can then send
+// it to connection using WritePreparedMessage method. Valid wire
+// representation will be calculated lazily only once for a set of current
+// connection options.
+func NewPreparedMessage(messageType int, data []byte) (*PreparedMessage, error) {
+	pm := &PreparedMessage{
+		messageType: messageType,
+		frames:      make(map[prepareKey]*preparedFrame),
+		data:        data,
+	}
+
+	// Prepare a plain server frame.
+	_, frameData, err := pm.frame(prepareKey{isServer: true, compress: false})
+	if err != nil {
+		return nil, err
+	}
+
+	// To protect against caller modifying the data argument, remember the data
+	// copied to the plain server frame.
+	pm.data = frameData[len(frameData)-len(data):]
+	return pm, nil
+}
+
+func (pm *PreparedMessage) frame(key prepareKey) (int, []byte, error) {
+	pm.mu.Lock()
+	frame, ok := pm.frames[key]
+	if !ok {
+		frame = &preparedFrame{}
+		pm.frames[key] = frame
+	}
+	pm.mu.Unlock()
+
+	var err error
+	frame.once.Do(func() {
+		// Prepare a frame using a 'fake' connection.
+		// TODO: Refactor code in conn.go to allow more direct construction of
+		// the frame.
+		mu := make(chan bool, 1)
+		mu <- true
+		var nc prepareConn
+		c := &SocketConn{
+			conn:                   &nc,
+			mu:                     mu,
+			isServer:               key.isServer,
+			compressionLevel:       key.compressionLevel,
+			enableWriteCompression: true,
+			writeBuf:               make([]byte, defaultWriteBufferSize+maxFrameHeaderSize),
+		}
+
+		if key.compress {
+			c.newCompressionWriter = CompressNoContextTakeover
+		}
+		err = c.WriteMessage(pm.messageType, pm.data)
+		frame.data = nc.buf.Bytes()
+	})
+	return pm.messageType, frame.data, err
+}
+
+type prepareConn struct {
+	buf bytes.Buffer
+	net.Conn
+}
+
+func (pc *prepareConn) Write(p []byte) (int, error)        { return pc.buf.Write(p) }
+func (pc *prepareConn) SetWriteDeadline(t time.Time) error { return nil }

socket/conn-read.go

@@ -0,0 +1,18 @@
+// Copyright 2016 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build go1.5
+
+package socket
+
+import "io"
+
+func (c *SocketConn) read(n int) ([]byte, error) {
+	p, err := c.BuffReader.Peek(n)
+	if err == io.EOF {
+		err = errUnexpectedEOF
+	}
+	c.BuffReader.Discard(len(p))
+	return p, err
+}

socket/net/client/connector.go

@@ -0,0 +1,219 @@
+package client
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	olog "git.loafle.net/overflow/log-go"
+	"git.loafle.net/overflow/server-go/socket"
+	"git.loafle.net/overflow/server-go/socket/client"
+)
+
+type Connectors struct {
+	client.Connectors
+
+	Network      string   `json:"network,omitempty"`
+	Address      string   `json:"address,omitempty"`
+	LocalAddress net.Addr `json:"-"`
+
+	stopChan chan struct{}
+	stopWg   sync.WaitGroup
+
+	readChan  chan socket.SocketMessage
+	writeChan chan socket.SocketMessage
+
+	disconnectedChan chan struct{}
+	reconnectedChan  chan socket.Conn
+
+	crw socket.ClientReadWriter
+
+	validated atomic.Value
+}
+
+func (c *Connectors) Connect() (readChan <-chan socket.SocketMessage, writeChan chan<- socket.SocketMessage, err error) {
+	var (
+		conn socket.Conn
+	)
+
+	if nil != c.stopChan {
+		return nil, nil, fmt.Errorf("%s already connected", c.logHeader())
+	}
+
+	conn, err = c.connect()
+	if nil != err {
+		return nil, nil, err
+	}
+
+	c.readChan = make(chan socket.SocketMessage, 256)
+	c.writeChan = make(chan socket.SocketMessage, 256)
+	c.disconnectedChan = make(chan struct{})
+	c.reconnectedChan = make(chan socket.Conn)
+	c.stopChan = make(chan struct{})
+
+	c.crw.ReadwriteHandler = c
+	c.crw.ReadChan = c.readChan
+	c.crw.WriteChan = c.writeChan
+	c.crw.ClientStopChan = c.stopChan
+	c.crw.ClientStopWg = &c.stopWg
+	c.crw.DisconnectedChan = c.disconnectedChan
+	c.crw.ReconnectedChan = c.reconnectedChan
+
+	c.stopWg.Add(1)
+	go c.handleReconnect()
+	c.stopWg.Add(1)
+	go c.crw.HandleConnection(conn)
+
+	return c.readChan, c.writeChan, nil
+}
+
+func (c *Connectors) Disconnect() error {
+	if c.stopChan == nil {
+		return fmt.Errorf("%s must be connected before disconnection it", c.logHeader())
+	}
+	close(c.stopChan)
+	c.stopWg.Wait()
+
+	c.stopChan = nil
+
+	return nil
+}
+
+func (c *Connectors) logHeader() string {
+	return fmt.Sprintf("Connector[%s]: ", c.Name)
+}
+
+func (c *Connectors) onDisconnected() {
+	close(c.readChan)
+	close(c.writeChan)
+
+	c.reconnectedChan <- nil
+
+	onDisconnected := c.OnDisconnected
+	if nil != onDisconnected {
+		go func() {
+			onDisconnected(c)
+		}()
+	}
+}
+
+func (c *Connectors) handleReconnect() {
+	defer func() {
+		c.stopWg.Done()
+	}()
+
+RC_LOOP:
+	for {
+		select {
+		case <-c.disconnectedChan:
+		case <-c.stopChan:
+			return
+		}
+
+		if 0 >= c.GetReconnectTryTime() {
+			c.onDisconnected()
+			return
+		}
+
+		olog.Logger().Debugf("%s connection lost", c.logHeader())
+
+		for indexI := 0; indexI < c.GetReconnectTryTime(); indexI++ {
+			olog.Logger().Debugf("%s trying reconnect[%d]", c.logHeader(), indexI)
+
+			conn, err := c.connect()
+			if nil == err {
+				olog.Logger().Debugf("reconnected")
+				c.reconnectedChan <- conn
+				continue RC_LOOP
+			}
+			time.Sleep(c.GetReconnectInterval())
+		}
+
+		olog.Logger().Debugf("%s reconnecting has been failed", c.logHeader())
+		c.onDisconnected()
+		return
+	}
+}
+
+func (c *Connectors) connect() (socket.Conn, error) {
+	netConn, err := c.dial()
+	if nil != err {
+		return nil, err
+	}
+
+	conn := socket.NewConn(netConn, false, c.GetReadBufferSize(), c.GetWriteBufferSize())
+	conn.SetCloseHandler(func(code int, text string) error {
+		olog.Logger().Debugf("%s close", c.logHeader())
+		return nil
+	})
+	return conn, nil
+}
+
+func (c *Connectors) dial() (net.Conn, error) {
+	var deadline time.Time
+	if 0 != c.GetHandshakeTimeout() {
+		deadline = time.Now().Add(c.GetHandshakeTimeout())
+	}
+
+	d := &net.Dialer{
+		KeepAlive: c.GetKeepAlive(),
+		Deadline:  deadline,
+		LocalAddr: c.LocalAddress,
+	}
+
+	conn, err := d.Dial(c.Network, c.Address)
+	if nil != err {
+		return nil, err
+	}
+
+	if nil != c.GetTLSConfig() {
+		cfg := c.GetTLSConfig().Clone()
+		tlsConn := tls.Client(conn, cfg)
+		if err := tlsConn.Handshake(); err != nil {
+			tlsConn.Close()
+			return nil, err
+		}
+		if !cfg.InsecureSkipVerify {
+			if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
+				return nil, err
+			}
+		}
+		conn = tlsConn
+	}
+
+	return conn, nil
+}
+
+func (c *Connectors) Clone() client.Connector {
+	return &Connectors{
+		Connectors:   *c.Connectors.Clone(),
+		Network:      c.Network,
+		Address:      c.Address,
+		LocalAddress: c.LocalAddress,
+		validated:    c.validated,
+	}
+}
+
+func (c *Connectors) Validate() error {
+	if nil != c.validated.Load() {
+		return nil
+	}
+	c.validated.Store(true)
+
+	if err := c.Connectors.Validate(); nil != err {
+		return err
+	}
+
+	if "" == c.Network {
+		return fmt.Errorf("%s Network is not valid", c.logHeader())
+	}
+
+	if "" == c.Address {
+		return fmt.Errorf("%s Address is not valid", c.logHeader())
+	}
+
+	return nil
+}

socket/net/server-handler.go

@@ -0,0 +1,94 @@
+package net
+
+import (
+	"net"
+	"sync/atomic"
+
+	"git.loafle.net/overflow/server-go"
+	"git.loafle.net/overflow/server-go/socket"
+)
+
+type ServerHandler interface {
+	socket.ServerHandler
+
+	OnError(serverCtx server.ServerCtx, conn net.Conn, status int, reason error)
+
+	RegisterServlet(servlet Servlet)
+	Servlet(serverCtx server.ServerCtx, conn net.Conn) Servlet
+}
+
+type ServerHandlers struct {
+	socket.ServerHandlers
+
+	servlet Servlet
+
+	validated atomic.Value
+}
+
+func (sh *ServerHandlers) Init(serverCtx server.ServerCtx) error {
+	if err := sh.ServerHandlers.Init(serverCtx); nil != err {
+		return err
+	}
+
+	if nil != sh.servlet {
+		if err := sh.servlet.Init(serverCtx); nil != err {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (sh *ServerHandlers) OnStart(serverCtx server.ServerCtx) error {
+	if err := sh.ServerHandlers.OnStart(serverCtx); nil != err {
+		return err
+	}
+
+	if nil != sh.servlet {
+		if err := sh.servlet.OnStart(serverCtx); nil != err {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (sh *ServerHandlers) OnStop(serverCtx server.ServerCtx) {
+	if nil != sh.servlet {
+		sh.servlet.OnStop(serverCtx)
+	}
+
+	sh.ServerHandlers.OnStop(serverCtx)
+}
+
+func (sh *ServerHandlers) Destroy(serverCtx server.ServerCtx) {
+	if nil != sh.servlet {
+		sh.servlet.Destroy(serverCtx)
+	}
+
+	sh.ServerHandlers.Destroy(serverCtx)
+}
+
+func (sh *ServerHandlers) OnError(serverCtx server.ServerCtx, conn net.Conn, status int, reason error) {
+}
+
+func (sh *ServerHandlers) RegisterServlet(servlet Servlet) {
+	sh.servlet = servlet
+}
+
+func (sh *ServerHandlers) Servlet(serverCtx server.ServerCtx, conn net.Conn) Servlet {
+	return sh.servlet
+}
+
+func (sh *ServerHandlers) Validate() error {
+	if nil != sh.validated.Load() {
+		return nil
+	}
+	sh.validated.Store(true)
+
+	if err := sh.ServerHandlers.Validate(); nil != err {
+		return err
+	}
+
+	return nil
+}

socket/net/server.go

@@ -0,0 +1,167 @@
+package net
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	olog "git.loafle.net/overflow/log-go"
+	"git.loafle.net/overflow/server-go"
+	"git.loafle.net/overflow/server-go/socket"
+)
+
+type Server struct {
+	ServerHandler ServerHandler
+
+	ctx      server.ServerCtx
+	stopChan chan struct{}
+	stopWg   sync.WaitGroup
+
+	srw socket.ServerReadWriter
+}
+
+func (s *Server) ListenAndServe() error {
+	if s.stopChan != nil {
+		return fmt.Errorf("%s already running. Stop it before starting it again", s.logHeader())
+	}
+
+	var (
+		err      error
+		listener net.Listener
+	)
+	if nil == s.ServerHandler {
+		return fmt.Errorf("%s server handler must be specified", s.logHeader())
+	}
+	if err = s.ServerHandler.Validate(); nil != err {
+		return err
+	}
+
+	s.ctx = s.ServerHandler.ServerCtx()
+	if nil == s.ctx {
+		return fmt.Errorf("%s ServerCtx is nil", s.logHeader())
+	}
+
+	if err = s.ServerHandler.Init(s.ctx); nil != err {
+		return err
+	}
+
+	if listener, err = s.ServerHandler.Listener(s.ctx); nil != err {
+		return err
+	}
+
+	s.stopChan = make(chan struct{})
+
+	s.srw.ReadwriteHandler = s.ServerHandler
+	s.srw.ServerStopChan = s.stopChan
+	s.srw.ServerStopWg = &s.stopWg
+
+	s.stopWg.Add(1)
+	return s.handleServer(listener)
+}
+
+func (s *Server) Shutdown(ctx context.Context) error {
+	if s.stopChan == nil {
+		return fmt.Errorf("%s must be started before stopping it", s.logHeader())
+	}
+	close(s.stopChan)
+	s.stopWg.Wait()
+
+	s.ServerHandler.Destroy(s.ctx)
+
+	s.stopChan = nil
+
+	return nil
+}
+
+func (s *Server) logHeader() string {
+	return fmt.Sprintf("Server[%s]:", s.ServerHandler.GetName())
+}
+
+func (s *Server) handleServer(listener net.Listener) error {
+	var (
+		stopping atomic.Value
+		netConn  net.Conn
+		err      error
+	)
+
+	defer func() {
+		if nil != listener {
+			listener.Close()
+		}
+		s.ServerHandler.OnStop(s.ctx)
+		olog.Logger().Infof("%s Stopped", s.logHeader())
+		s.stopWg.Done()
+	}()
+
+	if err = s.ServerHandler.OnStart(s.ctx); nil != err {
+		return err
+	}
+
+	olog.Logger().Infof("%s Started", s.logHeader())
+
+	for {
+		acceptChan := make(chan struct{})
+
+		go func() {
+			if netConn, err = listener.Accept(); err != nil {
+				if nil == stopping.Load() {
+					olog.Logger().Errorf("%s %v", s.logHeader(), err)
+				}
+			}
+			close(acceptChan)
+		}()
+
+		select {
+		case <-s.stopChan:
+			stopping.Store(true)
+			listener.Close()
+			<-acceptChan
+			listener = nil
+			return nil
+		case <-acceptChan:
+		}
+
+		if nil != err {
+			select {
+			case <-s.stopChan:
+				return nil
+			case <-time.After(time.Second):
+			}
+			continue
+		}
+
+		if 0 < s.ServerHandler.GetConcurrency() {
+			sz := s.srw.ConnectionSize()
+			if sz >= s.ServerHandler.GetConcurrency() {
+				olog.Logger().Warnf("%s max connections size %d, refuse", s.logHeader(), sz)
+				netConn.Close()
+				continue
+			}
+		}
+
+		servlet := s.ServerHandler.(ServerHandler).Servlet(s.ctx, netConn)
+		if nil == servlet {
+			olog.Logger().Errorf("%s Servlet is nil", s.logHeader())
+			continue
+		}
+
+		servletCtx := servlet.ServletCtx(s.ctx)
+		if nil == servletCtx {
+			olog.Logger().Errorf("%s ServletCtx is nil", s.logHeader())
+			continue
+		}
+
+		if err := servlet.Handshake(servletCtx, netConn); nil != err {
+			olog.Logger().Infof("%s Handshaking of Client[%s] has been failed %v", s.logHeader(), netConn.RemoteAddr(), err)
+			continue
+		}
+
+		conn := socket.NewConn(netConn, true, s.ServerHandler.GetReadBufferSize(), s.ServerHandler.GetWriteBufferSize())
+
+		s.stopWg.Add(1)
+		go s.srw.HandleConnection(servlet, servletCtx, conn)
+	}
+}

socket/net/servlet.go

@@ -0,0 +1,54 @@
+package net
+
+import (
+	"net"
+
+	"git.loafle.net/overflow/server-go"
+	"git.loafle.net/overflow/server-go/socket"
+)
+
+type Servlet interface {
+	socket.Servlet
+
+	Handshake(servletCtx server.ServletCtx, conn net.Conn) error
+}
+
+type Servlets struct {
+	Servlet
+}
+
+func (s *Servlets) ServletCtx(serverCtx server.ServerCtx) server.ServletCtx {
+	return server.NewServletContext(nil, serverCtx)
+}
+
+func (s *Servlets) Init(serverCtx server.ServerCtx) error {
+	return nil
+}
+
+func (s *Servlets) OnStart(serverCtx server.ServerCtx) error {
+	return nil
+}
+
+func (s *Servlets) OnStop(serverCtx server.ServerCtx) {
+	//
+}
+
+func (s *Servlets) Destroy(serverCtx server.ServerCtx) {
+	//
+}
+
+func (s *Servlets) Handshake(servletCtx server.ServletCtx, conn net.Conn) error {
+	return nil
+}
+
+func (s *Servlets) OnConnect(servletCtx server.ServletCtx, conn socket.Conn) {
+	//
+}
+
+func (s *Servlets) Handle(servletCtx server.ServletCtx, stopChan <-chan struct{}, doneChan chan<- struct{}, readChan <-chan socket.SocketMessage, writeChan chan<- socket.SocketMessage) {
+
+}
+
+func (s *Servlets) OnDisconnect(servletCtx server.ServletCtx) {
+	//
+}

socket/readwrite-handler.go

@@ -0,0 +1,107 @@
+package socket
+
+import (
+	"errors"
+	"sync/atomic"
+	"time"
+
+	"git.loafle.net/overflow/server-go"
+)
+
+type ReadWriteHandler interface {
+	server.ReadWriteHandler
+	GetPongTimeout() time.Duration
+	GetPingTimeout() time.Duration
+	GetPingPeriod() time.Duration
+
+	IsEnableCompression() bool
+	GetCompressionLevel() int
+	GetCompressionThreshold() int
+}
+
+type ReadWriteHandlers struct {
+	server.ReadWriteHandlers
+
+	PongTimeout time.Duration `json:"pongTimeout,omitempty"`
+	PingTimeout time.Duration `json:"pingTimeout,omitempty"`
+	PingPeriod  time.Duration `json:"pingPeriod,omitempty"`
+
+	EnableCompression    bool `json:"enableCompression,omitempty"`
+	CompressionLevel     int  `json:"compressionLevel,omitempty"`
+	CompressionThreshold int  `json:"compressionThreshold,omitempty"`
+
+	validated atomic.Value
+}
+
+func (rwh *ReadWriteHandlers) GetPongTimeout() time.Duration {
+	return rwh.PongTimeout
+}
+func (rwh *ReadWriteHandlers) GetPingTimeout() time.Duration {
+	return rwh.PingTimeout
+}
+func (rwh *ReadWriteHandlers) GetPingPeriod() time.Duration {
+	return rwh.PingPeriod
+}
+
+func (rwh *ReadWriteHandlers) IsEnableCompression() bool {
+	return rwh.EnableCompression
+}
+func (rwh *ReadWriteHandlers) GetCompressionLevel() int {
+	return rwh.CompressionLevel
+}
+func (rwh *ReadWriteHandlers) GetCompressionThreshold() int {
+	return rwh.CompressionThreshold
+}
+
+func (rwh *ReadWriteHandlers) Clone() *ReadWriteHandlers {
+	return &ReadWriteHandlers{
+		ReadWriteHandlers:    *rwh.ReadWriteHandlers.Clone(),
+		PongTimeout:          rwh.PongTimeout,
+		PingTimeout:          rwh.PingTimeout,
+		PingPeriod:           rwh.PingPeriod,
+		EnableCompression:    rwh.EnableCompression,
+		CompressionLevel:     rwh.CompressionLevel,
+		CompressionThreshold: rwh.CompressionThreshold,
+		validated:            rwh.validated,
+	}
+}
+
+func (rwh *ReadWriteHandlers) Validate() error {
+	if nil != rwh.validated.Load() {
+		return nil
+	}
+	rwh.validated.Store(true)
+
+	if err := rwh.ReadWriteHandlers.Validate(); nil != err {
+		return err
+	}
+
+	if rwh.PongTimeout <= 0 {
+		rwh.PongTimeout = server.DefaultPongTimeout
+	} else {
+		rwh.PongTimeout = rwh.PongTimeout * time.Second
+	}
+
+	if rwh.PingTimeout <= 0 {
+		rwh.PingTimeout = server.DefaultPingTimeout
+	} else {
+		rwh.PingTimeout = rwh.PingTimeout * time.Second
+	}
+	if rwh.PingPeriod <= 0 {
+		rwh.PingPeriod = (rwh.PingTimeout * 9) / 10
+	} else {
+		rwh.PingPeriod = rwh.PingPeriod * time.Second
+	}
+
+	if rwh.EnableCompression {
+		if !IsValidCompressionLevel(rwh.CompressionLevel) {
+			return errors.New("Socket: invalid compression level")
+		}
+	}
+
+	if 0 > rwh.CompressionThreshold {
+		rwh.CompressionThreshold = server.DefaultCompressionThreshold
+	}
+
+	return nil
+}

socket/readwrite.go

@@ -0,0 +1,123 @@
+package socket
+
+import (
+	"fmt"
+	"time"
+
+	olog "git.loafle.net/overflow/log-go"
+)
+
+type SocketMessage func() (int, []byte)
+
+func MakeSocketMessage(messageType int, message []byte) SocketMessage {
+	return func() (int, []byte) { return messageType, message }
+}
+
+func connReadHandler(readWriteHandler ReadWriteHandler, conn Conn, stopChan <-chan struct{}, doneChan chan<- error, readChan chan<- SocketMessage) {
+	var (
+		err error
+	)
+
+	defer func() {
+		doneChan <- err
+	}()
+
+	if 0 < readWriteHandler.GetMaxMessageSize() {
+		conn.SetReadLimit(readWriteHandler.GetMaxMessageSize())
+	}
+
+	if 0 < readWriteHandler.GetReadTimeout() {
+		conn.SetReadDeadline(time.Now().Add(readWriteHandler.GetReadTimeout()))
+	} else {
+		conn.SetReadDeadline(time.Time{})
+	}
+	conn.SetPongHandler(func(string) error {
+		if 0 < readWriteHandler.GetPongTimeout() {
+			conn.SetReadDeadline(time.Now().Add(readWriteHandler.GetPongTimeout()))
+		} else {
+			conn.SetReadDeadline(time.Time{})
+		}
+		return nil
+	})
+
+	for {
+		var message []byte
+		var messageType int
+		readMessageChan := make(chan struct{})
+
+		go func() {
+			messageType, message, err = conn.ReadMessage()
+			close(readMessageChan)
+		}()
+
+		select {
+		case <-stopChan:
+			return
+		case <-readMessageChan:
+		}
+
+		if nil != err {
+			if IsUnexpectedCloseError(err, CloseGoingAway, CloseAbnormalClosure) {
+				err = fmt.Errorf("Read error %v", err)
+			}
+			olog.Logger().Debug(err.Error())
+			return
+		}
+
+		readChan <- MakeSocketMessage(messageType, message)
+	}
+}
+
+func connWriteHandler(readWriteHandler ReadWriteHandler, conn Conn, stopChan <-chan struct{}, doneChan chan<- error, writeChan <-chan SocketMessage) {
+	var (
+		socketMessage SocketMessage
+		message       []byte
+		messageType   int
+		ok            bool
+		err           error
+	)
+
+	defer func() {
+		doneChan <- err
+	}()
+
+	ticker := time.NewTicker(readWriteHandler.GetPingPeriod())
+	defer func() {
+		ticker.Stop()
+	}()
+	for {
+		select {
+		case socketMessage, ok = <-writeChan:
+			if 0 < readWriteHandler.GetWriteTimeout() {
+				conn.SetWriteDeadline(time.Now().Add(readWriteHandler.GetWriteTimeout()))
+			} else {
+				conn.SetWriteDeadline(time.Time{})
+			}
+			if !ok {
+				conn.WriteMessage(CloseMessage, []byte{})
+				return
+			}
+
+			messageType, message = socketMessage()
+
+			err = conn.WriteMessage(messageType, message)
+			if err != nil {
+				olog.Logger().Debug(err.Error())
+				return
+			}
+
+		case <-ticker.C:
+			if 0 < readWriteHandler.GetPingTimeout() {
+				conn.SetWriteDeadline(time.Now().Add(readWriteHandler.GetPingTimeout()))
+			} else {
+				conn.SetWriteDeadline(time.Time{})
+			}
+			if err = conn.WriteMessage(PingMessage, nil); nil != err {
+				olog.Logger().Debug(err.Error())
+				return
+			}
+		case <-stopChan:
+			return
+		}
+	}
+}

socket/server-handler.go

@@ -0,0 +1,35 @@
+package socket
+
+import (
+	"sync/atomic"
+
+	"git.loafle.net/overflow/server-go"
+)
+
+type ServerHandler interface {
+	server.ServerHandler
+	ReadWriteHandler
+}
+
+type ServerHandlers struct {
+	server.ServerHandlers
+	ReadWriteHandlers
+
+	validated atomic.Value
+}
+
+func (sh *ServerHandlers) Validate() error {
+	if nil != sh.validated.Load() {
+		return nil
+	}
+	sh.validated.Store(true)
+
+	if err := sh.ServerHandlers.Validate(); nil != err {
+		return err
+	}
+	if err := sh.ReadWriteHandlers.Validate(); nil != err {
+		return err
+	}
+
+	return nil
+}

socket/server-readwriter.go

@@ -0,0 +1,84 @@
+package socket
+
+import (
+	"sync"
+
+	"go.uber.org/zap"
+
+	olog "git.loafle.net/overflow/log-go"
+	"git.loafle.net/overflow/server-go"
+)
+
+type ServerReadWriter struct {
+	connections sync.Map
+
+	ReadwriteHandler ReadWriteHandler
+	ServerStopChan   <-chan struct{}
+	ServerStopWg     *sync.WaitGroup
+}
+
+func (srw *ServerReadWriter) ConnectionSize() int {
+	var sz int
+	srw.connections.Range(func(k, v interface{}) bool {
+		sz++
+		return true
+	})
+	return sz
+}
+
+func (srw *ServerReadWriter) HandleConnection(servlet Servlet, servletCtx server.ServletCtx, conn Conn) {
+	addr := conn.RemoteAddr()
+
+	defer func() {
+		if nil != conn {
+			conn.Close()
+		}
+		servlet.OnDisconnect(servletCtx)
+		olog.Logger().Info("Client has been disconnected", zap.String("Address", addr.String()))
+		srw.ServerStopWg.Done()
+	}()
+
+	olog.Logger().Info("Client has been connected", zap.String("Address", addr.String()))
+
+	srw.connections.Store(conn, true)
+	defer srw.connections.Delete(conn)
+
+	servlet.OnConnect(servletCtx, conn)
+	conn.SetCloseHandler(func(code int, text string) error {
+		olog.Logger().Debug("close")
+		return nil
+	})
+
+	stopChan := make(chan struct{})
+	servletDoneChan := make(chan struct{})
+
+	readChan := make(chan SocketMessage)
+	writeChan := make(chan SocketMessage)
+
+	readerDoneChan := make(chan error)
+	writerDoneChan := make(chan error)
+
+	go connReadHandler(srw.ReadwriteHandler, conn, stopChan, readerDoneChan, readChan)
+	go connWriteHandler(srw.ReadwriteHandler, conn, stopChan, writerDoneChan, writeChan)
+	go servlet.Handle(servletCtx, stopChan, servletDoneChan, readChan, writeChan)
+
+	select {
+	case <-readerDoneChan:
+		close(stopChan)
+		<-writerDoneChan
+		<-servletDoneChan
+	case <-writerDoneChan:
+		close(stopChan)
+		<-readerDoneChan
+		<-servletDoneChan
+	case <-servletDoneChan:
+		close(stopChan)
+		<-readerDoneChan
+		<-writerDoneChan
+	case <-srw.ServerStopChan:
+		close(stopChan)
+		<-readerDoneChan
+		<-writerDoneChan
+		<-servletDoneChan
+	}
+}

socket/servlet.go

@@ -0,0 +1,13 @@
+package socket
+
+import (
+	"git.loafle.net/overflow/server-go"
+)
+
+type Servlet interface {
+	server.Servlet
+
+	OnConnect(servletCtx server.ServletCtx, conn Conn)
+	Handle(servletCtx server.ServletCtx, stopChan <-chan struct{}, doneChan chan<- struct{}, readChan <-chan SocketMessage, writeChan chan<- SocketMessage)
+	OnDisconnect(servletCtx server.ServletCtx)
+}

socket/web/client/connector.go

@@ -0,0 +1,534 @@
+package client
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/tls"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	olog "git.loafle.net/overflow/log-go"
+	"git.loafle.net/overflow/server-go/socket"
+	"git.loafle.net/overflow/server-go/socket/client"
+	"git.loafle.net/overflow/server-go/socket/web"
+)
+
+var errMalformedURL = errors.New("malformed ws or wss URL")
+
+type Connectors struct {
+	client.Connectors
+
+	URL string `json:"url,omitempty"`
+
+	RequestHeader func() http.Header `json:"-"`
+
+	Subprotocols []string `json:"subprotocols,omitempty"`
+	// Jar specifies the cookie jar.
+	// If Jar is nil, cookies are not sent in requests and ignored
+	// in responses.
+	CookieJar http.CookieJar `json:"-"`
+
+	ResponseHandler func(*http.Response) `json:"-"`
+
+	// NetDial specifies the dial function for creating TCP connections. If
+	// NetDial is nil, net.Dial is used.
+	NetDial func(network, addr string) (net.Conn, error) `json:"-"`
+
+	// Proxy specifies a function to return a proxy for a given
+	// Request. If the function returns a non-nil error, the
+	// request is aborted with the provided error.
+	// If Proxy is nil or returns a nil *URL, no proxy is used.
+	Proxy func(*http.Request) (*url.URL, error) `json:"-"`
+
+	serverURL *url.URL
+
+	stopChan chan struct{}
+	stopWg   sync.WaitGroup
+
+	readChan  chan socket.SocketMessage
+	writeChan chan socket.SocketMessage
+
+	disconnectedChan chan struct{}
+	reconnectedChan  chan socket.Conn
+
+	crw socket.ClientReadWriter
+
+	validated atomic.Value
+}
+
+func (c *Connectors) Connect() (readChan <-chan socket.SocketMessage, writeChan chan<- socket.SocketMessage, err error) {
+	var (
+		conn socket.Conn
+		res  *http.Response
+	)
+
+	if c.stopChan != nil {
+		return nil, nil, fmt.Errorf("%s already connected", c.logHeader())
+	}
+
+	conn, res, err = c.connect()
+	if nil != err {
+		return nil, nil, err
+	}
+	resH := c.ResponseHandler
+	if nil != resH {
+		resH(res)
+	}
+
+	c.readChan = make(chan socket.SocketMessage, 256)
+	c.writeChan = make(chan socket.SocketMessage, 256)
+	c.disconnectedChan = make(chan struct{})
+	c.reconnectedChan = make(chan socket.Conn)
+	c.stopChan = make(chan struct{})
+
+	c.crw.ReadwriteHandler = c
+	c.crw.ReadChan = c.readChan
+	c.crw.WriteChan = c.writeChan
+	c.crw.ClientStopChan = c.stopChan
+	c.crw.ClientStopWg = &c.stopWg
+	c.crw.DisconnectedChan = c.disconnectedChan
+	c.crw.ReconnectedChan = c.reconnectedChan
+
+	c.stopWg.Add(1)
+	go c.handleReconnect()
+	c.stopWg.Add(1)
+	go c.crw.HandleConnection(conn)
+
+	return c.readChan, c.writeChan, nil
+}
+
+func (c *Connectors) Disconnect() error {
+	if c.stopChan == nil {
+		return fmt.Errorf("%s must be connected before disconnection it", c.logHeader())
+	}
+	close(c.stopChan)
+	c.stopWg.Wait()
+
+	c.stopChan = nil
+
+	return nil
+}
+
+func (c *Connectors) logHeader() string {
+	return fmt.Sprintf("Connector[%s]:", c.Name)
+}
+
+func (c *Connectors) onDisconnected() {
+	close(c.readChan)
+	close(c.writeChan)
+
+	c.reconnectedChan <- nil
+
+	onDisconnected := c.OnDisconnected
+	if nil != onDisconnected {
+		go func() {
+			onDisconnected(c)
+		}()
+	}
+}
+
+func (c *Connectors) handleReconnect() {
+	defer func() {
+		c.stopWg.Done()
+	}()
+
+RC_LOOP:
+	for {
+		select {
+		case <-c.disconnectedChan:
+		case <-c.stopChan:
+			return
+		}
+
+		if 0 >= c.GetReconnectTryTime() {
+			c.onDisconnected()
+			return
+		}
+
+		olog.Logger().Debugf("%s connection lost", c.logHeader())
+
+		for indexI := 0; indexI < c.GetReconnectTryTime(); indexI++ {
+			olog.Logger().Debugf("%s trying reconnect[%d]", c.logHeader(), indexI)
+
+			conn, res, err := c.connect()
+			if nil == err {
+				resH := c.ResponseHandler
+				if nil != resH {
+					resH(res)
+				}
+
+				olog.Logger().Debugf("%s reconnected", c.logHeader())
+				c.reconnectedChan <- conn
+				continue RC_LOOP
+			}
+			time.Sleep(c.GetReconnectInterval())
+		}
+		olog.Logger().Debugf("%s reconnecting has been failed", c.logHeader())
+
+		c.onDisconnected()
+		return
+	}
+}
+
+func (c *Connectors) connect() (socket.Conn, *http.Response, error) {
+	conn, res, err := c.dial()
+	if nil != err {
+		return nil, nil, err
+	}
+
+	conn.SetCloseHandler(func(code int, text string) error {
+		olog.Logger().Debugf("%s close", c.logHeader())
+		return nil
+	})
+	return conn, res, nil
+}
+
+func (c *Connectors) dial() (socket.Conn, *http.Response, error) {
+	var (
+		err          error
+		challengeKey string
+		netConn      net.Conn
+	)
+
+	challengeKey, err = web.GenerateChallengeKey()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	req := &http.Request{
+		Method:     "GET",
+		URL:        c.serverURL,
+		Proto:      "HTTP/1.1",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+		Header:     make(http.Header),
+		Host:       c.serverURL.Host,
+	}
+
+	cookieJar := c.CookieJar
+	// Set the cookies present in the cookie jar of the dialer
+	if nil != cookieJar {
+		for _, cookie := range cookieJar.Cookies(c.serverURL) {
+			req.AddCookie(cookie)
+		}
+	}
+
+	// Set the request headers using the capitalization for names and values in
+	// RFC examples. Although the capitalization shouldn't matter, there are
+	// servers that depend on it. The Header.Set method is not used because the
+	// method canonicalizes the header names.
+	req.Header["Upgrade"] = []string{"websocket"}
+	req.Header["Connection"] = []string{"Upgrade"}
+	req.Header["Sec-WebSocket-Key"] = []string{challengeKey}
+	req.Header["Sec-WebSocket-Version"] = []string{"13"}
+
+	subprotocols := c.Subprotocols
+
+	if len(subprotocols) > 0 {
+		req.Header["Sec-WebSocket-Protocol"] = []string{strings.Join(subprotocols, ", ")}
+	}
+
+	for k, vs := range c.RequestHeader() {
+		switch {
+		case k == "Host":
+			if len(vs) > 0 {
+				req.Host = vs[0]
+			}
+		case k == "Upgrade" ||
+			k == "Connection" ||
+			k == "Sec-Websocket-Key" ||
+			k == "Sec-Websocket-Version" ||
+			k == "Sec-Websocket-Extensions" ||
+			(k == "Sec-Websocket-Protocol" && len(subprotocols) > 0):
+			return nil, nil, fmt.Errorf("%s duplicate header not allowed: %s", c.logHeader(), k)
+		default:
+			req.Header[k] = vs
+		}
+	}
+
+	if c.IsEnableCompression() {
+		req.Header.Set("Sec-Websocket-Extensions", "permessage-deflate; server_no_context_takeover; client_no_context_takeover")
+	}
+
+	hostPort, hostNoPort := hostPortNoPort(c.serverURL)
+
+	var proxyURL *url.URL
+	// Check wether the proxy method has been configured
+	proxy := c.Proxy
+	if nil != proxy {
+		proxyURL, err = proxy(req)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	var targetHostPort string
+	if proxyURL != nil {
+		targetHostPort, _ = hostPortNoPort(proxyURL)
+	} else {
+		targetHostPort = hostPort
+	}
+
+	var deadline time.Time
+	handshakeTimeout := c.GetHandshakeTimeout()
+	if 0 != handshakeTimeout {
+		deadline = time.Now().Add(handshakeTimeout)
+	}
+
+	netDial := c.NetDial
+	if netDial == nil {
+		netDialer := &net.Dialer{Deadline: deadline}
+		netDial = netDialer.Dial
+	}
+
+	netConn, err = netDial("tcp", targetHostPort)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	defer func() {
+		if nil != netConn {
+			netConn.Close()
+		}
+	}()
+
+	err = netConn.SetDeadline(deadline)
+	if nil != err {
+		return nil, nil, err
+	}
+
+	if nil != proxyURL {
+		connectHeader := make(http.Header)
+		if user := proxyURL.User; nil != user {
+			proxyUser := user.Username()
+			if proxyPassword, passwordSet := user.Password(); passwordSet {
+				credential := base64.StdEncoding.EncodeToString([]byte(proxyUser + ":" + proxyPassword))
+				connectHeader.Set("Proxy-Authorization", "Basic "+credential)
+			}
+		}
+		connectReq := &http.Request{
+			Method: "CONNECT",
+			URL:    &url.URL{Opaque: hostPort},
+			Host:   hostPort,
+			Header: connectHeader,
+		}
+
+		connectReq.Write(netConn)
+
+		// Read response.
+		// Okay to use and discard buffered reader here, because
+		// TLS server will not speak until spoken to.
+		br := bufio.NewReader(netConn)
+		resp, err := http.ReadResponse(br, connectReq)
+		if err != nil {
+			return nil, nil, err
+		}
+		if resp.StatusCode != 200 {
+			f := strings.SplitN(resp.Status, " ", 2)
+			return nil, nil, errors.New(f[1])
+		}
+	}
+
+	if "https" == c.serverURL.Scheme {
+		cfg := cloneTLSConfig(c.GetTLSConfig())
+		if cfg.ServerName == "" {
+			cfg.ServerName = hostNoPort
+		}
+		tlsConn := tls.Client(netConn, cfg)
+		netConn = tlsConn
+		if err := tlsConn.Handshake(); err != nil {
+			return nil, nil, err
+		}
+		if !cfg.InsecureSkipVerify {
+			if err := tlsConn.VerifyHostname(cfg.ServerName); err != nil {
+				return nil, nil, err
+			}
+		}
+	}
+
+	conn := socket.NewConn(netConn, false, c.GetReadBufferSize(), c.GetWriteBufferSize())
+
+	if err := req.Write(netConn); err != nil {
+		return nil, nil, err
+	}
+
+	resp, err := http.ReadResponse(conn.BuffReader, req)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if nil != cookieJar {
+		if rc := resp.Cookies(); len(rc) > 0 {
+			cookieJar.SetCookies(c.serverURL, rc)
+		}
+	}
+
+	if resp.StatusCode != 101 ||
+		!strings.EqualFold(resp.Header.Get("Upgrade"), "websocket") ||
+		!strings.EqualFold(resp.Header.Get("Connection"), "upgrade") ||
+		resp.Header.Get("Sec-Websocket-Accept") != web.ComputeAcceptKey(challengeKey) {
+		// Before closing the network connection on return from this
+		// function, slurp up some of the response to aid application
+		// debugging.
+		buf := make([]byte, 1024)
+		n, _ := io.ReadFull(resp.Body, buf)
+		resp.Body = ioutil.NopCloser(bytes.NewReader(buf[:n]))
+		return nil, resp, socket.ErrBadHandshake
+	}
+
+	for _, ext := range web.HttpParseExtensions(resp.Header) {
+		if ext[""] != "permessage-deflate" {
+			continue
+		}
+		_, snct := ext["server_no_context_takeover"]
+		_, cnct := ext["client_no_context_takeover"]
+		if !snct || !cnct {
+			return nil, resp, socket.ErrInvalidCompression
+		}
+		conn.SetNewCompressionWriter(socket.CompressNoContextTakeover)
+		conn.SetNewDecompressionReader(socket.DecompressNoContextTakeover)
+		break
+	}
+
+	resp.Body = ioutil.NopCloser(bytes.NewReader([]byte{}))
+	conn.SetSubprotocol(resp.Header.Get("Sec-Websocket-Protocol"))
+
+	netConn.SetDeadline(time.Time{})
+	netConn = nil // to avoid close in defer.
+
+	return conn, resp, nil
+}
+
+// parseURL parses the URL.
+//
+// This function is a replacement for the standard library url.Parse function.
+// In Go 1.4 and earlier, url.Parse loses information from the path.
+func parseURL(s string) (*url.URL, error) {
+	// From the RFC:
+	//
+	// ws-URI = "ws:" "//" host [ ":" port ] path [ "?" query ]
+	// wss-URI = "wss:" "//" host [ ":" port ] path [ "?" query ]
+	var u url.URL
+	switch {
+	case strings.HasPrefix(s, "ws://"):
+		u.Scheme = "ws"
+		s = s[len("ws://"):]
+	case strings.HasPrefix(s, "wss://"):
+		u.Scheme = "wss"
+		s = s[len("wss://"):]
+	default:
+		return nil, errMalformedURL
+	}
+
+	if i := strings.Index(s, "?"); i >= 0 {
+		u.RawQuery = s[i+1:]
+		s = s[:i]
+	}
+
+	if i := strings.Index(s, "/"); i >= 0 {
+		u.Opaque = s[i:]
+		s = s[:i]
+	} else {
+		u.Opaque = "/"
+	}
+
+	u.Host = s
+
+	if strings.Contains(u.Host, "@") {
+		// Don't bother parsing user information because user information is
+		// not allowed in websocket URIs.
+		return nil, errMalformedURL
+	}
+
+	return &u, nil
+}
+
+func hostPortNoPort(u *url.URL) (hostPort, hostNoPort string) {
+	hostPort = u.Host
+	hostNoPort = u.Host
+	if i := strings.LastIndex(u.Host, ":"); i > strings.LastIndex(u.Host, "]") {
+		hostNoPort = hostNoPort[:i]
+	} else {
+		switch u.Scheme {
+		case "wss":
+			hostPort += ":443"
+		case "https":
+			hostPort += ":443"
+		default:
+			hostPort += ":80"
+		}
+	}
+	return hostPort, hostNoPort
+}
+
+func cloneTLSConfig(cfg *tls.Config) *tls.Config {
+	if cfg == nil {
+		return &tls.Config{}
+	}
+	return cfg.Clone()
+}
+
+func (c *Connectors) Clone() client.Connector {
+	return &Connectors{
+		Connectors:      *c.Connectors.Clone(),
+		URL:             c.URL,
+		RequestHeader:   c.RequestHeader,
+		Subprotocols:    c.Subprotocols,
+		CookieJar:       c.CookieJar,
+		ResponseHandler: c.ResponseHandler,
+		NetDial:         c.NetDial,
+		Proxy:           c.Proxy,
+		serverURL:       c.serverURL,
+		validated:       c.validated,
+	}
+}
+
+func (c *Connectors) Validate() error {
+	if nil != c.validated.Load() {
+		return nil
+	}
+	c.validated.Store(true)
+
+	if err := c.Connectors.Validate(); nil != err {
+		return err
+	}
+
+	if "" == c.URL {
+		return fmt.Errorf("URL is not valid")
+	}
+
+	u, err := parseURL(c.URL)
+	if nil != err {
+		return err
+	}
+	switch u.Scheme {
+	case "ws":
+		u.Scheme = "http"
+	case "wss":
+		u.Scheme = "https"
+	default:
+		return errMalformedURL
+	}
+	if nil != u.User {
+		// User name and password are not allowed in websocket URIs.
+		return errMalformedURL
+	}
+
+	c.serverURL = u
+
+	if nil == c.Proxy {
+		c.Proxy = http.ProxyFromEnvironment
+	}
+
+	return nil
+}

socket/web/server-handler.go

@@ -0,0 +1,126 @@
+package web
+
+import (
+	"net/http"
+	"sync/atomic"
+
+	"git.loafle.net/overflow/server-go"
+	"git.loafle.net/overflow/server-go/socket"
+
+	"github.com/valyala/fasthttp"
+)
+
+type ServerHandler interface {
+	socket.ServerHandler
+
+	OnError(serverCtx server.ServerCtx, ctx *fasthttp.RequestCtx, status int, reason error)
+
+	RegisterServlet(path string, servlet Servlet)
+	Servlet(serverCtx server.ServerCtx, ctx *fasthttp.RequestCtx) Servlet
+
+	CheckOrigin(ctx *fasthttp.RequestCtx) bool
+}
+
+type ServerHandlers struct {
+	socket.ServerHandlers
+
+	servlets map[string]Servlet
+
+	validated atomic.Value
+}
+
+func (sh *ServerHandlers) Init(serverCtx server.ServerCtx) error {
+	if err := sh.ServerHandlers.Init(serverCtx); nil != err {
+		return err
+	}
+
+	if nil != sh.servlets {
+		for _, servlet := range sh.servlets {
+			if err := servlet.Init(serverCtx); nil != err {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (sh *ServerHandlers) OnStart(serverCtx server.ServerCtx) error {
+	if err := sh.ServerHandlers.OnStart(serverCtx); nil != err {
+		return err
+	}
+
+	if nil != sh.servlets {
+		for _, servlet := range sh.servlets {
+			if err := servlet.OnStart(serverCtx); nil != err {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (sh *ServerHandlers) OnStop(serverCtx server.ServerCtx) {
+	if nil != sh.servlets {
+		for _, servlet := range sh.servlets {
+			servlet.OnStop(serverCtx)
+		}
+	}
+
+	sh.ServerHandlers.OnStop(serverCtx)
+}
+
+func (sh *ServerHandlers) Destroy(serverCtx server.ServerCtx) {
+	if nil != sh.servlets {
+		for _, servlet := range sh.servlets {
+			servlet.Destroy(serverCtx)
+		}
+	}
+
+	sh.ServerHandlers.Destroy(serverCtx)
+}
+
+func (sh *ServerHandlers) OnError(serverCtx server.ServerCtx, ctx *fasthttp.RequestCtx, status int, reason error) {
+	ctx.Response.Header.Set("Sec-Websocket-Version", "13")
+	ctx.Error(http.StatusText(status), status)
+}
+
+func (sh *ServerHandlers) RegisterServlet(path string, servlet Servlet) {
+	if nil == sh.servlets {
+		sh.servlets = make(map[string]Servlet)
+	}
+	sh.servlets[path] = servlet
+}
+
+func (sh *ServerHandlers) Servlet(serverCtx server.ServerCtx, ctx *fasthttp.RequestCtx) Servlet {
+	path := string(ctx.Path())
+
+	var servlet Servlet
+	if path == "" && len(sh.servlets) == 1 {
+		for _, s := range sh.servlets {
+			servlet = s
+		}
+	} else if servlet = sh.servlets[path]; nil == servlet {
+		return nil
+	}
+
+	return servlet
+}
+
+func (sh *ServerHandlers) CheckOrigin(ctx *fasthttp.RequestCtx) bool {
+	return true
+}
+
+func (sh *ServerHandlers) Validate() error {
+	if nil != sh.validated.Load() {
+		return nil
+	}
+	sh.validated.Store(true)
+
+	if err := sh.ServerHandlers.Validate(); nil != err {
+		return err
+	}
+
+	return nil
+}

socket/web/server.go

@@ -0,0 +1,197 @@
+package web
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/http"
+	"sync"
+	"sync/atomic"
+
+	olog "git.loafle.net/overflow/log-go"
+	"git.loafle.net/overflow/server-go"
+	"git.loafle.net/overflow/server-go/socket"
+	"github.com/valyala/fasthttp"
+)
+
+type Server struct {
+	ServerHandler ServerHandler
+
+	ctx      server.ServerCtx
+	stopChan chan struct{}
+	stopWg   sync.WaitGroup
+
+	srw socket.ServerReadWriter
+
+	hs       *fasthttp.Server
+	upgrader *Upgrader
+}
+
+func (s *Server) ListenAndServe() error {
+	var (
+		err      error
+		listener net.Listener
+	)
+	if nil == s.ServerHandler {
+		return fmt.Errorf("%s server handler must be specified", s.logHeader())
+	}
+	s.ServerHandler.Validate()
+
+	if s.stopChan != nil {
+		return fmt.Errorf("%s already running. Stop it before starting it again", s.logHeader())
+	}
+
+	s.ctx = s.ServerHandler.ServerCtx()
+	if nil == s.ctx {
+		return fmt.Errorf("%s ServerCtx is nil", s.logHeader())
+	}
+
+	s.hs = &fasthttp.Server{
+		Handler:         s.httpHandler,
+		Name:            s.ServerHandler.GetName(),
+		Concurrency:     s.ServerHandler.GetConcurrency(),
+		ReadBufferSize:  s.ServerHandler.GetReadBufferSize(),
+		WriteBufferSize: s.ServerHandler.GetWriteBufferSize(),
+		ReadTimeout:     s.ServerHandler.GetReadTimeout(),
+		WriteTimeout:    s.ServerHandler.GetWriteTimeout(),
+	}
+
+	s.upgrader = &Upgrader{
+		HandshakeTimeout:  s.ServerHandler.GetHandshakeTimeout(),
+		ReadBufferSize:    s.ServerHandler.GetReadBufferSize(),
+		WriteBufferSize:   s.ServerHandler.GetWriteBufferSize(),
+		CheckOrigin:       s.ServerHandler.(ServerHandler).CheckOrigin,
+		Error:             s.onError,
+		EnableCompression: s.ServerHandler.IsEnableCompression(),
+		CompressionLevel:  s.ServerHandler.GetCompressionLevel(),
+	}
+
+	if err = s.ServerHandler.Init(s.ctx); nil != err {
+		olog.Logger().Errorf("%s Init has been failed %v", s.logHeader(), err)
+		return err
+	}
+
+	if listener, err = s.ServerHandler.Listener(s.ctx); nil != err {
+		return err
+	}
+
+	s.stopChan = make(chan struct{})
+
+	s.srw.ReadwriteHandler = s.ServerHandler
+	s.srw.ServerStopChan = s.stopChan
+	s.srw.ServerStopWg = &s.stopWg
+
+	s.stopWg.Add(1)
+	return s.handleServer(listener)
+}
+
+func (s *Server) Shutdown(ctx context.Context) error {
+	if s.stopChan == nil {
+		return fmt.Errorf("%s must be started before stopping it", s.logHeader())
+	}
+	close(s.stopChan)
+	s.stopWg.Wait()
+
+	s.ServerHandler.Destroy(s.ctx)
+
+	s.stopChan = nil
+
+	return nil
+}
+
+func (s *Server) logHeader() string {
+	return fmt.Sprintf("Server[%s]:", s.ServerHandler.GetName())
+}
+
+func (s *Server) handleServer(listener net.Listener) error {
+	var (
+		err      error
+		stopping atomic.Value
+	)
+
+	defer func() {
+		if nil != listener {
+			listener.Close()
+		}
+		s.ServerHandler.OnStop(s.ctx)
+
+		olog.Logger().Infof("%s Stopped", s.logHeader())
+
+		s.stopWg.Done()
+	}()
+
+	if err = s.ServerHandler.OnStart(s.ctx); nil != err {
+		olog.Logger().Errorf("%s OnStart has been failed %v", s.logHeader(), err)
+		return err
+	}
+
+	hsCloseChan := make(chan error)
+	go func() {
+		if err := s.hs.Serve(listener); nil != err {
+			if nil == stopping.Load() {
+				hsCloseChan <- err
+				return
+			}
+		}
+		hsCloseChan <- nil
+	}()
+
+	olog.Logger().Infof("%s Started", s.logHeader())
+
+	select {
+	case err, _ := <-hsCloseChan:
+		if nil != err {
+			return err
+		}
+	case <-s.stopChan:
+		stopping.Store(true)
+		listener.Close()
+		<-hsCloseChan
+		listener = nil
+	}
+
+	return nil
+}
+
+func (s *Server) httpHandler(ctx *fasthttp.RequestCtx) {
+	var (
+		servlet Servlet
+		err     error
+	)
+
+	if 0 < s.ServerHandler.GetConcurrency() {
+		sz := s.srw.ConnectionSize()
+		if sz >= s.ServerHandler.GetConcurrency() {
+			olog.Logger().Warnf("%s max connections size %d, refuse", s.logHeader(), sz)
+			s.onError(ctx, fasthttp.StatusServiceUnavailable, err)
+			return
+		}
+	}
+
+	if servlet = s.ServerHandler.Servlet(s.ctx, ctx); nil == servlet {
+		s.onError(ctx, fasthttp.StatusInternalServerError, err)
+		return
+	}
+
+	var responseHeader *fasthttp.ResponseHeader
+	servletCtx := servlet.ServletCtx(s.ctx)
+
+	if responseHeader, err = servlet.Handshake(servletCtx, ctx); nil != err {
+		s.onError(ctx, http.StatusNotAcceptable, fmt.Errorf("Handshake err: %v", err))
+		return
+	}
+
+	s.upgrader.Upgrade(ctx, responseHeader, func(conn *socket.SocketConn, err error) {
+		if err != nil {
+			s.onError(ctx, fasthttp.StatusInternalServerError, err)
+			return
+		}
+
+		s.stopWg.Add(1)
+		s.srw.HandleConnection(servlet, servletCtx, conn)
+	})
+}
+
+func (s *Server) onError(ctx *fasthttp.RequestCtx, status int, reason error) {
+	s.ServerHandler.(ServerHandler).OnError(s.ctx, ctx, status, reason)
+}

socket/web/servlet.go

@@ -0,0 +1,53 @@
+package web
+
+import (
+	"git.loafle.net/overflow/server-go"
+	"git.loafle.net/overflow/server-go/socket"
+	"github.com/valyala/fasthttp"
+)
+
+type Servlet interface {
+	socket.Servlet
+
+	Handshake(servletCtx server.ServletCtx, ctx *fasthttp.RequestCtx) (*fasthttp.ResponseHeader, error)
+}
+
+type Servlets struct {
+	Servlet
+}
+
+func (s *Servlets) ServletCtx(serverCtx server.ServerCtx) server.ServletCtx {
+	return server.NewServletContext(nil, serverCtx)
+}
+
+func (s *Servlets) Init(serverCtx server.ServerCtx) error {
+	return nil
+}
+
+func (s *Servlets) OnStart(serverCtx server.ServerCtx) error {
+	return nil
+}
+
+func (s *Servlets) OnStop(serverCtx server.ServerCtx) {
+	//
+}
+
+func (s *Servlets) Destroy(serverCtx server.ServerCtx) {
+	//
+}
+
+func (s *Servlets) Handshake(servletCtx server.ServletCtx, ctx *fasthttp.RequestCtx) (*fasthttp.ResponseHeader, error) {
+	return nil, nil
+}
+
+func (s *Servlets) OnConnect(servletCtx server.ServletCtx, conn socket.Conn) {
+	//
+}
+
+func (s *Servlets) Handle(servletCtx server.ServletCtx, stopChan <-chan struct{}, doneChan chan<- struct{}, readChan <-chan socket.SocketMessage, writeChan chan<- socket.SocketMessage) {
+
+}
+
+func (s *Servlets) OnDisconnect(servletCtx server.ServletCtx) {
+	//
+}

socket/web/upgrade.go

@@ -0,0 +1,279 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package web
+
+import (
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"git.loafle.net/overflow/server-go/socket"
+	"github.com/valyala/fasthttp"
+)
+
+type (
+	OnUpgradeFunc func(*socket.SocketConn, error)
+)
+
+// HandshakeError describes an error with the handshake from the peer.
+type HandshakeError struct {
+	message string
+}
+
+func (e HandshakeError) Error() string { return e.message }
+
+// Upgrader specifies parameters for upgrading an HTTP connection to a
+// WebSocket connection.
+type Upgrader struct {
+	// HandshakeTimeout specifies the duration for the handshake to complete.
+	HandshakeTimeout time.Duration
+
+	// ReadBufferSize and WriteBufferSize specify I/O buffer sizes. If a buffer
+	// size is zero, then buffers allocated by the HTTP server are used. The
+	// I/O buffer sizes do not limit the size of the messages that can be sent
+	// or received.
+	ReadBufferSize, WriteBufferSize int
+
+	// Subprotocols specifies the server's supported protocols in order of
+	// preference. If this field is set, then the Upgrade method negotiates a
+	// subprotocol by selecting the first match in this list with a protocol
+	// requested by the client.
+	Subprotocols []string
+
+	// Error specifies the function for generating HTTP error responses. If Error
+	// is nil, then http.Error is used to generate the HTTP response.
+	Error func(ctx *fasthttp.RequestCtx, status int, reason error)
+
+	// CheckOrigin returns true if the request Origin header is acceptable. If
+	// CheckOrigin is nil, the host in the Origin header must not be set or
+	// must match the host of the request.
+	CheckOrigin func(ctx *fasthttp.RequestCtx) bool
+
+	// EnableCompression specify if the server should attempt to negotiate per
+	// message compression (RFC 7692). Setting this value to true does not
+	// guarantee that compression will be supported. Currently only "no context
+	// takeover" modes are supported.
+	EnableCompression bool
+	CompressionLevel  int
+}
+
+func (u *Upgrader) returnError(ctx *fasthttp.RequestCtx, status int, reason string) (*socket.SocketConn, error) {
+	err := HandshakeError{reason}
+	if u.Error != nil {
+		u.Error(ctx, status, err)
+	} else {
+		ctx.Response.Header.Set("Sec-Websocket-Version", "13")
+		ctx.Error(http.StatusText(status), status)
+	}
+	return nil, err
+}
+
+// checkSameOrigin returns true if the origin is not set or is equal to the request host.
+func checkSameOrigin(ctx *fasthttp.RequestCtx) bool {
+	origin := string(ctx.Request.Header.Peek("Origin"))
+	if len(origin) == 0 {
+		return true
+	}
+	u, err := url.Parse(origin)
+	if err != nil {
+		return false
+	}
+	return u.Host == string(ctx.Host())
+}
+
+func (u *Upgrader) selectSubprotocol(ctx *fasthttp.RequestCtx, responseHeader *fasthttp.ResponseHeader) string {
+	if u.Subprotocols != nil {
+		clientProtocols := Subprotocols(ctx)
+		for _, serverProtocol := range u.Subprotocols {
+			for _, clientProtocol := range clientProtocols {
+				if clientProtocol == serverProtocol {
+					return clientProtocol
+				}
+			}
+		}
+	} else if responseHeader != nil {
+		return string(responseHeader.Peek("Sec-Websocket-Protocol"))
+	}
+	return ""
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// application negotiated subprotocol (Sec-Websocket-Protocol).
+//
+// If the upgrade fails, then Upgrade replies to the client with an HTTP error
+// response.
+func (u *Upgrader) Upgrade(ctx *fasthttp.RequestCtx, responseHeader *fasthttp.ResponseHeader, cb OnUpgradeFunc) {
+	if !ctx.IsGet() {
+		cb(u.returnError(ctx, fasthttp.StatusMethodNotAllowed, "websocket: not a websocket handshake: request method is not GET"))
+		return
+	}
+
+	if nil != responseHeader {
+		if v := responseHeader.Peek("Sec-Websocket-Extensions"); nil != v {
+			cb(u.returnError(ctx, fasthttp.StatusInternalServerError, "websocket: application specific 'Sec-Websocket-Extensions' headers are unsupported"))
+			return
+		}
+	}
+
+	if !tokenListContainsValue(&ctx.Request.Header, "Connection", "upgrade") {
+		cb(u.returnError(ctx, fasthttp.StatusBadRequest, "websocket: not a websocket handshake: 'upgrade' token not found in 'Connection' header"))
+		return
+	}
+
+	if !tokenListContainsValue(&ctx.Request.Header, "Upgrade", "websocket") {
+		cb(u.returnError(ctx, fasthttp.StatusBadRequest, "websocket: not a websocket handshake: 'websocket' token not found in 'Upgrade' header"))
+		return
+	}
+
+	if !tokenListContainsValue(&ctx.Request.Header, "Sec-Websocket-Version", "13") {
+		cb(u.returnError(ctx, fasthttp.StatusBadRequest, "websocket: unsupported version: 13 not found in 'Sec-Websocket-Version' header"))
+		return
+	}
+
+	checkOrigin := u.CheckOrigin
+	if checkOrigin == nil {
+		checkOrigin = checkSameOrigin
+	}
+	if !checkOrigin(ctx) {
+		cb(u.returnError(ctx, fasthttp.StatusForbidden, "websocket: 'Origin' header value not allowed"))
+		return
+	}
+
+	challengeKey := string(ctx.Request.Header.Peek("Sec-Websocket-Key"))
+	if challengeKey == "" {
+		cb(u.returnError(ctx, fasthttp.StatusBadRequest, "websocket: not a websocket handshake: `Sec-Websocket-Key' header is missing or blank"))
+		return
+	}
+
+	subprotocol := u.selectSubprotocol(ctx, responseHeader)
+
+	// Negotiate PMCE
+	var compress bool
+	if u.EnableCompression {
+		for _, ext := range parseExtensions(&ctx.Request.Header) {
+			if ext[""] != "permessage-deflate" {
+				continue
+			}
+			compress = true
+			break
+		}
+	}
+
+	ctx.SetStatusCode(fasthttp.StatusSwitchingProtocols)
+	ctx.Response.Header.Set("Upgrade", "websocket")
+	ctx.Response.Header.Set("Connection", "Upgrade")
+	ctx.Response.Header.Set("Sec-Websocket-Accept", ComputeAcceptKey(challengeKey))
+	if subprotocol != "" {
+		ctx.Response.Header.Set("Sec-Websocket-Protocol", subprotocol)
+	}
+	if compress {
+		ctx.Response.Header.Set("Sec-Websocket-Extensions", "permessage-deflate; server_no_context_takeover; client_no_context_takeover")
+	}
+	if nil != responseHeader {
+		responseHeader.VisitAll(func(key, value []byte) {
+			k := string(key)
+			v := string(value)
+			if k == "Sec-Websocket-Protocol" {
+				return
+			}
+			ctx.Response.Header.Set(k, v)
+		})
+	}
+
+	h := &fasthttp.RequestHeader{}
+
+	//copy request headers in order to have access inside the Conn after
+	ctx.Request.Header.CopyTo(h)
+
+	ctx.Hijack(func(netConn net.Conn) {
+		c := socket.NewConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize)
+		c.SetSubprotocol(subprotocol)
+		if compress {
+			c.SetCompressionLevel(u.CompressionLevel)
+			c.SetNewCompressionWriter(socket.CompressNoContextTakeover)
+			c.SetNewDecompressionReader(socket.DecompressNoContextTakeover)
+		}
+
+		// Clear deadlines set by HTTP server.
+		netConn.SetDeadline(time.Time{})
+
+		if u.HandshakeTimeout > 0 {
+			netConn.SetWriteDeadline(time.Now().Add(u.HandshakeTimeout))
+		}
+
+		if u.HandshakeTimeout > 0 {
+			netConn.SetWriteDeadline(time.Time{})
+		}
+
+		cb(c, nil)
+	})
+}
+
+// Upgrade upgrades the HTTP server connection to the WebSocket protocol.
+//
+// This function is deprecated, use websocket.Upgrader instead.
+//
+// The application is responsible for checking the request origin before
+// calling Upgrade. An example implementation of the same origin policy is:
+//
+//	if req.Header.Get("Origin") != "http://"+req.Host {
+//		http.Error(w, "Origin not allowed", 403)
+//		return
+//	}
+//
+// If the endpoint supports subprotocols, then the application is responsible
+// for negotiating the protocol used on the connection. Use the Subprotocols()
+// function to get the subprotocols requested by the client. Use the
+// Sec-Websocket-Protocol response header to specify the subprotocol selected
+// by the application.
+//
+// The responseHeader is included in the response to the client's upgrade
+// request. Use the responseHeader to specify cookies (Set-Cookie) and the
+// negotiated subprotocol (Sec-Websocket-Protocol).
+//
+// The connection buffers IO to the underlying network connection. The
+// readBufSize and writeBufSize parameters specify the size of the buffers to
+// use. Messages can be larger than the buffers.
+//
+// If the request is not a valid WebSocket handshake, then Upgrade returns an
+// error of type HandshakeError. Applications should handle this error by
+// replying to the client with an HTTP error response.
+func Upgrade(ctx *fasthttp.RequestCtx, responseHeader *fasthttp.ResponseHeader, readBufSize, writeBufSize int, cb OnUpgradeFunc) {
+	u := Upgrader{ReadBufferSize: readBufSize, WriteBufferSize: writeBufSize}
+	u.Error = func(ctx *fasthttp.RequestCtx, status int, reason error) {
+		// don't return errors to maintain backwards compatibility
+	}
+	u.CheckOrigin = func(ctx *fasthttp.RequestCtx) bool {
+		// allow all connections by default
+		return true
+	}
+	u.Upgrade(ctx, responseHeader, cb)
+}
+
+// Subprotocols returns the subprotocols requested by the client in the
+// Sec-Websocket-Protocol header.
+func Subprotocols(ctx *fasthttp.RequestCtx) []string {
+	h := strings.TrimSpace(string(ctx.Request.Header.Peek("Sec-Websocket-Protocol")))
+	if h == "" {
+		return nil
+	}
+	protocols := strings.Split(h, ",")
+	for i := range protocols {
+		protocols[i] = strings.TrimSpace(protocols[i])
+	}
+	return protocols
+}
+
+// IsWebSocketUpgrade returns true if the client requested upgrade to the
+// WebSocket protocol.
+func IsWebSocketUpgrade(ctx *fasthttp.RequestCtx) bool {
+	return tokenListContainsValue(&ctx.Request.Header, "Connection", "upgrade") &&
+		tokenListContainsValue(&ctx.Request.Header, "Upgrade", "websocket")
+}

socket/web/util.go

@@ -0,0 +1,272 @@
+// Copyright 2013 The Gorilla WebSocket Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package web
+
+import (
+	"crypto/rand"
+	"crypto/sha1"
+	"encoding/base64"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/valyala/fasthttp"
+)
+
+var keyGUID = []byte("258EAFA5-E914-47DA-95CA-C5AB0DC85B11")
+
+func ComputeAcceptKey(challengeKey string) string {
+	h := sha1.New()
+	h.Write([]byte(challengeKey))
+	h.Write(keyGUID)
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+func GenerateChallengeKey() (string, error) {
+	p := make([]byte, 16)
+	if _, err := io.ReadFull(rand.Reader, p); err != nil {
+		return "", err
+	}
+	return base64.StdEncoding.EncodeToString(p), nil
+}
+
+// Octet types from RFC 2616.
+var octetTypes [256]byte
+
+const (
+	isTokenOctet = 1 << iota
+	isSpaceOctet
+)
+
+func init() {
+	// From RFC 2616
+	//
+	// OCTET      = <any 8-bit sequence of data>
+	// CHAR       = <any US-ASCII character (octets 0 - 127)>
+	// CTL        = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
+	// CR         = <US-ASCII CR, carriage return (13)>
+	// LF         = <US-ASCII LF, linefeed (10)>
+	// SP         = <US-ASCII SP, space (32)>
+	// HT         = <US-ASCII HT, horizontal-tab (9)>
+	// <">        = <US-ASCII double-quote mark (34)>
+	// CRLF       = CR LF
+	// LWS        = [CRLF] 1*( SP | HT )
+	// TEXT       = <any OCTET except CTLs, but including LWS>
+	// separators = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <">
+	//              | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT
+	// token      = 1*<any CHAR except CTLs or separators>
+	// qdtext     = <any TEXT except <">>
+
+	for c := 0; c < 256; c++ {
+		var t byte
+		isCtl := c <= 31 || c == 127
+		isChar := 0 <= c && c <= 127
+		isSeparator := strings.IndexRune(" \t\"(),/:;<=>?@[]\\{}", rune(c)) >= 0
+		if strings.IndexRune(" \t\r\n", rune(c)) >= 0 {
+			t |= isSpaceOctet
+		}
+		if isChar && !isCtl && !isSeparator {
+			t |= isTokenOctet
+		}
+		octetTypes[c] = t
+	}
+}
+
+func skipSpace(s string) (rest string) {
+	i := 0
+	for ; i < len(s); i++ {
+		if octetTypes[s[i]]&isSpaceOctet == 0 {
+			break
+		}
+	}
+	return s[i:]
+}
+
+func nextToken(s string) (token string, rest string) {
+	i := 0
+	for ; i < len(s); i++ {
+		if octetTypes[s[i]]&isTokenOctet == 0 {
+			break
+		}
+	}
+	return s[:i], s[i:]
+}
+
+func nextTokenOrQuoted(s string) (value string, rest string) {
+	if !strings.HasPrefix(s, "\"") {
+		return nextToken(s)
+	}
+	s = s[1:]
+	for i := 0; i < len(s); i++ {
+		switch s[i] {
+		case '"':
+			return s[:i], s[i+1:]
+		case '\\':
+			p := make([]byte, len(s)-1)
+			j := copy(p, s[:i])
+			escape := true
+			for i = i + 1; i < len(s); i++ {
+				b := s[i]
+				switch {
+				case escape:
+					escape = false
+					p[j] = b
+					j++
+				case b == '\\':
+					escape = true
+				case b == '"':
+					return string(p[:j]), s[i+1:]
+				default:
+					p[j] = b
+					j++
+				}
+			}
+			return "", ""
+		}
+	}
+	return "", ""
+}
+
+// tokenListContainsValue returns true if the 1#token header with the given
+// name contains token.
+func tokenListContainsValue(header *fasthttp.RequestHeader, name string, value string) bool {
+	s := string(header.Peek(name))
+	for {
+		var t string
+		t, s = nextToken(skipSpace(s))
+		if t == "" {
+			break
+		}
+		s = skipSpace(s)
+		if s != "" && s[0] != ',' {
+			break
+		}
+		if strings.EqualFold(t, value) {
+			return true
+		}
+		if s == "" {
+			break
+		}
+		s = s[1:]
+	}
+	return false
+}
+
+// parseExtensiosn parses WebSocket extensions from a header.
+func parseExtensions(header *fasthttp.RequestHeader) []map[string]string {
+
+	// From RFC 6455:
+	//
+	//  Sec-WebSocket-Extensions = extension-list
+	//  extension-list = 1#extension
+	//  extension = extension-token *( ";" extension-param )
+	//  extension-token = registered-token
+	//  registered-token = token
+	//  extension-param = token [ "=" (token | quoted-string) ]
+	//     ;When using the quoted-string syntax variant, the value
+	//     ;after quoted-string unescaping MUST conform to the
+	//     ;'token' ABNF.
+	s := string(header.Peek("Sec-Websocket-Extensions"))
+	var result []map[string]string
+headers:
+	for {
+		var t string
+		t, s = nextToken(skipSpace(s))
+		if t == "" {
+			break headers
+		}
+		ext := map[string]string{"": t}
+		for {
+			s = skipSpace(s)
+			if !strings.HasPrefix(s, ";") {
+				break
+			}
+			var k string
+			k, s = nextToken(skipSpace(s[1:]))
+			if k == "" {
+				break headers
+			}
+			s = skipSpace(s)
+			var v string
+			if strings.HasPrefix(s, "=") {
+				v, s = nextTokenOrQuoted(skipSpace(s[1:]))
+				s = skipSpace(s)
+			}
+			if s != "" && s[0] != ',' && s[0] != ';' {
+				break headers
+			}
+			ext[k] = v
+		}
+		if s != "" && s[0] != ',' {
+			break headers
+		}
+		result = append(result, ext)
+		if s == "" {
+			break headers
+		}
+		s = s[1:]
+	}
+
+	return result
+}
+
+// parseExtensiosn parses WebSocket extensions from a header.
+func HttpParseExtensions(header http.Header) []map[string]string {
+
+	// From RFC 6455:
+	//
+	//  Sec-WebSocket-Extensions = extension-list
+	//  extension-list = 1#extension
+	//  extension = extension-token *( ";" extension-param )
+	//  extension-token = registered-token
+	//  registered-token = token
+	//  extension-param = token [ "=" (token | quoted-string) ]
+	//     ;When using the quoted-string syntax variant, the value
+	//     ;after quoted-string unescaping MUST conform to the
+	//     ;'token' ABNF.
+
+	var result []map[string]string
+headers:
+	for _, s := range header["Sec-Websocket-Extensions"] {
+		for {
+			var t string
+			t, s = nextToken(skipSpace(s))
+			if t == "" {
+				continue headers
+			}
+			ext := map[string]string{"": t}
+			for {
+				s = skipSpace(s)
+				if !strings.HasPrefix(s, ";") {
+					break
+				}
+				var k string
+				k, s = nextToken(skipSpace(s[1:]))
+				if k == "" {
+					continue headers
+				}
+				s = skipSpace(s)
+				var v string
+				if strings.HasPrefix(s, "=") {
+					v, s = nextTokenOrQuoted(skipSpace(s[1:]))
+					s = skipSpace(s)
+				}
+				if s != "" && s[0] != ',' && s[0] != ';' {
+					continue headers
+				}
+				ext[k] = v
+			}
+			if s != "" && s[0] != ',' {
+				continue headers
+			}
+			result = append(result, ext)
+			if s == "" {
+				continue headers
+			}
+			s = s[1:]
+		}
+	}
+	return result
+}