CoSync/internal/server/server.go

package server

import (
	"bufio"
	"cosync/internal/core"
	"io"
	"log"
	"net"
	"strconv"
)

// TODO: handle errors, review logging
func Run() {

	log.Println("Loading config")

	// Loading config into program
	err := core.LoadConfig()
	if err != nil {
		log.Fatal(err)
		panic(err)
	}
	config := core.GetConfig()

	log.Println("Loaded")

	serverPort := strconv.Itoa(config["port"].(int))

	// Listening
	listener, err := net.Listen("tcp", ":"+serverPort)
	if err != nil {
		panic(err)
	}
	defer listener.Close()

	log.Println("Server listening on port " + serverPort)

	for {
		conn, err := listener.Accept()
		if err != nil {
			log.Println("Error accepting connection:", err)
			continue
		}
		go handleConnection(conn)
	}
}

func handleConnection(conn net.Conn) {

	// tells the connector to close once exchange ends
	defer conn.Close()

	clientAddress := conn.RemoteAddr().String()
	log.Println("Accepting from ", clientAddress)

	// Read the message sent by the client (line by line)
	reader := bufio.NewReader(conn)
	for {
		message, err := reader.ReadString('\n')
		if err != nil {
			if err == io.EOF {
				log.Println(clientAddress, " disconnected")
				return
			}
			log.Println("Error reading from ", clientAddress, ": ", err)
			return
		}

		// to rm
		println(message)
		// fmt.Println("Received from client:", message)

		// Process the message (e.g., send a response)
		// ...

		// Send a response to the client
		_, err = conn.Write([]byte("Server received your message\n"))
		if err != nil {
			log.Println("Error replying to", clientAddress, ": ", err)
			return
		}
	}
}