deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: tcp-server-fast
  labels:
    app: tcp-server
spec:
  replicas: 2
  selector:
    matchLabels:
      app: tcp-server
  template:
    metadata:
      labels:
        app: tcp-server
    spec:
      containers:
        - name: tcp-server-container
          image: 662591887723.dkr.ecr.us-west-2.amazonaws.com/jianfei-dev:tcp-server-0730b
          imagePullPolicy: Always
          args: ["--delay", "0", "--port", "9000"]
          ports:
            - containerPort: 9000
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: tcp-server-delay
  labels:
    app: tcp-server
spec:
  replicas: 1
  selector:
    matchLabels:
      app: tcp-server
  template:
    metadata:
      labels:
        app: tcp-server
    spec:
      containers:
        - name: tcp-server-container
          image: 662591887723.dkr.ecr.us-west-2.amazonaws.com/jianfei-dev:tcp-server-0730b
          imagePullPolicy: Always
          args: ["--delay", "3000", "--port", "9000"]
          ports:
            - containerPort: 9000
---
apiVersion: v1
kind: Service
metadata:
  name: tcp-server-service
  labels:
    app: tcp-server
spec:
  selector:
    app: tcp-server
  ports:
    - protocol: TCP
      port: 9000
      targetPort: 9000
  type: ClusterIP

Dockerfile

# Use the official Ubuntu as a base image
FROM ubuntu:latest

# Set the working directory inside the container
WORKDIR /app

# Copy the Go binary from the host to the container
COPY server /app/server

# Set the binary as the entry point
ENTRYPOINT ["./server"]

server.go

package main

import (
	"flag"
	"fmt"
	"net"
	"sync/atomic"
	"time"
)

var (
	port *int
)

func main() {
	// Define a command-line flag for the initial delay
	initialDelay := flag.Int("delay", 0, "Initial delay in seconds for the first three requests")
	port = flag.Int("port", 8080, "port")
	flag.Parse()

	// Start listening on the specified port
	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
	if err != nil {
		fmt.Println("Error starting server:", err)
		return
	}
	defer listener.Close()
	fmt.Printf("Server is listening on port %d...\n", *port)

	// Counter for tracking the number of handled requests
	var requestCount int32

	for {
		// Accept a new connection
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Error accepting connection:", err)
			continue
		}

		// Handle the connection in a new goroutine
		go handleConnection(conn, *initialDelay, &requestCount)
	}
}

func handleConnection(conn net.Conn, initialDelay int, requestCount *int32) {
	defer conn.Close()

	// Increment the request count
	count := atomic.AddInt32(requestCount, 1)

	// Delay the response if the request count is 1, 2, or 3
	if count <= 3000 {
		fmt.Printf("Delaying for %d seconds for request %d...\n", initialDelay, count)
		time.Sleep(time.Duration(initialDelay) * time.Second)
	}

	// Construct the HTTP response
	responseBody := fmt.Sprintf("from port %d, delayt %v", *port, initialDelay)
	response := fmt.Sprintf("HTTP/1.1 200 OK\r\n"+
		"Content-Type: text/plain\r\n"+
		"Content-Length: %d\r\n"+
		"Connection: close\r\n"+
		"\r\n"+
		"%s", len(responseBody), responseBody)

	// Send the response back to the client
	_, err := conn.Write([]byte(response))
	if err != nil {
		fmt.Println("Error sending response:", err)
		return
	}

	fmt.Printf("Response sent to client for request %d.\n", count)
}