Added environment variables that can be used during source package compilation to fetch package info (i.e $BPM_PKG_NAME or $BPM_PKG_VERSION)

Packages created using the -b flag will now contain the version number in their filename
Source install scripts will now exit if any error is encountered
Obsolete files should now be removed properly

README.md

@@ -77,7 +77,7 @@ mkdir files
 5) Either copy the bpm-create script from the bpm-utils test package into your /usr/local/bin directory or install the bpm-utils.bpm package
 6) Run the following
 ```
-bpm-create <filename_without_extension>
+bpm-create <filename.bpm>
 ```
 7) It's done! You now hopefully have a working BPM package!
 ### Source Packages
@@ -85,10 +85,11 @@ bpm-create <filename_without_extension>
 ```
 touch source.sh
 ```
-4) You are able to run bash code in this file. BPM will extract this file in a directory under /tmp and it will be ran there
+4) If you would like to bundle patches or other files with your source package create a 'source-files' directory and place your files in there. They will be extracted to the same location as the source.sh file during compilation
-5) Your goal is to download your program's source code with either git, wget, curl, etc. and put the binaries under a folder called 'output' in the root of the temp directory. There is a simple example script with helpful comments in the htop-src test package
+5) You are able to run bash code in source.sh. BPM will extract this file in a directory under /tmp and it will be run there
-6) As of this moment there is no script to automate package compression like for binary packages. You will need to create the archive manually
+6) Your goal is to download your program's source code with either git, wget, curl, etc. and put the binaries under a folder called 'output' in the root of the temp directory. There is a simple example script with helpful comments in the htop-src test package
+7) When you are done making your source.sh script run the following to create a package archive
 ```
-tar -czvf my_package-src.bpm pkg.info source.sh
+bpm-create <filename.bpm>
 ```
-7) That's it! Your source package should now be compiling correctly!
+8) That's it! Your source package should now be compiling correctly!

bpm_utils/package_utils.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"io"
 	"io/fs"
-	"log"
 	"os"
 	"os/exec"
 	"path"
