refactor initialization and logging

cmd/create-key.go

@@ -11,7 +11,6 @@ import (
 	"path/filepath"
 
 	"github.com/pavelanni/labshop/internal/config"
-	"github.com/pavelanni/labshop/internal/logger"
 	"github.com/pavelanni/labshop/internal/provider/options"
 	"github.com/pavelanni/labshop/internal/types"
 	"github.com/pavelanni/labshop/internal/util/labelutil"
@@ -45,8 +44,7 @@ func NewCreateKeyCmd() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			logger.Info("SSH key created successfully",
-				"key", key.ObjectMeta.Name)
+			fmt.Printf("SSH key created successfully: %s\n", key.ObjectMeta.Name)
 			return nil
 		},
 	}
@@ -115,9 +113,7 @@ func createKey(key *types.SSHKey) (*types.SSHKey, error) {
 			return nil, fmt.Errorf("failed to save public key: %w", err)
 		}
 		pubKeyString = string(pubKey)
-		logger.Info("SSH key pair created successfully",
-			"private_key", privKeyPath,
-			"public_key", pubKeyPath)
+		fmt.Printf("SSH key pair created successfully: %s\n", keyName)
 		key.Spec.PublicKey = pubKeyString
 	}
 
@@ -131,8 +127,7 @@ func createKey(key *types.SSHKey) (*types.SSHKey, error) {
 		return nil, fmt.Errorf("failed to upload public key: %w", err)
 	}
 
-	logger.Info("SSH key uploaded to provider",
-		"key", keyName)
+	fmt.Printf("SSH key uploaded to provider: %s\n", keyName)
 	return key, nil
 }
 

cmd/create-lab.go

@@ -2,11 +2,11 @@ package cmd
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
+	"time"
 
 	"github.com/pavelanni/labshop/internal/config"
 	"github.com/pavelanni/labshop/internal/types"
