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"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
2017-07-17 22:44:46 +00:00
|
|
|
"unicode"
|
2017-07-14 17:03:54 +00:00
|
|
|
|
|
|
|
alpm "github.com/jguer/go-alpm"
|
|
|
|
rpc "github.com/mikkeloscar/aur"
|
|
|
|
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 {
|
|
|
|
iRunes := []rune(u[i].Repository)
|
|
|
|
jRunes := []rune(u[j].Repository)
|
2017-07-17 22:44:46 +00:00
|
|
|
|
|
|
|
max := len(iRunes)
|
|
|
|
if max > len(jRunes) {
|
|
|
|
max = len(jRunes)
|
|
|
|
}
|
|
|
|
|
|
|
|
for idx := 0; idx < max; idx++ {
|
|
|
|
ir := iRunes[idx]
|
|
|
|
jr := jRunes[idx]
|
|
|
|
|
|
|
|
lir := unicode.ToLower(ir)
|
|
|
|
ljr := unicode.ToLower(jr)
|
|
|
|
|
|
|
|
if lir != ljr {
|
|
|
|
return lir > ljr
|
|
|
|
}
|
|
|
|
|
|
|
|
// the lowercase runes are the same, so compare the original
|
|
|
|
if ir != jr {
|
|
|
|
return ir > jr
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// Print prints the details of the packages to upgrade.
|
2017-08-01 16:43:20 +00:00
|
|
|
func (u upSlice) Print(start int) {
|
2017-07-17 22:44:46 +00:00
|
|
|
for k, i := range u {
|
2017-12-30 22:02:27 +00:00
|
|
|
old, errOld := pkgb.NewCompleteVersion(i.LocalVersion)
|
|
|
|
new, errNew := pkgb.NewCompleteVersion(i.RemoteVersion)
|
|
|
|
var left, right string
|
2017-07-14 17:03:54 +00:00
|
|
|
|
|
|
|
f := func(name string) (color int) {
|
|
|
|
var hash = 5381
|
|
|
|
for i := 0; i < len(name); i++ {
|
|
|
|
hash = int(name[i]) + ((hash << 5) + (hash))
|
|
|
|
}
|
2017-07-19 09:32:32 +00:00
|
|
|
return hash%6 + 31
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
2017-07-17 22:44:46 +00:00
|
|
|
fmt.Printf("\x1b[33m%-2d\x1b[0m ", len(u)+start-k-1)
|
|
|
|
fmt.Printf("\x1b[1;%dm%s\x1b[0m/\x1b[1;39m%-25s\t\t\x1b[0m", f(i.Repository), i.Repository, i.Name)
|
2017-07-14 17:03:54 +00:00
|
|
|
|
2017-12-30 22:02:27 +00:00
|
|
|
if errOld != nil {
|
|
|
|
left = fmt.Sprintf("\x1b[31m%20s\x1b[0m", "Invalid Version")
|
|
|
|
} else {
|
|
|
|
left = fmt.Sprintf("\x1b[31m%18s\x1b[0m-%s", old.Version, old.Pkgrel)
|
|
|
|
}
|
|
|
|
|
|
|
|
if errNew != nil {
|
|
|
|
right = fmt.Sprintf("\x1b[31m%s\x1b[0m", "Invalid Version")
|
2017-07-14 17:03:54 +00:00
|
|
|
} else {
|
2017-12-30 22:02:27 +00:00
|
|
|
right = fmt.Sprintf("\x1b[31m%s\x1b[0m-%s", new.Version, new.Pkgrel)
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
2017-12-30 22:02:27 +00:00
|
|
|
fmt.Printf("%s -> %s\n", left, right)
|
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.
|
2017-08-01 16:43:20 +00:00
|
|
|
func upList() (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 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
repoC := make(chan upSlice)
|
|
|
|
aurC := make(chan upSlice)
|
2017-07-14 17:03:54 +00:00
|
|
|
errC := make(chan error)
|
|
|
|
|
2017-07-31 12:07:22 +00:00
|
|
|
fmt.Println("\x1b[1;36;1m::\x1b[0m\x1b[1m Searching databases for updates...\x1b[0m")
|
2017-07-14 17:03:54 +00:00
|
|
|
go func() {
|
2017-08-01 16:43:20 +00:00
|
|
|
repoUpList, err := upRepo(local)
|
2017-07-14 17:03:54 +00:00
|
|
|
errC <- err
|
|
|
|
repoC <- repoUpList
|
|
|
|
}()
|
|
|
|
|
2017-07-31 12:07:22 +00:00
|
|
|
fmt.Println("\x1b[1;36;1m::\x1b[0m\x1b[1m Searching AUR for updates...\x1b[0m")
|
2017-07-14 17:03:54 +00:00
|
|
|
go func() {
|
2017-08-01 16:43:20 +00:00
|
|
|
aurUpList, err := upAUR(remote, remoteNames)
|
2017-07-14 17:03:54 +00:00
|
|
|
errC <- err
|
|
|
|
aurC <- aurUpList
|
|
|
|
}()
|
|
|
|
|
|
|
|
var i = 0
|
|
|
|
loop:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case repoUp = <-repoC:
|
|
|
|
i++
|
|
|
|
case aurUp = <-aurC:
|
|
|
|
i++
|
|
|
|
case err := <-errC:
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
if i == 2 {
|
|
|
|
close(repoC)
|
|
|
|
close(aurC)
|
|
|
|
close(errC)
|
|
|
|
break loop
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-10-25 07:17:13 +00:00
|
|
|
func isIgnored(name string, groups []string, oldVersion string, newVersion string) bool {
|
2017-10-18 02:38:19 +00:00
|
|
|
for _, p := range alpmConf.IgnorePkg {
|
2017-10-25 07:17:13 +00:00
|
|
|
if p == name {
|
|
|
|
fmt.Printf("\x1b[33mwarning:\x1b[0m %s (ignored pkg) ignoring upgrade (%s -> %s)\n", name, oldVersion, newVersion)
|
2017-10-18 02:38:19 +00:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, g := range alpmConf.IgnoreGroup {
|
2017-10-25 07:17:13 +00:00
|
|
|
for _, pg := range groups {
|
2017-10-18 02:38:19 +00:00
|
|
|
if g == pg {
|
2017-10-25 07:17:13 +00:00
|
|
|
fmt.Printf("\x1b[33mwarning:\x1b[0m %s (ignored pkg) ignoring upgrade (%s -> %s)\n", name, oldVersion, newVersion)
|
2017-10-18 02:38:19 +00:00
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-10-18 05:46:21 +00:00
|
|
|
func upDevel(remoteNames []string, packageC chan upgrade, done chan bool) {
|
2017-10-18 02:12:16 +00:00
|
|
|
for _, e := range savedInfo {
|
|
|
|
if e.needsUpdate() {
|
2017-10-18 05:46:21 +00:00
|
|
|
found := false
|
|
|
|
for _, r := range remoteNames {
|
|
|
|
if r == e.Package {
|
|
|
|
found = true
|
|
|
|
}
|
|
|
|
}
|
2017-10-25 07:17:13 +00:00
|
|
|
if found && !isIgnored(e.Package, nil, e.SHA[0:6], "git") {
|
2017-10-18 05:46:21 +00:00
|
|
|
packageC <- upgrade{e.Package, "devel", e.SHA[0:6], "git"}
|
2017-10-18 02:12:16 +00:00
|
|
|
} else {
|
|
|
|
removeVCSPackage([]string{e.Package})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-10-18 05:46:21 +00:00
|
|
|
done <- true
|
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.
|
2017-08-01 16:43:20 +00:00
|
|
|
func upAUR(remote []alpm.Package, remoteNames []string) (toUpgrade upSlice, err error) {
|
2017-07-14 17:03:54 +00:00
|
|
|
var j int
|
|
|
|
var routines int
|
|
|
|
var routineDone int
|
|
|
|
|
2017-08-01 16:43:20 +00:00
|
|
|
packageC := make(chan upgrade)
|
2017-07-14 17:03:54 +00:00
|
|
|
done := make(chan bool)
|
|
|
|
|
2017-10-18 02:12:16 +00:00
|
|
|
if config.Devel {
|
2017-10-18 05:46:21 +00:00
|
|
|
routines++
|
|
|
|
go upDevel(remoteNames, packageC, done)
|
|
|
|
fmt.Println("\x1b[1;36;1m::\x1b[0m\x1b[1m Checking development packages...\x1b[0m")
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
|
2017-07-14 17:03:54 +00:00
|
|
|
for i := len(remote); i != 0; i = j {
|
|
|
|
//Split requests so AUR RPC doesn't get mad at us.
|
2017-08-02 17:24:03 +00:00
|
|
|
j = i - config.RequestSplitN
|
2017-07-14 17:03:54 +00:00
|
|
|
if j < 0 {
|
|
|
|
j = 0
|
|
|
|
}
|
|
|
|
|
|
|
|
routines++
|
|
|
|
go func(local []alpm.Package, remote []string) {
|
2017-10-25 05:42:03 +00:00
|
|
|
qtemp, err := rpc.Info(remote)
|
2017-07-14 17:03:54 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
done <- true
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// For each item in query: Search equivalent in foreign.
|
|
|
|
// We assume they're ordered and are returned ordered
|
|
|
|
// and will only be missing if they don't exist in AUR.
|
|
|
|
max := len(qtemp) - 1
|
|
|
|
var missing, x int
|
|
|
|
|
|
|
|
for i := range local {
|
|
|
|
x = i - missing
|
|
|
|
if x > max {
|
|
|
|
break
|
|
|
|
} else if qtemp[x].Name == local[i].Name() {
|
2017-08-02 17:24:03 +00:00
|
|
|
if (config.TimeUpdate && (int64(qtemp[x].LastModified) > local[i].BuildDate().Unix())) ||
|
2017-07-14 17:03:54 +00:00
|
|
|
(alpm.VerCmp(local[i].Version(), qtemp[x].Version) < 0) {
|
2017-10-25 07:17:13 +00:00
|
|
|
if !isIgnored(local[i].Name(), local[i].Groups().Slice(), local[i].Version(), qtemp[x].Version) {
|
|
|
|
packageC <- upgrade{qtemp[x].Name, "aur", local[i].Version(), qtemp[x].Version}
|
|
|
|
}
|
2017-07-14 17:03:54 +00:00
|
|
|
}
|
|
|
|
continue
|
|
|
|
} else {
|
|
|
|
missing++
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done <- true
|
|
|
|
}(remote[j:i], remoteNames[j:i])
|
|
|
|
}
|
|
|
|
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case pkg := <-packageC:
|
2017-10-30 12:36:50 +00:00
|
|
|
for _, w := range toUpgrade {
|
|
|
|
if w.Name == pkg.Name {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
}
|
2017-07-14 17:03:54 +00:00
|
|
|
toUpgrade = append(toUpgrade, pkg)
|
|
|
|
case <-done:
|
|
|
|
routineDone++
|
|
|
|
if routineDone == routines {
|
|
|
|
err = nil
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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)
|
2017-07-18 08:37:12 +00:00
|
|
|
|
2017-10-25 07:17:13 +00:00
|
|
|
if newPkg != nil && !isIgnored(pkg.Name(), pkg.Groups().Slice(), pkg.Version(), newPkg.Version()) {
|
2017-08-01 16:43:20 +00:00
|
|
|
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
|
|
|
|
2018-01-14 17:48:16 +00:00
|
|
|
func contains(s []int, e int) bool {
|
|
|
|
for _, a := range s {
|
|
|
|
if a == e {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func removeListFromList(src, target []int) []int {
|
|
|
|
max := len(target)
|
|
|
|
for i := 0; i < max; i++ {
|
|
|
|
if contains(src, target[i]) {
|
|
|
|
target = append(target[:i], target[i+1:]...)
|
|
|
|
max--
|
|
|
|
i--
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return target
|
|
|
|
}
|
|
|
|
|
2017-10-14 16:11:47 +00:00
|
|
|
// upgradePkgs handles updating the cache and installing updates.
|
2017-08-01 16:43:20 +00:00
|
|
|
func upgradePkgs(flags []string) error {
|
|
|
|
aurUp, repoUp, err := upList()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else if len(aurUp)+len(repoUp) == 0 {
|
2018-01-14 16:04:15 +00:00
|
|
|
fmt.Println("\nThere is nothing to do")
|
2017-08-01 16:43:20 +00:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-08-02 21:56:45 +00:00
|
|
|
var repoNums []int
|
|
|
|
var aurNums []int
|
2017-08-01 16:43:20 +00:00
|
|
|
sort.Sort(repoUp)
|
|
|
|
fmt.Printf("\x1b[1;34;1m:: \x1b[0m\x1b[1m%d Packages to upgrade.\x1b[0m\n", len(aurUp)+len(repoUp))
|
|
|
|
repoUp.Print(len(aurUp))
|
|
|
|
aurUp.Print(0)
|
|
|
|
|
2017-08-07 09:18:19 +00:00
|
|
|
if !config.NoConfirm {
|
2017-08-02 21:56:45 +00:00
|
|
|
fmt.Print("\x1b[32mEnter packages you don't want to upgrade.\x1b[0m\nNumbers: ")
|
|
|
|
reader := bufio.NewReader(os.Stdin)
|
2017-08-01 16:43:20 +00:00
|
|
|
|
2017-08-02 21:56:45 +00:00
|
|
|
numberBuf, overflow, err := reader.ReadLine()
|
|
|
|
if err != nil || overflow {
|
|
|
|
fmt.Println(err)
|
|
|
|
return err
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
2017-08-02 21:56:45 +00:00
|
|
|
|
|
|
|
result := strings.Fields(string(numberBuf))
|
2018-01-14 17:48:16 +00:00
|
|
|
excludeAur := make([]int, 0)
|
|
|
|
excludeRepo := make([]int, 0)
|
2017-08-02 21:56:45 +00:00
|
|
|
for _, numS := range result {
|
2018-01-14 17:48:16 +00:00
|
|
|
negate := numS[0] == '^'
|
|
|
|
if negate {
|
|
|
|
numS = numS[1:]
|
|
|
|
}
|
2018-01-14 16:04:15 +00:00
|
|
|
var numbers []int
|
2017-08-02 21:56:45 +00:00
|
|
|
num, err := strconv.Atoi(numS)
|
|
|
|
if err != nil {
|
2018-01-14 16:04:15 +00:00
|
|
|
numbers, err = BuildRange(numS)
|
|
|
|
if err != nil {
|
|
|
|
continue
|
|
|
|
}
|
2017-08-02 21:56:45 +00:00
|
|
|
} else {
|
2018-01-14 16:04:15 +00:00
|
|
|
numbers = []int{num}
|
|
|
|
}
|
|
|
|
for _, target := range numbers {
|
|
|
|
if target > len(aurUp)+len(repoUp)-1 || target < 0 {
|
|
|
|
continue
|
|
|
|
} else if target < len(aurUp) {
|
|
|
|
target = len(aurUp) - target - 1
|
2018-01-14 17:48:16 +00:00
|
|
|
if negate {
|
|
|
|
excludeAur = append(excludeAur, target)
|
|
|
|
} else {
|
|
|
|
aurNums = append(aurNums, target)
|
|
|
|
}
|
2018-01-14 16:04:15 +00:00
|
|
|
} else {
|
|
|
|
target = len(aurUp) + len(repoUp) - target - 1
|
2018-01-14 17:48:16 +00:00
|
|
|
if negate {
|
|
|
|
excludeRepo = append(excludeRepo, target)
|
|
|
|
} else {
|
|
|
|
repoNums = append(repoNums, target)
|
|
|
|
}
|
2018-01-14 16:04:15 +00:00
|
|
|
}
|
2017-08-02 21:56:45 +00:00
|
|
|
}
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
2018-01-14 17:48:16 +00:00
|
|
|
if len(repoNums) == 0 && len(aurNums) == 0 {
|
|
|
|
if len(repoUp) > 0 {
|
|
|
|
repoNums = BuildIntRange(0, len(repoUp)-1)
|
|
|
|
}
|
|
|
|
if len(aurUp) > 0 {
|
|
|
|
aurNums = BuildIntRange(0, len(aurUp)-1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
aurNums = removeListFromList(excludeAur, aurNums)
|
|
|
|
repoNums = removeListFromList(excludeRepo, repoNums)
|
|
|
|
fmt.Println(repoNums, aurNums, excludeAur, excludeRepo)
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if len(repoUp) != 0 {
|
|
|
|
var repoNames []string
|
|
|
|
repoloop:
|
|
|
|
for i, k := range repoUp {
|
|
|
|
for _, j := range repoNums {
|
|
|
|
if j == i {
|
|
|
|
continue repoloop
|
|
|
|
}
|
|
|
|
}
|
|
|
|
repoNames = append(repoNames, k.Name)
|
|
|
|
}
|
|
|
|
|
2017-08-07 09:18:19 +00:00
|
|
|
err := passToPacman("-S", repoNames, append(flags, "--noconfirm"))
|
2017-08-01 16:43:20 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println("Error upgrading repo packages.")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(aurUp) != 0 {
|
|
|
|
var aurNames []string
|
|
|
|
aurloop:
|
|
|
|
for i, k := range aurUp {
|
|
|
|
for _, j := range aurNums {
|
|
|
|
if j == i {
|
|
|
|
continue aurloop
|
|
|
|
}
|
|
|
|
}
|
|
|
|
aurNames = append(aurNames, k.Name)
|
|
|
|
}
|
2017-08-04 09:26:53 +00:00
|
|
|
aurInstall(aurNames, flags)
|
2017-08-01 16:43:20 +00:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|