Merge pull request #19 from nauticalab/eywalker/plt-149-manually-verify-the-parity-between-new-devenv-engine-and-the

Fix GPU resource formatting and enhance manifest generation

Author: maxwellgagnon

.github/workflows/release.yml

@@ -1,85 +1,85 @@
 name: Release
 
 on:
-    push:
-        tags:
-            - "v*" # Trigger on version tags like v0.1.0, v1.2.3
+  push:
+    tags:
+      - "v*" # Trigger on version tags like v0.1.0, v1.2.3
 
 permissions:
-    contents: write # Required for creating releases
+  contents: write # Required for creating releases
 
 jobs:
-    test:
-        name: Run Tests
-        runs-on: ubuntu-latest
-        steps:
-            - name: Checkout code
-              uses: actions/checkout@v5
-
-            - name: Set up Go
-              uses: actions/setup-go@v5
-              with:
-                  go-version: "1.24"
-
-            - name: Run tests
-              run: go test -v ./...
-
-    release:
-        name: Build and Release
-        needs: test # Only run if tests pass
-        runs-on: ubuntu-latest
-        steps:
-            - name: Checkout code
-              uses: actions/checkout@v5
-
-            - name: Set up Go
-              uses: actions/setup-go@v5
-              with:
-                  go-version: "1.24"
-
-            - name: Build binaries for all platforms
-              run: |
-                  # Get version from tag (GitHub sets GITHUB_REF to refs/tags/v0.1.0)
-                  VERSION=${GITHUB_REF#refs/tags/}
-                  COMMIT=$(git rev-parse --short HEAD)
-                  BUILD_TIME=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
-                  GO_VERSION=$(go version | awk '{print $3}')
-
-                  echo "Building version: ${VERSION}"
-
-                  # Build flags
-                  LDFLAGS="-X main.version=${VERSION} -X main.gitCommit=${COMMIT} -X main.buildTime=${BUILD_TIME} -X main.goVersion=${GO_VERSION} -w -s"
-
-                  # Create output directory
-                  mkdir -p dist
-
-                  # Linux amd64
-                  echo "Building Linux amd64..."
-                  GOOS=linux GOARCH=amd64 go build -ldflags="${LDFLAGS}" -o dist/devenv-linux-amd64 ./cmd/devenv
-
-                  # macOS amd64 (Intel)
-                  echo "Building macOS amd64..."
-                  GOOS=darwin GOARCH=amd64 go build -ldflags="${LDFLAGS}" -o dist/devenv-darwin-amd64 ./cmd/devenv
-
-                  # macOS arm64 (Apple Silicon)
-                  echo "Building macOS arm64..."
-                  GOOS=darwin GOARCH=arm64 go build -ldflags="${LDFLAGS}" -o dist/devenv-darwin-arm64 ./cmd/devenv
-
-                  # Windows amd64
-                  echo "Building Windows amd64..."
-                  GOOS=windows GOARCH=amd64 go build -ldflags="${LDFLAGS}" -o dist/devenv-windows-amd64.exe ./cmd/devenv
-
-                  echo "✅ All binaries built successfully"
-                  ls -lh dist/
-
-            - name: Create Release
-              uses: softprops/action-gh-release@v2
-              with:
-                  files: |
-                      dist/devenv-linux-amd64
-                      dist/devenv-darwin-amd64
-                      dist/devenv-darwin-arm64
-                      dist/devenv-windows-amd64.exe
-                  generate_release_notes: true
-                  draft: false
-                  prerelease: false
+  test:
+    name: Run Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+
+      - name: Run tests
+        run: go test -v ./...
+
+  release:
+    name: Build and Release
+    needs: test # Only run if tests pass
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.24"
+
+      - name: Build binaries for all platforms
+        run: |
+          # Get version from tag (GitHub sets GITHUB_REF to refs/tags/v0.1.0)
+          VERSION=${GITHUB_REF#refs/tags/}
+          COMMIT=$(git rev-parse --short HEAD)
+          BUILD_TIME=$(date -u +'%Y-%m-%dT%H:%M:%SZ')
+          GO_VERSION=$(go version | awk '{print $3}')
+
+          echo "Building version: ${VERSION}"
+
+          # Build flags
+          LDFLAGS="-X main.version=${VERSION} -X main.gitCommit=${COMMIT} -X main.buildTime=${BUILD_TIME} -X main.goVersion=${GO_VERSION} -w -s"
+
+          # Create output directory
+          mkdir -p dist
+
+          # Linux amd64
+          echo "Building Linux amd64..."
+          GOOS=linux GOARCH=amd64 go build -ldflags="${LDFLAGS}" -o dist/devenv-linux-amd64 ./cmd/devenv
+
+          # macOS amd64 (Intel)
+          echo "Building macOS amd64..."
+          GOOS=darwin GOARCH=amd64 go build -ldflags="${LDFLAGS}" -o dist/devenv-darwin-amd64 ./cmd/devenv
+
+          # macOS arm64 (Apple Silicon)
+          echo "Building macOS arm64..."
+          GOOS=darwin GOARCH=arm64 go build -ldflags="${LDFLAGS}" -o dist/devenv-darwin-arm64 ./cmd/devenv
+
+          # Windows amd64
+          echo "Building Windows amd64..."
+          GOOS=windows GOARCH=amd64 go build -ldflags="${LDFLAGS}" -o dist/devenv-windows-amd64.exe ./cmd/devenv
+
+          echo "✅ All binaries built successfully"
+          ls -lh dist/
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            dist/devenv-linux-amd64
+            dist/devenv-darwin-amd64
+            dist/devenv-darwin-arm64
+            dist/devenv-windows-amd64.exe
+          generate_release_notes: true
+          draft: false
+          prerelease: false

Taskfile.yml

@@ -116,7 +116,7 @@ tasks:
   test:
     desc: Run tests
     cmds:
-      - go test -v ./... {{.CLI_ARGS}}
+      - go test ./... {{.CLI_ARGS}}
 
   clean:
     desc: Clean build artifacts
@@ -129,7 +129,7 @@ tasks:
   update-golden:
     desc: Update golden files for tests
     cmds:
-      - go test ./... -update-golden {{.CLI_ARGS}} 
+      - go test ./... -- -update-golden {{.CLI_ARGS}} 
 
   doc:
     desc: Launch pkgsite documentation server

cmd/devenv/generate.go

@@ -78,37 +78,56 @@ func init() {
 }
 
 func generateAllDevelopersWithProgress() {
-	// Step 1: Discover all developers
+	// Step 1: Load global config once
+	globalConfig, err := config.LoadGlobalConfig(configDir)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error loading global config in %s: %v\n", configDir, err)
+		os.Exit(1)
+	}
+
+	if verbose {
+		fmt.Printf("Generating system manifests in %s\n", outputDir)
+	}
+
+	// Step 2: Generate system manifests once
+	if !dryRun {
+		if err := generateSystemManifests(globalConfig, outputDir); err != nil {
+			fmt.Fprintf(os.Stderr, "Error generating system manifests: %v\n", err)
+			os.Exit(1)
+		}
+	}
+
+	// Step 3: Discover all developers
 	developers, err := findAllDevelopers(configDir)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error discovering developers: %v\n", err)
 		os.Exit(1)
 	}
 
 	if len(developers) == 0 {
-		fmt.Printf("No deveolopers found in %s\n", configDir)
+		fmt.Printf("No developers found in %s\n", configDir)
 		return
 	}
 
 	fmt.Printf("Found %d developers to process.\n", len(developers))
 
-	// Step 2: Set up channels for worker communication
+	// Step 4: Set up channels for worker communication
 	const numWorkers = 4
 	jobs := make(chan DeveloperJob, len(developers))
 	results := make(chan ProcessingResult, len(developers))
 
-	// Step 3: Start worker goroutines
+	// Step 5: Start worker goroutines
 	for i := 0; i < numWorkers; i++ {
-		go developerWorker(jobs, results)
+		go developerWorker(jobs, results, globalConfig)
 	}
 
-	// Step 4: Send all jobs to workers
+	// Step 6: Send all jobs to workers
 	for _, dev := range developers {
 		jobs <- DeveloperJob{Name: dev}
 	}
 	close(jobs)
 
-	// Step 5: Collect results
+	// Step 7: Collect results
 	var successCount, failureCount int
 	var failures []ProcessingResult
 
@@ -126,7 +145,7 @@ func generateAllDevelopersWithProgress() {
 		}
 	}
 
