Make repositories arch-aware

Introduce an arch field that can be used to filter repositories based on
the local architecture.

If arch is provided and matching with the current GOARCH then the
repository is enabled

cmd/install.go

@@ -80,7 +80,6 @@ To force install a package:
 		LuetCfg.GetSolverOptions().Implementation = solver.SingleCoreSimple
 
 		Debug("Solver", LuetCfg.GetSolverOptions().CompactString())
-		repos := installer.SystemRepositories(LuetCfg)
 
 		// Load config protect configs
 		installer.LoadConfigProtectConfs(LuetCfg)
@@ -101,8 +100,8 @@ To force install a package:
 			DownloadOnly:                downloadOnly,
 			Ask:                         !yes,
 			Relaxed:                     relax,
+			PackageRepositories:         LuetCfg.SystemRepositories,
 		})
-		inst.Repositories(repos)
 
 		system := &installer.System{Database: LuetCfg.GetSystemDB(), Target: LuetCfg.GetSystem().Rootfs}
 		err = inst.Install(toInstall, system)

cmd/reclaim.go

@@ -40,16 +40,6 @@ It scans the target file system, and if finds a match with a package available i
 	Run: func(cmd *cobra.Command, args []string) {
 		util.SetSystemConfig()
 
-		// This shouldn't be necessary, but we need to unmarshal the repositories to a concrete struct, thus we need to port them back to the Repositories type
-		repos := installer.Repositories{}
-		for _, repo := range LuetCfg.SystemRepositories {
-			if !repo.Enable {
-				continue
-			}
-			r := installer.NewSystemRepository(repo)
-			repos = append(repos, r)
-		}
-
 		force := LuetCfg.Viper.GetBool("force")
 
 		Debug("Solver", LuetCfg.GetSolverOptions().CompactString())
@@ -58,8 +48,8 @@ It scans the target file system, and if finds a match with a package available i
 			Concurrency:                 LuetCfg.GetGeneral().Concurrency,
 			Force:                       force,
 			PreserveSystemEssentialData: true,
+			PackageRepositories:         LuetCfg.SystemRepositories,
 		})
-		inst.Repositories(repos)
 
 		system := &installer.System{Database: LuetCfg.GetSystemDB(), Target: LuetCfg.GetSystem().Rootfs}
 		err := inst.Reclaim(system)

cmd/reinstall.go

@@ -64,16 +64,6 @@ var reinstallCmd = &cobra.Command{
 			toAdd = append(toAdd, pack)
 		}
 
-		// This shouldn't be necessary, but we need to unmarshal the repositories to a concrete struct, thus we need to port them back to the Repositories type
-		repos := installer.Repositories{}
-		for _, repo := range LuetCfg.SystemRepositories {
-			if !repo.Enable {
-				continue
-			}
-			r := installer.NewSystemRepository(repo)
-			repos = append(repos, r)
-		}
-
 		util.SetSolverConfig()
 
 		LuetCfg.GetSolverOptions().Implementation = solver.SingleCoreSimple
@@ -92,8 +82,8 @@ var reinstallCmd = &cobra.Command{
 			PreserveSystemEssentialData: true,
 			Ask:                         !yes,
 			DownloadOnly:                downloadOnly,
+			PackageRepositories:         LuetCfg.SystemRepositories,
 		})
-		inst.Repositories(repos)
 
 		system := &installer.System{Database: LuetCfg.GetSystemDB(), Target: LuetCfg.GetSystem().Rootfs}
 		err := inst.Swap(toUninstall, toAdd, system)

cmd/replace.go

@@ -74,16 +74,6 @@ var replaceCmd = &cobra.Command{
 			toAdd = append(toAdd, pack)
 		}
 
-		// This shouldn't be necessary, but we need to unmarshal the repositories to a concrete struct, thus we need to port them back to the Repositories type
-		repos := installer.Repositories{}
-		for _, repo := range LuetCfg.SystemRepositories {
-			if !repo.Enable {
-				continue
-			}
-			r := installer.NewSystemRepository(repo)
-			repos = append(repos, r)
-		}
-
 		LuetCfg.GetSolverOptions().Implementation = solver.SingleCoreSimple
 
 		Debug("Solver", LuetCfg.GetSolverOptions().CompactString())
