fix(sync_list): remove alpmHandle

wip

cmd.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"net/http"
 	"os"
-	"time"
 
 	alpm "github.com/Jguer/go-alpm"
 	"github.com/leonelquinteros/gotext"
@@ -140,7 +139,7 @@ getpkgbuild specific options:
     -f --force            Force download for existing ABS packages`)
 }
 
-func handleCmd(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, dbExecutor *db.AlpmExecutor) error {
+func handleCmd(cmdArgs *settings.Arguments, dbExecutor *db.AlpmExecutor) error {
 	if cmdArgs.ExistsArg("h", "help") {
 		return handleHelp(cmdArgs)
 	}
@@ -162,7 +161,7 @@ func handleCmd(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, dbExecutor
 	case "R", "remove":
 		return handleRemove(cmdArgs)
 	case "S", "sync":
-		return handleSync(cmdArgs, alpmHandle, dbExecutor)
+		return handleSync(cmdArgs, dbExecutor)
 	case "T", "deptest":
 		return show(passToPacman(cmdArgs))
 	case "U", "upgrade":
@@ -170,7 +169,7 @@ func handleCmd(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, dbExecutor
 	case "G", "getpkgbuild":
 		return handleGetpkgbuild(cmdArgs, dbExecutor)
 	case "P", "show":
-		return handlePrint(cmdArgs, alpmHandle, dbExecutor)
+		return handlePrint(cmdArgs, dbExecutor)
 	case "Y", "--yay":
 		return handleYay(cmdArgs, dbExecutor)
 	}
@@ -197,28 +196,7 @@ func handleVersion() {
 	fmt.Printf("yay v%s - libalpm v%s\n", yayVersion, alpm.Version())
 }
 
-func lastBuildTime(alpmHandle *alpm.Handle) time.Time {
-	dbList, err := alpmHandle.SyncDBs()
-	if err != nil {
-		return time.Now()
-	}
-
-	var lastTime time.Time
-	_ = dbList.ForEach(func(db alpm.DB) error {
-		_ = db.PkgCache().ForEach(func(pkg alpm.Package) error {
-			thisTime := pkg.BuildDate()
-			if thisTime.After(lastTime) {
-				lastTime = thisTime
-			}
-			return nil
-		})
-		return nil
-	})
-
-	return lastTime
-}
-
-func handlePrint(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, dbExecutor *db.AlpmExecutor) (err error) {
+func handlePrint(cmdArgs *settings.Arguments, dbExecutor *db.AlpmExecutor) (err error) {
 	switch {
 	case cmdArgs.ExistsArg("d", "defaultconfig"):
 		tmpConfig := settings.MakeConfig()
@@ -231,7 +209,7 @@ func handlePrint(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, dbExecuto
 	case cmdArgs.ExistsArg("w", "news"):
 		double := cmdArgs.ExistsDouble("w", "news")
 		quiet := cmdArgs.ExistsArg("q", "quiet")
-		err = news.PrintNewsFeed(lastBuildTime(alpmHandle), config.SortMode, double, quiet)
+		err = news.PrintNewsFeed(dbExecutor.LastBuildTime(), config.SortMode, double, quiet)
 	case cmdArgs.ExistsDouble("c", "complete"):
 		err = completion.Show(dbExecutor, config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, true)
 	case cmdArgs.ExistsArg("c", "complete"):
@@ -269,7 +247,7 @@ func handleYogurt(cmdArgs *settings.Arguments, dbExecutor *db.AlpmExecutor) erro
 	return displayNumberMenu(cmdArgs.Targets, dbExecutor, cmdArgs)
 }
 
-func handleSync(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, dbExecutor *db.AlpmExecutor) error {
+func handleSync(cmdArgs *settings.Arguments, dbExecutor *db.AlpmExecutor) error {
 	targets := cmdArgs.Targets
 
 	if cmdArgs.ExistsArg("s", "search") {
@@ -287,7 +265,7 @@ func handleSync(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle, dbExecutor
 		return syncClean(cmdArgs, dbExecutor)
 	}
 	if cmdArgs.ExistsArg("l", "list") {
-		return syncList(cmdArgs, alpmHandle)
+		return syncList(cmdArgs, dbExecutor)
 	}
 	if cmdArgs.ExistsArg("g", "groups") {
 		return show(passToPacman(cmdArgs))
@@ -430,7 +408,7 @@ func displayNumberMenu(pkgS []string, dbExecutor *db.AlpmExecutor, cmdArgs *sett
 	return install(arguments, dbExecutor, true)
 }
 
-func syncList(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle) error {
+func syncList(cmdArgs *settings.Arguments, dbExecutor *db.AlpmExecutor) error {
 	aur := false
 
 	for i := len(cmdArgs.Targets) - 1; i >= 0; i-- {
@@ -441,11 +419,6 @@ func syncList(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle) error {
 	}
 
 	if (config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR) && (len(cmdArgs.Targets) == 0 || aur) {
-		localDB, err := alpmHandle.LocalDB()
-		if err != nil {
-			return err
-		}
-
 		resp, err := http.Get(config.AURURL + "/packages.gz")
 		if err != nil {
 			return err
@@ -462,7 +435,7 @@ func syncList(cmdArgs *settings.Arguments, alpmHandle *alpm.Handle) error {
 			} else {
 				fmt.Printf("%s %s %s", magenta("aur"), bold(name), bold(green(gotext.Get("unknown-version"))))
 
-				if localDB.Pkg(name) != nil {
+				if dbExecutor.LocalPackage(name) != nil {
 					fmt.Print(bold(blue(gotext.Get(" [Installed]"))))
 				}
 

config.go

@@ -7,8 +7,6 @@ import (
 	"os/exec"
 	"strings"
 
-	alpm "github.com/Jguer/go-alpm"
-	"github.com/Morganamilo/go-pacmanconf"
 	"github.com/leonelquinteros/gotext"
 
 	"github.com/Jguer/yay/v10/pkg/settings"
@@ -111,102 +109,3 @@ func getInput(defaultValue string) (string, error) {
 
 	return string(buf), nil
 }
-
-func toUsage(usages []string) alpm.Usage {
-	if len(usages) == 0 {
-		return alpm.UsageAll
-	}
-
-	var ret alpm.Usage
-	for _, usage := range usages {
-		switch usage {
-		case "Sync":
-			ret |= alpm.UsageSync
-		case "Search":
-			ret |= alpm.UsageSearch
-		case "Install":
-			ret |= alpm.UsageInstall
-		case "Upgrade":
-			ret |= alpm.UsageUpgrade
-		case "All":
-			ret |= alpm.UsageAll
-		}
-	}
-
-	return ret
-}
-
-func configureAlpm(pacmanConf *pacmanconf.Config, alpmHandle *alpm.Handle) error {
-	// TODO: set SigLevel
-	// sigLevel := alpm.SigPackage | alpm.SigPackageOptional | alpm.SigDatabase | alpm.SigDatabaseOptional
-	// localFileSigLevel := alpm.SigUseDefault
-	// remoteFileSigLevel := alpm.SigUseDefault
-
-	for _, repo := range pacmanConf.Repos {
-		// TODO: set SigLevel
-		db, err := alpmHandle.RegisterSyncDB(repo.Name, 0)
-		if err != nil {
-			return err
-		}
-
-		db.SetServers(repo.Servers)
-		db.SetUsage(toUsage(repo.Usage))
-	}
-
-	if err := alpmHandle.SetCacheDirs(pacmanConf.CacheDir); err != nil {
-		return err
-	}
-
-	// add hook directories 1-by-1 to avoid overwriting the system directory
-	for _, dir := range pacmanConf.HookDir {
-		if err := alpmHandle.AddHookDir(dir); err != nil {
-			return err
-		}
-	}
-
-	if err := alpmHandle.SetGPGDir(pacmanConf.GPGDir); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetLogFile(pacmanConf.LogFile); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetIgnorePkgs(pacmanConf.IgnorePkg); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetIgnoreGroups(pacmanConf.IgnoreGroup); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetArch(pacmanConf.Architecture); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetNoUpgrades(pacmanConf.NoUpgrade); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetNoExtracts(pacmanConf.NoExtract); err != nil {
-		return err
-	}
-
-	/*if err := alpmHandle.SetDefaultSigLevel(sigLevel); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetLocalFileSigLevel(localFileSigLevel); err != nil {
-		return err
-	}
-
-	if err := alpmHandle.SetRemoteFileSigLevel(remoteFileSigLevel); err != nil {
-		return err
-	}*/
-
-	if err := alpmHandle.SetUseSyslog(pacmanConf.UseSyslog); err != nil {
-		return err
-	}
-
-	return alpmHandle.SetCheckSpace(pacmanConf.CheckSpace)
-}

install.go

@@ -366,7 +366,9 @@ func install(cmdArgs *settings.Arguments, dbExecutor *db.AlpmExecutor, ignorePro
 		}
 	}
 
-	go exitOnError(completion.Update(dbExecutor, config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false))
+	go func() {
+		_ = completion.Update(dbExecutor, config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
+	}()
 
 	err = downloadPkgbuildsSources(do.Aur, incompatible)
 	if err != nil {

main.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"os"
 
-	alpm "github.com/Jguer/go-alpm"
 	pacmanconf "github.com/Morganamilo/go-pacmanconf"
 	"github.com/leonelquinteros/gotext"
 
@@ -74,7 +73,7 @@ func initBuildDir() error {
 	return nil
 }
 
-func initAlpm(cmdArgs *settings.Arguments, pacmanConfigPath string) (*alpm.Handle, *pacmanconf.Config, error) {
+func initAlpm(cmdArgs *settings.Arguments, pacmanConfigPath string) (*pacmanconf.Config, bool, error) {
 	root := "/"
 	if value, _, exists := cmdArgs.GetArg("root", "r"); exists {
 		root = value
@@ -82,7 +81,7 @@ func initAlpm(cmdArgs *settings.Arguments, pacmanConfigPath string) (*alpm.Handl
 
 	pacmanConf, stderr, err := pacmanconf.PacmanConf("--config", pacmanConfigPath, "--root", root)
 	if err != nil {
-		return nil, nil, fmt.Errorf("%s", stderr)
+		return nil, false, fmt.Errorf("%s", stderr)
 	}
 
 	if dbPath, _, exists := cmdArgs.GetArg("dbpath", "b"); exists {
@@ -109,92 +108,111 @@ func initAlpm(cmdArgs *settings.Arguments, pacmanConfigPath string) (*alpm.Handl
 		pacmanConf.GPGDir = gpgDir
 	}
 
-	alpmHandle, err := initAlpmHandle(pacmanConf, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
+	useColor := pacmanConf.Color && isTty()
 	switch value, _, _ := cmdArgs.GetArg("color"); value {
 	case "always":
-		text.UseColor = true
+		useColor = true
 	case "auto":
-		text.UseColor = isTty()
+		useColor = isTty()
 	case "never":
-		text.UseColor = false
-	default:
-		text.UseColor = pacmanConf.Color && isTty()
+		useColor = false
 	}
 
-	return alpmHandle, pacmanConf, nil
+	return pacmanConf, useColor, nil
 }
 
-func initAlpmHandle(pacmanConf *pacmanconf.Config, oldAlpmHandle *alpm.Handle) (*alpm.Handle, error) {
-	if oldAlpmHandle != nil {
-		if errRelease := oldAlpmHandle.Release(); errRelease != nil {
-			return nil, errRelease
+func main() {
+	ret := 0
+	defer func() { os.Exit(ret) }()
+	initGotext()
+	if os.Geteuid() == 0 {
+		text.Warnln(gotext.Get("Avoid running yay as root/sudo."))
+	}
+
+	cmdArgs := settings.MakeArguments()
+	runtime, err := settings.MakeRuntime()
+	if err != nil {
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
 		}
+		ret = 1
+		return
 	}
 
-	alpmHandle, err := alpm.Initialize(pacmanConf.RootDir, pacmanConf.DBPath)
+	config = settings.MakeConfig()
+	config.Runtime = runtime
+
+	err = initConfig(runtime.ConfigPath)
 	if err != nil {
-		return nil, errors.New(gotext.Get("unable to CreateHandle: %s", err))
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
+		}
+		ret = 1
+		return
 	}
 
-	if err := configureAlpm(pacmanConf, alpmHandle); err != nil {
-		return nil, err
+	err = cmdArgs.ParseCommandLine(config)
+	if err != nil {
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
+		}
+		ret = 1
+		return
 	}
 
-	alpmHandle.SetQuestionCallback(questionCallback)
-	return alpmHandle, nil
-}
+	if config.Runtime.SaveConfig {
+		errS := config.SaveConfig(runtime.ConfigPath)
+		if errS != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}
 
-func exitOnError(err error) {
+	config.ExpandEnv()
+	err = initBuildDir()
 	if err != nil {
 		if str := err.Error(); str != "" {
 			fmt.Fprintln(os.Stderr, str)
 		}
-		cleanup(config.Runtime.AlpmHandle)
-		os.Exit(1)
+		ret = 1
+		return
 	}
-}
 
-func cleanup(alpmHandle *alpm.Handle) int {
-	if alpmHandle != nil {
-		if err := alpmHandle.Release(); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			return 1
+	err = initVCS(runtime.VCSPath)
+	if err != nil {
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
+		}
+		ret = 1
+		return
+	}
+	var useColor bool
+	config.Runtime.PacmanConf, useColor, err = initAlpm(cmdArgs, config.PacmanConf)
+	if err != nil {
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
 		}
+		ret = 1
+		return
 	}
 
-	return 0
-}
+	text.UseColor = useColor
 
-func main() {
-	initGotext()
-	if os.Geteuid() == 0 {
-		text.Warnln(gotext.Get("Avoid running yay as root/sudo."))
+	dbExecutor, err := db.NewExecutor(runtime.PacmanConf, questionCallback)
+	if err != nil {
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
+		}
+		ret = 1
+		return
 	}
 
-	cmdArgs := settings.MakeArguments()
-	runtime, err := settings.MakeRuntime()
-	exitOnError(err)
-	config = settings.MakeConfig()
-	config.Runtime = runtime
-	exitOnError(initConfig(runtime.ConfigPath))
-	exitOnError(cmdArgs.ParseCommandLine(config))
-	if config.Runtime.SaveConfig {
-		errS := config.SaveConfig(runtime.ConfigPath)
-		if errS != nil {
-			fmt.Fprintln(os.Stderr, err)
+	defer dbExecutor.Cleanup()
+	err = handleCmd(cmdArgs, dbExecutor)
+	if err != nil {
+		if str := err.Error(); str != "" {
+			fmt.Fprintln(os.Stderr, str)
 		}
+		ret = 1
+		return
 	}
-	config.ExpandEnv()
-	exitOnError(initBuildDir())
-	exitOnError(initVCS(runtime.VCSPath))
-	config.Runtime.AlpmHandle, config.Runtime.PacmanConf, err = initAlpm(cmdArgs, config.PacmanConf)
-	exitOnError(err)
-	config.Runtime.DBExecutor, err = db.NewAlpmExecutor(config.Runtime.AlpmHandle, runtime.PacmanConf, questionCallback)
-	exitOnError(err)
-	exitOnError(handleCmd(cmdArgs, config.Runtime.AlpmHandle, config.Runtime.DBExecutor))
-	os.Exit(cleanup(config.Runtime.AlpmHandle))
 }

main_test.go

@@ -9,11 +9,10 @@ import (
 )
 
 func TestInitAlpm(t *testing.T) {
-	alpmHandle, pacmanConf, err := initAlpm(settings.MakeArguments(), "testdata/pacman.conf")
+	pacmanConf, color, err := initAlpm(settings.MakeArguments(), "testdata/pacman.conf")
 	assert.Nil(t, err)
 	assert.NotNil(t, pacmanConf)
-
-	h := alpmHandle
+	assert.Equal(t, color, false)
 
 	root, err := h.Root()
 	assert.Nil(t, err)

pkg/db/alpm.go

@@ -2,6 +2,9 @@ package db
 
 import (
 	"errors"
+	"fmt"
+	"os"
+	"time"
 
 	alpm "github.com/Jguer/go-alpm"
 	pacmanconf "github.com/Morganamilo/go-pacmanconf"
@@ -19,19 +22,26 @@ type AlpmExecutor struct {
 	questionCallback func(question alpm.QuestionAny)
 }
 
-func NewAlpmExecutor(handle *alpm.Handle,
-	pacamnConf *pacmanconf.Config,
+func NewExecutor(pacamnConf *pacmanconf.Config,
 	questionCallback func(question alpm.QuestionAny)) (*AlpmExecutor, error) {
-	localDB, err := handle.LocalDB()
+	ae := &AlpmExecutor{conf: pacamnConf, questionCallback: questionCallback}
+
+	err := ae.RefreshHandle()
 	if err != nil {
 		return nil, err
 	}
-	syncDB, err := handle.SyncDBs()
+
+	ae.localDB, err = ae.handle.LocalDB()
 	if err != nil {
 		return nil, err
 	}
 
-	return &AlpmExecutor{handle: handle, localDB: localDB, syncDB: syncDB, conf: pacamnConf, questionCallback: questionCallback}, nil
+	ae.syncDB, err = ae.handle.SyncDBs()
+	if err != nil {
+		return nil, err
+	}
+
+	return ae, nil
 }
 
 func toUsage(usages []string) alpm.Usage {
@@ -338,3 +348,27 @@ func (ae *AlpmExecutor) BiggestPackages() []RepoPackage {
 	})
 	return localPackages
 }
+
+func (ae *AlpmExecutor) LastBuildTime() time.Time {
+	var lastTime time.Time
+	_ = ae.syncDB.ForEach(func(db alpm.DB) error {
+		_ = db.PkgCache().ForEach(func(pkg alpm.Package) error {
+			thisTime := pkg.BuildDate()
+			if thisTime.After(lastTime) {
+				lastTime = thisTime
+			}
+			return nil
+		})
+		return nil
+	})
+
+	return lastTime
+}
+
+func (ae *AlpmExecutor) Cleanup() {
+	if ae.handle != nil {
+		if err := ae.handle.Release(); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+		}
+	}
+}