-	// Step 6: Print final summary
+	// Step 8: Print final summary
 	fmt.Printf("\n🎉 Batch processing complete!\n")
 	fmt.Printf("✅ Successful: %d\n", successCount)
 	if failureCount > 0 {
@@ -142,10 +161,10 @@ func generateAllDevelopersWithProgress() {
 	}
 }
 
-func developerWorker(jobs <-chan DeveloperJob, results chan<- ProcessingResult) {
+func developerWorker(jobs <-chan DeveloperJob, results chan<- ProcessingResult, globalConfig *config.BaseConfig) {
 	for job := range jobs {
 		startTime := time.Now()
-		err := processSingleDeveloperForBatchWithError(job.Name)
+		err := processSingleDeveloperForBatchWithError(job.Name, globalConfig)
 
 		results <- ProcessingResult{
 			Developer: job.Name,
@@ -157,12 +176,12 @@ func developerWorker(jobs <-chan DeveloperJob, results chan<- ProcessingResult)
 }
 
 // processSingleDeveloperForBatchWithError processes a single developer for batch mode
-func processSingleDeveloperForBatchWithError(developerName string) error {
+func processSingleDeveloperForBatchWithError(developerName string, globalConfig *config.BaseConfig) error {
 	if verbose {
 		fmt.Printf("Processing developer: %s\n", developerName)
 	}
 
-	cfg, err := config.LoadDeveloperConfigWithGlobalDefaults(configDir, developerName)
+	cfg, err := config.LoadDeveloperConfigWithBaseConfig(configDir, developerName, globalConfig)
 	if err != nil {
 		return fmt.Errorf("failed to load config: %w", err)
 	}
@@ -171,7 +190,7 @@ func processSingleDeveloperForBatchWithError(developerName string) error {
 	userOutputDir := filepath.Join(outputDir, developerName)
 
 	if !dryRun {
-		if err := generateManifests(cfg, userOutputDir); err != nil {
+		if err := generateDeveloperManifests(cfg, userOutputDir); err != nil {
 			return fmt.Errorf("failed to generate manifests: %w", err)
 		}
 	}
@@ -212,7 +231,18 @@ func generateSingleDeveloper(developerName string) {
 
 	userOutputDir := filepath.Join(outputDir, developerName)
 
-	cfg, err := config.LoadDeveloperConfigWithGlobalDefaults(configDir, developerName)
+	globalConfig, err := config.LoadGlobalConfig(configDir)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error loading global config in %s: %v\n", configDir, err)
+		os.Exit(1)
+	}
+
+	if err := generateSystemManifests(globalConfig, outputDir); err != nil {
+		fmt.Fprintf(os.Stderr, "Error generating system manifests: %v\n", err)
+		os.Exit(1)
+	}
+
+	cfg, err := config.LoadDeveloperConfigWithBaseConfig(configDir, developerName, globalConfig)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error loading config for developer %s: %v\n", developerName, err)
 		os.Exit(1)
@@ -225,7 +255,7 @@ func generateSingleDeveloper(developerName string) {
 	}
 
 	if !dryRun {
-		if err := generateManifests(cfg, userOutputDir); err != nil {
+		if err := generateDeveloperManifests(cfg, userOutputDir); err != nil {
 			fmt.Fprintf(os.Stderr, "Error generating manifests: %v\n", err)
 			os.Exit(1)
 		}
@@ -234,10 +264,24 @@ func generateSingleDeveloper(developerName string) {
 	}
 }
 
-// generateManifests creates Kubernetes manifests for a developer
-func generateManifests(cfg *config.DevEnvConfig, outputDir string) error {
+func generateSystemManifests(cfg *config.BaseConfig, outputDir string) error {
+	// Create template renderer
+	renderer := templates.NewSystemRenderer(outputDir)
+
+	// Render all main templates
+	if err := renderer.RenderAll(cfg); err != nil {
+		return fmt.Errorf("failed to render templates: %w", err)
+	}
+
+	fmt.Printf("🎉 Successfully generated system manifests\n")
+
+	return nil
+}
+
+// generateDeveloperManifests creates Kubernetes manifests for a developer
+func generateDeveloperManifests(cfg *config.DevEnvConfig, outputDir string) error {
 	// Create template renderer
-	renderer := templates.NewRenderer(outputDir)
+	renderer := templates.NewDevRenderer(outputDir)
 
 	// Render all main templates
 	if err := renderer.RenderAll(cfg); err != nil {

internal/config/parser.go

@@ -79,16 +79,11 @@ func LoadDeveloperConfig(configDir, developerName string) (*DevEnvConfig, error)
 // LoadDeveloperConfigWithGlobalDefaults loads a developer config and merges it with global defaults.
 // This is the recommended loading function that provides the complete configuration hierarchy:
 // System defaults → Global config → User config
-func LoadDeveloperConfigWithGlobalDefaults(configDir, developerName string) (*DevEnvConfig, error) {
-	// Step 1: Load global configuration (pre-populated with system defaults)
-	globalConfig, err := LoadGlobalConfig(configDir)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load global config: %w", err)
-	}
+func LoadDeveloperConfigWithBaseConfig(configDir, developerName string, baseConfig *BaseConfig) (*DevEnvConfig, error) {
 
 	// Step 2: Create user config pre-populated with global config values
 	userConfig := &DevEnvConfig{
-		BaseConfig: *globalConfig, // Copy all global values (which include system defaults)
+		BaseConfig: *baseConfig, // Copy all global values (which include system defaults)
 	}
 
 	// Step 3: Load user YAML
@@ -113,7 +108,7 @@ func LoadDeveloperConfigWithGlobalDefaults(configDir, developerName string) (*De
 
 	// Step 5: Merge additive list fields (packages, volumes, SSH keys)
 	// Note that this step is neceessary because YAML unmarshaling replaces slices
-	userConfig.mergeListFields(globalConfig)
+	userConfig.mergeListFields(baseConfig)
 
 	// Step 6: Set developer directory and validate
 	userConfig.DeveloperDir = developerDir