kairos/luet
1
0
Fork 0
mirror of https://github.com/mudler/luet.git synced 2025-08-12 04:32:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introduce Packages for []Package

Browse Source
This commit is contained in:
Ettore Di Giacinto 2020-04-04 14:29:08 +02:00
parent 07e78dd89b
commit 5e31d940f0
No known key found for this signature in database
GPG Key ID: 1ADA699B145A2D1C
18 changed files with 104 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmd/install.go
View File

@ -46,7 +46,7 @@ var installCmd = &cobra.Command{
}, },
Long: `Install packages in parallel`, Long: `Install packages in parallel`,
Run: func(cmd *cobra.Command, args []string) { Run: func(cmd *cobra.Command, args []string) {
var toInstall []pkg.Package var toInstall pkg.Packages
var systemDB pkg.PackageDatabase var systemDB pkg.PackageDatabase
for _, a := range args { for _, a := range args {

2
cmd/search.go
View File

@ -108,7 +108,7 @@ var searchCmd = &cobra.Command{
system := &installer.System{Database: systemDB, Target: LuetCfg.GetSystem().Rootfs} system := &installer.System{Database: systemDB, Target: LuetCfg.GetSystem().Rootfs}
var err error var err error
iMatches := []pkg.Package{} iMatches := pkg.Packages{}
if searchWithLabel { if searchWithLabel {
iMatches, err = system.Database.FindPackageLabel(args[0]) iMatches, err = system.Database.FindPackageLabel(args[0])
} else if searchWithLabelMatch { } else if searchWithLabelMatch {

2
cmd/tree/validate.go
View File

@ -184,7 +184,7 @@ func NewTreeValidateCommand() *cobra.Command {
if withSolver { if withSolver {
Spinner(32) Spinner(32)
_, err := depSolver.Install([]pkg.Package{r}) _, err := depSolver.Install(pkg.Packages{r})
SpinnerStop() SpinnerStop()
if err != nil { if err != nil {

2
pkg/compiler/compiler.go
View File

@ -433,7 +433,7 @@ func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssert
s := solver.NewResolver(pkg.NewInMemoryDatabase(false), cs.Database, pkg.NewInMemoryDatabase(false), cs.Options.SolverOptions.Resolver()) s := solver.NewResolver(pkg.NewInMemoryDatabase(false), cs.Database, pkg.NewInMemoryDatabase(false), cs.Options.SolverOptions.Resolver())
solution, err := s.Install([]pkg.Package{p.GetPackage()}) solution, err := s.Install(pkg.Packages{p.GetPackage()})
if err != nil { if err != nil {
return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().HumanReadableString()) return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().HumanReadableString())
} }

20
pkg/installer/installer.go
View File

@ -74,7 +74,7 @@ func (l *LuetInstaller) Upgrade(s *System) error {
return errors.Wrap(err, "Failed solving solution for upgrade") return errors.Wrap(err, "Failed solving solution for upgrade")
} }
toInstall := []pkg.Package{} toInstall := pkg.Packages{}
for _, assertion := range solution { for _, assertion := range solution {
// Be sure to filter from solutions packages already installed in the system // Be sure to filter from solutions packages already installed in the system
if _, err := s.Database.FindPackage(assertion.Package); err != nil && assertion.Value { if _, err := s.Database.FindPackage(assertion.Package); err != nil && assertion.Value {
@ -107,7 +107,7 @@ func (l *LuetInstaller) SyncRepositories(inMemory bool) (Repositories, error) {
return syncedRepos, nil return syncedRepos, nil
} }
func (l *LuetInstaller) Swap(toRemove []pkg.Package, toInstall []pkg.Package, s *System) error { func (l *LuetInstaller) Swap(toRemove pkg.Packages, toInstall pkg.Packages, s *System) error {
syncedRepos, err := l.SyncRepositories(true) syncedRepos, err := l.SyncRepositories(true)
if err != nil { if err != nil {
return err return err
@ -115,7 +115,7 @@ func (l *LuetInstaller) Swap(toRemove []pkg.Package, toInstall []pkg.Package, s
return l.swap(syncedRepos, toRemove, toInstall, s) return l.swap(syncedRepos, toRemove, toInstall, s)
} }
func (l *LuetInstaller) swap(syncedRepos Repositories, toRemove []pkg.Package, toInstall []pkg.Package, s *System) error { func (l *LuetInstaller) swap(syncedRepos Repositories, toRemove pkg.Packages, toInstall pkg.Packages, s *System) error {
// First match packages against repositories by priority // First match packages against repositories by priority
allRepos := pkg.NewInMemoryDatabase(false) allRepos := pkg.NewInMemoryDatabase(false)
syncedRepos.SyncDatabase(allRepos) syncedRepos.SyncDatabase(allRepos)
@ -153,7 +153,7 @@ func (l *LuetInstaller) swap(syncedRepos Repositories, toRemove []pkg.Package, t
return l.install(syncedRepos, toInstall, s) return l.install(syncedRepos, toInstall, s)
} }
func (l *LuetInstaller) Install(cp []pkg.Package, s *System, downloadOnly bool) error { func (l *LuetInstaller) Install(cp pkg.Packages, s *System, downloadOnly bool) error {
syncedRepos, err := l.SyncRepositories(true) syncedRepos, err := l.SyncRepositories(true)
if err != nil { if err != nil {
return err return err
@ -161,7 +161,7 @@ func (l *LuetInstaller) Install(cp []pkg.Package, s *System, downloadOnly bool)
return l.install(syncedRepos, cp, s) return l.install(syncedRepos, cp, s)
} }
func (l *LuetInstaller) download(syncedRepos Repositories, cp []pkg.Package) error { func (l *LuetInstaller) download(syncedRepos Repositories, cp pkg.Packages) error {
toDownload := map[string]ArtifactMatch{} toDownload := map[string]ArtifactMatch{}
// FIXME: This can be optimized. We don't need to re-match this to the repository // FIXME: This can be optimized. We don't need to re-match this to the repository
@ -169,7 +169,7 @@ func (l *LuetInstaller) download(syncedRepos Repositories, cp []pkg.Package) err
// Gathers things to download // Gathers things to download
for _, currentPack := range cp { for _, currentPack := range cp {
matches := syncedRepos.PackageMatches([]pkg.Package{currentPack}) matches := syncedRepos.PackageMatches(pkg.Packages{currentPack})
if len(matches) == 0 { if len(matches) == 0 {
return errors.New("Failed matching solutions against repository for " + currentPack.HumanReadableString() + " where are definitions coming from?!") return errors.New("Failed matching solutions against repository for " + currentPack.HumanReadableString() + " where are definitions coming from?!")
} }
@ -206,8 +206,8 @@ func (l *LuetInstaller) download(syncedRepos Repositories, cp []pkg.Package) err
return nil return nil
} }
func (l *LuetInstaller) install(syncedRepos Repositories, cp []pkg.Package, s *System) error { func (l *LuetInstaller) install(syncedRepos Repositories, cp pkg.Packages, s *System) error {
var p []pkg.Package var p pkg.Packages
// Check if the package is installed first // Check if the package is installed first
for _, pi := range cp { for _, pi := range cp {
@ -237,7 +237,7 @@ func (l *LuetInstaller) install(syncedRepos Repositories, cp []pkg.Package, s *S
syncedRepos.SyncDatabase(allRepos) syncedRepos.SyncDatabase(allRepos)
p = syncedRepos.ResolveSelectors(p) p = syncedRepos.ResolveSelectors(p)
toInstall := map[string]ArtifactMatch{} toInstall := map[string]ArtifactMatch{}
var packagesToInstall []pkg.Package var packagesToInstall pkg.Packages
var err error var err error
var solution solver.PackagesAssertions var solution solver.PackagesAssertions
@ -261,7 +261,7 @@ func (l *LuetInstaller) install(syncedRepos Repositories, cp []pkg.Package, s *S
// Gathers things to install // Gathers things to install
for _, currentPack := range packagesToInstall { for _, currentPack := range packagesToInstall {
matches := syncedRepos.PackageMatches([]pkg.Package{currentPack}) matches := syncedRepos.PackageMatches(pkg.Packages{currentPack})
if len(matches) == 0 { if len(matches) == 0 {
return errors.New("Failed matching solutions against repository for " + currentPack.HumanReadableString() + " where are definitions coming from?!") return errors.New("Failed matching solutions against repository for " + currentPack.HumanReadableString() + " where are definitions coming from?!")
} }

4
pkg/installer/interface.go
View File

@ -23,12 +23,12 @@ import (
) )
type Installer interface { type Installer interface {
Install([]pkg.Package, *System, bool) error Install(pkg.Packages, *System, bool) error
Uninstall(pkg.Package, *System) error Uninstall(pkg.Package, *System) error
Upgrade(s *System) error Upgrade(s *System) error
Repositories([]Repository) Repositories([]Repository)
SyncRepositories(bool) (Repositories, error) SyncRepositories(bool) (Repositories, error)
Swap([]pkg.Package, []pkg.Package, *System) error Swap(pkg.Packages, pkg.Packages, *System) error
} }
type Client interface { type Client interface {

12
pkg/installer/repository.go
View File

@ -701,9 +701,9 @@ func (r Repositories) Less(i, j int) bool {
return r[i].GetPriority() < r[j].GetPriority() return r[i].GetPriority() < r[j].GetPriority()
} }
func (r Repositories) World() []pkg.Package { func (r Repositories) World() pkg.Packages {
cache := map[string]pkg.Package{} cache := map[string]pkg.Package{}
world := []pkg.Package{} world := pkg.Packages{}
// Get Uniques. Walk in reverse so the definitions of most prio-repo overwrites lower ones // Get Uniques. Walk in reverse so the definitions of most prio-repo overwrites lower ones
// In this way, when we will walk again later the deps sorting them by most higher prio we have better chance of success. // In this way, when we will walk again later the deps sorting them by most higher prio we have better chance of success.
@ -741,7 +741,7 @@ type PackageMatch struct {
Package pkg.Package Package pkg.Package
} }
func (re Repositories) PackageMatches(p []pkg.Package) []PackageMatch { func (re Repositories) PackageMatches(p pkg.Packages) []PackageMatch {
// TODO: Better heuristic. here we pick the first repo that contains the atom, sorted by priority but // TODO: Better heuristic. here we pick the first repo that contains the atom, sorted by priority but
// we should do a permutations and get the best match, and in case there are more solutions the user should be able to pick // we should do a permutations and get the best match, and in case there are more solutions the user should be able to pick
sort.Sort(re) sort.Sort(re)
@ -762,10 +762,10 @@ PACKAGE:
} }
func (re Repositories) ResolveSelectors(p []pkg.Package) []pkg.Package { func (re Repositories) ResolveSelectors(p pkg.Packages) pkg.Packages {
// If a selector is given, get the best from each repo // If a selector is given, get the best from each repo
sort.Sort(re) // respect prio sort.Sort(re) // respect prio
var matches []pkg.Package var matches pkg.Packages
PACKAGE: PACKAGE:
for _, pack := range p { for _, pack := range p {
REPOSITORY: REPOSITORY:
@ -798,7 +798,7 @@ func (re Repositories) SearchPackages(p string, o LuetSearchOpts) []PackageMatch
var err error var err error
for _, r := range re { for _, r := range re {
var repoMatches []pkg.Package var repoMatches pkg.Packages
switch o.Mode { switch o.Mode {
case SRegexPkg: case SRegexPkg:

2
pkg/installer/system.go
View File

@ -9,6 +9,6 @@ type System struct {
Target string Target string
} }
func (s *System) World() ([]pkg.Package, error) { func (s *System) World() (pkg.Packages, error) {
return s.Database.World(), nil return s.Database.World(), nil
} }

12
pkg/package/database.go
View File

@ -33,7 +33,7 @@ type PackageSet interface {
GetPackage(ID string) (Package, error) GetPackage(ID string) (Package, error)
Clean() error Clean() error
FindPackage(Package) (Package, error) FindPackage(Package) (Package, error)
FindPackages(p Package) ([]Package, error) FindPackages(p Package) (Packages, error)
UpdatePackage(p Package) error UpdatePackage(p Package) error
GetAllPackages(packages chan Package) error GetAllPackages(packages chan Package) error
RemovePackage(Package) error RemovePackage(Package) error
@ -41,13 +41,13 @@ type PackageSet interface {
GetPackageFiles(Package) ([]string, error) GetPackageFiles(Package) ([]string, error)
SetPackageFiles(*PackageFile) error SetPackageFiles(*PackageFile) error
RemovePackageFiles(Package) error RemovePackageFiles(Package) error
FindPackageVersions(p Package) ([]Package, error) FindPackageVersions(p Package) (Packages, error)
World() []Package World() Packages
FindPackageCandidate(p Package) (Package, error) FindPackageCandidate(p Package) (Package, error)
FindPackageLabel(labelKey string) ([]Package, error) FindPackageLabel(labelKey string) (Packages, error)
FindPackageLabelMatch(pattern string) ([]Package, error) FindPackageLabelMatch(pattern string) (Packages, error)
FindPackageMatch(pattern string) ([]Package, error) FindPackageMatch(pattern string) (Packages, error)
} }
type PackageFile struct { type PackageFile struct {

26
pkg/package/database_boltdb.go
View File

@ -314,7 +314,7 @@ func (db *BoltDatabase) RemovePackage(p Package) error {
return nil return nil
} }
func (db *BoltDatabase) World() []Package { func (db *BoltDatabase) World() Packages {
var all []Package var all []Package
// FIXME: This should all be locked in the db - for now forbid the solver to be run in threads. // FIXME: This should all be locked in the db - for now forbid the solver to be run in threads.
@ -324,7 +324,7 @@ func (db *BoltDatabase) World() []Package {
all = append(all, pack) all = append(all, pack)
} }
} }
return all return Packages(all)
} }
func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) { func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
@ -338,7 +338,7 @@ func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
if err != nil || len(packages) == 0 { if err != nil || len(packages) == 0 {
required = p required = p
} else { } else {
required = Best(packages) required = packages.Best()
} }
return required, nil return required, nil
@ -351,7 +351,7 @@ func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
// FindPackages return the list of the packages beloging to cat/name (any versions in requested range) // FindPackages return the list of the packages beloging to cat/name (any versions in requested range)
// FIXME: Optimize, see inmemorydb // FIXME: Optimize, see inmemorydb
func (db *BoltDatabase) FindPackages(p Package) ([]Package, error) { func (db *BoltDatabase) FindPackages(p Package) (Packages, error) {
// Provides: Treat as the replaced package here // Provides: Treat as the replaced package here
if provided, err := db.getProvide(p); err == nil { if provided, err := db.getProvide(p); err == nil {
p = provided p = provided
@ -370,11 +370,11 @@ func (db *BoltDatabase) FindPackages(p Package) ([]Package, error) {
versionsInWorld = append(versionsInWorld, w) versionsInWorld = append(versionsInWorld, w)
} }
} }
return versionsInWorld, nil return Packages(versionsInWorld), nil
} }
// FindPackageVersions return the list of the packages beloging to cat/name // FindPackageVersions return the list of the packages beloging to cat/name
func (db *BoltDatabase) FindPackageVersions(p Package) ([]Package, error) { func (db *BoltDatabase) FindPackageVersions(p Package) (Packages, error) {
var versionsInWorld []Package var versionsInWorld []Package
for _, w := range db.World() { for _, w := range db.World() {
if w.GetName() != p.GetName() || w.GetCategory() != p.GetCategory() { if w.GetName() != p.GetName() || w.GetCategory() != p.GetCategory() {
@ -383,10 +383,10 @@ func (db *BoltDatabase) FindPackageVersions(p Package) ([]Package, error) {
versionsInWorld = append(versionsInWorld, w) versionsInWorld = append(versionsInWorld, w)
} }
return versionsInWorld, nil return Packages(versionsInWorld), nil
} }
func (db *BoltDatabase) FindPackageLabel(labelKey string) ([]Package, error) { func (db *BoltDatabase) FindPackageLabel(labelKey string) (Packages, error) {
var ans []Package var ans []Package
for _, k := range db.GetPackages() { for _, k := range db.GetPackages() {
@ -398,10 +398,10 @@ func (db *BoltDatabase) FindPackageLabel(labelKey string) ([]Package, error) {
ans = append(ans, pack) ans = append(ans, pack)
} }
} }
return ans, nil return Packages(ans), nil
} }
func (db *BoltDatabase) FindPackageLabelMatch(pattern string) ([]Package, error) { func (db *BoltDatabase) FindPackageLabelMatch(pattern string) (Packages, error) {
var ans []Package var ans []Package
re := regexp.MustCompile(pattern) re := regexp.MustCompile(pattern)
@ -419,10 +419,10 @@ func (db *BoltDatabase) FindPackageLabelMatch(pattern string) ([]Package, error)
} }
} }
return ans, nil return Packages(ans), nil
} }
func (db *BoltDatabase) FindPackageMatch(pattern string) ([]Package, error) { func (db *BoltDatabase) FindPackageMatch(pattern string) (Packages, error) {
var ans []Package var ans []Package
re := regexp.MustCompile(pattern) re := regexp.MustCompile(pattern)
@ -441,5 +441,5 @@ func (db *BoltDatabase) FindPackageMatch(pattern string) ([]Package, error) {
} }
} }
return ans, nil return Packages(ans), nil
} }

26
pkg/package/database_mem.go
View File

@ -223,7 +223,7 @@ func (db *InMemoryDatabase) FindPackage(p Package) (Package, error) {
} }
// FindPackages return the list of the packages beloging to cat/name // FindPackages return the list of the packages beloging to cat/name
func (db *InMemoryDatabase) FindPackageVersions(p Package) ([]Package, error) { func (db *InMemoryDatabase) FindPackageVersions(p Package) (Packages, error) {
versions, ok := db.CacheNoVersion[p.GetPackageName()] versions, ok := db.CacheNoVersion[p.GetPackageName()]
if !ok { if !ok {
return nil, errors.New("No versions found for package") return nil, errors.New("No versions found for package")
@ -236,11 +236,11 @@ func (db *InMemoryDatabase) FindPackageVersions(p Package) ([]Package, error) {
} }
versionsInWorld = append(versionsInWorld, w) versionsInWorld = append(versionsInWorld, w)
} }
return versionsInWorld, nil return Packages(versionsInWorld), nil
} }
// FindPackages return the list of the packages beloging to cat/name (any versions in requested range) // FindPackages return the list of the packages beloging to cat/name (any versions in requested range)
func (db *InMemoryDatabase) FindPackages(p Package) ([]Package, error) { func (db *InMemoryDatabase) FindPackages(p Package) (Packages, error) {
// Provides: Treat as the replaced package here // Provides: Treat as the replaced package here
if provided, err := db.getProvide(p); err == nil { if provided, err := db.getProvide(p); err == nil {
@ -265,7 +265,7 @@ func (db *InMemoryDatabase) FindPackages(p Package) ([]Package, error) {
versionsInWorld = append(versionsInWorld, w) versionsInWorld = append(versionsInWorld, w)
} }
} }
return versionsInWorld, nil return Packages(versionsInWorld), nil
} }
func (db *InMemoryDatabase) UpdatePackage(p Package) error { func (db *InMemoryDatabase) UpdatePackage(p Package) error {
@ -327,7 +327,7 @@ func (db *InMemoryDatabase) RemovePackage(p Package) error {
delete(db.Database, p.GetFingerPrint()) delete(db.Database, p.GetFingerPrint())
return nil return nil
} }
func (db *InMemoryDatabase) World() []Package { func (db *InMemoryDatabase) World() Packages {
var all []Package var all []Package
// FIXME: This should all be locked in the db - for now forbid the solver to be run in threads. // FIXME: This should all be locked in the db - for now forbid the solver to be run in threads.
for _, k := range db.GetPackages() { for _, k := range db.GetPackages() {
@ -336,7 +336,7 @@ func (db *InMemoryDatabase) World() []Package {
all = append(all, pack) all = append(all, pack)
} }
} }
return all return Packages(all)
} }
func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) { func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
@ -349,7 +349,7 @@ func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
if err != nil || len(packages) == 0 { if err != nil || len(packages) == 0 {
required = p required = p
} else { } else {
required = Best(packages) required = packages.Best()
} }
return required, nil return required, nil
@ -360,7 +360,7 @@ func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
} }
func (db *InMemoryDatabase) FindPackageLabel(labelKey string) ([]Package, error) { func (db *InMemoryDatabase) FindPackageLabel(labelKey string) (Packages, error) {
var ans []Package var ans []Package
for _, k := range db.GetPackages() { for _, k := range db.GetPackages() {
@ -373,10 +373,10 @@ func (db *InMemoryDatabase) FindPackageLabel(labelKey string) ([]Package, error)
} }
} }
return ans, nil return Packages(ans), nil
} }
func (db *InMemoryDatabase) FindPackageLabelMatch(pattern string) ([]Package, error) { func (db *InMemoryDatabase) FindPackageLabelMatch(pattern string) (Packages, error) {
var ans []Package var ans []Package
re := regexp.MustCompile(pattern) re := regexp.MustCompile(pattern)
@ -394,10 +394,10 @@ func (db *InMemoryDatabase) FindPackageLabelMatch(pattern string) ([]Package, er
} }
} }
return ans, nil return Packages(ans), nil
} }
func (db *InMemoryDatabase) FindPackageMatch(pattern string) ([]Package, error) { func (db *InMemoryDatabase) FindPackageMatch(pattern string) (Packages, error) {
var ans []Package var ans []Package
re := regexp.MustCompile(pattern) re := regexp.MustCompile(pattern)
@ -416,5 +416,5 @@ func (db *InMemoryDatabase) FindPackageMatch(pattern string) ([]Package, error)
} }
} }
return ans, nil return Packages(ans), nil
} }

24
pkg/package/package.go
View File

@ -47,15 +47,15 @@ type Package interface {
GetPackageName() string GetPackageName() string
Requires([]*DefaultPackage) Package Requires([]*DefaultPackage) Package
Conflicts([]*DefaultPackage) Package Conflicts([]*DefaultPackage) Package
Revdeps(PackageDatabase) []Package Revdeps(PackageDatabase) Packages
LabelDeps(PackageDatabase, string) []Package LabelDeps(PackageDatabase, string) Packages
GetProvides() []*DefaultPackage GetProvides() []*DefaultPackage
SetProvides([]*DefaultPackage) Package SetProvides([]*DefaultPackage) Package
GetRequires() []*DefaultPackage GetRequires() []*DefaultPackage
GetConflicts() []*DefaultPackage GetConflicts() []*DefaultPackage
Expand(PackageDatabase) ([]Package, error) Expand(PackageDatabase) (Packages, error)
SetCategory(string) SetCategory(string)
GetName() string GetName() string
@ -104,10 +104,12 @@ type Tree interface {
GetPackageSet() PackageDatabase GetPackageSet() PackageDatabase
Prelude() string // A tree might have a prelude to be able to consume a tree Prelude() string // A tree might have a prelude to be able to consume a tree
SetPackageSet(s PackageDatabase) SetPackageSet(s PackageDatabase)
World() ([]Package, error) World() (Packages, error)
FindPackage(Package) (Package, error) FindPackage(Package) (Package, error)
} }
type Packages []Package
// >> Unmarshallers // >> Unmarshallers
// DefaultPackageFromYaml decodes a package from yaml bytes // DefaultPackageFromYaml decodes a package from yaml bytes
func DefaultPackageFromYaml(yml []byte) (DefaultPackage, error) { func DefaultPackageFromYaml(yml []byte) (DefaultPackage, error) {
@ -378,8 +380,8 @@ func (p *DefaultPackage) Matches(m Package) bool {
return false return false
} }
func (p *DefaultPackage) Expand(definitiondb PackageDatabase) ([]Package, error) { func (p *DefaultPackage) Expand(definitiondb PackageDatabase) (Packages, error) {
var versionsInWorld []Package var versionsInWorld Packages
all, err := definitiondb.FindPackages(p) all, err := definitiondb.FindPackages(p)
if err != nil { if err != nil {
@ -398,8 +400,8 @@ func (p *DefaultPackage) Expand(definitiondb PackageDatabase) ([]Package, error)
return versionsInWorld, nil return versionsInWorld, nil
} }
func (p *DefaultPackage) Revdeps(definitiondb PackageDatabase) []Package { func (p *DefaultPackage) Revdeps(definitiondb PackageDatabase) Packages {
var versionsInWorld []Package var versionsInWorld Packages
for _, w := range definitiondb.World() { for _, w := range definitiondb.World() {
if w.Matches(p) { if w.Matches(p) {
continue continue
@ -415,8 +417,8 @@ func (p *DefaultPackage) Revdeps(definitiondb PackageDatabase) []Package {
return versionsInWorld return versionsInWorld
} }
func (p *DefaultPackage) LabelDeps(definitiondb PackageDatabase, labelKey string) []Package { func (p *DefaultPackage) LabelDeps(definitiondb PackageDatabase, labelKey string) Packages {
var pkgsWithLabelInWorld []Package var pkgsWithLabelInWorld Packages
// TODO: check if integrate some index to improve // TODO: check if integrate some index to improve
// research instead of iterate all list. // research instead of iterate all list.
for _, w := range definitiondb.World() { for _, w := range definitiondb.World() {
@ -458,7 +460,7 @@ func (pack *DefaultPackage) RequiresContains(definitiondb PackageDatabase, s Pac
return false, nil return false, nil
} }
func Best(set []Package) Package { func (set Packages) Best() Package {
var versionsMap map[string]Package = make(map[string]Package) var versionsMap map[string]Package = make(map[string]Package)
if len(set) == 0 { if len(set) == 0 {
panic("Best needs a list with elements") panic("Best needs a list with elements")

2
pkg/package/package_test.go
View File

@ -58,7 +58,7 @@ var _ = Describe("Package", func() {
Expect(lst).To(ContainElement(a1)) Expect(lst).To(ContainElement(a1))
Expect(lst).ToNot(ContainElement(a01)) Expect(lst).ToNot(ContainElement(a01))
Expect(len(lst)).To(Equal(2)) Expect(len(lst)).To(Equal(2))
p := Best(lst) p := lst.Best()
Expect(p).To(Equal(a11)) Expect(p).To(Equal(a11))
}) })
}) })

8
pkg/solver/resolver.go
View File

@ -77,11 +77,11 @@ type QLearningResolver struct {
Solver PackageSolver Solver PackageSolver
Formula bf.Formula Formula bf.Formula
Targets []pkg.Package Targets pkg.Packages
Current []pkg.Package Current pkg.Packages
observedDelta int observedDelta int
observedDeltaChoice []pkg.Package observedDeltaChoice pkg.Packages
Agent *qlearning.SimpleAgent Agent *qlearning.SimpleAgent
} }
@ -177,7 +177,7 @@ func (resolver *QLearningResolver) Try(c Choice) error {
packtoAdd := pkg.FromString(pack) packtoAdd := pkg.FromString(pack)
resolver.Attempted[pack+strconv.Itoa(int(c.Action))] = true // increase the count resolver.Attempted[pack+strconv.Itoa(int(c.Action))] = true // increase the count
s, _ := resolver.Solver.(*Solver) s, _ := resolver.Solver.(*Solver)
var filtered []pkg.Package var filtered pkg.Packages
switch c.Action { switch c.Action {
case ActionAdded: case ActionAdded:

46
pkg/solver/solver.go
View File

@ -27,12 +27,12 @@ import (
// PackageSolver is an interface to a generic package solving algorithm // PackageSolver is an interface to a generic package solving algorithm
type PackageSolver interface { type PackageSolver interface {
SetDefinitionDatabase(pkg.PackageDatabase) SetDefinitionDatabase(pkg.PackageDatabase)
Install(p []pkg.Package) (PackagesAssertions, error) Install(p pkg.Packages) (PackagesAssertions, error)
Uninstall(candidate pkg.Package, checkconflicts bool) ([]pkg.Package, error) Uninstall(candidate pkg.Package, checkconflicts bool) (pkg.Packages, error)
ConflictsWithInstalled(p pkg.Package) (bool, error) ConflictsWithInstalled(p pkg.Package) (bool, error)
ConflictsWith(p pkg.Package, ls []pkg.Package) (bool, error) ConflictsWith(p pkg.Package, ls pkg.Packages) (bool, error)
World() []pkg.Package World() pkg.Packages
Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions, error) Upgrade(checkconflicts bool) (pkg.Packages, PackagesAssertions, error)
SetResolver(PackageResolver) SetResolver(PackageResolver)
@ -43,7 +43,7 @@ type PackageSolver interface {
type Solver struct { type Solver struct {
DefinitionDatabase pkg.PackageDatabase DefinitionDatabase pkg.PackageDatabase
SolverDatabase pkg.PackageDatabase SolverDatabase pkg.PackageDatabase
Wanted []pkg.Package Wanted pkg.Packages
InstalledDatabase pkg.PackageDatabase InstalledDatabase pkg.PackageDatabase
Resolver PackageResolver Resolver PackageResolver
@ -72,11 +72,11 @@ func (s *Solver) SetResolver(r PackageResolver) {
s.Resolver = r s.Resolver = r
} }
func (s *Solver) World() []pkg.Package { func (s *Solver) World() pkg.Packages {
return s.DefinitionDatabase.World() return s.DefinitionDatabase.World()
} }
func (s *Solver) Installed() []pkg.Package { func (s *Solver) Installed() pkg.Packages {
return s.InstalledDatabase.World() return s.InstalledDatabase.World()
} }
@ -130,8 +130,8 @@ func (s *Solver) BuildWorld(includeInstalled bool) (bf.Formula, error) {
return bf.And(formulas...), nil return bf.And(formulas...), nil
} }
func (s *Solver) getList(db pkg.PackageDatabase, lsp []pkg.Package) ([]pkg.Package, error) { func (s *Solver) getList(db pkg.PackageDatabase, lsp pkg.Packages) (pkg.Packages, error) {
var ls []pkg.Package var ls pkg.Packages
for _, pp := range lsp { for _, pp := range lsp {
cp, err := db.FindPackage(pp) cp, err := db.FindPackage(pp)
@ -141,7 +141,7 @@ func (s *Solver) getList(db pkg.PackageDatabase, lsp []pkg.Package) ([]pkg.Packa
if err != nil || len(packages) == 0 { if err != nil || len(packages) == 0 {
cp = pp cp = pp
} else { } else {
cp = pkg.Best(packages) cp = packages.Best()
} }
} }
ls = append(ls, cp) ls = append(ls, cp)
@ -149,7 +149,7 @@ func (s *Solver) getList(db pkg.PackageDatabase, lsp []pkg.Package) ([]pkg.Packa
return ls, nil return ls, nil
} }
func (s *Solver) ConflictsWith(pack pkg.Package, lsp []pkg.Package) (bool, error) { func (s *Solver) ConflictsWith(pack pkg.Package, lsp pkg.Packages) (bool, error) {
p, err := s.DefinitionDatabase.FindPackage(pack) p, err := s.DefinitionDatabase.FindPackage(pack)
if err != nil { if err != nil {
p = pack //Relax search, otherwise we cannot compute solutions for packages not in definitions p = pack //Relax search, otherwise we cannot compute solutions for packages not in definitions
@ -210,14 +210,14 @@ func (s *Solver) ConflictsWithInstalled(p pkg.Package) (bool, error) {
return s.ConflictsWith(p, s.Installed()) return s.ConflictsWith(p, s.Installed())
} }
func (s *Solver) Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions, error) { func (s *Solver) Upgrade(checkconflicts bool) (pkg.Packages, PackagesAssertions, error) {
// First get candidates that needs to be upgraded.. // First get candidates that needs to be upgraded..
toUninstall := []pkg.Package{} toUninstall := pkg.Packages{}
toInstall := []pkg.Package{} toInstall := pkg.Packages{}
availableCache := map[string][]pkg.Package{} availableCache := map[string]pkg.Packages{}
for _, p := range s.DefinitionDatabase.World() { for _, p := range s.DefinitionDatabase.World() {
// Each one, should be expanded // Each one, should be expanded
availableCache[p.GetName()+p.GetCategory()] = append(availableCache[p.GetName()+p.GetCategory()], p) availableCache[p.GetName()+p.GetCategory()] = append(availableCache[p.GetName()+p.GetCategory()], p)
@ -229,7 +229,7 @@ func (s *Solver) Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions
installedcopy.CreatePackage(p) installedcopy.CreatePackage(p)
packages, ok := availableCache[p.GetName()+p.GetCategory()] packages, ok := availableCache[p.GetName()+p.GetCategory()]
if ok && len(packages) != 0 { if ok && len(packages) != 0 {
best := pkg.Best(packages) best := packages.Best()
if best.GetVersion() != p.GetVersion() { if best.GetVersion() != p.GetVersion() {
toUninstall = append(toUninstall, p) toUninstall = append(toUninstall, p)
toInstall = append(toInstall, best) toInstall = append(toInstall, best)
@ -261,8 +261,8 @@ func (s *Solver) Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions
// Uninstall takes a candidate package and return a list of packages that would be removed // Uninstall takes a candidate package and return a list of packages that would be removed
// in order to purge the candidate. Returns error if unsat. // in order to purge the candidate. Returns error if unsat.
func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) ([]pkg.Package, error) { func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) (pkg.Packages, error) {
var res []pkg.Package var res pkg.Packages
candidate, err := s.InstalledDatabase.FindPackage(c) candidate, err := s.InstalledDatabase.FindPackage(c)
if err != nil { if err != nil {
@ -272,13 +272,13 @@ func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) ([]pkg.Package, e
if err != nil || len(packages) == 0 { if err != nil || len(packages) == 0 {
candidate = c candidate = c
} else { } else {
candidate = pkg.Best(packages) candidate = packages.Best()
} }
//Relax search, otherwise we cannot compute solutions for packages not in definitions //Relax search, otherwise we cannot compute solutions for packages not in definitions
// return nil, errors.Wrap(err, "Package not found between installed") // return nil, errors.Wrap(err, "Package not found between installed")
} }
// Build a fake "Installed" - Candidate and its requires tree // Build a fake "Installed" - Candidate and its requires tree
var InstalledMinusCandidate []pkg.Package var InstalledMinusCandidate pkg.Packages
// TODO: Can be optimized // TODO: Can be optimized
for _, i := range s.Installed() { for _, i := range s.Installed() {
@ -296,7 +296,7 @@ func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) ([]pkg.Package, e
s2 := NewSolver(pkg.NewInMemoryDatabase(false), s.DefinitionDatabase, pkg.NewInMemoryDatabase(false)) s2 := NewSolver(pkg.NewInMemoryDatabase(false), s.DefinitionDatabase, pkg.NewInMemoryDatabase(false))
s2.SetResolver(s.Resolver) s2.SetResolver(s.Resolver)
// Get the requirements to install the candidate // Get the requirements to install the candidate
asserts, err := s2.Install([]pkg.Package{candidate}) asserts, err := s2.Install(pkg.Packages{candidate})
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -403,7 +403,7 @@ func (s *Solver) Solve() (PackagesAssertions, error) {
// Install given a list of packages, returns package assertions to indicate the packages that must be installed in the system in order // Install given a list of packages, returns package assertions to indicate the packages that must be installed in the system in order
// to statisfy all the constraints // to statisfy all the constraints
func (s *Solver) Install(c []pkg.Package) (PackagesAssertions, error) { func (s *Solver) Install(c pkg.Packages) (PackagesAssertions, error) {
coll, err := s.getList(s.DefinitionDatabase, c) coll, err := s.getList(s.DefinitionDatabase, c)
if err != nil { if err != nil {

2
pkg/solver/solver_test.go
View File

@ -882,7 +882,7 @@ var _ = Describe("Solver", func() {
Expect(lst).To(ContainElement(a03)) Expect(lst).To(ContainElement(a03))
Expect(lst).ToNot(ContainElement(old)) Expect(lst).ToNot(ContainElement(old))
Expect(len(lst)).To(Equal(5)) Expect(len(lst)).To(Equal(5))
p := pkg.Best(lst) p := lst.Best()
Expect(p).To(Equal(a03)) Expect(p).To(Equal(a03))
}) })
}) })

2
pkg/tree/builder/gentoo/gentoo.go
View File

@ -50,7 +50,7 @@ type GentooBuilder struct {
} }
type EbuildParser interface { type EbuildParser interface {
ScanEbuild(string) ([]pkg.Package, error) ScanEbuild(string) (pkg.Packages, error)
} }
func (gb *GentooBuilder) scanEbuild(path string, db pkg.PackageDatabase) error { func (gb *GentooBuilder) scanEbuild(path string, db pkg.PackageDatabase) error {

12
pkg/tree/builder/gentoo/simpleparser.go
View File

@ -323,7 +323,7 @@ func SourceFile(ctx context.Context, path string, pkg *_gentoo.GentooPackage) (m
} }
// ScanEbuild returns a list of packages (always one with SimpleEbuildParser) decoded from an ebuild. // ScanEbuild returns a list of packages (always one with SimpleEbuildParser) decoded from an ebuild.
func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) { func (ep *SimpleEbuildParser) ScanEbuild(path string) (pkg.Packages, error) {
Debug("Starting parsing of ebuild", path) Debug("Starting parsing of ebuild", path)
pkgstr := filepath.Base(path) pkgstr := filepath.Base(path)
@ -332,7 +332,7 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
gp, err := _gentoo.ParsePackageStr(pkgstr) gp, err := _gentoo.ParsePackageStr(pkgstr)
if err != nil { if err != nil {
return []pkg.Package{}, errors.New("Error on parsing package string") return pkg.Packages{}, errors.New("Error on parsing package string")
} }
pack := &pkg.DefaultPackage{ pack := &pkg.DefaultPackage{
@ -350,7 +350,7 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
vars, err := SourceFile(timeout, path, gp) vars, err := SourceFile(timeout, path, gp)
if err != nil { if err != nil {
Error("Error on source file ", pack.Name, ": ", err) Error("Error on source file ", pack.Name, ": ", err)
return []pkg.Package{}, err return pkg.Packages{}, err
} }
// TODO: Handle this a bit better // TODO: Handle this a bit better
@ -405,8 +405,8 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
gRDEPEND, err := ParseRDEPEND(rdepend.String()) gRDEPEND, err := ParseRDEPEND(rdepend.String())
if err != nil { if err != nil {
Warning("Error on parsing RDEPEND for package ", pack.Category+"/"+pack.Name, err) Warning("Error on parsing RDEPEND for package ", pack.Category+"/"+pack.Name, err)
return []pkg.Package{pack}, nil return pkg.Packages{pack}, nil
// return []pkg.Package{}, err // return pkg.Packages{}, err
} }
pack.PackageConflicts = []*pkg.DefaultPackage{} pack.PackageConflicts = []*pkg.DefaultPackage{}
@ -436,5 +436,5 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
Debug("Finished processing ebuild", path, "deps ", len(pack.PackageRequires)) Debug("Finished processing ebuild", path, "deps ", len(pack.PackageRequires))
//TODO: Deps and conflicts //TODO: Deps and conflicts
return []pkg.Package{pack}, nil return pkg.Packages{pack}, nil
} }