lockfile.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/resolver/lockfile.hh
 *
 * @brief A lockfile representing a resolved environment.
 *
 * This lockfile is processed by `mkEnv` to realize an environment.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <unordered_map>
 
#include <nlohmann/json.hpp>
 
#include "flox/core/exceptions.hh"
#include "flox/core/types.hh"
#include "flox/pkgdb/input.hh"
#include "flox/pkgdb/read.hh"
#include "flox/registry.hh"
#include "flox/resolver/manifest.hh"
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox::resolver {
 
/* -------------------------------------------------------------------------- */
 
FLOX_DEFINE_EXCEPTION( InvalidLockfileException,
                       EC_INVALID_LOCKFILE,
                       "invalid lockfile" )
/* -------------------------------------------------------------------------- */
 
struct LockedInputRaw
{
 
  pkgdb::Fingerprint fingerprint; 
  std::string        url;         
  nlohmann::json attrs;
 
  ~LockedInputRaw() = default;
  LockedInputRaw() : fingerprint( nix::htSHA256 ) {}
  LockedInputRaw( const LockedInputRaw & ) = default;
  LockedInputRaw( LockedInputRaw && )      = default;
 
  LockedInputRaw &
  operator=( const LockedInputRaw & )
    = default;
  LockedInputRaw &
  operator=( LockedInputRaw && )
    = default;
 
  explicit LockedInputRaw( const pkgdb::PkgDbReadOnly & pdb )
    : fingerprint( pdb.fingerprint )
    , url( pdb.lockedRef.string )
    , attrs( pdb.lockedRef.attrs )
  {}
 
  explicit LockedInputRaw( const pkgdb::PkgDbInput & input )
    : LockedInputRaw( *input.getDbReadOnly() )
  {}
 
  explicit operator nix::FlakeRef() const
  {
    return nix::FlakeRef::fromAttrs(
      nix::fetchers::jsonToAttrs( this->attrs ) );
  }
 
  explicit operator RegistryInput() const
  {
    return RegistryInput( static_cast<nix::FlakeRef>( *this ) );
  }
 
  [[nodiscard]] bool
  operator==( const LockedInputRaw & other ) const
  {
    return ( this->fingerprint == other.fingerprint )
           && ( this->url == other.url ) && ( this->attrs == other.attrs );
  }
 
  [[nodiscard]] bool
  operator!=( const LockedInputRaw & other ) const
  {
    return ! ( ( *this ) == other );
  }
 
 
}; /* End struct `LockedInputRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, LockedInputRaw & raw );
 
void
to_json( nlohmann::json & jto, const LockedInputRaw & raw );
 
 
/* -------------------------------------------------------------------------- */
 
std::ostream &
operator<<( std::ostream & oss, const LockedInputRaw & raw );
 
 
/* -------------------------------------------------------------------------- */
 
struct LockedPackageRaw
{
 
  LockedInputRaw input;
  AttrPath       attrPath;
  unsigned       priority;
  nlohmann::json info; /* pname, version, license */
 
  [[nodiscard]] bool
  operator==( const LockedPackageRaw & other ) const
  {
    return ( this->input == other.input )
           && ( this->attrPath == other.attrPath )
           && ( this->priority == other.priority )
           && ( this->info == other.info );
  }
 
  [[nodiscard]] bool
  operator!=( const LockedPackageRaw & other ) const
  {
    return ! ( ( *this ) == other );
  }
 
 
}; /* End struct `LockedPackageRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, LockedPackageRaw & raw );
 
void
to_json( nlohmann::json & jto, const LockedPackageRaw & raw );
 
 
/* -------------------------------------------------------------------------- */
 
std::ostream &
operator<<( std::ostream & oss, const LockedPackageRaw & raw );
 
 
/* -------------------------------------------------------------------------- */
 
using SystemPackages
  = std::unordered_map<InstallID, std::optional<LockedPackageRaw>>;
 
struct LockfileRaw
{
 
  ManifestRaw                                manifest;
  RegistryRaw                                registry;
  std::unordered_map<System, SystemPackages> packages;
  unsigned                                   lockfileVersion = 0;
 
 
  ~LockfileRaw()                     = default;
  LockfileRaw()                      = default;
  LockfileRaw( const LockfileRaw & ) = default;
  LockfileRaw( LockfileRaw && )      = default;
  LockfileRaw &
  operator=( const LockfileRaw & )
    = default;
  LockfileRaw &
  operator=( LockfileRaw && )
    = default;
 
  void
  check() const;
 
  void
  clear();
 
 
}; /* End struct `LockfileRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, LockfileRaw & raw );
 
void
to_json( nlohmann::json & jto, const LockfileRaw & raw );
 
 
/* -------------------------------------------------------------------------- */
 
class Lockfile
{
 
private:
 
  LockfileRaw lockfileRaw;
 
  EnvironmentManifest manifest;
  RegistryRaw packagesRegistryRaw;
 
 
  void
  checkGroups() const;
 
  void
  check() const;
 
  void
  init();
 
 
public:
 
  ~Lockfile()                  = default;
  Lockfile()                   = default;
  Lockfile( const Lockfile & ) = default;
  Lockfile( Lockfile && )      = default;
 
  explicit Lockfile( LockfileRaw raw ) : lockfileRaw( std::move( raw ) )
  {
    this->init();
  }
 
  explicit Lockfile( std::filesystem::path lockfilePath );
 
  Lockfile &
  operator=( const Lockfile & )
    = default;
 
  Lockfile &
  operator=( Lockfile && )
    = default;
 
  [[nodiscard]] const LockfileRaw &
  getLockfileRaw() const
  {
    return this->lockfileRaw;
  }
 
  [[nodiscard]] const ManifestRaw &
  getManifestRaw() const
  {
    return this->getLockfileRaw().manifest;
  }
 
  [[nodiscard]] const RegistryRaw &
  getRegistryRaw() const
  {
    return this->getLockfileRaw().registry;
  }
 
  [[nodiscard]] const EnvironmentManifest &
  getManifest() const
  {
    return this->manifest;
  }
 
  [[nodiscard]] const std::unordered_map<InstallID, ManifestDescriptor> &
  getDescriptors() const
  {
    return this->getManifest().getDescriptors();
  }
 
  [[nodiscard]] const RegistryRaw &
  getPackagesRegistryRaw() const
  {
    return this->packagesRegistryRaw;
  }
 
  std::size_t
  removeUnusedInputs();
 
 
}; /* End class `Lockfile' */
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox::resolver
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */