2017-04-29 17:12:12 +00:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
2018-02-28 17:39:57 +00:00
|
|
|
"bytes"
|
2017-08-02 17:24:03 +00:00
|
|
|
"encoding/json"
|
2017-04-29 17:12:12 +00:00
|
|
|
"fmt"
|
|
|
|
"os"
|
2018-01-03 19:01:34 +00:00
|
|
|
"os/exec"
|
2017-10-16 14:38:51 +00:00
|
|
|
"path/filepath"
|
2017-04-29 17:12:12 +00:00
|
|
|
"strconv"
|
|
|
|
"strings"
|
2018-02-13 18:20:15 +00:00
|
|
|
"time"
|
2018-03-21 05:34:54 +00:00
|
|
|
|
|
|
|
alpm "github.com/jguer/go-alpm"
|
2017-04-29 17:12:12 +00:00
|
|
|
)
|
|
|
|
|
2018-01-14 19:17:15 +00:00
|
|
|
var cmdArgs = makeArguments()
|
2018-01-04 08:13:47 +00:00
|
|
|
|
2017-04-29 17:12:12 +00:00
|
|
|
func usage() {
|
2018-01-03 04:55:47 +00:00
|
|
|
fmt.Println(`Usage:
|
|
|
|
yay <operation> [...]
|
|
|
|
yay <package(s)>
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-03 04:55:47 +00:00
|
|
|
operations:
|
|
|
|
yay {-h --help}
|
|
|
|
yay {-V --version}
|
|
|
|
yay {-D --database} <options> <package(s)>
|
|
|
|
yay {-F --files} [options] [package(s)]
|
|
|
|
yay {-Q --query} [options] [package(s)]
|
|
|
|
yay {-R --remove} [options] <package(s)>
|
|
|
|
yay {-S --sync} [options] [package(s)]
|
|
|
|
yay {-T --deptest} [options] [package(s)]
|
|
|
|
yay {-U --upgrade} [options] <file(s)>
|
2017-10-19 02:30:37 +00:00
|
|
|
|
2018-01-03 04:55:47 +00:00
|
|
|
New operations:
|
|
|
|
yay {-Y --yay} [options] [package(s)]
|
2018-01-31 10:25:46 +00:00
|
|
|
yay {-P --print} [options]
|
2018-01-03 04:55:47 +00:00
|
|
|
yay {-G --getpkgbuild} [package(s)]
|
2017-10-19 02:30:37 +00:00
|
|
|
|
2018-01-03 04:55:47 +00:00
|
|
|
Permanent configuration options:
|
2018-03-07 22:37:44 +00:00
|
|
|
--save Causes the following options to be saved back to the
|
|
|
|
config file when used
|
|
|
|
|
2018-03-08 01:36:06 +00:00
|
|
|
--builddir <dir> Directory to use for building AUR Packages
|
|
|
|
--editor <file> Editor to use when editing PKGBUILDs
|
|
|
|
--makepkg <file> makepkg command to use
|
|
|
|
--pacman <file> pacman command to use
|
|
|
|
--tar <file> bsdtar command to use
|
|
|
|
--git <file> git command to use
|
2018-03-17 20:40:24 +00:00
|
|
|
--gpg <file> gpg command to use
|
2018-03-08 01:36:06 +00:00
|
|
|
--config <file> pacman.conf file to use
|
|
|
|
|
|
|
|
--requestsplitn <n> Max amount of packages to query per AUR request
|
|
|
|
|
2018-01-31 21:04:21 +00:00
|
|
|
--topdown Shows repository's packages first and then AUR's
|
|
|
|
--bottomup Shows AUR's packages first and then repository's
|
2018-02-28 22:48:56 +00:00
|
|
|
--devel Check development packages during sysupgrade
|
|
|
|
--nodevel Do not check development packages
|
|
|
|
--afterclean Remove package sources after successful install
|
|
|
|
--noafterclean Do not remove package sources after successful build
|
|
|
|
--timeupdate Check package's AUR page for changes during sysupgrade
|
|
|
|
--notimeupdate Do not checking of AUR page changes
|
2018-03-07 21:32:55 +00:00
|
|
|
--redownload Always download pkgbuilds of targets
|
|
|
|
--redownloadall Always download pkgbuilds of all AUR packages
|
2018-03-06 15:17:55 +00:00
|
|
|
--noredownload Skip pkgbuild download if in cache and up to date
|
2018-03-14 02:33:40 +00:00
|
|
|
--rebuild Always build target packages
|
|
|
|
--rebuildall Always build all AUR packages
|
2018-03-17 20:40:24 +00:00
|
|
|
--rebuildtree Always build all AUR packages even if installed
|
2018-03-14 02:33:40 +00:00
|
|
|
--norebuild Skip package build if in cache and up to date
|
2018-03-08 01:36:06 +00:00
|
|
|
--mflags <flags> Pass arguments to makepkg
|
2018-03-17 20:40:24 +00:00
|
|
|
--gpgflags <flags> Pass arguments to gpg
|
2018-03-11 21:19:05 +00:00
|
|
|
--sudoloop Loop sudo calls in the background to avoid timeout
|
|
|
|
--nosudoloop Do not loop sudo calls in the background
|
2017-12-04 02:39:23 +00:00
|
|
|
|
2018-01-31 10:25:46 +00:00
|
|
|
Print specific options:
|
|
|
|
-c --complete Used for completions
|
2018-02-20 15:08:29 +00:00
|
|
|
-d --defaultconfig Print default yay configuration
|
2018-02-20 15:12:07 +00:00
|
|
|
-g --config Print current yay configuration
|
2018-01-31 10:25:46 +00:00
|
|
|
-n --numberupgrades Print number of updates
|
|
|
|
-s --stats Display system package statistics
|
|
|
|
-u --upgrades Print update list
|
|
|
|
|
2018-01-03 04:55:47 +00:00
|
|
|
Yay specific options:
|
2018-01-31 10:25:46 +00:00
|
|
|
-c --clean Remove unneeded dependencies
|
2018-02-28 22:48:56 +00:00
|
|
|
--gendb Generates development package DB used for updating
|
2018-01-03 04:55:47 +00:00
|
|
|
|
2018-02-27 03:41:39 +00:00
|
|
|
If no operation is provided -Y will be assumed`)
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-03-07 05:20:10 +00:00
|
|
|
func initPaths() {
|
2017-10-18 02:12:16 +00:00
|
|
|
if configHome = os.Getenv("XDG_CONFIG_HOME"); configHome != "" {
|
2017-10-19 02:30:37 +00:00
|
|
|
if info, err := os.Stat(configHome); err == nil && info.IsDir() {
|
2017-10-18 02:12:16 +00:00
|
|
|
configHome = configHome + "/yay"
|
2017-10-16 14:38:51 +00:00
|
|
|
} else {
|
2017-10-18 02:12:16 +00:00
|
|
|
configHome = os.Getenv("HOME") + "/.config/yay"
|
2017-10-16 14:38:51 +00:00
|
|
|
}
|
|
|
|
} else {
|
2017-10-18 02:12:16 +00:00
|
|
|
configHome = os.Getenv("HOME") + "/.config/yay"
|
2017-10-16 14:38:51 +00:00
|
|
|
}
|
2017-08-02 17:24:03 +00:00
|
|
|
|
2017-10-18 02:12:16 +00:00
|
|
|
if cacheHome = os.Getenv("XDG_CACHE_HOME"); cacheHome != "" {
|
2017-10-19 02:30:37 +00:00
|
|
|
if info, err := os.Stat(cacheHome); err == nil && info.IsDir() {
|
2017-10-18 02:12:16 +00:00
|
|
|
cacheHome = cacheHome + "/yay"
|
|
|
|
} else {
|
|
|
|
cacheHome = os.Getenv("HOME") + "/.cache/yay"
|
|
|
|
}
|
|
|
|
} else {
|
2017-10-19 02:30:37 +00:00
|
|
|
cacheHome = os.Getenv("HOME") + "/.cache/yay"
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
|
2018-03-05 23:53:03 +00:00
|
|
|
configFile = configHome + "/" + configFileName
|
|
|
|
vcsFile = cacheHome + "/" + vcsFileName
|
|
|
|
completionFile = cacheHome + "/" + completionFilePrefix
|
2018-03-07 05:20:10 +00:00
|
|
|
}
|
2017-10-18 02:12:16 +00:00
|
|
|
|
2018-03-07 05:20:10 +00:00
|
|
|
func initConfig() (err error) {
|
2018-03-07 16:26:15 +00:00
|
|
|
defaultSettings(&config)
|
|
|
|
|
2017-10-18 02:12:16 +00:00
|
|
|
if _, err = os.Stat(configFile); os.IsNotExist(err) {
|
2017-10-19 02:56:19 +00:00
|
|
|
err = os.MkdirAll(filepath.Dir(configFile), 0755)
|
2017-10-16 14:38:51 +00:00
|
|
|
if err != nil {
|
2018-01-14 19:17:15 +00:00
|
|
|
err = fmt.Errorf("Unable to create config directory:\n%s\n"+
|
|
|
|
"The error was:\n%s", filepath.Dir(configFile), err)
|
2018-01-04 21:21:39 +00:00
|
|
|
return
|
2017-10-16 14:38:51 +00:00
|
|
|
}
|
2017-08-02 17:24:03 +00:00
|
|
|
// Save the default config if nothing is found
|
|
|
|
config.saveConfig()
|
|
|
|
} else {
|
2017-12-04 06:24:20 +00:00
|
|
|
cfile, errf := os.OpenFile(configFile, os.O_RDWR|os.O_CREATE, 0644)
|
|
|
|
if errf != nil {
|
2018-01-14 19:17:15 +00:00
|
|
|
fmt.Printf("Error reading config: %s\n", err)
|
2017-08-02 17:24:03 +00:00
|
|
|
} else {
|
2017-10-19 05:59:26 +00:00
|
|
|
defer cfile.Close()
|
|
|
|
decoder := json.NewDecoder(cfile)
|
2017-08-02 17:24:03 +00:00
|
|
|
err = decoder.Decode(&config)
|
|
|
|
if err != nil {
|
2018-01-14 15:15:32 +00:00
|
|
|
fmt.Println("Loading default Settings.\nError reading config:",
|
|
|
|
err)
|
2017-08-02 17:24:03 +00:00
|
|
|
defaultSettings(&config)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-07 05:20:10 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func initVCS() (err error) {
|
|
|
|
if _, err = os.Stat(vcsFile); os.IsNotExist(err) {
|
|
|
|
err = os.MkdirAll(filepath.Dir(vcsFile), 0755)
|
|
|
|
if err != nil {
|
|
|
|
err = fmt.Errorf("Unable to create vcs directory:\n%s\n"+
|
|
|
|
"The error was:\n%s", filepath.Dir(configFile), err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
vfile, err := os.OpenFile(vcsFile, os.O_RDONLY|os.O_CREATE, 0644)
|
|
|
|
if err == nil {
|
|
|
|
defer vfile.Close()
|
|
|
|
decoder := json.NewDecoder(vfile)
|
|
|
|
_ = decoder.Decode(&savedInfo)
|
|
|
|
}
|
2017-08-02 17:24:03 +00:00
|
|
|
}
|
2017-10-18 02:12:16 +00:00
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
return
|
|
|
|
}
|
2017-10-18 02:12:16 +00:00
|
|
|
|
2018-01-14 17:12:51 +00:00
|
|
|
func initAlpm() (err error) {
|
2018-01-04 21:21:39 +00:00
|
|
|
var value string
|
|
|
|
var exists bool
|
|
|
|
//var double bool
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("config")
|
|
|
|
if exists {
|
|
|
|
config.PacmanConf = value
|
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2017-10-18 05:46:21 +00:00
|
|
|
alpmConf, err = readAlpmConfig(config.PacmanConf)
|
2017-10-18 02:12:16 +00:00
|
|
|
if err != nil {
|
2018-01-04 21:21:39 +00:00
|
|
|
err = fmt.Errorf("Unable to read Pacman conf: %s", err)
|
|
|
|
return
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("dbpath", "b")
|
|
|
|
if exists {
|
|
|
|
alpmConf.DBPath = value
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
2017-04-29 17:12:12 +00:00
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("root", "r")
|
|
|
|
if exists {
|
|
|
|
alpmConf.RootDir = value
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("arch")
|
|
|
|
if exists {
|
|
|
|
alpmConf.Architecture = value
|
|
|
|
}
|
2017-04-29 17:12:12 +00:00
|
|
|
|
2018-03-12 23:25:09 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("ignore")
|
|
|
|
if exists {
|
|
|
|
alpmConf.IgnorePkg = append(alpmConf.IgnorePkg, strings.Split(value, ",")...)
|
|
|
|
}
|
|
|
|
|
|
|
|
value, _, exists = cmdArgs.getArg("ignoregroup")
|
|
|
|
if exists {
|
|
|
|
alpmConf.IgnoreGroup = append(alpmConf.IgnoreGroup, strings.Split(value, ",")...)
|
|
|
|
}
|
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
//TODO
|
|
|
|
//current system does not allow duplicate arguments
|
|
|
|
//but pacman allows multiple cachdirs to be passed
|
2018-01-31 21:04:21 +00:00
|
|
|
//for now only handle one cache dir
|
2018-01-04 21:21:39 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("cachdir")
|
|
|
|
if exists {
|
|
|
|
alpmConf.CacheDir = []string{value}
|
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("gpgdir")
|
|
|
|
if exists {
|
|
|
|
alpmConf.GPGDir = value
|
2017-10-18 02:12:16 +00:00
|
|
|
}
|
|
|
|
|
2017-10-18 05:46:21 +00:00
|
|
|
alpmHandle, err = alpmConf.CreateHandle()
|
2017-10-18 02:12:16 +00:00
|
|
|
if err != nil {
|
2018-01-14 19:17:15 +00:00
|
|
|
err = fmt.Errorf("Unable to CreateHandle: %s", err)
|
2018-01-04 21:21:39 +00:00
|
|
|
return
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-03-21 05:34:54 +00:00
|
|
|
value, _, exists = cmdArgs.getArg("color")
|
|
|
|
if value == "always" || value == "auto" {
|
|
|
|
useColor = true
|
|
|
|
} else if value == "never" {
|
|
|
|
useColor = false
|
|
|
|
} else {
|
|
|
|
useColor = alpmConf.Options&alpm.ConfColor > 0
|
|
|
|
}
|
|
|
|
|
2018-03-19 15:30:44 +00:00
|
|
|
alpmHandle.SetQuestionCallback(questionCallback)
|
2018-03-16 00:18:13 +00:00
|
|
|
|
2017-04-29 17:12:12 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func main() {
|
2018-01-14 17:12:51 +00:00
|
|
|
var status int
|
2018-01-04 21:21:39 +00:00
|
|
|
var err error
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-03-07 05:20:10 +00:00
|
|
|
if 0 == os.Geteuid() {
|
|
|
|
fmt.Println("Please avoid running yay as root/sudo.")
|
|
|
|
}
|
|
|
|
|
2018-01-14 17:12:51 +00:00
|
|
|
err = cmdArgs.parseCommandLine()
|
2017-04-29 17:12:12 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
2018-01-03 05:55:12 +00:00
|
|
|
status = 1
|
2018-01-04 21:21:39 +00:00
|
|
|
goto cleanup
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-03-07 05:20:10 +00:00
|
|
|
initPaths()
|
|
|
|
|
|
|
|
err = initConfig()
|
2017-12-31 15:18:12 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
2018-01-03 05:55:12 +00:00
|
|
|
status = 1
|
2018-01-04 21:21:39 +00:00
|
|
|
goto cleanup
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-03-07 05:20:10 +00:00
|
|
|
err = initVCS()
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
status = 1
|
|
|
|
goto cleanup
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
err = initAlpm()
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
status = 1
|
|
|
|
goto cleanup
|
2017-12-31 15:18:12 +00:00
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-31 17:41:13 +00:00
|
|
|
err = handleCmd()
|
2017-12-31 15:18:12 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
2018-01-03 05:55:12 +00:00
|
|
|
status = 1
|
2018-01-04 21:21:39 +00:00
|
|
|
goto cleanup
|
2017-12-31 15:18:12 +00:00
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
cleanup:
|
|
|
|
//cleanup
|
|
|
|
//from here on out dont exit if an error occurs
|
|
|
|
//if we fail to save the configuration
|
2018-01-31 21:04:21 +00:00
|
|
|
//at least continue on and try clean up other parts
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
if alpmHandle != nil {
|
|
|
|
err = alpmHandle.Release()
|
2017-07-24 09:32:11 +00:00
|
|
|
if err != nil {
|
2018-01-04 21:21:39 +00:00
|
|
|
fmt.Println(err)
|
|
|
|
status = 1
|
2017-07-24 09:32:11 +00:00
|
|
|
}
|
2018-01-04 21:21:39 +00:00
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-04 21:21:39 +00:00
|
|
|
os.Exit(status)
|
2017-12-31 15:18:12 +00:00
|
|
|
}
|
2017-04-29 17:12:12 +00:00
|
|
|
|
2018-02-16 18:02:56 +00:00
|
|
|
func sudoLoopBackground() {
|
|
|
|
updateSudo()
|
|
|
|
go sudoLoop()
|
|
|
|
}
|
|
|
|
|
2018-02-13 18:20:15 +00:00
|
|
|
func sudoLoop() {
|
2018-02-16 18:02:56 +00:00
|
|
|
for {
|
2018-02-20 14:24:48 +00:00
|
|
|
updateSudo()
|
2018-02-16 18:02:56 +00:00
|
|
|
time.Sleep(298 * time.Second)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func updateSudo() {
|
2018-02-13 18:20:15 +00:00
|
|
|
for {
|
|
|
|
cmd := exec.Command("sudo", "-v")
|
|
|
|
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
|
|
|
|
err := cmd.Run()
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
2018-02-16 18:02:56 +00:00
|
|
|
} else {
|
|
|
|
break
|
2018-02-13 18:20:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-31 17:41:13 +00:00
|
|
|
func handleCmd() (err error) {
|
2018-03-07 17:12:30 +00:00
|
|
|
for option, value := range cmdArgs.options {
|
|
|
|
if handleConfig(option, value) {
|
2018-01-31 17:41:13 +00:00
|
|
|
cmdArgs.delArg(option)
|
|
|
|
}
|
2018-01-04 08:13:47 +00:00
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-03-07 17:12:30 +00:00
|
|
|
for option, value := range cmdArgs.globals {
|
|
|
|
if handleConfig(option, value) {
|
2018-01-31 17:41:13 +00:00
|
|
|
cmdArgs.delArg(option)
|
|
|
|
}
|
2017-12-31 15:18:12 +00:00
|
|
|
}
|
2017-04-29 17:12:12 +00:00
|
|
|
|
2018-03-07 22:09:03 +00:00
|
|
|
if shouldSaveConfig {
|
|
|
|
config.saveConfig()
|
|
|
|
}
|
|
|
|
|
2018-02-20 13:20:33 +00:00
|
|
|
if config.SudoLoop && cmdArgs.needRoot() {
|
2018-02-16 18:02:56 +00:00
|
|
|
sudoLoopBackground()
|
2018-02-13 18:20:15 +00:00
|
|
|
}
|
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
switch cmdArgs.op {
|
2017-12-31 15:18:12 +00:00
|
|
|
case "V", "version":
|
2018-01-04 08:13:47 +00:00
|
|
|
handleVersion()
|
2017-12-31 15:18:12 +00:00
|
|
|
case "D", "database":
|
2018-03-21 04:50:54 +00:00
|
|
|
err = passToPacman(cmdArgs)
|
2017-12-31 15:18:12 +00:00
|
|
|
case "F", "files":
|
2018-03-21 04:50:54 +00:00
|
|
|
err = passToPacman(cmdArgs)
|
2017-12-31 15:18:12 +00:00
|
|
|
case "Q", "query":
|
2018-03-21 04:50:54 +00:00
|
|
|
err = handleQuery()
|
2017-12-31 15:18:12 +00:00
|
|
|
case "R", "remove":
|
2018-03-21 04:50:54 +00:00
|
|
|
err = handleRemove()
|
2017-12-31 15:18:12 +00:00
|
|
|
case "S", "sync":
|
2018-01-04 08:13:47 +00:00
|
|
|
err = handleSync()
|
2017-12-31 15:18:12 +00:00
|
|
|
case "T", "deptest":
|
2018-03-21 04:50:54 +00:00
|
|
|
err = passToPacman(cmdArgs)
|
2017-12-31 15:18:12 +00:00
|
|
|
case "U", "upgrade":
|
2018-03-21 04:50:54 +00:00
|
|
|
err =passToPacman(cmdArgs)
|
2018-01-03 19:17:57 +00:00
|
|
|
case "G", "getpkgbuild":
|
2018-01-04 08:13:47 +00:00
|
|
|
err = handleGetpkgbuild()
|
2018-01-20 17:48:40 +00:00
|
|
|
case "P", "print":
|
|
|
|
err = handlePrint()
|
2017-12-31 15:18:12 +00:00
|
|
|
case "Y", "--yay":
|
2018-01-04 08:13:47 +00:00
|
|
|
err = handleYay()
|
2017-12-31 15:18:12 +00:00
|
|
|
default:
|
|
|
|
//this means we allowed an op but not implement it
|
|
|
|
//if this happens it an error in the code and not the usage
|
|
|
|
err = fmt.Errorf("unhandled operation")
|
2018-01-04 08:13:47 +00:00
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2017-12-31 15:18:12 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-03-21 04:50:54 +00:00
|
|
|
func handleQuery() error {
|
|
|
|
var err error
|
|
|
|
|
|
|
|
if cmdArgs.existsArg("u", "upgrades") {
|
|
|
|
err = printUpdateList(cmdArgs)
|
|
|
|
} else {
|
|
|
|
err = passToPacman(cmdArgs)
|
|
|
|
}
|
|
|
|
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2017-12-31 15:18:12 +00:00
|
|
|
//this function should only set config options
|
|
|
|
//but currently still uses the switch left over from old code
|
2018-01-31 21:04:21 +00:00
|
|
|
//eventually this should be refactored out futher
|
2017-12-31 15:18:12 +00:00
|
|
|
//my current plan is to have yay specific operations in its own operator
|
|
|
|
//e.g. yay -Y --gendb
|
|
|
|
//e.g yay -Yg
|
2018-03-07 17:12:30 +00:00
|
|
|
func handleConfig(option, value string) bool {
|
2017-12-31 15:18:12 +00:00
|
|
|
switch option {
|
2018-03-07 22:09:03 +00:00
|
|
|
case "save":
|
|
|
|
shouldSaveConfig = true
|
2018-01-14 17:12:51 +00:00
|
|
|
case "afterclean":
|
|
|
|
config.CleanAfter = true
|
|
|
|
case "noafterclean":
|
|
|
|
config.CleanAfter = false
|
|
|
|
case "devel":
|
|
|
|
config.Devel = true
|
|
|
|
case "nodevel":
|
|
|
|
config.Devel = false
|
|
|
|
case "timeupdate":
|
|
|
|
config.TimeUpdate = true
|
|
|
|
case "notimeupdate":
|
|
|
|
config.TimeUpdate = false
|
|
|
|
case "topdown":
|
|
|
|
config.SortMode = TopDown
|
2018-01-31 17:41:13 +00:00
|
|
|
case "bottomup":
|
2018-01-14 17:12:51 +00:00
|
|
|
config.SortMode = BottomUp
|
|
|
|
case "noconfirm":
|
|
|
|
config.NoConfirm = true
|
2018-03-06 03:42:26 +00:00
|
|
|
case "redownload":
|
2018-03-07 21:32:55 +00:00
|
|
|
config.ReDownload = "yes"
|
|
|
|
case "redownloadall":
|
|
|
|
config.ReDownload = "all"
|
2018-03-06 03:42:26 +00:00
|
|
|
case "noredownload":
|
2018-03-07 21:32:55 +00:00
|
|
|
config.ReDownload = "no"
|
2018-03-14 01:48:33 +00:00
|
|
|
case "rebuild":
|
|
|
|
config.ReBuild = "yes"
|
|
|
|
case "rebuildall":
|
|
|
|
config.ReBuild = "all"
|
|
|
|
case "rebuildtree":
|
|
|
|
config.ReBuild = "tree"
|
|
|
|
case "norebuild":
|
|
|
|
config.ReBuild = "no"
|
2018-03-17 20:40:24 +00:00
|
|
|
case "gpgflags":
|
|
|
|
config.GpgFlags = value
|
2018-03-07 17:12:30 +00:00
|
|
|
case "mflags":
|
|
|
|
config.MFlags = value
|
2018-03-08 01:36:06 +00:00
|
|
|
case "builddir":
|
|
|
|
config.BuildDir = value
|
|
|
|
case "editor":
|
|
|
|
config.Editor = value
|
|
|
|
case "makepkg":
|
|
|
|
config.MakepkgBin = value
|
|
|
|
case "pacman":
|
|
|
|
config.PacmanBin = value
|
|
|
|
case "tar":
|
|
|
|
config.TarBin = value
|
|
|
|
case "git":
|
|
|
|
config.GitBin = value
|
2018-03-17 20:40:24 +00:00
|
|
|
case "gpg":
|
|
|
|
config.GpgBin = value
|
2018-03-08 01:36:06 +00:00
|
|
|
case "requestsplitn":
|
|
|
|
n, err := strconv.Atoi(value)
|
|
|
|
if err == nil && n > 0 {
|
|
|
|
config.RequestSplitN = n
|
|
|
|
}
|
2018-03-08 16:06:40 +00:00
|
|
|
case "sudoloop":
|
|
|
|
config.SudoLoop = true
|
|
|
|
case "nosudoloop":
|
|
|
|
config.SudoLoop = false
|
2018-01-14 17:12:51 +00:00
|
|
|
default:
|
2018-01-31 17:41:13 +00:00
|
|
|
return false
|
2018-01-14 17:12:51 +00:00
|
|
|
}
|
|
|
|
|
2018-01-31 17:41:13 +00:00
|
|
|
return true
|
2017-12-31 15:18:12 +00:00
|
|
|
}
|
2017-04-29 17:12:12 +00:00
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
func handleVersion() {
|
2018-01-03 04:55:47 +00:00
|
|
|
fmt.Printf("yay v%s\n", version)
|
|
|
|
}
|
|
|
|
|
2018-01-20 17:48:40 +00:00
|
|
|
func handlePrint() (err error) {
|
|
|
|
switch {
|
|
|
|
case cmdArgs.existsArg("d", "defaultconfig"):
|
2018-02-20 15:08:29 +00:00
|
|
|
var tmpConfig Configuration
|
|
|
|
defaultSettings(&tmpConfig)
|
|
|
|
fmt.Printf("%v", tmpConfig)
|
|
|
|
case cmdArgs.existsArg("g", "config"):
|
2018-02-20 14:24:48 +00:00
|
|
|
fmt.Printf("%v", config)
|
2018-01-20 17:48:40 +00:00
|
|
|
case cmdArgs.existsArg("n", "numberupgrades"):
|
2018-01-25 20:39:26 +00:00
|
|
|
err = printNumberOfUpdates()
|
2018-01-20 17:48:40 +00:00
|
|
|
case cmdArgs.existsArg("u", "upgrades"):
|
2018-03-21 04:50:54 +00:00
|
|
|
err = printUpdateList(cmdArgs)
|
2018-01-20 17:48:40 +00:00
|
|
|
case cmdArgs.existsArg("c", "complete"):
|
|
|
|
switch {
|
|
|
|
case cmdArgs.existsArg("f", "fish"):
|
|
|
|
complete("fish")
|
|
|
|
default:
|
|
|
|
complete("sh")
|
|
|
|
}
|
2018-01-20 18:39:53 +00:00
|
|
|
case cmdArgs.existsArg("s", "stats"):
|
|
|
|
err = localStatistics()
|
2018-01-20 17:48:40 +00:00
|
|
|
default:
|
2018-02-13 18:20:15 +00:00
|
|
|
err = nil
|
2018-01-20 17:48:40 +00:00
|
|
|
}
|
|
|
|
|
2018-02-13 18:20:15 +00:00
|
|
|
return err
|
2018-01-20 17:48:40 +00:00
|
|
|
}
|
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
func handleYay() (err error) {
|
|
|
|
//_, options, targets := cmdArgs.formatArgs()
|
|
|
|
if cmdArgs.existsArg("h", "help") {
|
2018-01-03 04:55:47 +00:00
|
|
|
usage()
|
2018-01-04 08:13:47 +00:00
|
|
|
} else if cmdArgs.existsArg("gendb") {
|
2018-01-03 04:55:47 +00:00
|
|
|
err = createDevelDB()
|
|
|
|
if err != nil {
|
|
|
|
return
|
2017-07-19 09:32:32 +00:00
|
|
|
}
|
2018-01-31 10:25:46 +00:00
|
|
|
} else if cmdArgs.existsArg("c", "clean") {
|
2018-01-04 00:59:57 +00:00
|
|
|
err = cleanDependencies()
|
2018-01-05 22:12:14 +00:00
|
|
|
} else if len(cmdArgs.targets) > 0 {
|
2018-01-04 08:13:47 +00:00
|
|
|
err = handleYogurt()
|
2018-01-03 04:55:47 +00:00
|
|
|
}
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-03 04:55:47 +00:00
|
|
|
return
|
2017-12-31 15:18:12 +00:00
|
|
|
}
|
2017-05-09 01:09:43 +00:00
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
func handleGetpkgbuild() (err error) {
|
2018-02-17 17:44:30 +00:00
|
|
|
err = getPkgbuilds(cmdArgs.formatTargets())
|
2018-01-03 19:17:57 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
func handleYogurt() (err error) {
|
|
|
|
options := cmdArgs.formatArgs()
|
|
|
|
targets := cmdArgs.formatTargets()
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-04 00:59:57 +00:00
|
|
|
config.SearchMode = NumberMenu
|
|
|
|
err = numberMenu(targets, options)
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2017-12-31 15:18:12 +00:00
|
|
|
return
|
|
|
|
}
|
2017-05-09 01:09:43 +00:00
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
func handleSync() (err error) {
|
|
|
|
targets := cmdArgs.formatTargets()
|
2018-01-14 17:12:51 +00:00
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
if cmdArgs.existsArg("y", "refresh") {
|
|
|
|
arguments := cmdArgs.copy()
|
2018-02-17 23:00:18 +00:00
|
|
|
cmdArgs.delArg("y", "refresh")
|
2018-01-04 08:13:47 +00:00
|
|
|
arguments.delArg("u", "sysupgrade")
|
2018-02-17 23:00:18 +00:00
|
|
|
arguments.delArg("s", "search")
|
|
|
|
arguments.delArg("i", "info")
|
2018-03-11 23:34:09 +00:00
|
|
|
arguments.delArg("l", "list")
|
2018-01-04 08:13:47 +00:00
|
|
|
arguments.targets = make(stringSet)
|
2018-01-04 00:59:57 +00:00
|
|
|
err = passToPacman(arguments)
|
|
|
|
if err != nil {
|
|
|
|
return
|
2017-07-06 23:05:18 +00:00
|
|
|
}
|
2017-05-09 01:09:43 +00:00
|
|
|
}
|
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
if cmdArgs.existsArg("s", "search") {
|
|
|
|
if cmdArgs.existsArg("q", "quiet") {
|
2018-01-04 00:59:57 +00:00
|
|
|
config.SearchMode = Minimal
|
|
|
|
} else {
|
|
|
|
config.SearchMode = Detailed
|
2017-07-06 23:05:18 +00:00
|
|
|
}
|
|
|
|
|
2018-01-04 00:59:57 +00:00
|
|
|
err = syncSearch(targets)
|
2018-03-11 23:34:09 +00:00
|
|
|
} else if cmdArgs.existsArg("l", "list") {
|
|
|
|
err = passToPacman(cmdArgs)
|
2018-01-04 08:13:47 +00:00
|
|
|
} else if cmdArgs.existsArg("c", "clean") {
|
|
|
|
err = passToPacman(cmdArgs)
|
|
|
|
} else if cmdArgs.existsArg("i", "info") {
|
2018-02-14 16:10:07 +00:00
|
|
|
err = syncInfo(targets)
|
2018-02-18 23:46:25 +00:00
|
|
|
} else if cmdArgs.existsArg("u", "sysupgrade") {
|
|
|
|
err = install(cmdArgs)
|
2018-01-04 08:13:47 +00:00
|
|
|
} else if len(cmdArgs.targets) > 0 {
|
|
|
|
err = install(cmdArgs)
|
2017-07-06 23:05:18 +00:00
|
|
|
}
|
|
|
|
|
2017-12-31 15:18:12 +00:00
|
|
|
return
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-01-14 17:12:51 +00:00
|
|
|
func handleRemove() (err error) {
|
2018-01-04 08:13:47 +00:00
|
|
|
removeVCSPackage(cmdArgs.formatTargets())
|
|
|
|
err = passToPacman(cmdArgs)
|
2018-01-04 00:59:57 +00:00
|
|
|
return
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// NumberMenu presents a CLI for selecting packages to install.
|
|
|
|
func numberMenu(pkgS []string, flags []string) (err error) {
|
2018-01-14 18:53:37 +00:00
|
|
|
aurQ, err := narrowSearch(pkgS, true)
|
2017-04-29 17:12:12 +00:00
|
|
|
if err != nil {
|
|
|
|
fmt.Println("Error during AUR search:", err)
|
|
|
|
}
|
2018-01-14 18:53:37 +00:00
|
|
|
numaq := len(aurQ)
|
|
|
|
repoQ, numpq, err := queryRepo(pkgS)
|
2017-04-29 17:12:12 +00:00
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if numpq == 0 && numaq == 0 {
|
|
|
|
return fmt.Errorf("no packages match search")
|
|
|
|
}
|
|
|
|
|
2017-08-02 17:24:03 +00:00
|
|
|
if config.SortMode == BottomUp {
|
2018-01-14 18:53:37 +00:00
|
|
|
aurQ.printSearch(numpq + 1)
|
|
|
|
repoQ.printSearch()
|
2017-04-29 17:12:12 +00:00
|
|
|
} else {
|
2018-01-14 18:53:37 +00:00
|
|
|
repoQ.printSearch()
|
|
|
|
aurQ.printSearch(numpq + 1)
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-03-02 04:54:38 +00:00
|
|
|
fmt.Println(bold(green(arrow + " Packages to install (eg: 1 2 3, 1-3 or ^4)")))
|
2018-03-02 04:03:09 +00:00
|
|
|
fmt.Print(bold(green(arrow + " ")))
|
2018-03-09 05:25:05 +00:00
|
|
|
|
2017-04-29 17:12:12 +00:00
|
|
|
reader := bufio.NewReader(os.Stdin)
|
|
|
|
numberBuf, overflow, err := reader.ReadLine()
|
2018-03-09 05:25:05 +00:00
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 05:25:05 +00:00
|
|
|
if overflow {
|
|
|
|
return fmt.Errorf("Input too long")
|
|
|
|
}
|
|
|
|
|
|
|
|
include, exclude, _, otherExclude := parseNumberMenu(string(numberBuf))
|
|
|
|
arguments := makeArguments()
|
|
|
|
|
|
|
|
isInclude := len(exclude) == 0 && len(otherExclude) == 0
|
|
|
|
|
|
|
|
for i, pkg := range repoQ {
|
|
|
|
target := len(repoQ) - i
|
|
|
|
if config.SortMode == TopDown {
|
|
|
|
target = i + 1
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 05:25:05 +00:00
|
|
|
if isInclude && include.get(target) {
|
2018-03-10 19:14:37 +00:00
|
|
|
arguments.addTarget(pkg.DB().Name() + "/" + pkg.Name())
|
2018-03-09 05:25:05 +00:00
|
|
|
}
|
|
|
|
if !isInclude && !exclude.get(target) {
|
2018-03-10 19:14:37 +00:00
|
|
|
arguments.addTarget(pkg.DB().Name() + "/" + pkg.Name())
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-09 05:25:05 +00:00
|
|
|
for i, pkg := range aurQ {
|
|
|
|
target := len(aurQ) - i + len(repoQ)
|
|
|
|
if config.SortMode == TopDown {
|
|
|
|
target = i + 1 + len(repoQ)
|
|
|
|
}
|
|
|
|
|
|
|
|
if isInclude && include.get(target) {
|
2018-03-10 19:14:37 +00:00
|
|
|
arguments.addTarget("aur/" + pkg.Name)
|
2018-01-14 18:53:37 +00:00
|
|
|
}
|
2018-03-09 05:25:05 +00:00
|
|
|
if !isInclude && !exclude.get(target) {
|
2018-03-10 19:14:37 +00:00
|
|
|
arguments.addTarget("aur/" + pkg.Name)
|
2018-01-14 18:53:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-20 13:20:33 +00:00
|
|
|
if config.SudoLoop {
|
2018-02-16 18:02:56 +00:00
|
|
|
sudoLoopBackground()
|
2018-02-16 13:14:59 +00:00
|
|
|
}
|
2018-03-09 05:25:05 +00:00
|
|
|
|
2018-01-17 21:48:23 +00:00
|
|
|
err = install(arguments)
|
2017-04-29 17:12:12 +00:00
|
|
|
|
2017-05-09 01:09:43 +00:00
|
|
|
return err
|
2017-04-29 17:12:12 +00:00
|
|
|
}
|
2017-07-10 17:10:51 +00:00
|
|
|
|
2018-01-31 21:04:21 +00:00
|
|
|
// passToPacman outsources execution to pacman binary without modifications.
|
2018-01-04 08:13:47 +00:00
|
|
|
func passToPacman(args *arguments) error {
|
2018-01-03 19:01:34 +00:00
|
|
|
var cmd *exec.Cmd
|
2018-01-04 08:13:47 +00:00
|
|
|
argArr := make([]string, 0)
|
2018-01-03 19:01:34 +00:00
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
if args.needRoot() {
|
|
|
|
argArr = append(argArr, "sudo")
|
2018-01-03 19:01:34 +00:00
|
|
|
}
|
|
|
|
|
2018-02-08 09:34:47 +00:00
|
|
|
argArr = append(argArr, config.PacmanBin)
|
2018-01-04 08:13:47 +00:00
|
|
|
argArr = append(argArr, cmdArgs.formatGlobals()...)
|
|
|
|
argArr = append(argArr, args.formatArgs()...)
|
2018-02-07 11:18:19 +00:00
|
|
|
if config.NoConfirm {
|
|
|
|
argArr = append(argArr, "--noconfirm")
|
|
|
|
}
|
|
|
|
|
2018-02-20 17:03:50 +00:00
|
|
|
argArr = append(argArr, "--")
|
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
argArr = append(argArr, args.formatTargets()...)
|
2018-01-03 19:01:34 +00:00
|
|
|
|
2018-01-04 08:13:47 +00:00
|
|
|
cmd = exec.Command(argArr[0], argArr[1:]...)
|
2018-01-03 19:01:34 +00:00
|
|
|
|
|
|
|
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
|
|
|
|
err := cmd.Run()
|
|
|
|
return err
|
|
|
|
}
|
2018-01-04 02:53:19 +00:00
|
|
|
|
2018-02-28 17:39:57 +00:00
|
|
|
//passToPacman but return the output instead of showing the user
|
|
|
|
func passToPacmanCapture(args *arguments) (string, string, error) {
|
|
|
|
var outbuf, errbuf bytes.Buffer
|
|
|
|
var cmd *exec.Cmd
|
|
|
|
argArr := make([]string, 0)
|
|
|
|
|
|
|
|
if args.needRoot() {
|
|
|
|
argArr = append(argArr, "sudo")
|
|
|
|
}
|
|
|
|
|
|
|
|
argArr = append(argArr, config.PacmanBin)
|
|
|
|
argArr = append(argArr, cmdArgs.formatGlobals()...)
|
|
|
|
argArr = append(argArr, args.formatArgs()...)
|
|
|
|
if config.NoConfirm {
|
|
|
|
argArr = append(argArr, "--noconfirm")
|
|
|
|
}
|
|
|
|
|
|
|
|
argArr = append(argArr, "--")
|
|
|
|
|
|
|
|
argArr = append(argArr, args.formatTargets()...)
|
|
|
|
|
|
|
|
cmd = exec.Command(argArr[0], argArr[1:]...)
|
|
|
|
cmd.Stdout = &outbuf
|
|
|
|
cmd.Stderr = &errbuf
|
|
|
|
|
|
|
|
err := cmd.Run()
|
|
|
|
stdout := outbuf.String()
|
|
|
|
stderr := errbuf.String()
|
|
|
|
|
|
|
|
return stdout, stderr, err
|
|
|
|
}
|
|
|
|
|
2018-01-31 21:04:21 +00:00
|
|
|
// passToMakepkg outsources execution to makepkg binary without modifications.
|
2018-01-04 02:53:19 +00:00
|
|
|
func passToMakepkg(dir string, args ...string) (err error) {
|
2018-02-07 11:18:19 +00:00
|
|
|
|
|
|
|
if config.NoConfirm {
|
|
|
|
args = append(args)
|
|
|
|
}
|
|
|
|
|
2018-03-07 17:12:30 +00:00
|
|
|
mflags := strings.Fields(config.MFlags)
|
|
|
|
args = append(args, mflags...)
|
|
|
|
|
2018-01-04 02:53:19 +00:00
|
|
|
cmd := exec.Command(config.MakepkgBin, args...)
|
|
|
|
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
|
|
|
|
cmd.Dir = dir
|
|
|
|
err = cmd.Run()
|
|
|
|
if err == nil {
|
|
|
|
_ = saveVCSInfo()
|
|
|
|
}
|
|
|
|
return
|
2018-01-04 21:21:39 +00:00
|
|
|
}
|