add Worker pools exercise templates (zhravan#157)

Signed-off-by: Kaushalya Pradeep <24698778+kaushalyap@users.noreply.github.com>
Co-authored-by: kaushalyap <24698778+kaushalyap@users.noreply.github.com>

Author: Sayan-995

internal/exercises/catalog.yaml

@@ -217,7 +217,19 @@ concepts:
     - "Call wg.Add(1) before starting a goroutine and wg.Done() when it finishes."
     - "Close result channels after wg.Wait() so collectors can range over them."
     - "Capture loop variables correctly inside goroutines (e.g., `n := n`)."
-    - "Return results as a slice — order does not need to match input order
+    - "Return results as a slice — order does not need to match input order"
+    
+- slug: 43_worker_pools
+  title: Worker Pools
+  test_regex: ".*"
+  hints:
+    - Create separate channels for jobs (send work) and results (receive processed data).
+    - Launch multiple worker goroutines that read from jobs channel and write to results channel.
+    - Use channel directions (<-chan for receive-only, chan<- for send-only) in worker function signature.
+    - Close the jobs channel after sending all work to signal workers to finish.
+    - Use strings.TrimSpace() to clean message strings by removing leading/trailing whitespace.
+    - Collect exactly len(logs) results to ensure all work is processed.
+    
 projects:
 - slug: 101_text_analyzer
   title: Text Analyzer (Easy)

internal/exercises/solutions/43_worker_pools/worker_pools.go

@@ -0,0 +1,93 @@
+package worker_pools
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// Use case: Log Processing System
+// You're building a log processing system that needs to analyze logs from
+// multiple servers. Each log entry needs to be parsed, validated, and
+// transformed before being stored. Using a worker pool pattern ensures
+// efficient processing of thousands of log entries without overwhelming
+// system resources.
+
+// LogEntry represents a single log entry to process
+type LogEntry struct {
+	ID        int
+	Timestamp string
+	Level     string
+	Message   string
+}
+
+// ProcessedLog represents a log after processing
+type ProcessedLog struct {
+	ID             int
+	Severity       int // 1=INFO, 2=WARNING, 3=ERROR
+	CleanedMessage string
+}
+
+// processLog processes a single log entry
+func processLog(log LogEntry) ProcessedLog {
+	fmt.Printf("Processing log ID: %d\n", log.ID)
+	time.Sleep(5 * time.Microsecond) // Simulate processing time
+
+	// Convert level to severity
+	severity := 1 // Default INFO
+	switch log.Level {
+	case "INFO":
+		severity = 1
+	case "WARNING":
+		severity = 2
+	case "ERROR":
+		severity = 3
+	}
+
+	// Clean message
+	cleanedMessage := strings.TrimSpace(log.Message)
+
+	return ProcessedLog{
+		ID:             log.ID,
+		Severity:       severity,
+		CleanedMessage: cleanedMessage,
+	}
+}
+
+// worker receives jobs from a channel, processes them, and sends results
+func worker(id int, jobs <-chan LogEntry, results chan<- ProcessedLog) {
+	for job := range jobs {
+		fmt.Printf("Worker %d processing log %d\n", id, job.ID)
+		processed := processLog(job)
+		results <- processed
+	}
+}
+
+// LogProcessor creates a worker pool and processes all logs
+func LogProcessor(logs []LogEntry, numWorkers int) []ProcessedLog {
+	// Create channels
+	jobs := make(chan LogEntry, len(logs))
+	results := make(chan ProcessedLog, len(logs))
+
+	// Start worker pool
+	for w := 1; w <= numWorkers; w++ {
+		go worker(w, jobs, results)
+	}
+
+	// Send jobs
+	go func() {
+		for _, log := range logs {
+			jobs <- log
+		}
+		close(jobs)
+	}()
+
+	// Collect results
+	processed := make([]ProcessedLog, 0, len(logs))
+	for i := 0; i < len(logs); i++ {
+		result := <-results
+		processed = append(processed, result)
+	}
+
+	return processed
+}

internal/exercises/templates/43_worker_pools/worker_pools.go

@@ -0,0 +1,71 @@
+package worker_pools
+
+import (
+	"fmt"
+	"time"
+)
+
+// Use case: Log Processing System
+// You're building a log processing system that needs to analyze logs from
+// multiple servers. Each log entry needs to be parsed, validated, and
+// transformed before being stored. Using a worker pool pattern ensures
+// efficient processing of thousands of log entries without overwhelming
+// system resources.
+
+// LogEntry represents a single log entry to process
+type LogEntry struct {
+	ID        int
+	Timestamp string
+	Level     string
+	Message   string
+}
+
+// ProcessedLog represents a log after processing
+type ProcessedLog struct {
+	ID             int
+	Severity       int // 1=INFO, 2=WARNING, 3=ERROR
+	CleanedMessage string
+}
+
+// TODO: 1. Implement processLog function that processes a single log entry
+// It should:
+// - Convert log level string to severity int (INFO=1, WARNING=2, ERROR=3)
+// - Clean the message by trimming spaces
+// - Return a ProcessedLog
+func processLog(log LogEntry) ProcessedLog {
+	fmt.Printf("Processing log ID: %d\n", log.ID)
+	time.Sleep(5 * time.Millisecond) // Simulate processing time
+
+	// TODO: Implement log processing logic
+	return ProcessedLog{}
+}
+
+// TODO: 2. Implement worker function that:
+// - Takes an ID, jobs channel (receive-only), and results channel (send-only)
+// - Continuously receives LogEntry from jobs channel
+// - Processes each log using processLog
+// - Sends ProcessedLog to results channel
+// - Stops when jobs channel is closed
+func worker(id int, jobs <-chan LogEntry, results chan<- ProcessedLog) {
+	// TODO: Implement worker logic with proper channel directions
+	fmt.Println("Worker started")
+}
+
+// TODO: 3. Implement LogProcessor that:
+// - Creates jobs and results channels
+// - Spawns numWorkers worker goroutines
+// - Sends all logs to the jobs channel in a separate goroutine
+// - Collects all processed results
+// - Returns slice of ProcessedLog
+func LogProcessor(logs []LogEntry, numWorkers int) []ProcessedLog {
+	// TODO: Create channels
+
+	// TODO: Start worker pool
+
+	// TODO: Send jobs
+
+	// TODO: Collect results
+
+	processed := []ProcessedLog{}
+	return processed
+}

internal/exercises/templates/43_worker_pools/worker_pools_test.go

@@ -0,0 +1,167 @@
+package worker_pools
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestProcessLog(t *testing.T) {
+	log := LogEntry{
+		ID:        1,
+		Timestamp: "2025-10-15T10:30:00Z",
+		Level:     "ERROR",
+		Message:   "  Database connection failed  ",
+	}
+
+	result := processLog(log)
+
+	if result.ID != 1 {
+		t.Errorf("Expected ID 1, got %d", result.ID)
+	}
+
+	if result.Severity != 3 {
+		t.Errorf("Expected severity 3 for ERROR, got %d", result.Severity)
+	}
+
+	if result.CleanedMessage != "Database connection failed" {
+		t.Errorf("Expected cleaned message 'Database connection failed', got '%s'", result.CleanedMessage)
+	}
+}
+
+func TestLogProcessor(t *testing.T) {
+	t.Run("Process all logs successfully", func(t *testing.T) {
+		logs := []LogEntry{
+			{ID: 1, Timestamp: "2025-10-15T10:30:00Z", Level: "INFO", Message: "  Server started  "},
+			{ID: 2, Timestamp: "2025-10-15T10:31:00Z", Level: "WARNING", Message: "High memory usage"},
+			{ID: 3, Timestamp: "2025-10-15T10:32:00Z", Level: "ERROR", Message: "Connection timeout"},
+			{ID: 4, Timestamp: "2025-10-15T10:33:00Z", Level: "INFO", Message: "Request completed"},
+			{ID: 5, Timestamp: "2025-10-15T10:34:00Z", Level: "ERROR", Message: "  Failed to save  "},
+		}
+
+		results := LogProcessor(logs, 3)
+
+		if len(results) != 5 {
+			t.Fatalf("Expected 5 processed logs, got %d", len(results))
+		}
+
+		// Verify all IDs are present
+		ids := make(map[int]bool)
+		for _, r := range results {
+			ids[r.ID] = true
+		}
+
+		for i := 1; i <= 5; i++ {
+			if !ids[i] {
+				t.Errorf("Missing log ID %d in results", i)
+			}
+		}
+	})
+
+	t.Run("Processing is concurrent and faster than sequential", func(t *testing.T) {
+		// Create 20 logs
+		logs := make([]LogEntry, 20)
+		for i := 0; i < 20; i++ {
+			logs[i] = LogEntry{
+				ID:        i + 1,
+				Timestamp: "2025-10-15T10:30:00Z",
+				Level:     "INFO",
+				Message:   "Test message",
+			}
+		}
+
+		start := time.Now()
+		results := LogProcessor(logs, 5)
+		elapsed := time.Since(start)
+
+		if len(results) != 20 {
+			t.Fatalf("Expected 20 processed logs, got %d", len(results))
+		}
+
+		// With 5 workers processing 20 logs at ~5 microseconds each:
+		// Sequential would take ~100 microseconds
+		// Concurrent should take ~20-30 microseconds (4 batches of 5)
+		if elapsed.Microseconds() > 50 {
+			t.Errorf("Processing took too long (%v), worker pool may not be working correctly", elapsed)
+		}
+	})
+
+	t.Run("Verify correct severity mapping", func(t *testing.T) {
+		logs := []LogEntry{
+			{ID: 1, Timestamp: "2025-10-15T10:30:00Z", Level: "INFO", Message: "info"},
+			{ID: 2, Timestamp: "2025-10-15T10:30:00Z", Level: "WARNING", Message: "warn"},
+			{ID: 3, Timestamp: "2025-10-15T10:30:00Z", Level: "ERROR", Message: "error"},
+		}
+
+		results := LogProcessor(logs, 2)
+
+		severities := make(map[int]int)
+		for _, r := range results {
+			severities[r.ID] = r.Severity
+		}
+
+		if severities[1] != 1 {
+			t.Errorf("Expected INFO severity 1, got %d", severities[1])
+		}
+		if severities[2] != 2 {
+			t.Errorf("Expected WARNING severity 2, got %d", severities[2])
+		}
+		if severities[3] != 3 {
+			t.Errorf("Expected ERROR severity 3, got %d", severities[3])
+		}
+	})
+}
+
+func TestWorkerChannelDirections(t *testing.T) {
+	// This test ensures channels are properly typed with directions
+	// by checking if the implementation compiles and runs correctly
+	logs := []LogEntry{
+		{ID: 1, Timestamp: "2025-10-15T10:30:00Z", Level: "INFO", Message: "test"},
+	}
+
+	results := LogProcessor(logs, 1)
+
+	if len(results) != 1 {
+		t.Errorf("Expected 1 result, got %d", len(results))
+	}
+}
+
+func BenchmarkLogProcessor(b *testing.B) {
+	logs := make([]LogEntry, 100)
+	for i := 0; i < 100; i++ {
+		logs[i] = LogEntry{
+			ID:        i + 1,
+			Timestamp: "2025-10-15T10:30:00Z",
+			Level:     "INFO",
+			Message:   "Test message",
+		}
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		LogProcessor(logs, 10)
+	}
+}
+
+func BenchmarkLogProcessorWorkerComparison(b *testing.B) {
+	logs := make([]LogEntry, 100)
+	for i := 0; i < 100; i++ {
+		logs[i] = LogEntry{
+			ID:        i + 1,
+			Timestamp: "2025-10-15T10:30:00Z",
+			Level:     "INFO",
+			Message:   "Test message",
+		}
+	}
+
+	workerCounts := []int{1, 2, 5, 10, 20}
+
+	for _, numWorkers := range workerCounts {
+		b.Run(fmt.Sprintf("Workers_%d", numWorkers), func(b *testing.B) {
+			b.ResetTimer()
+			for i := 0; i < b.N; i++ {
+				LogProcessor(logs, numWorkers)
+			}
+		})
+	}
+}