yay/upgrade.go

200 lines
4.7 KiB
Go
Raw Normal View History

2017-08-01 16:43:20 +00:00
package main
2017-07-14 17:03:54 +00:00
import (
"fmt"
2017-08-01 16:43:20 +00:00
"sort"
2020-07-10 00:36:45 +00:00
"strings"
"sync"
2017-07-14 17:03:54 +00:00
2020-10-01 11:38:03 +00:00
alpm "github.com/Jguer/go-alpm/v2"
"github.com/leonelquinteros/gotext"
2020-10-01 12:06:21 +00:00
rpc "github.com/mikkeloscar/aur"
2020-07-31 23:20:00 +00:00
"github.com/Jguer/yay/v10/pkg/db"
"github.com/Jguer/yay/v10/pkg/intrange"
2020-10-01 12:06:21 +00:00
"github.com/Jguer/yay/v10/pkg/multierror"
"github.com/Jguer/yay/v10/pkg/query"
2020-07-05 00:45:23 +00:00
"github.com/Jguer/yay/v10/pkg/settings"
2020-10-01 12:06:21 +00:00
"github.com/Jguer/yay/v10/pkg/stringset"
"github.com/Jguer/yay/v10/pkg/text"
2020-07-31 23:20:00 +00:00
"github.com/Jguer/yay/v10/pkg/upgrade"
2017-07-14 17:03:54 +00:00
)
2017-10-14 16:11:47 +00:00
// upList returns lists of packages to upgrade from each source.
2020-08-16 21:41:38 +00:00
func upList(warnings *query.AURWarnings, dbExecutor db.Executor, enableDowngrade bool) (aurUp, repoUp upgrade.UpSlice, err error) {
2020-07-31 23:20:00 +00:00
remote, remoteNames := query.GetRemotePackages(dbExecutor)
2017-07-14 17:03:54 +00:00
var wg sync.WaitGroup
2020-07-31 23:20:00 +00:00
var develUp upgrade.UpSlice
var errs multierror.MultiError
2017-07-14 17:03:54 +00:00
aurdata := make(map[string]*rpc.Pkg)
2019-11-11 07:15:04 +00:00
for _, pkg := range remote {
if pkg.ShouldIgnore() {
warnings.Ignore.Set(pkg.Name())
}
}
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeRepo {
text.OperationInfoln(gotext.Get("Searching databases for updates..."))
wg.Add(1)
go func() {
2020-07-31 23:20:00 +00:00
repoUp, err = dbExecutor.RepoUpgrades(enableDowngrade)
2018-08-02 16:14:57 +00:00
errs.Add(err)
wg.Done()
}()
}
2020-07-05 00:45:23 +00:00
if config.Runtime.Mode == settings.ModeAny || config.Runtime.Mode == settings.ModeAUR {
text.OperationInfoln(gotext.Get("Searching AUR for updates..."))
var _aurdata []*rpc.Pkg
2020-07-10 00:36:45 +00:00
_aurdata, err = query.AURInfo(remoteNames, warnings, config.RequestSplitN)
2018-08-02 16:14:57 +00:00
errs.Add(err)
if err == nil {
for _, pkg := range _aurdata {
aurdata[pkg.Name] = pkg
}
wg.Add(1)
go func() {
2020-10-01 12:06:21 +00:00
aurUp = upgrade.UpAUR(remote, aurdata, config.TimeUpdate)
wg.Done()
}()
if config.Devel {
text.OperationInfoln(gotext.Get("Checking development packages..."))
wg.Add(1)
go func() {
2020-10-01 12:06:21 +00:00
develUp = upgrade.UpDevel(remote, aurdata, config.Runtime.VCSStore)
wg.Done()
}()
}
}
}
wg.Wait()
printLocalNewerThanAUR(remote, aurdata)
if develUp != nil {
names := make(stringset.StringSet)
for _, up := range develUp {
names.Set(up.Name)
}
for _, up := range aurUp {
if !names.Get(up.Name) {
develUp = append(develUp, up)
}
}
aurUp = develUp
}
2018-08-02 16:14:57 +00:00
return aurUp, repoUp, errs.Return()
2017-07-14 17:03:54 +00:00
}
func printLocalNewerThanAUR(
2020-10-01 11:38:03 +00:00
remote []alpm.IPackage, aurdata map[string]*rpc.Pkg) {
for _, pkg := range remote {
aurPkg, ok := aurdata[pkg.Name()]
if !ok {
continue
}
2020-07-31 23:20:00 +00:00
left, right := upgrade.GetVersionDiff(pkg.Version(), aurPkg.Version)
if !isDevelPackage(pkg) && alpm.VerCmp(pkg.Version(), aurPkg.Version) > 0 {
text.Warnln(gotext.Get("%s: local (%s) is newer than AUR (%s)",
2020-08-16 22:09:43 +00:00
text.Cyan(pkg.Name()),
2018-08-04 13:22:49 +00:00
left, right,
))
}
}
}
2020-07-10 00:36:45 +00:00
func isDevelName(name string) bool {
for _, suffix := range []string{"git", "svn", "hg", "bzr", "nightly"} {
if strings.HasSuffix(name, "-"+suffix) {
return true
}
}
return strings.Contains(name, "-always-")
}
2020-10-01 11:38:03 +00:00
func isDevelPackage(pkg alpm.IPackage) bool {
2020-07-10 00:36:45 +00:00
return isDevelName(pkg.Name()) || isDevelName(pkg.Base())
}
2017-10-14 16:11:47 +00:00
// upgradePkgs handles updating the cache and installing updates.
2020-07-31 23:20:00 +00:00
func upgradePkgs(aurUp, repoUp upgrade.UpSlice) (ignore, aurNames stringset.StringSet, err error) {
ignore = make(stringset.StringSet)
aurNames = make(stringset.StringSet)
2018-05-02 15:46:21 +00:00
allUpLen := len(repoUp) + len(aurUp)
if allUpLen == 0 {
return ignore, aurNames, nil
2017-08-01 16:43:20 +00:00
}
if !config.UpgradeMenu {
for _, pkg := range aurUp {
aurNames.Set(pkg.Name)
}
return ignore, aurNames, nil
}
2017-08-01 16:43:20 +00:00
sort.Sort(repoUp)
sort.Sort(aurUp)
2018-05-02 15:46:21 +00:00
allUp := append(repoUp, aurUp...)
2020-08-16 22:09:43 +00:00
fmt.Printf("%s"+text.Bold(" %d ")+"%s\n", text.Bold(text.Cyan("::")), allUpLen, text.Bold(gotext.Get("Packages to upgrade.")))
2020-07-31 23:20:00 +00:00
allUp.Print()
2017-08-01 16:43:20 +00:00
text.Infoln(gotext.Get("Packages to exclude: (eg: \"1 2 3\", \"1-3\", \"^4\" or repo name)"))
numbers, err := getInput(config.AnswerUpgrade)
if err != nil {
return nil, nil, err
}
// upgrade menu asks you which packages to NOT upgrade so in this case
// include and exclude are kind of swapped
include, exclude, otherInclude, otherExclude := intrange.ParseNumberMenu(numbers)
2017-08-01 16:43:20 +00:00
isInclude := len(exclude) == 0 && len(otherExclude) == 0
for i, pkg := range repoUp {
if isInclude && otherInclude.Get(pkg.Repository) {
ignore.Set(pkg.Name)
2017-08-01 16:43:20 +00:00
}
2017-08-02 21:56:45 +00:00
if isInclude && !include.Get(len(repoUp)-i+len(aurUp)) {
continue
2017-08-01 16:43:20 +00:00
}
if !isInclude && (exclude.Get(len(repoUp)-i+len(aurUp)) || otherExclude.Get(pkg.Repository)) {
continue
2018-01-14 17:48:16 +00:00
}
ignore.Set(pkg.Name)
2017-08-01 16:43:20 +00:00
}
for i, pkg := range aurUp {
if isInclude && otherInclude.Get(pkg.Repository) {
continue
2017-08-01 16:43:20 +00:00
}
if isInclude && !include.Get(len(aurUp)-i) {
aurNames.Set(pkg.Name)
}
if !isInclude && (exclude.Get(len(aurUp)-i) || otherExclude.Get(pkg.Repository)) {
aurNames.Set(pkg.Name)
2017-08-01 16:43:20 +00:00
}
}
return ignore, aurNames, err
2017-08-01 16:43:20 +00:00
}