Follow-up to PR #10: Fix YUM package manager review issues

manager/yum/utils.go

@@ -9,6 +9,9 @@ import (
 	"github.com/bluet/syspkg/manager"
 )
 
+// packageLineRegex matches package lines in yum search output (name.arch format)
+var packageLineRegex = regexp.MustCompile(`^[\w\d-]+\.[\w\d_]+`)
+
 // ParseFindOutput parses the output of `yum search packageName` command
 // and returns a list of available packages that match the search query. It extracts package
 // information such as name, architecture from the
@@ -26,15 +29,16 @@ import (
 // The function first removes the "Last Metadata..." and the "========="
 // lines, and then processes each package entry line to extract relevant
 // information.
+//
+// The opts parameter is reserved for future parsing options and is currently unused.
 func ParseFindOutput(msg string, opts *manager.Options) []manager.PackageInfo {
 	var packages []manager.PackageInfo
 
 	// remove the last empty line
 	msg = strings.TrimSuffix(msg, "\n")
 
-	// split output by empty lines
-	var lines []string = strings.Split(msg, "\n")
-	var packageLineRegex = regexp.MustCompile(`^[\w\d-]+\.[\w\d_]+`)
+	// split output by lines
+	lines := strings.Split(msg, "\n")
 
 	for _, line := range lines {
 		if strings.HasPrefix(line, "=======") {
@@ -50,14 +54,14 @@ func ParseFindOutput(msg string, opts *manager.Options) []manager.PackageInfo {
 			if parts[0] == "" {
 				continue
 			}
-			name_arch := strings.Split(parts[0], ".")
-			if len(name_arch) != 2 {
+			nameArch := strings.Split(parts[0], ".")
+			if len(nameArch) < 2 {
 				continue
 			}
 
 			packageInfo := manager.PackageInfo{
-				Name:           name_arch[0],
-				Arch:           name_arch[1],
+				Name:           nameArch[0],
+				Arch:           nameArch[1],
 				PackageManager: pm,
 			}
 
@@ -71,6 +75,8 @@ func ParseFindOutput(msg string, opts *manager.Options) []manager.PackageInfo {
 // ParseListInstalledOutput parses the output of `yum list --installed` command
 // and returns a list of installed packages. It extracts the package name, version,
 // and architecture from the output and stores them in a list of manager.PackageInfo objects.
+//
+// The opts parameter is reserved for future parsing options and is currently unused.
 func ParseListInstalledOutput(msg string, opts *manager.Options) []manager.PackageInfo {
 	var packages []manager.PackageInfo
 
@@ -90,12 +96,12 @@ func ParseListInstalledOutput(msg string, opts *manager.Options) []manager.Packa
 			if len(parts) < 2 || parts[0] == "" {
 				continue
 			}
-			name_arch := strings.Split(parts[0], ".")
-			if len(name_arch) != 2 {
+			nameArch := strings.Split(parts[0], ".")
+			if len(nameArch) < 2 {
 				continue
 			}
-			name := name_arch[0]
-			arch := name_arch[1]
+			name := nameArch[0]
+			arch := nameArch[1]
 
 			packageInfo := manager.PackageInfo{
 				Name:           name,
@@ -114,6 +120,8 @@ func ParseListInstalledOutput(msg string, opts *manager.Options) []manager.Packa
 // ParsePackageInfoOutput parses the output of `yum info packageName` command
 // and returns a manager.PackageInfo object containing package information such as name, version,
 // architecture, and category. This function is useful for getting detailed package information.
+//
+// The opts parameter is reserved for future parsing options and is currently unused.
 func ParsePackageInfoOutput(msg string, opts *manager.Options) manager.PackageInfo {
 	var pkg manager.PackageInfo
 

manager/yum/yum.go

@@ -1,33 +1,41 @@
 // Package yum provides an implementation of the syspkg manager interface for the yum package manager.
-// It provides an Go (golang) API interface for interacting with the YUM package manager.
+// It provides a Go (golang) API interface for interacting with the YUM package manager.
 // This package is a wrapper around the yum command line tool.
 //
-// YUM was the default package manager on RedHat-based systems such as Centos, it has been recently superseded by DNF (Dandified YUM)
+// YUM was the default package manager on RedHat-based systems such as CentOS, it has been recently superseded by DNF (Dandified YUM)
 //
 // This package is part of the syspkg library.
 package yum
 
 import (
+	"context"
 	"errors"
 	"log"
 	"os"
 	"os/exec"
+	"time"
 
 	"github.com/bluet/syspkg/manager"
 )
 
+// Timeouts for different YUM operations
+const (
+	readTimeout  = 3 * time.Minute // For search, list, info operations
+	cleanTimeout = 5 * time.Minute // For clean operations
+)
+
 var pm string = "yum"
 
 // Constants used for yum commands
 const (
 	ArgsAssumeYes    string = "-y"
 	ArgsAssumeNo     string = "--assumeno"
 	ArgsQuiet        string = "-q"
-	ArgsDryRun       string = ""
-	ArgsFixBroken    string = ""
-	ArgsPurge        string = ""
-	ArgsAutoRemove   string = ""
-	ArgsShowProgress string = ""
+	ArgsDryRun       string = "--setopt=tsflags=test" // Test transaction without executing
+	ArgsFixBroken    string = "check"                 // Check for broken dependencies
+	ArgsPurge        string = ""                      // YUM doesn't distinguish remove vs purge
+	ArgsAutoRemove   string = "autoremove"            // Remove unneeded dependencies
+	ArgsShowProgress string = "-v"                    // Verbose output shows progress
 )
 
 // PackageManager implements the manager.PackageManager interface for the yum package manager.
@@ -53,8 +61,14 @@ func (a *PackageManager) Delete(pkgs []string, opts *manager.Options) ([]manager
 }
 
 // Refresh updates the package list using the yum package manager.
+// Uses 'yum clean expire-cache' which efficiently refreshes metadata without
+// aggressive cache clearing. This preserves valid cache files while ensuring
+// up-to-date repository information.
 func (a *PackageManager) Refresh(opts *manager.Options) error {
-	cmd := exec.Command(pm, "clean", "expire-cache")
+	ctx, cancel := context.WithTimeout(context.Background(), cleanTimeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, pm, "clean", "expire-cache")
 
 	if opts == nil {
 		opts = &manager.Options{
@@ -83,8 +97,11 @@ func (a *PackageManager) Refresh(opts *manager.Options) error {
 
 // Find searches for packages matching the provided keywords using the yum package manager.
 func (a *PackageManager) Find(keywords []string, opts *manager.Options) ([]manager.PackageInfo, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), readTimeout)
+	defer cancel()
+
 	args := append([]string{"search"}, keywords...)
-	cmd := exec.Command(pm, args...)
+	cmd := exec.CommandContext(ctx, pm, args...)
 
 	out, err := cmd.Output()
 	if err != nil {
@@ -96,8 +113,11 @@ func (a *PackageManager) Find(keywords []string, opts *manager.Options) ([]manag
 
 // ListInstalled lists all installed packages using the yum package manager.
 func (a *PackageManager) ListInstalled(opts *manager.Options) ([]manager.PackageInfo, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), readTimeout)
+	defer cancel()
+
 	args := []string{"list", "--installed"}
-	cmd := exec.Command(pm, args...)
+	cmd := exec.CommandContext(ctx, pm, args...)
 	out, err := cmd.Output()
 	if err != nil {
 		return nil, err
@@ -114,13 +134,46 @@ func (a *PackageManager) Upgrade(pkgs []string, opts *manager.Options) ([]manage
 func (a *PackageManager) UpgradeAll(opts *manager.Options) ([]manager.PackageInfo, error) {
 	return nil, errors.New("not implemented")
 }
+
+// Clean performs comprehensive cleanup of YUM caches.
+// Uses 'yum clean all' which removes all cached packages, metadata, and headers.
+// This is what administrators typically expect from a clean operation.
 func (a *PackageManager) Clean(opts *manager.Options) error {
-	return a.Refresh(nil)
+	ctx, cancel := context.WithTimeout(context.Background(), cleanTimeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, pm, "clean", "all")
+
+	if opts == nil {
+		opts = &manager.Options{
+			DryRun:      false,
+			Interactive: false,
+			Verbose:     false,
+		}
+	}
+	if opts.Interactive {
+		cmd.Stdout = os.Stdout
+		cmd.Stderr = os.Stderr
+		cmd.Stdin = os.Stdin
+		return cmd.Run()
+	}
+
+	out, err := cmd.Output()
+	if err != nil {
+		return err
+	}
+	if opts.Verbose {
+		log.Println(string(out))
+	}
+	return nil
 }
 
 // GetPackageInfo retrieves package information for the specified package using the yum package manager.
 func (a *PackageManager) GetPackageInfo(pkg string, opts *manager.Options) (manager.PackageInfo, error) {
-	cmd := exec.Command(pm, "info", pkg)
+	ctx, cancel := context.WithTimeout(context.Background(), readTimeout)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, pm, "info", pkg)
 	out, err := cmd.Output()
 	if err != nil {
 		return manager.PackageInfo{}, err

manager/yum/yum_test.go

@@ -23,7 +23,7 @@ func TestYumPackageManagerNotAvailable(t *testing.T) {
 	}
 	_, errlu := yumManager.ListUpgradable(&opts)
 	if errlu == nil {
-		t.Fatal("YumPackageManager should not support list-upgadeable")
+		t.Fatal("YumPackageManager should not support list-upgradable")
 	}
 	_, erru := yumManager.Upgrade(packages, nil)
 	if erru == nil {