✨ setup tcp and upd sample

Author: yuanyu90221

.github/workflows/go.yml

@@ -0,0 +1,28 @@
+name: Go
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+jobs:
+  build_and_test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup go-task
+        uses: pnorton5432/setup-task@v1
+        with:
+          task-version: 3.29.1
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'
+          check-latest: true
+      - name: Task Build for mage
+        run: task build-gg
+      - name: Test with gg
+        run: ./gg test

.gitignore

@@ -0,0 +1,28 @@
+# If you prefer the allow list template instead of the deny list, see community template:
+# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore
+#
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/
+
+# Go workspace file
+go.work
+go.work.sum
+
+# env file
+.env
+gg
+mage
+bin

README.md

@@ -0,0 +1,109 @@
+# golang-sample-with-tcp-udp-socket
+
+  This repository is demo how to use tcp and udp socket in golang
+
+## tcp logic
+
+```golang
+func main() {
+	// setup logger
+	ctx := context.Background()
+	ulog := logger.FromContext(ctx)
+	// create tcp socket
+	listener, err := net.Listen("tcp", config.AppConfig.ServerURI)
+	if err != nil {
+		ulog.ErrorContext(ctx, "failed to listen", slog.Any("addr", listener.Addr().String()))
+		os.Exit(1)
+	}
+	defer listener.Close()
+
+	for {
+		// Accept an incoming connection
+		conn, err := listener.Accept()
+		if err != nil {
+			ulog.ErrorContext(ctx, "failed to accept request", slog.Any("err", err))
+		}
+
+		// Handle the connection
+		go handleConnectionNonBlocking(ctx, conn)
+	}
+}
+
+// handleConnectionNonBlocking - nonblock reading with setup conn read/write timeout
+func handleConnectionNonBlocking(ctx context.Context, conn net.Conn) {
+	hlog := logger.FromContext(ctx)
+	defer conn.Close()
+	for {
+		// Set a deadline for reading data
+		conn.SetReadDeadline(time.Now().Add(time.Second))
+		// Read from client
+		buf := make([]byte, 1024)
+		// block util read timeout
+		n, err := conn.Read(buf)
+		if err != nil {
+			if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+				// The read operation timeout, continue waiting for next read
+				continue
+			} else if !errors.Is(err, io.EOF) {
+				// Other errors (client disconnected, etc)
+				hlog.ErrorContext(ctx, "Connection closed", slog.Any("err", err))
+				break
+			}
+		}
+		if n > 0 {
+			msg := string(buf[:n])
+			hlog.InfoContext(ctx, "Received", slog.String("message", msg))
+
+			// Set a deadline for writing data
+			conn.SetWriteDeadline(time.Now().Add(time.Second))
+			// Send a response to the client
+			_, err = fmt.Fprintf(conn, "Echo - %s", msg)
+			if err != nil {
+				hlog.ErrorContext(ctx, "error writing to client", slog.Any("err", err))
+				break
+			}
+		}
+	}
+}
+```
+## udp logic
+```golang
+func main() {
+	// setup logger
+	ctx := context.Background()
+	ulog := logger.FromContext(ctx)
+	// setup connection socket with udp
+	addr, err := net.ResolveUDPAddr("udp", config.AppConfig.ServerURI)
+	if err != nil {
+		ulog.InfoContext(ctx, "failed to resolve addr", slog.Any("err", err))
+		os.Exit(1)
+	}
+	conn, err := net.ListenUDP("udp", addr)
+	if err != nil {
+		ulog.ErrorContext(ctx, "failed to listen udp", slog.Any("err", err))
+		os.Exit(2)
+	}
+	defer conn.Close()
+
+	for {
+		// Read a message from the client
+		buf := make([]byte, 1024)
+		n, clientAddr, err := conn.ReadFromUDP(buf)
+		if err != nil {
+			ulog.ErrorContext(ctx, "Error reading", slog.Any("err", err))
+			continue
+		}
+
+		if n > 0 {
+			msg := string(buf[:n])
+			// Print received message
+			ulog.InfoContext(ctx, "Received message", slog.Any("clientAddr", clientAddr), slog.String("message", msg))
+			// Send response to the client
+			_, err = conn.WriteToUDP([]byte("Hey client!"), clientAddr)
+			if err != nil {
+				ulog.ErrorContext(ctx, "error writing", slog.Any("err", err))
+			}
+		}
+	}
+}
+```

Taskfile.yml

@@ -0,0 +1,42 @@
+version: '3'
+
+dotenv: ['.env']
+
+tasks:
+  default:
+    cmds:
+      - echo "SERVER_URI=$SERVER_URI"
+    silent: true
+  
+  # build:
+  #   cmds:
+  #     - CGO_ENABLED=0 GOOS=linux go build -o bin/main cmd/main.go
+  #   silent: true
+  # run:
+  #   cmds:
+  #     - ./bin/main
+  #   deps:
+  #     - build
+  #   silent: true
+
+  build-mage:
+    cmds:
+      - CGO_ENABLED=0 GOOS=linux go build -o ./mage mage-tools/mage.go
+    silent: true
+  
+  build-gg:
+    cmds:
+      - ./mage -d mage-tools -compile ../gg
+    deps:
+      - build-mage
+    silent: true
+
+  coverage:
+    cmds:
+      - go test -v -cover ./...
+    silent: true
+  test:
+    cmds:
+      - go test -v ./...
+    silent: true
+  

