@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/go/examples/cloud-native-app.go

@@ -0,0 +1,217 @@
+// Package main demonstrates a cloud-native Go application with Kubernetes integration,
+// configuration management, health checks, and graceful shutdown.
+package main
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/kelseyhightower/envconfig"
+	_ "github.com/lib/pq"
+)
+
+// Config holds application configuration loaded from environment variables
+type Config struct {
+	Port        int    `envconfig:"PORT" default:"8080"`
+	DatabaseURL string `envconfig:"DATABASE_URL" required:"true"`
+	LogLevel    string `envconfig:"LOG_LEVEL" default:"info"`
+}
+
+// HealthChecker manages health check functions
+type HealthChecker struct {
+	checks map[string]func(context.Context) error
+}
+
+// NewHealthChecker creates a new health checker
+func NewHealthChecker() *HealthChecker {
+	return &HealthChecker{
+		checks: make(map[string]func(context.Context) error),
+	}
+}
+
+// AddCheck adds a named health check function
+func (hc *HealthChecker) AddCheck(name string, check func(context.Context) error) {
+	hc.checks[name] = check
+}
+
+// Check runs all health checks and returns results
+func (hc *HealthChecker) Check(ctx context.Context) (map[string]string, error) {
+	results := make(map[string]string)
+	var hasError bool
+
+	for name, check := range hc.checks {
+		checkCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
+		defer cancel()
+
+		if err := check(checkCtx); err != nil {
+			results[name] = fmt.Sprintf("FAIL: %v", err)
+			hasError = true
+		} else {
+			results[name] = "OK"
+		}
+	}
+
+	if hasError {
+		return results, fmt.Errorf("health check failed")
+	}
+
+	return results, nil
+}
+
+// HealthResponse represents the health check response
+type HealthResponse struct {
+	Status     string            `json:"status"`
+	Timestamp  time.Time         `json:"timestamp"`
+	Components map[string]string `json:"components,omitempty"`
+}
+
+// Application holds the application state
+type Application struct {
+	config  *Config
+	db      *sql.DB
+	server  *http.Server
+	checker *HealthChecker
+}
+
+// NewApplication creates a new application instance
+func NewApplication(cfg *Config) (*Application, error) {
+	// Connect to database
+	db, err := sql.Open("postgres", cfg.DatabaseURL)
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect to database: %w", err)
+	}
+
+	// Configure connection pool
+	db.SetMaxOpenConns(25)
+	db.SetMaxIdleConns(5)
+	db.SetConnMaxLifetime(5 * time.Minute)
+
+	// Verify connection
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	if err := db.PingContext(ctx); err != nil {
+		return nil, fmt.Errorf("failed to ping database: %w", err)
+	}
+
+	app := &Application{
+		config:  cfg,
+		db:      db,
+		checker: NewHealthChecker(),
+	}
+
+	// Add health checks
+	app.checker.AddCheck("database", func(ctx context.Context) error {
+		return db.PingContext(ctx)
+	})
+
+	return app, nil
+}
+
+// healthHandler handles liveness probe requests
+func (app *Application) healthHandler(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("OK"))
+}
+
+// readinessHandler handles readiness probe requests
+func (app *Application) readinessHandler(w http.ResponseWriter, r *http.Request) {
+	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
+	defer cancel()
+
+	components, err := app.checker.Check(ctx)
+
+	response := HealthResponse{
+		Timestamp:  time.Now(),
+		Components: components,
+	}
+
+	if err != nil {
+		response.Status = "unhealthy"
+		w.WriteHeader(http.StatusServiceUnavailable)
+	} else {
+		response.Status = "healthy"
+		w.WriteHeader(http.StatusOK)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(response)
+}
+
+// Start starts the HTTP server
+func (app *Application) Start() error {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/health", app.healthHandler)
+	mux.HandleFunc("/ready", app.readinessHandler)
+
+	app.server = &http.Server{
+		Addr:         fmt.Sprintf(":%d", app.config.Port),
+		Handler:      mux,
+		ReadTimeout:  15 * time.Second,
+		WriteTimeout: 15 * time.Second,
+		IdleTimeout:  60 * time.Second,
+	}
+
+	log.Printf("Starting server on port %d", app.config.Port)
+	return app.server.ListenAndServe()
+}
+
+// Shutdown gracefully shuts down the application
+func (app *Application) Shutdown(ctx context.Context) error {
+	log.Println("Shutting down gracefully...")
+
+	// Shutdown HTTP server
+	if err := app.server.Shutdown(ctx); err != nil {
+		return fmt.Errorf("server shutdown failed: %w", err)
+	}
+
+	// Close database connection
+	if err := app.db.Close(); err != nil {
+		return fmt.Errorf("database close failed: %w", err)
+	}
+
+	log.Println("Shutdown complete")
+	return nil
+}
+
+func main() {
+	// Load configuration
+	var cfg Config
+	if err := envconfig.Process("", &cfg); err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Create application
+	app, err := NewApplication(&cfg)
+	if err != nil {
+		log.Fatalf("Failed to create application: %v", err)
+	}
+
+	// Start server in goroutine
+	go func() {
+		if err := app.Start(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("Server failed: %v", err)
+		}
+	}()
+
+	// Wait for interrupt signal
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	// Graceful shutdown with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	if err := app.Shutdown(ctx); err != nil {
+		log.Fatalf("Shutdown failed: %v", err)
+	}
+}
+