@@ -304,19 +303,6 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			}
 		}
 	} else if pkgInfo.Type == "source" {
-		for {
-			header, err := tr.Next()
-			if err == io.EOF {
-				break
-			}
-			if err != nil {
-				return err
-			}
-			if header.Name == "source.sh" {
-				bs, err := io.ReadAll(tr)
-				if err != nil {
-					return err
-				}
 		temp := "/var/tmp/bpm_source-" + pkgInfo.Name
 		err = os.RemoveAll(temp)
 		if err != nil {
@@ -327,16 +313,97 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 		if err != nil {
 			return err
 		}
+		for {
+			header, err := tr.Next()
+			if err == io.EOF {
+				break
+			}
+			if err != nil {
+				return err
+			}
+			if strings.HasPrefix(header.Name, "source-files/") && header.Name != "source-files/" {
+				extractFilename := path.Join(temp, strings.TrimPrefix(header.Name, "source-files/"))
+				switch header.Typeflag {
+				case tar.TypeDir:
+					if err := os.Mkdir(extractFilename, 0755); err != nil {
+						if !os.IsExist(err) {
+							return err
+						}
+					} else {
+						fmt.Println("Creating Directory: " + extractFilename)
+					}
+				case tar.TypeReg:
+					err := os.Remove(extractFilename)
+					if err != nil && !os.IsNotExist(err) {
+						return err
+					}
+					outFile, err := os.Create(extractFilename)
+					fmt.Println("Creating File: " + extractFilename)
+					if err != nil {
+						return err
+					}
+					if _, err := io.Copy(outFile, tr); err != nil {
+						return err
+					}
+					if err := os.Chmod(extractFilename, header.FileInfo().Mode()); err != nil {
+						return err
+					}
+					err = outFile.Close()
+					if err != nil {
+						return err
+					}
+				case tar.TypeSymlink:
+					fmt.Println("Skipping symlink (Bundling symlinks in source packages is not supported)")
+				case tar.TypeLink:
+					fmt.Println("Skipping hard link (Bundling hard links in source packages is not supported)")
+				default:
+					return errors.New("ExtractTarGz: unknown type: " + strconv.Itoa(int(header.Typeflag)) + " in " + extractFilename)
+				}
+			}
+			if header.Name == "source.sh" {
+				bs, err := io.ReadAll(tr)
+				if err != nil {
+					return err
+				}
 				err = os.WriteFile(path.Join(temp, "source.sh"), bs, 0644)
 				if err != nil {
 					return err
 				}
+			}
+		}
+		if _, err := os.Stat(path.Join(temp, "source.sh")); os.IsNotExist(err) {
+			return errors.New("source.sh file could not be found in the temporary build directory")
+		}
+		if err != nil {
+			return err
+		}
 		fmt.Println("Running source.sh file...")
-				cmd := exec.Command("/usr/bin/sh", "source.sh")
+		if err != nil {
+			return err
+		}
+		cmd := exec.Command("/bin/bash", "-e", "source.sh")
 		cmd.Stdin = os.Stdin
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 		cmd.Dir = temp
+		cmd.Env = os.Environ()
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_NAME=%s", pkgInfo.Name))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DESC=%s", pkgInfo.Description))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_VERSION=%s", pkgInfo.Version))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_URL=%s", pkgInfo.Url))
+		depends := make([]string, len(pkgInfo.Depends))
+		copy(depends, pkgInfo.Depends)
+		for i := 0; i < len(depends); i++ {
+			depends[i] = fmt.Sprintf("\"%s\"", depends[i])
+		}
+		makeDepends := make([]string, len(pkgInfo.MakeDepends))
+		copy(makeDepends, pkgInfo.MakeDepends)
+		for i := 0; i < len(makeDepends); i++ {
+			makeDepends[i] = fmt.Sprintf("\"%s\"", makeDepends[i])
+		}
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_DEPENDS=(%s)", strings.Join(depends, " ")))
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_PKG_MAKE_DEPENDS=(%s)", strings.Join(makeDepends, " ")))
+		cmd.Env = append(cmd.Env, "BPM_PKG_TYPE=source")
 		err = cmd.Run()
 		if err != nil {
 			return err
@@ -432,7 +499,7 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 				return err
 			}
 			sed := fmt.Sprintf("s/%s/files/", strings.Replace(strings.TrimPrefix(path.Join(temp, "/output/"), "/"), "/", `\/`, -1))
-					cmd := exec.Command("/usr/bin/tar", "-czvf", compiledInfo.Name+".bpm", "pkg.info", path.Join(temp, "/output/"), "--transform", sed)
+			cmd := exec.Command("/usr/bin/tar", "-czvf", compiledInfo.Name+"-"+compiledInfo.Version+".bpm", "pkg.info", path.Join(temp, "/output/"), "--transform", sed)
 			cmd.Stdin = os.Stdin
 			cmd.Stdout = os.Stdout
 			cmd.Stderr = os.Stderr
@@ -453,7 +520,8 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 				return err
 			}
 		}