@@ -100,8 +90,8 @@ var replaceCmd = &cobra.Command{
 			PreserveSystemEssentialData: true,
 			Ask:                         !yes,
 			DownloadOnly:                downloadOnly,
+			PackageRepositories:         LuetCfg.SystemRepositories,
 		})
-		inst.Repositories(repos)
 
 		system := &installer.System{Database: LuetCfg.GetSystemDB(), Target: LuetCfg.GetSystem().Rootfs}
 		err := inst.Swap(toUninstall, toAdd, system)

cmd/search.go

@@ -128,23 +128,14 @@ func searchLocally(term string, l list.Writer, t table.Writer, label, labelMatch
 func searchOnline(term string, l list.Writer, t table.Writer, label, labelMatch, revdeps, hidden bool) Results {
 	var results Results
 
-	repos := installer.Repositories{}
-	for _, repo := range LuetCfg.SystemRepositories {
-		if !repo.Enable {
-			continue
-		}
-		r := installer.NewSystemRepository(repo)
-		repos = append(repos, r)
-	}
-
 	inst := installer.NewLuetInstaller(
 		installer.LuetInstallerOptions{
-			Concurrency:   LuetCfg.GetGeneral().Concurrency,
-			SolverOptions: *LuetCfg.GetSolverOptions(),
+			Concurrency:         LuetCfg.GetGeneral().Concurrency,
+			SolverOptions:       *LuetCfg.GetSolverOptions(),
+			PackageRepositories: LuetCfg.SystemRepositories,
 		},
 	)
-	inst.Repositories(repos)
-	synced, err := inst.SyncRepositories(false)
+	synced, err := inst.SyncRepositories()
 	if err != nil {
 		Fatal("Error: " + err.Error())
 	}
@@ -226,23 +217,14 @@ func searchLocalFiles(term string, l list.Writer, t table.Writer) Results {
 func searchFiles(term string, l list.Writer, t table.Writer) Results {
 	var results Results
 
-	repos := installer.Repositories{}
-	for _, repo := range LuetCfg.SystemRepositories {
-		if !repo.Enable {
-			continue
-		}
-		r := installer.NewSystemRepository(repo)
-		repos = append(repos, r)
-	}
-
 	inst := installer.NewLuetInstaller(
 		installer.LuetInstallerOptions{
-			Concurrency:   LuetCfg.GetGeneral().Concurrency,
-			SolverOptions: *LuetCfg.GetSolverOptions(),
+			Concurrency:         LuetCfg.GetGeneral().Concurrency,
+			SolverOptions:       *LuetCfg.GetSolverOptions(),
+			PackageRepositories: LuetCfg.SystemRepositories,
 		},
 	)
-	inst.Repositories(repos)
-	synced, err := inst.SyncRepositories(false)
+	synced, err := inst.SyncRepositories()
 	if err != nil {
 		Fatal("Error: " + err.Error())
 	}

cmd/upgrade.go

@@ -37,16 +37,6 @@ var upgradeCmd = &cobra.Command{
 	Long: `Upgrades packages in parallel`,
 	Run: func(cmd *cobra.Command, args []string) {
 
-		repos := installer.Repositories{}
-		for _, repo := range LuetCfg.SystemRepositories {
-			if !repo.Enable {
-				continue
-			}
-
-			r := installer.NewSystemRepository(repo)
-			repos = append(repos, r)
-		}
-
 		force := LuetCfg.Viper.GetBool("force")
 		nodeps, _ := cmd.Flags().GetBool("nodeps")
 		full, _ := cmd.Flags().GetBool("full")
@@ -78,8 +68,8 @@ var upgradeCmd = &cobra.Command{
 			PreserveSystemEssentialData: true,
 			Ask:                         !yes,
 			DownloadOnly:                downloadOnly,
+			PackageRepositories:         LuetCfg.SystemRepositories,
 		})
-		inst.Repositories(repos)
 
 		system := &installer.System{Database: LuetCfg.GetSystemDB(), Target: LuetCfg.GetSystem().Rootfs}
 		if err := inst.Upgrade(system); err != nil {

cmd/util/cli.go

@@ -100,7 +100,7 @@ func TemplateFolders(fromRepo bool, treePaths []string) []string {
 		templateFolders = append(templateFolders, filepath.Join(t, "templates"))
 	}
 	if fromRepo {
-		for _, s := range installer.SystemRepositories(LuetCfg) {
+		for _, s := range installer.SystemRepositories(LuetCfg.SystemRepositories) {
 			templateFolders = append(templateFolders, filepath.Join(s.TreePath, "templates"))
 		}
 	}

pkg/api/core/types/config_suite_test.go

@@ -0,0 +1,32 @@
+// Copyright © 2021 Ettore Di Giacinto <mudler@mocaccino.org>
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, see <http://www.gnu.org/licenses/>.
+
+package types_test
+
+import (
+	"testing"
+
+	. "github.com/mudler/luet/cmd"
+	config "github.com/mudler/luet/pkg/config"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+func TestAPITypes(t *testing.T) {
+	RegisterFailHandler(Fail)
+	LoadConfig(config.LuetCfg)
+	RunSpecs(t, "Types Suite")
+}

pkg/api/core/types/repository.go

@@ -0,0 +1,94 @@
+// Copyright © 2021 Ettore Di Giacinto <mudler@mocaccino.org>
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, see <http://www.gnu.org/licenses/>.
+
+package types
+
+import (
+	"fmt"
+	"runtime"
+
+	"gopkg.in/yaml.v2"
+)
+
+type LuetRepository struct {
+	Name           string            `json:"name" yaml:"name" mapstructure:"name"`
+	Description    string            `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description"`
+	Urls           []string          `json:"urls" yaml:"urls" mapstructure:"urls"`
+	Type           string            `json:"type" yaml:"type" mapstructure:"type"`
+	Mode           string            `json:"mode,omitempty" yaml:"mode,omitempty" mapstructure:"mode,omitempty"`
+	Priority       int               `json:"priority,omitempty" yaml:"priority,omitempty" mapstructure:"priority"`
+	Enable         bool              `json:"enable" yaml:"enable" mapstructure:"enable"`
+	Cached         bool              `json:"cached,omitempty" yaml:"cached,omitempty" mapstructure:"cached,omitempty"`
+	Authentication map[string]string `json:"auth,omitempty" yaml:"auth,omitempty" mapstructure:"auth,omitempty"`
+	TreePath       string            `json:"treepath,omitempty" yaml:"treepath,omitempty" mapstructure:"treepath"`
+	MetaPath       string            `json:"metapath,omitempty" yaml:"metapath,omitempty" mapstructure:"metapath"`
+	Verify         bool              `json:"verify,omitempty" yaml:"verify,omitempty" mapstructure:"verify"`
+	Arch           string            `json:"arch,omitempty" yaml:"arch,omitempty" mapstructure:"arch"`
+
+	// Incremented value that identify revision of the repository in a user-friendly way.
+	Revision int `json:"revision,omitempty" yaml:"-" mapstructure:"-"`
+	// Epoch time in seconds
+	LastUpdate string `json:"last_update,omitempty" yaml:"-" mapstructure:"-"`
+}
+
+func (r *LuetRepository) String() string {
+	return fmt.Sprintf("[%s] prio: %d, type: %s, enable: %t, cached: %t",
+		r.Name, r.Priority, r.Type, r.Enable, r.Cached)
+}
+
+// Enabled returns a boolean indicating if the repository should be considered enabled or not
+func (r *LuetRepository) Enabled() bool {
+	return r.Arch != "" && r.Arch == runtime.GOARCH && !r.Enable || r.Enable
+}
+
+type LuetRepositories []LuetRepository
+
+func (l LuetRepositories) Enabled() (res LuetRepositories) {
+	for _, r := range l {
+		if r.Enabled() {
+			res = append(res, r)
+		}
+	}
+	return
+}
+
+func NewLuetRepository(name, t, descr string, urls []string, priority int, enable, cached bool) *LuetRepository {
+	return &LuetRepository{
+		Name:           name,
+		Description:    descr,
+		Urls:           urls,
+		Type:           t,
+		Priority:       priority,
+		Enable:         enable,
+		Cached:         cached,
+		Authentication: make(map[string]string),
+	}
+}
+
+func NewEmptyLuetRepository() *LuetRepository {
+	return &LuetRepository{
+		Priority:       9999,
+		Authentication: make(map[string]string),
+	}
+}
+
+func LoadRepository(data []byte) (*LuetRepository, error) {
+	ans := NewEmptyLuetRepository()
+	err := yaml.Unmarshal(data, &ans)
+	if err != nil {
+		return nil, err
+	}
+	return ans, nil
+}

pkg/api/core/types/repository_test.go

@@ -0,0 +1,49 @@
+// Copyright © 2021 Ettore Di Giacinto <mudler@mocaccino.org>
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, see <http://www.gnu.org/licenses/>.
+
+package types_test
+
+import (
+	"runtime"
+
+	. "github.com/mudler/luet/pkg/api/core/types"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Types", func() {
+	Context("Repository detects underlying arch", func() {
+		It("is enabled if arch is matching", func() {
+			r := LuetRepository{Arch: runtime.GOARCH}
+			Expect(r.Enabled()).To(BeTrue())
+		})
+		It("is disabled if arch is NOT matching", func() {
+			r := LuetRepository{Arch: "foo"}
+			Expect(r.Enabled()).To(BeFalse())
+		})
+		It("is enabled if arch is NOT matching and enabled is true", func() {
+			r := LuetRepository{Arch: "foo", Enable: true}
+			Expect(r.Enabled()).To(BeTrue())
+		})
+		It("enabled is true", func() {
+			r := LuetRepository{Enable: true}
+			Expect(r.Enabled()).To(BeTrue())
+		})
+		It("enabled is false", func() {
+			r := LuetRepository{Enable: false}
+			Expect(r.Enabled()).To(BeFalse())
+		})
+	})
+})

pkg/config/config.go

@@ -26,6 +26,7 @@ import (
 	"strings"
 	"time"
 
+	types "github.com/mudler/luet/pkg/api/core/types"
 	fileHelper "github.com/mudler/luet/pkg/helpers/file"
 	pkg "github.com/mudler/luet/pkg/package"
 	solver "github.com/mudler/luet/pkg/solver"
@@ -161,64 +162,6 @@ func (sc *LuetSystemConfig) GetRootFsAbs() (string, error) {
 	return filepath.Abs(sc.Rootfs)
 }
 
-type LuetRepository struct {
-	Name           string            `json:"name" yaml:"name" mapstructure:"name"`
-	Description    string            `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description"`
-	Urls           []string          `json:"urls" yaml:"urls" mapstructure:"urls"`
-	Type           string            `json:"type" yaml:"type" mapstructure:"type"`
-	Mode           string            `json:"mode,omitempty" yaml:"mode,omitempty" mapstructure:"mode,omitempty"`
-	Priority       int               `json:"priority,omitempty" yaml:"priority,omitempty" mapstructure:"priority"`
-	Enable         bool              `json:"enable" yaml:"enable" mapstructure:"enable"`
-	Cached         bool              `json:"cached,omitempty" yaml:"cached,omitempty" mapstructure:"cached,omitempty"`
-	Authentication map[string]string `json:"auth,omitempty" yaml:"auth,omitempty" mapstructure:"auth,omitempty"`
-	TreePath       string            `json:"treepath,omitempty" yaml:"treepath,omitempty" mapstructure:"treepath"`
-	MetaPath       string            `json:"metapath,omitempty" yaml:"metapath,omitempty" mapstructure:"metapath"`
-	Verify         bool              `json:"verify,omitempty" yaml:"verify,omitempty" mapstructure:"verify"`
-
-	// Serialized options not used in repository configuration
-
-	// Incremented value that identify revision of the repository in a user-friendly way.
-	Revision int `json:"revision,omitempty" yaml:"-" mapstructure:"-"`
-	// Epoch time in seconds
-	LastUpdate string `json:"last_update,omitempty" yaml:"-" mapstructure:"-"`
-}
-
-func NewLuetRepository(name, t, descr string, urls []string, priority int, enable, cached bool) *LuetRepository {
-	return &LuetRepository{
-		Name:        name,
-		Description: descr,
-		Urls:        urls,
-		Type:        t,
-		// Used in cached repositories
-		Mode:           "",
-		Priority:       priority,
-		Enable:         enable,
-		Cached:         cached,
-		Authentication: make(map[string]string, 0),
-		TreePath:       "",
-		MetaPath:       "",
-	}
-}
-
-func NewEmptyLuetRepository() *LuetRepository {
-	return &LuetRepository{
-		Name:           "",
-		Description:    "",
-		Urls:           []string{},
-		Type:           "",
-		Priority:       9999,
-		TreePath:       "",
-		MetaPath:       "",
-		Enable:         false,
-		Cached:         false,
-		Authentication: make(map[string]string, 0),
-	}
-}
-
-func (r *LuetRepository) String() string {
-	return fmt.Sprintf("[%s] prio: %d, type: %s, enable: %t, cached: %t",
-		r.Name, r.Priority, r.Type, r.Enable, r.Cached)
-}
 
 type LuetKV struct {
 	Key   string `json:"key" yaml:"key" mapstructure:"key"`
@@ -233,12 +176,11 @@ type LuetConfig struct {
 	System  LuetSystemConfig  `yaml:"system" mapstructure:"system"`
 	Solver  LuetSolverOptions `yaml:"solver,omitempty" mapstructure:"solver"`
 
-	RepositoriesConfDir  []string         `yaml:"repos_confdir,omitempty" mapstructure:"repos_confdir"`
-	ConfigProtectConfDir []string         `yaml:"config_protect_confdir,omitempty" mapstructure:"config_protect_confdir"`
-	ConfigProtectSkip    bool             `yaml:"config_protect_skip,omitempty" mapstructure:"config_protect_skip"`
-	ConfigFromHost       bool             `yaml:"config_from_host,omitempty" mapstructure:"config_from_host"`
-	CacheRepositories    []LuetRepository `yaml:"repetitors,omitempty" mapstructure:"repetitors"`
-	SystemRepositories   []LuetRepository `yaml:"repositories,omitempty" mapstructure:"repositories"`
+	RepositoriesConfDir  []string               `yaml:"repos_confdir,omitempty" mapstructure:"repos_confdir"`
+	ConfigProtectConfDir []string               `yaml:"config_protect_confdir,omitempty" mapstructure:"config_protect_confdir"`
+	ConfigProtectSkip    bool                   `yaml:"config_protect_skip,omitempty" mapstructure:"config_protect_skip"`
+	ConfigFromHost       bool                   `yaml:"config_from_host,omitempty" mapstructure:"config_from_host"`
+	SystemRepositories   types.LuetRepositories `yaml:"repositories,omitempty" mapstructure:"repositories"`
 
 	FinalizerEnvs []LuetKV `json:"finalizer_envs,omitempty" yaml:"finalizer_envs,omitempty" mapstructure:"finalizer_envs,omitempty"`
 
@@ -308,7 +250,7 @@ func (c *LuetConfig) GetSystemDB() pkg.PackageDatabase {
 	}
 }
 
-func (c *LuetConfig) AddSystemRepository(r LuetRepository) {
+func (c *LuetConfig) AddSystemRepository(r types.LuetRepository) {
 	c.SystemRepositories = append(c.SystemRepositories, r)
 }
 
@@ -396,8 +338,8 @@ func (c *LuetConfig) AddConfigProtectConfFile(file *ConfigProtectConfFile) {
 	}
 }
 
-func (c *LuetConfig) GetSystemRepository(name string) (*LuetRepository, error) {
-	var ans *LuetRepository = nil
+func (c *LuetConfig) GetSystemRepository(name string) (*types.LuetRepository, error) {
+	var ans *types.LuetRepository = nil
 
 	for idx, repo := range c.SystemRepositories {
 		if repo.Name == name {

pkg/installer/installer.go

@@ -24,6 +24,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/mudler/luet/pkg/api/core/types"
 	"github.com/mudler/luet/pkg/bus"
 	artifact "github.com/mudler/luet/pkg/compiler/types/artifact"
 	"github.com/mudler/luet/pkg/config"
@@ -51,11 +52,10 @@ type LuetInstallerOptions struct {
 	Ask                                                            bool
 	DownloadOnly                                                   bool
 	Relaxed                                                        bool
+	PackageRepositories                                            types.LuetRepositories
 }
 
 type LuetInstaller struct {
-	PackageRepositories Repositories
-
 	Options LuetInstallerOptions
 }
 
@@ -148,7 +148,7 @@ func matchesToList(artefacts map[string]ArtifactMatch) string {
 // Upgrade upgrades a System based on the Installer options. Returns error in case of failure
 func (l *LuetInstaller) Upgrade(s *System) error {
 
-	syncedRepos, err := l.SyncRepositories(true)
+	syncedRepos, err := l.SyncRepositories()
 	if err != nil {
 		return err
 	}
@@ -161,11 +161,11 @@ func (l *LuetInstaller) Upgrade(s *System) error {
 	return l.checkAndUpgrade(syncedRepos, s)
 }
 
-func (l *LuetInstaller) SyncRepositories(inMemory bool) (Repositories, error) {
+func (l *LuetInstaller) SyncRepositories() (Repositories, error) {
 	Spinner(32)
 	defer SpinnerStop()
 	syncedRepos := Repositories{}
-	for _, r := range l.PackageRepositories {
+	for _, r := range SystemRepositories(l.Options.PackageRepositories) {
 		repo, err := r.Sync(false)
 		if err != nil {
 			return nil, errors.Wrap(err, "Failed syncing repository: "+r.GetName())
@@ -176,15 +176,11 @@ func (l *LuetInstaller) SyncRepositories(inMemory bool) (Repositories, error) {
 	// compute what to install and from where
 	sort.Sort(syncedRepos)
 
-	if !inMemory {
-		l.PackageRepositories = syncedRepos
-	}
-
 	return syncedRepos, nil
 }
 
 func (l *LuetInstaller) Swap(toRemove pkg.Packages, toInstall pkg.Packages, s *System) error {
-	syncedRepos, err := l.SyncRepositories(true)
+	syncedRepos, err := l.SyncRepositories()
 	if err != nil {
 		return err
 	}
@@ -509,7 +505,7 @@ func (l *LuetInstaller) checkAndUpgrade(r Repositories, s *System) error {
 }
 
 func (l *LuetInstaller) Install(cp pkg.Packages, s *System) error {
-	syncedRepos, err := l.SyncRepositories(true)
+	syncedRepos, err := l.SyncRepositories()
 	if err != nil {
 		return err
 	}
@@ -603,7 +599,7 @@ func (l *LuetInstaller) download(syncedRepos Repositories, toDownload map[string
 // if files from artifacts in the repositories are found
 // in the system target
 func (l *LuetInstaller) Reclaim(s *System) error {
-	syncedRepos, err := l.SyncRepositories(true)
+	syncedRepos, err := l.SyncRepositories()
 	if err != nil {
 		return err
 	}
@@ -1197,5 +1193,3 @@ func (l *LuetInstaller) Uninstall(s *System, packs ...pkg.Package) error {
 	}
 	return uninstall()
 }
-
-func (l *LuetInstaller) Repositories(r []*LuetSystemRepository) { l.PackageRepositories = r }

pkg/installer/installer_test.go

@@ -21,6 +21,7 @@ import (
 	"path/filepath"
 
 	//	. "github.com/mudler/luet/pkg/installer"
+	"github.com/mudler/luet/pkg/api/core/types"
 	compiler "github.com/mudler/luet/pkg/compiler"
 	backend "github.com/mudler/luet/pkg/compiler/backend"
 	compression "github.com/mudler/luet/pkg/compiler/types/compression"
@@ -121,16 +122,18 @@ var _ = Describe("Installer", func() {
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
-
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 			systemDB := pkg.NewInMemoryDatabase(false)
@@ -241,16 +244,19 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 			systemDB := pkg.NewInMemoryDatabase(false)
@@ -365,16 +371,18 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
-
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 
@@ -492,16 +500,19 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 
@@ -547,15 +558,18 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst = NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err = NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir2+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
-			inst.Repositories(Repositories{repo2})
+			inst = NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir2))
 			Expect(repo.GetType()).To(Equal("disk"))
 			system.Target = fakeroot
@@ -625,16 +639,18 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
-
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 
@@ -749,10 +765,10 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
@@ -761,12 +777,15 @@ urls:
 			repoupgrade2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdirnewrepo+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
-
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 
@@ -792,7 +811,8 @@ urls:
 			files, err := systemDB.GetPackageFiles(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"})
 			Expect(files).To(Equal([]string{"artifact42", "test5", "test6"}))
 			Expect(err).ToNot(HaveOccurred())
-			inst.Repositories(Repositories{repoupgrade2})
+
+			inst.Options.PackageRepositories = types.LuetRepositories{*repoupgrade2.LuetRepository}
 
 			err = inst.Upgrade(system)
 			Expect(err).ToNot(HaveOccurred())
@@ -879,16 +899,20 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
+
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 
@@ -1037,16 +1061,20 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
+
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 
@@ -1136,16 +1164,20 @@ urls:
 			Expect(err).ToNot(HaveOccurred())
 			defer os.RemoveAll(fakeroot) // clean up
 
-			inst := NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 
-			inst.Repositories(Repositories{repo2})
+			inst := NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
+
 			Expect(repo.GetUrls()[0]).To(Equal(tmpdir))
 			Expect(repo.GetType()).To(Equal("disk"))
 
@@ -1209,16 +1241,20 @@ urls:
 			err = repo.Write(tmpdir2, false, false)
 			Expect(err).ToNot(HaveOccurred())
 
-			inst = NewLuetInstaller(LuetInstallerOptions{Concurrency: 1})
 			repo2, err = NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
+enable: true
 urls:
   - "`+tmpdir2+`"
 `), pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 
-			inst.Repositories(Repositories{repo2})
+			inst = NewLuetInstaller(LuetInstallerOptions{
+				Concurrency:         1,
+				PackageRepositories: types.LuetRepositories{*repo2.LuetRepository},
+			})
+
 			err = inst.Upgrade(system)
 			Expect(err).ToNot(HaveOccurred())
 

pkg/installer/repository.go

@@ -32,10 +32,12 @@ import (
 	fileHelper "github.com/mudler/luet/pkg/helpers/file"
 	"go.uber.org/multierr"
 
+	"github.com/mudler/luet/pkg/api/core/types"
 	"github.com/mudler/luet/pkg/compiler"
 	"github.com/mudler/luet/pkg/config"
 	"github.com/mudler/luet/pkg/installer/client"
 	. "github.com/mudler/luet/pkg/logger"
+
 	pkg "github.com/mudler/luet/pkg/package"
 	tree "github.com/mudler/luet/pkg/tree"
 
@@ -65,7 +67,7 @@ type LuetRepositoryFile struct {
 }
 
 type LuetSystemRepository struct {
-	*config.LuetRepository
+	*types.LuetRepository
 
 	Index           compiler.ArtifactIndex        `json:"index"`
 	BuildTree, Tree tree.Builder                  `json:"-"`
@@ -104,12 +106,10 @@ func NewLuetSystemRepositoryMetadata(file string, removeFile bool) (*LuetSystemR
 }
 
 // SystemRepositories returns the repositories from the local configuration file
-func SystemRepositories(c *config.LuetConfig) Repositories {
+// it filters the available repositories returning the ones that are enabled
+func SystemRepositories(t types.LuetRepositories) Repositories {
 	repos := Repositories{}
-	for _, repo := range c.SystemRepositories {
-		if !repo.Enable {
-			continue
-		}
+	for _, repo := range t.Enabled() {
 		r := NewSystemRepository(repo)
 		repos = append(repos, r)
 	}
@@ -119,7 +119,7 @@ func SystemRepositories(c *config.LuetConfig) Repositories {
 // LoadBuildTree loads to the tree the compilation specs from the system repositories
 func LoadBuildTree(t tree.Builder, db pkg.PackageDatabase, c *config.LuetConfig) error {
 	var reserr error
-	repos := SystemRepositories(c)
+	repos := SystemRepositories(c.SystemRepositories)
 	for _, r := range repos {
 		repodir, err := config.LuetCfg.GetSystem().TempDir(r.Name)
 		if err != nil {
@@ -340,7 +340,7 @@ func GenerateRepository(p ...RepositoryOption) (*LuetSystemRepository, error) {
 	}
 
 	repo := &LuetSystemRepository{
-		LuetRepository:  config.NewLuetRepository(c.Name, c.Type, c.Description, c.Urls, c.Priority, true, false),
+		LuetRepository:  types.NewLuetRepository(c.Name, c.Type, c.Description, c.Urls, c.Priority, true, false),
 		Tree:            tree.NewInstallerRecipe(runtimeTree),
 		BuildTree:       btr,
 		RepositoryFiles: map[string]LuetRepositoryFile{},
@@ -357,7 +357,7 @@ func GenerateRepository(p ...RepositoryOption) (*LuetSystemRepository, error) {
 	return repo, nil
 }
 
-func NewSystemRepository(repo config.LuetRepository) *LuetSystemRepository {
+func NewSystemRepository(repo types.LuetRepository) *LuetSystemRepository {
 	return &LuetSystemRepository{
 		LuetRepository:  &repo,
 		RepositoryFiles: map[string]LuetRepositoryFile{},

pkg/installer/repository_test.go

@@ -24,11 +24,11 @@ import (
 	"os"
 	"path/filepath"
 
+	"github.com/mudler/luet/pkg/api/core/types"
 	"github.com/mudler/luet/pkg/compiler"
 	backend "github.com/mudler/luet/pkg/compiler/backend"
 	artifact "github.com/mudler/luet/pkg/compiler/types/artifact"
 	compilerspec "github.com/mudler/luet/pkg/compiler/types/spec"
-	config "github.com/mudler/luet/pkg/config"
 	"github.com/mudler/luet/pkg/helpers"
 	fileHelper "github.com/mudler/luet/pkg/helpers/file"
 	. "github.com/mudler/luet/pkg/installer"
@@ -335,8 +335,8 @@ urls:
 
 			_, err = builder2.GetDatabase().CreatePackage(package2)
 			Expect(err).ToNot(HaveOccurred())
-			repo1 := &LuetSystemRepository{LuetRepository: &config.LuetRepository{Name: "test1"}, Tree: builder1}
-			repo2 := &LuetSystemRepository{LuetRepository: &config.LuetRepository{Name: "test2"}, Tree: builder2}
+			repo1 := &LuetSystemRepository{LuetRepository: &types.LuetRepository{Name: "test1"}, Tree: builder1}
+			repo2 := &LuetSystemRepository{LuetRepository: &types.LuetRepository{Name: "test2"}, Tree: builder2}
 			repositories := Repositories{repo1, repo2}
 			matches := repositories.PackageMatches([]pkg.Package{package1})
 			Expect(matches).To(Equal([]PackageMatch{{Repo: repo1, Package: package1}}))

pkg/repository/loader.go

@@ -22,7 +22,7 @@ import (
 	"path/filepath"
 	"regexp"
 
-	"github.com/ghodss/yaml"
+	"github.com/mudler/luet/pkg/api/core/types"
 
 	. "github.com/mudler/luet/pkg/config"
 	. "github.com/mudler/luet/pkg/logger"
@@ -70,7 +70,7 @@ func LoadRepositories(c *LuetConfig) error {
 				continue
 			}
 
-			r, err := LoadRepository(content)
+			r, err := types.LoadRepository(content)
 			if err != nil {
 				Warning("On parse file", file.Name(), ":", err.Error())
 				Warning("File", file.Name(), "skipped.")
@@ -88,12 +88,3 @@ func LoadRepositories(c *LuetConfig) error {
 	}
 	return nil
 }
-
-func LoadRepository(data []byte) (*LuetRepository, error) {
-	ans := NewEmptyLuetRepository()
-	err := yaml.Unmarshal(data, &ans)
-	if err != nil {
-		return nil, err
-	}
-	return ans, nil
-}