Started implementation on the new bpm file structure

main.go

@@ -178,26 +178,26 @@ func resolveCommand() {
 			bpmFile      string
 			isDependency bool
 			shouldFetch  bool
-			pkgInfo      *utils.PackageInfo
+			bpmpkg       *utils.BPMPackage
 		}]()
 		unresolvedDepends := make([]string, 0)
 
 		// Search for packages
 		for _, pkg := range pkgs {
 			if stat, err := os.Stat(pkg); err == nil && !stat.IsDir() {
-				pkgInfo, err := utils.ReadPackage(pkg)
+				bpmpkg, err := utils.ReadPackage(pkg)
 				if err != nil {
 					log.Fatalf("Error: could not read package: %s\n", err)
 				}
-				if !reinstall && utils.IsPackageInstalled(pkgInfo.Name, rootDir) && utils.GetPackageInfo(pkgInfo.Name, rootDir, true).GetFullVersion() == pkgInfo.GetFullVersion() {
+				if !reinstall && utils.IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) && utils.GetPackageInfo(bpmpkg.PkgInfo.Name, rootDir, true).GetFullVersion() == bpmpkg.PkgInfo.GetFullVersion() {
 					continue
 				}
-				pkgsToInstall.Set(pkgInfo.Name, &struct {
+				pkgsToInstall.Set(bpmpkg.PkgInfo.Name, &struct {
 					bpmFile      string
 					isDependency bool
 					shouldFetch  bool
-					pkgInfo      *utils.PackageInfo
+					bpmpkg       *utils.BPMPackage
-				}{bpmFile: pkg, isDependency: false, shouldFetch: false, pkgInfo: pkgInfo})
+				}{bpmFile: pkg, isDependency: false, shouldFetch: false, bpmpkg: bpmpkg})
 			} else {
 				entry, _, err := utils.GetRepositoryEntry(pkg)
 				if err != nil {
@@ -210,8 +210,11 @@ func resolveCommand() {
 					bpmFile      string
 					isDependency bool
 					shouldFetch  bool
-					pkgInfo      *utils.PackageInfo
+					bpmpkg       *utils.BPMPackage
-				}{bpmFile: "", isDependency: false, shouldFetch: true, pkgInfo: entry.Info})
+				}{bpmFile: "", isDependency: false, shouldFetch: true, bpmpkg: &utils.BPMPackage{
+					PkgInfo:  entry.Info,
+					PkgFiles: nil,
+				}})
 			}
 		}
 
@@ -220,14 +223,14 @@ func resolveCommand() {
 			bpmFile      string
 			isDependency bool
 			shouldFetch  bool
-			pkgInfo      *utils.PackageInfo
+			bpmpkg       *utils.BPMPackage
 		}]()
 		for _, pkg := range clone.Keys() {
 			value, _ := clone.Get(pkg)
-			resolved, unresolved := value.pkgInfo.ResolveAll(&[]string{}, &[]string{}, value.pkgInfo.Type == "source", !noOptional, !reinstall, verbose, rootDir)
+			resolved, unresolved := value.bpmpkg.PkgInfo.ResolveAll(&[]string{}, &[]string{}, value.bpmpkg.PkgInfo.Type == "source", !noOptional, !reinstall, verbose, rootDir)
 			unresolvedDepends = append(unresolvedDepends, unresolved...)
 			for _, depend := range resolved {
-				if _, ok := pkgsToInstall.Get(depend); !ok && depend != value.pkgInfo.Name {
+				if _, ok := pkgsToInstall.Get(depend); !ok && depend != value.bpmpkg.PkgInfo.Name {
 					if !reinstallAll && utils.IsPackageInstalled(depend, rootDir) {
 						continue
 					}
@@ -239,8 +242,11 @@ func resolveCommand() {
 						bpmFile      string
 						isDependency bool
 						shouldFetch  bool
-						pkgInfo      *utils.PackageInfo
+						bpmpkg       *utils.BPMPackage
-					}{bpmFile: "", isDependency: true, shouldFetch: true, pkgInfo: entry.Info})
+					}{bpmFile: "", isDependency: true, shouldFetch: true, bpmpkg: &utils.BPMPackage{
+						PkgInfo:  entry.Info,
+						PkgFiles: nil,
+					}})
 				}
 			}
 			pkgsToInstall.Set(pkg, value)
