fix: switched to meshkit loggers and addressed other review comments

Signed-off-by: SHIGRAF SALIK <[email protected]>

Author: ShigrafS

generators/github/git_repo.go

@@ -9,21 +9,28 @@ import (
 	"strings"
 
 	"github.com/meshery/meshkit/generators/models"
+	"github.com/meshery/meshkit/logger"
 	"github.com/meshery/meshkit/utils"
 	"github.com/meshery/meshkit/utils/helm"
 	"github.com/meshery/meshkit/utils/walker"
 )
 
 type GitRepo struct {
 	// <git://github.com/owner/repo/branch/versiontag/root(path to the directory/file)>
-	URL         *url.URL
+	URL       *url.URL
 	PackageName string
 }
 
 // Assumpations: 1. Always a K8s manifest
 // 2. Unzipped/unarchived File type
 
 func (gr GitRepo) GetContent() (models.Package, error) {
+	log, err := logger.New("generators-github", logger.Options{})
+	if err != nil {
+		// If logger fails to initialize, we can't proceed without logging capabilities.
+		// Alternatively, one could fall back to fmt.Println and continue.
+		return nil, err
+	}
 	gitWalker := walker.NewGit()
 
 	owner, repo, branch, root, err := gr.extractRepoDetailsFromSourceURL()
@@ -48,11 +55,11 @@ func (gr GitRepo) GetContent() (models.Package, error) {
 
 	defer func() {
 		if err := br.Flush(); err != nil {
-			fmt.Printf("Warning: failed to flush writer: %v\n", err)
+			log.Warnf("failed to flush writer: %v", err)
 		}
 
 		if err := fd.Close(); err != nil {
-			fmt.Printf("Warning: failed to close file: %v\n", err)
+			log.Warnf("failed to close file: %v", err)
 		}
 	}()
 

utils/unarchive.go

@@ -73,24 +73,23 @@ func readData(name string) (buffer []byte, err error) {
 
 func ExtractZip(path, artifactPath string) error {
 	zipReader, err := zip.OpenReader(artifactPath)
+	if err != nil {
+		return ErrExtractZip(err, path)
+	}
 	defer func() {
 		_ = zipReader.Close()
 	}()
 
-	if err != nil {
-		return ErrExtractZip(err, path)
-	}
 	buffer := make([]byte, 1<<4)
 	for _, file := range zipReader.File {
 
 		fd, err := file.Open()
-		defer func() {
-			_ = fd.Close()
-		}()
-
 		if err != nil {
 			return ErrExtractZip(err, path)
 		}
+		defer func() {
+			_ = fd.Close()
+		}()
 
 		filePath := filepath.Join(path, file.Name)
 
@@ -106,31 +105,30 @@ func ExtractZip(path, artifactPath string) error {
 			}
 			_, err = io.CopyBuffer(openedFile, fd, buffer)
 			if err != nil {
+				// We need to close the file, but the error from CopyBuffer is more important.
+				_ = openedFile.Close()
+				return ErrExtractZip(err, path)
+			}
+			if err := openedFile.Close(); err != nil {
 				return ErrExtractZip(err, path)
 			}
-			defer func() {
-				_ = openedFile.Close()
-			}()
 		}
-
 	}
 	return nil
-
 }
 
 func ExtractTarGz(path, downloadfilePath string) error {
 	gzipStream, err := os.Open(downloadfilePath)
 	if err != nil {
 		return ErrReadFile(err, downloadfilePath)
 	}
+	defer gzipStream.Close()
+
 	uncompressedStream, err := gzip.NewReader(gzipStream)
 	if err != nil {
 		return ErrExtractTarXZ(err, path)
 	}
-	defer func() {
-		_ = uncompressedStream.Close()
-		_ = gzipStream.Close()
-	}()
+	defer uncompressedStream.Close()
 
 	tarReader := tar.NewReader(uncompressedStream)
 
@@ -158,23 +156,35 @@ func ExtractTarGz(path, downloadfilePath string) error {
 				return ErrExtractTarXZ(err, path)
 			}
 			if _, err = io.Copy(outFile, tarReader); err != nil {
-				outFile.Close()
+				// The subsequent Close() call will handle closing the file.
+				// Return the more critical I/O error immediately.
+				_ = outFile.Close() // Attempt to close, but ignore error as we are returning the copy error.
 				return ErrExtractTarXZ(err, path)
 			}
 
 			// 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)
+				return ErrFileClose(err, header.Name)
 			}
 
 		default:
-			return ErrExtractTarXZ(err, path)
+			return ErrUnsupportedTarHeaderType(header.Typeflag, header.Name)
 		}
 	}
 
 	return nil
 }
 
+// ErrFileClose creates a standardized error for file closing failures.
+func ErrFileClose(err error, filename string) error {
+	return fmt.Errorf("failed to close file %s: %w", filename, err)
+}
+
+// ErrUnsupportedTarHeaderType creates an error for unsupported tar header types.
+func ErrUnsupportedTarHeaderType(typeflag byte, name string) error {
+	return fmt.Errorf("unsupported tar header type %v for file %s", typeflag, name)
+}
+
 func ProcessContent(filePath string, f func(path string) error) error {
 	pathInfo, err := os.Stat(filePath)
 	if err != nil {

utils/utils.go

@@ -145,7 +145,6 @@ 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() // Close the file before returning the error
 		return err