135 líneas
3.6 KiB
Go
135 líneas
3.6 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"time"
|
|
|
|
"github.com/manalejandro/buque/internal/config"
|
|
"github.com/manalejandro/buque/internal/docker"
|
|
"github.com/manalejandro/buque/internal/models"
|
|
"github.com/manalejandro/buque/internal/stats"
|
|
)
|
|
|
|
// This is an example of using Buque as a library in your own Go code
|
|
|
|
func main() {
|
|
ctx := context.Background()
|
|
|
|
// Initialize configuration manager
|
|
configMgr := config.NewManager("")
|
|
cfg, err := configMgr.Load()
|
|
if err != nil {
|
|
log.Fatalf("Failed to load config: %v", err)
|
|
}
|
|
|
|
// Create Docker Compose manager
|
|
compose, err := docker.NewComposeManager()
|
|
if err != nil {
|
|
log.Fatalf("Failed to create compose manager: %v", err)
|
|
}
|
|
|
|
// Create stats collector
|
|
collector, err := stats.NewCollector()
|
|
if err != nil {
|
|
log.Fatalf("Failed to create stats collector: %v", err)
|
|
}
|
|
defer collector.Close()
|
|
|
|
// Example 1: Start all enabled environments
|
|
fmt.Println("Starting all enabled environments...")
|
|
for _, env := range cfg.Environments {
|
|
if !env.Enabled {
|
|
continue
|
|
}
|
|
|
|
fmt.Printf("Starting %s...\n", env.Name)
|
|
if err := compose.Up(ctx, env, true); err != nil {
|
|
log.Printf("Failed to start %s: %v", env.Name, err)
|
|
continue
|
|
}
|
|
fmt.Printf("✓ %s started\n", env.Name)
|
|
}
|
|
|
|
// Wait a bit for containers to start
|
|
time.Sleep(5 * time.Second)
|
|
|
|
// Example 2: Collect and display statistics
|
|
fmt.Println("\nCollecting container statistics...")
|
|
containerStats, err := collector.CollectAll(ctx)
|
|
if err != nil {
|
|
log.Fatalf("Failed to collect stats: %v", err)
|
|
}
|
|
|
|
fmt.Printf("\nRunning containers: %d\n", len(containerStats))
|
|
for _, stat := range containerStats {
|
|
fmt.Printf(" %s: CPU=%.2f%% Memory=%s\n",
|
|
stat.Name,
|
|
stat.CPUPercentage,
|
|
stats.FormatBytes(stat.MemoryUsage))
|
|
}
|
|
|
|
// Example 3: Get aggregated statistics
|
|
aggStats, err := collector.GetAggregatedStats(ctx)
|
|
if err != nil {
|
|
log.Fatalf("Failed to get aggregated stats: %v", err)
|
|
}
|
|
|
|
fmt.Printf("\nAggregated Statistics:\n")
|
|
fmt.Printf(" Total Containers: %d\n", aggStats.TotalContainers)
|
|
fmt.Printf(" Total CPU: %.2f%%\n", aggStats.TotalCPUPercent)
|
|
fmt.Printf(" Total Memory: %s\n", stats.FormatBytes(aggStats.TotalMemoryUsage))
|
|
|
|
// Example 4: Add a new environment programmatically
|
|
newEnv := models.Environment{
|
|
Name: "test-app",
|
|
Path: "/path/to/test-app",
|
|
ComposeFile: "docker-compose.yml",
|
|
Enabled: true,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
|
|
if err := configMgr.AddEnvironment(newEnv); err != nil {
|
|
log.Printf("Failed to add environment: %v", err)
|
|
} else {
|
|
fmt.Printf("\n✓ Added new environment: %s\n", newEnv.Name)
|
|
}
|
|
|
|
// Example 5: Pull images for an environment
|
|
if len(cfg.Environments) > 0 {
|
|
env := cfg.Environments[0]
|
|
fmt.Printf("\nPulling images for %s...\n", env.Name)
|
|
if err := compose.Pull(ctx, env); err != nil {
|
|
log.Printf("Failed to pull images: %v", err)
|
|
} else {
|
|
fmt.Printf("✓ Images pulled successfully\n")
|
|
}
|
|
}
|
|
|
|
// Example 6: Continuous monitoring (runs for 30 seconds)
|
|
fmt.Println("\nStarting continuous monitoring for 30 seconds...")
|
|
monitorCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
|
|
defer cancel()
|
|
|
|
err = collector.MonitorContinuously(monitorCtx, 5*time.Second, func(stats []models.ContainerStats) {
|
|
fmt.Printf("\n[%s] Active containers: %d\n",
|
|
time.Now().Format("15:04:05"),
|
|
len(stats))
|
|
|
|
for _, stat := range stats {
|
|
fmt.Printf(" %s: CPU=%.1f%% Mem=%.1f%%\n",
|
|
stat.Name,
|
|
stat.CPUPercentage,
|
|
stat.MemoryPercent)
|
|
}
|
|
})
|
|
|
|
if err != nil && err != context.DeadlineExceeded {
|
|
log.Printf("Monitoring error: %v", err)
|
|
}
|
|
|
|
fmt.Println("\nExample completed!")
|
|
}
|