@@ -259,12 +265,13 @@ func resolveCommand() {
 			os.Exit(0)
 		}
 
+		var totalOperationSize uint64 = 0
 		for _, pkg := range pkgsToInstall.Keys() {
 			value, _ := pkgsToInstall.Get(pkg)
-			pkgInfo := value.pkgInfo
+			bpmpkg := value.bpmpkg
-			installedInfo := utils.GetPackageInfo(pkgInfo.Name, rootDir, false)
+			installedInfo := utils.GetPackageInfo(bpmpkg.PkgInfo.Name, rootDir, false)
 			sourceInfo := ""
-			if pkgInfo.Type == "source" {
+			if bpmpkg.PkgInfo.Type == "source" {
 				if rootDir != "/" && !force {
 					log.Fatalf("Error: cannot compile and install source packages to a different root directory")
 				}
@@ -272,21 +279,29 @@ func resolveCommand() {
 			}
 
 			if installedInfo == nil {
-				fmt.Printf("%s: %s (Install) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo)
+				fmt.Printf("%s: %s (Install) %s\n", bpmpkg.PkgInfo.Name, bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
+				totalOperationSize += bpmpkg.GetInstalledSize()
 			} else {
-				comparison := utils.ComparePackageVersions(*pkgInfo, *installedInfo)
+				comparison := utils.ComparePackageVersions(*bpmpkg.PkgInfo, *installedInfo)
 				if comparison < 0 {
-					fmt.Printf("%s: %s -> %s (Downgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo)
+					fmt.Printf("%s: %s -> %s (Downgrade) %s\n", bpmpkg.PkgInfo.Name, installedInfo.GetFullVersion(), bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
 				} else if comparison > 0 {
-					fmt.Printf("%s: %s -> %s (Upgrade) %s\n", pkgInfo.Name, installedInfo.GetFullVersion(), pkgInfo.GetFullVersion(), sourceInfo)
+					fmt.Printf("%s: %s -> %s (Upgrade) %s\n", bpmpkg.PkgInfo.Name, installedInfo.GetFullVersion(), bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
 				} else {
-					fmt.Printf("%s: %s (Reinstall) %s\n", pkgInfo.Name, pkgInfo.GetFullVersion(), sourceInfo)
+					fmt.Printf("%s: %s (Reinstall) %s\n", bpmpkg.PkgInfo.Name, bpmpkg.PkgInfo.GetFullVersion(), sourceInfo)
 				}
+				totalOperationSize += bpmpkg.GetInstalledSize()
 			}
 		}
 		if rootDir != "/" {
 			fmt.Println("Warning: Operating in " + rootDir)
 		}
+		if totalOperationSize >= 0 {
+			fmt.Printf("A total of %s will be used to complete this operation\n", utils.BytesToHumanReadable(totalOperationSize))
+		} else {
+			fmt.Printf("A total of %s will be freed by this operation\n", utils.BytesToHumanReadable(totalOperationSize))
+		}
+
 		if !yesAll {
 			reader := bufio.NewReader(os.Stdin)
 			if pkgsToInstall.Len() == 1 {
@@ -317,7 +332,7 @@ func resolveCommand() {
 			if err != nil {
 				log.Fatalf("Error: could not fetch package (%s): %s\n", pkg, err)
 			}
-			fmt.Printf("Package (%s) was successfully fetched!\n", value.pkgInfo.Name)
+			fmt.Printf("Package (%s) was successfully fetched!\n", value.bpmpkg.PkgInfo.Name)
 			value.bpmFile = fetchedPackage
 			pkgsToInstall.Set(pkg, value)
 		}
@@ -325,7 +340,7 @@ func resolveCommand() {
 		// Install fetched packages
 		for _, pkg := range pkgsToInstall.Keys() {
 			value, _ := pkgsToInstall.Get(pkg)
-			pkgInfo := value.pkgInfo
+			bpmpkg := value.bpmpkg
 			var err error
 			if value.isDependency {
 				err = utils.InstallPackage(value.bpmFile, rootDir, verbose, true, buildSource, skipCheck, keepTempDir)
@@ -334,19 +349,19 @@ func resolveCommand() {
 			}
 
 			if err != nil {
-				if pkgInfo.Type == "source" && keepTempDir {
+				if bpmpkg.PkgInfo.Type == "source" && keepTempDir {
-					fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + pkgInfo.Name)
+					fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + bpmpkg.PkgInfo.Name)
 				}
 				log.Fatalf("Error: could not install package (%s): %s\n", pkg, err)
 			}
-			fmt.Printf("Package (%s) was successfully installed\n", pkgInfo.Name)
+			fmt.Printf("Package (%s) was successfully installed\n", bpmpkg.PkgInfo.Name)
 			if value.isDependency {
-				err := utils.SetInstallationReason(pkgInfo.Name, utils.Dependency, rootDir)
+				err := utils.SetInstallationReason(bpmpkg.PkgInfo.Name, utils.Dependency, rootDir)
 				if err != nil {
 					log.Fatalf("Error: could not set installation reason for package: %s\n", err)
 				}
 			}
-			if pkgInfo.Type == "source" && keepTempDir {
+			if bpmpkg.PkgInfo.Type == "source" && keepTempDir {
 				fmt.Println("** It is recommended you delete the temporary bpm folder in /var/tmp **")
 			}
 		}

utils/extract_utils.go

@@ -0,0 +1,40 @@
+package utils
+
+import (
+	"archive/tar"
+	"errors"
+	"io"
+	"os"
+)
+
+func ReadTarballContent(tarballPath, fileToExtract string) ([]byte, error) {
+	file, err := os.Open(tarballPath)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	tr := tar.NewReader(file)
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+		if header.Name == fileToExtract {
+			if header.Typeflag != tar.TypeReg {
+				return nil, errors.New("file to extract must be a regular file")
+			}
+
+			bytes, err := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			return bytes, nil
+		}
+	}
+
+	return nil, errors.New("could not file in tarball")
+}

utils/general_utils.go

@@ -1,7 +1,9 @@
 package utils
 
 import (
+	"fmt"
 	"io"
+	"math"
 	"os"
 	"os/exec"
 	"strings"
@@ -56,3 +58,14 @@ func stringSliceRemoveEmpty(s []string) []string {
 	}
 	return r
 }
+
+func BytesToHumanReadable(b uint64) string {
+	bf := float64(b)
+	for _, unit := range []string{"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"} {
+		if math.Abs(bf) < 1024.0 {
+			return fmt.Sprintf("%3.1f%sB", bf, unit)
+		}
+		bf /= 1024.0
+	}
+	return fmt.Sprintf("%.1fYiB", bf)
+}

utils/package_utils.go

@@ -3,6 +3,7 @@ package utils
 import (
 	"archive/tar"
 	"bufio"
+	"bytes"
 	"compress/gzip"
 	"errors"
 	"fmt"
@@ -20,6 +21,11 @@ import (
 	"syscall"
 )
 
+type BPMPackage struct {
+	PkgInfo  *PackageInfo
+	PkgFiles []*PackageFileEntry
+}
+
 type PackageInfo struct {
 	Name            string   `yaml:"name,omitempty"`
 	Description     string   `yaml:"description,omitempty"`
@@ -37,6 +43,29 @@ type PackageInfo struct {
 	Provides        []string `yaml:"provides,omitempty"`
 }
 
+type PackageFileEntry struct {
+	Path        string
+	UserID      int
+	GroupID     int
+	SizeInBytes uint64
+}
+
+func (pkg *BPMPackage) GetInstalledSize() uint64 {
+	var totalSize uint64 = 0
+	for _, entry := range pkg.PkgFiles {
+		totalSize += entry.SizeInBytes
+	}
+	return totalSize
+}
+
+func (pkg *BPMPackage) ConvertFilesToString() string {
+	str := ""
+	for _, file := range pkg.PkgFiles {
+		str += fmt.Sprintf("%s %d %d %d\n", file.Path, file.UserID, file.GroupID, file.SizeInBytes)
+	}
+	return str
+}
+
 func (pkgInfo *PackageInfo) GetFullVersion() string {
 	return pkgInfo.Version + "-" + strconv.Itoa(pkgInfo.Revision)
 }
@@ -93,11 +122,8 @@ func GetPackageInfoRaw(filename string) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	archive, err := gzip.NewReader(file)
+
-	if err != nil {
+	tr := tar.NewReader(file)
-		return "", err
-	}
-	tr := tar.NewReader(archive)
 	for {
 		header, err := tr.Next()
 		if err == io.EOF {
@@ -118,19 +144,21 @@ func GetPackageInfoRaw(filename string) (string, error) {
 	return "", errors.New("pkg.info not found in archive")
 }
 
-func ReadPackage(filename string) (*PackageInfo, error) {
+func ReadPackage(filename string) (*BPMPackage, error) {
+	var pkgInfo *PackageInfo
+	var pkgFiles []*PackageFileEntry
+
 	if _, err := os.Stat(filename); os.IsNotExist(err) {
 		return nil, err
 	}
+
 	file, err := os.Open(filename)
+	defer file.Close()
 	if err != nil {
 		return nil, err
 	}
-	archive, err := gzip.NewReader(file)
+
-	if err != nil {
+	tr := tar.NewReader(file)
-		return nil, err
-	}
-	tr := tar.NewReader(archive)
 	for {
 		header, err := tr.Next()
 		if err == io.EOF {
@@ -141,18 +169,49 @@ func ReadPackage(filename string) (*PackageInfo, error) {
 		}
 		if header.Name == "pkg.info" {
 			bs, _ := io.ReadAll(tr)
-			err := file.Close()
+			pkgInfo, err = ReadPackageInfo(string(bs))
 			if err != nil {
 				return nil, err
 			}
-			pkgInfo, err := ReadPackageInfo(string(bs))
+		} else if header.Name == "pkg.files" {
-			if err != nil {
+			bs, _ := io.ReadAll(tr)
-				return nil, err
+			for _, line := range strings.Split(string(bs), "\n") {
+				if strings.TrimSpace(line) == "" {
+					continue
+				}
+				stringEntry := strings.Split(strings.TrimSpace(line), " ")
+				if len(stringEntry) != 4 {
+					return nil, errors.New("pkg.files is not formatted correctly")
+				}
+				uid, err := strconv.ParseInt(stringEntry[1], 0, 32)
+				if err != nil {
+					return nil, err
+				}
+				gid, err := strconv.ParseInt(stringEntry[2], 0, 32)
+				if err != nil {
+					return nil, err
+				}
+				size, err := strconv.ParseUint(stringEntry[3], 0, 64)
+				if err != nil {
+					return nil, err
+				}
+				pkgFiles = append(pkgFiles, &PackageFileEntry{
+					Path:        stringEntry[0],
+					UserID:      int(uid),
+					GroupID:     int(gid),
+					SizeInBytes: size,
+				})
 			}
-			return pkgInfo, nil
 		}
 	}
-	return nil, errors.New("pkg.info not found in archive")
+
+	if pkgInfo == nil {
+		return nil, errors.New("pkg.info not found in archive")
+	}
+	return &BPMPackage{
+		PkgInfo:  pkgInfo,
+		PkgFiles: pkgFiles,
+	}, nil
 }
 
 func ReadPackageScripts(filename string) (map[string]string, error) {
@@ -163,11 +222,8 @@ func ReadPackageScripts(filename string) (map[string]string, error) {
 	if err != nil {
 		return nil, err
 	}
-	archive, err := gzip.NewReader(file)
+
-	if err != nil {
+	tr := tar.NewReader(file)
-		return nil, err
-	}
-	tr := tar.NewReader(archive)
 	ret := make(map[string]string)
 	for {
 		header, err := tr.Next()
@@ -209,10 +265,7 @@ func ReadPackageScripts(filename string) (map[string]string, error) {
 			ret[header.Name] = string(bs)
 		}
 	}
-	err = archive.Close()
+
-	if err != nil {
-		return nil, err
-	}
 	err = file.Close()
 	if err != nil {
 		return nil, err
@@ -257,25 +310,25 @@ func ExecutePackageScripts(filename, rootDir string, operation Operation, postOp
 		cmd.Dir = rootDir
 		cmd.Env = os.Environ()
 		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", rootDir))
-		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.PkgInfo.Name))
-		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.PkgInfo.Description))
-		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.PkgInfo.Version))
 		if operation != Install {
-			cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_VERSION=%s", GetPackageInfo(pkgInfo.Name, rootDir, true).Version))
+			cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_VERSION=%s", GetPackageInfo(pkgInfo.PkgInfo.Name, rootDir, true).Version))
 		}
-		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", pkgInfo.Revision))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", pkgInfo.PkgInfo.Revision))
 		if operation != Install {
-			cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_REVISION=%d", GetPackageInfo(pkgInfo.Name, rootDir, true).Revision))
+			cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_OLD_REVISION=%d", GetPackageInfo(pkgInfo.PkgInfo.Name, rootDir, true).Revision))
 		}
-		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.PkgInfo.Url))
-		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.PkgInfo.Arch))
-		depends := make([]string, len(pkgInfo.Depends))
+		depends := make([]string, len(pkgInfo.PkgInfo.Depends))
-		copy(depends, pkgInfo.Depends)
+		copy(depends, pkgInfo.PkgInfo.Depends)
 		for i := 0; i < len(depends); i++ {
 			depends[i] = fmt.Sprintf("\"%s\"", depends[i])
 		}
-		makeDepends := make([]string, len(pkgInfo.MakeDepends))
+		makeDepends := make([]string, len(pkgInfo.PkgInfo.MakeDepends))
-		copy(makeDepends, pkgInfo.MakeDepends)
+		copy(makeDepends, pkgInfo.PkgInfo.MakeDepends)
 		for i := 0; i < len(makeDepends); i++ {
 			makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
 		}
@@ -411,9 +464,9 @@ func CreateReadableInfo(showArchitecture, showType, showPackageRelations bool, p
 	return strings.Join(ret, "\n")
 }
 
-func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string) (error, []string) {
+func extractPackage(bpmpkg *BPMPackage, verbose bool, filename, rootDir string) (error, []string) {
 	var files []string
-	if !IsPackageInstalled(pkgInfo.Name, rootDir) {
+	if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
 		err := ExecutePackageScripts(filename, rootDir, Install, false)
 		if err != nil {
 			return err, nil
@@ -429,7 +482,13 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
 	if err != nil {
 		return err, nil
 	}
-	archive, err := gzip.NewReader(file)
+
+	content, err := ReadTarballContent(filename, "files.tar.gz")
+	if err != nil {
+		return err, nil
+	}
+
+	archive, err := gzip.NewReader(bytes.NewReader(content))
 	if err != nil {
 		return err, nil
 	}
@@ -442,97 +501,95 @@ func extractPackage(pkgInfo *PackageInfo, verbose bool, filename, rootDir string
 		if err != nil {
 			return err, nil
 		}
-		if strings.HasPrefix(header.Name, "files/") && header.Name != "files/" {
+		trimmedName := strings.TrimPrefix(header.Name, "./")
-			trimmedName := strings.TrimPrefix(header.Name, "files/")
+		extractFilename := path.Join(rootDir, trimmedName)
-			extractFilename := path.Join(rootDir, trimmedName)
+		switch header.Typeflag {
-			switch header.Typeflag {
+		case tar.TypeDir:
-			case tar.TypeDir:
+			files = append(files, strings.TrimPrefix(header.Name, "./"))
-				files = append(files, strings.TrimPrefix(header.Name, "files/"))
+			if err := os.Mkdir(extractFilename, 0755); err != nil {
-				if err := os.Mkdir(extractFilename, 0755); err != nil {
+				if !os.IsExist(err) {
-					if !os.IsExist(err) {
+					return err, nil
-						return err, nil
-					}
-				} else {
-					if verbose {
-						fmt.Println("Creating Directory: " + extractFilename)
-					}
 				}
-			case tar.TypeReg:
+			} else {
-				skip := false
+				if verbose {
-				if _, err := os.Stat(extractFilename); err == nil {
+					fmt.Println("Creating Directory: " + extractFilename)
-					for _, k := range pkgInfo.Keep {
+				}
-						if strings.HasSuffix(k, "/") {
+			}
-							if strings.HasPrefix(trimmedName, k) {
+		case tar.TypeReg:
-								if verbose {
+			skip := false
-									fmt.Println("Skipping File: " + extractFilename + " (Containing directory is set to be kept during installs/updates)")
+			if _, err := os.Stat(extractFilename); err == nil {
-								}
+				for _, k := range bpmpkg.PkgInfo.Keep {
-								files = append(files, strings.TrimPrefix(header.Name, "files/"))
+					if strings.HasSuffix(k, "/") {
-								skip = true
+						if strings.HasPrefix(trimmedName, k) {
-								continue
+							if verbose {
+								fmt.Println("Skipping File: " + extractFilename + " (Containing directory is set to be kept during installs/updates)")
 							}
-						} else {
+							files = append(files, strings.TrimPrefix(header.Name, "./"))
-							if trimmedName == k {
+							skip = true
-								if verbose {
+							continue
-									fmt.Println("Skipping File: " + extractFilename + " (File is configured to be kept during installs/updates)")
+						}
-								}
+					} else {
-								files = append(files, strings.TrimPrefix(header.Name, "files/"))
+						if trimmedName == k {
-								skip = true
+							if verbose {
-								continue
+								fmt.Println("Skipping File: " + extractFilename + " (File is configured to be kept during installs/updates)")
 							}
+							files = append(files, strings.TrimPrefix(header.Name, "./"))
+							skip = true
+							continue
 						}
 					}
 				}
-				if skip {
-					continue
-				}
-				err := os.Remove(extractFilename)
-				if err != nil && !os.IsNotExist(err) {
-					return err, nil
-				}
-				outFile, err := os.Create(extractFilename)
-				if verbose {
-					fmt.Println("Creating File: " + extractFilename)
-				}
-				files = append(files, strings.TrimPrefix(header.Name, "files/"))
-				if err != nil {
-					return err, nil
-				}
-				if _, err := io.Copy(outFile, tr); err != nil {
-					return err, nil
-				}
-				if err := os.Chmod(extractFilename, header.FileInfo().Mode()); err != nil {
-					return err, nil
-				}
-				err = outFile.Close()
-				if err != nil {
-					return err, nil
-				}
-			case tar.TypeSymlink:
-				if verbose {
-					fmt.Println("Creating Symlink: " + extractFilename + " -> " + header.Linkname)
-				}
-				files = append(files, strings.TrimPrefix(header.Name, "files/"))
-				err := os.Remove(extractFilename)
-				if err != nil && !os.IsNotExist(err) {
-					return err, nil
-				}
-				err = os.Symlink(header.Linkname, extractFilename)
-				if err != nil {
-					return err, nil
-				}
-			case tar.TypeLink:
-				if verbose {
-					fmt.Println("Detected Hard Link: " + extractFilename + " -> " + path.Join(rootDir, strings.TrimPrefix(header.Linkname, "files/")))
-				}
-				files = append(files, strings.TrimPrefix(header.Name, "files/"))
-				seenHardlinks[extractFilename] = path.Join(strings.TrimPrefix(header.Linkname, "files/"))
-				err := os.Remove(extractFilename)
-				if err != nil && !os.IsNotExist(err) {
-					return err, nil
-				}
-			default:
-				return errors.New("unknown type (" + strconv.Itoa(int(header.Typeflag)) + ") in " + extractFilename), nil
 			}
+			if skip {
+				continue
+			}
+			err := os.Remove(extractFilename)
+			if err != nil && !os.IsNotExist(err) {
+				return err, nil
+			}
+			outFile, err := os.Create(extractFilename)
+			if verbose {
+				fmt.Println("Creating File: " + extractFilename)
+			}
+			files = append(files, strings.TrimPrefix(header.Name, "./"))
+			if err != nil {
+				return err, nil
+			}
+			if _, err := io.Copy(outFile, tr); err != nil {
+				return err, nil
+			}
+			if err := os.Chmod(extractFilename, header.FileInfo().Mode()); err != nil {
+				return err, nil
+			}
+			err = outFile.Close()
+			if err != nil {
+				return err, nil
+			}
+		case tar.TypeSymlink:
+			if verbose {
+				fmt.Println("Creating Symlink: " + extractFilename + " -> " + header.Linkname)
+			}
+			files = append(files, strings.TrimPrefix(header.Name, "./"))
+			err := os.Remove(extractFilename)
+			if err != nil && !os.IsNotExist(err) {
+				return err, nil
+			}
+			err = os.Symlink(header.Linkname, extractFilename)
+			if err != nil {
+				return err, nil
+			}
+		case tar.TypeLink:
+			if verbose {
+				fmt.Println("Detected Hard Link: " + extractFilename + " -> " + path.Join(rootDir, strings.TrimPrefix(header.Linkname, "files/")))
+			}
+			files = append(files, strings.TrimPrefix(header.Name, "./"))
+			seenHardlinks[extractFilename] = path.Join(strings.TrimPrefix(header.Linkname, "files/"))
+			err := os.Remove(extractFilename)
+			if err != nil && !os.IsNotExist(err) {
+				return err, nil
+			}
+		default:
+			return errors.New("unknown type (" + strconv.Itoa(int(header.Typeflag)) + ") in " + extractFilename), nil
 		}
 	}
 	for extractFilename, destination := range seenHardlinks {
@@ -554,7 +611,7 @@ func isSplitPackage(filename string) bool {
 	if err != nil {
 		return false
 	}
-	if pkgInfo.Type != "source" {
+	if pkgInfo.PkgInfo.Type != "source" {
 		return false
 	}
 	cmd := exec.Command("/bin/bash", "-c", fmt.Sprintf("test $(tar -tf %s | grep '^pkg.info' | wc -l) -eq 1", filename))
@@ -564,9 +621,9 @@ func isSplitPackage(filename string) bool {
 	return true
 }
 
-func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, binaryPkgFromSrc, skipCheck, keepTempDir bool) (error, []string) {
+func compilePackage(bpmpkg *BPMPackage, filename, rootDir string, verbose, binaryPkgFromSrc, skipCheck, keepTempDir bool) (error, []string) {
 	var files []string
-	if !IsPackageInstalled(pkgInfo.Name, rootDir) {
+	if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
 		err := ExecutePackageScripts(filename, rootDir, Install, false)
 		if err != nil {
 			return err, nil
@@ -582,13 +639,10 @@ func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, bin
 	if err != nil {
 		return err, nil
 	}
-	archive, err := gzip.NewReader(file)
-	if err != nil {
-		return err, nil
-	}
-	tr := tar.NewReader(archive)
 
-	temp := path.Join(BPMConfig.CompilationDir, "bpm_source-"+pkgInfo.Name)
+	tr := tar.NewReader(file)
+
+	temp := path.Join(BPMConfig.CompilationDir, "bpm_source-"+bpmpkg.PkgInfo.Name)
 	err = os.RemoveAll(temp)
 	if err != nil {
 		return err, nil
@@ -690,7 +744,7 @@ func compilePackage(pkgInfo *PackageInfo, filename, rootDir string, verbose, bin
 		return err, nil
 	}
 	fmt.Println("Running source.sh file...")
-	if !IsPackageInstalled(pkgInfo.Name, rootDir) {
+	if !IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir) {
 		err = ExecutePackageScripts(filename, rootDir, Install, false)
 		if err != nil {
 			return err, nil
@@ -800,19 +854,19 @@ fi
 	cmd.Env = append(cmd.Env, "SKIPCHECK="+strconv.FormatBool(skipCheck))
 
 	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", rootDir))
-	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", bpmpkg.PkgInfo.Name))
-	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", bpmpkg.PkgInfo.Description))
-	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", bpmpkg.PkgInfo.Version))
-	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", pkgInfo.Revision))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_REVISION=%d", bpmpkg.PkgInfo.Revision))
-	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", bpmpkg.PkgInfo.Url))
-	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", pkgInfo.Arch))
+	cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_ARCH=%s", bpmpkg.PkgInfo.Arch))
-	depends := make([]string, len(pkgInfo.Depends))
+	depends := make([]string, len(bpmpkg.PkgInfo.Depends))
-	copy(depends, pkgInfo.Depends)
+	copy(depends, bpmpkg.PkgInfo.Depends)
 	for i := 0; i < len(depends); i++ {
 		depends[i] = fmt.Sprintf("\"%s\"", depends[i])
 	}
-	makeDepends := make([]string, len(pkgInfo.MakeDepends))
+	makeDepends := make([]string, len(bpmpkg.PkgInfo.MakeDepends))
-	copy(makeDepends, pkgInfo.MakeDepends)
+	copy(makeDepends, bpmpkg.PkgInfo.MakeDepends)
 	for i := 0; i < len(makeDepends); i++ {
 		makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
 	}
@@ -864,7 +918,7 @@ fi
 			}
 		} else if d.Type().IsRegular() {
 			if _, err := os.Stat(extractFilename); err == nil {
-				if slices.Contains(pkgInfo.Keep, relFilename) {
+				if slices.Contains(bpmpkg.PkgInfo.Keep, relFilename) {
 					if verbose {
 						fmt.Println("Skipping File: " + extractFilename + "(File is configured to be kept during installs/updates)")
 					}
@@ -933,7 +987,7 @@ fi
 		compiledDir := path.Join(BPMConfig.BinaryOutputDir)
 		err = os.MkdirAll(compiledDir, 0755)
 		compiledInfo := PackageInfo{}
-		compiledInfo = *pkgInfo
+		compiledInfo = *bpmpkg.PkgInfo
 		compiledInfo.Type = "binary"
 		compiledInfo.Arch = GetArch()
 		err = os.WriteFile(path.Join(temp, "pkg.info"), []byte(CreateInfoFile(&compiledInfo)), 0644)
@@ -991,7 +1045,6 @@ fi
 		return errors.New("no output files for source package. Cancelling package installation"), nil
 	}
 
-	defer archive.Close()
 	defer file.Close()
 	return nil, files
 }
@@ -1002,39 +1055,39 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc,
 	}
 	var oldFiles []string
 	var files []string
-	pkgInfo, err := ReadPackage(filename)
+	bpmpkg, err := ReadPackage(filename)
 	if err != nil {
 		return err
 	}
-	packageInstalled := IsPackageInstalled(pkgInfo.Name, rootDir)
+	packageInstalled := IsPackageInstalled(bpmpkg.PkgInfo.Name, rootDir)
 	if packageInstalled {
-		oldFiles = GetPackageFiles(pkgInfo.Name, rootDir)
+		oldFiles = GetPackageFiles(bpmpkg.PkgInfo.Name, rootDir)
 	}
 	if !force {
-		if pkgInfo.Arch != "any" && pkgInfo.Arch != GetArch() {
+		if bpmpkg.PkgInfo.Arch != "any" && bpmpkg.PkgInfo.Arch != GetArch() {
 			return errors.New("cannot install a package with a different architecture")
 		}
-		if unresolved := pkgInfo.CheckDependencies(pkgInfo.Type == "source", true, rootDir); len(unresolved) != 0 {
+		if unresolved := bpmpkg.PkgInfo.CheckDependencies(bpmpkg.PkgInfo.Type == "source", true, rootDir); len(unresolved) != 0 {
 			return errors.New("the following dependencies are not installed: " + strings.Join(unresolved, ", "))
 		}
 	}
-	if pkgInfo.Type == "binary" {
+	if bpmpkg.PkgInfo.Type == "binary" {
-		err, i := extractPackage(pkgInfo, verbose, filename, rootDir)
+		err, i := extractPackage(bpmpkg, verbose, filename, rootDir)
 		if err != nil {
 			return err
 		}
 		files = i
-	} else if pkgInfo.Type == "source" {
+	} else if bpmpkg.PkgInfo.Type == "source" {
 		if isSplitPackage(filename) {
 			return errors.New("BPM is unable to install split source packages")
 		}
-		err, i := compilePackage(pkgInfo, filename, rootDir, verbose, binaryPkgFromSrc, skipCheck, keepTempDir)
+		err, i := compilePackage(bpmpkg, filename, rootDir, verbose, binaryPkgFromSrc, skipCheck, keepTempDir)
 		if err != nil {
 			return err
 		}
 		files = i
 	} else {
-		return errors.New("unknown package type: " + pkgInfo.Type)
+		return errors.New("unknown package type: " + bpmpkg.PkgInfo.Type)
 	}
 	slices.Sort(files)
 	slices.Reverse(files)
@@ -1048,7 +1101,7 @@ func InstallPackage(filename, rootDir string, verbose, force, binaryPkgFromSrc,
 	if err != nil {
 		return err
 	}
-	pkgDir := path.Join(installedDir, pkgInfo.Name)
+	pkgDir := path.Join(installedDir, bpmpkg.PkgInfo.Name)
 	err = os.RemoveAll(pkgDir)
 	if err != nil {
 		return err
@@ -1201,25 +1254,22 @@ func GetSourceScript(filename string) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	if pkgInfo.Type != "source" {
+	if pkgInfo.PkgInfo.Type != "source" {
 		return "", errors.New("package not of source type")
 	}
 	file, err := os.Open(filename)
 	if err != nil {
 		return "", err
 	}
-	archive, err := gzip.NewReader(file)
+
-	if err != nil {
+	tr := tar.NewReader(file)
-		return "", err
-	}
-	tr := tar.NewReader(archive)
 	for {
 		header, err := tr.Next()
 		if err == io.EOF {
 			break
 		}
 		if header.Name == "source.sh" {
-			err := archive.Close()
+			err := file.Close()
 			if err != nil {
 				return "", err
 			}