environment.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/resolver/environment.hh
 *
 * @brief A collection of files associated with an environment.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <memory>
#include <optional>
#include <string_view>
#include <utility>
#include <vector>
 
#include <nix/ref.hh>
 
#include "flox/core/exceptions.hh"
#include "flox/core/nix-state.hh"
#include "flox/core/types.hh"
#include "flox/pkgdb/input.hh"
#include "flox/pkgdb/pkg-query.hh"
#include "flox/registry.hh"
#include "flox/resolver/lockfile.hh"
#include "flox/resolver/manifest-raw.hh"
#include "flox/resolver/manifest.hh"
 
 
/* -------------------------------------------------------------------------- */
 
/* Forward Declarations */
 
namespace flox {
 
namespace pkgdb {
class PkgDbReadOnly;
}  // namespace pkgdb
 
namespace resolver {
struct ManifestDescriptor;
}  // namespace resolver
 
 
}  // namespace flox
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox::resolver {
 
/* -------------------------------------------------------------------------- */
 
FLOX_DEFINE_EXCEPTION( ResolutionFailureException,
                       EC_RESOLUTION_FAILURE,
                       "resolution failure" );
 
 
/* -------------------------------------------------------------------------- */
 
using ResolutionFailure = std::vector<std::pair<InstallID, std::string>>;
 
using ResolutionResult = std::variant<ResolutionFailure, SystemPackages>;
 
 
/* -------------------------------------------------------------------------- */
 
class Environment : private NixStoreMixin
{
 
private:
 
  /* From `NixStoreMixin':
   *   std::shared_ptr<nix::Store> store
   */
 
  std::optional<GlobalManifest> globalManifest;
 
  EnvironmentManifest manifest;
 
  std::optional<Lockfile> oldLockfile;
 
 
  using Upgrades = std::variant<bool, std::vector<InstallID>>;
  Upgrades upgrades;
 
  std::optional<LockfileRaw> lockfileRaw;
 
  std::optional<RegistryRaw> combinedRegistryRaw;
 
  std::optional<Options> combinedOptions;
 
  std::optional<pkgdb::PkgQueryArgs> combinedBaseQueryArgs;
 
  std::optional<RegistryRaw> lockedRegistry;
 
  std::shared_ptr<Registry<pkgdb::PkgDbInputFactory>> dbs;
 
 
  static LockedPackageRaw
  lockPackage( const LockedInputRaw & input,
               pkgdb::PkgDbReadOnly & dbRO,
               pkgdb::row_id          row,
               unsigned               priority );
 
  static inline LockedPackageRaw
  lockPackage( const pkgdb::PkgDbInput & input,
               pkgdb::row_id             row,
               unsigned                  priority )
  {
    return lockPackage( LockedInputRaw( input ),
                        *input.getDbReadOnly(),
                        row,
                        priority );
  }
 
  [[nodiscard]] std::vector<InstallDescriptors>
  getUnlockedGroups( const System & system );
 
  [[nodiscard]] std::vector<InstallDescriptors>
  getLockedGroups( const System & system );
 
  [[nodiscard]] const Options &
  getCombinedOptions();
 
  [[nodiscard]] std::optional<pkgdb::row_id>
  tryResolveDescriptorIn( const ManifestDescriptor & descriptor,
                          const pkgdb::PkgDbInput &  input,
                          const System &             system );
 
  [[nodiscard]] ResolutionResult
  tryResolveGroup( const InstallDescriptors & group, const System & system );
 
  [[nodiscard]] std::variant<InstallID, SystemPackages>
  tryResolveGroupIn( const InstallDescriptors & group,
                     const pkgdb::PkgDbInput &  input,
                     const System &             system );
 
  void
  lockSystem( const System & system );
 
 
protected:
 
  [[nodiscard]] std::optional<LockedInputRaw>
  getGroupInput( const InstallDescriptors & group,
                 const Lockfile &           oldLockfile,
                 const System &             system ) const;
 
  [[nodiscard]] bool
  groupIsLocked( const InstallDescriptors & group,
                 const Lockfile &           oldLockfile,
                 const System &             system ) const;
 
 
public:
 
  Environment( std::optional<GlobalManifest> globalManifest,
               EnvironmentManifest           manifest,
               std::optional<Lockfile>       oldLockfile,
               Upgrades                      upgrades = false )
    : globalManifest( std::move( globalManifest ) )
    , manifest( std::move( manifest ) )
    , oldLockfile( std::move( oldLockfile ) )
    , upgrades( std::move( upgrades ) )
  {}
 
  explicit Environment( EnvironmentManifest     manifest,
                        std::optional<Lockfile> oldLockfile = std::nullopt )
    : globalManifest( std::nullopt )
    , manifest( std::move( manifest ) )
    , oldLockfile( std::move( oldLockfile ) )
  {}
 
  [[nodiscard]] const std::optional<GlobalManifest> &
  getGlobalManifest() const
  {
    return this->globalManifest;
  }
 
  [[nodiscard]] std::optional<GlobalManifestRaw>
  getGlobalManifestRaw() const
  {
    const auto & global = this->getGlobalManifest();
    if ( ! global.has_value() ) { return std::nullopt; }
    return global->getManifestRaw();
  }
 
  [[nodiscard]] const EnvironmentManifest &
  getManifest() const
  {
    return this->manifest;
  }
 
  [[nodiscard]] const ManifestRaw &
  getManifestRaw() const
  {
    return this->getManifest().getManifestRaw();
  }
 
  [[nodiscard]] std::optional<ManifestRaw>
  getOldManifestRaw() const;
 
  [[nodiscard]] std::optional<Lockfile>
  getOldLockfile() const
  {
    return this->oldLockfile;
  }
 
  [[nodiscard]] RegistryRaw &
  getCombinedRegistryRaw();
 
  [[nodiscard]] const pkgdb::PkgQueryArgs &
  getCombinedBaseQueryArgs();
 
  [[nodiscard]] std::vector<System>
  getSystems() const
  {
    return this->getManifest().getSystems();
  }
 
  [[nodiscard]] nix::ref<Registry<pkgdb::PkgDbInputFactory>>
  getPkgDbRegistry();
 
  // TODO: (Question) Should we lock the combined options and fill registry
  //                  `default` fields in inputs?
  [[nodiscard]] Lockfile
  createLockfile();
 
 
}; /* End class `Environment' */
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox::resolver
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */