wroclaw-git-backups/nix
1
0
Fork 0
mirror of https://github.com/NixOS/nix synced 2025-07-06 09:11:47 +02:00
Code Activity

Factor out bits of the worker protocol to use elsewhere

Browse source 
This introduces some shared infrastructure for our notion of protocols.
We can then define multiple protocols in terms of that notion.
We an also express how particular protocols depend on each other.

For example, we can define a common protocol and a worker protocol,
where the second depends on the first in terms of the data types it can
read and write.

The "serve" protocol can just use the common one for now, but will
eventually need its own machinary just like the worker protocol for
version-aware serialisers
This commit is contained in:
John Ericson 2022-03-25 04:39:57 +00:00
parent aaef47a08e
commit be81764320
13 changed files with 542 additions and 251 deletions
Download patch file Download diff file Expand all files Collapse all files

60
src/libstore/worker-protocol.hh
View file

@ -1,7 +1,7 @@
#pragma once
///@file
#include "serialise.hh"
#include "common-protocol.hh"
namespace nix {
@ -28,11 +28,7 @@ class Store;
struct Source;
// items being serialised
class StorePath;
struct ContentAddress;
struct DerivedPath;
struct DrvOutput;
struct Realisation;
struct BuildResult;
struct KeyedBuildResult;
enum TrustedFlag : bool;
@ -193,60 +189,32 @@ inline std::ostream & operator << (std::ostream & s, WorkerProto::Op op)
* be legal specialization syntax. See below for what that looks like in
* practice.
*/
#define MAKE_WORKER_PROTO(T) \
struct WorkerProto::Serialise< T > { \
#define DECLARE_WORKER_SERIALISER(T) \
struct WorkerProto::Serialise< T > \
{ \
static T read(const Store & store, WorkerProto::ReadConn conn); \
static void write(const Store & store, WorkerProto::WriteConn conn, const T & t); \
};
template<>
MAKE_WORKER_PROTO(std::string);
DECLARE_WORKER_SERIALISER(DerivedPath);
template<>
MAKE_WORKER_PROTO(StorePath);
DECLARE_WORKER_SERIALISER(BuildResult);
template<>
MAKE_WORKER_PROTO(ContentAddress);
DECLARE_WORKER_SERIALISER(KeyedBuildResult);
template<>
MAKE_WORKER_PROTO(DerivedPath);
template<>
MAKE_WORKER_PROTO(DrvOutput);
template<>
MAKE_WORKER_PROTO(Realisation);
template<>
MAKE_WORKER_PROTO(BuildResult);
template<>
MAKE_WORKER_PROTO(KeyedBuildResult);
template<>
MAKE_WORKER_PROTO(std::optional<TrustedFlag>);
DECLARE_WORKER_SERIALISER(std::optional<TrustedFlag>);
template<typename T>
MAKE_WORKER_PROTO(std::vector<T>);
DECLARE_WORKER_SERIALISER(std::vector<T>);
template<typename T>
MAKE_WORKER_PROTO(std::set<T>);
DECLARE_WORKER_SERIALISER(std::set<T>);
template<typename... Ts>
MAKE_WORKER_PROTO(std::tuple<Ts...>);
DECLARE_WORKER_SERIALISER(std::tuple<Ts...>);
#define COMMA_ ,
template<typename K, typename V>
#define X_ std::map<K, V>
MAKE_WORKER_PROTO(X_);
#undef X_
/**
* These use the empty string for the null case, relying on the fact
* that the underlying types never serialise to the empty string.
*
* We do this instead of a generic std::optional<T> instance because
* ordinal tags (0 or 1, here) are a bit of a compatability hazard. For
* the same reason, we don't have a std::variant<T..> instances (ordinal
* tags 0...n).
*
* We could the generic instances and then these as specializations for
* compatability, but that's proven a bit finnicky, and also makes the
* worker protocol harder to implement in other languages where such
* specializations may not be allowed.
*/
template<>
MAKE_WORKER_PROTO(std::optional<StorePath>);
template<>
MAKE_WORKER_PROTO(std::optional<ContentAddress>);
DECLARE_WORKER_SERIALISER(std::map<K COMMA_ V>);
#undef COMMA_
}