Comprehensive comparison for DevOps technology in Software Development applications

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"

	capi "github.com/hashicorp/consul/api"
)

type PaymentService struct {
	consulClient *capi.Client
	serviceID    string
}

type PaymentRequest struct {
	UserID        string  `json:"user_id"`
	Amount        float64 `json:"amount"`
	PaymentMethod string  `json:"payment_method"`
}

type PaymentResponse struct {
	TransactionID string `json:"transaction_id"`
	Status        string `json:"status"`
}

func NewPaymentService() (*PaymentService, error) {
	config := capi.DefaultConfig()
	config.Address = os.Getenv("CONSUL_HTTP_ADDR")
	if config.Address == "" {
		config.Address = "localhost:8500"
	}

	client, err := capi.NewClient(config)
	if err != nil {
		return nil, fmt.Errorf("failed to create consul client: %w", err)
	}

	return &PaymentService{
		consulClient: client,
		serviceID:    fmt.Sprintf("payment-service-%s", os.Getenv("HOSTNAME")),
	}, nil
}

func (ps *PaymentService) RegisterService(port int) error {
	registration := &capi.AgentServiceRegistration{
		ID:      ps.serviceID,
		Name:    "payment-service",
		Port:    port,
		Address: "localhost",
		Tags:    []string{"payment", "api", "v1"},
		Check: &capi.AgentServiceCheck{
			HTTP:                           fmt.Sprintf("http://localhost:%d/health", port),
			Interval:                       "10s",
			Timeout:                        "3s",
			DeregisterCriticalServiceAfter: "30s",
		},
	}

	err := ps.consulClient.Agent().ServiceRegister(registration)
	if err != nil {
		return fmt.Errorf("failed to register service: %w", err)
	}

	log.Printf("Service %s registered successfully", ps.serviceID)
	return nil
}

func (ps *PaymentService) GetDatabaseConfig() (string, error) {
	kv := ps.consulClient.KV()
	pair, _, err := kv.Get("config/payment-service/database/connection_string", nil)
	if err != nil {
		return "", fmt.Errorf("failed to get config from consul: %w", err)
	}
	if pair == nil {
		return "", fmt.Errorf("database config not found in consul")
	}
	return string(pair.Value), nil
}

func (ps *PaymentService) ProcessPayment(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodPost {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}

	var req PaymentRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		http.Error(w, "Invalid request body", http.StatusBadRequest)
		return
	}

	dbConfig, err := ps.GetDatabaseConfig()
	if err != nil {
		log.Printf("Error getting database config: %v", err)
		http.Error(w, "Internal server error", http.StatusInternalServerError)
		return
	}

	log.Printf("Processing payment for user %s, amount: %.2f using DB: %s", req.UserID, req.Amount, dbConfig)

	resp := PaymentResponse{
		TransactionID: fmt.Sprintf("txn_%d", time.Now().Unix()),
		Status:        "completed",
	}

	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(resp)
}

func (ps *PaymentService) HealthCheck(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
	w.Write([]byte("OK"))
}

func (ps *PaymentService) Deregister() error {
	err := ps.consulClient.Agent().ServiceDeregister(ps.serviceID)
	if err != nil {
		return fmt.Errorf("failed to deregister service: %w", err)
	}
	log.Printf("Service %s deregistered successfully", ps.serviceID)
	return nil
}

func main() {
	ps, err := NewPaymentService()
	if err != nil {
		log.Fatalf("Failed to create payment service: %v", err)
	}

	port := 8080
	if err := ps.RegisterService(port); err != nil {
		log.Fatalf("Failed to register service with Consul: %v", err)
	}

	defer ps.Deregister()

	http.HandleFunc("/payment", ps.ProcessPayment)
	http.HandleFunc("/health", ps.HealthCheck)

	log.Printf("Payment service starting on port %d", port)
	if err := http.ListenAndServe(fmt.Sprintf(":%d", port), nil); err != nil {
		log.Fatalf("Server failed: %v", err)
	}
}