utils.go

package main

import (
	"fmt"
	"log"
	"math/rand"
	"os"
	"sync"
	"time"

	"gopkg.in/yaml.v3"
)

// Global config cache with thread safety
var (
	vmsConfig    *VMsConfig
	configMutex  sync.RWMutex
	configLoaded bool
)

func init() {
	rand.Seed(time.Now().UnixNano())
}

// GenerateUniqueID generates a random string for VM name
func GenerateUniqueID(length int) string {
	const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
	result := make([]byte, length)
	for i := range result {
		result[i] = charset[rand.Intn(len(charset))]
	}
	return string(result)
}

// FormatDuration formats a duration to a human-readable string
func FormatDuration(d time.Duration) string {
	d = d.Round(time.Minute)
	h := d / time.Hour
	d -= h * time.Hour
	m := d / time.Minute

	if h > 0 {
		return time.Duration(h).String() + " " + time.Duration(m*time.Minute).String()
	}
	return time.Duration(m * time.Minute).String()
}

// Load VMs configurations from file
func loadVMsConfig() (*VMsConfig, error) {
	configMutex.Lock()
	defer configMutex.Unlock()

	// Return cached config if already loaded
	if configLoaded && vmsConfig != nil {
		return vmsConfig, nil
	}

	configPath := os.Getenv("VMS_CONFIG_PATH")
	if configPath == "" {
		configPath = "/etc/config/vms.yaml"
	}

	log.Printf("Loading VMs configuration from: %s", configPath)

	data, err := os.ReadFile(configPath)
	if err != nil {
		return nil, fmt.Errorf("failed to read config file: %v", err)
	}

	var config VMsConfig
	if err := yaml.Unmarshal(data, &config); err != nil {
		return nil, fmt.Errorf("failed to parse YAML config: %v", err)
	}

	// Validate configuration
	if len(config.AvailableVMs) == 0 {
		return nil, fmt.Errorf("no vms configured")
	}

	vmsConfig = &config
	configLoaded = true

	log.Printf("Successfully loaded VMs configuration %v", config.AvailableVMs)

	return vmsConfig, nil
}

// Get VM configuration by type
func getVMConfig(vmtype string) (*VMConfig, error) {
	// Load config if not already loaded
	config, err := loadVMsConfig()
	if err != nil {
		return nil, err
	}

	configMutex.RLock()
	defer configMutex.RUnlock()

	if vm, exists := config.AvailableVMs[vmtype]; exists {
		return &vm, nil
	}

	return nil, fmt.Errorf("VM of type %s not found in configuration", vmtype)
}