Exemple #1
0
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)
			}
		}
	})
}
Exemple #2
0
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(),
			}
		}
	})
}
Exemple #3
0
// 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)
	}
}
Exemple #4
0
Fichier : main.go Projet : e4x/glue
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")
}
Exemple #5
0
func onNewSocket(s *glue.Socket) {
	s.OnRead(func(data string) {
		// Echo back.
		s.Write(data)
	})

	s.OnClose(func() {
		println("closed")
	})

	s.Write("Hello Client")
}
Exemple #6
0
Fichier : main.go Projet : e4x/glue
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")
}
Exemple #7
0
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")
}
Exemple #8
0
// 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)
}
Exemple #9
0
Fichier : main.go Projet : e4x/glue
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!")
}