clean up

Author: jsbroks

cmd/ctrlc/root/apply/apply.go

@@ -3,6 +3,7 @@ package apply
 import (
 	"context"
 	"fmt"
+	"sync"
 
 	"path/filepath"
 
@@ -28,14 +29,18 @@ type System struct {
 	Deployments map[string]Deployment `yaml:"deployments"`
 }
 
+type JobAgent struct {
+	Id     string         `yaml:"id"`
+	Config map[string]any `yaml:"config"`
+}
+
 type Deployment struct {
-	Name        string            `yaml:"name"`
-	Description string            `yaml:"description"`
-	SystemName  string            `yaml:"systemName"`
-	Metadata    map[string]string `yaml:"metadata"`
+	Name        string    `yaml:"name"`
+	Description *string   `yaml:"description"`
+	JobAgent    *JobAgent `yaml:"jobAgent,omitempty"`
 }
 
-// NewApplyCommand creates a new apply command
+// NewApplyCmd creates a new apply command
 func NewApplyCmd() *cobra.Command {
 	var filePath string
 
@@ -56,7 +61,6 @@ func NewApplyCmd() *cobra.Command {
 
 func runApply(filePath string) error {
 	ctx := context.Background()
-	logger := log.FromContext(ctx)
 
 	// Read and parse the YAML file
 	config, err := readConfigFile(filePath)
@@ -65,45 +69,156 @@ func runApply(filePath string) error {
 	}
 
 	// Create API client
+	client, workspaceID, err := createAPIClient()
+	if err != nil {
+		return err
+	}
+
+	// Process systems and collect errors
+	errors := processAllSystems(ctx, client, workspaceID, config.Systems)
+
+	if len(errors) > 0 {
+		return fmt.Errorf("encountered %d errors during apply", len(errors))
+	}
+
+	return nil
+}
+
+func createAPIClient() (*api.ClientWithResponses, uuid.UUID, error) {
 	apiURL := viper.GetString("url")
 	apiKey := viper.GetString("api-key")
 	workspace := viper.GetString("workspace")
 
 	workspaceID, err := uuid.Parse(workspace)
 	if err != nil {
-		return fmt.Errorf("invalid workspace ID: %w", err)
+		return nil, uuid.Nil, fmt.Errorf("invalid workspace ID: %w", err)
 	}
 
 	client, err := api.NewAPIKeyClientWithResponses(apiURL, apiKey)
 	if err != nil {
-		return fmt.Errorf("failed to create API client: %w", err)
+		return nil, uuid.Nil, fmt.Errorf("failed to create API client: %w", err)
 	}
 
-	for slug, system := range config.Systems {
-		logger.Info("Upserting system", "name", system.Name)
+	return client, workspaceID, nil
+}
 
-		systemID, err := upsertSystem(ctx, client, workspaceID, slug, system)
-		if err != nil {
-			logger.Error("Failed to upsert system", "name", system.Name, "error", err)
-			continue
-		}
-		logger.Info("System created successfully", "name", system.Name, "id", systemID)
+func processAllSystems(
+	ctx context.Context,
+	client *api.ClientWithResponses,
+	workspaceID uuid.UUID,
+	systems map[string]System,
+) []error {
+	systemErrors := make(chan error, len(systems))
+	var systemWg sync.WaitGroup
+
+	for slug, system := range systems {
+		systemWg.Add(1)
+		go processSystem(
+			ctx, 
+			client, 
+			workspaceID,
+			slug, 
+			system, 
+			&systemWg,
+		)
+	}
+
+	systemWg.Wait()
+	close(systemErrors)
+
+	// Collect all errors
+	var errList []error
+	for err := range systemErrors {
+		errList = append(errList, err)
+	}
+
+	return errList
+}
+
+func processSystem(
+	ctx context.Context,
+	client *api.ClientWithResponses,
+	workspaceID uuid.UUID,
+	slug string,
+	system System,
+	systemWg *sync.WaitGroup,
+) {
+	defer systemWg.Done()
+	
+	log.Info("Upserting system", "name", system.Name)
+	systemID, err := upsertSystem(ctx, client, workspaceID, slug, system)
+	if err != nil {
+		log.Error("Failed to upsert system", "name", system.Name, "error", err)
+		return
+	}
+	log.Info("System created successfully", "name", system.Name, "id", systemID)
+
+	systemIDUUID, err := uuid.Parse(systemID)
+	if err != nil {
+		log.Error("Failed to parse system ID as UUID", "id", systemID, "error", err)
+		return
+	}
+
+	processSystemDeployments(ctx, client, systemIDUUID, system)
+}
 
-		systemIDUUID, err := uuid.Parse(systemID)
+func processSystemDeployments(
+	ctx context.Context,
+	client *api.ClientWithResponses,
+	systemID uuid.UUID,
+	system System,
+) {
+	var deploymentWg sync.WaitGroup
+	for deploymentSlug, deployment := range system.Deployments {
+		deploymentWg.Add(1)
+		log.Info("Creating deployment", "system", system.Name, "name", deployment.Name)
+		go processDeployment(
+			ctx, 
+			client, 
+			systemID, 
+			deploymentSlug, 
+			deployment, 
+			&deploymentWg,
+		)
+	}
+	deploymentWg.Wait()
+}
+
+func processDeployment(
+	ctx context.Context,
+	client *api.ClientWithResponses,
+	systemID uuid.UUID,
+	deploymentSlug string,
+	deployment Deployment,
+	deploymentWg *sync.WaitGroup,
+) {
+	defer deploymentWg.Done()
+
+	body := createDeploymentRequestBody(systemID, deploymentSlug, deployment)
+	
+	if deployment.JobAgent != nil {
+		jobAgentUUID, err := uuid.Parse(deployment.JobAgent.Id)
 		if err != nil {
-			return fmt.Errorf("invalid system ID: %w", err)
+			log.Error("Failed to parse job agent ID as UUID", "id", deployment.JobAgent.Id, "error", err)
+			return
 		}
+		body.JobAgentId = &jobAgentUUID
+		body.JobAgentConfig = &deployment.JobAgent.Config
+	}
 
-		for deploymentSlug, deployment := range system.Deployments {
-			logger.Info("Creating deployment", "name", deployment.Name)
-			_, err := upsertDeployment(ctx, client, systemIDUUID, deploymentSlug, deployment)
-			if err != nil {
-				logger.Error("Failed to create deployment", "name", deployment.Name, "error", err)
-			}
-		}
+	_, err := upsertDeployment(ctx, client, body)
+	if err != nil {
+		log.Error("Failed to create deployment", "name", deployment.Name, "error", err)
 	}
+}
 
-	return nil
+func createDeploymentRequestBody(systemID uuid.UUID, slug string, deployment Deployment) api.CreateDeploymentJSONBody {
+	return api.CreateDeploymentJSONBody{
+		Slug:        slug,
+		SystemId:    systemID,
+		Name:        deployment.Name,
+		Description: deployment.Description,
+	}
 }
 
 func readConfigFile(filePath string) (*Config, error) {
@@ -164,21 +279,14 @@ func upsertSystem(
 func upsertDeployment(
 	ctx context.Context,
 	client *api.ClientWithResponses,
-	systemID uuid.UUID,
-	deploymentSlug string,
-	deployment Deployment,
+	deployment api.CreateDeploymentJSONBody,
 ) (string, error) {
-	resp, err := client.CreateDeploymentWithResponse(ctx, api.CreateDeploymentJSONRequestBody{
-		SystemId:    systemID,
-		Slug:        deploymentSlug,
-		Name:        deployment.Name,
-		Description: &deployment.Description,
-	})
+	resp, err := client.CreateDeploymentWithResponse(ctx, api.CreateDeploymentJSONRequestBody(deployment))
 
 	if err != nil {
 		return "", fmt.Errorf("API request failed: %w", err)
 	}
-	
+
 	if resp.StatusCode() >= 400 {
 		return "", fmt.Errorf("API returned error status: %d", resp.StatusCode())
 	}