libsolv.h

   1 /*
   2  * Copyright (c) 2017 Jon Turney
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     A copy of the GNU General Public License can be found at
  10  *     http://www.gnu.org/
  11  *
  12  */
  13
  14 #ifndef LIBSOLV_H
  15 #define LIBSOLV_H
  16
  17 #include "solv/pool.h"
  18 #include "solv/repo.h"
  19 #include "solv/solver.h"
  20 #include "PackageSpecification.h"
  21 #include "PackageTrust.h"
  22 #include "package_source.h"
  23 #include "package_depends.h"
  24 #include <map>
  25 #include <vector>
  26
  27 typedef trusts package_stability_t;
  28
  29 typedef enum
  30 {
  31   package_binary,
  32   package_source
  33 }
  34 package_type_t;
  35
  36 // ---------------------------------------------------------------------------
  37 // interface to class SolverVersion
  38 //
  39 // a wrapper around a libsolv Solvable
  40 // ---------------------------------------------------------------------------
  41
  42 class SolverPool;
  43 class SolverSolution;
  44
  45 class SolvableVersion
  46 {
  47  public:
  48   SolvableVersion() : id(0), pool(0) {};
  49   SolvableVersion(Id _id, Pool *_pool) : id(_id), pool(_pool) {};
  50
  51   // converted to a bool, this is true if this isn't the result of the default
  52   // constructor (an 'empty' version, in some sense)
  53   explicit operator bool () const { return (id != 0); }
  54
  55   const std::string Name () const;
  56   const std::string SDesc () const;
  57   // In setup-speak, 'Canonical' version means 'e:v-r', the non-decomposed version
  58   const std::string Canonical_version () const;
  59   // Return the dependency list
  60   const PackageDepends depends() const;
  61   // Return the obsoletes list
  62   const PackageDepends obsoletes() const;
  63   bool accessible () const;
  64   package_type_t Type () const;
  65   package_stability_t Stability () const;
  66   // the associated source package name, if this is a binary package
  67   const std::string sourcePackageName () const;
  68   // the associated source package, if this is a binary package
  69   SolvableVersion sourcePackage () const;
  70   // where this package archive can be obtained from
  71   packagesource *source() const;
  72
  73   // fixup spkg_id
  74   void fixup_spkg_id(SolvableVersion spkg_id) const;
  75
  76   // utility function to compare package versions
  77   static int compareVersions(const SolvableVersion &a, const SolvableVersion &b);
  78
  79   // comparison operators
  80
  81   // these are somewhat necessary as otherwise we are compared as bool values
  82   bool operator == (SolvableVersion const &) const;
  83   bool operator != (SolvableVersion const &) const;
  84
  85   // these are only well defined for versions of the same package
  86   bool operator < (SolvableVersion const &) const;
  87   bool operator <= (SolvableVersion const &) const;
  88   bool operator > (SolvableVersion const &) const;
  89   bool operator >= (SolvableVersion const &) const;
  90
  91  private:
  92   Id id;
  93   Pool *pool;
  94
  95   friend SolverPool;
  96   friend SolverSolution;
  97
  98   const PackageDepends deplist(Id keyname) const;
  99   Id name_id () const;
 100 };
 101
 102 // ---------------------------------------------------------------------------
 103 // Helper class SolvRepo
 104 //
 105 // ---------------------------------------------------------------------------
 106
 107 class SolvRepo
 108 {
 109 public:
 110   typedef enum
 111   {
 112     priorityLow = 0,
 113     priorityNormal,
 114     priorityHigh,
 115   } priority_t;
 116   Repo *repo;
 117   Repodata *data;
 118   bool test;
 119   void setPriority(priority_t p) { repo->priority = p; }
 120 };
 121
 122 // ---------------------------------------------------------------------------
 123 // interface to class SolverPool
 124 //
 125 // a simplified wrapper for libsolv
 126 // ---------------------------------------------------------------------------
 127
 128 class SolverPool
 129 {
 130 public:
 131   SolverPool();
 132   void clear();
 133   SolvRepo *getRepo(const std::string &name, bool test = false);
 134
 135   // Utility class for passing arguments to addPackage()
 136   class addPackageData
 137   {
 138   public:
 139     std::string reponame;
 140     std::string version;
 141     std::string vendor;
 142     std::string sdesc;
 143     std::string ldesc;
 144     package_stability_t stability;
 145     package_type_t type;
 146     packagesource archive;
 147     PackageSpecification spkg;
 148     SolvableVersion spkg_id;
 149     PackageDepends *requires;
 150     PackageDepends *obsoletes;
 151     PackageDepends *provides;
 152   };
 153
 154   SolvableVersion addPackage(const std::string& pkgname,
 155                              const addPackageData &pkgdata);
 156
 157   void internalize(void);
 158   void use_test_packages(bool use_test_packages);
 159
 160
 161 private:
 162   void init();
 163   Id makedeps(Repo *repo, PackageDepends *requires);
 164   Pool *pool;
 165
 166   typedef std::map<std::string, SolvRepo *> RepoList;
 167   RepoList repos;
 168
 169   friend SolverSolution;
 170 };
 171
 172
 173 // ---------------------------------------------------------------------------
 174 // interface to class SolverTaskQueue
 175 //
 176 // This is used to contain a set of package install/uninstall tasks selected via
 177 // the UI to be passed to solver
 178 // ---------------------------------------------------------------------------
 179
 180 class SolverTasks
 181 {
 182  public:
 183   enum task
 184   {
 185     taskInstall,
 186     taskUninstall,
 187     taskReinstall,
 188     taskKeep,
 189     taskSkip,
 190     taskForceDistUpgrade,
 191   };
 192   void add(const SolvableVersion &v, task t)
 193   {
 194     tasks.push_back(taskList::value_type(v, t));
 195   };
 196   /* Create solver tasks corresponding to state of database */
 197   void setTasks();
 198
 199  private:
 200   typedef std::vector<std::pair<const SolvableVersion, task>> taskList;
 201   taskList tasks;
 202
 203   friend SolverSolution;
 204 };
 205
 206 // ---------------------------------------------------------------------------
 207 // SolverTransactionList
 208 //
 209 // a list of transactions output by the solver
 210 // ---------------------------------------------------------------------------
 211
 212 class SolverTransaction
 213 {
 214  public:
 215   typedef enum
 216   {
 217     transIgnore,
 218     transInstall,
 219     transErase,
 220   } transType;
 221
 222   SolverTransaction(SolvableVersion version_, transType type_) :
 223   version(version_), type(type_) {};
 224
 225   SolvableVersion version;
 226   transType type;
 227 };
 228
 229 typedef std::vector<SolverTransaction> SolverTransactionList;
 230
 231 // ---------------------------------------------------------------------------
 232 // interface to class SolverSolution
 233 //
 234 // A wrapper around the libsolv solver
 235 // ---------------------------------------------------------------------------
 236
 237 class SolverSolution
 238 {
 239  public:
 240   SolverSolution(SolverPool &_pool);
 241   ~SolverSolution();
 242   void clear();
 243
 244   /* Reset package database to correspond to trans */
 245   void trans2db() const;
 246
 247   /* Reset transaction list to correspond to package database */
 248   void db2trans();
 249
 250   enum updateMode
 251   {
 252     keep,        // don't update
 253     updateBest,  // update to best version
 254     updateForce, // distupdate: downgrade if necessary to best version in repo
 255   };
 256   bool update(SolverTasks &tasks, updateMode update, bool use_test_packages);
 257   void augmentTasks(SolverTasks &tasks);
 258   void addSource(bool include_source);
 259   void applyDefaultProblemSolutions();
 260   std::string report() const;
 261
 262   const SolverTransactionList &transactions() const;
 263   void dumpTransactionList() const;
 264
 265  private:
 266   static SolverTransaction::transType type(Transaction *trans, int pos);
 267   bool solve();
 268   void tasksToJobs(SolverTasks &tasks, updateMode update, Queue &job);
 269   void solutionToTransactionList();
 270
 271   SolverPool &pool;
 272   Solver *solv;
 273   Queue job;
 274   SolverTransactionList trans;
 275 };
 276
 277 #endif // LIBSOLV_H