go-ethereum/websocket/server.go

package websocket

import (
	"net/http"

	"github.com/ethereum/eth-go/ethlog"

	ws "code.google.com/p/go.net/websocket"
)

var logger = ethlog.NewLogger("WS")

// Chat server.
type Server struct {
	httpServ  string
	pattern   string
	messages  []*Message
	clients   map[int]*Client
	addCh     chan *Client
	delCh     chan *Client
	sendAllCh chan string
	doneCh    chan bool
	errCh     chan error
	msgFunc   MsgFunc
}

// Create new chat server.
func NewServer(pattern, httpServ string) *Server {
	clients := make(map[int]*Client)
	addCh := make(chan *Client)
	delCh := make(chan *Client)
	sendAllCh := make(chan string)
	doneCh := make(chan bool)
	errCh := make(chan error)

	return &Server{
		httpServ,
		pattern,
		nil,
		clients,
		addCh,
		delCh,
		sendAllCh,
		doneCh,
		errCh,
		nil,
	}
}

func (s *Server) Add(c *Client) {
	s.addCh <- c
}

func (s *Server) Del(c *Client) {
	s.delCh <- c
}

func (s *Server) SendAll(msg string) {
	s.sendAllCh <- msg
}

func (s *Server) Done() {
	s.doneCh <- true
}

func (s *Server) Err(err error) {
	s.errCh <- err
}

func (s *Server) servHTTP() {
	logger.Debugln("Serving http", s.httpServ)
	err := http.ListenAndServe(s.httpServ, nil)

	logger.Warnln(err)
}

func (s *Server) MessageFunc(f MsgFunc) {
	s.msgFunc = f
}

// Listen and serve.
// It serves client connection and broadcast request.
func (s *Server) Listen() {
	logger.Debugln("Listening server...")

	// ws handler
	onConnected := func(ws *ws.Conn) {
		defer func() {
			err := ws.Close()
			if err != nil {
				s.errCh <- err
			}
		}()

		client := NewClient(ws, s)
		client.onMessage = s.msgFunc
		s.Add(client)
		client.Listen()
	}
	// Disable Origin check. Request don't need to come necessarily from origin.
	http.HandleFunc(s.pattern, func(w http.ResponseWriter, req *http.Request) {
		s := ws.Server{Handler: ws.Handler(onConnected)}
		s.ServeHTTP(w, req)
	})
	logger.Debugln("Created handler")

	go s.servHTTP()

	for {
		select {

		// Add new a client
		case c := <-s.addCh:
			s.clients[c.id] = c

		// del a client
		case c := <-s.delCh:
			delete(s.clients, c.id)

		case err := <-s.errCh:
			logger.Debugln("Error:", err.Error())

		case <-s.doneCh:
			return
		}
	}
}