WatchDog_Linux-systemd/socket/server.go

package socket

import (
	"Watchdog_Linux-systemd/postLog"
	"bufio"
	"fmt"
	"net"
	"strings"
)

var (
	Conn           net.Conn
	CommandHandler func(string) error
)

func BootSocket(networkType, listenAddr string, listenPort int) error {
	listen, err := net.Listen(networkType, fmt.Sprintf("%s:%d", listenAddr, listenPort))
	if err != nil {
		postLog.Fatal(fmt.Sprintf("[Socket] Failed to listen: %v, err: %v, %v", listenAddr, listenPort, err))
		return fmt.Errorf("failed to listen: %v, err: %v, %v", listenAddr, listenPort, err)
	}
	defer listen.Close()

	postLog.Info(fmt.Sprintf("Server is running on %s:%d", listenAddr, listenPort))

	for {
		Conn, err = listen.Accept()
		if err != nil {
			postLog.Error(fmt.Sprintf("Failed to accept: %v, err: %v", Conn, err))
		}
		go handleRequest()
	}
}

func handleRequest() {
	defer Conn.Close()

	reader := bufio.NewReader(Conn)

	for {
		data, err := reader.ReadBytes('\n')
		if err != nil {
			return
		}

		recvMsg := strings.TrimSpace(string(data))

		responseMsg := ""
		if len(recvMsg) != 0 {
			postLog.Debug(fmt.Sprintf("Received message: %s", recvMsg))
			if recvMsg == "watchdogAgentConnectionTest" {
				responseMsg = "success"
			} else {
				if CommandHandler != nil {
					err := CommandHandler(recvMsg)
					if err != nil {
						responseMsg = fmt.Sprintf("error: %v", err)
					} else {
						responseMsg = "success"
					}
				} else {
					responseMsg = "error: command handler not initialized"
				}
			}
		}

		Conn.Write([]byte(responseMsg + "\n"))
	}
}

func SendMsg(msg string) error {
	if Conn == nil {
		return fmt.Errorf("connection is nil")
	}

	data := []byte(msg + "\n")
	n, err := Conn.Write(data)
	if err != nil {
		return fmt.Errorf("failed to write message: %v", err)
	}

	if n != len(data) {
		return fmt.Errorf("incomplete write: wrote %d bytes out of %d", n, len(data))
	}

	return nil
}