cmd/tcp-client/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"net"
+	"os"
+
+	"github.com/leetcode-golang-classroom/golang-sample-with-tcp-udp-socket/internal/config"
+	"github.com/leetcode-golang-classroom/golang-sample-with-tcp-udp-socket/internal/logger"
+)
+
+func main() {
+	// setup logger
+	ctx := context.Background()
+	ulog := logger.FromContext(ctx)
+	// Create a TCP socket
+	conn, err := net.Dial("tcp", config.AppConfig.ServerURI)
+	if err != nil {
+		ulog.ErrorContext(ctx, "failed to connect tcp", slog.Any("err", err))
+		os.Exit(1)
+	}
+
+	// Send a message
+	fmt.Fprint(conn, "Hello!")
+
+	// Read a response
+	buf := make([]byte, 1024)
+	n, err := conn.Read(buf)
+	if err != nil {
+		ulog.ErrorContext(ctx, "failed to read", slog.Any("err", err))
+	}
+	msg := string(buf[:n])
+	ulog.InfoContext(ctx, "server reply", slog.String("message", msg))
+	conn.Close()
+}

cmd/tcp-server/main.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"os"
+	"time"
+
+	"github.com/leetcode-golang-classroom/golang-sample-with-tcp-udp-socket/internal/config"
+	"github.com/leetcode-golang-classroom/golang-sample-with-tcp-udp-socket/internal/logger"
+)
+
+func main() {
+	// setup logger
+	ctx := context.Background()
+	ulog := logger.FromContext(ctx)
+	// create tcp socket
+	listener, err := net.Listen("tcp", config.AppConfig.ServerURI)
+	if err != nil {
+		ulog.ErrorContext(ctx, "failed to listen", slog.Any("addr", listener.Addr().String()))
+		os.Exit(1)
+	}
+	defer listener.Close()
+
+	for {
+		// Accept an incoming connection
+		conn, err := listener.Accept()
+		if err != nil {
+			ulog.ErrorContext(ctx, "failed to accept request", slog.Any("err", err))
+		}
+
+		// Handle the connection
+		go handleConnectionNonBlocking(ctx, conn)
+	}
+}
+
+// handleConnectionNonBlocking - nonblock reading with setup conn read/write timeout
+func handleConnectionNonBlocking(ctx context.Context, conn net.Conn) {
+	hlog := logger.FromContext(ctx)
+	defer conn.Close()
+	for {
+		// Set a deadline for reading data
+		conn.SetReadDeadline(time.Now().Add(time.Second))
+		// Read from client
+		buf := make([]byte, 1024)
+		// block util read timeout
+		n, err := conn.Read(buf)
+		if err != nil {
+			if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
+				// The read operation timeout, continue waiting for next read
+				continue
+			} else if !errors.Is(err, io.EOF) {
+				// Other errors (client disconnected, etc)
+				hlog.ErrorContext(ctx, "Connection closed", slog.Any("err", err))
+				break
+			}
+		}
+		if n > 0 {
+			msg := string(buf[:n])
+			hlog.InfoContext(ctx, "Received", slog.String("message", msg))
+
+			// Set a deadline for writing data
+			conn.SetWriteDeadline(time.Now().Add(time.Second))
+			// Send a response to the client
+			_, err = fmt.Fprintf(conn, "Echo - %s", msg)
+			if err != nil {
+				hlog.ErrorContext(ctx, "error writing to client", slog.Any("err", err))
+				break
+			}
+		}
+	}
+}

cmd/udp-client/main.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"context"
+	"log/slog"
+	"net"
+	"os"
+	"time"
+
+	"github.com/leetcode-golang-classroom/golang-sample-with-tcp-udp-socket/internal/config"
+	"github.com/leetcode-golang-classroom/golang-sample-with-tcp-udp-socket/internal/logger"
+)
+
+func main() {
+	// setup logger
+	ctx := context.Background()
+	ulog := logger.FromContext(ctx)
+	// Create UDP connection
+	conn, err := net.Dial("udp", config.AppConfig.ServerURI)
+	if err != nil {
+		ulog.ErrorContext(ctx, "failed to dial", slog.Any("err", err))
+		os.Exit(1)
+	}
+	defer conn.Close()
+
+	// Send message to the server
+	message := "Hello UDP Server"
+	_, err = conn.Write([]byte(message))
+	if err != nil {
+		ulog.ErrorContext(ctx, "failed to sending message", slog.Any("err", err))
+		return
+	}
+	ulog.InfoContext(ctx, "Sent:", slog.String("message", message))
+	// Set read deadline to avoid blocking indefinitely
+	conn.SetReadDeadline(time.Now().Add(5 * time.Second))
+
+	// Receive response from server
+	buf := make([]byte, 1024)
+	n, err := conn.Read(buf)
+	if err != nil {
+		ulog.InfoContext(ctx, "errror reading from server", slog.Any("err", err))
+		return
+	}
+	if n > 0 {
+		receivedMsg := string(buf[:n])
+		ulog.InfoContext(ctx, "Received:", slog.String("receivedMsg", receivedMsg))
+	}
+}