Added the ability to create pre_install.sh, post_install.sh, pre_update.sh, post_update.sh and post_remove.sh scripts

bpm_utils/package_utils.go

@@ -100,6 +100,166 @@ func ReadPackage(filename string) (*PackageInfo, error) {
 	return nil, errors.New("pkg.info not found in archive")
 }
 
+func ReadPackageScripts(filename string) (map[string]string, error) {
+	if _, err := os.Stat(filename); os.IsNotExist(err) {
+		return nil, err
+	}
+	file, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+	archive, err := gzip.NewReader(file)
+	if err != nil {
+		return nil, err
+	}
+	tr := tar.NewReader(archive)
+	ret := make(map[string]string)
+	for {
+		header, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return nil, err
+		}
+		if header.Name == "pre_install.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "post_install.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "pre_update.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "post_update.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		} else if header.Name == "post_remove.sh" {
+			bs, _ := io.ReadAll(tr)
+			if err != nil {
+				return nil, err
+			}
+			ret[header.Name] = string(bs)
+		}
+	}
+	err = archive.Close()
+	if err != nil {
+		return nil, err
+	}
+	err = file.Close()
+	if err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+type Operation uint8
+
+const (
+	Install Operation = 0
+	Update            = 1
+	Remove            = 2
+)
+
+func ExecutePackageScripts(filename, rootDir string, operation Operation, postOperation bool) error {
+	pkgInfo, err := ReadPackage(filename)
+	if err != nil {
+		return err
+	}
+	scripts, err := ReadPackageScripts(filename)
+	if err != nil {
+		return err
+	}
+
+	run := func(name, content string) error {
+		temp, err := os.CreateTemp("", name)
+		if err != nil {
+			return err
+		}
+		_, err = temp.WriteString(content)
+		if err != nil {
+			return err
+		}
+		cmd := exec.Command("/bin/bash", temp.Name())
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		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_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
+		}
+		return nil
+	}
+
+	if operation == Install {
+		if val, ok := scripts["pre_install.sh"]; !postOperation && ok {
+			err := run("pre_install.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := scripts["post_install.sh"]; postOperation && ok {
+			err := run("post_install.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+	} else if operation == Update {
+		if val, ok := scripts["pre_update.sh"]; !postOperation && ok {
+			err := run("pre_update.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := scripts["post_update.sh"]; postOperation && ok {
+			err := run("post_update.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+	} else if operation == Remove {
+		if val, ok := scripts["post_remove.sh"]; postOperation && ok {
+			err := run("post_remove.sh", val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
 func ReadPackageInfo(contents string, defaultValues bool) (*PackageInfo, error) {
 	pkgInfo := PackageInfo{
 		Name:        "",
@@ -216,7 +376,8 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 	if err != nil {
 		return err
 	}
-	if IsPackageInstalled(pkgInfo.Name, installDir) {
+	packageInstalled := IsPackageInstalled(pkgInfo.Name, installDir)
+	if packageInstalled {
 		oldFiles = GetPackageFiles(pkgInfo.Name, installDir)
 	}
 	if !force {
@@ -227,8 +388,18 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			return errors.New("Could not resolve all dependencies. Missing " + strings.Join(unresolved, ", "))
 		}
 	}
-
 	if pkgInfo.Type == "binary" {
+		if !packageInstalled {
+			err = ExecutePackageScripts(filename, installDir, Install, false)
+			if err != nil {
+				return err
+			}
+		} else {
+			err = ExecutePackageScripts(filename, installDir, Update, false)
+			if err != nil {
+				return err
+			}
+		}
 		seenHardlinks := make(map[string]string)
 		for {
 			header, err := tr.Next()
@@ -378,8 +549,16 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			return err
 		}
 		fmt.Println("Running source.sh file...")
-		if err != nil {
+		if !packageInstalled {
-			return err
+			err = ExecutePackageScripts(filename, installDir, Install, false)
+			if err != nil {
+				return err
+			}
+		} else {
+			err = ExecutePackageScripts(filename, installDir, Update, false)
+			if err != nil {
+				return err
+			}
 		}
 		cmd := exec.Command("/bin/bash", "-e", "source.sh")
 		cmd.Stdin = os.Stdin
@@ -387,6 +566,7 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 		cmd.Stderr = os.Stderr
 		cmd.Dir = temp
 		cmd.Env = os.Environ()
+		cmd.Env = append(cmd.Env, fmt.Sprintf("BPM_ROOT=%s", installDir))
 		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))
@@ -498,6 +678,13 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			if err != nil {
 				return err
 			}
+			scripts, err := ReadPackageScripts(filename)
+			for key, val := range scripts {
+				err = os.WriteFile(path.Join(compiledDir, key), []byte(val), 0644)
+				if err != nil {
+					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+"-"+compiledInfo.Version+".bpm", "pkg.info", path.Join(temp, "/output/"), "--transform", sed)
 			cmd.Stdin = os.Stdin
@@ -505,11 +692,17 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 			cmd.Stderr = os.Stderr
 			cmd.Dir = compiledDir
 			fmt.Printf("running command: %s %s\n", cmd.Path, strings.Join(cmd.Args, " "))
-			err := cmd.Run()
+			err = cmd.Run()
 			if err != nil {
 				return err
 			}
 			err = os.Remove(path.Join(compiledDir, "pkg.info"))
+			for key := range scripts {
+				err = os.Remove(path.Join(compiledDir, key))
+				if err != nil {
+					return err
+				}
+			}
 			if err != nil {
 				return err
 			}
@@ -580,6 +773,25 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 		return err
 	}
 
+	scripts, err := ReadPackageScripts(filename)
+	if err != nil {
+		return err
+	}
+	if val, ok := scripts["post_remove.sh"]; ok {
+		f, err = os.Create(path.Join(pkgDir, "post_remove.sh"))
+		if err != nil {
+			return err
+		}
+		_, err = f.WriteString(val)
+		if err != nil {
+			return err
+		}
+		err = f.Close()
+		if err != nil {
+			return err
+		}
+	}
+
 	err = archive.Close()
 	if err != nil {
 		return err
@@ -590,12 +802,77 @@ func InstallPackage(filename, installDir string, force, binaryPkgFromSrc, keepTe
 	}
 	if len(filesDiff) != 0 {
 		fmt.Println("Removing obsolete files")
+		var symlinks []string
 		for _, f := range filesDiff {
-			err := os.RemoveAll(path.Join(installDir, f))
+			f = path.Join(installDir, f)
+			lstat, err := os.Lstat(f)
+			if os.IsNotExist(err) {
+				continue
+			}
 			if err != nil {
 				return err
 			}
-			fmt.Println("Removing: " + path.Join(installDir, f))
+			if lstat.Mode() == os.ModeSymlink {
+				symlinks = append(symlinks, f)
+				continue
+			}
+			stat, err := os.Stat(f)
+			if os.IsNotExist(err) {
+				continue
+			}
+			if err != nil {
+				return err
+			}
+			if stat.IsDir() {
+				dir, err := os.ReadDir(f)
+				if err != nil {
+					return err
+				}
+				if len(dir) == 0 {
+					fmt.Println("Removing: " + f)
+					err := os.Remove(f)
+					if err != nil {
+						return err
+					}
+				}
+			} else {
+				fmt.Println("Removing: " + f)
+				err := os.Remove(f)
+				if err != nil {
+					return err
+				}
+			}
+		}
+		for _, f := range symlinks {
+			f = path.Join(installDir, f)
+			_, err := os.Lstat(f)
+			if os.IsNotExist(err) {
+				continue
+			}
+			if err != nil {
+				return err
+			}
+			_, err = filepath.EvalSymlinks(f)
+			if os.IsNotExist(err) {
+				err := os.Remove(f)
+				if err != nil {
+					return err
+				}
+			}
+			if err != nil {
+				return err
+			}
+		}
+	}
+	if !packageInstalled {
+		err = ExecutePackageScripts(filename, installDir, Install, true)
+		if err != nil {
+			return err
+		}
+	} else {
+		err = ExecutePackageScripts(filename, installDir, Update, true)
+		if err != nil {
+			return err
 		}
 	}
 	return nil
@@ -815,10 +1092,26 @@ func setPackageInfo(pkg, contents, rootDir string) error {
 func RemovePackage(pkg, rootDir string) error {
 	installedDir := path.Join(rootDir, "var/lib/bpm/installed/")
 	pkgDir := path.Join(installedDir, pkg)
+	pkgInfo := GetPackageInfo(pkg, rootDir, false)
+	if pkgInfo == nil {
+		return errors.New("could not get package info")
+	}
 	files := GetPackageFiles(pkg, rootDir)
+	var symlinks []string
 	for _, file := range files {
 		file = path.Join(rootDir, file)
-		stat, err := os.Lstat(file)
+		lstat, err := os.Lstat(file)
+		if os.IsNotExist(err) {
+			continue
+		}
+		if err != nil {
+			return err
+		}
+		if lstat.Mode() == os.ModeSymlink {
+			symlinks = append(symlinks, file)
+			continue
+		}
+		stat, err := os.Stat(file)
 		if os.IsNotExist(err) {
 			continue
 		}
@@ -845,6 +1138,56 @@ func RemovePackage(pkg, rootDir string) error {
 			}
 		}
 	}
+	for _, file := range symlinks {
+		file = path.Join(rootDir, file)
+		_, err := os.Lstat(file)
+		if os.IsNotExist(err) {
+			continue
+		}
+		if err != nil {
+			return err
+		}
+		_, err = filepath.EvalSymlinks(file)
+		if os.IsNotExist(err) {
+			err := os.Remove(file)
+			if err != nil {
+				return err
+			}
+		}
+		if err != nil {
+			return err
+		}
+	}
+	if _, err := os.Stat(path.Join(pkgDir, "post_remove.sh")); err == nil {
+		cmd := exec.Command("/bin/bash", path.Join(pkgDir, "post_remove.sh"))
+		cmd.Stdin = os.Stdin
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		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_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
+		}
+	}
 	err := os.RemoveAll(pkgDir)
 	if err != nil {
 		return err

main.go

@@ -7,6 +7,8 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
+	"slices"
 	"strings"
 )
 
@@ -15,7 +17,7 @@ import (
 /*   A simple-to-use package manager  */
 /* ---------------------------------- */
 
-var bpmVer = "0.1.3"
+var bpmVer = "0.1.7"
 
 var subcommand = "help"
 var subcommandArgs []string
@@ -43,6 +45,7 @@ const (
 	list
 	install
 	remove
+	file
 )
 
 func getCommandType() commandType {
@@ -57,6 +60,8 @@ func getCommandType() commandType {
 		return install
 	case "remove":
 		return remove
+	case "file":
+		return file
 	default:
 		return help
 	}
@@ -247,6 +252,53 @@ func resolveCommand() {
 			}
 			fmt.Printf("Package (%s) was successfully removed!\n", pkgInfo.Name)
 		}
+	case file:
+		files := subcommandArgs
+		if len(files) == 0 {
+			fmt.Println("No files were given to get which packages manage it")
+			return
+		}
+		for _, file := range files {
+			absFile, err := filepath.Abs(file)
+			if err != nil {
+				log.Fatalf("Could not get absolute path of %s", file)
+			}
+			stat, err := os.Stat(absFile)
+			if os.IsNotExist(err) {
+				log.Fatalf(absFile + " does not exist!")
+			}
+			pkgs, err := bpm_utils.GetInstalledPackages(rootDir)
+			if err != nil {
+				log.Fatalf("Could not get installed packages. Error %s", err.Error())
+			}
+
+			if !strings.HasPrefix(absFile, rootDir) {
+				log.Fatalf("Could not get relative path of %s to root path", absFile)
+			}
+			absFile, err = filepath.Rel(rootDir, absFile)
+			if err != nil {
+				log.Fatalf("Could not get relative path of %s to root path", absFile)
+			}
+			absFile = strings.TrimPrefix(absFile, "/")
+			if stat.IsDir() {
+				absFile = absFile + "/"
+			}
+
+			var pkgList []string
+			for _, pkg := range pkgs {
+				if slices.Contains(bpm_utils.GetPackageFiles(pkg, rootDir), absFile) {
+					pkgList = append(pkgList, pkg)
+				}
+			}
+			if len(pkgList) == 0 {
+				fmt.Println(absFile + " is not managed by any packages")
+			} else {
+				fmt.Println(absFile + " is managed by the following packages:")
+				for _, pkg := range pkgList {
+					fmt.Println("- " + pkg)
+				}
+			}
+		}
 	default:
 		printHelp()
 	}
@@ -259,18 +311,23 @@ func printHelp() {
 	fmt.Println("-> flags will be read if passed right after the subcommand otherwise they will be read as subcommand arguments")
 	fmt.Println("\033[1m\\ Command List /\033[0m")
 	fmt.Println("-> bpm version | shows information on the installed version of bpm")
-	fmt.Println("-> bpm info | shows information on an installed package")
+	fmt.Println("-> bpm info [-R] | shows information on an installed package")
-	fmt.Println("-> bpm list [-n, -l] | lists all installed packages")
+	fmt.Println("       -R=<root_path> lets you define the root path which will be used")
+	fmt.Println("-> bpm list [-R, -n, -l] | lists all installed packages")
+	fmt.Println("       -R=<root_path> lets you define the root path which will be used")
 	fmt.Println("       -n shows the number of packages")
 	fmt.Println("       -l lists package names only")
-	fmt.Println("-> bpm install [-y, -f, -b] <files...> | installs the following files")
+	fmt.Println("-> bpm install [-R, -y, -f, -b] <files...> | installs the following files")
+	fmt.Println("       -R=<root_path> lets you define the root path which will be used")
 	fmt.Println("       -y skips the confirmation prompt")
 	fmt.Println("       -f skips dependency and architecture checking")
 	fmt.Println("       -b creates a binary package for a source package after compilation and saves it in /var/lib/bpm/compiled")
 	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("-> bpm remove [-R, -y] <packages...> | removes the following packages")
+	fmt.Println("       -R=<root_path> lets you define the root path which will be used")
 	fmt.Println("       -y skips the confirmation prompt")
-	//fmt.Println("-> bpm cleanup | removes all unneeded dependencies")
+	fmt.Println("-> bpm file [-R] <files...> | shows what packages the following packages are managed by")
+	fmt.Println("       -R=<root_path> lets you define the root path which will be used")
 	fmt.Println("\033[1m----------------\033[0m")
 }
 
@@ -299,6 +356,11 @@ func resolveFlags() {
 	removeFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root")
 	removeFlagSet.BoolVar(&yesAll, "y", false, "Skip confirmation prompts")
 	removeFlagSet.Usage = printHelp
+	// File flags
+	// Remove flags
+	fileFlagSet := flag.NewFlagSet("Remove flags", flag.ExitOnError)
+	fileFlagSet.StringVar(&rootDir, "R", "/", "Set the destination root")
+	fileFlagSet.Usage = printHelp
 	if len(os.Args[1:]) <= 0 {
 		subcommand = "help"
 	} else {
@@ -328,6 +390,12 @@ func resolveFlags() {
 				return
 			}
 			subcommandArgs = removeFlagSet.Args()
+		} else if getCommandType() == file {
+			err := fileFlagSet.Parse(subcommandArgs)
+			if err != nil {
+				return
+			}
+			subcommandArgs = fileFlagSet.Args()
 		}
 	}
 }

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

@@ -13,17 +13,41 @@ if [[ ! "$output" =~ ^[a-z.A-Z0-9_-]{1,}$ ]]; then
 fi
 
 type="binary"
+toCompress=("pkg.info")
 
 echo "Creating package with the name $output..."
 
 if [ -d files ]; then
   echo "files/ directory found"
+  toCompress+=("files/")
 else
   if [ -f source.sh ]; then
     type="source"
     echo "source.sh file found"
+    toCompress+=("source.sh")
+    if [ -f pre_update.sh ]; then
+      echo "pre_update.sh file found"
+      toCompress+=("pre_update.sh")
+    fi
+    if [ -f post_update.sh ]; then
+      echo "post_update.sh file found"
+      toCompress+=("post_update.sh")
+    fi
+    if [ -f pre_install.sh ]; then
+      echo "pre_install.sh file found"
+      toCompress+=("pre_install.sh")
+    fi
+    if [ -f post_install.sh ]; then
+      echo "post_install.sh file found"
+      toCompress+=("post_install.sh")
+    fi
+    if [ -f post_remove.sh ]; then
+          echo "post_remove.sh file found"
+          toCompress+=("post_remove.sh")
+        fi
     if [ -d source-files ]; then
       echo "source-files/ directory found"
+      toCompress+=("source-files/")
     fi
   else
     echo "files/ directory or source.sh file not found in $PWD"
@@ -40,12 +64,14 @@ fi
 
 echo "Creating $type package as $output"
 
-if [[ "$type" == "binary" ]]; then
+tar -czf "$output" "${toCompress[@]}"
-  tar -czf "$output" files/ pkg.info
+
-else
+#if [[ "$type" == "binary" ]]; then
-  if [ -d source-files ]; then
+#  tar -czf "$output" files/ pkg.info
-    tar -czf "$output" source.sh source-files/ pkg.info
+#else
-  else
+#  if [ -d source-files ]; then
-    tar -czf "$output" source.sh pkg.info
+#    tar -czf "$output" source.sh source-files/ pkg.info
-  fi
+#  else
-fi
+#    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.3.0
+version: 1.4.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.3
+version: 0.1.7
 url: https://gitlab.com/bubble-package-manager/bpm/
 license: GPL3
 architecture: x86_64