[MADE LOAD BALANCING VIA FIBER PREFORK]

Author: Muhammad-Ali-Khan9

cmd/generate.go

@@ -1,17 +1,18 @@
 package cmd
 
 import (
-	"embed"      // For embedding templates
+	"embed"
+
 	"fmt"
-	"net"        // For checking port availability in generateCmd
+	"net"
 	"os"
-	"path/filepath" // For path manipulation
-	"strconv"    // For string to int conversion
+	"path/filepath"
+	"strconv"
+	"os/exec"
 
 	"github.com/spf13/cobra"
 )
 
-// CustomError is a simple wrapper for errors, useful for consistent error handling.
 type CustomError struct {
 	Err error
 }
@@ -226,9 +227,93 @@ var listServicesCmd = &cobra.Command{
 	},
 }
 
+// modTidyAllCmd is the new Cobra command to run 'go mod tidy' in the pkg/ and all service directories.
+var modTidyAllCmd = &cobra.Command{
+	Use:   "mod-tidy-all",
+	Short: "Runs 'go mod tidy' in pkg/ and all generated service directories",
+	Long:  "Executes 'go mod tidy' in the 'pkg/' folder and then in each subdirectory within the 'services/' folder, ensuring all module dependencies are clean.",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		fmt.Println("Running 'go mod tidy' across the monorepo...")
+
+		originalDir, err := os.Getwd()
+		if err != nil {
+			return fmt.Errorf("failed to get current working directory: %w", err)
+		}
+		// Ensure we always return to the original directory at the end
+		defer func() {
+			if cerr := os.Chdir(originalDir); cerr != nil {
+				fmt.Fprintf(os.Stderr, "Warning: Failed to change back to original directory '%s': %v\n", originalDir, cerr)
+			}
+		}()
+
+		// 1. Run 'go mod tidy' in the pkg/ directory
+		pkgDir := filepath.Join(originalDir, "pkg") // Construct full path to pkg/
+		if _, err := os.Stat(pkgDir); os.IsNotExist(err) {
+			fmt.Printf("No 'pkg/' directory found, skipping 'go mod tidy' for pkg.\n")
+		} else if err != nil {
+			return fmt.Errorf("failed to check 'pkg/' directory: %w", err)
+		} else {
+			fmt.Printf("\nRunning 'go mod tidy' in: %s\n", pkgDir)
+			if err := runGoModTidy(pkgDir); err != nil { // Run in pkgDir
+				fmt.Fprintf(os.Stderr, "Error: Failed to run 'go mod tidy' in 'pkg/': %v\n", err)
+				// Continue, but log the error
+			}
+		}
+
+		// 2. Iterate through 'services/' directory and run 'go mod tidy' in each service
+		servicesDir := "services"
+		serviceFolders, err := os.ReadDir(servicesDir)
+		if err != nil {
+			if os.IsNotExist(err) {
+				fmt.Printf("No 'services/' directory found, skipping service-specific tidy.\n")
+				// No error if services directory doesn't exist yet, just means nothing to tidy
+				return nil
+			}
+			return fmt.Errorf("failed to read 'services/' directory: %w", err)
+		}
+
+		for _, entry := range serviceFolders {
+			if entry.IsDir() {
+				servicePath := filepath.Join(servicesDir, entry.Name())
+				fmt.Printf("\nRunning 'go mod tidy' in: %s\n", servicePath)
+
+				// Change to service directory
+				if err := os.Chdir(servicePath); err != nil {
+					fmt.Fprintf(os.Stderr, "Warning: Failed to change to service directory '%s': %v\n", servicePath, err)
+					continue // Continue to next service
+				}
+
+				// Run go mod tidy in the service directory
+				if err := runGoModTidy("."); err != nil {
+					fmt.Fprintf(os.Stderr, "Error: Failed to run 'go mod tidy' in '%s': %v\n", servicePath, err)
+					// Optionally, you might want to stop here or collect all errors
+				}
+
+				// Change back to original directory (handled by defer, but good practice for clarity in loop)
+				if err := os.Chdir(originalDir); err != nil {
+					return fmt.Errorf("failed to change back to original directory after processing '%s': %w", servicePath, err)
+				}
+			}
+		}
+
+		fmt.Println("\n'go mod tidy' completed across all relevant directories. ✨")
+		return nil
+	},
+}
+
+// runGoModTidy executes the 'go mod tidy' command in the specified directory.
+func runGoModTidy(dir string) error {
+	cmd := exec.Command("go", "mod", "tidy")
+	cmd.Dir = dir // Set the working directory for the command
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
 // init function to add commands to the root command.
 func init() {
 	rootCmd.AddCommand(initCmd)
 	rootCmd.AddCommand(generateCmd)
 	rootCmd.AddCommand(listServicesCmd)
+	rootCmd.AddCommand(modTidyAllCmd)
 }

cmd/templates/auth/main.tmpl

@@ -5,7 +5,7 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
-	"time" // For context timeout, if needed in shutdown
+	"time"
 
 	"github.com/gofiber/fiber/v2"
 	"github.com/joho/godotenv"
@@ -17,61 +17,43 @@ import (
 )
 
 func main() {
-	// Load environment variables from .env file
-	// This will typically contain JWT_SECRET and API_KEY for your middlewares
 	if err := godotenv.Load(); err != nil {
 		log.Println("No .env file found or failed to load. Using system environment variables.")
 	}
 
-	// --- Service & Controller Wiring ---
-	// Instantiate your authentication service
-	// In a real application, you might pass a database connection here: internal.NewAuthService(db)
 	authService := internal.NewAuthService()
-	// Instantiate your authentication controller, injecting the service
 	authController := internal.NewAuthController(authService)
 
-	// --- Fiber App Setup ---
-	// Initialize a new Fiber application instance
-	app := fiber.New()
+	// --- Fiber App Setup with Prefork ---
+	app := fiber.New(fiber.Config{
+		Prefork: true, // Enable prefork for load balancing
+	})
 
-	// Apply global Fiber middlewares defined in your shared pkg/http/middleware
-	// This includes logging, CORS, recovery, security headers, etc.
 	middleware.InitGlobalMiddlewares(app)
 
-	// Register all authentication-related routes with the Fiber application
-	// This will set up your login and other auth endpoints.
 	internal.RegisterAuthRoutes(app, authController)
 
-	// Set application port. This will be {{.Port}} as assigned by the CLI.
 	port := os.Getenv("PORT")
 	if port == "" {
-		port = "{{.Port}}" // Default port for auth service, generated by CLI
+		port = "{{.Port}}"
 	}
 
 	// --- Start HTTP Server in a Goroutine ---
 	go func() {
 		log.Printf("Auth service is running on :%s", port)
 		if err := app.Listen(":" + port); err != nil && err != fiber.ErrServerClosed {
-			// Log fatal error if server fails to start or closes unexpectedly
 			log.Fatalf("Fiber Listen error: %v", err)
 		}
 	}()
 
 	// --- Graceful Shutdown ---
-	// Create a channel to listen for OS signals (e.g., Ctrl+C, SIGTERM from Docker/Kubernetes)
 	quit := make(chan os.Signal, 1)
 	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 
-	// Block until a termination signal is received
 	<-quit
 	log.Println("Shutdown signal received, shutting down gracefully...")
 
-	// Attempt to gracefully shut down the Fiber app.
-	// We use a context with a timeout to ensure shutdown doesn't hang indefinitely.
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) // 5-second timeout
-	defer cancel()
-
-	if err := app.ShutdownWithContext(ctx); err != nil {
+	if err := app.Shutdown(); err != nil {
 		log.Fatalf("Server forced to shutdown: %v", err)
 	}
 

cmd/templates/config/consul_config.tmpl

@@ -0,0 +1,35 @@
+{{/*
+  templates/config/consul_config.tmpl
+  This template generates code for initializing and managing dynamic configuration
+  via HashiCorp Consul's Key-Value store. It sets up initial config loading
+  and a background goroutine to watch for changes.
+
+  Assumes:
+  - appConfig struct is defined in pkg/config.
+  - Required Consul client import: "github.com/hashicorp/consul/api"
+  - Environment variable CONSUL_ADDR is set (e.g., "127.0.0.1:8500").
+  - `fetchAndSetConsulConfigs` and `watchConsulConfig` functions exist in pkg/config.
+*/}}
+	log.Println("Initializing dynamic configuration from Consul...")
+	consulAddress := os.Getenv("CONSUL_ADDR")
+	if consulAddress == "" {
+		log.Fatal("CONSUL_ADDR environment variable is not set for Consul dynamic config.")
+	}
+
+	consulConfig := api.DefaultConfig()
+	consulConfig.Address = consulAddress
+	consulClient, err := api.NewClient(consulConfig)
+	if err != nil {
+		log.Fatalf("Failed to create Consul client: %v", err)
+	}
+
+	// Initial configuration load from Consul
+	if err := config.FetchAndSetConsulConfigs(consulClient, "{{.Name | lower}}-service"); err != nil {
+		log.Fatalf("Failed initial configuration load from Consul: %v", err)
+	}
+	log.Println("Initial configuration loaded from Consul.")
+
+	// Start a background goroutine to watch for configuration changes
+	go config.WatchConsulConfig(consulClient, "{{.Name | lower}}-service")
+
+	// Use config.GetConfig() to access live configuration values throughout the application.

cmd/templates/config/etcd_config.tmpl

@@ -4,17 +4,16 @@ import (
 	"context"
 	"flag"
 	"log"
-	"net/http"
 	"os"
 	"os/signal"
 	"syscall"
 	"time"
 
-	"github.com/gorilla/mux"
+	"github.com/gofiber/fiber/v2" // Import Fiber
 	"github.com/joho/godotenv"
 
-	"pkg/http"
-	"pkg/database/postgres"
+	// You'll need to replace these with your actual package paths.
+	"pkg/database/postgres" 
 	"src/internal"
 	"pkg/entities"
 )
@@ -43,39 +42,33 @@ func main() {
 	service := internal.NewUserService(db, entityModel)
 	controller := internal.NewUserController(service)
 
-	// Setup router
-	r := mux.NewRouter()
-	internal.RegisterUserRoutes(r, controller)
+	// --- Initialize Fiber and enable Prefork ---
+	app := fiber.New(fiber.Config{
+		Prefork: true, // This enables prefork for load balancing
+	})
 
-	// Setup HTTP server with CORS middleware
-	addr := ":" + *port
-	srv := &http.Server{
-		Addr:    addr,
-		Handler: http.WithCORS(r),
-	}
+	// Setup router (assumes a new RegisterUserRoutes that accepts *fiber.App)
+	internal.RegisterUserRoutes(app, controller)
 
 	// Channel to listen for OS signals
 	stop := make(chan os.Signal, 1)
 	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
 
 	// Start server in goroutine
 	go func() {
+		addr := ":" + *port
 		log.Printf("Service running on %s\n", addr)
-		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			log.Fatalf("Server error: %v", err)
+		if err := app.Listen(addr); err != nil {
+			log.Fatalf("Fiber Listen error: %v", err)
 		}
 	}()
 
 	// Wait for termination signal
 	<-stop
 	log.Println("Shutting down server...")
 
-	// Context for graceful shutdown
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
 	// Shutdown server
-	if err := srv.Shutdown(ctx); err != nil {
+	if err := app.Shutdown(); err != nil {
 		log.Fatalf("Server shutdown failed: %v", err)
 	}