Hey there, I’m trying to use the below code in a TCP server application, it goes fine, but CPU usage reaches 100%. Could anyone help me?
package main
import (
"bufio"
"bytes"
"encoding/hex"
"log"
"net"
"strings"
)
// Client holds info about connection
type TCPClient struct {
conn net.Conn
Server *server
}
// TCP server
type server struct {
clients []*TCPClient
address string // Address to open connection: localhost:9999
onNewClientCallback func(c *TCPClient)
onClientConnectionClosed func(c *TCPClient, err error)
onNewMessage func(c *TCPClient, message string)
}
// dropCR drops a terminal \r from the data.
func dropCR(data []byte) []byte {
if len(data) > 0 && data[len(data)-1] == '\r' {
return data[0 : len(data)-1]
}
return data
}
func ScanCRLF(data []byte, atEOF bool) (advance int, token []byte, err error) {
if atEOF && len(data) == 0 {
return 0, nil, nil
}
if i := bytes.Index(data, []byte{'\r'}); i >= 0 {
// We have a full newline-terminated line.
return i + 1, dropCR(data[0:i]), nil
}
// If we're at EOF, we have a final, non-terminated line. Return it.
if atEOF {
return len(data), dropCR(data), nil
}
// Request more data.
return 0, nil, nil
}
// Read client data from channel
func (c *TCPClient) listen() {
for {
message, _ := bufio.NewReader(c.conn).ReadString('\r')
Rec := strings.TrimSpace(strings.ToUpper(string(message)))
c.Server.onNewMessage(c, strings.Replace(Rec, "\r", "", -1))
}
go c.listen()
}
// Send text message to client
func (c *TCPClient) Send(message string) error {
hexbytes, _ := hex.DecodeString(message)
_, err := c.conn.Write([]byte(hexbytes))
return err
}
func (c *TCPClient) Conn() net.Conn {
return c.conn
}
func (c *TCPClient) Close() error {
return c.conn.Close()
}
// Called right after server starts listening new client
func (s *server) OnNewClient(callback func(c *TCPClient)) {
s.onNewClientCallback = callback
}
// Called right after connection closed
func (s *server) OnClientConnectionClosed(callback func(c *TCPClient, err error)) {
s.onClientConnectionClosed = callback
}
// Called when Client receives new message
func (s *server) OnNewMessage(callback func(c *TCPClient, message string)) {
s.onNewMessage = callback
}
// Start network server
func (s *server) Listen() {
listener, err := net.Listen("tcp", s.address)
if err != nil {
log.Fatal("Error starting TCP server.")
}
defer listener.Close()
for {
conn, _ := listener.Accept()
client := &TCPClient{
conn: conn,
Server: s,
}
go client.listen()
s.onNewClientCallback(client)
}
}
// Creates new tcp server instance
func NewTCP(address string) *server {
server := &server{
address: address,
}
server.OnNewClient(func(c *TCPClient) {})
server.OnNewMessage(func(c *TCPClient, message string) {})
server.OnClientConnectionClosed(func(c *TCPClient, err error) {})
return server
}