mirror of
https://github.com/Jguer/yay
synced 2024-09-14 13:51:12 +00:00
e28f4f3431
The main reason behind this is for future localisation. yes and no can be set to the localized equivalent and it should just work. This Refactor also changes the function in ways which make it much less confusing. The param is no longer reversed and changed to a boolean. Before you had to pass in Yy to get a default of no and vice versa. The function now retuens false for no and true for yes. Before it would return true if the default option was choosen.
125 lines
3.3 KiB
Go
125 lines
3.3 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"strings"
|
|
|
|
gosrc "github.com/Morganamilo/go-srcinfo"
|
|
rpc "github.com/mikkeloscar/aur"
|
|
)
|
|
|
|
// pgpKeySet maps a PGP key with a list of PKGBUILDs that require it.
|
|
// This is similar to stringSet, used throughout the code.
|
|
type pgpKeySet map[string][]*rpc.Pkg
|
|
|
|
func (set pgpKeySet) toSlice() []string {
|
|
slice := make([]string, 0, len(set))
|
|
for v := range set {
|
|
slice = append(slice, v)
|
|
}
|
|
return slice
|
|
}
|
|
|
|
func (set pgpKeySet) set(key string, p *rpc.Pkg) {
|
|
// Using ToUpper to make sure keys with a different case will be
|
|
// considered the same.
|
|
upperKey := strings.ToUpper(key)
|
|
if _, exists := set[upperKey]; !exists {
|
|
set[upperKey] = []*rpc.Pkg{}
|
|
}
|
|
set[key] = append(set[key], p)
|
|
}
|
|
|
|
func (set pgpKeySet) get(key string) bool {
|
|
upperKey := strings.ToUpper(key)
|
|
_, exists := set[upperKey]
|
|
return exists
|
|
}
|
|
|
|
// checkPgpKeys iterates through the keys listed in the PKGBUILDs and if needed,
|
|
// asks the user whether yay should try to import them.
|
|
func checkPgpKeys(pkgs []*rpc.Pkg, bases map[string][]*rpc.Pkg, srcinfos map[string]*gosrc.Srcinfo) error {
|
|
// Let's check the keys individually, and then we can offer to import
|
|
// the problematic ones.
|
|
problematic := make(pgpKeySet)
|
|
args := append(strings.Fields(config.GpgFlags), "--list-keys")
|
|
|
|
// Mapping all the keys.
|
|
for _, pkg := range pkgs {
|
|
srcinfo := srcinfos[pkg.PackageBase]
|
|
|
|
for _, key := range srcinfo.ValidPGPKeys {
|
|
// If key already marked as problematic, indicate the current
|
|
// PKGBUILD requires it.
|
|
if problematic.get(key) {
|
|
problematic.set(key, pkg)
|
|
continue
|
|
}
|
|
|
|
cmd := exec.Command(config.GpgBin, append(args, key)...)
|
|
err := cmd.Run()
|
|
if err != nil {
|
|
problematic.set(key, pkg)
|
|
}
|
|
}
|
|
}
|
|
|
|
// No key issues!
|
|
if len(problematic) == 0 {
|
|
return nil
|
|
}
|
|
|
|
str, err := formatKeysToImport(problematic, bases)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
fmt.Println()
|
|
fmt.Println(str)
|
|
|
|
if continueTask(bold(green("Import?")), true) {
|
|
return importKeys(problematic.toSlice())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// importKeys tries to import the list of keys specified in its argument.
|
|
func importKeys(keys []string) error {
|
|
args := append(strings.Fields(config.GpgFlags), "--recv-keys")
|
|
cmd := exec.Command(config.GpgBin, append(args, keys...)...)
|
|
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
|
|
|
|
fmt.Printf("%s %s...\n", bold(cyan("::")), bold("Importing keys with gpg..."))
|
|
err := cmd.Run()
|
|
|
|
if err != nil {
|
|
return fmt.Errorf("%s Problem importing keys", bold(red(arrow+" Error:")))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// formatKeysToImport receives a set of keys and returns a string containing the
|
|
// question asking the user wants to import the problematic keys.
|
|
func formatKeysToImport(keys pgpKeySet, bases map[string][]*rpc.Pkg) (string, error) {
|
|
if len(keys) == 0 {
|
|
return "", fmt.Errorf("%s No keys to import", bold(red(arrow+" Error:")))
|
|
}
|
|
|
|
var buffer bytes.Buffer
|
|
buffer.WriteString(bold(green(arrow)))
|
|
buffer.WriteString(bold(green(" PGP keys need importing:")))
|
|
for key, pkgs := range keys {
|
|
pkglist := ""
|
|
for _, pkg := range pkgs {
|
|
pkglist += formatPkgbase(pkg, bases) + " "
|
|
}
|
|
pkglist = strings.TrimRight(pkglist, " ")
|
|
buffer.WriteString(fmt.Sprintf("\n%s %s, required by: %s", yellow(bold(smallArrow)), cyan(key), cyan(pkglist)))
|
|
}
|
|
return buffer.String(), nil
|
|
}
|