yay/upgrade.go

404 lines
9 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 (
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 {
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
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 {
right = fmt.Sprintf("\x1b[31m%s\x1b[0m-%s", new.Version, new.Pkgrel)
2017-07-14 17:03:54 +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) {
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
}
2018-01-10 00:38:32 +00:00
func upDevel(remote []alpm.Package, packageC chan upgrade, done chan bool) {
for _, e := range savedInfo {
if e.needsUpdate() {
found := false
2018-01-10 00:38:32 +00:00
var pkg alpm.Package
for _, r := range remote {
if r.Name() == e.Package {
found = true
2018-01-10 00:38:32 +00:00
pkg = r
}
}
2018-01-10 00:38:32 +00:00
if found {
if pkg.ShouldIgnore() {
fmt.Printf("\x1b[33mwarning:\x1b[0m %s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), "git")
} else {
packageC <- upgrade{e.Package, "devel", e.SHA[0:6], "git"}
}
} else {
removeVCSPackage([]string{e.Package})
}
}
}
done <- true
}
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)
if config.Devel {
routines++
2018-01-10 00:38:32 +00:00
go upDevel(remote, packageC, done)
fmt.Println("\x1b[1;36;1m::\x1b[0m\x1b[1m Checking development packages...\x1b[0m")
}
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.
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() {
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) {
2018-01-10 00:38:32 +00:00
if local[i].ShouldIgnore() {
fmt.Printf("\x1b[33mwarning:\x1b[0m %s ignoring package upgrade (%s => %s)\n", local[i].Name(), local[i].Version(), qtemp[x].Version)
} else {
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:
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) {
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-07-14 17:03:54 +00:00
for _, pkg := range local {
newPkg := pkg.NewVersion(dbList)
2018-01-10 00:38:32 +00:00
if newPkg != nil {
if pkg.ShouldIgnore() {
fmt.Printf("\x1b[33mwarning:\x1b[0m %s ignoring package upgrade (%s => %s)\n", pkg.Name(), pkg.Version(), newPkg.Version())
} 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
//Contains returns wheter e is present in s
func containsInt(s []int, e int) bool {
2018-01-14 17:48:16 +00:00
for _, a := range s {
if a == e {
return true
}
}
return false
}
// RemoveIntListFromList removes all src's elements that are present in target
func removeIntListFromList(src, target []int) []int {
2018-01-14 17:48:16 +00:00
max := len(target)
for i := 0; i < max; i++ {
if containsInt(src, target[i]) {
2018-01-14 17:48:16 +00:00
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 {
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))
2018-01-16 10:18:36 +00:00
repoUp.Print(len(aurUp) + 1)
aurUp.Print(1)
2017-08-01 16:43:20 +00:00
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:]
}
var numbers []int
2017-08-02 21:56:45 +00:00
num, err := strconv.Atoi(numS)
if err != nil {
numbers, err = BuildRange(numS)
if err != nil {
continue
}
2017-08-02 21:56:45 +00:00
} else {
numbers = []int{num}
}
for _, target := range numbers {
2018-01-16 10:18:36 +00:00
if target > len(aurUp)+len(repoUp) || target <= 0 {
continue
2018-01-16 10:18:36 +00:00
} else if target <= len(aurUp) {
target = len(aurUp) - target
2018-01-14 17:48:16 +00:00
if negate {
excludeAur = append(excludeAur, target)
} else {
aurNums = append(aurNums, target)
}
} else {
2018-01-16 10:18:36 +00:00
target = len(aurUp) + len(repoUp) - target
2018-01-14 17:48:16 +00:00
if negate {
excludeRepo = append(excludeRepo, target)
} else {
repoNums = append(repoNums, target)
}
}
2017-08-02 21:56:45 +00:00
}
2017-08-01 16:43:20 +00:00
}
if len(repoNums) == 0 && len(aurNums) == 0 &&
(len(excludeRepo) > 0 || len(excludeAur) > 0) {
2018-01-14 17:48:16 +00:00
if len(repoUp) > 0 {
repoNums = BuildIntRange(0, len(repoUp)-1)
}
if len(aurUp) > 0 {
aurNums = BuildIntRange(0, len(aurUp)-1)
}
}
aurNums = removeIntListFromList(excludeAur, aurNums)
repoNums = removeIntListFromList(excludeRepo, repoNums)
2017-08-01 16:43:20 +00:00
}
New install algorithm I have replaced the old install and dependancy algorithms with a new design that attemps to be more pacaur like. Mostly in minimizing user input. Ask every thing first then do everything with no need for more user input. It is not yet fully complete but is finished enough so that it works, should not fail in most cases and provides a base for more contributors to help address the existing problems. The new install chain is as follows: Source info about the provided targets Fetch a list of all dependancies needed to install targets I put alot of effort into fetching the dependancy tree while making the least amount of aur requests as possible. I'm actually very happy with how it turned out and yay wil now resolve dependancies noticably faster than pacaur when there are many aur dependancies. Install repo targets by passing to pacman Print dependancy tree and ask to confirm Ask to clean build if directory already exists Download all pkgbuilds Ask to edit all pkgbuilds Ask to continue with the install Download the sources for each packagebuild Build and install every package using -s to get repo deps and -i to install Ask to remove make dependancies There are still a lot of things that need to be done for a fully working system. Here are the problems I found with this system, either new or existing: Formating I am not so good at formatting myself, I thought best to leave it until last so I could get feedback on how it should look and help implementing it. Dependancy tree The dependancy tree is usually correct although I have noticed times where it doesnt detect all the dependancies that it should. I have only noticed this when there are circular dependancies so i think this might be the cause. It's not a big deal currently because makepkg -i installed repo deps for us which handles the repo deps for us and will get the correct ones. So yay might not list all the dependancies. but they will get installed so I consider this a visual bug. I have yet to see any circular dependancies in the AUR so I can not say what will happend but I#m guessing that it will break. Versioned packages/dependencies Targets and dependancies with version constriants such as 'linux>=4.1' will not be checked on the aur side of things but will be checked on the repo side. Ignorepkg/Ignoregroup Currently I do not handle this in any way but it shouldn't be too hard to implement. Conflict checking This is not currently implemented either Split Paclages Split packages are not Handles properly. If we only specify one package so install from a split package makepkg -i ends up installing them all anyway. If we specify more than one (n) package it will actually build the package base n times and reinstall every split package n times. Makepkg To get things working I decided to keep using the makepkg -i method. I plan to eventually replace this with a pacman -U based method. This should allow passing args such as --dbpath and --config to aur packages aswell as help solve some problems such as the split packages. Clean build I plan to improve the clean build choice to be a little more smart and instead of check if the directory exists, check if the package is already build and if so skip the build all together.
2018-01-17 21:48:23 +00:00
arguments := cmdArgs.copy()
arguments.delArg("u", "sysupgrade")
arguments.delArg("y", "refresh")
New install algorithm I have replaced the old install and dependancy algorithms with a new design that attemps to be more pacaur like. Mostly in minimizing user input. Ask every thing first then do everything with no need for more user input. It is not yet fully complete but is finished enough so that it works, should not fail in most cases and provides a base for more contributors to help address the existing problems. The new install chain is as follows: Source info about the provided targets Fetch a list of all dependancies needed to install targets I put alot of effort into fetching the dependancy tree while making the least amount of aur requests as possible. I'm actually very happy with how it turned out and yay wil now resolve dependancies noticably faster than pacaur when there are many aur dependancies. Install repo targets by passing to pacman Print dependancy tree and ask to confirm Ask to clean build if directory already exists Download all pkgbuilds Ask to edit all pkgbuilds Ask to continue with the install Download the sources for each packagebuild Build and install every package using -s to get repo deps and -i to install Ask to remove make dependancies There are still a lot of things that need to be done for a fully working system. Here are the problems I found with this system, either new or existing: Formating I am not so good at formatting myself, I thought best to leave it until last so I could get feedback on how it should look and help implementing it. Dependancy tree The dependancy tree is usually correct although I have noticed times where it doesnt detect all the dependancies that it should. I have only noticed this when there are circular dependancies so i think this might be the cause. It's not a big deal currently because makepkg -i installed repo deps for us which handles the repo deps for us and will get the correct ones. So yay might not list all the dependancies. but they will get installed so I consider this a visual bug. I have yet to see any circular dependancies in the AUR so I can not say what will happend but I#m guessing that it will break. Versioned packages/dependencies Targets and dependancies with version constriants such as 'linux>=4.1' will not be checked on the aur side of things but will be checked on the repo side. Ignorepkg/Ignoregroup Currently I do not handle this in any way but it shouldn't be too hard to implement. Conflict checking This is not currently implemented either Split Paclages Split packages are not Handles properly. If we only specify one package so install from a split package makepkg -i ends up installing them all anyway. If we specify more than one (n) package it will actually build the package base n times and reinstall every split package n times. Makepkg To get things working I decided to keep using the makepkg -i method. I plan to eventually replace this with a pacman -U based method. This should allow passing args such as --dbpath and --config to aur packages aswell as help solve some problems such as the split packages. Clean build I plan to improve the clean build choice to be a little more smart and instead of check if the directory exists, check if the package is already build and if so skip the build all together.
2018-01-17 21:48:23 +00:00
var repoNames []string
var aurNames []string
2017-08-01 16:43:20 +00:00
if len(repoUp) != 0 {
repoloop:
for i, k := range repoUp {
for _, j := range repoNums {
if j == i {
continue repoloop
}
}
repoNames = append(repoNames, k.Name)
}
}
if len(aurUp) != 0 {
aurloop:
for i, k := range aurUp {
for _, j := range aurNums {
if j == i {
continue aurloop
}
}
aurNames = append(aurNames, k.Name)
}
}
New install algorithm I have replaced the old install and dependancy algorithms with a new design that attemps to be more pacaur like. Mostly in minimizing user input. Ask every thing first then do everything with no need for more user input. It is not yet fully complete but is finished enough so that it works, should not fail in most cases and provides a base for more contributors to help address the existing problems. The new install chain is as follows: Source info about the provided targets Fetch a list of all dependancies needed to install targets I put alot of effort into fetching the dependancy tree while making the least amount of aur requests as possible. I'm actually very happy with how it turned out and yay wil now resolve dependancies noticably faster than pacaur when there are many aur dependancies. Install repo targets by passing to pacman Print dependancy tree and ask to confirm Ask to clean build if directory already exists Download all pkgbuilds Ask to edit all pkgbuilds Ask to continue with the install Download the sources for each packagebuild Build and install every package using -s to get repo deps and -i to install Ask to remove make dependancies There are still a lot of things that need to be done for a fully working system. Here are the problems I found with this system, either new or existing: Formating I am not so good at formatting myself, I thought best to leave it until last so I could get feedback on how it should look and help implementing it. Dependancy tree The dependancy tree is usually correct although I have noticed times where it doesnt detect all the dependancies that it should. I have only noticed this when there are circular dependancies so i think this might be the cause. It's not a big deal currently because makepkg -i installed repo deps for us which handles the repo deps for us and will get the correct ones. So yay might not list all the dependancies. but they will get installed so I consider this a visual bug. I have yet to see any circular dependancies in the AUR so I can not say what will happend but I#m guessing that it will break. Versioned packages/dependencies Targets and dependancies with version constriants such as 'linux>=4.1' will not be checked on the aur side of things but will be checked on the repo side. Ignorepkg/Ignoregroup Currently I do not handle this in any way but it shouldn't be too hard to implement. Conflict checking This is not currently implemented either Split Paclages Split packages are not Handles properly. If we only specify one package so install from a split package makepkg -i ends up installing them all anyway. If we specify more than one (n) package it will actually build the package base n times and reinstall every split package n times. Makepkg To get things working I decided to keep using the makepkg -i method. I plan to eventually replace this with a pacman -U based method. This should allow passing args such as --dbpath and --config to aur packages aswell as help solve some problems such as the split packages. Clean build I plan to improve the clean build choice to be a little more smart and instead of check if the directory exists, check if the package is already build and if so skip the build all together.
2018-01-17 21:48:23 +00:00
arguments.addTarget(repoNames...)
arguments.addTarget(aurNames...)
err = install(arguments)
return err
2017-08-01 16:43:20 +00:00
}