package/augment-extensions/coding-standards/go/examples/devops-tool.go

@@ -0,0 +1,250 @@
+// Package main demonstrates a DevOps automation tool in Go with CLI,
+// deployment automation, and infrastructure management capabilities.
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+// DeploymentConfig holds deployment configuration
+type DeploymentConfig struct {
+	Name        string
+	Environment string
+	Version     string
+	Replicas    int
+}
+
+// DeploymentStep represents a single deployment step
+type DeploymentStep struct {
+	Name        string
+	Description string
+	Execute     func(context.Context) error
+}
+
+// DeploymentOptions holds deployment options
+type DeploymentOptions struct {
+	DryRun  bool
+	Verbose bool
+	Timeout time.Duration
+}
+
+// Deployer handles deployment operations
+type Deployer struct {
+	config  *DeploymentConfig
+	options *DeploymentOptions
+}
+
+// NewDeployer creates a new deployer
+func NewDeployer(config *DeploymentConfig, options *DeploymentOptions) *Deployer {
+	return &Deployer{
+		config:  config,
+		options: options,
+	}
+}
+
+// Deploy executes the deployment
+func (d *Deployer) Deploy(ctx context.Context) error {
+	steps := []DeploymentStep{
+		{
+			Name:        "validate",
+			Description: "Validating configuration",
+			Execute:     d.validateConfig,
+		},
+		{
+			Name:        "build",
+			Description: "Building application",
+			Execute:     d.buildApplication,
+		},
+		{
+			Name:        "test",
+			Description: "Running tests",
+			Execute:     d.runTests,
+		},
+		{
+			Name:        "deploy",
+			Description: "Deploying to environment",
+			Execute:     d.deployToEnvironment,
+		},
+		{
+			Name:        "verify",
+			Description: "Verifying deployment",
+			Execute:     d.verifyDeployment,
+		},
+	}
+
+	for i, step := range steps {
+		if d.options.Verbose {
+			log.Printf("[%d/%d] %s", i+1, len(steps), step.Description)
+		}
+
+		if d.options.DryRun {
+			log.Printf("[DRY RUN] Would execute: %s", step.Name)
+			continue
+		}
+
+		if err := step.Execute(ctx); err != nil {
+			return fmt.Errorf("step '%s' failed: %w", step.Name, err)
+		}
+	}
+
+	return nil
+}
+
+func (d *Deployer) validateConfig(ctx context.Context) error {
+	if d.config.Name == "" {
+		return fmt.Errorf("deployment name is required")
+	}
+	if d.config.Environment == "" {
+		return fmt.Errorf("environment is required")
+	}
+	log.Println("Configuration validated")
+	return nil
+}
+
+func (d *Deployer) buildApplication(ctx context.Context) error {
+	log.Printf("Building application version %s", d.config.Version)
+	time.Sleep(100 * time.Millisecond) // Simulate build
+	return nil
+}
+
+func (d *Deployer) runTests(ctx context.Context) error {
+	log.Println("Running tests")
+	time.Sleep(100 * time.Millisecond) // Simulate tests
+	return nil
+}
+
+func (d *Deployer) deployToEnvironment(ctx context.Context) error {
+	log.Printf("Deploying to %s environment", d.config.Environment)
+	time.Sleep(100 * time.Millisecond) // Simulate deployment
+	return nil
+}
+
+func (d *Deployer) verifyDeployment(ctx context.Context) error {
+	log.Println("Verifying deployment health")
+	time.Sleep(100 * time.Millisecond) // Simulate verification
+	return nil
+}
+
+// Rollback performs deployment rollback
+func (d *Deployer) Rollback(ctx context.Context, version string) error {
+	log.Printf("Rolling back to version %s", version)
+	
+	if d.options.DryRun {
+		log.Println("[DRY RUN] Would rollback deployment")
+		return nil
+	}
+
+	// Simulate rollback
+	time.Sleep(100 * time.Millisecond)
+	log.Println("Rollback completed")
+	return nil
+}
+
+var (
+	dryRun      bool
+	verbose     bool
+	version     string
+	environment string
+	replicas    int
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "devops-tool",
+	Short: "A DevOps automation tool",
+	Long:  `A comprehensive DevOps automation tool for deployment and infrastructure management.`,
+}
+
+var deployCmd = &cobra.Command{
+	Use:   "deploy [name]",
+	Short: "Deploy application",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		name := args[0]
+
+		config := &DeploymentConfig{
+			Name:        name,
+			Environment: environment,
+			Version:     version,
+			Replicas:    replicas,
+		}
+
+		options := &DeploymentOptions{
+			DryRun:  dryRun,
+			Verbose: verbose,
+			Timeout: 5 * time.Minute,
+		}
+
+		deployer := NewDeployer(config, options)
+
+		ctx, cancel := context.WithTimeout(context.Background(), options.Timeout)
+		defer cancel()
+
+		if err := deployer.Deploy(ctx); err != nil {
+			return err
+		}
+
+		log.Printf("Deployment '%s' completed successfully", name)
+		return nil
+	},
+}
+
+var rollbackCmd = &cobra.Command{
+	Use:   "rollback [name] [version]",
+	Short: "Rollback deployment",
+	Args:  cobra.ExactArgs(2),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		name := args[0]
+		targetVersion := args[1]
+
+		config := &DeploymentConfig{
+			Name:        name,
+			Environment: environment,
+		}
+
+		options := &DeploymentOptions{
+			DryRun:  dryRun,
+			Verbose: verbose,
+		}
+
+		deployer := NewDeployer(config, options)
+
+		ctx := context.Background()
+		if err := deployer.Rollback(ctx, targetVersion); err != nil {
+			return err
+		}
+
+		log.Printf("Rollback to version %s completed", targetVersion)
+		return nil
+	},
+}
+
+func init() {
+	// Deploy command flags
+	deployCmd.Flags().StringVarP(&version, "version", "v", "latest", "Version to deploy")
+	deployCmd.Flags().StringVarP(&environment, "environment", "e", "production", "Target environment")
+	deployCmd.Flags().IntVarP(&replicas, "replicas", "r", 3, "Number of replicas")
+	deployCmd.Flags().BoolVarP(&dryRun, "dry-run", "d", false, "Perform dry run")
+	deployCmd.Flags().BoolVar(&verbose, "verbose", false, "Verbose output")
+
+	// Rollback command flags
+	rollbackCmd.Flags().StringVarP(&environment, "environment", "e", "production", "Target environment")
+	rollbackCmd.Flags().BoolVarP(&dryRun, "dry-run", "d", false, "Perform dry run")
+	rollbackCmd.Flags().BoolVar(&verbose, "verbose", false, "Verbose output")
+
+	rootCmd.AddCommand(deployCmd)
+	rootCmd.AddCommand(rollbackCmd)
+}
+
+func main() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+		os.Exit(1)
+	}
+}
+

