binary-cache-store.hh binary-cache-store.cc

 binary-cache-store.hh binary-cache-store.cc \
 local-binary-cache-store.hh local-binary-cache-store.cc

BinaryCacheStore::BinaryCacheStore(ref<Store> localStore, const Path & binaryCacheDir,

BinaryCacheStore::BinaryCacheStore(ref<Store> localStore,

    , binaryCacheDir(binaryCacheDir)

    createDirs(binaryCacheDir + "/nar");
    Path cacheInfoFile = binaryCacheDir + "/nix-cache-info";
    if (!pathExists(cacheInfoFile))
        writeFile(cacheInfoFile, "StoreDir: " + settings.nixStore + "\n");

Path BinaryCacheStore::narInfoFileFor(const Path & storePath)

void BinaryCacheStore::init()

    assertStorePath(storePath);
    return binaryCacheDir + "/" + storePathToHash(storePath) + ".narinfo";

    std::string cacheInfoFile = "nix-cache-info";
    if (!fileExists(cacheInfoFile))
        upsertFile(cacheInfoFile, "StoreDir: " + settings.nixStore + "\n");

void atomicWrite(const Path & path, const std::string & s)

Path BinaryCacheStore::narInfoFileFor(const Path & storePath)

    Path tmp = path + ".tmp." + std::to_string(getpid());
    AutoDelete del(tmp, false);
    writeFile(tmp, s);
    if (rename(tmp.c_str(), path.c_str()))
        throw SysError(format("renaming ‘%1%’ to ‘%2%’") % tmp % path);
    del.cancel();

    assertStorePath(storePath);
    return storePathToHash(storePath) + ".narinfo";

    Path narInfoFile = narInfoFileFor(info.path);
    if (pathExists(narInfoFile)) return;

    auto narInfoFile = narInfoFileFor(info.path);
    if (fileExists(narInfoFile)) return;

    Path narFile = binaryCacheDir + "/" + narInfo.url;
    if (!pathExists(narFile)) atomicWrite(narFile, narXz);

    if (!fileExists(narInfo.url)) upsertFile(narInfo.url, narXz);

    atomicWrite(narInfoFile, narInfo.to_string());

    upsertFile(narInfoFile, narInfo.to_string());

    Path narInfoFile = narInfoFileFor(storePath);
    NarInfo narInfo = NarInfo(readFile(narInfoFile), narInfoFile);

    auto narInfoFile = narInfoFileFor(storePath);
    auto narInfo = NarInfo(getFile(narInfoFile), narInfoFile);

    return pathExists(narInfoFileFor(storePath));

    return fileExists(narInfoFileFor(storePath));

    auto nar = readFile(binaryCacheDir + "/" + res.url);

    auto nar = getFile(res.url);

class BinaryCacheStore : public nix::Store

class BinaryCacheStore : public Store

    Path binaryCacheDir;

public:

protected:

    BinaryCacheStore(ref<Store> localStore, const Path & binaryCacheDir,

    BinaryCacheStore(ref<Store> localStore,

    virtual bool fileExists(const std::string & path) = 0;
    virtual void upsertFile(const std::string & path, const std::string & data) = 0;
    virtual std::string getFile(const std::string & path) = 0;
public:

    virtual void init();

    Path narInfoFileFor(const Path & storePath);

    std::string narInfoFileFor(const Path & storePath);

#include "binary-cache-store.hh"

#include "local-binary-cache-store.hh"

    return make_ref<BinaryCacheStore>(getLocalStore(),

    auto store = make_ref<LocalBinaryCacheStore>(getLocalStore(),

    store->init();
    return store;

#include "local-binary-cache-store.hh"
namespace nix {
LocalBinaryCacheStore::LocalBinaryCacheStore(ref<Store> localStore,
    const Path & binaryCacheDir,  const Path & secretKeyFile, const Path & publicKeyFile)
    : BinaryCacheStore(localStore, secretKeyFile, publicKeyFile)
    , binaryCacheDir(binaryCacheDir)
{
}
void LocalBinaryCacheStore::init()
{
    createDirs(binaryCacheDir + "/nar");
    BinaryCacheStore::init();
}
static void atomicWrite(const Path & path, const std::string & s)
{
    Path tmp = path + ".tmp." + std::to_string(getpid());
    AutoDelete del(tmp, false);
    writeFile(tmp, s);
    if (rename(tmp.c_str(), path.c_str()))
        throw SysError(format("renaming ‘%1%’ to ‘%2%’") % tmp % path);
    del.cancel();
}
bool LocalBinaryCacheStore::fileExists(const std::string & path)
{
    return pathExists(binaryCacheDir + "/" + path);
}
void LocalBinaryCacheStore::upsertFile(const std::string & path, const std::string & data)
{
    atomicWrite(binaryCacheDir + "/" + path, data);
}
std::string LocalBinaryCacheStore::getFile(const std::string & path)
{
    return readFile(binaryCacheDir + "/" + path);
}
}

#pragma once
#include "binary-cache-store.hh"
namespace nix {
class LocalBinaryCacheStore : public BinaryCacheStore
{
private:
    Path binaryCacheDir;
public:
    LocalBinaryCacheStore(ref<Store> localStore, const Path & binaryCacheDir,
        const Path & secretKeyFile, const Path & publicKeyFile);
    void init() override;
protected:
    bool fileExists(const std::string & path) override;
    void upsertFile(const std::string & path, const std::string & data) override;
    std::string getFile(const std::string & path) override;
};
}