sharpetronics/yay
1
0
Fork 0
mirror of https://github.com/Jguer/yay.git synced 2025-12-08 00:05:04 -05:00
Code Issues Projects Releases Wiki Activity

add repo install

Browse Source
This commit is contained in:
jguer 2022-09-09 20:57:18 +02:00
parent 4a73dfb0ca
commit 5bb46ac1de
No known key found for this signature in database
GPG Key ID: 6D6CC9BEA8556B35
5 changed files with 126 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
aur_source.go
View File

@ -9,7 +9,6 @@ import (
"github.com/leonelquinteros/gotext"
"github.com/Jguer/yay/v11/pkg/dep"
"github.com/Jguer/yay/v11/pkg/multierror"
"github.com/Jguer/yay/v11/pkg/settings/exe"
"github.com/Jguer/yay/v11/pkg/stringset"
@ -32,7 +31,8 @@ func (e *ErrDownloadSource) Unwrap() error {
}
func downloadPKGBUILDSource(ctx context.Context, cmdBuilder exe.ICmdBuilder, dest,
base string, incompatible stringset.StringSet) (err error) {
base string, incompatible stringset.StringSet,
) error {
dir := filepath.Join(dest, base)
args := []string{"--verifysource", "-Ccf"}
@ -40,7 +40,7 @@ func downloadPKGBUILDSource(ctx context.Context, cmdBuilder exe.ICmdBuilder, des
args = append(args, "--ignorearch")
}
err = cmdBuilder.Show(
err := cmdBuilder.Show(
cmdBuilder.BuildMakepkgCmd(ctx, dir, args...))
if err != nil {
return ErrDownloadSource{inner: err, pkgName: base, errOut: ""}
@ -51,7 +51,8 @@ func downloadPKGBUILDSource(ctx context.Context, cmdBuilder exe.ICmdBuilder, des
func downloadPKGBUILDSourceWorker(ctx context.Context, wg *sync.WaitGroup, dest string,
cBase <-chan string, valOut chan<- string, errOut chan<- error,
cmdBuilder exe.ICmdBuilder, incompatible stringset.StringSet) {
cmdBuilder exe.ICmdBuilder, incompatible stringset.StringSet,
) {
for base := range cBase {
err := downloadPKGBUILDSource(ctx, cmdBuilder, dest, base, incompatible)
if err != nil {
@ -65,9 +66,14 @@ func downloadPKGBUILDSourceWorker(ctx context.Context, wg *sync.WaitGroup, dest
}
func downloadPKGBUILDSourceFanout(ctx context.Context, cmdBuilder exe.ICmdBuilder, dest string,
bases []dep.Base, incompatible stringset.StringSet, maxConcurrentDownloads int) error {
bases []string, incompatible stringset.StringSet, maxConcurrentDownloads int,
) error {
if len(bases) == 0 {
return nil // no work to do
}
if len(bases) == 1 {
return downloadPKGBUILDSource(ctx, cmdBuilder, dest, bases[0].Pkgbase(), incompatible)
return downloadPKGBUILDSource(ctx, cmdBuilder, dest, bases[0], incompatible)
}
var (
@ -84,7 +90,7 @@ func downloadPKGBUILDSourceFanout(ctx context.Context, cmdBuilder exe.ICmdBuilde
go func() {
for _, base := range bases {
c <- base.Pkgbase()
c <- base
}
close(c)

28
aur_source_test.go
View File

@ -9,9 +9,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/Jguer/aur"
"github.com/Jguer/yay/v11/pkg/dep"
"github.com/Jguer/yay/v11/pkg/multierror"
"github.com/Jguer/yay/v11/pkg/settings/exe"
"github.com/Jguer/yay/v11/pkg/stringset"
@ -84,14 +81,7 @@ func Test_downloadPKGBUILDSourceError(t *testing.T) {
func Test_downloadPKGBUILDSourceFanout(t *testing.T) {
t.Parallel()
bases := []dep.Base{
{&aur.Pkg{PackageBase: "yay"}},
{&aur.Pkg{PackageBase: "yay-bin"}},
{&aur.Pkg{PackageBase: "yay-git"}},
{&aur.Pkg{PackageBase: "yay-v11"}},
{&aur.Pkg{PackageBase: "yay-v12"}},
}
bases := []string{"yay", "yay-bin", "yay-git", "yay-v11", "yay-v12"}
for _, maxConcurrentDownloads := range []int{0, 3} {
t.Run(fmt.Sprintf("maxconcurrentdownloads set to %d", maxConcurrentDownloads), func(t *testing.T) {
cmdBuilder := &TestMakepkgBuilder{
@ -122,9 +112,7 @@ func Test_downloadPKGBUILDSourceFanoutNoCC(t *testing.T) {
test: t,
}
bases := []dep.Base{
{&aur.Pkg{PackageBase: "yay"}},
}
bases := []string{"yay"}
err := downloadPKGBUILDSourceFanout(context.TODO(), cmdBuilder, "/tmp", bases, stringset.Make(), 0)
assert.NoError(t, err)
@ -145,12 +133,12 @@ func Test_downloadPKGBUILDSourceFanoutError(t *testing.T) {
showError: &exec.ExitError{},
}
bases := []dep.Base{
{&aur.Pkg{PackageBase: "yay"}},
{&aur.Pkg{PackageBase: "yay-bin"}},
{&aur.Pkg{PackageBase: "yay-git"}},
{&aur.Pkg{PackageBase: "yay-v11"}},
{&aur.Pkg{PackageBase: "yay-v12"}},
bases := []string{
"yay",
"yay-bin",
"yay-git",
"yay-v11",
"yay-v12",
}
err := downloadPKGBUILDSourceFanout(context.TODO(), cmdBuilder, "/tmp", bases, stringset.Make(), 0)

2
cmd.go
View File

@ -330,7 +330,7 @@ func handleUpgrade(ctx context.Context,
config *settings.Configuration, dbExecutor db.Executor, cmdArgs *parser.Arguments,
) error {
if cmdArgs.ExistsArg("i", "install") {
return installLocalPKGBUILD(ctx, cmdArgs, dbExecutor, false)
return installLocalPKGBUILD(ctx, cmdArgs, dbExecutor)
}
return config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,

7
install.go
View File

@ -330,8 +330,13 @@ func install(ctx context.Context, cmdArgs *parser.Arguments, dbExecutor db.Execu
config.AURURL, config.Runtime.CompletionPath, config.CompletionInterval, false)
}()
bases := make([]string, 0, len(do.Aur))
for _, base := range do.Aur {
bases = append(bases, base.Pkgbase())
}
if errP := downloadPKGBUILDSourceFanout(ctx, config.Runtime.CmdBuilder, config.BuildDir,
do.Aur, incompatible, config.MaxConcurrentDownloads); errP != nil {
bases, incompatible, config.MaxConcurrentDownloads); errP != nil {
text.Errorln(errP)
}

103
local_install.go
View File

@ -1,3 +1,5 @@
// Experimental code for install local with dependency refactoring
// Not at feature parity with install.go
package main
import (
@ -8,19 +10,22 @@ import (
"github.com/Jguer/yay/v11/pkg/db"
"github.com/Jguer/yay/v11/pkg/dep"
"github.com/Jguer/yay/v11/pkg/download"
"github.com/Jguer/yay/v11/pkg/metadata"
"github.com/Jguer/yay/v11/pkg/settings"
"github.com/Jguer/yay/v11/pkg/settings/exe"
"github.com/Jguer/yay/v11/pkg/settings/parser"
gosrc "github.com/Morganamilo/go-srcinfo"
"github.com/leonelquinteros/gotext"
"github.com/pkg/errors"
)
var ErrInstallRepoPkgs = errors.New(gotext.Get("error installing repo packages"))
func installLocalPKGBUILD(
ctx context.Context,
cmdArgs *parser.Arguments,
dbExecutor db.Executor,
ignoreProviders bool,
) error {
aurCache, err := metadata.NewAURCache(filepath.Join(config.BuildDir, "aur.json"))
if err != nil {
@ -55,9 +60,37 @@ func installLocalPKGBUILD(
topoSorted := graph.TopoSortedLayerMap()
fmt.Println(topoSorted, len(topoSorted))
preparer := &Preparer{dbExecutor: dbExecutor, cmdBuilder: config.Runtime.CmdBuilder}
installer := &Installer{dbExecutor: dbExecutor}
installer.Install(ctx, topoSorted)
if err := preparer.PrepareWorkspace(ctx, topoSorted); err != nil {
return err
}
return installer.Install(ctx, cmdArgs, topoSorted)
}
type Preparer struct {
dbExecutor db.Executor
cmdBuilder exe.ICmdBuilder
aurBases []string
}
func (preper *Preparer) PrepareWorkspace(ctx context.Context, targets []map[string]*dep.InstallInfo,
) error {
for _, layer := range targets {
for pkgBase, info := range layer {
if info.Source == dep.AUR {
preper.aurBases = append(preper.aurBases, pkgBase)
}
}
}
_, errA := download.AURPKGBUILDRepos(ctx,
preper.cmdBuilder, preper.aurBases, config.AURURL, config.BuildDir, false)
if errA != nil {
return errA
}
return nil
}
@ -66,10 +99,10 @@ type Installer struct {
dbExecutor db.Executor
}
func (installer *Installer) Install(ctx context.Context, targets []map[string]*dep.InstallInfo) error {
func (installer *Installer) Install(ctx context.Context, cmdArgs *parser.Arguments, targets []map[string]*dep.InstallInfo) error {
// Reorganize targets into layers of dependencies
for i := len(targets) - 1; i >= 0; i-- {
err := installer.handleLayer(ctx, targets[i])
err := installer.handleLayer(ctx, cmdArgs, targets[i])
if err != nil {
// rollback
return err
@ -95,7 +128,7 @@ func (m *MapBySourceAndType) String() string {
return s
}
func (installer *Installer) handleLayer(ctx context.Context, layer map[string]*dep.InstallInfo) error {
func (installer *Installer) handleLayer(ctx context.Context, cmdArgs *parser.Arguments, layer map[string]*dep.InstallInfo) error {
// Install layer
depByTypeAndReason := make(MapBySourceAndType)
for name, info := range layer {
@ -108,5 +141,65 @@ func (installer *Installer) handleLayer(ctx context.Context, layer map[string]*d
fmt.Printf("%v\n", depByTypeAndReason)
syncDeps, syncExp := make([]string, 0), make([]string, 0)
repoTargets := make([]string, 0)
for source, reasons := range depByTypeAndReason {
switch source {
case dep.AUR:
case dep.Sync:
for reason, names := range reasons {
switch reason {
case dep.Explicit:
if cmdArgs.ExistsArg("asdeps", "asdep") {
syncDeps = append(syncDeps, names...)
} else {
syncExp = append(syncExp, names...)
}
case dep.CheckDep:
fallthrough
case dep.MakeDep:
fallthrough
case dep.Dep:
syncDeps = append(syncDeps, names...)
}
repoTargets = append(repoTargets, names...)
}
}
}
fmt.Println(syncDeps, syncExp)
errShow := installer.installRepoPackages(ctx, cmdArgs, repoTargets, syncDeps, syncExp)
if errShow != nil {
return ErrInstallRepoPkgs
}
return nil
}
func (*Installer) installRepoPackages(ctx context.Context, cmdArgs *parser.Arguments,
repoTargets, // all repo targets
syncDeps, // repo targets that are deps
syncExp []string, // repo targets that are exp
) error {
arguments := cmdArgs.Copy()
arguments.DelArg("asdeps", "asdep")
arguments.DelArg("asexplicit", "asexp")
arguments.DelArg("i", "install")
arguments.Op = "S"
arguments.ClearTargets()
arguments.AddTarget(repoTargets...)
errShow := config.Runtime.CmdBuilder.Show(config.Runtime.CmdBuilder.BuildPacmanCmd(ctx,
arguments, config.Runtime.Mode, settings.NoConfirm))
if errD := asdeps(ctx, cmdArgs, syncDeps); errD != nil {
return errD
}
if errE := asexp(ctx, cmdArgs, syncExp); errE != nil {
return errE
}
return errShow
}