2017-08-01 16:43:20 +00:00
|
|
|
package main
|
2017-07-14 17:03:54 +00:00
|
|
|
|
|
|
|
import (
|
2017-08-01 16:43:20 +00:00
|
|
|
"bufio"
|
2017-07-14 17:03:54 +00:00
|
|
|
"fmt"
|
2017-08-01 16:43:20 +00:00
|
|
|
"os"
|
|
|
|
"sort"
|
2018-03-22 16:39:27 +00:00
|
|
|
"strings"
|
2018-03-08 21:34:12 +00:00
|
|
|
"sync"
|
2017-07-14 17:03:54 +00:00
|
|
|
|
|
|
|
alpm "github.com/jguer/go-alpm"
|
|
|
|
pkgb "github.com/mikkeloscar/gopkgbuild"
|
|
|
|
)
|
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
// upgrade type describes a system upgrade.
|
|
|
|
type upgrade struct {
|
2017-07-14 17:03:54 +00:00
|
|
|
Name string
|
|
|
|
Repository string
|
|
|
|
LocalVersion string
|
|
|
|
RemoteVersion string
|
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upSlice is a slice of Upgrades
|
2017-08-01 16:43:20 +00:00
|
|
|
type upSlice []upgrade
|
2017-07-17 22:44:46 +00:00
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
func (u upSlice) Len() int { return len(u) }
|
|
|
|
func (u upSlice) Swap(i, j int) { u[i], u[j] = u[j], u[i] }
|
2017-07-17 22:44:46 +00:00
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
func (u upSlice) Less(i, j int) bool {
|
2018-03-26 01:28:31 +00:00
|
|
|
if u[i].Repository == u[j].Repository {
|
|
|
|
iRunes := []rune(u[i].Name)
|
|
|
|
jRunes := []rune(u[j].Name)
|
|
|
|
return lessRunes(iRunes, jRunes)
|
|
|
|
}
|
|
|
|
|
|
|
|
syncDb, err := alpmHandle.SyncDbs()
|
|
|
|
if err != nil {
|
2018-03-20 22:34:06 +00:00
|
|
|
iRunes := []rune(u[i].Repository)
|
|
|
|
jRunes := []rune(u[j].Repository)
|
|
|
|
return lessRunes(iRunes, jRunes)
|
2018-03-26 01:28:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
less := false
|
|
|
|
found := syncDb.ForEach(func(db alpm.Db) error {
|
|
|
|
if db.Name() == u[i].Repository {
|
|
|
|
less = true
|
|
|
|
} else if db.Name() == u[j].Repository {
|
|
|
|
less = false
|
|
|
|
} else {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
return fmt.Errorf("")
|
|
|
|
})
|
|
|
|
|
|
|
|
if found != nil {
|
|
|
|
return less
|
2018-03-20 22:34:06 +00:00
|
|
|
} else {
|
2018-03-26 01:28:31 +00:00
|
|
|
iRunes := []rune(u[i].Repository)
|
|
|
|
jRunes := []rune(u[j].Repository)
|
2018-03-20 22:34:06 +00:00
|
|
|
return lessRunes(iRunes, jRunes)
|
|
|
|
}
|
2018-03-26 01:28:31 +00:00
|
|
|
|
2018-03-20 22:34:06 +00:00
|
|
|
}
|
2017-07-17 22:44:46 +00:00
|
|
|
|
2018-02-19 17:01:19 +00:00
|
|
|
func getVersionDiff(oldVersion, newversion string) (left, right string) {
|
2018-02-21 08:41:25 +00:00
|
|
|
old, errOld := pkgb.NewCompleteVersion(oldVersion)
|
|
|
|
new, errNew := pkgb.NewCompleteVersion(newversion)
|
2018-02-19 17:01:19 +00:00
|
|
|
|
2018-02-21 08:41:25 +00:00
|
|
|
if errOld != nil {
|
2018-03-02 04:03:09 +00:00
|
|
|
left = red("Invalid Version")
|
2018-02-21 08:41:25 +00:00
|
|
|
}
|
|
|
|
if errNew != nil {
|
2018-03-02 04:03:09 +00:00
|
|
|
right = red("Invalid Version")
|
2018-02-21 08:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if errOld == nil && errNew == nil {
|
|
|
|
if old.Version == new.Version {
|
2018-03-02 04:03:09 +00:00
|
|
|
left = string(old.Version) + "-" + red(string(old.Pkgrel))
|
|
|
|
right = string(new.Version) + "-" + green(string(new.Pkgrel))
|
2018-02-21 08:41:25 +00:00
|
|
|
} else {
|
2018-03-02 04:03:09 +00:00
|
|
|
left = red(string(old.Version)) + "-" + string(old.Pkgrel)
|
|
|
|
right = bold(green(string(new.Version))) + "-" + string(new.Pkgrel)
|
2018-02-19 17:01:19 +00:00
|
|
|
}
|
2018-02-21 08:41:25 +00:00
|
|
|
}
|
2018-02-19 17:01:19 +00:00
|
|
|
|
2018-02-21 08:41:25 +00:00
|
|
|
return
|
2018-02-19 17:01:19 +00:00
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upList returns lists of packages to upgrade from each source.
|
2018-02-18 23:46:25 +00:00
|
|
|
func upList(dt *depTree) (aurUp upSlice, repoUp upSlice, err error) {
|
2017-08-07 13:43:25 +00:00
|
|
|
local, remote, _, remoteNames, err := filterPackages()
|
2017-07-14 17:03:54 +00:00
|
|
|
if err != nil {
|
2018-03-20 16:20:09 +00:00
|
|
|
return nil, nil, err
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
var wg sync.WaitGroup
|
|
|
|
var develUp upSlice
|
|
|
|
|
|
|
|
var repoErr error
|
|
|
|
var aurErr error
|
|
|
|
var develErr error
|
2017-07-14 17:03:54 +00:00
|
|
|
|
2018-03-02 04:03:09 +00:00
|
|
|
fmt.Println(bold(cyan("::") + " Searching databases for updates..."))
|
2018-03-20 16:20:09 +00:00
|
|
|
wg.Add(1)
|
2017-07-14 17:03:54 +00:00
|
|
|
go func() {
|
2018-03-20 16:20:09 +00:00
|
|
|
repoUp, repoErr = upRepo(local)
|
|
|
|
wg.Done()
|
2017-07-14 17:03:54 +00:00
|
|
|
}()
|
|
|
|
|
2018-03-02 04:03:09 +00:00
|
|
|
fmt.Println(bold(cyan("::") + " Searching AUR for updates..."))
|
2018-03-20 16:20:09 +00:00
|
|
|
wg.Add(1)
|
2017-07-14 17:03:54 +00:00
|
|
|
go func() {
|
2018-03-20 16:20:09 +00:00
|
|
|
aurUp, aurErr = upAUR(remote, remoteNames, dt)
|
|
|
|
wg.Done()
|
2017-07-14 17:03:54 +00:00
|
|
|
}()
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
if config.Devel {
|
|
|
|
fmt.Println(bold(cyan("::") + " Checking development packages..."))
|
|
|
|
wg.Add(1)
|
|
|
|
go func() {
|
|
|
|
develUp, develErr = upDevel(remote)
|
|
|
|
wg.Done()
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
errs := make([]string, 0)
|
|
|
|
for _, e := range []error{repoErr, aurErr, develErr} {
|
|
|
|
if e != nil {
|
|
|
|
errs = append(errs, e.Error())
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
}
|
2018-03-20 16:20:09 +00:00
|
|
|
|
|
|
|
if len(errs) > 0 {
|
|
|
|
err = fmt.Errorf("%s", strings.Join(errs, "\n"))
|
2018-03-20 23:04:28 +00:00
|
|
|
return nil, nil, err
|
2018-03-20 16:20:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if develUp != nil {
|
2018-03-20 23:04:28 +00:00
|
|
|
names := make(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-03-20 16:20:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return aurUp, repoUp, err
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
func upDevel(remote []alpm.Package) (toUpgrade upSlice, err error) {
|
2018-03-08 21:34:12 +00:00
|
|
|
toUpdate := make([]alpm.Package, 0, 0)
|
|
|
|
toRemove := make([]string, 0, 0)
|
|
|
|
|
|
|
|
var mux1 sync.Mutex
|
|
|
|
var mux2 sync.Mutex
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
|
|
|
|
checkUpdate := func(vcsName string, e shaInfos) {
|
|
|
|
defer wg.Done()
|
|
|
|
|
2017-10-18 02:12:16 +00:00
|
|
|
if e.needsUpdate() {
|
2018-03-08 21:34:12 +00:00
|
|
|
for _, pkg := range remote {
|
|
|
|
if pkg.Name() == vcsName {
|
|
|
|
mux1.Lock()
|
|
|
|
toUpdate = append(toUpdate, pkg)
|
|
|
|
mux1.Unlock()
|
|
|
|
return
|
2017-10-18 05:46:21 +00:00
|
|
|
}
|
|
|
|
}
|
2018-03-08 21:34:12 +00:00
|
|
|
|
|
|
|
mux2.Lock()
|
|
|
|
toRemove = append(toRemove, vcsName)
|
|
|
|
mux2.Unlock()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for vcsName, e := range savedInfo {
|
|
|
|
wg.Add(1)
|
|
|
|
go checkUpdate(vcsName, e)
|
|
|
|
}
|
|
|
|
|
|
|
|
wg.Wait()
|
|
|
|
|
|
|
|
for _, pkg := range toUpdate {
|
|
|
|
if pkg.ShouldIgnore() {
|
|
|
|
left, right := getVersionDiff(pkg.Version(), "latest-commit")
|
|
|
|
fmt.Print(magenta("Warning: "))
|
|
|
|
fmt.Printf("%s ignoring package upgrade (%s => %s)\n", cyan(pkg.Name()), left, right)
|
|
|
|
} else {
|
2018-03-20 16:20:09 +00:00
|
|
|
toUpgrade = append(toUpgrade, upgrade{pkg.Name(), "devel", pkg.Version(), "latest-commit"})
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
}
|
2018-03-08 21:34:12 +00:00
|
|
|
|
|
|
|
removeVCSPackage(toRemove)
|
2018-03-20 16:20:09 +00:00
|
|
|
return
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upAUR gathers foreign packages and checks if they have new versions.
|
2017-07-14 17:03:54 +00:00
|
|
|
// Output: Upgrade type package list.
|
2018-02-18 23:46:25 +00:00
|
|
|
func upAUR(remote []alpm.Package, remoteNames []string, dt *depTree) (toUpgrade upSlice, err error) {
|
2018-03-20 16:20:09 +00:00
|
|
|
for _, pkg := range remote {
|
|
|
|
aurPkg, ok := dt.Aur[pkg.Name()]
|
|
|
|
if !ok {
|
|
|
|
continue
|
2018-02-18 23:46:25 +00:00
|
|
|
}
|
|
|
|
|
2018-03-20 16:20:09 +00:00
|
|
|
if (config.TimeUpdate && (int64(aurPkg.LastModified) > pkg.BuildDate().Unix())) ||
|
|
|
|
(alpm.VerCmp(pkg.Version(), aurPkg.Version) < 0) {
|
|
|
|
if pkg.ShouldIgnore() {
|
|
|
|
left, right := getVersionDiff(pkg.Version(), aurPkg.Version)
|
|
|
|
fmt.Print(magenta("Warning: "))
|
|
|
|
fmt.Printf("%s ignoring package upgrade (%s => %s)\n", cyan(pkg.Name()), left, right)
|
|
|
|
} else {
|
|
|
|
toUpgrade = append(toUpgrade, upgrade{aurPkg.Name, "aur", pkg.Version(), aurPkg.Version})
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-03-20 16:20:09 +00:00
|
|
|
|
|
|
|
return
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upRepo gathers local packages and checks if they have new versions.
|
2017-07-14 17:03:54 +00:00
|
|
|
// Output: Upgrade type package list.
|
2017-08-01 16:43:20 +00:00
|
|
|
func upRepo(local []alpm.Package) (upSlice, error) {
|
2017-10-18 02:38:19 +00:00
|
|
|
dbList, err := alpmHandle.SyncDbs()
|
2017-07-14 17:03:54 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
slice := upSlice{}
|
2017-10-18 02:38:19 +00:00
|
|
|
|
2017-07-14 17:03:54 +00:00
|
|
|
for _, pkg := range local {
|
2017-07-18 09:51:58 +00:00
|
|
|
newPkg := pkg.NewVersion(dbList)
|
2018-01-10 00:38:32 +00:00
|
|
|
if newPkg != nil {
|
|
|
|
if pkg.ShouldIgnore() {
|
2018-03-12 23:25:09 +00:00
|
|
|
left, right := getVersionDiff(pkg.Version(), newPkg.Version())
|
2018-03-02 04:54:38 +00:00
|
|
|
fmt.Print(magenta("Warning: "))
|
2018-03-12 23:25:09 +00:00
|
|
|
fmt.Printf("%s ignoring package upgrade (%s => %s)\n", cyan(pkg.Name()), left, right)
|
2018-01-10 00:38:32 +00:00
|
|
|
} else {
|
|
|
|
slice = append(slice, upgrade{pkg.Name(), newPkg.DB().Name(), pkg.Version(), newPkg.Version()})
|
|
|
|
}
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return slice, nil
|
|
|
|
}
|
2017-08-01 16:43:20 +00:00
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upgradePkgs handles updating the cache and installing updates.
|
2018-02-18 23:46:25 +00:00
|
|
|
func upgradePkgs(dt *depTree) (stringSet, stringSet, error) {
|
2018-03-21 16:30:00 +00:00
|
|
|
ignore := make(stringSet)
|
2018-02-18 23:46:25 +00:00
|
|
|
aurNames := make(stringSet)
|
|
|
|
|
|
|
|
aurUp, repoUp, err := upList(dt)
|
2017-08-01 16:43:20 +00:00
|
|
|
if err != nil {
|
2018-03-21 16:30:00 +00:00
|
|
|
return ignore, aurNames, err
|
2017-08-01 16:43:20 +00:00
|
|
|
} else if len(aurUp)+len(repoUp) == 0 {
|
2018-03-21 16:30:00 +00:00
|
|
|
return ignore, aurNames, err
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
sort.Sort(repoUp)
|
2018-03-20 22:34:06 +00:00
|
|
|
sort.Sort(aurUp)
|
2018-03-02 04:54:38 +00:00
|
|
|
fmt.Println(bold(blue("::")), len(aurUp)+len(repoUp), bold("Packages to upgrade."))
|
2018-01-16 10:18:36 +00:00
|
|
|
repoUp.Print(len(aurUp) + 1)
|
|
|
|
aurUp.Print(1)
|
2017-08-01 16:43:20 +00:00
|
|
|
|
2018-03-09 03:41:45 +00:00
|
|
|
if config.NoConfirm {
|
|
|
|
for _, up := range aurUp {
|
|
|
|
aurNames.set(up.Name)
|
|
|
|
}
|
2018-03-21 16:30:00 +00:00
|
|
|
return ignore, aurNames, nil
|
2018-03-09 03:41:45 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 22:11:30 +00:00
|
|
|
fmt.Println(bold(green(arrow + " Packages to not upgrade (eg: 1 2 3, 1-3, ^4 or repo name)")))
|
2018-03-09 03:41:45 +00:00
|
|
|
fmt.Print(bold(green(arrow + " ")))
|
|
|
|
reader := bufio.NewReader(os.Stdin)
|
|
|
|
|
|
|
|
numberBuf, overflow, err := reader.ReadLine()
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if overflow {
|
|
|
|
return nil, nil, fmt.Errorf("Input too long")
|
|
|
|
}
|
|
|
|
|
|
|
|
//upgrade menu asks you which packages to NOT upgrade so in this case
|
|
|
|
//include and exclude are kind of swaped
|
|
|
|
//include, exclude, other := parseNumberMenu(string(numberBuf))
|
|
|
|
include, exclude, otherInclude, otherExclude := parseNumberMenu(string(numberBuf))
|
2017-08-01 16:43:20 +00:00
|
|
|
|
2018-03-09 03:41:45 +00:00
|
|
|
isInclude := len(exclude) == 0 && len(otherExclude) == 0
|
|
|
|
|
|
|
|
for i, pkg := range repoUp {
|
|
|
|
if isInclude && otherInclude.get(pkg.Repository) {
|
2018-03-21 16:30:00 +00:00
|
|
|
ignore.set(pkg.Name)
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
2017-08-02 21:56:45 +00:00
|
|
|
|
2018-03-09 03:41:45 +00:00
|
|
|
if isInclude && !include.get(len(repoUp)-i+len(aurUp)) {
|
2018-03-21 16:30:00 +00:00
|
|
|
continue
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
2018-03-09 03:41:45 +00:00
|
|
|
|
|
|
|
if !isInclude && (exclude.get(len(repoUp)-i+len(aurUp)) || otherExclude.get(pkg.Repository)) {
|
2018-03-21 16:30:00 +00:00
|
|
|
continue
|
2018-01-14 17:48:16 +00:00
|
|
|
}
|
2018-03-21 16:30:00 +00:00
|
|
|
|
|
|
|
ignore.set(pkg.Name)
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 03:41:45 +00:00
|
|
|
for i, pkg := range aurUp {
|
|
|
|
if isInclude && otherInclude.get(pkg.Repository) {
|
|
|
|
continue
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 03:41:45 +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
|
|
|
}
|
|
|
|
}
|
2018-01-20 22:37:10 +00:00
|
|
|
|
2018-03-21 16:30:00 +00:00
|
|
|
return ignore, aurNames, err
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|