e2m/dispatch
4
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor websocket handler

Browse Source
This commit is contained in:
Ken-Håvard Lieng 2015-06-17 00:46:58 +02:00
parent 047027ddec
commit 114bf8201e
8 changed files with 257 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
assets/bindata.go
View File

File diff suppressed because one or more lines are too long

4
client/src/js/socket.js
View File

@ -59,7 +59,7 @@ class Socket extends EventEmitter {
this.send('pong');
}
this.emit(msg.type, msg.response);
this.emit(msg.type, msg.data);
};
}
@ -68,7 +68,7 @@ class Socket extends EventEmitter {
}
send(type, data) {
this.ws.send(JSON.stringify({ type, request: data }));
this.ws.send(JSON.stringify({ type, data }));
}
setTimeoutPing() {

4
server/irc_handler_test.go
View File

@ -43,9 +43,9 @@ func dispatchMessage(msg *irc.Message) WSResponse {
return <-s.out
}
func checkResponse(t *testing.T, expectedType string, expectedResponse interface{}, res WSResponse) {
func checkResponse(t *testing.T, expectedType string, expectedData interface{}, res WSResponse) {
assert.Equal(t, expectedType, res.Type)
assert.Equal(t, expectedResponse, res.Response)
assert.Equal(t, expectedData, res.Data)
}
func TestHandleIRCNick(t *testing.T) {

4
server/json_types.go → server/json.go
View File

@ -8,12 +8,12 @@ import (
type WSRequest struct {
Type string `json:"type"`
Request json.RawMessage `json:"request"`
Data json.RawMessage `json:"data"`
}
type WSResponse struct {
Type string `json:"type"`
Response interface{} `json:"response"`
Data interface{} `json:"data"`
}
type Connect struct {

2
server/server.go
View File

@ -59,7 +59,7 @@ func upgradeWS(w http.ResponseWriter, r *http.Request) {
return
}
handleWS(conn)
newWSHandler(conn).run()
}
func reconnect() {

6
server/session.go
View File

@ -11,7 +11,7 @@ type Session struct {
irc map[string]*irc.Client
ircLock sync.Mutex
ws map[string]*conn
ws map[string]*wsConn
wsLock sync.Mutex
out chan WSResponse
@ -21,7 +21,7 @@ type Session struct {
func NewSession() *Session {
return &Session{
irc: make(map[string]*irc.Client),
ws: make(map[string]*conn),
ws: make(map[string]*wsConn),
out: make(chan WSResponse, 32),
}
}
@ -54,7 +54,7 @@ func (s *Session) numIRC() int {
return n
}
func (s *Session) setWS(addr string, w *conn) {
func (s *Session) setWS(addr string, w *wsConn) {
s.wsLock.Lock()
s.ws[addr] = w
s.wsLock.Unlock()

15
server/conn.go → server/websocket.go
View File

@ -6,21 +6,21 @@ import (
"github.com/khlieng/name_pending/Godeps/_workspace/src/github.com/gorilla/websocket"
)
type conn struct {
type wsConn struct {
conn *websocket.Conn
in chan WSRequest
out chan WSResponse
}
func newConn(ws *websocket.Conn) *conn {
return &conn{
conn: ws,
func newWSConn(conn *websocket.Conn) *wsConn {
return &wsConn{
conn: conn,
in: make(chan WSRequest, 32),
out: make(chan WSResponse, 32),
}
}
func (c *conn) send() {
func (c *wsConn) send() {
var err error
ping := time.Tick(20 * time.Second)
@ -43,7 +43,7 @@ func (c *conn) send() {
}
}
func (c *conn) recv() {
func (c *wsConn) recv() {
var req WSRequest
for {
@ -57,6 +57,7 @@ func (c *conn) recv() {
}
}
func (c *conn) close() {
func (c *wsConn) close() {
close(c.out)
c.conn.Close()
}

240
server/websocket_handler.go
View File

@ -11,82 +11,97 @@ import (
"github.com/khlieng/name_pending/storage"
)
func handleWS(conn *websocket.Conn) {
defer conn.Close()
type wsHandler struct {
ws *wsConn
session *Session
var session *Session
var UUID string
uuid string
addr string
addr := conn.RemoteAddr().String()
ws := newConn(conn)
defer ws.close()
go ws.send()
go ws.recv()
log.Println(addr, "connected")
for {
req, ok := <-ws.in
if !ok {
if session != nil {
session.deleteWS(addr)
handlers map[string]func([]byte)
}
log.Println(addr, "disconnected")
func newWSHandler(conn *websocket.Conn) *wsHandler {
h := &wsHandler{
ws: newWSConn(conn),
addr: conn.RemoteAddr().String(),
}
h.initHandlers()
return h
}
func (h *wsHandler) run() {
defer h.ws.close()
go h.ws.send()
go h.ws.recv()
for {
req, ok := <-h.ws.in
if !ok {
if h.session != nil {
h.session.deleteWS(h.addr)
}
return
}
switch req.Type {
case "uuid":
json.Unmarshal(req.Request, &UUID)
h.dispatchRequest(req)
}
}
log.Println(addr, "set UUID", UUID)
func (h *wsHandler) dispatchRequest(req WSRequest) {
if handler, ok := h.handlers[req.Type]; ok {
handler(req.Data)
}
}
func (h *wsHandler) init(b []byte) {
json.Unmarshal(b, &h.uuid)
log.Println(h.addr, "set UUID", h.uuid)
sessionLock.Lock()
if storedSession, exists := sessions[UUID]; exists {
if storedSession, exists := sessions[h.uuid]; exists {
sessionLock.Unlock()
session = storedSession
session.setWS(addr, ws)
h.session = storedSession
h.session.setWS(h.addr, h.ws)
log.Println(addr, "attached to", session.numIRC(), "existing IRC connections")
log.Println(h.addr, "attached to", h.session.numIRC(), "existing IRC connections")
channels := session.user.GetChannels()
channels := h.session.user.GetChannels()
for i, channel := range channels {
channels[i].Topic = channelStore.GetTopic(channel.Server, channel.Name)
}
session.sendJSON("channels", channels)
session.sendJSON("servers", session.user.GetServers())
h.session.sendJSON("channels", channels)
h.session.sendJSON("servers", h.session.user.GetServers())
for _, channel := range channels {
session.sendJSON("users", Userlist{
h.session.sendJSON("users", Userlist{
Server: channel.Server,
Channel: channel.Name,
Users: channelStore.GetUsers(channel.Server, channel.Name),
})
}
} else {
session = NewSession()
session.user = storage.NewUser(UUID)
h.session = NewSession()
h.session.user = storage.NewUser(h.uuid)
sessions[UUID] = session
sessions[h.uuid] = h.session
sessionLock.Unlock()
session.setWS(addr, ws)
session.sendJSON("servers", nil)
h.session.setWS(h.addr, h.ws)
h.session.sendJSON("servers", nil)
go session.write()
go h.session.write()
}
}
case "connect":
func (h *wsHandler) connect(b []byte) {
var data Connect
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
if _, ok := session.getIRC(data.Server); !ok {
log.Println(addr, "connecting to", data.Server)
if _, ok := h.session.getIRC(data.Server); !ok {
log.Println(h.addr, "connecting to", data.Server)
i := irc.NewClient(data.Nick, data.Username)
i.TLS = data.TLS
@ -94,15 +109,15 @@ func handleWS(conn *websocket.Conn) {
i.Realname = data.Realname
if idx := strings.Index(data.Server, ":"); idx < 0 {
session.setIRC(data.Server, i)
h.session.setIRC(data.Server, i)
} else {
session.setIRC(data.Server[:idx], i)
h.session.setIRC(data.Server[:idx], i)
}
i.Connect(data.Server)
go newIRCHandler(i, session).run()
go newIRCHandler(i, h.session).run()
session.user.AddServer(storage.Server{
h.session.user.AddServer(storage.Server{
Name: data.Name,
Address: i.Host,
TLS: data.TLS,
@ -112,112 +127,127 @@ func handleWS(conn *websocket.Conn) {
Realname: data.Realname,
})
} else {
log.Println(addr, "already connected to", data.Server)
log.Println(h.addr, "already connected to", data.Server)
}
}
case "join":
func (h *wsHandler) join(b []byte) {
var data Join
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
if i, ok := h.session.getIRC(data.Server); ok {
i.Join(data.Channels...)
}
}
case "part":
func (h *wsHandler) part(b []byte) {
var data Part
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
if i, ok := h.session.getIRC(data.Server); ok {
i.Part(data.Channels...)
}
case "quit":
var data Quit
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
i.Quit()
session.deleteIRC(data.Server)
channelStore.RemoveUserAll(i.GetNick(), data.Server)
session.user.RemoveServer(data.Server)
}
case "chat":
func (h *wsHandler) quit(b []byte) {
var data Quit
json.Unmarshal(b, &data)
if i, ok := h.session.getIRC(data.Server); ok {
i.Quit()
h.session.deleteIRC(data.Server)
channelStore.RemoveUserAll(i.GetNick(), data.Server)
h.session.user.RemoveServer(data.Server)
}
}
func (h *wsHandler) chat(b []byte) {
var data Chat
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
if i, ok := h.session.getIRC(data.Server); ok {
i.Privmsg(data.To, data.Message)
}
case "nick":
var data Nick
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
i.Nick(data.New)
session.user.SetNick(data.New, data.Server)
}
case "invite":
func (h *wsHandler) nick(b []byte) {
var data Nick
json.Unmarshal(b, &data)
if i, ok := h.session.getIRC(data.Server); ok {
i.Nick(data.New)
h.session.user.SetNick(data.New, data.Server)
}
}
func (h *wsHandler) invite(b []byte) {
var data Invite
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
if i, ok := h.session.getIRC(data.Server); ok {
i.Invite(data.User, data.Channel)
}
}
case "kick":
func (h *wsHandler) kick(b []byte) {
var data Invite
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
if i, ok := h.session.getIRC(data.Server); ok {
i.Kick(data.Channel, data.User)
}
}
case "whois":
func (h *wsHandler) whois(b []byte) {
var data Whois
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
if i, ok := h.session.getIRC(data.Server); ok {
i.Whois(data.User)
}
case "away":
var data Away
json.Unmarshal(req.Request, &data)
if i, ok := session.getIRC(data.Server); ok {
i.Away(data.Message)
}
case "search":
func (h *wsHandler) away(b []byte) {
var data Away
json.Unmarshal(b, &data)
if i, ok := h.session.getIRC(data.Server); ok {
i.Away(data.Message)
}
}
func (h *wsHandler) search(b []byte) {
go func() {
var data SearchRequest
json.Unmarshal(b, &data)
json.Unmarshal(req.Request, &data)
results, err := session.user.SearchMessages(data.Server, data.Channel, data.Phrase)
results, err := h.session.user.SearchMessages(data.Server, data.Channel, data.Phrase)
if err != nil {
log.Println(err)
return
}
session.sendJSON("search", SearchResult{
h.session.sendJSON("search", SearchResult{
Server: data.Server,
Channel: data.Channel,
Results: results,
})
}()
}
func (h *wsHandler) initHandlers() {
h.handlers = map[string]func([]byte){
"uuid": h.init,
"connect": h.connect,
"join": h.join,
"part": h.part,
"quit": h.quit,
"chat": h.chat,
"nick": h.nick,
"invite": h.invite,
"kick": h.kick,
"whois": h.whois,
"away": h.away,
"search": h.search,
}
}