Compute upgrades

Make solver compute simply upgrades and the installer execute them.

Add simple upgrade test

pkg/solver/solver.go

@@ -32,6 +32,7 @@ type PackageSolver interface {
 	ConflictsWithInstalled(p pkg.Package) (bool, error)
 	ConflictsWith(p pkg.Package, ls []pkg.Package) (bool, error)
 	World() []pkg.Package
+	Upgrade() ([]pkg.Package, PackagesAssertions, error)
 }
 
 // Solver is the default solver for luet
@@ -193,6 +194,55 @@ func (s *Solver) ConflictsWithInstalled(p pkg.Package) (bool, error) {
 	return s.ConflictsWith(p, s.Installed())
 }
 
+func (s *Solver) Upgrade() ([]pkg.Package, PackagesAssertions, error) {
+
+	// First get candidates that needs to be upgraded..
+
+	toUninstall := []pkg.Package{}
+	toInstall := []pkg.Package{}
+
+	availableCache := map[string][]pkg.Package{}
+	for _, p := range s.DefinitionDatabase.World() {
+		// Each one, should be expanded
+		availableCache[p.GetName()+p.GetCategory()] = append(availableCache[p.GetName()+p.GetCategory()], p)
+	}
+
+	installedcopy := pkg.NewInMemoryDatabase(false)
+
+	for _, p := range s.InstalledDatabase.World() {
+		installedcopy.CreatePackage(p)
+		packages, ok := availableCache[p.GetName()+p.GetCategory()]
+		if ok && len(packages) != 0 {
+			best := pkg.Best(packages)
+			if best.GetVersion() != p.GetVersion() {
+				toUninstall = append(toUninstall, p)
+				toInstall = append(toInstall, best)
+			}
+		}
+	}
+
+	s2 := NewSolver(installedcopy, s.DefinitionDatabase, pkg.NewInMemoryDatabase(false))
+	// Then try to uninstall the versions in the system, and store that tree
+	for _, p := range toUninstall {
+		r, err := s.Uninstall(p)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "Could not compute upgrade - couldn't uninstall selected candidate "+p.GetFingerPrint())
+		}
+		for _, z := range r {
+			err = installedcopy.RemovePackage(z)
+			if err != nil {
+				return nil, nil, errors.Wrap(err, "Could not compute upgrade - couldn't remove copy of package targetted for removal")
+			}
+		}
+
+	}
+	r, e := s2.Install(toInstall)
+	return toUninstall, r, e
+	// To that tree, ask to install the versions that should be upgraded, and try to solve
+	// Return the solution
+
+}
+
 // 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.
 func (s *Solver) Uninstall(c pkg.Package) ([]pkg.Package, error) {

pkg/solver/solver_test.go

@@ -678,5 +678,39 @@ var _ = Describe("Solver", func() {
 			Expect(p).To(Equal(a03))
 		})
 	})
+	Context("Upgrades", func() {
 
+		C := pkg.NewPackage("c", "1.5", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "a", Version: ">=1.0", Category: "test"}}, []*pkg.DefaultPackage{})
+		C.SetCategory("test")
+		B := pkg.NewPackage("b", "1.0", []*pkg.DefaultPackage{}, []*pkg.DefaultPackage{})
+		B.SetCategory("test")
+		A := pkg.NewPackage("a", "1.1", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "b", Version: "1.0", Category: "test"}}, []*pkg.DefaultPackage{})
+		A.SetCategory("test")
+		A1 := pkg.NewPackage("a", "1.2", []*pkg.DefaultPackage{&pkg.DefaultPackage{Name: "b", Version: "1.0", Category: "test"}}, []*pkg.DefaultPackage{})
+		A1.SetCategory("test")
+
+		It("upgrades correctly", func() {
+			for _, p := range []pkg.Package{A1, B, C} {
+				_, err := dbDefinitions.CreatePackage(p)
+				Expect(err).ToNot(HaveOccurred())
+			}
+
+			for _, p := range []pkg.Package{A, B} {
+				_, err := dbInstalled.CreatePackage(p)
+				Expect(err).ToNot(HaveOccurred())
+			}
+			uninstall, solution, err := s.Upgrade()
+			Expect(err).ToNot(HaveOccurred())
+
+			Expect(len(uninstall)).To(Equal(1))
+			Expect(uninstall[0].GetName()).To(Equal("a"))
+			Expect(uninstall[0].GetVersion()).To(Equal("1.1"))
+
+			Expect(solution).To(ContainElement(PackageAssert{Package: A1, Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: B, Value: true}))
+			Expect(solution).To(ContainElement(PackageAssert{Package: C, Value: false}))
+			Expect(len(solution)).To(Equal(3))
+
+		})
+	})
 })