@@ -46,8 +46,8 @@ func NewCreateLabCmd() *cobra.Command {
 
 	defaultTemplate := filepath.Join(os.Getenv("HOME"), config.DefaultConfigDir, config.DefaultTemplateDir, "lab.yaml")
 	cmd.Flags().StringVar(&template, "template", defaultTemplate, "lab template to use")
-	cmd.Flags().StringVar(&provider, "provider", cfg.Provider.Name, "provider to use")
-	cmd.Flags().StringVar(&location, "location", cfg.Provider.Location, "location to use")
+	cmd.Flags().StringVar(&provider, "provider", config.DefaultProvider, "provider to use")
+	cmd.Flags().StringVar(&location, "location", config.DefaultLocation, "location to use")
 	cmd.Flags().StringVar(&ttl, "ttl", config.DefaultTTL, "ttl to use")
 
 	return cmd
@@ -81,7 +81,7 @@ func createLab(lab *types.Lab) (*types.Lab, error) {
 			Spec: types.ServerSpec{
 				Location:    lab.Spec.Location,
 				Provider:    lab.Spec.Provider,
-				Type:        serverSpec.Type,
+				ServerType:  serverSpec.ServerType,
 				TTL:         ttl,
 				Image:       serverSpec.Image,
 				SSHKeyNames: keyNames,
@@ -96,13 +96,30 @@ func createLab(lab *types.Lab) (*types.Lab, error) {
 		}
 		servers = append(servers, result)
 	}
+	// Add a DNS record for 'aistor.' using the IP of the control plane server
+	cpPublicNet := servers[0].Status.PublicNet
+	aistorServer := &types.Server{
+		ObjectMeta: types.ObjectMeta{
+			Name:   strings.Join([]string{lab.ObjectMeta.Name, "aistor"}, "-"),
+			Labels: lab.ObjectMeta.Labels,
+		},
+		Status: types.ServerStatus{
+			PublicNet: cpPublicNet,
+		},
+	}
+	if err := addDNSRecord(aistorServer); err != nil {
+		return nil, err
+	}
+
 	// Wait for servers to be ready
-	results, err := serverchecker.CheckServers(context.Background(), servers)
+	timeout := 30 * time.Minute
+	attempts := 20
+	results, err := serverchecker.CheckServers(servers, cfg.LogLevel, timeout, attempts)
 	if err != nil {
 		return nil, err
 	}
 	for _, result := range results {
-		fmt.Printf("Server %s: %+v\n", result.Server.ObjectMeta.Name, result)
+		fmt.Printf("Server %s: Ready: %v\n", result.Server.ObjectMeta.Name, result.Ready)
 		if !result.Ready {
 			return nil, fmt.Errorf("server %s not ready", result.Server.ObjectMeta.Name)
 		}
@@ -163,8 +180,12 @@ func addDNSRecord(server *types.Server) error {
 	if !ok {
 		labName = "no-lab"
 	}
+	labName = strings.ToLower(labName)
+	serverName := strings.ToLower(server.Name)
+	// remove the leading labName with "-" from the serverName
+	serverName = strings.TrimPrefix(serverName, labName+"-")
 	err := dnsSvc.AddRecord(cfg.DNS.ZoneID,
-		strings.Join([]string{server.Name, labName}, "."),
+		strings.Join([]string{serverName, labName}, "."),
 		"A",
 		server.Status.PublicNet.IPv4.IP,
 		false)

cmd/create-server.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/pavelanni/labshop/internal/config"
-	"github.com/pavelanni/labshop/internal/logger"
 	"github.com/pavelanni/labshop/internal/provider/options"
 	"github.com/pavelanni/labshop/internal/types"
 	"github.com/pavelanni/labshop/internal/util/labelutil"
@@ -38,7 +37,7 @@ func NewCreateServerCmd() *cobra.Command {
 					Labels: labels,
 				},
 				Spec: types.ServerSpec{
-					Type:        serverType,
+					ServerType:  serverType,
 					Image:       image,
 					Location:    location,
 					Provider:    cfg.Provider.Name,
@@ -49,15 +48,15 @@ func NewCreateServerCmd() *cobra.Command {
 			if err != nil {
 				return err
 			}
-			logger.Info("Server created successfully", "server", result.ObjectMeta.Name)
+			fmt.Printf("Server created successfully: %s\n", result.ObjectMeta.Name)
 			return nil
 		},
 	}
 
 	cmd.Flags().StringSliceVar(&sshKeyNames, "ssh-keys", []string{}, "SSH key names to use (required)")
-	cmd.Flags().StringVar(&serverType, "type", "cx22", "Server type")
-	cmd.Flags().StringVar(&image, "image", "ubuntu-24.04", "Server image")
-	cmd.Flags().StringVar(&location, "location", "fsn1", "Server location")
+	cmd.Flags().StringVar(&serverType, "type", config.DefaultServerType, "Server type")
+	cmd.Flags().StringVar(&image, "image", config.DefaultImage, "Server image")
+	cmd.Flags().StringVar(&location, "location", config.DefaultLocation, "Server location")
 	cmd.Flags().StringVar(&ttl, "ttl", config.DefaultTTL, "Server TTL")
 	cmd.Flags().StringToStringVar(&labels, "labels", map[string]string{}, "Server labels")
 	if err := cmd.MarkFlagRequired("ssh-keys"); err != nil {
@@ -71,11 +70,16 @@ func createServer(server *types.Server) (*types.Server, error) {
 	// Access fields using map syntax
 	fmt.Printf("Creating server %s with type %s, image %s, location %s, ssh keys %v\n",
 		server.ObjectMeta.Name,
-		server.Spec.Type,
+		server.Spec.ServerType,
 		server.Spec.Image,
 		server.Spec.Location,
 		server.Spec.SSHKeyNames)
 
+	if len(server.Spec.SSHKeyNames) == 0 {
+		serverKeyName := server.ObjectMeta.Name + "-admin"
+		fmt.Printf("No SSH keys provided, using default: %s\n", serverKeyName)
+		server.Spec.SSHKeyNames = []string{serverKeyName}
+	}
 	ttl := config.DefaultTTL
 	if server.Spec.TTL != "" {
 		ttl = server.Spec.TTL
@@ -91,9 +95,8 @@ func createServer(server *types.Server) (*types.Server, error) {
 		if err != nil {
 			return nil, err
 		}
-		if !keyExists { // Key not found, create it
-			logger.Info("SSH key not found, creating",
-				"key", sshKeyName)
+		if !keyExists {
+			fmt.Printf("Creating new SSH key: %s\n", sshKeyName)
 			newKey, err := createKey(&types.SSHKey{
 				TypeMeta: types.TypeMeta{
 					Kind: "SSHKey",
@@ -117,10 +120,9 @@ func createServer(server *types.Server) (*types.Server, error) {
 	}
 
 	cloudInitUserData := fmt.Sprintf(config.DefaultCloudInitUserData, sshKeys[0].Spec.PublicKey)
-	logger.Debug("cloud-init user data", "data", cloudInitUserData)
 	result, err := providerSvc.CreateServer(options.ServerCreateOpts{
 		Name:     server.ObjectMeta.Name,
-		Type:     server.Spec.Type,
+		Type:     server.Spec.ServerType,
 		Image:    server.Spec.Image,
 		Location: server.Spec.Location,
 		Provider: server.Spec.Provider,

cmd/create-volume.go

@@ -47,11 +47,11 @@ func NewCreateVolumeCmd() *cobra.Command {
 		},
 	}
 
-	cmd.Flags().IntVar(&size, "size", 10, "Volume size in GB")
+	cmd.Flags().IntVar(&size, "size", config.DefaultVolumeSize, "Volume size in GB")
 	cmd.Flags().StringVar(&server, "server", "", "Server to attach the volume to")
 	cmd.Flags().StringToStringVar(&labels, "labels", map[string]string{}, "Volume labels")
 	cmd.Flags().BoolVar(&automount, "automount", false, "Automount the volume")
-	cmd.Flags().StringVar(&format, "format", "xfs", "Volume format")
+	cmd.Flags().StringVar(&format, "format", config.DefaultVolumeFormat, "Volume format")
 	if err := cmd.MarkFlagRequired("server"); err != nil {
 		panic(err)
 	}

cmd/delete-key.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"time"
 
 	"github.com/pavelanni/labshop/internal/config"
 	"github.com/spf13/cobra"
@@ -19,30 +20,34 @@ func NewDeleteSSHKeyCmd() *cobra.Command {
 			force, _ := cmd.Flags().GetBool("yes")
 			skipTimeCheck, _ := cmd.Flags().GetBool("force")
 
-			if !force {
-				fmt.Printf("Are you sure you want to delete key %s? [y/N] ", keyName)
-				var response string
-				_, err := fmt.Scanln(&response)
-				if err != nil {
-					return fmt.Errorf("failed to read response: %w", err)
-				}
-				if response != "y" && response != "Y" {
-					fmt.Println("Operation cancelled")
-					return nil
-				}
+			if !force && !askForConfirmationSimple("key", keyName) {
+				fmt.Println("Operation cancelled")
+				return nil
 			}
 
 			// Delete the key using cloud provider
-			if err := providerSvc.DeleteSSHKey(keyName, skipTimeCheck); err != nil {
-				return fmt.Errorf("failed to delete key: %w", err)
+			status := providerSvc.DeleteSSHKey(keyName, skipTimeCheck)
+			if status.Error != nil {
+				return fmt.Errorf("failed to delete key: %w", status.Error)
+			}
+			if !status.Deleted && status.DeleteAfter.After(time.Now().UTC()) {
+				fmt.Printf("Key %s is not ready for deletion until %s UTC\n", keyName, status.DeleteAfter.Format("2006-01-02 15:04:05"))
+				return nil
 			}
+			privateKeyPath := filepath.Join(os.Getenv("HOME"), config.DefaultConfigDir, config.KeysDir, keyName)
+			publicKeyPath := privateKeyPath + ".pub"
 			// Delete the key from the ~/.labshop/keys directory
-			if err := os.Remove(filepath.Join(os.Getenv("HOME"), config.DefaultConfigDir, config.KeysDir, keyName)); err != nil {
-				return fmt.Errorf("failed to delete private key from the keys directory: %w", err)
+			// check if the file exists
+			if _, err := os.Stat(privateKeyPath); err == nil {
+				if err := os.Remove(privateKeyPath); err != nil {
+					return fmt.Errorf("failed to delete private key from the keys directory: %w", err)
+				}
 			}
 			// Delete the public key from the ~/.labshop/keys directory
-			if err := os.Remove(filepath.Join(os.Getenv("HOME"), config.DefaultConfigDir, config.KeysDir, keyName+".pub")); err != nil {
-				return fmt.Errorf("failed to delete public key from the keys directory: %w", err)
+			if _, err := os.Stat(publicKeyPath); err == nil {
+				if err := os.Remove(publicKeyPath); err != nil {
+					return fmt.Errorf("failed to delete public key from the keys directory: %w", err)
+				}
 			}
 
 			fmt.Printf("Successfully deleted key %s\n", keyName)

cmd/delete-lab.go

@@ -16,22 +16,14 @@ func NewDeleteLabCmd() *cobra.Command {
 			assumeYes, _ := cmd.Flags().GetBool("yes")
 			skipTimeCheck, _ := cmd.Flags().GetBool("force")
 
-			if !assumeYes {
-				fmt.Printf("Are you sure you want to delete lab %s? [y/N] ", labName)
-				var response string
-				_, err := fmt.Scanln(&response)
-				if err != nil {
-					return fmt.Errorf("failed to read response: %w", err)
-				}
-				if response != "y" && response != "Y" {
-					fmt.Println("Operation cancelled")
-					return nil
-				}
+			if !assumeYes && !askForConfirmationSimple("lab", labName) {
+				fmt.Println("Operation cancelled")
+				return nil
 			}
 
 			// Delete the lab using cloud provider
-			if err := providerSvc.DeleteLab(labName, skipTimeCheck); err != nil {
-				return fmt.Errorf("failed to delete lab: %w", err)
+			if status := providerSvc.DeleteLab(labName, skipTimeCheck); status.Error != nil {
+				return fmt.Errorf("failed to delete lab: %w", status.Error)
 			}
 
 			fmt.Printf("Successfully deleted lab %s\n", labName)

cmd/delete-server.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/spf13/cobra"
 )
@@ -16,22 +17,19 @@ func NewDeleteServerCmd() *cobra.Command {
 			assumeYes, _ := cmd.Flags().GetBool("yes")
 			skipTimeCheck, _ := cmd.Flags().GetBool("force")
 
-			if !assumeYes {
-				fmt.Printf("Are you sure you want to delete server %s? [y/N] ", serverName)
-				var response string
-				_, err := fmt.Scanln(&response)
-				if err != nil {
-					return fmt.Errorf("failed to read response: %w", err)
-				}
-				if response != "y" && response != "Y" {
-					fmt.Println("Operation cancelled")
-					return nil
-				}
+			if !assumeYes && !askForConfirmationSimple("server", serverName) {
+				fmt.Println("Operation cancelled")
+				return nil
 			}
 
 			// Delete the server using cloud provider
-			if err := providerSvc.DeleteServer(serverName, skipTimeCheck); err != nil {
-				return fmt.Errorf("failed to delete server: %w", err)
+			status := providerSvc.DeleteServer(serverName, skipTimeCheck)
+			if status.Error != nil {
+				return fmt.Errorf("failed to delete server: %w", status.Error)
+			}
+			if !status.Deleted && status.DeleteAfter.After(time.Now().UTC()) {
+				fmt.Printf("Server %s is not ready for deletion until %s UTC\n", serverName, status.DeleteAfter.Format("2006-01-02 15:04:05"))
+				return nil
 			}
 
 			fmt.Printf("Successfully deleted server %s\n", serverName)

cmd/delete-volume.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/spf13/cobra"
 )
@@ -16,22 +17,19 @@ func NewDeleteVolumeCmd() *cobra.Command {
 			assumeYes, _ := cmd.Flags().GetBool("yes")
 			skipTimeCheck, _ := cmd.Flags().GetBool("force")
 
-			if !assumeYes {
-				fmt.Printf("Are you sure you want to delete volume %s? [y/N] ", volumeName)
-				var response string
-				_, err := fmt.Scanln(&response)
-				if err != nil {
-					return fmt.Errorf("failed to read response: %w", err)
-				}
-				if response != "y" && response != "Y" {
-					fmt.Println("Operation cancelled")
-					return nil
-				}
+			if !assumeYes && !askForConfirmationSimple("volume", volumeName) {
+				fmt.Println("Operation cancelled")
+				return nil
 			}
 
 			// Delete the volume using cloud provider
-			if err := providerSvc.DeleteVolume(volumeName, skipTimeCheck); err != nil {
-				return fmt.Errorf("failed to delete volume: %w", err)
+			status := providerSvc.DeleteVolume(volumeName, skipTimeCheck)
+			if status.Error != nil {
+				return fmt.Errorf("failed to delete volume: %w", status.Error)
+			}
+			if !status.Deleted && status.DeleteAfter.After(time.Now().UTC()) {
+				fmt.Printf("Volume %s is not ready for deletion until %s UTC\n", volumeName, status.DeleteAfter.Format("2006-01-02 15:04:05"))
+				return nil
 			}
 
 			fmt.Printf("Successfully deleted volume %s\n", volumeName)