diff options
Diffstat (limited to 'third_party/nix/src/proto')
| -rw-r--r-- | third_party/nix/src/proto/CMakeLists.txt | 37 | ||||
| -rw-r--r-- | third_party/nix/src/proto/worker.proto | 374 |
2 files changed, 411 insertions, 0 deletions
diff --git a/third_party/nix/src/proto/CMakeLists.txt b/third_party/nix/src/proto/CMakeLists.txt new file mode 100644 index 000000000000..726ca8742f86 --- /dev/null +++ b/third_party/nix/src/proto/CMakeLists.txt @@ -0,0 +1,37 @@ +# -*- mode: cmake; -*- +# +# The proto generation happens outside of CMake and the path to the +# generated files is passed in via the environment variable +# $NIX_PROTO_SRCS. +# +# This configuration defines a library target that compiles these +# sources and makes the headers available. + +add_library(nixproto SHARED) +set_property(TARGET nixproto PROPERTY CXX_STANDARD 17) + +set(HEADER_FILES + $ENV{NIX_PROTO_SRCS}/libproto/worker.grpc.pb.h + $ENV{NIX_PROTO_SRCS}/libproto/worker.pb.h +) + +target_sources(nixproto + PUBLIC + ${HEADER_FILES} + + PRIVATE + $ENV{NIX_PROTO_SRCS}/libproto/worker.grpc.pb.cc + $ENV{NIX_PROTO_SRCS}/libproto/worker.pb.cc +) + +target_link_libraries(nixproto + gRPC::grpc++_reflection + protobuf::libprotobuf +) + +target_include_directories(nixproto + INTERFACE $ENV{NIX_PROTO_SRCS} +) + +INSTALL(FILES ${HEADER_FILES} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/nix/libproto) +INSTALL(TARGETS nixproto DESTINATION ${CMAKE_INSTALL_LIBDIR}) diff --git a/third_party/nix/src/proto/worker.proto b/third_party/nix/src/proto/worker.proto new file mode 100644 index 000000000000..b0dc32afbe5f --- /dev/null +++ b/third_party/nix/src/proto/worker.proto @@ -0,0 +1,374 @@ +syntax = "proto3"; + +import "google/protobuf/empty.proto"; +import "google/protobuf/timestamp.proto"; + +package nix.proto; + +// Service representing a worker used for building and interfacing +// with the Nix store. +service WorkerService { + // Validates whether the supplied path is a valid store path. + rpc IsValidPath(StorePath) returns (IsValidPathResponse); + + // Checks whether any substitutes exist for the given path. + rpc HasSubstitutes(StorePath) returns (HasSubstitutesResponse); + + // Query referrers for a given path. + rpc QueryReferrers(StorePath) returns (StorePaths); + + // Add a path to the store. The first stream request + // should be a message indicating metadata, the rest should be file + // chunks. + rpc AddToStore(stream AddToStoreRequest) returns (StorePath); + + // Adds the supplied string to the store, as a text file. + rpc AddTextToStore(stream AddTextToStoreRequest) returns (StorePath); + + // Build the specified derivations in one of the specified build + // modes, defaulting to a normal build. + rpc BuildPaths(BuildPathsRequest) returns (stream BuildEvent); + + // TODO: What does this do? + rpc EnsurePath(StorePath) returns (google.protobuf.Empty); + + // TODO: What does this do? + // TODO(grfn): This should not actually take a StorePath, as it's not a + // StorePath + rpc AddTempRoot(StorePath) returns (google.protobuf.Empty); + + // TODO: What does this do? + rpc AddIndirectRoot(StorePath) returns (google.protobuf.Empty); + + // TODO: What does this do? + rpc SyncWithGC(google.protobuf.Empty) returns (google.protobuf.Empty); + + // TODO: What does this do? + rpc FindRoots(google.protobuf.Empty) returns (FindRootsResponse); + + // TODO: What does this do? + rpc SetOptions(SetOptionsRequest) returns (google.protobuf.Empty); + + // Ask the store to perform a garbage collection, based on the + // specified parameters. See `GCAction` for the possible actions. + rpc CollectGarbage(CollectGarbageRequest) returns (CollectGarbageResponse); + + // TODO: What does this do? + rpc QuerySubstitutablePathInfos(StorePaths) returns (SubstitutablePathInfos); + + // TODO: What does this do? + rpc QueryDerivationOutputs(StorePath) returns (StorePaths); + + // Query all valid paths in the store + rpc QueryAllValidPaths(google.protobuf.Empty) returns (StorePaths); + + // TODO: What does this do? + rpc QueryPathInfo(StorePath) returns (PathInfo); + + // Query the output names of the given derivation + rpc QueryDerivationOutputNames(StorePath) returns (DerivationOutputNames); + + // TODO: What is a HashPart? + rpc QueryPathFromHashPart(HashPart) returns (StorePath); + + // Query which of the given paths is valid. + rpc QueryValidPaths(StorePaths) returns (StorePaths); + + // Query which of the given paths have substitutes. + rpc QuerySubstitutablePaths(StorePaths) returns (StorePaths); + + // Return all currently valid derivations that have the given store path as an + // output. + rpc QueryValidDerivers(StorePath) returns (StorePaths); + + // Optimise the disk space usage of the Nix store by hard-linking files + // with the same contents. + rpc OptimiseStore(google.protobuf.Empty) returns (google.protobuf.Empty); + + // Check the integrity of the Nix store + rpc VerifyStore(VerifyStoreRequest) returns (VerifyStoreResponse); + + // Build a single non-materialized derivation (i.e. not from an + // on-disk .drv file). + rpc BuildDerivation(BuildDerivationRequest) returns (stream BuildEvent); + + // Add signatures to the specified store path. The signatures are not + // verified. + rpc AddSignatures(AddSignaturesRequest) returns (google.protobuf.Empty); + + // TODO: What does this do? + rpc NarFromPath(StorePath) returns (StorePath); + + // Upload & add a NAR to the daemon's Nix store. + rpc AddToStoreNar(stream AddToStoreNarRequest) + returns (google.protobuf.Empty); + + // Given a set of paths that are to be built, return the set of + // derivations that will be built, and the set of output paths that + // will be substituted. + rpc QueryMissing(StorePaths) returns (QueryMissingResponse); + + // Return the build log of the specified store path, if available + rpc GetBuildLog(StorePath) returns (BuildLog); +} + +enum HashType { + UNKNOWN = 0; + MD5 = 1; // TODO(tazjin): still needed? + SHA1 = 2; + SHA256 = 3; + SHA512 = 4; +} + +enum BuildMode { + Normal = 0; + Repair = 1; + Check = 2; +} + +enum GCAction { + // Return the set of paths reachable from (i.e. in the closure of) + // the roots. + ReturnLive = 0; + + // Return the set of paths not reachable from the roots. + ReturnDead = 1; + + // Actually delete the latter set. + DeleteDead = 2; + + // Delete the paths listed in `pathsToDelete', insofar as they are + // not reachable. + DeleteSpecific = 3; +} + +enum BuildStatus { + Built = 0; + Substituted = 1; + AlreadyValid = 2; + PermanentFailure = 3; + InputRejected = 4; + OutputRejected = 5; + TransientFailure = 6; // possibly transient + CachedFailure = 7; // no longer used + TimedOut = 8; + MiscFailure = 9; + DependencyFailed = 10; + LogLimitExceeded = 11; + NotDeterministic = 12; +}; + +// Generic type for any RPC call that just reads or returns a single +// store path. +message StorePath { + string path = 1; +} + +// Generic type for any RPC call that just reads or returns a list of +// store paths. +message StorePaths { + repeated string paths = 1; +} + +message Signatures { + repeated string sigs = 1; +} + +// Represents the outcome of a build for a single store path. +message BuildResult { + StorePath path = 1; + BuildStatus status = 2; + string msg = 3; +} + +// Represents an event occuring during a build. +message BuildEvent { + message LogLine { + string line = 1; + StorePath path = 2; + } + + oneof result_type { + // Build for a store path has finished + BuildResult result = 1; + + // A line of build log output was produced + LogLine build_log = 2; + + // Build for a store path has started + StorePath building_path = 3; + } +} + +message IsValidPathResponse { + bool is_valid = 1; +} + +message HasSubstitutesResponse { + bool has_substitutes = 1; +} + +message AddToStoreRequest { + message Metadata { + bool fixed = 1; + bool recursive = 2; // TODO(tazjin): what is this? "obsolete" comment? + HashType hash_type = 3; + string base_name = 4; + } + + oneof add_oneof { + Metadata meta = 1; + bytes data = 3; + } +} + +message AddTextToStoreRequest { + message Metadata { + string name = 1; + repeated string references = 2; + uint64 size = 3; + } + + oneof add_oneof { + Metadata meta = 4; + bytes data = 5; + } +} + +message BuildPathsRequest { + repeated string drvs = 1; + BuildMode mode = 2; +} + +message FindRootsResponse { + map<string, StorePaths> roots = 1; +} + +message SetOptionsRequest { + bool keep_failed = 1; + bool keep_going = 2; + bool try_fallback = 3; + uint32 max_build_jobs = 4; + uint32 verbose_build = + 5; // TODO(tazjin): Maybe this should be bool, unclear. + uint32 build_cores = 6; // TODO(tazjin): Difference from max_build_jobs? + bool use_substitutes = 7; + map<string, string> overrides = 8; // TODO(tazjin): better name? +} + +message CollectGarbageRequest { + // GC action that should be performed. + GCAction action = 1; + + // For `DeleteSpecific', the paths to delete. + repeated string paths_to_delete = 2; + + // If `ignore_liveness' is set, then reachability from the roots is + // ignored (dangerous!). However, the paths must still be + // unreferenced *within* the store (i.e., there can be no other + // store paths that depend on them). + bool ignore_liveness = 3; + + // Stop after at least `max_freed' bytes have been freed. + uint64 max_freed = 4; +} + +message CollectGarbageResponse { + // Depending on the action, the GC roots, or the paths that would be + // or have been deleted. + repeated string deleted_paths = 1; + + // For `ReturnDead', `DeleteDead' and `DeleteSpecific', the number + // of bytes that would be or was freed. + uint64 bytes_freed = 2; +} + +message PathInfo { + StorePath path = 10; + bool is_valid = 9; + StorePath deriver = 1; + bytes nar_hash = 2; + repeated string references = 3; + google.protobuf.Timestamp registration_time = 4; + uint64 download_size = 11; + uint64 nar_size = 5; + // Whether the path is ultimately trusted, that is, it's a derivation + // output that was built locally. + bool ultimate = 6; + repeated string sigs = 7; + // If non-empty, an assertion that the path is content-addressed + string ca = 8; + + // Only used for AddToStoreNarRequest + bool repair = 12; + bool check_sigs = 13; +} + +message SubstitutablePathInfos { + repeated PathInfo path_infos = 1; +} + +message DerivationOutputNames { + repeated string names = 1; +} + +message HashPart { + string hash_part = 1; +} + +message VerifyStoreRequest { + bool check_contents = 1; + bool repair = 2; + // TODO(grfn): Remove double-negative + bool dont_check_sigs = 3; +} + +message VerifyStoreResponse { + // True if errors remain (???) + bool errors = 1; +} + +message Derivation { + message DerivationOutput { + StorePath path = 1; + string hash_algo = 2; + bytes hash = 3; + } + map<string, DerivationOutput> outputs = 1; + StorePaths input_sources = 2; + string platform = 3; + StorePath builder = 4; + repeated string args = 5; + map<string, string> env = 6; +} + +message BuildDerivationRequest { + // Only used for informational purposes. + StorePath drv_path = 1; + Derivation derivation = 2; + BuildMode build_mode = 3; +} + +message AddSignaturesRequest { + StorePath path = 1; + Signatures sigs = 2; +} + +message AddToStoreNarRequest { + oneof add_oneof { + PathInfo path_info = 1; + bytes data = 2; + } +} + +message QueryMissingResponse { + repeated string will_build = 1; + repeated string will_substitute = 2; + repeated string unknown = 3; + uint64 download_size = 4; + uint64 nar_size = 5; +} + +message BuildLog { + string build_log = 1; +} |