package/augment-extensions/coding-standards/go/examples/distributed-system.go

@@ -0,0 +1,247 @@
+// Package main demonstrates a distributed system in Go with consensus,
+// event sourcing, and distributed caching patterns.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+	"github.com/google/uuid"
+)
+
+// Event represents an immutable event in the system
+type Event struct {
+	ID          string            `json:"id"`
+	AggregateID string            `json:"aggregate_id"`
+	Type        string            `json:"type"`
+	Data        json.RawMessage   `json:"data"`
+	Metadata    map[string]string `json:"metadata"`
+	Timestamp   time.Time         `json:"timestamp"`
+	Version     int               `json:"version"`
+}
+
+// EventStore interface for event persistence
+type EventStore interface {
+	Save(ctx context.Context, events []Event) error
+	Load(ctx context.Context, aggregateID string) ([]Event, error)
+}
+
+// CacheManager handles distributed caching operations
+type CacheManager struct {
+	client *redis.Client
+}
+
+// NewCacheManager creates a new cache manager
+func NewCacheManager(addr string) *CacheManager {
+	client := redis.NewClient(&redis.Options{
+		Addr:     addr,
+		Password: "",
+		DB:       0,
+	})
+
+	return &CacheManager{client: client}
+}
+
+// Get retrieves a value from cache
+func (cm *CacheManager) Get(ctx context.Context, key string) (string, error) {
+	return cm.client.Get(ctx, key).Result()
+}
+
+// Set stores a value in cache with TTL
+func (cm *CacheManager) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error {
+	return cm.client.Set(ctx, key, value, ttl).Err()
+}
+
+// Delete removes a value from cache
+func (cm *CacheManager) Delete(ctx context.Context, key string) error {
+	return cm.client.Del(ctx, key).Err()
+}
+
+// GetMultiple retrieves multiple values using pipelining
+func (cm *CacheManager) GetMultiple(ctx context.Context, keys []string) (map[string]string, error) {
+	pipe := cm.client.Pipeline()
+
+	cmds := make(map[string]*redis.StringCmd)
+	for _, key := range keys {
+		cmds[key] = pipe.Get(ctx, key)
+	}
+
+	if _, err := pipe.Exec(ctx); err != nil && err != redis.Nil {
+		return nil, err
+	}
+
+	results := make(map[string]string)
+	for key, cmd := range cmds {
+		val, err := cmd.Result()
+		if err == redis.Nil {
+			continue
+		}
+		if err != nil {
+			return nil, err
+		}
+		results[key] = val
+	}
+
+	return results, nil
+}
+
+// User aggregate root
+type User struct {
+	ID      string
+	Email   string
+	Name    string
+	Version int
+	changes []Event
+}
+
+// NewUser creates a new user
+func NewUser(id, email, name string) *User {
+	return &User{
+		ID:      id,
+		Email:   email,
+		Name:    name,
+		Version: 0,
+		changes: []Event{},
+	}
+}
+
+// ApplyEvent applies an event to the user aggregate
+func (u *User) ApplyEvent(event Event) error {
+	switch event.Type {
+	case "UserCreated":
+		var data struct {
+			Email string `json:"email"`
+			Name  string `json:"name"`
+		}
+		if err := json.Unmarshal(event.Data, &data); err != nil {
+			return err
+		}
+		u.Email = data.Email
+		u.Name = data.Name
+
+	case "UserEmailChanged":
+		var data struct {
+			NewEmail string `json:"new_email"`
+		}
+		if err := json.Unmarshal(event.Data, &data); err != nil {
+			return err
+		}
+		u.Email = data.NewEmail
+	}
+
+	u.Version = event.Version
+	return nil
+}
+
+// ChangeEmail changes the user's email
+func (u *User) ChangeEmail(newEmail string) error {
+	if newEmail == u.Email {
+		return fmt.Errorf("email unchanged")
+	}
+
+	data, err := json.Marshal(map[string]string{
+		"old_email": u.Email,
+		"new_email": newEmail,
+	})
+	if err != nil {
+		return err
+	}
+
+	event := Event{
+		ID:          uuid.New().String(),
+		AggregateID: u.ID,
+		Type:        "UserEmailChanged",
+		Data:        data,
+		Timestamp:   time.Now(),
+		Version:     u.Version + 1,
+	}
+
+	u.changes = append(u.changes, event)
+	return u.ApplyEvent(event)
+}
+
+// GetUncommittedChanges returns uncommitted events
+func (u *User) GetUncommittedChanges() []Event {
+	return u.changes
+}
+
+// MarkChangesAsCommitted clears uncommitted changes
+func (u *User) MarkChangesAsCommitted() {
+	u.changes = nil
+}
+
+// DistributedService demonstrates distributed system patterns
+type DistributedService struct {
+	cache      *CacheManager
+	eventStore EventStore
+}
+
+// NewDistributedService creates a new distributed service
+func NewDistributedService(cache *CacheManager, eventStore EventStore) *DistributedService {
+	return &DistributedService{
+		cache:      cache,
+		eventStore: eventStore,
+	}
+}
+
+// GetUserWithCache retrieves user with cache-aside pattern
+func (ds *DistributedService) GetUserWithCache(ctx context.Context, userID string) (*User, error) {
+	// Try cache first
+	cacheKey := fmt.Sprintf("user:%s", userID)
+	cached, err := ds.cache.Get(ctx, cacheKey)
+	if err == nil {
+		var user User
+		if err := json.Unmarshal([]byte(cached), &user); err == nil {
+			log.Printf("Cache hit for user %s", userID)
+			return &user, nil
+		}
+	}
+
+	// Cache miss - load from event store
+	log.Printf("Cache miss for user %s, loading from event store", userID)
+	events, err := ds.eventStore.Load(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	user := &User{ID: userID}
+	for _, event := range events {
+		if err := user.ApplyEvent(event); err != nil {
+			return nil, err
+		}
+	}
+
+	// Store in cache
+	data, _ := json.Marshal(user)
+	ds.cache.Set(ctx, cacheKey, data, 1*time.Hour)
+
+	return user, nil
+}
+
+func main() {
+	ctx := context.Background()
+
+	// Initialize cache manager
+	cache := NewCacheManager("localhost:6379")
+
+	log.Println("Distributed system example started")
+
+	// Example: Cache operations
+	if err := cache.Set(ctx, "example:key", "example value", 5*time.Minute); err != nil {
+		log.Printf("Failed to set cache: %v", err)
+	}
+
+	val, err := cache.Get(ctx, "example:key")
+	if err != nil {
+		log.Printf("Failed to get cache: %v", err)
+	} else {
+		log.Printf("Cache value: %s", val)
+	}
+
+	log.Println("Distributed system example completed")
+}
+