f

Author: emosbaugh

.github/workflows/v3-e2e.yaml

@@ -184,6 +184,7 @@ jobs:
 
       - name: Run test
         id: test
+        continue-on-error: true
         env:
           APP_VERSION: ${{ needs.output-vars.outputs.app_version }}
           KUBE_VERSION: "1.${{ needs.output-vars.outputs.k0s_minor_version }}"
@@ -240,6 +241,7 @@ jobs:
 
       - name: Run test
         id: test
+        continue-on-error: true
         env:
           APP_VERSION: ${{ needs.output-vars.outputs.app_version }}
           KUBE_VERSION: "1.${{ needs.output-vars.outputs.k0s_minor_version }}"

dagger/chainguard.go

@@ -20,7 +20,7 @@ func (m *chainguard) melangeBuildGo(
 	keygen := m.melangeKeygen(imageTag)
 
 	// Create cache volumes for improved build performance
-	goModCache := dag.CacheVolume("ec-melange-gomodcache")
+	goCache := dag.CacheVolume("ec-melange-gocache")
 	apkCache := dag.CacheVolume("ec-melange-apkcache")
 
 	c := dag.Container().
@@ -30,7 +30,7 @@ func (m *chainguard) melangeBuildGo(
 		WithFile("/workspace/melange.rsa", keygen.File("/workspace/melange.rsa")).
 		WithEnvVariable("MELANGE_CACHE_DIR", "/cache/melange").
 		WithEnvVariable("MELANGE_APK_CACHE_DIR", "/cache/apk").
-		WithMountedCache("/cache/melange", goModCache, dagger.ContainerWithMountedCacheOpts{
+		WithMountedCache("/cache/melange", goCache, dagger.ContainerWithMountedCacheOpts{
 			Sharing: dagger.CacheSharingModeShared,
 		}).
 		WithMountedCache("/cache/apk", apkCache, dagger.ContainerWithMountedCacheOpts{

dagger/e2e.go

@@ -55,7 +55,7 @@ func (m *EmbeddedCluster) E2eRunHeadless(
 	// Skip cleanup
 	// +default=false
 	skipCleanup bool,
-) (*dagger.Directory, error) {
+) (resultsDir *dagger.Directory) {
 	mode := "headless"
 
 	// Initialize test result that will be built up throughout the function
@@ -66,15 +66,15 @@ func (m *EmbeddedCluster) E2eRunHeadless(
 	}
 
 	// Initialize results directory
-	resultsDir := dag.Directory()
+	resultsDir = dag.Directory()
 
 	// Log test start
 	fmt.Printf("Starting E2E test: scenario=%s mode=%s app-version=%s kube-version=%s\n",
 		scenario, mode, appVersion, kubeVersion)
 
 	// Provision a fresh CMX VM for testing
 	fmt.Printf("Provisioning CMX VM for %s %s test...\n", scenario, mode)
-	vm, err := m.ProvisionCmxVm(
+	vm, provisionErr := m.ProvisionCmxVm(
 		ctx,
 		fmt.Sprintf("ec-e2e-%s-%s", scenario, mode),
 		"ubuntu",
@@ -86,10 +86,11 @@ func (m *EmbeddedCluster) E2eRunHeadless(
 		cmxToken,
 		sshKey,
 	)
-	if err != nil {
-		testResult.Error = fmt.Sprintf("failed to provision VM: %v", err)
+	if provisionErr != nil {
+		testResult.Error = fmt.Sprintf("failed to provision VM: %v", provisionErr)
 		resultJSON, _ := json.MarshalIndent(testResult, "", "  ")
-		return resultsDir.WithNewFile("result.json", string(resultJSON)), nil
+		resultsDir = resultsDir.WithNewFile("result.json", string(resultJSON))
+		return
 	}
 
 	fmt.Printf("Provisioned VM: %s\n", vm.VmID)
@@ -100,19 +101,19 @@ func (m *EmbeddedCluster) E2eRunHeadless(
 		// Collect support bundle before cleanup
 		if vm != nil {
 			fmt.Printf("Collecting support bundle from VM %s...\n", vm.VmID)
-			supportBundle, err := vm.CollectClusterSupportBundle(ctx)
-			if err != nil {
-				fmt.Printf("Warning: failed to collect support bundle: %v\n", err)
-				resultsDir = resultsDir.WithNewFile("support-bundle-error.txt", fmt.Sprintf("Failed to collect support bundle: %v", err))
+			supportBundle, bundleErr := vm.CollectClusterSupportBundle(ctx)
+			if bundleErr != nil {
+				fmt.Printf("Warning: failed to collect support bundle: %v\n", bundleErr)
+				resultsDir = resultsDir.WithNewFile("support-bundle-error.txt", fmt.Sprintf("Failed to collect support bundle: %v", bundleErr))
 			} else {
 				resultsDir = resultsDir.WithFile("support-bundle.tar.gz", supportBundle)
 			}
 		}
 
 		// Marshal final test result to JSON
-		resultJSON, err := json.MarshalIndent(testResult, "", "  ")
-		if err != nil {
-			fmt.Printf("Warning: failed to marshal test result: %v\n", err)
+		resultJSON, marshalErr := json.MarshalIndent(testResult, "", "  ")
+		if marshalErr != nil {
+			fmt.Printf("Warning: failed to marshal test result: %v\n", marshalErr)
 			return
 		}
 		resultsDir = resultsDir.WithNewFile("result.json", string(resultJSON))
@@ -128,37 +129,37 @@ func (m *EmbeddedCluster) E2eRunHeadless(
 	}()
 
 	// Download and prepare embedded-cluster release
-	if err := vm.PrepareRelease(ctx, scenario, appVersion, licenseFile); err != nil {
-		testResult.Error = fmt.Sprintf("failed to prepare release: %v", err)
-		return resultsDir, nil
+	if prepareErr := vm.PrepareRelease(ctx, scenario, appVersion, licenseFile); prepareErr != nil {
+		testResult.Error = fmt.Sprintf("failed to prepare release: %v", prepareErr)
+		return
 	}
 
 	// For airgap scenarios, apply network policy to block internet access
 	if scenario == "airgap" {
 		fmt.Printf("Applying airgap network policy on VM %s...\n", vm.VmID)
-		if err := vm.ApplyAirgapNetworkPolicy(ctx); err != nil {
-			testResult.Error = fmt.Sprintf("failed to apply airgap network policy: %v", err)
-			return resultsDir, nil
+		if airgapErr := vm.ApplyAirgapNetworkPolicy(ctx); airgapErr != nil {
+			testResult.Error = fmt.Sprintf("failed to apply airgap network policy: %v", airgapErr)
+			return
 		}
 	}
 
 	// Run headless installation
 	fmt.Printf("Running headless installation on VM %s...\n", vm.VmID)
-	installResult, err := vm.InstallHeadless(
+	installResult, installErr := vm.InstallHeadless(
 		ctx,
 		scenario,
 		appVersion,
 		licenseFile,
 		dag.File("config-values.yaml", configValuesFileContent),
 	)
-	if err != nil {
-		testResult.Error = fmt.Sprintf("installation failed: %v", err)
-		return resultsDir, nil
+	if installErr != nil {
+		testResult.Error = fmt.Sprintf("installation failed: %v", installErr)
+		return
 	}
 
 	if !installResult.Success {
 		testResult.Error = "installation reported failure"
-		return resultsDir, nil
+		return
 	}
 
 	// Validate installation
@@ -181,7 +182,7 @@ func (m *EmbeddedCluster) E2eRunHeadless(
 		fmt.Printf("Test PASSED: %s %s test completed successfully\n", scenario, mode)
 	}
 
-	return resultsDir, nil
+	return
 }
 
 func parseLicense(ctx context.Context, licenseFile *dagger.File) (contents string, licenseID string, channelID string, err error) {

dagger/localartifactmirror.go

@@ -110,8 +110,19 @@ func (m *EmbeddedCluster) BuildLocalArtifactMirrorPackage(
 	melangeFile := m.melangeTemplateLocalArtifactMirror(src, ecVersion, kzerosMinorVersion)
 
 	dir := dag.Directory().
-		WithDirectory("local-artifact-mirror", src.Directory("local-artifact-mirror")).
-		WithDirectory("cmd", src.Directory("cmd"))
+		WithDirectory("local-artifact-mirror",
+			src.Directory("local-artifact-mirror").
+				WithoutDirectory("bin").
+				WithoutDirectory("build").
+				WithoutDirectory("cache"),
+		).
+		WithDirectory("cmd",
+			src.Directory("cmd").
+				WithoutDirectory("installer/goods/bins").
+				WithNewFile("installer/goods/bins/.placeholder", ".placeholder").
+				WithoutDirectory("installer/goods/internal/bins").
+				WithNewFile("installer/goods/internal/bins/.placeholder", ".placeholder"),
+		)
 
 	build := m.chainguard.melangeBuildGo(
 		directoryWithCommonGoFiles(dir, src),

dagger/main.go

@@ -50,7 +50,13 @@ func directoryWithCommonGoFiles(dir *dagger.Directory, src *dagger.Directory) *d
 		WithFile("go.sum", src.File("go.sum")).
 		WithDirectory("pkg", src.Directory("pkg")).
 		WithDirectory("pkg-new", src.Directory("pkg-new")).
-		WithDirectory("cmd/installer/goods", src.Directory("cmd/installer/goods")).
+		WithDirectory("cmd/installer/goods",
+			src.Directory("cmd/installer/goods").
+				WithoutDirectory("bins").
+				WithNewFile("bins/.placeholder", ".placeholder").
+				WithoutDirectory("internal/bins").
+				WithNewFile("internal/bins/.placeholder", ".placeholder"),
+		).
 		WithDirectory("api", src.Directory("api")).
 		WithDirectory("kinds", src.Directory("kinds")).
 		WithDirectory("utils", src.Directory("utils"))