-			}
+		if len(files) == 0 {
+			return errors.New("no output files for source package. Cancelling package installation")
 		}
 	} else {
 		return errors.New("Unknown package type: " + pkgInfo.Type)
@@ -523,7 +591,11 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 	if len(filesDiff) != 0 {
 		fmt.Println("Removing obsolete files")
 		for _, f := range filesDiff {
-			fmt.Println("Removing: " + path.Join(installedDir, f))
+			err := os.RemoveAll(path.Join(installDir, f))
+			if err != nil {
+				return err
+			}
+			fmt.Println("Removing: " + path.Join(installDir, f))
 		}
 	}
 	return nil
@@ -780,44 +852,3 @@ func RemovePackage(pkg, rootDir string) error {
 	fmt.Println("Removing: " + pkgDir)
 	return nil
 }
-
-func FixInstalledPackages(rootDir string) (map[string]error, int) {
-	var errs map[string]error
-	totalFixed := 0
-	pkgs, err := GetInstalledPackages(rootDir)
-	if err != nil {
-		log.Fatalf("Could not check if installed package info files are formatted correctly\nError: %s", err.Error())
-	}
-	for _, pkg := range pkgs {
-		fixed := false
-		pkgInfo := GetPackageInfo(pkg, "/", true)
-		if pkgInfo.Name == "" {
-			errs[pkg] = errors.New("this package contains no name")
-			continue
-		}
-		if pkgInfo.Description == "" {
-			pkgInfo.Description = "Default Description"
-			fixed = true
-		}
-		if pkgInfo.Version == "" {
-			errs[pkg] = errors.New("this package contains no version")
-			continue
-		}
-		if pkgInfo.Arch == "" {
-			pkgInfo.Arch = GetArch()
-			fixed = true
-		}
-		if pkgInfo.Type == "" {
-			errs[pkg] = errors.New("this package contains no type")
-			continue
-		}
-		if fixed {
-			totalFixed++
-		}
-		err := setPackageInfo(pkg, CreateInfoFile(*pkgInfo), rootDir)
-		if err != nil {
-			log.Fatalf("Could not check if installed package info files are formatted correctly\nError: %s", err.Error())
-		}
-	}
-	return errs, totalFixed
-}

main.go

@@ -3,10 +3,10 @@ package main
 import (
 	"bufio"
 	"capcreepergr.me/bpm/bpm_utils"
+	"flag"
 	"fmt"
 	"log"
 	"os"
-	"slices"
 	"strings"
 )
 
@@ -15,29 +15,25 @@ import (
 /*   A simple-to-use package manager  */
 /* ---------------------------------- */
 
-var bpmVer = "0.1.0"
+var bpmVer = "0.1.3"
+
+var subcommand = "help"
+var subcommandArgs []string
+
+// Flags
 var rootDir = "/"
+var yesAll = false
+var buildSource = false
+var keepTempDir = false
+var forceInstall = false
+var pkgListNumbers = false
+var pkgListNames = false
 
 func main() {
-	/*errs, fixed := bpm_utils.FixInstalledPackages(rootDir)
+	resolveFlags()
-	if len(errs) != 0 {
-		for pkg, err := range errs {
-			fmt.Printf("Package (%s) could not be read properly\nError: %s\n", pkg, err.Error())
-		}
-		fmt.Println("The aforementioned packages require manual fixing. Make sure their info files are valid in " + path.Join(rootDir, "var/lib/bpm/installed"))
-		os.Exit(1)
-	} else {
-		if fixed != 0 {
-			fmt.Println("Fixed " + strconv.Itoa(fixed) + " outdated package info files")
-		}
-	}*/
 	resolveCommand()
 }
 
-func getArgs() []string {
-	return os.Args[1:]
-}
-
 type commandType uint8
 
 const (
@@ -47,15 +43,10 @@ const (
 	list
 	install
 	remove
-	cleanup
 )
 
 func getCommandType() commandType {
-	if len(getArgs()) == 0 {
+	switch subcommand {
-		return help
-	}
-	cmd := getArgs()[0]
-	switch cmd {
 	case "version":
 		return version
 	case "info":
@@ -66,23 +57,18 @@ func getCommandType() commandType {
 		return install
 	case "remove":
 		return remove
-	case "cleanup":
-		return cleanup
 	default:
 		return help
 	}
-
 }
 
 func resolveCommand() {
 	switch getCommandType() {
 	case version:
-		resolveFlags()
 		fmt.Println("Bubble Package Manager (BPM)")
 		fmt.Println("Version: " + bpmVer)
 	case info:
-		_, i := resolveFlags()
+		packages := subcommandArgs
-		packages := getArgs()[1+i:]
 		if len(packages) == 0 {
 			fmt.Println("No packages were given")
 			return
@@ -99,7 +85,6 @@ func resolveCommand() {
 			}
 		}
 	case list:
-		flags, _ := resolveFlags()
 		packages, err := bpm_utils.GetInstalledPackages(rootDir)
 		if err != nil {
 			log.Fatalf("Could not get installed packages\nError: %s", err.Error())
@@ -109,9 +94,9 @@ func resolveCommand() {
 			fmt.Println("No packages have been installed")
 			return
 		}
-		if slices.Contains(flags, "n") {
+		if pkgListNumbers {
 			fmt.Println(len(packages))
-		} else if slices.Contains(flags, "l") {
+		} else if pkgListNames {
 			for _, pkg := range packages {
 				fmt.Println(pkg)
 			}
@@ -133,8 +118,7 @@ func resolveCommand() {
 			fmt.Println("This subcommand needs to be run with superuser permissions")
 			os.Exit(0)
 		}
-		flags, i := resolveFlags()
+		files := subcommandArgs
-		files := getArgs()[1+i:]
 		if len(files) == 0 {
 			fmt.Println("No files were given to install")
 			return
@@ -150,7 +134,7 @@ func resolveCommand() {
 			if pkgInfo.Type == "source" {
 				verb = "build"
 			}
-			if !slices.Contains(flags, "f") {
+			if !forceInstall {
 				if pkgInfo.Arch != "any" && pkgInfo.Arch != bpm_utils.GetArch() {
 					fmt.Printf("skipping... cannot %s a package with a different architecture\n", verb)
 					continue
@@ -166,7 +150,10 @@ func resolveCommand() {
 					}
 				}
 			}
-			if !slices.Contains(flags, "y") {
+			if rootDir != "/" {
+				fmt.Println("Warning: Installing to " + rootDir)
+			}
+			if !yesAll {
 				reader := bufio.NewReader(os.Stdin)
 				if pkgInfo.Type == "source" {
 					fmt.Print("Would you like to view the source.sh file of this package? [Y\\n] ")
@@ -182,7 +169,7 @@ func resolveCommand() {
 				}
 			}
 			if bpm_utils.IsPackageInstalled(pkgInfo.Name, rootDir) {
-				if !slices.Contains(flags, "y") {
+				if !yesAll {
 					installedInfo := bpm_utils.GetPackageInfo(pkgInfo.Name, rootDir, false)
 					if strings.Compare(pkgInfo.Version, installedInfo.Version) > 0 {
 						fmt.Println("This file contains a newer version of this package (" + installedInfo.Version + " -> " + pkgInfo.Version + ")")
@@ -201,7 +188,7 @@ func resolveCommand() {
 						continue
 					}
 				}
-			} else if !slices.Contains(flags, "y") {
+			} else if !yesAll {
 				reader := bufio.NewReader(os.Stdin)
 				fmt.Printf("Do you wish to %s this package? [y\\N] ", verb)
 				text, _ := reader.ReadString('\n')
@@ -211,15 +198,15 @@ func resolveCommand() {
 				}
 			}
 
-			err = bpm_utils.InstallPackage(file, rootDir, slices.Contains(flags, "f"), slices.Contains(flags, "b"), slices.Contains(flags, "k"))
+			err = bpm_utils.InstallPackage(file, rootDir, forceInstall, buildSource, keepTempDir)
 			if err != nil {
-				if pkgInfo.Type == "source" && slices.Contains(flags, "k") {
+				if pkgInfo.Type == "source" && keepTempDir {
 					fmt.Println("BPM temp directory was created at /var/tmp/bpm_source-" + pkgInfo.Name)
 				}
 				log.Fatalf("Could not install package\nError: %s\n", err)
 			}
 			fmt.Printf("Package (%s) was successfully installed!\n", pkgInfo.Name)
-			if pkgInfo.Type == "source" && slices.Contains(flags, "k") {
+			if pkgInfo.Type == "source" && keepTempDir {
 				fmt.Println("** It is recommended you delete the temporary bpm folder in /var/tmp **")
 			}
 		}
@@ -228,8 +215,7 @@ func resolveCommand() {
 			fmt.Println("This subcommand needs to be run with superuser permissions")
 			os.Exit(0)
 		}
-		flags, i := resolveFlags()
+		packages := subcommandArgs
-		packages := getArgs()[1+i:]
 		if len(packages) == 0 {
 			fmt.Println("No packages were given")
 			return
@@ -242,7 +228,10 @@ func resolveCommand() {
 			}
 			fmt.Print("----------------\n" + bpm_utils.CreateInfoFile(*pkgInfo))
 			fmt.Println("----------------")
-			if !slices.Contains(flags, "y") {
+			if rootDir != "/" {
+				fmt.Println("Warning: Installing to " + rootDir)
+			}
+			if !yesAll {
 				reader := bufio.NewReader(os.Stdin)
 				fmt.Print("Do you wish to remove this package? [y\\N] ")
 				text, _ := reader.ReadString('\n')
@@ -259,6 +248,11 @@ func resolveCommand() {
 			fmt.Printf("Package (%s) was successfully removed!\n", pkgInfo.Name)
 		}
 	default:
+		printHelp()
+	}
+}
+
+func printHelp() {
 	fmt.Println("\033[1m------Help------\033[0m")
 	fmt.Println("\033[1m\\ Command Format /\033[0m")
 	fmt.Println("-> command format: bpm <subcommand> [-flags]...")
@@ -276,42 +270,64 @@ func resolveCommand() {
 	fmt.Println("       -k keeps the temp directory created by BPM after source package installation")
 	fmt.Println("-> bpm remove [-y] <packages...> | removes the following packages")
 	fmt.Println("       -y skips the confirmation prompt")
-		fmt.Println("-> bpm cleanup | removes all unneeded dependencies")
+	//fmt.Println("-> bpm cleanup | removes all unneeded dependencies")
 	fmt.Println("\033[1m----------------\033[0m")
 }
-}
 
-func resolveFlags() ([]string, int) {
+func resolveFlags() {
-	flags := getArgs()[1:]
+	// List flags
-	var ret []string
+	listFlagSet := flag.NewFlagSet("List flags", flag.ExitOnError)
-	for _, flag := range flags {
+	listFlagSet.Usage = printHelp
-		if strings.HasPrefix(flag, "-") {
+	listFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root")
-			f := strings.TrimPrefix(flag, "-")
+	listFlagSet.BoolVar(&yesAll, "y", false, "Skip confirmation prompts")
-			switch getCommandType() {
+	listFlagSet.BoolVar(&pkgListNumbers, "n", false, "List the number of all packages installed with BPM")
-			default:
+	listFlagSet.BoolVar(&pkgListNames, "l", false, "List the names of all packages installed with BPM")
-				log.Fatalf("Invalid flag " + flag)
+	// Info flags
-			case list:
+	infoFlagSet := flag.NewFlagSet("Info flags", flag.ExitOnError)
-				v := [...]string{"l", "n"}
+	infoFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root")
-				if !slices.Contains(v[:], f) {
+	infoFlagSet.Usage = printHelp
-					log.Fatalf("Invalid flag " + flag)
+	// Install flags
-				}
+	installFlagSet := flag.NewFlagSet("Install flags", flag.ExitOnError)
-				ret = append(ret, f)
+	installFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root")
-			case install:
+	installFlagSet.BoolVar(&yesAll, "y", false, "Skip confirmation prompts")
-				v := [...]string{"y", "f", "b", "k"}
+	installFlagSet.BoolVar(&buildSource, "b", false, "Build binary package from source package")
-				if !slices.Contains(v[:], f) {
+	installFlagSet.BoolVar(&keepTempDir, "k", false, "Keep temporary directory after source compilation")
-					log.Fatalf("Invalid flag " + flag)
+	installFlagSet.BoolVar(&forceInstall, "f", false, "Force installation by skipping architecture and dependency resolution")
-				}
+	installFlagSet.Usage = printHelp
-				ret = append(ret, f)
+	// Remove flags
-			case remove:
+	removeFlagSet := flag.NewFlagSet("Remove flags", flag.ExitOnError)
-				v := [...]string{"y"}
+	removeFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root")
-				if !slices.Contains(v[:], f) {
+	removeFlagSet.BoolVar(&yesAll, "y", false, "Skip confirmation prompts")
-					log.Fatalf("Invalid flag " + flag)
+	removeFlagSet.Usage = printHelp
-				}
+	if len(os.Args[1:]) <= 0 {
-				ret = append(ret, f)
+		subcommand = "help"
-			}
 	} else {
-			break
+		subcommand = os.Args[1]
+		subcommandArgs = os.Args[2:]
+		if getCommandType() == list {
+			err := listFlagSet.Parse(subcommandArgs)
+			if err != nil {
+				return
+			}
+			subcommandArgs = listFlagSet.Args()
+		} else if getCommandType() == info {
+			err := infoFlagSet.Parse(subcommandArgs)
+			if err != nil {
+				return
+			}
+			subcommandArgs = infoFlagSet.Args()
+		} else if getCommandType() == install {
+			err := installFlagSet.Parse(subcommandArgs)
+			if err != nil {
+				return
+			}
+			subcommandArgs = installFlagSet.Args()
+		} else if getCommandType() == remove {
+			err := removeFlagSet.Parse(subcommandArgs)
+			if err != nil {
+				return
+			}
+			subcommandArgs = removeFlagSet.Args()
 		}
 	}
-	return ret, len(ret)
 }

test_packages/x86_64/bpm-utils/files/usr/bin/bpm-create

@@ -7,7 +7,7 @@ fi
 
 output=$1
 
-if [[ ! "$output" =~ ^[a-zA-Z0-9_-]{1,}$ ]]; then
+if [[ ! "$output" =~ ^[a-z.A-Z0-9_-]{1,}$ ]]; then
   echo "Invalid output name! The name must only contain letters, numbers, hyphens or underscores!"
   exit 1
 fi
@@ -22,6 +22,9 @@ else
   if [ -f source.sh ]; then
     type="source"
     echo "source.sh file found"
+    if [ -d source-files ]; then
+      echo "source-files/ directory found"
+    fi
   else
     echo "files/ directory or source.sh file not found in $PWD"
     exit 1
@@ -35,10 +38,14 @@ else
   exit 1
 fi
 
-echo "Creating $type package as $output.bpm"
+echo "Creating $type package as $output"
 
 if [[ "$type" == "binary" ]]; then
-  tar -czf "$output".bpm files/ pkg.info
+  tar -czf "$output" files/ pkg.info
 else
-  tar -czf "$output".bpm source.sh pkg.info
+  if [ -d source-files ]; then
+    tar -czf "$output" source.sh source-files/ pkg.info
+  else
+    tar -czf "$output" source.sh pkg.info
+  fi
 fi

test_packages/x86_64/bpm-utils/pkg.info

@@ -1,6 +1,6 @@
 name: bpm-utils
 description: Utilities to create BPM packages
-version: 1.2.0
+version: 1.3.0
 url: https://gitlab.com/bubble-package-manager/bpm/
 license: GPL3
 architecture: x86_64

test_packages/x86_64/bpm/pkg.info

@@ -1,6 +1,6 @@
 name: bpm
 description: The Bubble Package Manager
-version: 0.1.0
+version: 0.1.3
 url: https://gitlab.com/bubble-package-manager/bpm/
 license: GPL3
 architecture: x86_64