Integrate config.LuetRepository with installer

* installer.LuetRepository is now installer.LuetSystemRepository,
  a struct that extend config.LuetRepository

* config: system_repositories option is now "repositories".
  This resolve viper issue.

* config: cache_repositories option is now "repetitors"
  This resolve viper issue.

* cmd/*: Now use new config.LuetRepository

* cmd/search: now create local luet repository if database_engine
  is equal to "boltdb"

cmd/create-repo.go

@@ -35,7 +35,8 @@ var createrepoCmd = &cobra.Command{
 		viper.BindPFlag("tree", cmd.Flags().Lookup("tree"))
 		viper.BindPFlag("output", cmd.Flags().Lookup("output"))
 		viper.BindPFlag("name", cmd.Flags().Lookup("name"))
-		viper.BindPFlag("uri", cmd.Flags().Lookup("uri"))
+		viper.BindPFlag("descr", cmd.Flags().Lookup("descr"))
+		viper.BindPFlag("urls", cmd.Flags().Lookup("urls"))
 		viper.BindPFlag("type", cmd.Flags().Lookup("type"))
 	},
 	Run: func(cmd *cobra.Command, args []string) {
@@ -44,10 +45,11 @@ var createrepoCmd = &cobra.Command{
 		dst := viper.GetString("output")
 		packages := viper.GetString("packages")
 		name := viper.GetString("name")
-		uri := viper.GetString("uri")
+		descr := viper.GetString("descr")
+		urls := viper.GetStringSlice("urls")
 		t := viper.GetString("type")
 
-		repo, err := installer.GenerateRepository(name, uri, t, 1, packages, tree, pkg.NewInMemoryDatabase(false))
+		repo, err := installer.GenerateRepository(name, descr, t, urls, 1, packages, tree, pkg.NewInMemoryDatabase(false))
 		if err != nil {
 			Fatal("Error: " + err.Error())
 		}
@@ -67,8 +69,9 @@ func init() {
 	createrepoCmd.Flags().String("tree", path, "Source luet tree")
 	createrepoCmd.Flags().String("output", path, "Destination folder")
 	createrepoCmd.Flags().String("name", "luet", "Repository name")
-	createrepoCmd.Flags().String("uri", path, "Repository uri")
+	createrepoCmd.Flags().String("descr", "luet", "Repository description")
-	createrepoCmd.Flags().String("type", "local", "Repository type (local)")
+	createrepoCmd.Flags().StringSlice("urls", []string{}, "Repository URLs")
+	createrepoCmd.Flags().String("type", "disk", "Repository type (disk)")
 
 	RootCmd.AddCommand(createrepoCmd)
 }

cmd/install.go

@@ -27,25 +27,19 @@ import (
 
 	_gentoo "github.com/Sabayon/pkgs-checker/pkg/gentoo"
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 var installCmd = &cobra.Command{
 	Use:   "install <pkg1> <pkg2> ...",
 	Short: "Install a package",
 	PreRun: func(cmd *cobra.Command, args []string) {
-		viper.BindPFlag("system-dbpath", cmd.Flags().Lookup("system-dbpath"))
+		LuetCfg.Viper.BindPFlag("system.database_path", cmd.Flags().Lookup("system-dbpath"))
-		viper.BindPFlag("system-target", cmd.Flags().Lookup("system-target"))
+		LuetCfg.Viper.BindPFlag("system.rootfs", cmd.Flags().Lookup("system-target"))
 	},
 	Long: `Install packages in parallel`,
 	Run: func(cmd *cobra.Command, args []string) {
-		c := []*installer.LuetRepository{}
-		err := viper.UnmarshalKey("system-repositories", &c)
-		if err != nil {
-			Fatal("Error: " + err.Error())
-		}
-
 		var toInstall []pkg.Package
+		var systemDB pkg.PackageDatabase
 
 		for _, a := range args {
 			gp, err := _gentoo.ParsePackageStr(a)
@@ -69,7 +63,12 @@ var installCmd = &cobra.Command{
 
 		// 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
 		synced := installer.Repositories{}
-		for _, toSync := range c {
+		for _, repo := range LuetCfg.SystemRepositories {
+			if !repo.Enable {
+				continue
+			}
+
+			toSync := installer.NewSystemRepository(&repo)
 			s, err := toSync.Sync()
 			if err != nil {
 				Fatal("Error: " + err.Error())
@@ -78,13 +77,21 @@ var installCmd = &cobra.Command{
 		}
 
 		inst := installer.NewLuetInstaller(LuetCfg.GetGeneral().Concurrency)
-
 		inst.Repositories(synced)
 
-		os.MkdirAll(viper.GetString("system-dbpath"), os.ModePerm)
+		if LuetCfg.GetSystem().DatabaseEngine == "boltdb" {
-		systemDB := pkg.NewBoltDatabase(filepath.Join(viper.GetString("system-dbpath"), "luet.db"))
+			os.MkdirAll(
-		system := &installer.System{Database: systemDB, Target: viper.GetString("system-target")}
+				filepath.Join(LuetCfg.GetSystem().Rootfs, LuetCfg.GetSystem().DatabasePath),
-		err = inst.Install(toInstall, system)
+				os.ModePerm,
+			)
+			systemDB = pkg.NewBoltDatabase(
+				filepath.Join(LuetCfg.GetSystem().Rootfs,
+					filepath.Join(LuetCfg.GetSystem().DatabasePath, "luet.db")))
+		} else {
+			systemDB = pkg.NewInMemoryDatabase(true)
+		}
+		system := &installer.System{Database: systemDB, Target: LuetCfg.GetSystem().Rootfs}
+		err := inst.Install(toInstall, system)
 		if err != nil {
 			Fatal("Error: " + err.Error())
 		}

cmd/search.go

@@ -21,6 +21,7 @@ import (
 
 	installer "github.com/mudler/luet/pkg/installer"
 
+	. "github.com/mudler/luet/pkg/config"
 	. "github.com/mudler/luet/pkg/logger"
 	pkg "github.com/mudler/luet/pkg/package"
 
@@ -33,16 +34,12 @@ var searchCmd = &cobra.Command{
 	Short: "Search packages",
 	Long:  `Search for installed and available packages`,
 	PreRun: func(cmd *cobra.Command, args []string) {
-		viper.BindPFlag("system-dbpath", cmd.Flags().Lookup("system-dbpath"))
+		LuetCfg.Viper.BindPFlag("system.database_path", installCmd.Flags().Lookup("system-dbpath"))
-		viper.BindPFlag("system-target", cmd.Flags().Lookup("system-target"))
+		LuetCfg.Viper.BindPFlag("system.rootfs", installCmd.Flags().Lookup("system-target"))
 		viper.BindPFlag("installed", cmd.Flags().Lookup("installed"))
 	},
 	Run: func(cmd *cobra.Command, args []string) {
-		c := []*installer.LuetRepository{}
+		var systemDB pkg.PackageDatabase
-		err := viper.UnmarshalKey("system-repositories", &c)
-		if err != nil {
-			Fatal("Error: " + err.Error())
-		}
 
 		if len(args) != 1 {
 			Fatal("Wrong number of arguments (expected 1)")
@@ -52,7 +49,12 @@ var searchCmd = &cobra.Command{
 		if !installed {
 			synced := installer.Repositories{}
 
-			for _, toSync := range c {
+			for _, repo := range LuetCfg.SystemRepositories {
+				if !repo.Enable {
+					continue
+				}
+
+				toSync := installer.NewSystemRepository(&repo)
 				s, err := toSync.Sync()
 				if err != nil {
 					Fatal("Error: " + err.Error())
@@ -63,12 +65,22 @@ var searchCmd = &cobra.Command{
 
 			matches := synced.Search(args[0])
 			for _, m := range matches {
-				Info(":package:", m.Package.GetCategory(), m.Package.GetName(), m.Package.GetVersion(), "repository:", m.Repo.GetName())
+				Info(":package:", m.Package.GetCategory(), m.Package.GetName(),
+					m.Package.GetVersion(), "repository:", m.Repo.GetName())
 			}
 		} else {
-			os.MkdirAll(viper.GetString("system-dbpath"), os.ModePerm)
+			if LuetCfg.GetSystem().DatabaseEngine == "boltdb" {
-			systemDB := pkg.NewBoltDatabase(filepath.Join(viper.GetString("system-dbpath"), "luet.db"))
+				os.MkdirAll(
-			system := &installer.System{Database: systemDB, Target: viper.GetString("system-target")}
+					filepath.Join(LuetCfg.GetSystem().Rootfs, LuetCfg.GetSystem().DatabasePath),
+					os.ModePerm,
+				)
+				systemDB = pkg.NewBoltDatabase(
+					filepath.Join(LuetCfg.GetSystem().Rootfs,
+						filepath.Join(LuetCfg.GetSystem().DatabasePath, "luet.db")))
+			} else {
+				systemDB = pkg.NewInMemoryDatabase(true)
+			}
+			system := &installer.System{Database: systemDB, Target: LuetCfg.GetSystem().Rootfs}
 			var term = regexp.MustCompile(args[0])
 
 			for _, k := range system.Database.GetPackages() {

cmd/upgrade.go

@@ -25,27 +25,26 @@ import (
 	pkg "github.com/mudler/luet/pkg/package"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
 )
 
 var upgradeCmd = &cobra.Command{
 	Use:   "upgrade",
 	Short: "Upgrades the system",
 	PreRun: func(cmd *cobra.Command, args []string) {
-		viper.BindPFlag("system-dbpath", cmd.Flags().Lookup("system-dbpath"))
+		LuetCfg.Viper.BindPFlag("system.database_path", installCmd.Flags().Lookup("system-dbpath"))
-		viper.BindPFlag("system-target", cmd.Flags().Lookup("system-target"))
+		LuetCfg.Viper.BindPFlag("system.rootfs", installCmd.Flags().Lookup("system-target"))
 	},
 	Long: `Upgrades packages in parallel`,
 	Run: func(cmd *cobra.Command, args []string) {
-		c := []*installer.LuetRepository{}
+		var systemDB pkg.PackageDatabase
-		err := viper.UnmarshalKey("system-repositories", &c)
-		if err != nil {
-			Fatal("Error: " + err.Error())
-		}
 
-		// 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
 		synced := installer.Repositories{}
-		for _, toSync := range c {
+		for _, repo := range LuetCfg.SystemRepositories {
+			if !repo.Enable {
+				continue
+			}
+
+			toSync := installer.NewSystemRepository(&repo)
 			s, err := toSync.Sync()
 			if err != nil {
 				Fatal("Error: " + err.Error())
@@ -57,10 +56,19 @@ var upgradeCmd = &cobra.Command{
 
 		inst.Repositories(synced)
 
-		os.MkdirAll(viper.GetString("system-dbpath"), os.ModePerm)
+		if LuetCfg.GetSystem().DatabaseEngine == "boltdb" {
-		systemDB := pkg.NewBoltDatabase(filepath.Join(viper.GetString("system-dbpath"), "luet.db"))
+			os.MkdirAll(
-		system := &installer.System{Database: systemDB, Target: viper.GetString("system-target")}
+				filepath.Join(LuetCfg.GetSystem().Rootfs, LuetCfg.GetSystem().DatabasePath),
-		err = inst.Upgrade(system)
+				os.ModePerm,
+			)
+			systemDB = pkg.NewBoltDatabase(
+				filepath.Join(LuetCfg.GetSystem().Rootfs,
+					filepath.Join(LuetCfg.GetSystem().DatabasePath, "luet.db")))
+		} else {
+			systemDB = pkg.NewInMemoryDatabase(true)
+		}
+		system := &installer.System{Database: systemDB, Target: LuetCfg.GetSystem().Rootfs}
+		err := inst.Upgrade(system)
 		if err != nil {
 			Fatal("Error: " + err.Error())
 		}

pkg/config/config.go

@@ -54,6 +54,26 @@ type LuetRepository struct {
 	Priority       int               `yaml:"priority,omitempty" mapstructure:"priority"`
 	Enable         bool              `yaml:"enable" mapstructure:"enable"`
 	Authentication map[string]string `yaml:"auth,omitempty" mapstructure:"auth"`
+	TreePath       string            `yaml::"tree_path,omitempty" mapstructure:"tree_path"`
+}
+
+func NewLuetRepository(name, t, descr string, urls []string, priority int, enable bool) *LuetRepository {
+	return &LuetRepository{
+		Name:        name,
+		Description: descr,
+		Urls:        urls,
+		Type:        t,
+		// Used in cached repositories
+		Mode:           "",
+		Priority:       priority,
+		Enable:         enable,
+		Authentication: make(map[string]string, 0),
+		TreePath:       "",
+	}
+}
+
+func (r *LuetRepository) String() string {
+	return fmt.Sprintf("[%s] prio: %d, type: %s, enable: %t", r.Name, r.Priority, r.Type, r.Enable)
 }
 
 type LuetConfig struct {
@@ -64,12 +84,8 @@ type LuetConfig struct {
 	System  LuetSystemConfig  `mapstructure:"system"`
 
 	RepositoriesConfDir []string         `mapstructure:"repos_confdir"`
-	CacheRepositories   []LuetRepository `mapstructure:"cache_repositories"`
+	CacheRepositories   []LuetRepository `mapstructure:"repetitors"`
-	SystemRepositories  []LuetRepository `mapstructure:"system_repositories"`
+	SystemRepositories  []LuetRepository `mapstructure:"repositories"`
-}
-
-func (r *LuetRepository) String() string {
-	return fmt.Sprintf("[%s] prio: %d, type: %s, enable: %t", r.Name, r.Priority, r.Type, r.Enable)
 }
 
 func NewLuetConfig(viper *v.Viper) *LuetConfig {

pkg/installer/installer_test.go

@@ -35,7 +35,7 @@ import (
 var _ = Describe("Installer", func() {
 	Context("Writes a repository definition", func() {
 		It("Writes a repo and can install packages from it", func() {
-			//repo:=NewLuetRepository()
+			//repo:=NewLuetSystemRepository()
 
 			tmpdir, err := ioutil.TempDir("", "tree")
 			Expect(err).ToNot(HaveOccurred())
@@ -83,7 +83,7 @@ var _ = Describe("Installer", func() {
 			Expect(helpers.Exists(spec.Rel("b-test-1.0.package.tar"))).To(BeTrue())
 			Expect(helpers.Exists(spec.Rel("b-test-1.0.metadata.yaml"))).To(BeTrue())
 
-			repo, err := GenerateRepository("test", tmpdir, "disk", 1, tmpdir, "../../tests/fixtures/buildable", pkg.NewInMemoryDatabase(false))
+			repo, err := GenerateRepository("test", "description", "disk", []string{tmpdir}, 1, tmpdir, "../../tests/fixtures/buildable", pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(repo.GetName()).To(Equal("test"))
 			Expect(helpers.Exists(spec.Rel("repository.yaml"))).ToNot(BeTrue())
@@ -101,7 +101,7 @@ var _ = Describe("Installer", func() {
 			defer os.RemoveAll(fakeroot) // clean up
 
 			inst := NewLuetInstaller(1)
-			repo2, err := NewLuetRepositoryFromYaml([]byte(`
+			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
 urls:
@@ -149,7 +149,7 @@ urls:
 
 	Context("Installation", func() {
 		It("Installs in a system with a persistent db", func() {
-			//repo:=NewLuetRepository()
+			//repo:=NewLuetSystemRepository()
 
 			tmpdir, err := ioutil.TempDir("", "tree")
 			Expect(err).ToNot(HaveOccurred())
@@ -197,7 +197,7 @@ urls:
 			Expect(helpers.Exists(spec.Rel("b-test-1.0.package.tar"))).To(BeTrue())
 			Expect(helpers.Exists(spec.Rel("b-test-1.0.metadata.yaml"))).To(BeTrue())
 
-			repo, err := GenerateRepository("test", tmpdir, "disk", 1, tmpdir, "../../tests/fixtures/buildable", pkg.NewInMemoryDatabase(false))
+			repo, err := GenerateRepository("test", "description", "disk", []string{tmpdir}, 1, tmpdir, "../../tests/fixtures/buildable", pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(repo.GetName()).To(Equal("test"))
 			Expect(helpers.Exists(spec.Rel("repository.yaml"))).ToNot(BeTrue())
@@ -215,7 +215,7 @@ urls:
 			defer os.RemoveAll(fakeroot) // clean up
 
 			inst := NewLuetInstaller(1)
-			repo2, err := NewLuetRepositoryFromYaml([]byte(`
+			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
 urls:
@@ -268,7 +268,7 @@ urls:
 
 	Context("Simple upgrades", func() {
 		It("Installs packages and Upgrades a system with a persistent db", func() {
-			//repo:=NewLuetRepository()
+			//repo:=NewLuetSystemRepository()
 
 			tmpdir, err := ioutil.TempDir("", "tree")
 			Expect(err).ToNot(HaveOccurred())
@@ -305,7 +305,7 @@ urls:
 
 			Expect(errs).To(BeEmpty())
 
-			repo, err := GenerateRepository("test", tmpdir, "disk", 1, tmpdir, "../../tests/fixtures/upgrade", pkg.NewInMemoryDatabase(false))
+			repo, err := GenerateRepository("test", "description", "disk", []string{tmpdir}, 1, tmpdir, "../../tests/fixtures/upgrade", pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(repo.GetName()).To(Equal("test"))
 			Expect(helpers.Exists(spec.Rel("repository.yaml"))).ToNot(BeTrue())
@@ -323,7 +323,7 @@ urls:
 			defer os.RemoveAll(fakeroot) // clean up
 
 			inst := NewLuetInstaller(1)
-			repo2, err := NewLuetRepositoryFromYaml([]byte(`
+			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
 urls:
@@ -382,7 +382,7 @@ urls:
 
 	Context("Compressed packages", func() {
 		It("Installs", func() {
-			//repo:=NewLuetRepository()
+			//repo:=NewLuetSystemRepository()
 
 			tmpdir, err := ioutil.TempDir("", "tree")
 			Expect(err).ToNot(HaveOccurred())
@@ -418,7 +418,7 @@ urls:
 
 			Expect(errs).To(BeEmpty())
 
-			repo, err := GenerateRepository("test", tmpdir, "disk", 1, tmpdir, "../../tests/fixtures/upgrade", pkg.NewInMemoryDatabase(false))
+			repo, err := GenerateRepository("test", "description", "disk", []string{tmpdir}, 1, tmpdir, "../../tests/fixtures/upgrade", pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(repo.GetName()).To(Equal("test"))
 			Expect(helpers.Exists(spec.Rel("repository.yaml"))).ToNot(BeTrue())
@@ -438,7 +438,7 @@ urls:
 			defer os.RemoveAll(fakeroot) // clean up
 
 			inst := NewLuetInstaller(1)
-			repo2, err := NewLuetRepositoryFromYaml([]byte(`
+			repo2, err := NewLuetSystemRepositoryFromYaml([]byte(`
 name: "test"
 type: "disk"
 urls:

pkg/installer/interface.go

@@ -38,6 +38,7 @@ type Repositories []Repository
 
 type Repository interface {
 	GetName() string
+	GetDescription() string
 	GetUrls() []string
 	SetUrls([]string)
 	AddUrl(string)

pkg/installer/repository.go

@@ -27,31 +27,30 @@ import (
 
 	"github.com/ghodss/yaml"
 	"github.com/mudler/luet/pkg/compiler"
+	"github.com/mudler/luet/pkg/config"
 	"github.com/mudler/luet/pkg/helpers"
 	pkg "github.com/mudler/luet/pkg/package"
 	tree "github.com/mudler/luet/pkg/tree"
 	"github.com/pkg/errors"
 )
 
-type LuetRepository struct {
+type LuetSystemRepository struct {
-	Name     string                 `json:"name"`
+	*config.LuetRepository
-	Urls     []string               `json:"urls"`
+
-	Priority int                    `json:"priority"`
+	Index compiler.ArtifactIndex `json:"index"`
-	Index    compiler.ArtifactIndex `json:"index"`
+	Tree  tree.Builder           `json:"-"`
-	Tree     tree.Builder           `json:"-"`
-	TreePath string                 `json:"-"`
-	Type     string                 `json:"type"`
 }
 
-type LuetRepositorySerialized struct {
+type LuetSystemRepositorySerialized struct {
-	Name     string                      `json:"name"`
+	Name        string                      `json:"name"`
-	Urls     []string                    `json:"urls"`
+	Description string                      `json:"description,omitempty"`
-	Priority int                         `json:"priority"`
+	Urls        []string                    `json:"urls"`
-	Index    []*compiler.PackageArtifact `json:"index"`
+	Priority    int                         `json:"priority"`
-	Type     string                      `json:"type"`
+	Index       []*compiler.PackageArtifact `json:"index"`
+	Type        string                      `json:"type"`
 }
 
-func GenerateRepository(name, uri, t string, priority int, src, treeDir string, db pkg.PackageDatabase) (Repository, error) {
+func GenerateRepository(name, descr, t string, urls []string, priority int, src, treeDir string, db pkg.PackageDatabase) (Repository, error) {
 
 	art, err := buildPackageIndex(src)
 	if err != nil {
@@ -63,24 +62,41 @@ func GenerateRepository(name, uri, t string, priority int, src, treeDir string,
 		return nil, err
 	}
 
-	return NewLuetRepository(name, uri, t, priority, art, tr), nil
+	return NewLuetSystemRepository(
+		config.NewLuetRepository(name, t, descr, urls, priority, true),
+		art, tr), nil
 }
 
-func NewLuetRepository(name, uri, t string, priority int, art []compiler.Artifact, builder tree.Builder) Repository {
+func NewSystemRepository(repo *config.LuetRepository) Repository {
-	return &LuetRepository{Index: art, Type: t, Tree: builder, Name: name, Urls: []string{uri}, Priority: priority}
+	return &LuetSystemRepository{
+		LuetRepository: repo,
+	}
 }
 
-func NewLuetRepositoryFromYaml(data []byte, db pkg.PackageDatabase) (Repository, error) {
+func NewLuetSystemRepository(repo *config.LuetRepository, art []compiler.Artifact, builder tree.Builder) Repository {
-	var p *LuetRepositorySerialized
+	return &LuetSystemRepository{
-	r := &LuetRepository{}
+		LuetRepository: repo,
+		Index:          art,
+		Tree:           builder,
+	}
+}
+
+func NewLuetSystemRepositoryFromYaml(data []byte, db pkg.PackageDatabase) (Repository, error) {
+	var p *LuetSystemRepositorySerialized
 	err := yaml.Unmarshal(data, &p)
 	if err != nil {
 		return nil, err
 	}
-	r.Name = p.Name
+	r := &LuetSystemRepository{
-	r.Urls = p.Urls
+		LuetRepository: config.NewLuetRepository(
-	r.Priority = p.Priority
+			p.Name,
-	r.Type = p.Type
+			p.Type,
+			p.Description,
+			p.Urls,
+			p.Priority,
+			true,
+		),
+	}
 	i := compiler.ArtifactIndex{}
 	for _, ii := range p.Index {
 		i = append(i, ii)
@@ -122,47 +138,46 @@ func buildPackageIndex(path string) ([]compiler.Artifact, error) {
 	return art, nil
 }
 
-func (r *LuetRepository) GetName() string {
+func (r *LuetSystemRepository) GetName() string {
-	return r.Name
+	return r.LuetRepository.Name
 }
-func (r *LuetRepository) GetTreePath() string {
+func (r *LuetSystemRepository) GetDescription() string {
+	return r.LuetRepository.Description
+}
+func (r *LuetSystemRepository) GetType() string {
+	return r.LuetRepository.Type
+}
+func (r *LuetSystemRepository) SetType(p string) {
+	r.LuetRepository.Type = p
+}
+func (r *LuetSystemRepository) AddUrl(p string) {
+	r.LuetRepository.Urls = append(r.LuetRepository.Urls, p)
+}
+func (r *LuetSystemRepository) GetUrls() []string {
+	return r.LuetRepository.Urls
+}
+func (r *LuetSystemRepository) SetUrls(urls []string) {
+	r.LuetRepository.Urls = urls
+}
+func (r *LuetSystemRepository) GetPriority() int {
+	return r.LuetRepository.Priority
+}
+func (r *LuetSystemRepository) GetTreePath() string {
 	return r.TreePath
 }
-func (r *LuetRepository) SetTreePath(p string) {
+func (r *LuetSystemRepository) SetTreePath(p string) {
 	r.TreePath = p
 }
-
+func (r *LuetSystemRepository) SetTree(b tree.Builder) {
-func (r *LuetRepository) SetTree(b tree.Builder) {
 	r.Tree = b
 }
-
+func (r *LuetSystemRepository) GetIndex() compiler.ArtifactIndex {
-func (r *LuetRepository) GetType() string {
-	return r.Type
-}
-func (r *LuetRepository) SetType(p string) {
-	r.Type = p
-}
-
-func (r *LuetRepository) AddUrl(p string) {
-	r.Urls = append(r.Urls, p)
-}
-func (r *LuetRepository) GetUrls() []string {
-	return r.Urls
-}
-func (r *LuetRepository) SetUrls(urls []string) {
-	r.Urls = urls
-}
-func (r *LuetRepository) GetPriority() int {
-	return r.Priority
-}
-func (r *LuetRepository) GetIndex() compiler.ArtifactIndex {
 	return r.Index
 }
-func (r *LuetRepository) GetTree() tree.Builder {
+func (r *LuetSystemRepository) GetTree() tree.Builder {
 	return r.Tree
 }
-
+func (r *LuetSystemRepository) Write(dst string) error {
-func (r *LuetRepository) Write(dst string) error {
 
 	os.MkdirAll(dst, os.ModePerm)
 	r.Index = r.Index.CleanPath()
@@ -191,7 +206,7 @@ func (r *LuetRepository) Write(dst string) error {
 	return nil
 }
 
-func (r *LuetRepository) Client() Client {
+func (r *LuetSystemRepository) Client() Client {
 	switch r.GetType() {
 	case "disk":
 		return client.NewLocalClient(client.RepoData{Urls: r.GetUrls()})
@@ -201,7 +216,7 @@ func (r *LuetRepository) Client() Client {
 
 	return nil
 }
-func (r *LuetRepository) Sync() (Repository, error) {
+func (r *LuetSystemRepository) Sync() (Repository, error) {
 	c := r.Client()
 	if c == nil {
 		return nil, errors.New("No client could be generated from repository.")
@@ -216,8 +231,21 @@ func (r *LuetRepository) Sync() (Repository, error) {
 	}
 	defer os.Remove(file)
 
-	// TODO: make it swappable
+	var repo Repository
-	repo, err := NewLuetRepositoryFromYaml(dat, pkg.NewInMemoryDatabase(false))
+	if config.LuetCfg.GetSystem().DatabaseEngine == "boltdb" {
+		os.MkdirAll(
+			filepath.Join(config.LuetCfg.GetSystem().Rootfs, config.LuetCfg.GetSystem().DatabasePath),
+			os.ModePerm,
+		)
+		repo, err = NewLuetSystemRepositoryFromYaml(
+			dat,
+			pkg.NewBoltDatabase(
+				filepath.Join(config.LuetCfg.GetSystem().Rootfs,
+					filepath.Join(config.LuetCfg.GetSystem().DatabasePath, "luet.db"))),
+		)
+	} else {
+		repo, err = NewLuetSystemRepositoryFromYaml(dat, pkg.NewInMemoryDatabase(false))
+	}
 	if err != nil {
 		return nil, errors.Wrap(err, "Error reading repository from file "+file)
 
@@ -247,7 +275,20 @@ func (r *LuetRepository) Sync() (Repository, error) {
 		return nil, errors.Wrap(err, "Error met while unpacking rootfs")
 	}
 
-	reciper := tree.NewInstallerRecipe(pkg.NewInMemoryDatabase(false))
+	var systemDB pkg.PackageDatabase = nil
+	if config.LuetCfg.GetSystem().DatabaseEngine == "boltdb" {
+		os.MkdirAll(
+			filepath.Join(config.LuetCfg.GetSystem().Rootfs, config.LuetCfg.GetSystem().DatabasePath),
+			os.ModePerm,
+		)
+		systemDB = pkg.NewBoltDatabase(
+			filepath.Join(config.LuetCfg.GetSystem().Rootfs,
+				filepath.Join(config.LuetCfg.GetSystem().DatabasePath, "luet.db")))
+	} else {
+		systemDB = pkg.NewInMemoryDatabase(false)
+	}
+
+	reciper := tree.NewInstallerRecipe(systemDB)
 	err = reciper.Load(treefs)
 	if err != nil {
 		return nil, errors.Wrap(err, "Error met while unpacking rootfs")

pkg/installer/repository_test.go

@@ -23,6 +23,7 @@ import (
 
 	"github.com/mudler/luet/pkg/compiler"
 	backend "github.com/mudler/luet/pkg/compiler/backend"
+	config "github.com/mudler/luet/pkg/config"
 	"github.com/mudler/luet/pkg/helpers"
 	. "github.com/mudler/luet/pkg/installer"
 	pkg "github.com/mudler/luet/pkg/package"
@@ -81,7 +82,7 @@ var _ = Describe("Repository", func() {
 			Expect(helpers.Exists(spec.Rel("b-test-1.0.package.tar"))).To(BeTrue())
 			Expect(helpers.Exists(spec.Rel("b-test-1.0.metadata.yaml"))).To(BeTrue())
 
-			repo, err := GenerateRepository("test", tmpdir, "local", 1, tmpdir, "../../tests/fixtures/buildable", pkg.NewInMemoryDatabase(false))
+			repo, err := GenerateRepository("test", "description", "disk", []string{tmpdir}, 1, tmpdir, "../../tests/fixtures/buildable", pkg.NewInMemoryDatabase(false))
 			Expect(err).ToNot(HaveOccurred())
 			Expect(repo.GetName()).To(Equal("test"))
 			Expect(helpers.Exists(spec.Rel("repository.yaml"))).ToNot(BeTrue())
@@ -105,8 +106,8 @@ var _ = Describe("Repository", func() {
 
 			_, err = builder2.GetDatabase().CreatePackage(package2)
 			Expect(err).ToNot(HaveOccurred())
-			repo1 := &LuetRepository{Name: "test1", Tree: builder1}
+			repo1 := &LuetSystemRepository{LuetRepository: &config.LuetRepository{Name: "test1"}, Tree: builder1}
-			repo2 := &LuetRepository{Name: "test2", Tree: builder2}
+			repo2 := &LuetSystemRepository{LuetRepository: &config.LuetRepository{Name: "test2"}, Tree: builder2}
 			repositories := Repositories{repo1, repo2}
 			matches := repositories.PackageMatches([]pkg.Package{package1})
 			Expect(matches).To(Equal([]PackageMatch{{Repo: repo1, Package: package1}}))