Track installed files

pkg/installer/installer.go

@@ -16,6 +16,8 @@
 package installer
 
 import (
+	"archive/tar"
+	"io"
 	"io/ioutil"
 	"os"
 	"os/exec"
@@ -255,13 +257,43 @@ func (l *LuetInstaller) installPackage(a ArtifactMatch, s *System) error {
 	// FIXME: Implement
 	artifact, err := a.Repository.Client().DownloadArtifact(a.Artifact)
 	defer os.Remove(artifact.GetPath())
+
+	tarFile, err := os.Open(artifact.GetPath())
+	if err != nil {
+		return errors.Wrap(err, "Could not open package archive")
+	}
+	defer tarFile.Close()
+	tr := tar.NewReader(tarFile)
+
+	var files []string
+	// untar each segment
+	for {
+		hdr, err := tr.Next()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			return err
+		}
+		// determine proper file path info
+		finfo := hdr.FileInfo()
+		fileName := hdr.Name
+		if finfo.Mode().IsDir() {
+			continue
+		}
+		files = append(files, fileName)
+
+		// if a dir, create it, then go to next segment
+	}
+
 	err = helpers.Untar(artifact.GetPath(), s.Target, true)
 	if err != nil {
 		return errors.Wrap(err, "Error met while unpacking rootfs")
 	}
+
 	// First create client and download
 	// Then unpack to system
-	return nil
+	return s.Database.SetPackageFiles(pkg.PackageFile{PackageFingerprint: a.Package.GetFingerPrint(), Files: files})
 }
 
 func (l *LuetInstaller) installerWorker(i int, wg *sync.WaitGroup, c <-chan ArtifactMatch, s *System) error {

pkg/installer/installer_test.go

@@ -120,6 +120,10 @@ uri: "`+tmpdir+`"
 			Expect(helpers.Exists(filepath.Join(fakeroot, "test6"))).To(BeTrue())
 			_, err = systemDB.FindPackage(&pkg.DefaultPackage{Name: "b", Category: "test", Version: "1.0"})
 			Expect(err).ToNot(HaveOccurred())
+
+			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())
 		})
 
 	})

pkg/package/database.go

@@ -26,3 +26,22 @@ type PackageDatabase interface {
 	Create([]byte) (string, error)
 	Retrieve(ID string) ([]byte, error)
 }
+
+type PackageSet interface {
+	GetPackages() []string //Ids
+	CreatePackage(pkg Package) (string, error)
+	GetPackage(ID string) (Package, error)
+	Clean() error
+	FindPackage(Package) (Package, error)
+	UpdatePackage(p Package) error
+	GetAllPackages(packages chan Package) error
+
+	GetPackageFiles(Package) ([]string, error)
+	SetPackageFiles(PackageFile) error
+	RemovePackageFiles(Package) error
+}
+
+type PackageFile struct {
+	PackageFingerprint string
+	Files              []string
+}

pkg/package/database_boltdb.go

@@ -183,3 +183,44 @@ func (db *BoltDatabase) Clean() error {
 	defer db.Unlock()
 	return os.RemoveAll(db.Path)
 }
+
+func (db *BoltDatabase) GetPackageFiles(p Package) ([]string, error) {
+	bolt, err := storm.Open(db.Path, storm.BoltOptions(0600, &bbolt.Options{Timeout: 30 * time.Second}))
+	if err != nil {
+		return []string{}, errors.Wrap(err, "Error opening boltdb "+db.Path)
+	}
+	defer bolt.Close()
+
+	files := bolt.From("files")
+	var pf PackageFile
+	err = files.One("PackageFingerprint", p.GetFingerPrint(), &pf)
+	if err != nil {
+		return []string{}, errors.Wrap(err, "While finding files")
+	}
+	return pf.Files, nil
+}
+func (db *BoltDatabase) SetPackageFiles(p PackageFile) error {
+	bolt, err := storm.Open(db.Path, storm.BoltOptions(0600, &bbolt.Options{Timeout: 30 * time.Second}))
+	if err != nil {
+		return errors.Wrap(err, "Error opening boltdb "+db.Path)
+	}
+	defer bolt.Close()
+
+	files := bolt.From("files")
+	return files.Save(p)
+}
+func (db *BoltDatabase) RemovePackageFiles(p Package) error {
+	bolt, err := storm.Open(db.Path, storm.BoltOptions(0600, &bbolt.Options{Timeout: 30 * time.Second}))
+	if err != nil {
+		return errors.Wrap(err, "Error opening boltdb "+db.Path)
+	}
+	defer bolt.Close()
+
+	files := bolt.From("files")
+	var pf PackageFile
+	err = files.One("PackageFingerprint", p.GetFingerPrint(), &pf)
+	if err != nil {
+		return errors.Wrap(err, "While finding files")
+	}
+	return files.DeleteStruct(&pf)
+}

pkg/package/database_mem.go

@@ -25,22 +25,23 @@ import (
 )
 
 var DBInMemoryInstance = &InMemoryDatabase{
-	Mutex: &sync.Mutex{},
+	Mutex:        &sync.Mutex{},
-
+	FileDatabase: map[string][]string{},
-	Database: map[string]string{}}
+	Database:     map[string]string{}}
 
 type InMemoryDatabase struct {
 	*sync.Mutex
-	Database map[string]string
+	Database     map[string]string
+	FileDatabase map[string][]string
 }
 
 func NewInMemoryDatabase(singleton bool) PackageDatabase {
 	// In memoryDB is a singleton
 	if !singleton {
 		return &InMemoryDatabase{
-			Mutex: &sync.Mutex{},
+			Mutex:        &sync.Mutex{},
-
+			FileDatabase: map[string][]string{},
-			Database: map[string]string{}}
+			Database:     map[string]string{}}
 	}
 	return DBInMemoryInstance
 }
@@ -204,3 +205,28 @@ func (db *InMemoryDatabase) Clean() error {
 	db.Database = map[string]string{}
 	return nil
 }
+
+func (db *InMemoryDatabase) GetPackageFiles(p Package) ([]string, error) {
+
+	db.Lock()
+	defer db.Unlock()
+
+	pa, ok := db.FileDatabase[p.GetFingerPrint()]
+	if !ok {
+		return pa, errors.New("No key found with that id")
+	}
+
+	return pa, nil
+}
+func (db *InMemoryDatabase) SetPackageFiles(p PackageFile) error {
+	db.Lock()
+	defer db.Unlock()
+	db.FileDatabase[p.PackageFingerprint] = p.Files
+	return nil
+}
+func (db *InMemoryDatabase) RemovePackageFiles(p Package) error {
+	db.Lock()
+	defer db.Unlock()
+	delete(db.FileDatabase, p.GetFingerPrint())
+	return nil
+}

pkg/package/package.go

@@ -64,16 +64,6 @@ type Package interface {
 	Rel(string) string
 }
 
-type PackageSet interface {
-	GetPackages() []string //Ids
-	CreatePackage(pkg Package) (string, error)
-	GetPackage(ID string) (Package, error)
-	Clean() error
-	FindPackage(Package) (Package, error)
-	UpdatePackage(p Package) error
-	GetAllPackages(packages chan Package) error
-}
-
 type Tree interface {
 	GetPackageSet() PackageDatabase
 	Prelude() string // A tree might have a prelude to be able to consume a tree