fetchers.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libstore/content-address.hh"
#include "lix/libutil/result.hh"
#include "lix/libutil/types.hh"
#include "lix/libutil/hash.hh"
#include "lix/libutil/canon-path.hh"
#include "lix/libstore/path.hh"
#include "lix/libfetchers/attrs.hh"
#include "lix/libutil/url.hh"
#include "lix/libutil/ref.hh"
#include "lix/libutil/strings.hh"
 
#include <kj/async.h>
#include <memory>
 
namespace nix { class Store; }
 
namespace nix::fetchers {
 
struct Tree
{
    Path actualPath;
    StorePath storePath;
};
 
struct InputScheme;

struct Input
{
    friend struct InputScheme;
 
    std::shared_ptr<InputScheme> scheme; // note: can be null
    Attrs attrs;
    bool locked = false;
    bool direct = true;

    std::optional<Path> parent;
 
public:
    static Input fromURL(const std::string & url, bool requireTree = true);
 
    static Input fromURL(const ParsedURL & url, bool requireTree = true);
 
    static Input fromAttrs(Attrs && attrs);
 
    ParsedURL toURL() const;
 
    std::string toURLString(const std::map<std::string, std::string> & extraQuery = {}) const;
 
    std::string to_string() const;
 
    Attrs toAttrs() const;

    bool isDirect() const { return direct; }

    bool isLocked() const { return locked; }

    bool hasAllInfo() const;
 
    bool operator ==(const Input & other) const;
 
    bool contains(const Input & other) const;

    kj::Promise<Result<std::pair<Tree, Input>>> fetch(ref<Store> store) const;
 
    Input applyOverrides(
        std::optional<std::string> ref,
        std::optional<Hash> rev) const;
 
    void clone(const Path & destDir) const;
 
    std::optional<Path> getSourcePath() const;

    void putFile(
        const CanonPath & path,
        std::string_view contents,
        std::optional<std::string> commitMsg) const;
 
    std::string getName() const;
 
    StorePath computeStorePath(Store & store) const;
 
    // Convenience functions for common attributes.
    std::string getType() const;
    std::optional<Hash> getNarHash() const;
    std::optional<std::string> getRef() const;
    std::optional<Hash> getRev() const;
    std::optional<uint64_t> getRevCount() const;
    std::optional<time_t> getLastModified() const;
};
 

struct InputScheme
{
    virtual ~InputScheme()
    { }
 
    virtual std::optional<Input> inputFromURL(const ParsedURL & url, bool requireTree) const = 0;
 
    virtual std::optional<Input> inputFromAttrs(const Attrs & attrs) const = 0;
 
    virtual ParsedURL toURL(const Input & input) const;
 
    virtual bool hasAllInfo(const Input & input) const = 0;
 
    virtual Input applyOverrides(
        const Input & input,
        std::optional<std::string> ref,
        std::optional<Hash> rev) const;
 
    virtual void clone(const Input & input, const Path & destDir) const;
 
    virtual std::optional<Path> getSourcePath(const Input & input) const;
 
    virtual void putFile(
        const Input & input,
        const CanonPath & path,
        std::string_view contents,
        std::optional<std::string> commitMsg) const;
 
    virtual kj::Promise<Result<std::pair<StorePath, Input>>>
    fetch(ref<Store> store, const Input & input) = 0;
 
    /*
     * By default, libfetchers considers inputs as locked if a `rev`
     * is specified. This however doesn't make any sense for `path` inputs,
     * so schemes can indicate that a `rev` on its own is not sufficient.
     */
    virtual bool isLockedByRev() const { return true; }
 
protected:
    void emplaceURLQueryIntoAttrs(
        const ParsedURL & parsedURL,
        Attrs & attrs,
        const StringSet & numericParams,
        const StringSet & booleanParams) const
    {
        for (auto &[name, value] : parsedURL.query) {
            if (name == "url") {
                throw BadURL(
                    "URL '%s' must not override url via query param!",
                    parsedURL.to_string()
                );
            } else if (numericParams.count(name) != 0) {
                if (auto n = string2Int<uint64_t>(value)) {
                    attrs.insert_or_assign(name, *n);
                } else {
                    throw BadURL(
                        "URL '%s' has non-numeric parameter '%s'",
                        parsedURL.to_string(),
                        name
                    );
                }
            } else if (booleanParams.count(name) != 0) {
                attrs.emplace(name, Explicit<bool> { value == "1" });
            } else {
                attrs.emplace(name, value);
            }
        }
    }
};
 
void registerInputScheme(std::shared_ptr<InputScheme> && fetcher);
 
void initLibFetchers();
 
struct DownloadFileResult
{
    StorePath storePath;
    std::string etag;
    std::string effectiveUrl;
    std::optional<std::string> immutableUrl;
};
 
kj::Promise<Result<DownloadFileResult>> downloadFile(
    ref<Store> store,
    const std::string & url,
    const std::string & name,
    bool locked,
    Headers headers = {},
    FileIngestionMethod ingestionMethod = FileIngestionMethod::Flat);
 
struct DownloadTarballResult
{
    Tree tree;
    time_t lastModified;
    std::optional<std::string> immutableUrl;
};
 
kj::Promise<Result<DownloadTarballResult>> downloadTarball(
    ref<Store> store,
    const std::string & url,
    const std::string & name,
    bool locked,
    const Headers & headers = {});
 
}