refactor(file-handling): improve error handling and file cleanup

Signed-off-by: ShigrafS <[email protected]>

Author: ShigrafS

files/tests/sanitization_test.go

@@ -146,9 +146,17 @@ func TestSanitizeFile(t *testing.T) {
 		".zip":    true,
 	}
 
-	tempDir, _ := os.MkdirTemp(" ", "temp-tests")
-	defer os.RemoveAll(tempDir)
-	// tempDir := "./temp"
+	// Create a temporary directory for the tests and handle potential errors.
+	tempDir, err := os.MkdirTemp(" ", "temp-tests")
+	if err != nil {
+		t.Fatalf("Failed to create temporary directory: %v", err)
+	}
+	// Defer cleanup and log any error that occurs during cleanup.
+	defer func() {
+		if err := os.RemoveAll(tempDir); err != nil {
+			t.Logf("Warning: failed to remove temporary directory %s: %v", tempDir, err)
+		}
+	}()
 
 	for _, tc := range testCases {
 

generators/github/git_repo.go

@@ -47,9 +47,15 @@ func (gr GitRepo) GetContent() (models.Package, error) {
 	br := bufio.NewWriter(fd)
 
 	defer func() {
-		br.Flush()
-		fd.Close()
+		if err := br.Flush(); err != nil {
+			fmt.Printf("Warning: failed to flush writer: %v\n", err)
+		}
+
+		if err := fd.Close(); err != nil {
+			fmt.Printf("Warning: failed to close file: %v\n", err)
+		}
 	}()
+
 	gw := gitWalker.
 		Owner(owner).
 		Repo(repo).

utils/kubernetes/kompose/convert.go

@@ -1,6 +1,7 @@
 package kompose
 
 import (
+	"fmt"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -42,52 +43,93 @@ func Convert(dockerCompose DockerComposeFile) (string, error) {
 	tempFilePath := filepath.Join(mesheryDir, "temp.data")
 	resultFilePath := filepath.Join(mesheryDir, "result.yaml")
 
+	// Create the temp file
 	if err := utils.CreateFile(dockerCompose, "temp.data", mesheryDir); err != nil {
 		return "", ErrCvrtKompose(err)
 	}
 
-	defer func() {
-		os.Remove(tempFilePath)
-		os.Remove(resultFilePath)
-	}()
+	// Format Docker Compose file for Kompose
+	err = formatComposeFile(&dockerCompose)
+	if err != nil {
+		return "", ErrCvrtKompose(err)
+	}
 
-	formatComposeFile(&dockerCompose)
+	// Check version compatibility
 	err = versionCheck(dockerCompose)
 	if err != nil {
 		return "", ErrCvrtKompose(err)
 	}
 
+	// Initialize Kompose client
 	komposeClient, err := client.NewClient()
 	if err != nil {
 		return "", ErrCvrtKompose(err)
 	}
 
+	// Set up Convert options
 	ConvertOpt := client.ConvertOptions{
 		InputFiles:              []string{tempFilePath},
 		OutFile:                 resultFilePath,
 		GenerateNetworkPolicies: true,
 	}
 
+	// Convert using Kompose client
 	_, err = komposeClient.Convert(ConvertOpt)
 	if err != nil {
 		return "", ErrCvrtKompose(err)
 	}
 
+	// Read the result file
 	result, err := os.ReadFile(resultFilePath)
 	if err != nil {
 		return "", ErrCvrtKompose(err)
 	}
 
+	// Clean up temporary files
+	cleanupErr := cleanup(tempFilePath, resultFilePath)
+	if cleanupErr != nil {
+		return "", cleanupErr
+	}
+
 	return string(result), nil
 }
 
-type composeFile struct {
-	Version string `yaml:"version,omitempty"`
+// cleanup removes temporary files
+func cleanup(tempFilePath, resultFilePath string) error {
+	// Try to remove tempFilePath
+	if err := os.Remove(tempFilePath); err != nil {
+		return fmt.Errorf("failed to remove temp file %s: %w", tempFilePath, err)
+	}
+
+	// Try to remove resultFilePath
+	if err := os.Remove(resultFilePath); err != nil {
+		return fmt.Errorf("failed to remove result file %s: %w", resultFilePath, err)
+	}
+
+	return nil // No errors
+}
+
+// formatComposeFile takes in a pointer to the compose file byte array and formats it
+// so that it is compatible with Kompose. It expects a validated Docker Compose file.
+func formatComposeFile(yamlManifest *DockerComposeFile) error {
+	data := composeFile{}
+	err := yaml.Unmarshal(*yamlManifest, &data)
+	if err != nil {
+		return fmt.Errorf("failed to unmarshal compose file: %w", err)
+	}
+
+	// Marshal it again to ensure it is in the correct format for Kompose
+	out, err := yaml.Marshal(data)
+	if err != nil {
+		return fmt.Errorf("failed to marshal compose file: %w", err)
+	}
+
+	*yamlManifest = out
+	return nil
 }
 
-// checks if the version is compatible with `kompose`
-// expects a valid docker compose yaml
-// error = nil means it is compatible
+// versionCheck checks if the version in the Docker Compose file is compatible with Kompose.
+// It expects a valid Docker Compose YAML and returns an error if the version is not supported.
 func versionCheck(dc DockerComposeFile) error {
 	cf := composeFile{}
 	err := yaml.Unmarshal(dc, &cf)
@@ -108,18 +150,7 @@ func versionCheck(dc DockerComposeFile) error {
 	return nil
 }
 
-// formatComposeFile takes in a pointer to the compose file byte array and formats it so that it is compatible with `Kompose`
-// it expects a validated docker compose file and does not validate
-func formatComposeFile(yamlManifest *DockerComposeFile) {
-	data := composeFile{}
-	err := yaml.Unmarshal(*yamlManifest, &data)
-	if err != nil {
-		return
-	}
-	// so that "3.3" and 3.3 are treated differently by `Kompose`
-	out, err := yaml.Marshal(data)
-	if err != nil {
-		return
-	}
-	*yamlManifest = out
+// composeFile represents the structure of the Docker Compose file version.
+type composeFile struct {
+	Version string `yaml:"version,omitempty"`
 }

utils/unarchive.go

@@ -4,6 +4,7 @@ import (
 	"archive/tar"
 	"archive/zip"
 	"compress/gzip"
+	"fmt"
 	"io"
 	"net/http"
 	"os"
@@ -149,22 +150,28 @@ func ExtractTarGz(path, downloadfilePath string) error {
 				return ErrExtractTarXZ(err, path)
 			}
 		case tar.TypeReg:
+			// Ensure that the directory for the file exists
 			_ = os.MkdirAll(filepath.Join(path, filepath.Dir(header.Name)), 0755)
 			var outFile *os.File
 			outFile, err = os.Create(filepath.Join(path, header.Name))
 			if err != nil {
 				return ErrExtractTarXZ(err, path)
 			}
 			if _, err = io.Copy(outFile, tarReader); err != nil {
+				outFile.Close()
 				return ErrExtractTarXZ(err, path)
 			}
-			outFile.Close()
+
+			// Close the file and check for errors
+			if err := outFile.Close(); err != nil {
+				return fmt.Errorf("failed to close output file %s: %w", header.Name, err)
+			}
 
 		default:
 			return ErrExtractTarXZ(err, path)
 		}
-
 	}
+
 	return nil
 }
 

utils/utils.go

@@ -145,13 +145,15 @@ func CreateFile(contents []byte, filename string, location string) error {
 		return err
 	}
 
+	// Write contents to the file
 	if _, err = fd.Write(contents); err != nil {
-		fd.Close()
+		fd.Close() // Close the file before returning the error
 		return err
 	}
 
-	if err = fd.Close(); err != nil {
-		return err
+	// Check error while closing the file
+	if err := fd.Close(); err != nil {
+		return fmt.Errorf("failed to close file descriptor: %w", err)
 	}
 
 	return nil

utils/walker/git.go

@@ -144,7 +144,9 @@ func clonewalk(g *Git) error {
 	var wg sync.WaitGroup
 	defer func() {
 		wg.Wait()
-		os.RemoveAll(path)
+		if err := os.RemoveAll(path); err != nil {
+			fmt.Println(fmt.Errorf("failed to remove path %s: %w", path, err))
+		}
 	}()
 	var err error
 	cloneOptions := &git.CloneOptions{