remove: custom logging in favor of standard lib log package

2 files changed, 19 insertions, 20 deletions

diff --git a/internal/server/handler.go b/internal/server/handler.go
index 88309b4..83d3e6e 100644
--- a/internal/server/handler.go
+++ b/internal/server/handler.go
@@ -2,33 +2,31 @@ package server
 
 import (
 	"fmt"
+	"log"
 	"net"
 	"sync"
-
-	"github.com/kyren223/eko/internal/utils/log"
 )
 
 func handleConnection(conn net.Conn, wg *sync.WaitGroup) {
-	log.Info("Accepted client: %v", conn.RemoteAddr().String())
-	defer log.Info("Disconnecting client: %v", conn.RemoteAddr().String())
+	log.Println("accepted client:", conn.RemoteAddr().String())
+	defer log.Println("disconnected client:", conn.RemoteAddr().String())
 	defer conn.Close()
 	defer wg.Done()
 
 	buffer := make([]byte, 1024)
 	bytesRead, err := conn.Read(buffer)
 	if err != nil {
-		log.Error("Failed reading: %v", err)
+		log.Println("failed reading request:", err)
 		return
 	}
 	request := string(buffer[:bytesRead])
-	log.Info("Read %v bytes: %v", bytesRead, request)
+	log.Printf("Read %v bytes: %v\n", bytesRead, request)
 
 	response := []byte(fmt.Sprintf("Eko \"%v\"", request))
 	bytesWritten, err := conn.Write(response)
 	if err != nil {
-		log.Error("Failed writing response: %v", err)
+		log.Println("failed writing response:", err)
 		return
 	}
-	log.Info("Written %v bytes", bytesWritten)
+	log.Printf("written %v bytes\n", bytesWritten)
 }
-
diff --git a/internal/server/server.go b/internal/server/server.go
index aeb97f8..55e0763 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -3,14 +3,14 @@ package server
 import (
 	"crypto/tls"
 	_ "embed"
+	"errors"
+	"log"
 	"net"
 	"os"
 	"os/signal"
 	"strconv"
 	"sync"
 	"syscall"
-
-	"github.com/kyren223/eko/internal/utils/log"
 )
 
 const port = 7223
@@ -24,16 +24,16 @@ var keyPEM []byte
 func Start() {
 	cert, err := tls.X509KeyPair(certPEM, keyPEM)
 	if err != nil {
-		log.Fatal("Error loading certificate: %s", err)
+		log.Fatalf("error loading certificate: %s", err)
 	}
 
 	tlsConfig := &tls.Config{
 		Certificates: []tls.Certificate{cert},
 	}
 
-	listener, err := tls.Listen("tcp", ":"+strconv.Itoa(port), tlsConfig)
+	listener, err := tls.Listen("tcp4", ":"+strconv.Itoa(port), tlsConfig)
 	if err != nil {
-		log.Fatal("Error starting listener: %s", err)
+		log.Fatal("error starting server: %s", err)
 	}
 	defer listener.Close()
 
@@ -47,22 +47,23 @@ func Start() {
 }
 
 func handleInterrupt(listener net.Listener, stopChan <-chan os.Signal) {
-	<-stopChan
-	log.Info("Interrupt Signal")
-	log.Info("Closing listener from receiving new connections")
+	signal := <-stopChan
+	log.Println(signal.String())
 	listener.Close()
 }
 
 func listen(listener net.Listener, wg *sync.WaitGroup) {
-	log.Info("Started listening on port %v...", port)
+	log.Printf("started listening on port %v...\n", port)
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
-			log.Warn("Failed to accept connection: %v", err)
+			if !errors.Is(err, net.ErrClosed) {
+				log.Println("error accepting connection:", err)
+			}
 			break
 		}
 		wg.Add(1)
 		go handleConnection(conn, wg)
 	}
-	log.Info("Stopped listening on port %v...", port)
+	log.Printf("stopped listening on port %v...\n", port)
 }