summaryrefslogtreecommitdiff
path: root/internal
diff options
context:
space:
mode:
Diffstat (limited to 'internal')
-rw-r--r--internal/client/client.go21
-rw-r--r--internal/server/handler.go16
-rw-r--r--internal/server/server.go23
-rw-r--r--internal/utils/log/level.go28
-rw-r--r--internal/utils/log/log.go38
-rw-r--r--internal/utils/log/logger.go64
6 files changed, 29 insertions, 161 deletions
diff --git a/internal/client/client.go b/internal/client/client.go
index c2ef6e1..3345a9f 100644
--- a/internal/client/client.go
+++ b/internal/client/client.go
@@ -6,11 +6,10 @@ import (
"crypto/x509"
_ "embed"
"fmt"
+ "log"
"os"
"strings"
"time"
-
- "github.com/kyren223/eko/internal/utils/log"
)
//go:embed server.crt
@@ -19,7 +18,7 @@ var certPEM []byte
func Run() {
certPool := x509.NewCertPool()
if !certPool.AppendCertsFromPEM(certPEM) {
- log.Fatal("failed to append server certificate")
+ log.Fatalf("failed to append server certificate")
}
tlsConfig := &tls.Config{
@@ -27,7 +26,7 @@ func Run() {
ServerName: "localhost",
}
- log.Info("Client started, waiting for user input...")
+ log.Println("client started, waiting for user input...")
for {
fmt.Print("> ")
input, _ := bufio.NewReader(os.Stdin).ReadString('\n')
@@ -37,32 +36,32 @@ func Run() {
}
err := processRequest(input, tlsConfig)
if err != nil {
- log.Error("%v", err)
+ log.Println(err)
}
}
}
func processRequest(request string, tlsConfig *tls.Config) error {
- conn, err := tls.Dial("tcp", ":7223", tlsConfig)
+ conn, err := tls.Dial("tcp4", ":7223", tlsConfig)
if err != nil {
- return fmt.Errorf("Unable to establish connection with server: %v", err)
+ return fmt.Errorf("error establishing connection with server: %v", err)
}
defer conn.Close()
conn.SetDeadline(time.Now().Add(time.Second))
- log.Info("Established connection to server: %v", conn.RemoteAddr().String())
+ log.Println("established connection with server:", conn.RemoteAddr().String())
_, err = conn.Write([]byte(request))
if err != nil {
- return fmt.Errorf("Unable to send request: %v", err)
+ return fmt.Errorf("error sending request: %v", err)
}
buffer := make([]byte, 1024)
n, err := conn.Read(buffer)
if err != nil {
- return fmt.Errorf("Unable to receive response: %v", err)
+ return fmt.Errorf("error receiving response: %v", err)
}
- log.Info("Response from server: %v", string(buffer[:n]))
+ log.Println("server response:", string(buffer[:n]))
return nil
}
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)
}
diff --git a/internal/utils/log/level.go b/internal/utils/log/level.go
deleted file mode 100644
index 1d3ca1b..0000000
--- a/internal/utils/log/level.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package log
-
-type Level int
-
-func (l Level) String() string {
- switch l {
- case LevelDebug:
- return "DEBUG"
- case LevelInfo:
- return "INFO"
- case LevelWarn:
- return "WARN"
- case LevelError:
- return "ERROR"
- case LevelFatal:
- return "FATAL"
- default:
- return ""
- }
-}
-
-const (
- LevelDebug Level = -4
- LevelInfo Level = 0
- LevelWarn Level = 4
- LevelError Level = 8
- LevelFatal Level = 12
-)
diff --git a/internal/utils/log/log.go b/internal/utils/log/log.go
deleted file mode 100644
index 453c998..0000000
--- a/internal/utils/log/log.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package log
-
-var logger *Logger
-
-func SetDefault(l *Logger) {
- logger = l
-}
-
-func Debug(message string, a ...any) {
- _ = logger.Debug(message, a...)
-}
-
-func Info(message string, a ...any) {
- _ = logger.Info(message, a...)
-}
-
-func Warn(message string, a ...any) {
- _ = logger.Warn(message, a...)
-}
-
-func Error(message string, a ...any) {
- _ = logger.Error(message, a...)
-}
-
-func Fatal(message string, a ...any) {
- _ = logger.Fatal(message, a...)
-}
-
-func SetLevel(level Level) (oldLevel Level) {
- oldLevel = logger.Level
- logger.Level = level
- return
-}
-
-func GetLevel() Level {
- return logger.Level
-}
-
diff --git a/internal/utils/log/logger.go b/internal/utils/log/logger.go
deleted file mode 100644
index 942003d..0000000
--- a/internal/utils/log/logger.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package log
-
-import (
- "fmt"
- "io"
- "os"
- "sync"
- "time"
-)
-
-type Logger struct {
- name string
- Level
- writer io.Writer
- mu sync.Mutex
- color bool
-}
-
-func NewLogger(name string, writer io.Writer, ansi bool) *Logger {
- color := ansi && (writer == os.Stdout || writer == os.Stderr)
- return &Logger{name, LevelInfo, writer, sync.Mutex{}, color}
-}
-
-func (l *Logger) Log(level Level, message string, a ...any) error {
- if l.Level > level {
- return nil
- }
-
- timestamp := time.Now().Format(time.TimeOnly)
- severity := level.String()
- formattedMessage := fmt.Sprintf(message, a...)
-
- // TODO: add support for ANSI coloring
- l.mu.Lock()
- _, err := fmt.Fprintf(l.writer, "[%s] [%s/%s]: %s\n", timestamp, l.name, severity, formattedMessage)
- l.mu.Unlock()
- return err
-}
-
-func (l *Logger) Debug(message string, a ...any) error {
- return l.Log(LevelDebug, message, a...)
-}
-
-func (l *Logger) Info(message string, a ...any) error {
- return l.Log(LevelInfo, message, a...)
-}
-
-func (l *Logger) Warn(message string, a ...any) error {
- return l.Log(LevelWarn, message, a...)
-}
-
-func (l *Logger) Error(message string, a ...any) error {
- return l.Log(LevelError, message, a...)
-}
-
-func (l *Logger) Fatal(message string, a ...any) error {
- err := l.Log(LevelError, message, a...)
- if err != nil {
- return err
- }
- os.Exit(1)
- return nil
-}
-
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-10 12:02:08 +0000