func echoHandler(session sockjs.Session) {
log.Println("new sockjs session established")
var closedSession = make(chan struct{})
chat.Publish("[info] new participant joined chat")
defer chat.Publish("[info] participant left chat")
go func() {
reader, _ := chat.SubChannel(nil)
for {
select {
case <-closedSession:
return
case msg := <-reader:
if err := session.Send(msg.(string)); err != nil {
return
}
}
}
}()
for {
if msg, err := session.Recv(); err == nil {
chat.Publish(msg)
continue
}
break
}
close(closedSession)
log.Println("sockjs session closed")
}
func send(s sockjs.Session, data interface{}) error {
b, err := json.Marshal(data)
if err != nil {
return err
}
return s.Send(string(b))
}
func echoHandler(session sockjs.Session) {
log.Println("new sockjs session established")
for {
if msg, err := session.Recv(); err == nil {
session.Send(msg)
continue
}
break
}
log.Println("sockjs session closed")
}
func respondError(session sockjs.Session, message string) {
result := cmd.Response{
Status: "error",
Result: message,
}
response, err := json.Marshal(result)
if err != nil {
panic(err)
}
session.Send(string(response))
}
func wsHandler(session sockjs.Session) {
log.Println("new sockjs session established")
go func() {
reader, _ := broadcaster.SubChannel(nil)
for {
status := <-reader
if err := session.Send(status.(string)); err != nil {
return
}
}
}()
}
func echoHandler(conn sockjs.Session) {
log.Println("New connection created")
for {
if msg, err := conn.Recv(); err != nil {
break
} else {
if err := conn.Send(msg); err != nil {
break
}
}
}
log.Println("Sessionection closed")
}
func (this *Room) AddClient(client sockjs.Session) {
if this.Len() >= this.max {
return
} else if indexOf(this.clients, client) == -1 {
message := "{\"type\":\"userConnected\"}"
this.sendToAll(message)
for i := 0; i < this.Len(); i++ {
client.Send(message)
}
this.clients = append(this.clients, client)
}
}
func (ws *Ws) Handler(session sockjs.Session) {
for {
if msg, err := session.Recv(); err == nil {
log.Printf("ws: received: %v", msg)
message := map[string]interface{}{}
err = json.Unmarshal([]byte(msg), &message)
if err != nil {
respondError(session, err.Error())
continue
}
command, ok := message["cmd"]
if !ok {
respondError(session, "`cmd` field must be specified!")
continue
}
commandName, ok := command.(string)
if !ok {
respondError(session, "`cmd` must be a string")
continue
}
params, ok := message["params"]
if !ok {
respondError(session, "`params` field must be specified!")
continue
}
paramsMap, ok := params.(map[string]interface{})
if !ok {
respondError(session, "`params` must be an object!")
continue
}
result, err := ws.Run(commandName, paramsMap)
if err != nil {
respondError(session, err.Error())
continue
}
response, err := json.Marshal(result)
if err != nil {
panic(err)
}
session.Send(string(response))
} else {
log.Println(err)
break
}
}
}
func echoHandler(session sockjs.Session) {
for {
if msg, err := session.Recv(); err == nil {
session.Send(msg)
continue
}
break
}
}
func receiveMessage(session sockjs.Session) {
reader, _ := pub.SubChannel(nil)
for {
select {
case msg, ok := <-reader:
if !ok {
log.Println("channel closed")
return
}
msg = msg.(*socketMessage)
if body, err := json.Marshal(msg); err == nil {
log.Println("message:", string(body))
if err = session.Send(string(body)); err != nil {
log.Println(err)
return
}
}
}
}
}
func echoHandler(session sockjs.Session) {
log.Println("new sockjs session established")
var closedSession = make(chan struct{})
session.Send(session.ID())
go func() {
reader, _ := chat.SubChannel(nil)
for {
select {
case <-closedSession:
return
case msg := <-reader:
if err := session.Send(msg.(string)); err != nil {
return
}
}
}
}()
for {
if msg, err := session.Recv(); err == nil {
data := &WSDataSchema{}
buf := bytes.NewBufferString(msg)
err = json.Unmarshal(buf.Bytes(), data)
if err == nil {
_type := data.Type
_endpoint := data.Endpoint
_id := data.Id
if _type == "container" {
session.Send(_endpoint + _id)
break
}
}
chat.Publish(msg)
//session.Send(msg)
continue
}
break
}
close(closedSession)
log.Println("sockjs session closed")
}
func Chat(session sockjs.Session) {
glog.Info("Session started")
sessionId := session.ID()
chatSession := &ChatSession{
Id: sessionId,
IsReady: false,
Session: &session,
}
ChatSessions.Set(sessionId, chatSession)
acceptedTypes := &map[string]string{
"image/jpeg": ".jpg",
"image/jpg": ".jpg",
"image/png": ".png",
"image/gif": ".gif",
}
ticker := time.NewTicker(time.Second)
// Not too nice, will be refactored later...
online := func() {
ready, chatting := ChatSessions.GetNumberOfReadyAndChatting()
msg := &ChatMessage{
"event": "online",
"r": ready,
"c": chatting,
}
out, _ := json.Marshal(msg)
body := string(out)
session.Send(body)
}
go func() {
for _ = range ticker.C {
online()
}
}()
online()
for {
if msg, err := session.Recv(); err == nil {
var data ChatMessage
json.Unmarshal([]byte(msg), &data)
switch data["event"] {
case "ready":
ChatReady(sessionId, data["region"].(string))
case "typing":
ChatSessions.Action(func() {
chatSession.Room.BroadcastOthers(sessionId, "typing", strconv.FormatBool(data["typing"].(bool)))
})
case "send":
ChatSessions.Action(func() {
chatSession.Room.BroadcastOthers(sessionId, "message", data["message"].(string))
})
case "exit":
ChatSessions.Action(func() {
glog.Info("Chat session ended")
chatSession.Room.BroadcastOthers(sessionId, "exit", "")
for i, _ := range chatSession.Room.Sessions {
s := chatSession.Room.Sessions[i]
if s != chatSession {
s.Room = nil
}
//s.IsReady = true
}
chatSession.Room = nil
})
case "picture":
glog.Info("Picture received")
ChatSessions.Action(func() {
chatSession.Room.BroadcastOthers(sessionId, "picturebefore", "true")
dataURL, err := dataurl.DecodeString(data["data"].(string))
if err != nil {
glog.Error("Problem decoding file: ", err)
}
filename := helpers.GetRandomString(8)
mt := dataURL.ContentType()
if ext, ok := (*acceptedTypes)[mt]; ok {
err = ioutil.WriteFile(MediaContent+filename+ext, dataURL.Data, 0644)
if err != nil {
glog.Error("Error saving file: ", err)
}
chatSession.Room.BroadcastOthers(sessionId, "picture", data["data"].(string))
}
})
}
continue
}
break
}
ticker.Stop()
ChatSessions.Close(sessionId)
glog.Info("Session closed")
}
func SendJsonMessage(session sockjs.Session, json string) {
session.Send(json)
}