2024-01-04 13:08:32 -07:00
|
|
|
package packagemanager
|
2024-01-04 09:49:03 -07:00
|
|
|
|
|
|
|
// This package is responsible for searching various sources for the availability of the requested package
|
|
|
|
|
|
|
|
import (
|
|
|
|
"encoding/json"
|
2024-01-04 11:04:38 -07:00
|
|
|
"io/ioutil"
|
2024-01-04 09:49:03 -07:00
|
|
|
"fmt"
|
2024-01-04 11:04:38 -07:00
|
|
|
"os/user"
|
|
|
|
"os/exec"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
"net/http"
|
2024-01-04 09:49:03 -07:00
|
|
|
)
|
|
|
|
|
2024-01-04 11:04:38 -07:00
|
|
|
// UninstallPackages uninstalls the provided packages
|
|
|
|
func UninstallPackages(packageNames []string) error {
|
|
|
|
pkgList, err := readPackageList()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, packageName := range packageNames {
|
|
|
|
source, exists := pkgList[packageName]
|
|
|
|
if !exists {
|
|
|
|
fmt.Printf("Package %s not found in installed packages list\n", packageName)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
switch source {
|
|
|
|
case "pacman":
|
2024-01-04 13:08:32 -07:00
|
|
|
err = UninstallPacmanPackage(packageName)
|
2024-01-04 11:04:38 -07:00
|
|
|
case "snap":
|
2024-01-04 13:08:32 -07:00
|
|
|
err = UninstallSnapPackage(packageName)
|
2024-01-04 11:04:38 -07:00
|
|
|
case "flatpak":
|
2024-01-04 13:08:32 -07:00
|
|
|
err = UninstallFlatpakPackage(packageName)
|
2024-01-04 11:04:38 -07:00
|
|
|
// Add cases for other package managers if necessary
|
|
|
|
default:
|
|
|
|
fmt.Printf("Unknown source for package %s\n", packageName)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
fmt.Printf("Error uninstalling package %s: %v\n", packageName, err)
|
|
|
|
} else {
|
|
|
|
fmt.Printf("Successfully uninstalled package %s\n", packageName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// readPackageList reads the package list from the pkg.list file
|
|
|
|
func readPackageList() (PackageList, error) {
|
|
|
|
usr, err := user.Current()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error getting current user: %v", err)
|
|
|
|
}
|
|
|
|
pkgListPath := filepath.Join(usr.HomeDir, ".allpac", "pkg.list")
|
|
|
|
|
|
|
|
file, err := ioutil.ReadFile(pkgListPath)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error reading package list file: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
var pkgList PackageList
|
|
|
|
err = json.Unmarshal(file, &pkgList)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error decoding package list: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return pkgList, nil
|
|
|
|
}
|
|
|
|
|
2024-01-04 09:49:03 -07:00
|
|
|
// AURResponse represents the structure of the response from AUR RPC
|
|
|
|
type AURResponse struct {
|
|
|
|
Version int `json:"version"`
|
|
|
|
Type string `json:"type"`
|
|
|
|
ResultCount int `json:"resultcount"`
|
|
|
|
Results []AURPackage `json:"results"`
|
|
|
|
}
|
|
|
|
|
|
|
|
// AURPackage represents a package in the AUR
|
|
|
|
type AURPackage struct {
|
|
|
|
ID int `json:"ID"`
|
|
|
|
Name string `json:"Name"`
|
|
|
|
Version string `json:"Version"`
|
|
|
|
Description string `json:"Description"`
|
|
|
|
URL string `json:"URL"`
|
|
|
|
// Add other fields as needed
|
|
|
|
}
|
|
|
|
|
|
|
|
// SearchPacman searches for a package in the Pacman repositories
|
|
|
|
func SearchPacman(packageName string) ([]string, error) {
|
|
|
|
cmd := exec.Command("pacman", "-Ss", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error searching Pacman: %v", err)
|
|
|
|
}
|
|
|
|
return parsePacmanOutput(string(output)), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// SearchSnap searches for a package in the Snap store
|
|
|
|
func SearchSnap(packageName string) ([]string, error) {
|
|
|
|
cmd := exec.Command("snap", "find", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error searching Snap: %v", err)
|
|
|
|
}
|
|
|
|
return strings.Split(string(output), "\n"), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// SearchFlatpak searches for a package in Flatpak repositories
|
|
|
|
func SearchFlatpak(packageName string) ([]string, error) {
|
|
|
|
cmd := exec.Command("flatpak", "search", packageName)
|
|
|
|
output, err := cmd.CombinedOutput()
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error searching Flatpak: %v", err)
|
|
|
|
}
|
|
|
|
return strings.Split(string(output), "\n"), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// SearchAUR searches the AUR for the given term
|
|
|
|
func SearchAUR(searchTerm string) ([]AURPackage, error) {
|
|
|
|
url := fmt.Sprintf("https://aur.archlinux.org/rpc/?v=5&type=search&arg=%s", searchTerm)
|
|
|
|
resp, err := http.Get(url)
|
|
|
|
if err != nil {
|
|
|
|
return nil, fmt.Errorf("error making request to AUR: %v", err)
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
|
|
|
var aurResponse AURResponse
|
|
|
|
if err := json.NewDecoder(resp.Body).Decode(&aurResponse); err != nil {
|
|
|
|
return nil, fmt.Errorf("error decoding AUR response: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return aurResponse.Results, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// parsePacmanOutput parses the output from Pacman search command
|
|
|
|
func parsePacmanOutput(output string) []string {
|
|
|
|
// Split the output into sections, each representing a package
|
|
|
|
sections := strings.Split(output, "\n\n")
|
|
|
|
|
|
|
|
var packages []string
|
|
|
|
for _, section := range sections {
|
|
|
|
// Split each section into lines
|
|
|
|
lines := strings.Split(section, "\n")
|
|
|
|
|
|
|
|
// The first line should contain the package name and version
|
|
|
|
if len(lines) > 0 {
|
|
|
|
packageNameLine := lines[0]
|
|
|
|
|
|
|
|
// Check if the package is installed
|
|
|
|
if strings.Contains(packageNameLine, "[installed]") {
|
|
|
|
packageNameLine += " (Installed)"
|
|
|
|
}
|
|
|
|
|
|
|
|
packages = append(packages, packageNameLine)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return packages
|
|
|
|
}
|
2024-01-04 13:08:32 -07:00
|
|
|
|
|
|
|
// GetPacmanPackageVersion returns the version of a package in the Pacman repositories
|
|
|
|
func GetPacmanPackageVersion(packageName string) (string, error) {
|
|
|
|
searchResults, err := SearchPacman(packageName)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, result := range searchResults {
|
|
|
|
if strings.Contains(result, packageName) {
|
|
|
|
return extractVersionFromPacmanResult(result), nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return "", fmt.Errorf("package %s not found in Pacman", packageName)
|
|
|
|
}
|
|
|
|
|
|
|
|
// extractVersionFromPacmanResult extracts the version from a Pacman search result string
|
|
|
|
func extractVersionFromPacmanResult(result string) string {
|
|
|
|
// Assuming the result is in the format "packageName version description"
|
|
|
|
parts := strings.Fields(result)
|
|
|
|
if len(parts) >= 2 {
|
|
|
|
return parts[1] // The second element should be the version
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
// fetchAURPackageInfo fetches package information from the AUR
|
|
|
|
func fetchAURPackageInfo(packageName string) (*AURPackageInfo, error) {
|
|
|
|
url := fmt.Sprintf("https://aur.archlinux.org/rpc/?v=5&type=info&arg[]=%s", packageName)
|
|
|
|
resp, err := http.Get(url)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
|
|
|
|
var result struct {
|
|
|
|
Results []AURPackageInfo `json:"results"`
|
|
|
|
}
|
|
|
|
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(result.Results) == 0 {
|
|
|
|
return nil, fmt.Errorf("package %s not found in AUR", packageName)
|
|
|
|
}
|
|
|
|
|
|
|
|
return &result.Results[0], nil
|
|
|
|
}
|