func HandleSocket(s *glue.Socket) {
s.OnClose(func() {
err := UnsubscribeAll(s)
if err != nil {
log.Print(err)
}
})
s.OnRead(func(data string) {
fields := strings.Fields(data)
if len(fields) == 0 {
return
}
switch fields[0] {
case "watch":
if len(fields) != 2 {
return
}
err := Subscribe(s, fields[1])
if err != nil {
log.Print(err)
}
case "touch":
if len(fields) != 4 {
return
}
err := Emit(fields[1], "touch:"+fields[2]+","+fields[3])
if err != nil {
log.Print(err)
}
}
})
}
func (h *Hub) HandleSocket(sock *glue.Socket) {
sock.OnClose(func() {
h.nexus.detach(sock)
})
sock.OnRead(func(data string) {
fields := strings.SplitN(data, " ", 2)
if len(fields) != 2 {
return
}
switch fields[0] {
case "attach":
h.attachInCh <- AttachIn{
Socket: sock,
Token: fields[1],
}
case "change":
data := ChangeData{}
err := json.Unmarshal([]byte(fields[1]), &data)
if err != nil {
h.sendError(sock, "bad request")
return
}
h.changeInCh <- ChangeIn{
Socket: sock,
Change: data.Change(),
}
}
})
}
// ConnectPlayer handles connecting a new player to the game
func (s *Server) ConnectPlayer(socket *glue.Socket) {
// Logging
log15.Debug("socket connected", "address", socket.RemoteAddr())
socket.OnClose(func() {
log15.Debug("socket closed", "address", socket.RemoteAddr())
})
// Attempt to allocate free player Slot
if slot := s.nextSlot(); slot != -1 {
log15.Info("Accepting new player connection", "slot", slot)
s.ConnectedPlayers[slot] = &Player{
Server: s,
Slot: slot,
Socket: socket,
}
s.ConnectedPlayers[slot].Socket.OnClose(func() {
log15.Debug("socket closed", "address", socket.RemoteAddr())
s.DisconnectPlayer(slot)
})
s.NumConnectedPlayers++
s.ConnectedPlayers[slot].Socket.Write(msg.SConnected)
s.ConnectedPlayers[slot].Socket.Write(msg.SDisplayMessage + ":Press [SPACEBAR] To Spawn!")
go s.ConnectedPlayers[slot].ReadLoop()
} else {
// No free slots available
log15.Info("Rejecting new player connection: Server is full!")
socket.Write(msg.SGameFull)
}
}
func onNewSocket(s *glue.Socket) {
// Set a function which is triggered as soon as the socket is closed.
s.OnClose(func() {
log.Printf("socket closed with remote address: %s", s.RemoteAddr())
})
// Set a function which is triggered during each received message.
s.OnRead(func(data string) {
// Echo the received data back to the client.
s.Write(data)
})
// Send a welcome string to the client.
s.Write("Hello Client")
}
func readLoop(s *glue.Socket) {
for {
// Wait for available data.
// Optional: pass a timeout duration to read.
data, err := s.Read()
if err != nil {
// Just return and release this goroutine if the socket was closed.
if err == glue.ErrSocketClosed {
return
}
log.Printf("read error: %v", err)
continue
}
// Echo the received data back to the client.
s.Write(data)
}
}
func onNewSocket(s *glue.Socket) {
s.OnRead(func(data string) {
// Echo back.
s.Write(data)
})
s.OnClose(func() {
println("closed")
})
s.Write("Hello Client")
}
func onNewSocket(s *glue.Socket) {
// Set a function which is triggered as soon as the socket is closed.
s.OnClose(func() {
log.Printf("socket closed with remote address: %s", s.RemoteAddr())
})
// Discard all reads.
// If received data is not discarded, then the read buffer will block as soon
// as it is full, which will also block the keep-alive mechanism of the socket.
// The result would be a closed socket...
s.DiscardRead()
// Send a welcome string to the client.
s.Write("Hello Client")
}
// onNewSocket is triggered as soon as a new socket connects.
func onNewSocket(s *glue.Socket) {
// Create the BitMonster Socket value.
socket := &Socket{
socket: s,
chanCall: s.Channel(channelCall),
chanEvent: s.Channel(channelEvent),
values: make(map[interface{}]interface{}),
valueTimeouts: make(map[interface{}]*time.Timer),
}
// Save itself to the glue Value.
s.Value = socket
// Set the emitter.
// Create a new emitter, set the recover function and the max listeners.
socket.emitter = emission.NewEmitter().
RecoverWith(recoverEmitter).
SetMaxListeners(emitterMaxListeners)
// We won't read any data from the socket itself.
// Discard the received data!
s.DiscardRead()
// Set the function which is triggered as soon as the socket is closed.
s.OnClose(func() {
onCloseSocket(socket)
})
// Prepare the call channel.
socket.chanCall.OnRead(func(data string) {
// Trigger the call request.
handleCallRequest(socket, data)
})
// Prepare the event channel.
socket.chanEvent.OnRead(func(data string) {
// Trigger the event request.
handleEventRequest(socket, data)
})
// Trigger the event.
emitter.Emit(emitterOnNewSocket, socket)
}
func onNewSocket(s *glue.Socket) {
// Set a function which is triggered as soon as the socket is closed.
s.OnClose(func() {
log.Printf("socket closed with remote address: %s", s.RemoteAddr())
})
// Run the read loop in a new goroutine.
go readLoop(s)
// Send a welcome string to the client.
s.Write("Hello Client")
}
func onNewSocket(s *glue.Socket) {
// We won't read any data from the socket itself.
// Discard received data!
s.DiscardRead()
// Set a function which is triggered as soon as the socket is closed.
s.OnClose(func() {
log.Printf("socket closed with remote address: %s", s.RemoteAddr())
})
// Create a channel.
c := s.Channel("golang")
// Set the channel on read event function.
c.OnRead(func(data string) {
// Echo the received data back to the client.
c.Write("channel golang: " + data)
})
// Write to the channel.
c.Write("Hello Gophers!")
}
func (h *Hub) sendError(sock *glue.Socket, msg string) {
sock.Write("error " + strconv.Quote(msg))
}