67ce4f7038
Some minor changes and bug fixes I've happened upon through my own testing. changes to main.go: ``` - change the CLI syntax for searching to be `allpac search {package name}` instead of `allpac search -package {package name}` - ensure when pacman doesn't find anything, it doesn't return an error. (pacman just exits with error code 1 when it doesn't find anything. Which is super silly but whatever) ``` changes to search.go: ``` - add some changes to ensure if pacman is "erroring" it's a real error. Not just pacman returning Exit code 1 because it didn't get a result. ```
273 lines
8.8 KiB
Go
273 lines
8.8 KiB
Go
package main
|
|
|
|
// This file is our main entrypoint, and build point for AllPac
|
|
|
|
import (
|
|
"flag"
|
|
"fmt"
|
|
"os"
|
|
"strings"
|
|
"pixelridgesoftworks.com/AllPac/pkg/packagemanager"
|
|
"pixelridgesoftworks.com/AllPac/pkg/logger"
|
|
"path/filepath"
|
|
)
|
|
|
|
func main() {
|
|
// Initialize the logger
|
|
logFilePath := filepath.Join(os.Getenv("HOME"), ".allpac", "logs", "allpac.log")
|
|
if err := logger.Init(logFilePath); err != nil {
|
|
// If logger initialization fails, you can choose to exit the program or use the default logger
|
|
logger.Errorf("Failed to initialize logger: %v", err)
|
|
}
|
|
// Define flags for different commands
|
|
updateCmd := flag.NewFlagSet("update", flag.ExitOnError)
|
|
installCmd := flag.NewFlagSet("install", flag.ExitOnError)
|
|
uninstallCmd := flag.NewFlagSet("uninstall", flag.ExitOnError)
|
|
searchCmd := flag.NewFlagSet("search", flag.ExitOnError)
|
|
aurRebuildCmd := flag.NewFlagSet("rebuild", flag.ExitOnError)
|
|
aurCleanCmd := flag.NewFlagSet("clean-aur", flag.ExitOnError)
|
|
|
|
if len(os.Args) < 2 {
|
|
fmt.Println("Expected 'update', 'install', 'uninstall', 'search', 'rebuild', or 'clean-aur' subcommands")
|
|
os.Exit(1)
|
|
}
|
|
|
|
switch os.Args[1] {
|
|
case "update":
|
|
handleUpdate(updateCmd)
|
|
case "install":
|
|
handleInstall(installCmd)
|
|
case "uninstall":
|
|
handleUninstall(uninstallCmd)
|
|
case "search":
|
|
handleSearch(searchCmd, os.Args[2:])
|
|
case "rebuild":
|
|
handleRebuild(aurRebuildCmd)
|
|
case "clean-aur":
|
|
handleCleanAur(aurCleanCmd)
|
|
default:
|
|
fmt.Printf("Unknown subcommand: %s\n", os.Args[1])
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func handleUpdate(cmd *flag.FlagSet) {
|
|
everythingFlag := cmd.Bool("everything", false, "Update all packages on the system")
|
|
snapFlag := cmd.Bool("snap", false, "Update all Snap packages")
|
|
aurFlag := cmd.Bool("aur", false, "Update all AUR packages")
|
|
archFlag := cmd.Bool("arch", false, "Update all Arch packages")
|
|
flatsFlag := cmd.Bool("flats", false, "Update all Flatpak packages")
|
|
cmd.Parse(os.Args[2:])
|
|
|
|
if *everythingFlag {
|
|
// Call function to update all packages
|
|
packagemanager.UpdateAllPackages()
|
|
} else if *snapFlag {
|
|
// Call function to update Snap packages
|
|
packagemanager.UpdateSnapPackages()
|
|
} else if *aurFlag {
|
|
// Call function to update AUR packages
|
|
packagemanager.UpdateAURPackages()
|
|
} else if *archFlag {
|
|
// Call function to update Arch packages
|
|
packagemanager.UpdatePacmanPackages()
|
|
} else if *flatsFlag {
|
|
// Call function to update Flatpak packages
|
|
packagemanager.UpdateFlatpakPackages()
|
|
} else {
|
|
fmt.Println("No update option specified or unrecognized option")
|
|
}
|
|
}
|
|
|
|
// handles the install command for packages
|
|
func handleInstall(cmd *flag.FlagSet) {
|
|
packageNames := cmd.String("packages", "", "Comma-separated list of packages to install")
|
|
cmd.Parse(os.Args[2:])
|
|
|
|
if *packageNames == "" {
|
|
fmt.Println("You must specify at least one package name.")
|
|
cmd.Usage()
|
|
return
|
|
}
|
|
|
|
packages := strings.Split(*packageNames, ",")
|
|
searchResults, err := packagemanager.SearchAllSources(packages)
|
|
if err != nil {
|
|
fmt.Printf("Error searching for packages: %v\n", err)
|
|
return
|
|
}
|
|
|
|
for _, result := range searchResults {
|
|
fmt.Printf("Searching for package: %s\n", result.PackageName)
|
|
if len(result.Results) == 0 {
|
|
fmt.Println("No sources found for package.")
|
|
continue
|
|
}
|
|
|
|
sourceIndex := promptUserForSource(result.Results)
|
|
if sourceIndex < 0 || sourceIndex >= len(result.Results) {
|
|
fmt.Println("Invalid selection. Skipping package.")
|
|
continue
|
|
}
|
|
|
|
selectedSource := result.Results[sourceIndex].Source
|
|
fmt.Printf("Installing %s from %s...\n", result.PackageName, selectedSource)
|
|
|
|
switch selectedSource {
|
|
case "pacman":
|
|
err = packagemanager.InstallPackagePacman(result.PackageName)
|
|
case "snap":
|
|
err = packagemanager.InstallPackageSnap(result.PackageName)
|
|
case "flatpak":
|
|
err = packagemanager.InstallPackageFlatpak(result.PackageName)
|
|
case "aur":
|
|
_, err = packagemanager.CloneAndInstallFromAUR(fmt.Sprintf("https://aur.archlinux.org/%s.git", result.PackageName), false)
|
|
default:
|
|
fmt.Printf("Unknown source for package %s\n", result.PackageName)
|
|
continue
|
|
}
|
|
|
|
if err != nil {
|
|
fmt.Printf("Error installing package %s from %s: %v\n", result.PackageName, selectedSource, err)
|
|
} else {
|
|
fmt.Printf("Package %s installed successfully from %s.\n", result.PackageName, selectedSource)
|
|
}
|
|
}
|
|
}
|
|
|
|
// handleUninstall handles the uninstall command for packages
|
|
func handleUninstall(cmd *flag.FlagSet) {
|
|
// Define a flag for accepting multiple package names
|
|
packageNames := cmd.String("packages", "", "Comma-separated list of packages to uninstall")
|
|
|
|
// Parse the command line arguments
|
|
cmd.Parse(os.Args[2:])
|
|
|
|
// Check if the package names were provided
|
|
if *packageNames == "" {
|
|
fmt.Println("You must specify at least one package name.")
|
|
cmd.Usage()
|
|
return
|
|
}
|
|
|
|
// Split the package names and convert to a slice
|
|
packages := strings.Split(*packageNames, ",")
|
|
|
|
// Call the function to uninstall the packages
|
|
err := packagemanager.UninstallPackages(packages)
|
|
if err != nil {
|
|
fmt.Printf("Error uninstalling packages: %v\n", err)
|
|
} else {
|
|
fmt.Println("Requested packages uninstalled successfully.")
|
|
}
|
|
}
|
|
|
|
// handleSearch handles the search command for packages across different package managers
|
|
func handleSearch(cmd *flag.FlagSet, args []string) {
|
|
// Check if the package name was provided
|
|
if len(args) < 1 {
|
|
fmt.Println("You must specify a package name.")
|
|
cmd.Usage()
|
|
return
|
|
}
|
|
|
|
// The package name is the first argument
|
|
packageName := args[0]
|
|
|
|
// Search in Pacman
|
|
pacmanResults, err := packagemanager.SearchPacman(packageName)
|
|
if err != nil {
|
|
logger.Errorf("Error searching in Pacman: %v", err)
|
|
} else if len(pacmanResults) == 0 {
|
|
fmt.Println("Pacman: No results found")
|
|
} else {
|
|
fmt.Println("Pacman Results:")
|
|
for _, result := range pacmanResults {
|
|
fmt.Println(result)
|
|
}
|
|
}
|
|
|
|
// Search in Snap
|
|
snapResults, err := packagemanager.SearchSnap(packageName)
|
|
if err != nil {
|
|
fmt.Printf("Error searching in Snap: %v\n", err)
|
|
} else {
|
|
fmt.Println("Snap Results:")
|
|
for _, result := range snapResults {
|
|
fmt.Println(result)
|
|
}
|
|
}
|
|
|
|
// Search in Flatpak
|
|
flatpakResults, err := packagemanager.SearchFlatpak(packageName)
|
|
if err != nil {
|
|
fmt.Printf("Error searching in Flatpak: %v\n", err)
|
|
} else {
|
|
fmt.Println("Flatpak Results:")
|
|
for _, result := range flatpakResults {
|
|
fmt.Println(result)
|
|
}
|
|
}
|
|
|
|
// Search in AUR
|
|
aurResults, err := packagemanager.SearchAUR(packageName)
|
|
if err != nil {
|
|
fmt.Printf("Error searching in AUR: %v\n", err)
|
|
} else {
|
|
fmt.Println("AUR Results:")
|
|
for _, result := range aurResults {
|
|
fmt.Printf("%s - %s\n", result.Name, result.Version)
|
|
}
|
|
}
|
|
}
|
|
|
|
// handleRebuild handles the rebuild command for an AUR package
|
|
func handleRebuild(cmd *flag.FlagSet) {
|
|
// Define a flag for the package name
|
|
packageName := cmd.String("package", "", "Name of the AUR package to rebuild")
|
|
|
|
// Parse the command line arguments
|
|
cmd.Parse(os.Args[2:])
|
|
|
|
// Check if the package name was provided
|
|
if *packageName == "" {
|
|
fmt.Println("You must specify a package name.")
|
|
cmd.Usage()
|
|
return
|
|
}
|
|
|
|
// Call the function to rebuild and reinstall the AUR package
|
|
err := packagemanager.RebuildAndReinstallAURPackage(*packageName)
|
|
if err != nil {
|
|
fmt.Printf("Error rebuilding package %s: %v\n", *packageName, err)
|
|
} else {
|
|
fmt.Printf("Package %s rebuilt and reinstalled successfully.\n", *packageName)
|
|
}
|
|
}
|
|
|
|
// handleCleanAur handles the cleaning of AUR cache
|
|
func handleCleanAur(cmd *flag.FlagSet) {
|
|
// Parse the command flags if needed
|
|
cmd.Parse(os.Args[2:])
|
|
|
|
// Call the function to clear the AUR cache
|
|
err := packagemanager.ClearAllPacCache()
|
|
if err != nil {
|
|
fmt.Printf("Error clearing AUR cache: %v\n", err)
|
|
return
|
|
}
|
|
|
|
fmt.Println("AUR cache cleared successfully.")
|
|
}
|
|
|
|
// prompts the user to select a source for installation
|
|
func promptUserForSource(sources []packagemanager.SourceResult) int {
|
|
for i, source := range sources {
|
|
fmt.Printf("%d: %s\n", i, source.Source)
|
|
}
|
|
fmt.Print("Select the source number to install from: ")
|
|
var choice int
|
|
fmt.Scan(&choice)
|
|
return choice
|
|
}
|