326 lines
9.3 KiB
Go
326 lines
9.3 KiB
Go
package cmd
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/spf13/cobra"
|
|
|
|
"github.com/wild-cloud/wild-central/wild/internal/config"
|
|
"github.com/wild-cloud/wild-central/wild/internal/prompt"
|
|
)
|
|
|
|
// Service commands
|
|
var serviceCmd = &cobra.Command{
|
|
Use: "service",
|
|
Short: "Manage services",
|
|
}
|
|
|
|
var serviceListCmd = &cobra.Command{
|
|
Use: "list",
|
|
Short: "List services",
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
inst, err := getInstanceName()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp, err := apiClient.Get(fmt.Sprintf("/api/v1/instances/%s/services", inst))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if outputFormat == "json" {
|
|
return printJSON(resp.Data)
|
|
}
|
|
|
|
services := resp.GetArray("services")
|
|
if len(services) == 0 {
|
|
fmt.Println("No services found")
|
|
return nil
|
|
}
|
|
|
|
fmt.Printf("%-20s %-12s\n", "NAME", "STATUS")
|
|
fmt.Println("----------------------------------")
|
|
for _, svc := range services {
|
|
if m, ok := svc.(map[string]interface{}); ok {
|
|
fmt.Printf("%-20s %-12s\n", m["name"], m["status"])
|
|
}
|
|
}
|
|
return nil
|
|
},
|
|
}
|
|
|
|
// ServiceManifest matches the daemon's ServiceManifest structure
|
|
type ServiceManifest struct {
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Namespace string `json:"namespace"`
|
|
ConfigReferences []string `json:"configReferences"`
|
|
ServiceConfig map[string]ConfigDefinition `json:"serviceConfig"`
|
|
}
|
|
|
|
// ConfigDefinition defines config that should be prompted during service setup
|
|
type ConfigDefinition struct {
|
|
Path string `json:"path"`
|
|
Prompt string `json:"prompt"`
|
|
Default string `json:"default"`
|
|
Type string `json:"type"`
|
|
}
|
|
|
|
// ConfigUpdate represents a single configuration update
|
|
type ConfigUpdate struct {
|
|
Path string `json:"path"`
|
|
Value interface{} `json:"value"`
|
|
}
|
|
|
|
var (
|
|
fetchFlag bool
|
|
noDeployFlag bool
|
|
)
|
|
|
|
var serviceInstallCmd = &cobra.Command{
|
|
Use: "install <service>",
|
|
Short: "Install a service with interactive configuration",
|
|
Long: `Install and configure a cluster service.
|
|
|
|
This command orchestrates the complete service installation lifecycle:
|
|
1. Fetch service files from Wild Cloud Directory (if needed or --fetch)
|
|
2. Validate configuration requirements
|
|
3. Prompt for any missing service configuration
|
|
4. Update instance configuration
|
|
5. Compile templates using gomplate
|
|
6. Deploy service to cluster (unless --no-deploy)
|
|
|
|
Examples:
|
|
# Configure and deploy (most common)
|
|
wild service install metallb
|
|
|
|
# Fetch fresh templates and deploy
|
|
wild service install metallb --fetch
|
|
|
|
# Configure only, skip deployment
|
|
wild service install metallb --no-deploy
|
|
|
|
# Fetch fresh templates, configure only
|
|
wild service install metallb --fetch --no-deploy
|
|
|
|
# Use cached templates (default if files exist)
|
|
wild service install traefik
|
|
`,
|
|
Args: cobra.ExactArgs(1),
|
|
RunE: func(cmd *cobra.Command, args []string) error {
|
|
serviceName := args[0]
|
|
|
|
inst, err := getInstanceName()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Printf("Installing service: %s\n", serviceName)
|
|
|
|
// Step 1: Fetch service manifest
|
|
fmt.Println("\nFetching service manifest...")
|
|
manifestResp, err := apiClient.Get(fmt.Sprintf("/api/v1/services/%s/manifest", serviceName))
|
|
if err != nil {
|
|
return fmt.Errorf("failed to fetch manifest: %w", err)
|
|
}
|
|
|
|
// Parse manifest
|
|
var manifest ServiceManifest
|
|
manifestData := manifestResp.Data
|
|
// API returns camelCase field names
|
|
if name, ok := manifestData["name"].(string); ok {
|
|
manifest.Name = name
|
|
}
|
|
if desc, ok := manifestData["description"].(string); ok {
|
|
manifest.Description = desc
|
|
}
|
|
if namespace, ok := manifestData["namespace"].(string); ok {
|
|
manifest.Namespace = namespace
|
|
}
|
|
if refs, ok := manifestData["configReferences"].([]interface{}); ok {
|
|
manifest.ConfigReferences = make([]string, len(refs))
|
|
for i, ref := range refs {
|
|
if s, ok := ref.(string); ok {
|
|
manifest.ConfigReferences[i] = s
|
|
}
|
|
}
|
|
}
|
|
if svcConfig, ok := manifestData["serviceConfig"].(map[string]interface{}); ok {
|
|
manifest.ServiceConfig = make(map[string]ConfigDefinition)
|
|
for key, val := range svcConfig {
|
|
if cfgMap, ok := val.(map[string]interface{}); ok {
|
|
cfg := ConfigDefinition{}
|
|
if path, ok := cfgMap["path"].(string); ok {
|
|
cfg.Path = path
|
|
}
|
|
if prompt, ok := cfgMap["prompt"].(string); ok {
|
|
cfg.Prompt = prompt
|
|
}
|
|
if def, ok := cfgMap["default"].(string); ok {
|
|
cfg.Default = def
|
|
}
|
|
if typ, ok := cfgMap["type"].(string); ok {
|
|
cfg.Type = typ
|
|
}
|
|
manifest.ServiceConfig[key] = cfg
|
|
}
|
|
}
|
|
}
|
|
|
|
fmt.Printf("Service: %s - %s\n", manifest.Name, manifest.Description)
|
|
|
|
// Step 2: Fetch current config
|
|
fmt.Println("\nFetching instance configuration...")
|
|
configResp, err := apiClient.Get(fmt.Sprintf("/api/v1/instances/%s/config", inst))
|
|
if err != nil {
|
|
return fmt.Errorf("failed to fetch config: %w", err)
|
|
}
|
|
|
|
instanceConfig := configResp.Data
|
|
|
|
// Step 3: Validate configReferences
|
|
if len(manifest.ConfigReferences) > 0 {
|
|
fmt.Println("\nValidating configuration references...")
|
|
missingPaths := config.ValidatePaths(instanceConfig, manifest.ConfigReferences)
|
|
if len(missingPaths) > 0 {
|
|
fmt.Println("\nERROR: Missing required configuration values:")
|
|
for _, path := range missingPaths {
|
|
fmt.Printf(" - %s\n", path)
|
|
}
|
|
fmt.Println("\nPlease set these configuration values before installing this service.")
|
|
fmt.Printf("Use: wild config set <key> <value>\n")
|
|
return fmt.Errorf("missing required configuration")
|
|
}
|
|
fmt.Println("All required configuration references are present.")
|
|
}
|
|
|
|
// Step 4: Process serviceConfig - prompt for missing values
|
|
var updates []ConfigUpdate
|
|
|
|
if len(manifest.ServiceConfig) > 0 {
|
|
fmt.Println("\nConfiguring service parameters...")
|
|
|
|
for key, cfg := range manifest.ServiceConfig {
|
|
// Check if path already set
|
|
existingValue := config.GetValue(instanceConfig, cfg.Path)
|
|
if existingValue != nil && existingValue != "" && existingValue != "null" {
|
|
fmt.Printf(" %s: %v (already set)\n", cfg.Path, existingValue)
|
|
continue
|
|
}
|
|
|
|
// Expand default template
|
|
defaultValue := cfg.Default
|
|
if defaultValue != "" {
|
|
expanded, err := config.ExpandTemplate(defaultValue, instanceConfig)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to expand template for %s: %w", key, err)
|
|
}
|
|
defaultValue = expanded
|
|
}
|
|
|
|
// Prompt user
|
|
var value string
|
|
switch cfg.Type {
|
|
case "int":
|
|
intVal, err := prompt.Int(cfg.Prompt, 0)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read input for %s: %w", key, err)
|
|
}
|
|
value = fmt.Sprintf("%d", intVal)
|
|
case "bool":
|
|
boolVal, err := prompt.Bool(cfg.Prompt, false)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read input for %s: %w", key, err)
|
|
}
|
|
if boolVal {
|
|
value = "true"
|
|
} else {
|
|
value = "false"
|
|
}
|
|
default: // string
|
|
var err error
|
|
value, err = prompt.String(cfg.Prompt, defaultValue)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read input for %s: %w", key, err)
|
|
}
|
|
}
|
|
|
|
// Add to updates
|
|
updates = append(updates, ConfigUpdate{
|
|
Path: cfg.Path,
|
|
Value: value,
|
|
})
|
|
|
|
fmt.Printf(" %s: %s\n", cfg.Path, value)
|
|
}
|
|
}
|
|
|
|
// Step 5: Update configuration if needed
|
|
if len(updates) > 0 {
|
|
fmt.Println("\nUpdating instance configuration...")
|
|
_, err = apiClient.Patch(
|
|
fmt.Sprintf("/api/v1/instances/%s/config", inst),
|
|
map[string]interface{}{
|
|
"updates": updates,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to update configuration: %w", err)
|
|
}
|
|
fmt.Printf("Configuration updated (%d values)\n", len(updates))
|
|
}
|
|
|
|
// Step 6: Install service with lifecycle control
|
|
if noDeployFlag {
|
|
fmt.Println("\nConfiguring service...")
|
|
} else {
|
|
fmt.Println("\nInstalling service...")
|
|
}
|
|
|
|
installResp, err := apiClient.Post(
|
|
fmt.Sprintf("/api/v1/instances/%s/services", inst),
|
|
map[string]interface{}{
|
|
"name": serviceName,
|
|
"fetch": fetchFlag,
|
|
"deploy": !noDeployFlag,
|
|
},
|
|
)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to install service: %w", err)
|
|
}
|
|
|
|
// Show appropriate success message
|
|
if noDeployFlag {
|
|
fmt.Printf("\n✓ Service configured: %s\n", serviceName)
|
|
fmt.Printf(" Templates compiled and ready to deploy\n")
|
|
fmt.Printf(" To deploy later, run: wild service install %s\n", serviceName)
|
|
} else {
|
|
// Stream installation output
|
|
opID := installResp.GetString("operation_id")
|
|
if opID != "" {
|
|
fmt.Printf("Installing service: %s\n\n", serviceName)
|
|
if err := streamOperationOutput(opID); err != nil {
|
|
// If streaming fails, show operation ID for manual monitoring
|
|
fmt.Printf("\nCouldn't stream output: %v\n", err)
|
|
fmt.Printf("Operation ID: %s\n", opID)
|
|
fmt.Printf("Monitor with: wild operation get %s\n", opID)
|
|
} else {
|
|
fmt.Printf("\n✓ Service installed successfully: %s\n", serviceName)
|
|
}
|
|
}
|
|
}
|
|
|
|
return nil
|
|
},
|
|
}
|
|
|
|
func init() {
|
|
serviceInstallCmd.Flags().BoolVar(&fetchFlag, "fetch", false, "Fetch fresh templates from directory before installing")
|
|
serviceInstallCmd.Flags().BoolVar(&noDeployFlag, "no-deploy", false, "Configure and compile only, skip deployment")
|
|
|
|
serviceCmd.AddCommand(serviceListCmd)
|
|
serviceCmd.AddCommand(serviceInstallCmd)
|
|
}
|
|
|