mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 14:20:23 -04:00
2808 lines
118 KiB
Go
2808 lines
118 KiB
Go
![]() |
// Code generated by protoc-gen-go. DO NOT EDIT.
|
||
|
// source: google/devtools/remoteexecution/v1test/remote_execution.proto
|
||
|
|
||
|
package remoteexecution // import "google.golang.org/genproto/googleapis/devtools/remoteexecution/v1test"
|
||
|
|
||
|
import proto "github.com/golang/protobuf/proto"
|
||
|
import fmt "fmt"
|
||
|
import math "math"
|
||
|
import duration "github.com/golang/protobuf/ptypes/duration"
|
||
|
import _ "google.golang.org/genproto/googleapis/api/annotations"
|
||
|
import longrunning "google.golang.org/genproto/googleapis/longrunning"
|
||
|
import status "google.golang.org/genproto/googleapis/rpc/status"
|
||
|
|
||
|
import (
|
||
|
context "golang.org/x/net/context"
|
||
|
grpc "google.golang.org/grpc"
|
||
|
)
|
||
|
|
||
|
// Reference imports to suppress errors if they are not otherwise used.
|
||
|
var _ = proto.Marshal
|
||
|
var _ = fmt.Errorf
|
||
|
var _ = math.Inf
|
||
|
|
||
|
// This is a compile-time assertion to ensure that this generated file
|
||
|
// is compatible with the proto package it is being compiled against.
|
||
|
// A compilation error at this line likely means your copy of the
|
||
|
// proto package needs to be updated.
|
||
|
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
|
||
|
|
||
|
// The current stage of execution.
|
||
|
type ExecuteOperationMetadata_Stage int32
|
||
|
|
||
|
const (
|
||
|
ExecuteOperationMetadata_UNKNOWN ExecuteOperationMetadata_Stage = 0
|
||
|
// Checking the result against the cache.
|
||
|
ExecuteOperationMetadata_CACHE_CHECK ExecuteOperationMetadata_Stage = 1
|
||
|
// Currently idle, awaiting a free machine to execute.
|
||
|
ExecuteOperationMetadata_QUEUED ExecuteOperationMetadata_Stage = 2
|
||
|
// Currently being executed by a worker.
|
||
|
ExecuteOperationMetadata_EXECUTING ExecuteOperationMetadata_Stage = 3
|
||
|
// Finished execution.
|
||
|
ExecuteOperationMetadata_COMPLETED ExecuteOperationMetadata_Stage = 4
|
||
|
)
|
||
|
|
||
|
var ExecuteOperationMetadata_Stage_name = map[int32]string{
|
||
|
0: "UNKNOWN",
|
||
|
1: "CACHE_CHECK",
|
||
|
2: "QUEUED",
|
||
|
3: "EXECUTING",
|
||
|
4: "COMPLETED",
|
||
|
}
|
||
|
var ExecuteOperationMetadata_Stage_value = map[string]int32{
|
||
|
"UNKNOWN": 0,
|
||
|
"CACHE_CHECK": 1,
|
||
|
"QUEUED": 2,
|
||
|
"EXECUTING": 3,
|
||
|
"COMPLETED": 4,
|
||
|
}
|
||
|
|
||
|
func (x ExecuteOperationMetadata_Stage) String() string {
|
||
|
return proto.EnumName(ExecuteOperationMetadata_Stage_name, int32(x))
|
||
|
}
|
||
|
func (ExecuteOperationMetadata_Stage) EnumDescriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{14, 0}
|
||
|
}
|
||
|
|
||
|
// An `Action` captures all the information about an execution which is required
|
||
|
// to reproduce it.
|
||
|
//
|
||
|
// `Action`s are the core component of the [Execution] service. A single
|
||
|
// `Action` represents a repeatable action that can be performed by the
|
||
|
// execution service. `Action`s can be succinctly identified by the digest of
|
||
|
// their wire format encoding and, once an `Action` has been executed, will be
|
||
|
// cached in the action cache. Future requests can then use the cached result
|
||
|
// rather than needing to run afresh.
|
||
|
//
|
||
|
// When a server completes execution of an
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action], it MAY choose to
|
||
|
// cache the [result][google.devtools.remoteexecution.v1test.ActionResult] in
|
||
|
// the [ActionCache][google.devtools.remoteexecution.v1test.ActionCache] unless
|
||
|
// `do_not_cache` is `true`. Clients SHOULD expect the server to do so. By
|
||
|
// default, future calls to [Execute][] the same `Action` will also serve their
|
||
|
// results from the cache. Clients must take care to understand the caching
|
||
|
// behaviour. Ideally, all `Action`s will be reproducible so that serving a
|
||
|
// result from cache is always desirable and correct.
|
||
|
type Action struct {
|
||
|
// The digest of the [Command][google.devtools.remoteexecution.v1test.Command]
|
||
|
// to run, which MUST be present in the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage].
|
||
|
CommandDigest *Digest `protobuf:"bytes,1,opt,name=command_digest,json=commandDigest,proto3" json:"command_digest,omitempty"`
|
||
|
// The digest of the root
|
||
|
// [Directory][google.devtools.remoteexecution.v1test.Directory] for the input
|
||
|
// files. The files in the directory tree are available in the correct
|
||
|
// location on the build machine before the command is executed. The root
|
||
|
// directory, as well as every subdirectory and content blob referred to, MUST
|
||
|
// be in the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage].
|
||
|
InputRootDigest *Digest `protobuf:"bytes,2,opt,name=input_root_digest,json=inputRootDigest,proto3" json:"input_root_digest,omitempty"`
|
||
|
// A list of the output files that the client expects to retrieve from the
|
||
|
// action. Only the listed files, as well as directories listed in
|
||
|
// `output_directories`, will be returned to the client as output.
|
||
|
// Other files that may be created during command execution are discarded.
|
||
|
//
|
||
|
// The paths are relative to the working directory of the action execution.
|
||
|
// The paths are specified using a single forward slash (`/`) as a path
|
||
|
// separator, even if the execution platform natively uses a different
|
||
|
// separator. The path MUST NOT include a trailing slash, nor a leading slash,
|
||
|
// being a relative path.
|
||
|
//
|
||
|
// In order to ensure consistent hashing of the same Action, the output paths
|
||
|
// MUST be sorted lexicographically by code point (or, equivalently, by UTF-8
|
||
|
// bytes).
|
||
|
OutputFiles []string `protobuf:"bytes,3,rep,name=output_files,json=outputFiles,proto3" json:"output_files,omitempty"`
|
||
|
// A list of the output directories that the client expects to retrieve from
|
||
|
// the action. Only the contents of the indicated directories (recursively
|
||
|
// including the contents of their subdirectories) will be
|
||
|
// returned, as well as files listed in `output_files`. Other files that may
|
||
|
// be created during command execution are discarded.
|
||
|
//
|
||
|
// The paths are relative to the working directory of the action execution.
|
||
|
// The paths are specified using a single forward slash (`/`) as a path
|
||
|
// separator, even if the execution platform natively uses a different
|
||
|
// separator. The path MUST NOT include a trailing slash, nor a leading slash,
|
||
|
// being a relative path.
|
||
|
// The special value of empty string is allowed, although not recommended, and
|
||
|
// can be used to capture the entire working directory tree, including inputs.
|
||
|
//
|
||
|
// In order to ensure consistent hashing of the same Action, the output paths
|
||
|
// MUST be sorted lexicographically by code point (or, equivalently, by UTF-8
|
||
|
// bytes).
|
||
|
OutputDirectories []string `protobuf:"bytes,4,rep,name=output_directories,json=outputDirectories,proto3" json:"output_directories,omitempty"`
|
||
|
// The platform requirements for the execution environment. The server MAY
|
||
|
// choose to execute the action on any worker satisfying the requirements, so
|
||
|
// the client SHOULD ensure that running the action on any such worker will
|
||
|
// have the same result.
|
||
|
Platform *Platform `protobuf:"bytes,5,opt,name=platform,proto3" json:"platform,omitempty"`
|
||
|
// A timeout after which the execution should be killed. If the timeout is
|
||
|
// absent, then the client is specifying that the execution should continue
|
||
|
// as long as the server will let it. The server SHOULD impose a timeout if
|
||
|
// the client does not specify one, however, if the client does specify a
|
||
|
// timeout that is longer than the server's maximum timeout, the server MUST
|
||
|
// reject the request.
|
||
|
//
|
||
|
// The timeout is a part of the
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action] message, and
|
||
|
// therefore two `Actions` with different timeouts are different, even if they
|
||
|
// are otherwise identical. This is because, if they were not, running an
|
||
|
// `Action` with a lower timeout than is required might result in a cache hit
|
||
|
// from an execution run with a longer timeout, hiding the fact that the
|
||
|
// timeout is too short. By encoding it directly in the `Action`, a lower
|
||
|
// timeout will result in a cache miss and the execution timeout will fail
|
||
|
// immediately, rather than whenever the cache entry gets evicted.
|
||
|
Timeout *duration.Duration `protobuf:"bytes,6,opt,name=timeout,proto3" json:"timeout,omitempty"`
|
||
|
// If true, then the `Action`'s result cannot be cached.
|
||
|
DoNotCache bool `protobuf:"varint,7,opt,name=do_not_cache,json=doNotCache,proto3" json:"do_not_cache,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Action) Reset() { *m = Action{} }
|
||
|
func (m *Action) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Action) ProtoMessage() {}
|
||
|
func (*Action) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{0}
|
||
|
}
|
||
|
func (m *Action) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Action.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Action) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Action.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Action) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Action.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Action) XXX_Size() int {
|
||
|
return xxx_messageInfo_Action.Size(m)
|
||
|
}
|
||
|
func (m *Action) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Action.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Action proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Action) GetCommandDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.CommandDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Action) GetInputRootDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.InputRootDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Action) GetOutputFiles() []string {
|
||
|
if m != nil {
|
||
|
return m.OutputFiles
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Action) GetOutputDirectories() []string {
|
||
|
if m != nil {
|
||
|
return m.OutputDirectories
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Action) GetPlatform() *Platform {
|
||
|
if m != nil {
|
||
|
return m.Platform
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Action) GetTimeout() *duration.Duration {
|
||
|
if m != nil {
|
||
|
return m.Timeout
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Action) GetDoNotCache() bool {
|
||
|
if m != nil {
|
||
|
return m.DoNotCache
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// A `Command` is the actual command executed by a worker running an
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action].
|
||
|
//
|
||
|
// Except as otherwise required, the environment (such as which system
|
||
|
// libraries or binaries are available, and what filesystems are mounted where)
|
||
|
// is defined by and specific to the implementation of the remote execution API.
|
||
|
type Command struct {
|
||
|
// The arguments to the command. The first argument must be the path to the
|
||
|
// executable, which must be either a relative path, in which case it is
|
||
|
// evaluated with respect to the input root, or an absolute path.
|
||
|
//
|
||
|
// The working directory will always be the input root.
|
||
|
Arguments []string `protobuf:"bytes,1,rep,name=arguments,proto3" json:"arguments,omitempty"`
|
||
|
// The environment variables to set when running the program. The worker may
|
||
|
// provide its own default environment variables; these defaults can be
|
||
|
// overridden using this field. Additional variables can also be specified.
|
||
|
//
|
||
|
// In order to ensure that equivalent `Command`s always hash to the same
|
||
|
// value, the environment variables MUST be lexicographically sorted by name.
|
||
|
// Sorting of strings is done by code point, equivalently, by the UTF-8 bytes.
|
||
|
EnvironmentVariables []*Command_EnvironmentVariable `protobuf:"bytes,2,rep,name=environment_variables,json=environmentVariables,proto3" json:"environment_variables,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Command) Reset() { *m = Command{} }
|
||
|
func (m *Command) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Command) ProtoMessage() {}
|
||
|
func (*Command) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{1}
|
||
|
}
|
||
|
func (m *Command) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Command.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Command) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Command.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Command) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Command.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Command) XXX_Size() int {
|
||
|
return xxx_messageInfo_Command.Size(m)
|
||
|
}
|
||
|
func (m *Command) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Command.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Command proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Command) GetArguments() []string {
|
||
|
if m != nil {
|
||
|
return m.Arguments
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Command) GetEnvironmentVariables() []*Command_EnvironmentVariable {
|
||
|
if m != nil {
|
||
|
return m.EnvironmentVariables
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// An `EnvironmentVariable` is one variable to set in the running program's
|
||
|
// environment.
|
||
|
type Command_EnvironmentVariable struct {
|
||
|
// The variable name.
|
||
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
||
|
// The variable value.
|
||
|
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Command_EnvironmentVariable) Reset() { *m = Command_EnvironmentVariable{} }
|
||
|
func (m *Command_EnvironmentVariable) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Command_EnvironmentVariable) ProtoMessage() {}
|
||
|
func (*Command_EnvironmentVariable) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{1, 0}
|
||
|
}
|
||
|
func (m *Command_EnvironmentVariable) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Command_EnvironmentVariable.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Command_EnvironmentVariable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Command_EnvironmentVariable.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Command_EnvironmentVariable) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Command_EnvironmentVariable.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Command_EnvironmentVariable) XXX_Size() int {
|
||
|
return xxx_messageInfo_Command_EnvironmentVariable.Size(m)
|
||
|
}
|
||
|
func (m *Command_EnvironmentVariable) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Command_EnvironmentVariable.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Command_EnvironmentVariable proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Command_EnvironmentVariable) GetName() string {
|
||
|
if m != nil {
|
||
|
return m.Name
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *Command_EnvironmentVariable) GetValue() string {
|
||
|
if m != nil {
|
||
|
return m.Value
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
// A `Platform` is a set of requirements, such as hardware, operating system, or
|
||
|
// compiler toolchain, for an
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action]'s execution
|
||
|
// environment. A `Platform` is represented as a series of key-value pairs
|
||
|
// representing the properties that are required of the platform.
|
||
|
//
|
||
|
// This message is currently being redeveloped since it is an overly simplistic
|
||
|
// model of platforms.
|
||
|
type Platform struct {
|
||
|
// The properties that make up this platform. In order to ensure that
|
||
|
// equivalent `Platform`s always hash to the same value, the properties MUST
|
||
|
// be lexicographically sorted by name, and then by value. Sorting of strings
|
||
|
// is done by code point, equivalently, by the UTF-8 bytes.
|
||
|
Properties []*Platform_Property `protobuf:"bytes,1,rep,name=properties,proto3" json:"properties,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Platform) Reset() { *m = Platform{} }
|
||
|
func (m *Platform) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Platform) ProtoMessage() {}
|
||
|
func (*Platform) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{2}
|
||
|
}
|
||
|
func (m *Platform) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Platform.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Platform) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Platform.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Platform) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Platform.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Platform) XXX_Size() int {
|
||
|
return xxx_messageInfo_Platform.Size(m)
|
||
|
}
|
||
|
func (m *Platform) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Platform.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Platform proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Platform) GetProperties() []*Platform_Property {
|
||
|
if m != nil {
|
||
|
return m.Properties
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A single property for the environment. The server is responsible for
|
||
|
// specifying the property `name`s that it accepts. If an unknown `name` is
|
||
|
// provided in the requirements for an
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action], the server SHOULD
|
||
|
// reject the execution request. If permitted by the server, the same `name`
|
||
|
// may occur multiple times.
|
||
|
//
|
||
|
// The server is also responsible for specifying the interpretation of
|
||
|
// property `value`s. For instance, a property describing how much RAM must be
|
||
|
// available may be interpreted as allowing a worker with 16GB to fulfill a
|
||
|
// request for 8GB, while a property describing the OS environment on which
|
||
|
// the action must be performed may require an exact match with the worker's
|
||
|
// OS.
|
||
|
//
|
||
|
// The server MAY use the `value` of one or more properties to determine how
|
||
|
// it sets up the execution environment, such as by making specific system
|
||
|
// files available to the worker.
|
||
|
type Platform_Property struct {
|
||
|
// The property name.
|
||
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
||
|
// The property value.
|
||
|
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Platform_Property) Reset() { *m = Platform_Property{} }
|
||
|
func (m *Platform_Property) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Platform_Property) ProtoMessage() {}
|
||
|
func (*Platform_Property) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{2, 0}
|
||
|
}
|
||
|
func (m *Platform_Property) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Platform_Property.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Platform_Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Platform_Property.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Platform_Property) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Platform_Property.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Platform_Property) XXX_Size() int {
|
||
|
return xxx_messageInfo_Platform_Property.Size(m)
|
||
|
}
|
||
|
func (m *Platform_Property) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Platform_Property.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Platform_Property proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Platform_Property) GetName() string {
|
||
|
if m != nil {
|
||
|
return m.Name
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *Platform_Property) GetValue() string {
|
||
|
if m != nil {
|
||
|
return m.Value
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
// A `Directory` represents a directory node in a file tree, containing zero or
|
||
|
// more children [FileNodes][google.devtools.remoteexecution.v1test.FileNode]
|
||
|
// and [DirectoryNodes][google.devtools.remoteexecution.v1test.DirectoryNode].
|
||
|
// Each `Node` contains its name in the directory, the digest of its content
|
||
|
// (either a file blob or a `Directory` proto), as well as possibly some
|
||
|
// metadata about the file or directory.
|
||
|
//
|
||
|
// In order to ensure that two equivalent directory trees hash to the same
|
||
|
// value, the following restrictions MUST be obeyed when constructing a
|
||
|
// a `Directory`:
|
||
|
// - Every child in the directory must have a path of exactly one segment.
|
||
|
// Multiple levels of directory hierarchy may not be collapsed.
|
||
|
// - Each child in the directory must have a unique path segment (file name).
|
||
|
// - The files and directories in the directory must each be sorted in
|
||
|
// lexicographical order by path. The path strings must be sorted by code
|
||
|
// point, equivalently, by UTF-8 bytes.
|
||
|
//
|
||
|
// A `Directory` that obeys the restrictions is said to be in canonical form.
|
||
|
//
|
||
|
// As an example, the following could be used for a file named `bar` and a
|
||
|
// directory named `foo` with an executable file named `baz` (hashes shortened
|
||
|
// for readability):
|
||
|
//
|
||
|
// ```json
|
||
|
// // (Directory proto)
|
||
|
// {
|
||
|
// files: [
|
||
|
// {
|
||
|
// name: "bar",
|
||
|
// digest: {
|
||
|
// hash: "4a73bc9d03...",
|
||
|
// size: 65534
|
||
|
// }
|
||
|
// }
|
||
|
// ],
|
||
|
// directories: [
|
||
|
// {
|
||
|
// name: "foo",
|
||
|
// digest: {
|
||
|
// hash: "4cf2eda940...",
|
||
|
// size: 43
|
||
|
// }
|
||
|
// }
|
||
|
// ]
|
||
|
// }
|
||
|
//
|
||
|
// // (Directory proto with hash "4cf2eda940..." and size 43)
|
||
|
// {
|
||
|
// files: [
|
||
|
// {
|
||
|
// name: "baz",
|
||
|
// digest: {
|
||
|
// hash: "b2c941073e...",
|
||
|
// size: 1294,
|
||
|
// },
|
||
|
// is_executable: true
|
||
|
// }
|
||
|
// ]
|
||
|
// }
|
||
|
// ```
|
||
|
type Directory struct {
|
||
|
// The files in the directory.
|
||
|
Files []*FileNode `protobuf:"bytes,1,rep,name=files,proto3" json:"files,omitempty"`
|
||
|
// The subdirectories in the directory.
|
||
|
Directories []*DirectoryNode `protobuf:"bytes,2,rep,name=directories,proto3" json:"directories,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Directory) Reset() { *m = Directory{} }
|
||
|
func (m *Directory) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Directory) ProtoMessage() {}
|
||
|
func (*Directory) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{3}
|
||
|
}
|
||
|
func (m *Directory) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Directory.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Directory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Directory.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Directory) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Directory.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Directory) XXX_Size() int {
|
||
|
return xxx_messageInfo_Directory.Size(m)
|
||
|
}
|
||
|
func (m *Directory) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Directory.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Directory proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Directory) GetFiles() []*FileNode {
|
||
|
if m != nil {
|
||
|
return m.Files
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Directory) GetDirectories() []*DirectoryNode {
|
||
|
if m != nil {
|
||
|
return m.Directories
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A `FileNode` represents a single file and associated metadata.
|
||
|
type FileNode struct {
|
||
|
// The name of the file.
|
||
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
||
|
// The digest of the file's content.
|
||
|
Digest *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
|
||
|
// True if file is executable, false otherwise.
|
||
|
IsExecutable bool `protobuf:"varint,4,opt,name=is_executable,json=isExecutable,proto3" json:"is_executable,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *FileNode) Reset() { *m = FileNode{} }
|
||
|
func (m *FileNode) String() string { return proto.CompactTextString(m) }
|
||
|
func (*FileNode) ProtoMessage() {}
|
||
|
func (*FileNode) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{4}
|
||
|
}
|
||
|
func (m *FileNode) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_FileNode.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *FileNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_FileNode.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *FileNode) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_FileNode.Merge(dst, src)
|
||
|
}
|
||
|
func (m *FileNode) XXX_Size() int {
|
||
|
return xxx_messageInfo_FileNode.Size(m)
|
||
|
}
|
||
|
func (m *FileNode) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_FileNode.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_FileNode proto.InternalMessageInfo
|
||
|
|
||
|
func (m *FileNode) GetName() string {
|
||
|
if m != nil {
|
||
|
return m.Name
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *FileNode) GetDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.Digest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *FileNode) GetIsExecutable() bool {
|
||
|
if m != nil {
|
||
|
return m.IsExecutable
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// A `DirectoryNode` represents a child of a
|
||
|
// [Directory][google.devtools.remoteexecution.v1test.Directory] which is itself
|
||
|
// a `Directory` and its associated metadata.
|
||
|
type DirectoryNode struct {
|
||
|
// The name of the directory.
|
||
|
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
||
|
// The digest of the
|
||
|
// [Directory][google.devtools.remoteexecution.v1test.Directory] object
|
||
|
// represented. See [Digest][google.devtools.remoteexecution.v1test.Digest]
|
||
|
// for information about how to take the digest of a proto message.
|
||
|
Digest *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *DirectoryNode) Reset() { *m = DirectoryNode{} }
|
||
|
func (m *DirectoryNode) String() string { return proto.CompactTextString(m) }
|
||
|
func (*DirectoryNode) ProtoMessage() {}
|
||
|
func (*DirectoryNode) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{5}
|
||
|
}
|
||
|
func (m *DirectoryNode) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_DirectoryNode.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *DirectoryNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_DirectoryNode.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *DirectoryNode) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_DirectoryNode.Merge(dst, src)
|
||
|
}
|
||
|
func (m *DirectoryNode) XXX_Size() int {
|
||
|
return xxx_messageInfo_DirectoryNode.Size(m)
|
||
|
}
|
||
|
func (m *DirectoryNode) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_DirectoryNode.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_DirectoryNode proto.InternalMessageInfo
|
||
|
|
||
|
func (m *DirectoryNode) GetName() string {
|
||
|
if m != nil {
|
||
|
return m.Name
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *DirectoryNode) GetDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.Digest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A content digest. A digest for a given blob consists of the size of the blob
|
||
|
// and its hash. The hash algorithm to use is defined by the server, but servers
|
||
|
// SHOULD use SHA-256.
|
||
|
//
|
||
|
// The size is considered to be an integral part of the digest and cannot be
|
||
|
// separated. That is, even if the `hash` field is correctly specified but
|
||
|
// `size_bytes` is not, the server MUST reject the request.
|
||
|
//
|
||
|
// The reason for including the size in the digest is as follows: in a great
|
||
|
// many cases, the server needs to know the size of the blob it is about to work
|
||
|
// with prior to starting an operation with it, such as flattening Merkle tree
|
||
|
// structures or streaming it to a worker. Technically, the server could
|
||
|
// implement a separate metadata store, but this results in a significantly more
|
||
|
// complicated implementation as opposed to having the client specify the size
|
||
|
// up-front (or storing the size along with the digest in every message where
|
||
|
// digests are embedded). This does mean that the API leaks some implementation
|
||
|
// details of (what we consider to be) a reasonable server implementation, but
|
||
|
// we consider this to be a worthwhile tradeoff.
|
||
|
//
|
||
|
// When a `Digest` is used to refer to a proto message, it always refers to the
|
||
|
// message in binary encoded form. To ensure consistent hashing, clients and
|
||
|
// servers MUST ensure that they serialize messages according to the following
|
||
|
// rules, even if there are alternate valid encodings for the same message.
|
||
|
// - Fields are serialized in tag order.
|
||
|
// - There are no unknown fields.
|
||
|
// - There are no duplicate fields.
|
||
|
// - Fields are serialized according to the default semantics for their type.
|
||
|
//
|
||
|
// Most protocol buffer implementations will always follow these rules when
|
||
|
// serializing, but care should be taken to avoid shortcuts. For instance,
|
||
|
// concatenating two messages to merge them may produce duplicate fields.
|
||
|
type Digest struct {
|
||
|
// The hash. In the case of SHA-256, it will always be a lowercase hex string
|
||
|
// exactly 64 characters long.
|
||
|
Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
|
||
|
// The size of the blob, in bytes.
|
||
|
SizeBytes int64 `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Digest) Reset() { *m = Digest{} }
|
||
|
func (m *Digest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Digest) ProtoMessage() {}
|
||
|
func (*Digest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{6}
|
||
|
}
|
||
|
func (m *Digest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Digest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Digest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Digest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Digest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Digest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Digest) XXX_Size() int {
|
||
|
return xxx_messageInfo_Digest.Size(m)
|
||
|
}
|
||
|
func (m *Digest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Digest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Digest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Digest) GetHash() string {
|
||
|
if m != nil {
|
||
|
return m.Hash
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *Digest) GetSizeBytes() int64 {
|
||
|
if m != nil {
|
||
|
return m.SizeBytes
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
|
||
|
// An ActionResult represents the result of an
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action] being run.
|
||
|
type ActionResult struct {
|
||
|
// The output files of the action. For each output file requested in the
|
||
|
// `output_files` field of the Action, if the corresponding file existed after
|
||
|
// the action completed, a single entry will be present in the output list.
|
||
|
//
|
||
|
// If the action does not produce the requested output, or produces a
|
||
|
// directory where a regular file is expected or vice versa, then that output
|
||
|
// will be omitted from the list. The server is free to arrange the output
|
||
|
// list as desired; clients MUST NOT assume that the output list is sorted.
|
||
|
OutputFiles []*OutputFile `protobuf:"bytes,2,rep,name=output_files,json=outputFiles,proto3" json:"output_files,omitempty"`
|
||
|
// The output directories of the action. For each output directory requested
|
||
|
// in the `output_directories` field of the Action, if the corresponding
|
||
|
// directory existed after the action completed, a single entry will be
|
||
|
// present in the output list, which will contain the digest of
|
||
|
// a [Tree][google.devtools.remoteexecution.v1test.Tree] message containing
|
||
|
// the directory tree, and the path equal exactly to the corresponding Action
|
||
|
// output_directories member.
|
||
|
// As an example, suppose the Action had an output directory `a/b/dir` and the
|
||
|
// execution produced the following contents in `a/b/dir`: a file named `bar`
|
||
|
// and a directory named `foo` with an executable file named `baz`. Then,
|
||
|
// output_directory will contain (hashes shortened for readability):
|
||
|
//
|
||
|
// ```json
|
||
|
// // OutputDirectory proto:
|
||
|
// {
|
||
|
// path: "a/b/dir"
|
||
|
// tree_digest: {
|
||
|
// hash: "4a73bc9d03...",
|
||
|
// size: 55
|
||
|
// }
|
||
|
// }
|
||
|
// // Tree proto with hash "4a73bc9d03..." and size 55:
|
||
|
// {
|
||
|
// root: {
|
||
|
// files: [
|
||
|
// {
|
||
|
// name: "bar",
|
||
|
// digest: {
|
||
|
// hash: "4a73bc9d03...",
|
||
|
// size: 65534
|
||
|
// }
|
||
|
// }
|
||
|
// ],
|
||
|
// directories: [
|
||
|
// {
|
||
|
// name: "foo",
|
||
|
// digest: {
|
||
|
// hash: "4cf2eda940...",
|
||
|
// size: 43
|
||
|
// }
|
||
|
// }
|
||
|
// ]
|
||
|
// }
|
||
|
// children : {
|
||
|
// // (Directory proto with hash "4cf2eda940..." and size 43)
|
||
|
// files: [
|
||
|
// {
|
||
|
// name: "baz",
|
||
|
// digest: {
|
||
|
// hash: "b2c941073e...",
|
||
|
// size: 1294,
|
||
|
// },
|
||
|
// is_executable: true
|
||
|
// }
|
||
|
// ]
|
||
|
// }
|
||
|
// }
|
||
|
// ```
|
||
|
OutputDirectories []*OutputDirectory `protobuf:"bytes,3,rep,name=output_directories,json=outputDirectories,proto3" json:"output_directories,omitempty"`
|
||
|
// The exit code of the command.
|
||
|
ExitCode int32 `protobuf:"varint,4,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"`
|
||
|
// The standard output buffer of the action. The server will determine, based
|
||
|
// on the size of the buffer, whether to return it in raw form or to return
|
||
|
// a digest in `stdout_digest` that points to the buffer. If neither is set,
|
||
|
// then the buffer is empty. The client SHOULD NOT assume it will get one of
|
||
|
// the raw buffer or a digest on any given request and should be prepared to
|
||
|
// handle either.
|
||
|
StdoutRaw []byte `protobuf:"bytes,5,opt,name=stdout_raw,json=stdoutRaw,proto3" json:"stdout_raw,omitempty"`
|
||
|
// The digest for a blob containing the standard output of the action, which
|
||
|
// can be retrieved from the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage].
|
||
|
// See `stdout_raw` for when this will be set.
|
||
|
StdoutDigest *Digest `protobuf:"bytes,6,opt,name=stdout_digest,json=stdoutDigest,proto3" json:"stdout_digest,omitempty"`
|
||
|
// The standard error buffer of the action. The server will determine, based
|
||
|
// on the size of the buffer, whether to return it in raw form or to return
|
||
|
// a digest in `stderr_digest` that points to the buffer. If neither is set,
|
||
|
// then the buffer is empty. The client SHOULD NOT assume it will get one of
|
||
|
// the raw buffer or a digest on any given request and should be prepared to
|
||
|
// handle either.
|
||
|
StderrRaw []byte `protobuf:"bytes,7,opt,name=stderr_raw,json=stderrRaw,proto3" json:"stderr_raw,omitempty"`
|
||
|
// The digest for a blob containing the standard error of the action, which
|
||
|
// can be retrieved from the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage].
|
||
|
// See `stderr_raw` for when this will be set.
|
||
|
StderrDigest *Digest `protobuf:"bytes,8,opt,name=stderr_digest,json=stderrDigest,proto3" json:"stderr_digest,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *ActionResult) Reset() { *m = ActionResult{} }
|
||
|
func (m *ActionResult) String() string { return proto.CompactTextString(m) }
|
||
|
func (*ActionResult) ProtoMessage() {}
|
||
|
func (*ActionResult) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{7}
|
||
|
}
|
||
|
func (m *ActionResult) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_ActionResult.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *ActionResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_ActionResult.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *ActionResult) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_ActionResult.Merge(dst, src)
|
||
|
}
|
||
|
func (m *ActionResult) XXX_Size() int {
|
||
|
return xxx_messageInfo_ActionResult.Size(m)
|
||
|
}
|
||
|
func (m *ActionResult) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_ActionResult.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_ActionResult proto.InternalMessageInfo
|
||
|
|
||
|
func (m *ActionResult) GetOutputFiles() []*OutputFile {
|
||
|
if m != nil {
|
||
|
return m.OutputFiles
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ActionResult) GetOutputDirectories() []*OutputDirectory {
|
||
|
if m != nil {
|
||
|
return m.OutputDirectories
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ActionResult) GetExitCode() int32 {
|
||
|
if m != nil {
|
||
|
return m.ExitCode
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
|
||
|
func (m *ActionResult) GetStdoutRaw() []byte {
|
||
|
if m != nil {
|
||
|
return m.StdoutRaw
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ActionResult) GetStdoutDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.StdoutDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ActionResult) GetStderrRaw() []byte {
|
||
|
if m != nil {
|
||
|
return m.StderrRaw
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ActionResult) GetStderrDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.StderrDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// An `OutputFile` is similar to a
|
||
|
// [FileNode][google.devtools.remoteexecution.v1test.FileNode], but it is
|
||
|
// tailored for output as part of an `ActionResult`. It allows a full file path
|
||
|
// rather than only a name, and allows the server to include content inline.
|
||
|
//
|
||
|
// `OutputFile` is binary-compatible with `FileNode`.
|
||
|
type OutputFile struct {
|
||
|
// The full path of the file relative to the input root, including the
|
||
|
// filename. The path separator is a forward slash `/`. Since this is a
|
||
|
// relative path, it MUST NOT begin with a leading forward slash.
|
||
|
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
|
||
|
// The digest of the file's content.
|
||
|
Digest *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
|
||
|
// The raw content of the file.
|
||
|
//
|
||
|
// This field may be used by the server to provide the content of a file
|
||
|
// inline in an
|
||
|
// [ActionResult][google.devtools.remoteexecution.v1test.ActionResult] and
|
||
|
// avoid requiring that the client make a separate call to
|
||
|
// [ContentAddressableStorage.GetBlob] to retrieve it.
|
||
|
//
|
||
|
// The client SHOULD NOT assume that it will get raw content with any request,
|
||
|
// and always be prepared to retrieve it via `digest`.
|
||
|
Content []byte `protobuf:"bytes,3,opt,name=content,proto3" json:"content,omitempty"`
|
||
|
// True if file is executable, false otherwise.
|
||
|
IsExecutable bool `protobuf:"varint,4,opt,name=is_executable,json=isExecutable,proto3" json:"is_executable,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *OutputFile) Reset() { *m = OutputFile{} }
|
||
|
func (m *OutputFile) String() string { return proto.CompactTextString(m) }
|
||
|
func (*OutputFile) ProtoMessage() {}
|
||
|
func (*OutputFile) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{8}
|
||
|
}
|
||
|
func (m *OutputFile) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_OutputFile.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *OutputFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_OutputFile.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *OutputFile) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_OutputFile.Merge(dst, src)
|
||
|
}
|
||
|
func (m *OutputFile) XXX_Size() int {
|
||
|
return xxx_messageInfo_OutputFile.Size(m)
|
||
|
}
|
||
|
func (m *OutputFile) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_OutputFile.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_OutputFile proto.InternalMessageInfo
|
||
|
|
||
|
func (m *OutputFile) GetPath() string {
|
||
|
if m != nil {
|
||
|
return m.Path
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *OutputFile) GetDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.Digest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *OutputFile) GetContent() []byte {
|
||
|
if m != nil {
|
||
|
return m.Content
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *OutputFile) GetIsExecutable() bool {
|
||
|
if m != nil {
|
||
|
return m.IsExecutable
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// A `Tree` contains all the
|
||
|
// [Directory][google.devtools.remoteexecution.v1test.Directory] protos in a
|
||
|
// single directory Merkle tree, compressed into one message.
|
||
|
type Tree struct {
|
||
|
// The root directory in the tree.
|
||
|
Root *Directory `protobuf:"bytes,1,opt,name=root,proto3" json:"root,omitempty"`
|
||
|
// All the child directories: the directories referred to by the root and,
|
||
|
// recursively, all its children. In order to reconstruct the directory tree,
|
||
|
// the client must take the digests of each of the child directories and then
|
||
|
// build up a tree starting from the `root`.
|
||
|
Children []*Directory `protobuf:"bytes,2,rep,name=children,proto3" json:"children,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *Tree) Reset() { *m = Tree{} }
|
||
|
func (m *Tree) String() string { return proto.CompactTextString(m) }
|
||
|
func (*Tree) ProtoMessage() {}
|
||
|
func (*Tree) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{9}
|
||
|
}
|
||
|
func (m *Tree) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_Tree.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *Tree) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_Tree.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *Tree) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_Tree.Merge(dst, src)
|
||
|
}
|
||
|
func (m *Tree) XXX_Size() int {
|
||
|
return xxx_messageInfo_Tree.Size(m)
|
||
|
}
|
||
|
func (m *Tree) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_Tree.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_Tree proto.InternalMessageInfo
|
||
|
|
||
|
func (m *Tree) GetRoot() *Directory {
|
||
|
if m != nil {
|
||
|
return m.Root
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *Tree) GetChildren() []*Directory {
|
||
|
if m != nil {
|
||
|
return m.Children
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// An `OutputDirectory` is the output in an `ActionResult` corresponding to a
|
||
|
// directory's full contents rather than a single file.
|
||
|
type OutputDirectory struct {
|
||
|
// The full path of the directory relative to the working directory. The path
|
||
|
// separator is a forward slash `/`. Since this is a relative path, it MUST
|
||
|
// NOT begin with a leading forward slash. The empty string value is allowed,
|
||
|
// and it denotes the entire working directory.
|
||
|
Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
|
||
|
// DEPRECATED: This field is deprecated and should no longer be used.
|
||
|
Digest *Digest `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
|
||
|
// The digest of the encoded
|
||
|
// [Tree][google.devtools.remoteexecution.v1test.Tree] proto containing the
|
||
|
// directory's contents.
|
||
|
TreeDigest *Digest `protobuf:"bytes,3,opt,name=tree_digest,json=treeDigest,proto3" json:"tree_digest,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *OutputDirectory) Reset() { *m = OutputDirectory{} }
|
||
|
func (m *OutputDirectory) String() string { return proto.CompactTextString(m) }
|
||
|
func (*OutputDirectory) ProtoMessage() {}
|
||
|
func (*OutputDirectory) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{10}
|
||
|
}
|
||
|
func (m *OutputDirectory) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_OutputDirectory.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *OutputDirectory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_OutputDirectory.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *OutputDirectory) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_OutputDirectory.Merge(dst, src)
|
||
|
}
|
||
|
func (m *OutputDirectory) XXX_Size() int {
|
||
|
return xxx_messageInfo_OutputDirectory.Size(m)
|
||
|
}
|
||
|
func (m *OutputDirectory) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_OutputDirectory.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_OutputDirectory proto.InternalMessageInfo
|
||
|
|
||
|
func (m *OutputDirectory) GetPath() string {
|
||
|
if m != nil {
|
||
|
return m.Path
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *OutputDirectory) GetDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.Digest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *OutputDirectory) GetTreeDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.TreeDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A request message for
|
||
|
// [Execution.Execute][google.devtools.remoteexecution.v1test.Execution.Execute].
|
||
|
type ExecuteRequest struct {
|
||
|
// The instance of the execution system to operate against. A server may
|
||
|
// support multiple instances of the execution system (with their own workers,
|
||
|
// storage, caches, etc.). The server MAY require use of this field to select
|
||
|
// between them in an implementation-defined fashion, otherwise it can be
|
||
|
// omitted.
|
||
|
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
|
||
|
// The action to be performed.
|
||
|
Action *Action `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"`
|
||
|
// If true, the action will be executed anew even if its result was already
|
||
|
// present in the cache. If false, the result may be served from the
|
||
|
// [ActionCache][google.devtools.remoteexecution.v1test.ActionCache].
|
||
|
SkipCacheLookup bool `protobuf:"varint,3,opt,name=skip_cache_lookup,json=skipCacheLookup,proto3" json:"skip_cache_lookup,omitempty"`
|
||
|
// DEPRECATED: This field should be ignored by clients and servers and will be
|
||
|
// removed.
|
||
|
TotalInputFileCount int32 `protobuf:"varint,4,opt,name=total_input_file_count,json=totalInputFileCount,proto3" json:"total_input_file_count,omitempty"`
|
||
|
// DEPRECATED: This field should be ignored by clients and servers and will be
|
||
|
// removed.
|
||
|
TotalInputFileBytes int64 `protobuf:"varint,5,opt,name=total_input_file_bytes,json=totalInputFileBytes,proto3" json:"total_input_file_bytes,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteRequest) Reset() { *m = ExecuteRequest{} }
|
||
|
func (m *ExecuteRequest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*ExecuteRequest) ProtoMessage() {}
|
||
|
func (*ExecuteRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{11}
|
||
|
}
|
||
|
func (m *ExecuteRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_ExecuteRequest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *ExecuteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_ExecuteRequest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *ExecuteRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_ExecuteRequest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *ExecuteRequest) XXX_Size() int {
|
||
|
return xxx_messageInfo_ExecuteRequest.Size(m)
|
||
|
}
|
||
|
func (m *ExecuteRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_ExecuteRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_ExecuteRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *ExecuteRequest) GetInstanceName() string {
|
||
|
if m != nil {
|
||
|
return m.InstanceName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteRequest) GetAction() *Action {
|
||
|
if m != nil {
|
||
|
return m.Action
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteRequest) GetSkipCacheLookup() bool {
|
||
|
if m != nil {
|
||
|
return m.SkipCacheLookup
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteRequest) GetTotalInputFileCount() int32 {
|
||
|
if m != nil {
|
||
|
return m.TotalInputFileCount
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteRequest) GetTotalInputFileBytes() int64 {
|
||
|
if m != nil {
|
||
|
return m.TotalInputFileBytes
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
|
||
|
// A `LogFile` is a log stored in the CAS.
|
||
|
type LogFile struct {
|
||
|
// The digest of the log contents.
|
||
|
Digest *Digest `protobuf:"bytes,1,opt,name=digest,proto3" json:"digest,omitempty"`
|
||
|
// This is a hint as to the purpose of the log, and is set to true if the log
|
||
|
// is human-readable text that can be usefully displayed to a user, and false
|
||
|
// otherwise. For instance, if a command-line client wishes to print the
|
||
|
// server logs to the terminal for a failed action, this allows it to avoid
|
||
|
// displaying a binary file.
|
||
|
HumanReadable bool `protobuf:"varint,2,opt,name=human_readable,json=humanReadable,proto3" json:"human_readable,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *LogFile) Reset() { *m = LogFile{} }
|
||
|
func (m *LogFile) String() string { return proto.CompactTextString(m) }
|
||
|
func (*LogFile) ProtoMessage() {}
|
||
|
func (*LogFile) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{12}
|
||
|
}
|
||
|
func (m *LogFile) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_LogFile.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *LogFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_LogFile.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *LogFile) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_LogFile.Merge(dst, src)
|
||
|
}
|
||
|
func (m *LogFile) XXX_Size() int {
|
||
|
return xxx_messageInfo_LogFile.Size(m)
|
||
|
}
|
||
|
func (m *LogFile) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_LogFile.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_LogFile proto.InternalMessageInfo
|
||
|
|
||
|
func (m *LogFile) GetDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.Digest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *LogFile) GetHumanReadable() bool {
|
||
|
if m != nil {
|
||
|
return m.HumanReadable
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
// The response message for
|
||
|
// [Execution.Execute][google.devtools.remoteexecution.v1test.Execution.Execute],
|
||
|
// which will be contained in the [response
|
||
|
// field][google.longrunning.Operation.response] of the
|
||
|
// [Operation][google.longrunning.Operation].
|
||
|
type ExecuteResponse struct {
|
||
|
// The result of the action.
|
||
|
Result *ActionResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty"`
|
||
|
// True if the result was served from cache, false if it was executed.
|
||
|
CachedResult bool `protobuf:"varint,2,opt,name=cached_result,json=cachedResult,proto3" json:"cached_result,omitempty"`
|
||
|
// If the status has a code other than `OK`, it indicates that the action did
|
||
|
// not finish execution. For example, if the operation times out during
|
||
|
// execution, the status will have a `DEADLINE_EXCEEDED` code. Servers MUST
|
||
|
// use this field for errors in execution, rather than the error field on the
|
||
|
// `Operation` object.
|
||
|
//
|
||
|
// If the status code is other than `OK`, then the result MUST NOT be cached.
|
||
|
// For an error status, the `result` field is optional; the server may
|
||
|
// populate the output-, stdout-, and stderr-related fields if it has any
|
||
|
// information available, such as the stdout and stderr of a timed-out action.
|
||
|
Status *status.Status `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
|
||
|
// An optional list of additional log outputs the server wishes to provide. A
|
||
|
// server can use this to return execution-specific logs however it wishes.
|
||
|
// This is intended primarily to make it easier for users to debug issues that
|
||
|
// may be outside of the actual job execution, such as by identifying the
|
||
|
// worker executing the action or by providing logs from the worker's setup
|
||
|
// phase. The keys SHOULD be human readable so that a client can display them
|
||
|
// to a user.
|
||
|
ServerLogs map[string]*LogFile `protobuf:"bytes,4,rep,name=server_logs,json=serverLogs,proto3" json:"server_logs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteResponse) Reset() { *m = ExecuteResponse{} }
|
||
|
func (m *ExecuteResponse) String() string { return proto.CompactTextString(m) }
|
||
|
func (*ExecuteResponse) ProtoMessage() {}
|
||
|
func (*ExecuteResponse) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{13}
|
||
|
}
|
||
|
func (m *ExecuteResponse) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_ExecuteResponse.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *ExecuteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_ExecuteResponse.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *ExecuteResponse) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_ExecuteResponse.Merge(dst, src)
|
||
|
}
|
||
|
func (m *ExecuteResponse) XXX_Size() int {
|
||
|
return xxx_messageInfo_ExecuteResponse.Size(m)
|
||
|
}
|
||
|
func (m *ExecuteResponse) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_ExecuteResponse.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_ExecuteResponse proto.InternalMessageInfo
|
||
|
|
||
|
func (m *ExecuteResponse) GetResult() *ActionResult {
|
||
|
if m != nil {
|
||
|
return m.Result
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteResponse) GetCachedResult() bool {
|
||
|
if m != nil {
|
||
|
return m.CachedResult
|
||
|
}
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteResponse) GetStatus() *status.Status {
|
||
|
if m != nil {
|
||
|
return m.Status
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteResponse) GetServerLogs() map[string]*LogFile {
|
||
|
if m != nil {
|
||
|
return m.ServerLogs
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// Metadata about an ongoing
|
||
|
// [execution][google.devtools.remoteexecution.v1test.Execution.Execute], which
|
||
|
// will be contained in the [metadata
|
||
|
// field][google.longrunning.Operation.response] of the
|
||
|
// [Operation][google.longrunning.Operation].
|
||
|
type ExecuteOperationMetadata struct {
|
||
|
Stage ExecuteOperationMetadata_Stage `protobuf:"varint,1,opt,name=stage,proto3,enum=google.devtools.remoteexecution.v1test.ExecuteOperationMetadata_Stage" json:"stage,omitempty"`
|
||
|
// The digest of the [Action][google.devtools.remoteexecution.v1test.Action]
|
||
|
// being executed.
|
||
|
ActionDigest *Digest `protobuf:"bytes,2,opt,name=action_digest,json=actionDigest,proto3" json:"action_digest,omitempty"`
|
||
|
// If set, the client can use this name with
|
||
|
// [ByteStream.Read][google.bytestream.ByteStream.Read] to stream the
|
||
|
// standard output.
|
||
|
StdoutStreamName string `protobuf:"bytes,3,opt,name=stdout_stream_name,json=stdoutStreamName,proto3" json:"stdout_stream_name,omitempty"`
|
||
|
// If set, the client can use this name with
|
||
|
// [ByteStream.Read][google.bytestream.ByteStream.Read] to stream the
|
||
|
// standard error.
|
||
|
StderrStreamName string `protobuf:"bytes,4,opt,name=stderr_stream_name,json=stderrStreamName,proto3" json:"stderr_stream_name,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteOperationMetadata) Reset() { *m = ExecuteOperationMetadata{} }
|
||
|
func (m *ExecuteOperationMetadata) String() string { return proto.CompactTextString(m) }
|
||
|
func (*ExecuteOperationMetadata) ProtoMessage() {}
|
||
|
func (*ExecuteOperationMetadata) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{14}
|
||
|
}
|
||
|
func (m *ExecuteOperationMetadata) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_ExecuteOperationMetadata.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *ExecuteOperationMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_ExecuteOperationMetadata.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *ExecuteOperationMetadata) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_ExecuteOperationMetadata.Merge(dst, src)
|
||
|
}
|
||
|
func (m *ExecuteOperationMetadata) XXX_Size() int {
|
||
|
return xxx_messageInfo_ExecuteOperationMetadata.Size(m)
|
||
|
}
|
||
|
func (m *ExecuteOperationMetadata) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_ExecuteOperationMetadata.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_ExecuteOperationMetadata proto.InternalMessageInfo
|
||
|
|
||
|
func (m *ExecuteOperationMetadata) GetStage() ExecuteOperationMetadata_Stage {
|
||
|
if m != nil {
|
||
|
return m.Stage
|
||
|
}
|
||
|
return ExecuteOperationMetadata_UNKNOWN
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteOperationMetadata) GetActionDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.ActionDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteOperationMetadata) GetStdoutStreamName() string {
|
||
|
if m != nil {
|
||
|
return m.StdoutStreamName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ExecuteOperationMetadata) GetStderrStreamName() string {
|
||
|
if m != nil {
|
||
|
return m.StderrStreamName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
// A request message for
|
||
|
// [ActionCache.GetActionResult][google.devtools.remoteexecution.v1test.ActionCache.GetActionResult].
|
||
|
type GetActionResultRequest struct {
|
||
|
// The instance of the execution system to operate against. A server may
|
||
|
// support multiple instances of the execution system (with their own workers,
|
||
|
// storage, caches, etc.). The server MAY require use of this field to select
|
||
|
// between them in an implementation-defined fashion, otherwise it can be
|
||
|
// omitted.
|
||
|
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
|
||
|
// The digest of the [Action][google.devtools.remoteexecution.v1test.Action]
|
||
|
// whose result is requested.
|
||
|
ActionDigest *Digest `protobuf:"bytes,2,opt,name=action_digest,json=actionDigest,proto3" json:"action_digest,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *GetActionResultRequest) Reset() { *m = GetActionResultRequest{} }
|
||
|
func (m *GetActionResultRequest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*GetActionResultRequest) ProtoMessage() {}
|
||
|
func (*GetActionResultRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{15}
|
||
|
}
|
||
|
func (m *GetActionResultRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_GetActionResultRequest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *GetActionResultRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_GetActionResultRequest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *GetActionResultRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_GetActionResultRequest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *GetActionResultRequest) XXX_Size() int {
|
||
|
return xxx_messageInfo_GetActionResultRequest.Size(m)
|
||
|
}
|
||
|
func (m *GetActionResultRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_GetActionResultRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_GetActionResultRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *GetActionResultRequest) GetInstanceName() string {
|
||
|
if m != nil {
|
||
|
return m.InstanceName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *GetActionResultRequest) GetActionDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.ActionDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A request message for
|
||
|
// [ActionCache.UpdateActionResult][google.devtools.remoteexecution.v1test.ActionCache.UpdateActionResult].
|
||
|
type UpdateActionResultRequest struct {
|
||
|
// The instance of the execution system to operate against. A server may
|
||
|
// support multiple instances of the execution system (with their own workers,
|
||
|
// storage, caches, etc.). The server MAY require use of this field to select
|
||
|
// between them in an implementation-defined fashion, otherwise it can be
|
||
|
// omitted.
|
||
|
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
|
||
|
// The digest of the [Action][google.devtools.remoteexecution.v1test.Action]
|
||
|
// whose result is being uploaded.
|
||
|
ActionDigest *Digest `protobuf:"bytes,2,opt,name=action_digest,json=actionDigest,proto3" json:"action_digest,omitempty"`
|
||
|
// The [ActionResult][google.devtools.remoteexecution.v1test.ActionResult]
|
||
|
// to store in the cache.
|
||
|
ActionResult *ActionResult `protobuf:"bytes,3,opt,name=action_result,json=actionResult,proto3" json:"action_result,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *UpdateActionResultRequest) Reset() { *m = UpdateActionResultRequest{} }
|
||
|
func (m *UpdateActionResultRequest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*UpdateActionResultRequest) ProtoMessage() {}
|
||
|
func (*UpdateActionResultRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{16}
|
||
|
}
|
||
|
func (m *UpdateActionResultRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_UpdateActionResultRequest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *UpdateActionResultRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_UpdateActionResultRequest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *UpdateActionResultRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_UpdateActionResultRequest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *UpdateActionResultRequest) XXX_Size() int {
|
||
|
return xxx_messageInfo_UpdateActionResultRequest.Size(m)
|
||
|
}
|
||
|
func (m *UpdateActionResultRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_UpdateActionResultRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_UpdateActionResultRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *UpdateActionResultRequest) GetInstanceName() string {
|
||
|
if m != nil {
|
||
|
return m.InstanceName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *UpdateActionResultRequest) GetActionDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.ActionDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *UpdateActionResultRequest) GetActionResult() *ActionResult {
|
||
|
if m != nil {
|
||
|
return m.ActionResult
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A request message for
|
||
|
// [ContentAddressableStorage.FindMissingBlobs][google.devtools.remoteexecution.v1test.ContentAddressableStorage.FindMissingBlobs].
|
||
|
type FindMissingBlobsRequest struct {
|
||
|
// The instance of the execution system to operate against. A server may
|
||
|
// support multiple instances of the execution system (with their own workers,
|
||
|
// storage, caches, etc.). The server MAY require use of this field to select
|
||
|
// between them in an implementation-defined fashion, otherwise it can be
|
||
|
// omitted.
|
||
|
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
|
||
|
// A list of the blobs to check.
|
||
|
BlobDigests []*Digest `protobuf:"bytes,2,rep,name=blob_digests,json=blobDigests,proto3" json:"blob_digests,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *FindMissingBlobsRequest) Reset() { *m = FindMissingBlobsRequest{} }
|
||
|
func (m *FindMissingBlobsRequest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*FindMissingBlobsRequest) ProtoMessage() {}
|
||
|
func (*FindMissingBlobsRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{17}
|
||
|
}
|
||
|
func (m *FindMissingBlobsRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_FindMissingBlobsRequest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *FindMissingBlobsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_FindMissingBlobsRequest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *FindMissingBlobsRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_FindMissingBlobsRequest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *FindMissingBlobsRequest) XXX_Size() int {
|
||
|
return xxx_messageInfo_FindMissingBlobsRequest.Size(m)
|
||
|
}
|
||
|
func (m *FindMissingBlobsRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_FindMissingBlobsRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_FindMissingBlobsRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *FindMissingBlobsRequest) GetInstanceName() string {
|
||
|
if m != nil {
|
||
|
return m.InstanceName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *FindMissingBlobsRequest) GetBlobDigests() []*Digest {
|
||
|
if m != nil {
|
||
|
return m.BlobDigests
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A response message for
|
||
|
// [ContentAddressableStorage.FindMissingBlobs][google.devtools.remoteexecution.v1test.ContentAddressableStorage.FindMissingBlobs].
|
||
|
type FindMissingBlobsResponse struct {
|
||
|
// A list of the blobs requested *not* present in the storage.
|
||
|
MissingBlobDigests []*Digest `protobuf:"bytes,2,rep,name=missing_blob_digests,json=missingBlobDigests,proto3" json:"missing_blob_digests,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *FindMissingBlobsResponse) Reset() { *m = FindMissingBlobsResponse{} }
|
||
|
func (m *FindMissingBlobsResponse) String() string { return proto.CompactTextString(m) }
|
||
|
func (*FindMissingBlobsResponse) ProtoMessage() {}
|
||
|
func (*FindMissingBlobsResponse) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{18}
|
||
|
}
|
||
|
func (m *FindMissingBlobsResponse) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_FindMissingBlobsResponse.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *FindMissingBlobsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_FindMissingBlobsResponse.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *FindMissingBlobsResponse) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_FindMissingBlobsResponse.Merge(dst, src)
|
||
|
}
|
||
|
func (m *FindMissingBlobsResponse) XXX_Size() int {
|
||
|
return xxx_messageInfo_FindMissingBlobsResponse.Size(m)
|
||
|
}
|
||
|
func (m *FindMissingBlobsResponse) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_FindMissingBlobsResponse.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_FindMissingBlobsResponse proto.InternalMessageInfo
|
||
|
|
||
|
func (m *FindMissingBlobsResponse) GetMissingBlobDigests() []*Digest {
|
||
|
if m != nil {
|
||
|
return m.MissingBlobDigests
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A single request message for
|
||
|
// [ContentAddressableStorage.BatchUpdateBlobs][google.devtools.remoteexecution.v1test.ContentAddressableStorage.BatchUpdateBlobs].
|
||
|
type UpdateBlobRequest struct {
|
||
|
// The digest of the blob. This MUST be the digest of `data`.
|
||
|
ContentDigest *Digest `protobuf:"bytes,1,opt,name=content_digest,json=contentDigest,proto3" json:"content_digest,omitempty"`
|
||
|
// The raw binary data.
|
||
|
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *UpdateBlobRequest) Reset() { *m = UpdateBlobRequest{} }
|
||
|
func (m *UpdateBlobRequest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*UpdateBlobRequest) ProtoMessage() {}
|
||
|
func (*UpdateBlobRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{19}
|
||
|
}
|
||
|
func (m *UpdateBlobRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_UpdateBlobRequest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *UpdateBlobRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_UpdateBlobRequest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *UpdateBlobRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_UpdateBlobRequest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *UpdateBlobRequest) XXX_Size() int {
|
||
|
return xxx_messageInfo_UpdateBlobRequest.Size(m)
|
||
|
}
|
||
|
func (m *UpdateBlobRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_UpdateBlobRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_UpdateBlobRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *UpdateBlobRequest) GetContentDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.ContentDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *UpdateBlobRequest) GetData() []byte {
|
||
|
if m != nil {
|
||
|
return m.Data
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A request message for
|
||
|
// [ContentAddressableStorage.BatchUpdateBlobs][google.devtools.remoteexecution.v1test.ContentAddressableStorage.BatchUpdateBlobs].
|
||
|
type BatchUpdateBlobsRequest struct {
|
||
|
// The instance of the execution system to operate against. A server may
|
||
|
// support multiple instances of the execution system (with their own workers,
|
||
|
// storage, caches, etc.). The server MAY require use of this field to select
|
||
|
// between them in an implementation-defined fashion, otherwise it can be
|
||
|
// omitted.
|
||
|
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
|
||
|
// The individual upload requests.
|
||
|
Requests []*UpdateBlobRequest `protobuf:"bytes,2,rep,name=requests,proto3" json:"requests,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *BatchUpdateBlobsRequest) Reset() { *m = BatchUpdateBlobsRequest{} }
|
||
|
func (m *BatchUpdateBlobsRequest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*BatchUpdateBlobsRequest) ProtoMessage() {}
|
||
|
func (*BatchUpdateBlobsRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{20}
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsRequest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsRequest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *BatchUpdateBlobsRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_BatchUpdateBlobsRequest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsRequest) XXX_Size() int {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsRequest.Size(m)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_BatchUpdateBlobsRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_BatchUpdateBlobsRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *BatchUpdateBlobsRequest) GetInstanceName() string {
|
||
|
if m != nil {
|
||
|
return m.InstanceName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *BatchUpdateBlobsRequest) GetRequests() []*UpdateBlobRequest {
|
||
|
if m != nil {
|
||
|
return m.Requests
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A response message for
|
||
|
// [ContentAddressableStorage.BatchUpdateBlobs][google.devtools.remoteexecution.v1test.ContentAddressableStorage.BatchUpdateBlobs].
|
||
|
type BatchUpdateBlobsResponse struct {
|
||
|
// The responses to the requests.
|
||
|
Responses []*BatchUpdateBlobsResponse_Response `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *BatchUpdateBlobsResponse) Reset() { *m = BatchUpdateBlobsResponse{} }
|
||
|
func (m *BatchUpdateBlobsResponse) String() string { return proto.CompactTextString(m) }
|
||
|
func (*BatchUpdateBlobsResponse) ProtoMessage() {}
|
||
|
func (*BatchUpdateBlobsResponse) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{21}
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsResponse.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsResponse.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *BatchUpdateBlobsResponse) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_BatchUpdateBlobsResponse.Merge(dst, src)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse) XXX_Size() int {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsResponse.Size(m)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_BatchUpdateBlobsResponse.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_BatchUpdateBlobsResponse proto.InternalMessageInfo
|
||
|
|
||
|
func (m *BatchUpdateBlobsResponse) GetResponses() []*BatchUpdateBlobsResponse_Response {
|
||
|
if m != nil {
|
||
|
return m.Responses
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A response corresponding to a single blob that the client tried to upload.
|
||
|
type BatchUpdateBlobsResponse_Response struct {
|
||
|
// The digest to which this response corresponds.
|
||
|
BlobDigest *Digest `protobuf:"bytes,1,opt,name=blob_digest,json=blobDigest,proto3" json:"blob_digest,omitempty"`
|
||
|
// The result of attempting to upload that blob.
|
||
|
Status *status.Status `protobuf:"bytes,2,opt,name=status,proto3" json:"status,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *BatchUpdateBlobsResponse_Response) Reset() { *m = BatchUpdateBlobsResponse_Response{} }
|
||
|
func (m *BatchUpdateBlobsResponse_Response) String() string { return proto.CompactTextString(m) }
|
||
|
func (*BatchUpdateBlobsResponse_Response) ProtoMessage() {}
|
||
|
func (*BatchUpdateBlobsResponse_Response) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{21, 0}
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse_Response) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsResponse_Response.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsResponse_Response.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *BatchUpdateBlobsResponse_Response) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_BatchUpdateBlobsResponse_Response.Merge(dst, src)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse_Response) XXX_Size() int {
|
||
|
return xxx_messageInfo_BatchUpdateBlobsResponse_Response.Size(m)
|
||
|
}
|
||
|
func (m *BatchUpdateBlobsResponse_Response) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_BatchUpdateBlobsResponse_Response.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_BatchUpdateBlobsResponse_Response proto.InternalMessageInfo
|
||
|
|
||
|
func (m *BatchUpdateBlobsResponse_Response) GetBlobDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.BlobDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *BatchUpdateBlobsResponse_Response) GetStatus() *status.Status {
|
||
|
if m != nil {
|
||
|
return m.Status
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// A request message for
|
||
|
// [ContentAddressableStorage.GetTree][google.devtools.remoteexecution.v1test.ContentAddressableStorage.GetTree].
|
||
|
type GetTreeRequest struct {
|
||
|
// The instance of the execution system to operate against. A server may
|
||
|
// support multiple instances of the execution system (with their own workers,
|
||
|
// storage, caches, etc.). The server MAY require use of this field to select
|
||
|
// between them in an implementation-defined fashion, otherwise it can be
|
||
|
// omitted.
|
||
|
InstanceName string `protobuf:"bytes,1,opt,name=instance_name,json=instanceName,proto3" json:"instance_name,omitempty"`
|
||
|
// The digest of the root, which must be an encoded
|
||
|
// [Directory][google.devtools.remoteexecution.v1test.Directory] message
|
||
|
// stored in the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage].
|
||
|
RootDigest *Digest `protobuf:"bytes,2,opt,name=root_digest,json=rootDigest,proto3" json:"root_digest,omitempty"`
|
||
|
// A maximum page size to request. If present, the server will request no more
|
||
|
// than this many items. Regardless of whether a page size is specified, the
|
||
|
// server may place its own limit on the number of items to be returned and
|
||
|
// require the client to retrieve more items using a subsequent request.
|
||
|
PageSize int32 `protobuf:"varint,3,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"`
|
||
|
// A page token, which must be a value received in a previous
|
||
|
// [GetTreeResponse][google.devtools.remoteexecution.v1test.GetTreeResponse].
|
||
|
// If present, the server will use it to return the following page of results.
|
||
|
PageToken string `protobuf:"bytes,4,opt,name=page_token,json=pageToken,proto3" json:"page_token,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *GetTreeRequest) Reset() { *m = GetTreeRequest{} }
|
||
|
func (m *GetTreeRequest) String() string { return proto.CompactTextString(m) }
|
||
|
func (*GetTreeRequest) ProtoMessage() {}
|
||
|
func (*GetTreeRequest) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{22}
|
||
|
}
|
||
|
func (m *GetTreeRequest) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_GetTreeRequest.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *GetTreeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_GetTreeRequest.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *GetTreeRequest) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_GetTreeRequest.Merge(dst, src)
|
||
|
}
|
||
|
func (m *GetTreeRequest) XXX_Size() int {
|
||
|
return xxx_messageInfo_GetTreeRequest.Size(m)
|
||
|
}
|
||
|
func (m *GetTreeRequest) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_GetTreeRequest.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_GetTreeRequest proto.InternalMessageInfo
|
||
|
|
||
|
func (m *GetTreeRequest) GetInstanceName() string {
|
||
|
if m != nil {
|
||
|
return m.InstanceName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *GetTreeRequest) GetRootDigest() *Digest {
|
||
|
if m != nil {
|
||
|
return m.RootDigest
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *GetTreeRequest) GetPageSize() int32 {
|
||
|
if m != nil {
|
||
|
return m.PageSize
|
||
|
}
|
||
|
return 0
|
||
|
}
|
||
|
|
||
|
func (m *GetTreeRequest) GetPageToken() string {
|
||
|
if m != nil {
|
||
|
return m.PageToken
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
// A response message for
|
||
|
// [ContentAddressableStorage.GetTree][google.devtools.remoteexecution.v1test.ContentAddressableStorage.GetTree].
|
||
|
type GetTreeResponse struct {
|
||
|
// The directories descended from the requested root.
|
||
|
Directories []*Directory `protobuf:"bytes,1,rep,name=directories,proto3" json:"directories,omitempty"`
|
||
|
// If present, signifies that there are more results which the client can
|
||
|
// retrieve by passing this as the page_token in a subsequent
|
||
|
// [request][google.devtools.remoteexecution.v1test.GetTreeRequest].
|
||
|
// If empty, signifies that this is the last page of results.
|
||
|
NextPageToken string `protobuf:"bytes,2,opt,name=next_page_token,json=nextPageToken,proto3" json:"next_page_token,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *GetTreeResponse) Reset() { *m = GetTreeResponse{} }
|
||
|
func (m *GetTreeResponse) String() string { return proto.CompactTextString(m) }
|
||
|
func (*GetTreeResponse) ProtoMessage() {}
|
||
|
func (*GetTreeResponse) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{23}
|
||
|
}
|
||
|
func (m *GetTreeResponse) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_GetTreeResponse.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *GetTreeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_GetTreeResponse.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *GetTreeResponse) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_GetTreeResponse.Merge(dst, src)
|
||
|
}
|
||
|
func (m *GetTreeResponse) XXX_Size() int {
|
||
|
return xxx_messageInfo_GetTreeResponse.Size(m)
|
||
|
}
|
||
|
func (m *GetTreeResponse) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_GetTreeResponse.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_GetTreeResponse proto.InternalMessageInfo
|
||
|
|
||
|
func (m *GetTreeResponse) GetDirectories() []*Directory {
|
||
|
if m != nil {
|
||
|
return m.Directories
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *GetTreeResponse) GetNextPageToken() string {
|
||
|
if m != nil {
|
||
|
return m.NextPageToken
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
// Details for the tool used to call the API.
|
||
|
type ToolDetails struct {
|
||
|
// Name of the tool, e.g. bazel.
|
||
|
ToolName string `protobuf:"bytes,1,opt,name=tool_name,json=toolName,proto3" json:"tool_name,omitempty"`
|
||
|
// Version of the tool used for the request, e.g. 5.0.3.
|
||
|
ToolVersion string `protobuf:"bytes,2,opt,name=tool_version,json=toolVersion,proto3" json:"tool_version,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *ToolDetails) Reset() { *m = ToolDetails{} }
|
||
|
func (m *ToolDetails) String() string { return proto.CompactTextString(m) }
|
||
|
func (*ToolDetails) ProtoMessage() {}
|
||
|
func (*ToolDetails) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{24}
|
||
|
}
|
||
|
func (m *ToolDetails) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_ToolDetails.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *ToolDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_ToolDetails.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *ToolDetails) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_ToolDetails.Merge(dst, src)
|
||
|
}
|
||
|
func (m *ToolDetails) XXX_Size() int {
|
||
|
return xxx_messageInfo_ToolDetails.Size(m)
|
||
|
}
|
||
|
func (m *ToolDetails) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_ToolDetails.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_ToolDetails proto.InternalMessageInfo
|
||
|
|
||
|
func (m *ToolDetails) GetToolName() string {
|
||
|
if m != nil {
|
||
|
return m.ToolName
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *ToolDetails) GetToolVersion() string {
|
||
|
if m != nil {
|
||
|
return m.ToolVersion
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
// An optional Metadata to attach to any RPC request to tell the server about an
|
||
|
// external context of the request. The server may use this for logging or other
|
||
|
// purposes. To use it, the client attaches the header to the call using the
|
||
|
// canonical proto serialization:
|
||
|
// name: google.devtools.remoteexecution.v1test.requestmetadata-bin
|
||
|
// contents: the base64 encoded binary RequestMetadata message.
|
||
|
type RequestMetadata struct {
|
||
|
// The details for the tool invoking the requests.
|
||
|
ToolDetails *ToolDetails `protobuf:"bytes,1,opt,name=tool_details,json=toolDetails,proto3" json:"tool_details,omitempty"`
|
||
|
// An identifier that ties multiple requests to the same action.
|
||
|
// For example, multiple requests to the CAS, Action Cache, and Execution
|
||
|
// API are used in order to compile foo.cc.
|
||
|
ActionId string `protobuf:"bytes,2,opt,name=action_id,json=actionId,proto3" json:"action_id,omitempty"`
|
||
|
// An identifier that ties multiple actions together to a final result.
|
||
|
// For example, multiple actions are required to build and run foo_test.
|
||
|
ToolInvocationId string `protobuf:"bytes,3,opt,name=tool_invocation_id,json=toolInvocationId,proto3" json:"tool_invocation_id,omitempty"`
|
||
|
// An identifier to tie multiple tool invocations together. For example,
|
||
|
// runs of foo_test, bar_test and baz_test on a post-submit of a given patch.
|
||
|
CorrelatedInvocationsId string `protobuf:"bytes,4,opt,name=correlated_invocations_id,json=correlatedInvocationsId,proto3" json:"correlated_invocations_id,omitempty"`
|
||
|
XXX_NoUnkeyedLiteral struct{} `json:"-"`
|
||
|
XXX_unrecognized []byte `json:"-"`
|
||
|
XXX_sizecache int32 `json:"-"`
|
||
|
}
|
||
|
|
||
|
func (m *RequestMetadata) Reset() { *m = RequestMetadata{} }
|
||
|
func (m *RequestMetadata) String() string { return proto.CompactTextString(m) }
|
||
|
func (*RequestMetadata) ProtoMessage() {}
|
||
|
func (*RequestMetadata) Descriptor() ([]byte, []int) {
|
||
|
return fileDescriptor_remote_execution_25e31fef95c58b43, []int{25}
|
||
|
}
|
||
|
func (m *RequestMetadata) XXX_Unmarshal(b []byte) error {
|
||
|
return xxx_messageInfo_RequestMetadata.Unmarshal(m, b)
|
||
|
}
|
||
|
func (m *RequestMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||
|
return xxx_messageInfo_RequestMetadata.Marshal(b, m, deterministic)
|
||
|
}
|
||
|
func (dst *RequestMetadata) XXX_Merge(src proto.Message) {
|
||
|
xxx_messageInfo_RequestMetadata.Merge(dst, src)
|
||
|
}
|
||
|
func (m *RequestMetadata) XXX_Size() int {
|
||
|
return xxx_messageInfo_RequestMetadata.Size(m)
|
||
|
}
|
||
|
func (m *RequestMetadata) XXX_DiscardUnknown() {
|
||
|
xxx_messageInfo_RequestMetadata.DiscardUnknown(m)
|
||
|
}
|
||
|
|
||
|
var xxx_messageInfo_RequestMetadata proto.InternalMessageInfo
|
||
|
|
||
|
func (m *RequestMetadata) GetToolDetails() *ToolDetails {
|
||
|
if m != nil {
|
||
|
return m.ToolDetails
|
||
|
}
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
func (m *RequestMetadata) GetActionId() string {
|
||
|
if m != nil {
|
||
|
return m.ActionId
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *RequestMetadata) GetToolInvocationId() string {
|
||
|
if m != nil {
|
||
|
return m.ToolInvocationId
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func (m *RequestMetadata) GetCorrelatedInvocationsId() string {
|
||
|
if m != nil {
|
||
|
return m.CorrelatedInvocationsId
|
||
|
}
|
||
|
return ""
|
||
|
}
|
||
|
|
||
|
func init() {
|
||
|
proto.RegisterType((*Action)(nil), "google.devtools.remoteexecution.v1test.Action")
|
||
|
proto.RegisterType((*Command)(nil), "google.devtools.remoteexecution.v1test.Command")
|
||
|
proto.RegisterType((*Command_EnvironmentVariable)(nil), "google.devtools.remoteexecution.v1test.Command.EnvironmentVariable")
|
||
|
proto.RegisterType((*Platform)(nil), "google.devtools.remoteexecution.v1test.Platform")
|
||
|
proto.RegisterType((*Platform_Property)(nil), "google.devtools.remoteexecution.v1test.Platform.Property")
|
||
|
proto.RegisterType((*Directory)(nil), "google.devtools.remoteexecution.v1test.Directory")
|
||
|
proto.RegisterType((*FileNode)(nil), "google.devtools.remoteexecution.v1test.FileNode")
|
||
|
proto.RegisterType((*DirectoryNode)(nil), "google.devtools.remoteexecution.v1test.DirectoryNode")
|
||
|
proto.RegisterType((*Digest)(nil), "google.devtools.remoteexecution.v1test.Digest")
|
||
|
proto.RegisterType((*ActionResult)(nil), "google.devtools.remoteexecution.v1test.ActionResult")
|
||
|
proto.RegisterType((*OutputFile)(nil), "google.devtools.remoteexecution.v1test.OutputFile")
|
||
|
proto.RegisterType((*Tree)(nil), "google.devtools.remoteexecution.v1test.Tree")
|
||
|
proto.RegisterType((*OutputDirectory)(nil), "google.devtools.remoteexecution.v1test.OutputDirectory")
|
||
|
proto.RegisterType((*ExecuteRequest)(nil), "google.devtools.remoteexecution.v1test.ExecuteRequest")
|
||
|
proto.RegisterType((*LogFile)(nil), "google.devtools.remoteexecution.v1test.LogFile")
|
||
|
proto.RegisterType((*ExecuteResponse)(nil), "google.devtools.remoteexecution.v1test.ExecuteResponse")
|
||
|
proto.RegisterMapType((map[string]*LogFile)(nil), "google.devtools.remoteexecution.v1test.ExecuteResponse.ServerLogsEntry")
|
||
|
proto.RegisterType((*ExecuteOperationMetadata)(nil), "google.devtools.remoteexecution.v1test.ExecuteOperationMetadata")
|
||
|
proto.RegisterType((*GetActionResultRequest)(nil), "google.devtools.remoteexecution.v1test.GetActionResultRequest")
|
||
|
proto.RegisterType((*UpdateActionResultRequest)(nil), "google.devtools.remoteexecution.v1test.UpdateActionResultRequest")
|
||
|
proto.RegisterType((*FindMissingBlobsRequest)(nil), "google.devtools.remoteexecution.v1test.FindMissingBlobsRequest")
|
||
|
proto.RegisterType((*FindMissingBlobsResponse)(nil), "google.devtools.remoteexecution.v1test.FindMissingBlobsResponse")
|
||
|
proto.RegisterType((*UpdateBlobRequest)(nil), "google.devtools.remoteexecution.v1test.UpdateBlobRequest")
|
||
|
proto.RegisterType((*BatchUpdateBlobsRequest)(nil), "google.devtools.remoteexecution.v1test.BatchUpdateBlobsRequest")
|
||
|
proto.RegisterType((*BatchUpdateBlobsResponse)(nil), "google.devtools.remoteexecution.v1test.BatchUpdateBlobsResponse")
|
||
|
proto.RegisterType((*BatchUpdateBlobsResponse_Response)(nil), "google.devtools.remoteexecution.v1test.BatchUpdateBlobsResponse.Response")
|
||
|
proto.RegisterType((*GetTreeRequest)(nil), "google.devtools.remoteexecution.v1test.GetTreeRequest")
|
||
|
proto.RegisterType((*GetTreeResponse)(nil), "google.devtools.remoteexecution.v1test.GetTreeResponse")
|
||
|
proto.RegisterType((*ToolDetails)(nil), "google.devtools.remoteexecution.v1test.ToolDetails")
|
||
|
proto.RegisterType((*RequestMetadata)(nil), "google.devtools.remoteexecution.v1test.RequestMetadata")
|
||
|
proto.RegisterEnum("google.devtools.remoteexecution.v1test.ExecuteOperationMetadata_Stage", ExecuteOperationMetadata_Stage_name, ExecuteOperationMetadata_Stage_value)
|
||
|
}
|
||
|
|
||
|
// Reference imports to suppress errors if they are not otherwise used.
|
||
|
var _ context.Context
|
||
|
var _ grpc.ClientConn
|
||
|
|
||
|
// This is a compile-time assertion to ensure that this generated file
|
||
|
// is compatible with the grpc package it is being compiled against.
|
||
|
const _ = grpc.SupportPackageIsVersion4
|
||
|
|
||
|
// ExecutionClient is the client API for Execution service.
|
||
|
//
|
||
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
||
|
type ExecutionClient interface {
|
||
|
// Execute an action remotely.
|
||
|
//
|
||
|
// In order to execute an action, the client must first upload all of the
|
||
|
// inputs, as well as the
|
||
|
// [Command][google.devtools.remoteexecution.v1test.Command] to run, into the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage].
|
||
|
// It then calls `Execute` with an
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action] referring to them.
|
||
|
// The server will run the action and eventually return the result.
|
||
|
//
|
||
|
// The input `Action`'s fields MUST meet the various canonicalization
|
||
|
// requirements specified in the documentation for their types so that it has
|
||
|
// the same digest as other logically equivalent `Action`s. The server MAY
|
||
|
// enforce the requirements and return errors if a non-canonical input is
|
||
|
// received. It MAY also proceed without verifying some or all of the
|
||
|
// requirements, such as for performance reasons. If the server does not
|
||
|
// verify the requirement, then it will treat the `Action` as distinct from
|
||
|
// another logically equivalent action if they hash differently.
|
||
|
//
|
||
|
// Returns a [google.longrunning.Operation][google.longrunning.Operation]
|
||
|
// describing the resulting execution, with eventual `response`
|
||
|
// [ExecuteResponse][google.devtools.remoteexecution.v1test.ExecuteResponse].
|
||
|
// The `metadata` on the operation is of type
|
||
|
// [ExecuteOperationMetadata][google.devtools.remoteexecution.v1test.ExecuteOperationMetadata].
|
||
|
//
|
||
|
// To query the operation, you can use the
|
||
|
// [Operations API][google.longrunning.Operations.GetOperation]. If you wish
|
||
|
// to allow the server to stream operations updates, rather than requiring
|
||
|
// client polling, you can use the
|
||
|
// [Watcher API][google.watcher.v1.Watcher.Watch] with the Operation's `name`
|
||
|
// as the `target`.
|
||
|
//
|
||
|
// When using the Watcher API, the initial `data` will be the `Operation` at
|
||
|
// the time of the request. Updates will be provided periodically by the
|
||
|
// server until the `Operation` completes, at which point the response message
|
||
|
// will (assuming no error) be at `data.response`.
|
||
|
//
|
||
|
// The server NEED NOT implement other methods or functionality of the
|
||
|
// Operation and Watcher APIs.
|
||
|
//
|
||
|
// Errors discovered during creation of the `Operation` will be reported
|
||
|
// as gRPC Status errors, while errors that occurred while running the
|
||
|
// action will be reported in the `status` field of the `ExecuteResponse`. The
|
||
|
// server MUST NOT set the `error` field of the `Operation` proto.
|
||
|
// The possible errors include:
|
||
|
// * `INVALID_ARGUMENT`: One or more arguments are invalid.
|
||
|
// * `FAILED_PRECONDITION`: One or more errors occurred in setting up the
|
||
|
// action requested, such as a missing input or command or no worker being
|
||
|
// available. The client may be able to fix the errors and retry.
|
||
|
// * `RESOURCE_EXHAUSTED`: There is insufficient quota of some resource to run
|
||
|
// the action.
|
||
|
// * `UNAVAILABLE`: Due to a transient condition, such as all workers being
|
||
|
// occupied (and the server does not support a queue), the action could not
|
||
|
// be started. The client should retry.
|
||
|
// * `INTERNAL`: An internal error occurred in the execution engine or the
|
||
|
// worker.
|
||
|
// * `DEADLINE_EXCEEDED`: The execution timed out.
|
||
|
//
|
||
|
// In the case of a missing input or command, the server SHOULD additionally
|
||
|
// send a [PreconditionFailure][google.rpc.PreconditionFailure] error detail
|
||
|
// where, for each requested blob not present in the CAS, there is a
|
||
|
// `Violation` with a `type` of `MISSING` and a `subject` of
|
||
|
// `"blobs/{hash}/{size}"` indicating the digest of the missing blob.
|
||
|
Execute(ctx context.Context, in *ExecuteRequest, opts ...grpc.CallOption) (*longrunning.Operation, error)
|
||
|
}
|
||
|
|
||
|
type executionClient struct {
|
||
|
cc *grpc.ClientConn
|
||
|
}
|
||
|
|
||
|
func NewExecutionClient(cc *grpc.ClientConn) ExecutionClient {
|
||
|
return &executionClient{cc}
|
||
|
}
|
||
|
|
||
|
func (c *executionClient) Execute(ctx context.Context, in *ExecuteRequest, opts ...grpc.CallOption) (*longrunning.Operation, error) {
|
||
|
out := new(longrunning.Operation)
|
||
|
err := c.cc.Invoke(ctx, "/google.devtools.remoteexecution.v1test.Execution/Execute", in, out, opts...)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return out, nil
|
||
|
}
|
||
|
|
||
|
// ExecutionServer is the server API for Execution service.
|
||
|
type ExecutionServer interface {
|
||
|
// Execute an action remotely.
|
||
|
//
|
||
|
// In order to execute an action, the client must first upload all of the
|
||
|
// inputs, as well as the
|
||
|
// [Command][google.devtools.remoteexecution.v1test.Command] to run, into the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage].
|
||
|
// It then calls `Execute` with an
|
||
|
// [Action][google.devtools.remoteexecution.v1test.Action] referring to them.
|
||
|
// The server will run the action and eventually return the result.
|
||
|
//
|
||
|
// The input `Action`'s fields MUST meet the various canonicalization
|
||
|
// requirements specified in the documentation for their types so that it has
|
||
|
// the same digest as other logically equivalent `Action`s. The server MAY
|
||
|
// enforce the requirements and return errors if a non-canonical input is
|
||
|
// received. It MAY also proceed without verifying some or all of the
|
||
|
// requirements, such as for performance reasons. If the server does not
|
||
|
// verify the requirement, then it will treat the `Action` as distinct from
|
||
|
// another logically equivalent action if they hash differently.
|
||
|
//
|
||
|
// Returns a [google.longrunning.Operation][google.longrunning.Operation]
|
||
|
// describing the resulting execution, with eventual `response`
|
||
|
// [ExecuteResponse][google.devtools.remoteexecution.v1test.ExecuteResponse].
|
||
|
// The `metadata` on the operation is of type
|
||
|
// [ExecuteOperationMetadata][google.devtools.remoteexecution.v1test.ExecuteOperationMetadata].
|
||
|
//
|
||
|
// To query the operation, you can use the
|
||
|
// [Operations API][google.longrunning.Operations.GetOperation]. If you wish
|
||
|
// to allow the server to stream operations updates, rather than requiring
|
||
|
// client polling, you can use the
|
||
|
// [Watcher API][google.watcher.v1.Watcher.Watch] with the Operation's `name`
|
||
|
// as the `target`.
|
||
|
//
|
||
|
// When using the Watcher API, the initial `data` will be the `Operation` at
|
||
|
// the time of the request. Updates will be provided periodically by the
|
||
|
// server until the `Operation` completes, at which point the response message
|
||
|
// will (assuming no error) be at `data.response`.
|
||
|
//
|
||
|
// The server NEED NOT implement other methods or functionality of the
|
||
|
// Operation and Watcher APIs.
|
||
|
//
|
||
|
// Errors discovered during creation of the `Operation` will be reported
|
||
|
// as gRPC Status errors, while errors that occurred while running the
|
||
|
// action will be reported in the `status` field of the `ExecuteResponse`. The
|
||
|
// server MUST NOT set the `error` field of the `Operation` proto.
|
||
|
// The possible errors include:
|
||
|
// * `INVALID_ARGUMENT`: One or more arguments are invalid.
|
||
|
// * `FAILED_PRECONDITION`: One or more errors occurred in setting up the
|
||
|
// action requested, such as a missing input or command or no worker being
|
||
|
// available. The client may be able to fix the errors and retry.
|
||
|
// * `RESOURCE_EXHAUSTED`: There is insufficient quota of some resource to run
|
||
|
// the action.
|
||
|
// * `UNAVAILABLE`: Due to a transient condition, such as all workers being
|
||
|
// occupied (and the server does not support a queue), the action could not
|
||
|
// be started. The client should retry.
|
||
|
// * `INTERNAL`: An internal error occurred in the execution engine or the
|
||
|
// worker.
|
||
|
// * `DEADLINE_EXCEEDED`: The execution timed out.
|
||
|
//
|
||
|
// In the case of a missing input or command, the server SHOULD additionally
|
||
|
// send a [PreconditionFailure][google.rpc.PreconditionFailure] error detail
|
||
|
// where, for each requested blob not present in the CAS, there is a
|
||
|
// `Violation` with a `type` of `MISSING` and a `subject` of
|
||
|
// `"blobs/{hash}/{size}"` indicating the digest of the missing blob.
|
||
|
Execute(context.Context, *ExecuteRequest) (*longrunning.Operation, error)
|
||
|
}
|
||
|
|
||
|
func RegisterExecutionServer(s *grpc.Server, srv ExecutionServer) {
|
||
|
s.RegisterService(&_Execution_serviceDesc, srv)
|
||
|
}
|
||
|
|
||
|
func _Execution_Execute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
|
in := new(ExecuteRequest)
|
||
|
if err := dec(in); err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
if interceptor == nil {
|
||
|
return srv.(ExecutionServer).Execute(ctx, in)
|
||
|
}
|
||
|
info := &grpc.UnaryServerInfo{
|
||
|
Server: srv,
|
||
|
FullMethod: "/google.devtools.remoteexecution.v1test.Execution/Execute",
|
||
|
}
|
||
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
return srv.(ExecutionServer).Execute(ctx, req.(*ExecuteRequest))
|
||
|
}
|
||
|
return interceptor(ctx, in, info, handler)
|
||
|
}
|
||
|
|
||
|
var _Execution_serviceDesc = grpc.ServiceDesc{
|
||
|
ServiceName: "google.devtools.remoteexecution.v1test.Execution",
|
||
|
HandlerType: (*ExecutionServer)(nil),
|
||
|
Methods: []grpc.MethodDesc{
|
||
|
{
|
||
|
MethodName: "Execute",
|
||
|
Handler: _Execution_Execute_Handler,
|
||
|
},
|
||
|
},
|
||
|
Streams: []grpc.StreamDesc{},
|
||
|
Metadata: "google/devtools/remoteexecution/v1test/remote_execution.proto",
|
||
|
}
|
||
|
|
||
|
// ActionCacheClient is the client API for ActionCache service.
|
||
|
//
|
||
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
||
|
type ActionCacheClient interface {
|
||
|
// Retrieve a cached execution result.
|
||
|
//
|
||
|
// Errors:
|
||
|
// * `NOT_FOUND`: The requested `ActionResult` is not in the cache.
|
||
|
GetActionResult(ctx context.Context, in *GetActionResultRequest, opts ...grpc.CallOption) (*ActionResult, error)
|
||
|
// Upload a new execution result.
|
||
|
//
|
||
|
// This method is intended for servers which implement the distributed cache
|
||
|
// independently of the
|
||
|
// [Execution][google.devtools.remoteexecution.v1test.Execution] API. As a
|
||
|
// result, it is OPTIONAL for servers to implement.
|
||
|
//
|
||
|
// Errors:
|
||
|
// * `NOT_IMPLEMENTED`: This method is not supported by the server.
|
||
|
// * `RESOURCE_EXHAUSTED`: There is insufficient storage space to add the
|
||
|
// entry to the cache.
|
||
|
UpdateActionResult(ctx context.Context, in *UpdateActionResultRequest, opts ...grpc.CallOption) (*ActionResult, error)
|
||
|
}
|
||
|
|
||
|
type actionCacheClient struct {
|
||
|
cc *grpc.ClientConn
|
||
|
}
|
||
|
|
||
|
func NewActionCacheClient(cc *grpc.ClientConn) ActionCacheClient {
|
||
|
return &actionCacheClient{cc}
|
||
|
}
|
||
|
|
||
|
func (c *actionCacheClient) GetActionResult(ctx context.Context, in *GetActionResultRequest, opts ...grpc.CallOption) (*ActionResult, error) {
|
||
|
out := new(ActionResult)
|
||
|
err := c.cc.Invoke(ctx, "/google.devtools.remoteexecution.v1test.ActionCache/GetActionResult", in, out, opts...)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return out, nil
|
||
|
}
|
||
|
|
||
|
func (c *actionCacheClient) UpdateActionResult(ctx context.Context, in *UpdateActionResultRequest, opts ...grpc.CallOption) (*ActionResult, error) {
|
||
|
out := new(ActionResult)
|
||
|
err := c.cc.Invoke(ctx, "/google.devtools.remoteexecution.v1test.ActionCache/UpdateActionResult", in, out, opts...)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return out, nil
|
||
|
}
|
||
|
|
||
|
// ActionCacheServer is the server API for ActionCache service.
|
||
|
type ActionCacheServer interface {
|
||
|
// Retrieve a cached execution result.
|
||
|
//
|
||
|
// Errors:
|
||
|
// * `NOT_FOUND`: The requested `ActionResult` is not in the cache.
|
||
|
GetActionResult(context.Context, *GetActionResultRequest) (*ActionResult, error)
|
||
|
// Upload a new execution result.
|
||
|
//
|
||
|
// This method is intended for servers which implement the distributed cache
|
||
|
// independently of the
|
||
|
// [Execution][google.devtools.remoteexecution.v1test.Execution] API. As a
|
||
|
// result, it is OPTIONAL for servers to implement.
|
||
|
//
|
||
|
// Errors:
|
||
|
// * `NOT_IMPLEMENTED`: This method is not supported by the server.
|
||
|
// * `RESOURCE_EXHAUSTED`: There is insufficient storage space to add the
|
||
|
// entry to the cache.
|
||
|
UpdateActionResult(context.Context, *UpdateActionResultRequest) (*ActionResult, error)
|
||
|
}
|
||
|
|
||
|
func RegisterActionCacheServer(s *grpc.Server, srv ActionCacheServer) {
|
||
|
s.RegisterService(&_ActionCache_serviceDesc, srv)
|
||
|
}
|
||
|
|
||
|
func _ActionCache_GetActionResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
|
in := new(GetActionResultRequest)
|
||
|
if err := dec(in); err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
if interceptor == nil {
|
||
|
return srv.(ActionCacheServer).GetActionResult(ctx, in)
|
||
|
}
|
||
|
info := &grpc.UnaryServerInfo{
|
||
|
Server: srv,
|
||
|
FullMethod: "/google.devtools.remoteexecution.v1test.ActionCache/GetActionResult",
|
||
|
}
|
||
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
return srv.(ActionCacheServer).GetActionResult(ctx, req.(*GetActionResultRequest))
|
||
|
}
|
||
|
return interceptor(ctx, in, info, handler)
|
||
|
}
|
||
|
|
||
|
func _ActionCache_UpdateActionResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
|
in := new(UpdateActionResultRequest)
|
||
|
if err := dec(in); err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
if interceptor == nil {
|
||
|
return srv.(ActionCacheServer).UpdateActionResult(ctx, in)
|
||
|
}
|
||
|
info := &grpc.UnaryServerInfo{
|
||
|
Server: srv,
|
||
|
FullMethod: "/google.devtools.remoteexecution.v1test.ActionCache/UpdateActionResult",
|
||
|
}
|
||
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
return srv.(ActionCacheServer).UpdateActionResult(ctx, req.(*UpdateActionResultRequest))
|
||
|
}
|
||
|
return interceptor(ctx, in, info, handler)
|
||
|
}
|
||
|
|
||
|
var _ActionCache_serviceDesc = grpc.ServiceDesc{
|
||
|
ServiceName: "google.devtools.remoteexecution.v1test.ActionCache",
|
||
|
HandlerType: (*ActionCacheServer)(nil),
|
||
|
Methods: []grpc.MethodDesc{
|
||
|
{
|
||
|
MethodName: "GetActionResult",
|
||
|
Handler: _ActionCache_GetActionResult_Handler,
|
||
|
},
|
||
|
{
|
||
|
MethodName: "UpdateActionResult",
|
||
|
Handler: _ActionCache_UpdateActionResult_Handler,
|
||
|
},
|
||
|
},
|
||
|
Streams: []grpc.StreamDesc{},
|
||
|
Metadata: "google/devtools/remoteexecution/v1test/remote_execution.proto",
|
||
|
}
|
||
|
|
||
|
// ContentAddressableStorageClient is the client API for ContentAddressableStorage service.
|
||
|
//
|
||
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
|
||
|
type ContentAddressableStorageClient interface {
|
||
|
// Determine if blobs are present in the CAS.
|
||
|
//
|
||
|
// Clients can use this API before uploading blobs to determine which ones are
|
||
|
// already present in the CAS and do not need to be uploaded again.
|
||
|
//
|
||
|
// There are no method-specific errors.
|
||
|
FindMissingBlobs(ctx context.Context, in *FindMissingBlobsRequest, opts ...grpc.CallOption) (*FindMissingBlobsResponse, error)
|
||
|
// Upload many blobs at once.
|
||
|
//
|
||
|
// The client MUST NOT upload blobs with a combined total size of more than 10
|
||
|
// MiB using this API. Such requests should either be split into smaller
|
||
|
// chunks or uploaded using the
|
||
|
// [ByteStream API][google.bytestream.ByteStream], as appropriate.
|
||
|
//
|
||
|
// This request is equivalent to calling [UpdateBlob][] on each individual
|
||
|
// blob, in parallel. The requests may succeed or fail independently.
|
||
|
//
|
||
|
// Errors:
|
||
|
// * `INVALID_ARGUMENT`: The client attempted to upload more than 10 MiB of
|
||
|
// data.
|
||
|
//
|
||
|
// Individual requests may return the following errors, additionally:
|
||
|
// * `RESOURCE_EXHAUSTED`: There is insufficient disk quota to store the blob.
|
||
|
// * `INVALID_ARGUMENT`: The
|
||
|
// [Digest][google.devtools.remoteexecution.v1test.Digest] does not match the
|
||
|
// provided data.
|
||
|
BatchUpdateBlobs(ctx context.Context, in *BatchUpdateBlobsRequest, opts ...grpc.CallOption) (*BatchUpdateBlobsResponse, error)
|
||
|
// Fetch the entire directory tree rooted at a node.
|
||
|
//
|
||
|
// This request must be targeted at a
|
||
|
// [Directory][google.devtools.remoteexecution.v1test.Directory] stored in the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage]
|
||
|
// (CAS). The server will enumerate the `Directory` tree recursively and
|
||
|
// return every node descended from the root.
|
||
|
// The exact traversal order is unspecified and, unless retrieving subsequent
|
||
|
// pages from an earlier request, is not guaranteed to be stable across
|
||
|
// multiple invocations of `GetTree`.
|
||
|
//
|
||
|
// If part of the tree is missing from the CAS, the server will return the
|
||
|
// portion present and omit the rest.
|
||
|
//
|
||
|
// * `NOT_FOUND`: The requested tree root is not present in the CAS.
|
||
|
GetTree(ctx context.Context, in *GetTreeRequest, opts ...grpc.CallOption) (*GetTreeResponse, error)
|
||
|
}
|
||
|
|
||
|
type contentAddressableStorageClient struct {
|
||
|
cc *grpc.ClientConn
|
||
|
}
|
||
|
|
||
|
func NewContentAddressableStorageClient(cc *grpc.ClientConn) ContentAddressableStorageClient {
|
||
|
return &contentAddressableStorageClient{cc}
|
||
|
}
|
||
|
|
||
|
func (c *contentAddressableStorageClient) FindMissingBlobs(ctx context.Context, in *FindMissingBlobsRequest, opts ...grpc.CallOption) (*FindMissingBlobsResponse, error) {
|
||
|
out := new(FindMissingBlobsResponse)
|
||
|
err := c.cc.Invoke(ctx, "/google.devtools.remoteexecution.v1test.ContentAddressableStorage/FindMissingBlobs", in, out, opts...)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return out, nil
|
||
|
}
|
||
|
|
||
|
func (c *contentAddressableStorageClient) BatchUpdateBlobs(ctx context.Context, in *BatchUpdateBlobsRequest, opts ...grpc.CallOption) (*BatchUpdateBlobsResponse, error) {
|
||
|
out := new(BatchUpdateBlobsResponse)
|
||
|
err := c.cc.Invoke(ctx, "/google.devtools.remoteexecution.v1test.ContentAddressableStorage/BatchUpdateBlobs", in, out, opts...)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return out, nil
|
||
|
}
|
||
|
|
||
|
func (c *contentAddressableStorageClient) GetTree(ctx context.Context, in *GetTreeRequest, opts ...grpc.CallOption) (*GetTreeResponse, error) {
|
||
|
out := new(GetTreeResponse)
|
||
|
err := c.cc.Invoke(ctx, "/google.devtools.remoteexecution.v1test.ContentAddressableStorage/GetTree", in, out, opts...)
|
||
|
if err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
return out, nil
|
||
|
}
|
||
|
|
||
|
// ContentAddressableStorageServer is the server API for ContentAddressableStorage service.
|
||
|
type ContentAddressableStorageServer interface {
|
||
|
// Determine if blobs are present in the CAS.
|
||
|
//
|
||
|
// Clients can use this API before uploading blobs to determine which ones are
|
||
|
// already present in the CAS and do not need to be uploaded again.
|
||
|
//
|
||
|
// There are no method-specific errors.
|
||
|
FindMissingBlobs(context.Context, *FindMissingBlobsRequest) (*FindMissingBlobsResponse, error)
|
||
|
// Upload many blobs at once.
|
||
|
//
|
||
|
// The client MUST NOT upload blobs with a combined total size of more than 10
|
||
|
// MiB using this API. Such requests should either be split into smaller
|
||
|
// chunks or uploaded using the
|
||
|
// [ByteStream API][google.bytestream.ByteStream], as appropriate.
|
||
|
//
|
||
|
// This request is equivalent to calling [UpdateBlob][] on each individual
|
||
|
// blob, in parallel. The requests may succeed or fail independently.
|
||
|
//
|
||
|
// Errors:
|
||
|
// * `INVALID_ARGUMENT`: The client attempted to upload more than 10 MiB of
|
||
|
// data.
|
||
|
//
|
||
|
// Individual requests may return the following errors, additionally:
|
||
|
// * `RESOURCE_EXHAUSTED`: There is insufficient disk quota to store the blob.
|
||
|
// * `INVALID_ARGUMENT`: The
|
||
|
// [Digest][google.devtools.remoteexecution.v1test.Digest] does not match the
|
||
|
// provided data.
|
||
|
BatchUpdateBlobs(context.Context, *BatchUpdateBlobsRequest) (*BatchUpdateBlobsResponse, error)
|
||
|
// Fetch the entire directory tree rooted at a node.
|
||
|
//
|
||
|
// This request must be targeted at a
|
||
|
// [Directory][google.devtools.remoteexecution.v1test.Directory] stored in the
|
||
|
// [ContentAddressableStorage][google.devtools.remoteexecution.v1test.ContentAddressableStorage]
|
||
|
// (CAS). The server will enumerate the `Directory` tree recursively and
|
||
|
// return every node descended from the root.
|
||
|
// The exact traversal order is unspecified and, unless retrieving subsequent
|
||
|
// pages from an earlier request, is not guaranteed to be stable across
|
||
|
// multiple invocations of `GetTree`.
|
||
|
//
|
||
|
// If part of the tree is missing from the CAS, the server will return the
|
||
|
// portion present and omit the rest.
|
||
|
//
|
||
|
// * `NOT_FOUND`: The requested tree root is not present in the CAS.
|
||
|
GetTree(context.Context, *GetTreeRequest) (*GetTreeResponse, error)
|
||
|
}
|
||
|
|
||
|
func RegisterContentAddressableStorageServer(s *grpc.Server, srv ContentAddressableStorageServer) {
|
||
|
s.RegisterService(&_ContentAddressableStorage_serviceDesc, srv)
|
||
|
}
|
||
|
|
||
|
func _ContentAddressableStorage_FindMissingBlobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
|
in := new(FindMissingBlobsRequest)
|
||
|
if err := dec(in); err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
if interceptor == nil {
|
||
|
return srv.(ContentAddressableStorageServer).FindMissingBlobs(ctx, in)
|
||
|
}
|
||
|
info := &grpc.UnaryServerInfo{
|
||
|
Server: srv,
|
||
|
FullMethod: "/google.devtools.remoteexecution.v1test.ContentAddressableStorage/FindMissingBlobs",
|
||
|
}
|
||
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
return srv.(ContentAddressableStorageServer).FindMissingBlobs(ctx, req.(*FindMissingBlobsRequest))
|
||
|
}
|
||
|
return interceptor(ctx, in, info, handler)
|
||
|
}
|
||
|
|
||
|
func _ContentAddressableStorage_BatchUpdateBlobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
|
in := new(BatchUpdateBlobsRequest)
|
||
|
if err := dec(in); err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
if interceptor == nil {
|
||
|
return srv.(ContentAddressableStorageServer).BatchUpdateBlobs(ctx, in)
|
||
|
}
|
||
|
info := &grpc.UnaryServerInfo{
|
||
|
Server: srv,
|
||
|
FullMethod: "/google.devtools.remoteexecution.v1test.ContentAddressableStorage/BatchUpdateBlobs",
|
||
|
}
|
||
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
return srv.(ContentAddressableStorageServer).BatchUpdateBlobs(ctx, req.(*BatchUpdateBlobsRequest))
|
||
|
}
|
||
|
return interceptor(ctx, in, info, handler)
|
||
|
}
|
||
|
|
||
|
func _ContentAddressableStorage_GetTree_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||
|
in := new(GetTreeRequest)
|
||
|
if err := dec(in); err != nil {
|
||
|
return nil, err
|
||
|
}
|
||
|
if interceptor == nil {
|
||
|
return srv.(ContentAddressableStorageServer).GetTree(ctx, in)
|
||
|
}
|
||
|
info := &grpc.UnaryServerInfo{
|
||
|
Server: srv,
|
||
|
FullMethod: "/google.devtools.remoteexecution.v1test.ContentAddressableStorage/GetTree",
|
||
|
}
|
||
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||
|
return srv.(ContentAddressableStorageServer).GetTree(ctx, req.(*GetTreeRequest))
|
||
|
}
|
||
|
return interceptor(ctx, in, info, handler)
|
||
|
}
|
||
|
|
||
|
var _ContentAddressableStorage_serviceDesc = grpc.ServiceDesc{
|
||
|
ServiceName: "google.devtools.remoteexecution.v1test.ContentAddressableStorage",
|
||
|
HandlerType: (*ContentAddressableStorageServer)(nil),
|
||
|
Methods: []grpc.MethodDesc{
|
||
|
{
|
||
|
MethodName: "FindMissingBlobs",
|
||
|
Handler: _ContentAddressableStorage_FindMissingBlobs_Handler,
|
||
|
},
|
||
|
{
|
||
|
MethodName: "BatchUpdateBlobs",
|
||
|
Handler: _ContentAddressableStorage_BatchUpdateBlobs_Handler,
|
||
|
},
|
||
|
{
|
||
|
MethodName: "GetTree",
|
||
|
Handler: _ContentAddressableStorage_GetTree_Handler,
|
||
|
},
|
||
|
},
|
||
|
Streams: []grpc.StreamDesc{},
|
||
|
Metadata: "google/devtools/remoteexecution/v1test/remote_execution.proto",
|
||
|
}
|
||
|
|
||
|
func init() {
|
||
|
proto.RegisterFile("google/devtools/remoteexecution/v1test/remote_execution.proto", fileDescriptor_remote_execution_25e31fef95c58b43)
|
||
|
}
|
||
|
|
||
|
var fileDescriptor_remote_execution_25e31fef95c58b43 = []byte{
|
||
|
// 2025 bytes of a gzipped FileDescriptorProto
|
||
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x59, 0xdd, 0x6f, 0x23, 0x57,
|
||
|
0x15, 0x67, 0xec, 0x24, 0xb6, 0x8f, 0x9d, 0x75, 0xf6, 0x76, 0xe9, 0x7a, 0xdd, 0x2e, 0x4a, 0xa7,
|
||
|
0xa2, 0x8a, 0xa2, 0x62, 0xb3, 0xde, 0x96, 0x85, 0x54, 0xa5, 0x6c, 0x1c, 0x27, 0x8d, 0x9a, 0xaf,
|
||
|
0x4e, 0xe2, 0x74, 0xbb, 0xaa, 0x34, 0x9d, 0x78, 0x6e, 0xc6, 0xa3, 0xd8, 0x73, 0xcd, 0xbd, 0xd7,
|
||
|
0x69, 0xd2, 0x65, 0x79, 0xe0, 0x05, 0x09, 0x04, 0x12, 0x54, 0x08, 0x24, 0x78, 0x42, 0x42, 0x48,
|
||
|
0x88, 0x27, 0xfe, 0x00, 0x24, 0xf8, 0x03, 0x78, 0x80, 0x17, 0x9e, 0x11, 0x2f, 0xbc, 0xf1, 0xdc,
|
||
|
0x07, 0x84, 0xee, 0xc7, 0x7c, 0xd8, 0xc9, 0xb2, 0x63, 0x67, 0x57, 0xe2, 0xcd, 0x73, 0xce, 0x3d,
|
||
|
0xbf, 0xf3, 0x79, 0xcf, 0x39, 0x33, 0x86, 0xb7, 0x3d, 0x42, 0xbc, 0x1e, 0xae, 0xbb, 0xf8, 0x94,
|
||
|
0x13, 0xd2, 0x63, 0x75, 0x8a, 0xfb, 0x84, 0x63, 0x7c, 0x86, 0x3b, 0x43, 0xee, 0x93, 0xa0, 0x7e,
|
||
|
0x7a, 0x87, 0x63, 0xc6, 0x35, 0xd9, 0x8e, 0xe8, 0xb5, 0x01, 0x25, 0x9c, 0xa0, 0xd7, 0x94, 0x78,
|
||
|
0x2d, 0x14, 0xaf, 0x8d, 0x89, 0xd7, 0x94, 0x78, 0xf5, 0x65, 0xad, 0xc6, 0x19, 0xf8, 0x75, 0x27,
|
||
|
0x08, 0x08, 0x77, 0x04, 0x97, 0x29, 0x94, 0xea, 0xab, 0x9a, 0xdb, 0x23, 0x81, 0x47, 0x87, 0x41,
|
||
|
0xe0, 0x07, 0x5e, 0x9d, 0x0c, 0x30, 0x1d, 0x39, 0xf4, 0x25, 0x7d, 0x48, 0x3e, 0x1d, 0x0d, 0x8f,
|
||
|
0xeb, 0xee, 0x50, 0x1d, 0xd0, 0xfc, 0x9b, 0x9a, 0x4f, 0x07, 0x9d, 0x3a, 0xe3, 0x0e, 0x1f, 0x6a,
|
||
|
0x41, 0xf3, 0x0f, 0x59, 0x98, 0xbb, 0xdf, 0x11, 0x27, 0x51, 0x1b, 0xae, 0x75, 0x48, 0xbf, 0xef,
|
||
|
0x04, 0xae, 0xed, 0xfa, 0x1e, 0x66, 0xbc, 0x62, 0x2c, 0x1a, 0x4b, 0xc5, 0x46, 0xad, 0x96, 0xce,
|
||
|
0x8f, 0xda, 0x9a, 0x94, 0xb2, 0xe6, 0x35, 0x8a, 0x7a, 0x44, 0x0f, 0xe1, 0xba, 0x1f, 0x0c, 0x86,
|
||
|
0xdc, 0xa6, 0x84, 0xf0, 0x10, 0x39, 0x33, 0x15, 0x72, 0x59, 0x02, 0x59, 0x84, 0x70, 0x8d, 0xfd,
|
||
|
0x0a, 0x94, 0xc8, 0x90, 0x0b, 0xf0, 0x63, 0xbf, 0x87, 0x59, 0x25, 0xbb, 0x98, 0x5d, 0x2a, 0x58,
|
||
|
0x45, 0x45, 0x5b, 0x17, 0x24, 0xf4, 0x15, 0x40, 0xfa, 0x88, 0xeb, 0x53, 0xdc, 0xe1, 0x84, 0xfa,
|
||
|
0x98, 0x55, 0x66, 0xe4, 0xc1, 0xeb, 0x8a, 0xb3, 0x16, 0x33, 0xd0, 0x16, 0xe4, 0x07, 0x3d, 0x87,
|
||
|
0x1f, 0x13, 0xda, 0xaf, 0xcc, 0x4a, 0x23, 0xbf, 0x9a, 0xd6, 0xc8, 0x3d, 0x2d, 0x67, 0x45, 0x08,
|
||
|
0xe8, 0x2e, 0xe4, 0xb8, 0xdf, 0xc7, 0x64, 0xc8, 0x2b, 0x73, 0x12, 0xec, 0x56, 0x08, 0x16, 0x26,
|
||
|
0xaa, 0xb6, 0xa6, 0x13, 0x65, 0x85, 0x27, 0xd1, 0x22, 0x94, 0x5c, 0x62, 0x07, 0x84, 0xdb, 0x1d,
|
||
|
0xa7, 0xd3, 0xc5, 0x95, 0xdc, 0xa2, 0xb1, 0x94, 0xb7, 0xc0, 0x25, 0x3b, 0x84, 0x37, 0x05, 0xc5,
|
||
|
0xfc, 0x87, 0x01, 0xb9, 0xa6, 0x0a, 0x32, 0x7a, 0x19, 0x0a, 0x0e, 0xf5, 0x86, 0x7d, 0x1c, 0x70,
|
||
|
0x56, 0x31, 0xa4, 0x5b, 0x31, 0x01, 0x9d, 0xc1, 0x17, 0x71, 0x70, 0xea, 0x53, 0x12, 0x88, 0x67,
|
||
|
0xfb, 0xd4, 0xa1, 0xbe, 0x73, 0x24, 0x22, 0x95, 0x59, 0xcc, 0x2e, 0x15, 0x1b, 0xcd, 0xb4, 0xbe,
|
||
|
0x69, 0x6d, 0xb5, 0x56, 0x0c, 0x76, 0xa8, 0xb1, 0xac, 0x1b, 0xf8, 0x22, 0x91, 0x55, 0xdf, 0x81,
|
||
|
0x17, 0x2e, 0x39, 0x8c, 0x10, 0xcc, 0x04, 0x4e, 0x1f, 0xcb, 0xd2, 0x2a, 0x58, 0xf2, 0x37, 0xba,
|
||
|
0x01, 0xb3, 0xa7, 0x4e, 0x6f, 0x88, 0x65, 0x55, 0x14, 0x2c, 0xf5, 0x60, 0xfe, 0xd2, 0x80, 0x7c,
|
||
|
0x18, 0x52, 0xf4, 0x21, 0xc0, 0x80, 0x8a, 0xaa, 0xe7, 0x22, 0x7b, 0x86, 0x34, 0xfe, 0x1b, 0x93,
|
||
|
0x26, 0xa6, 0xb6, 0xa7, 0x20, 0xce, 0xad, 0x04, 0x58, 0xf5, 0x0d, 0xc8, 0x87, 0xf4, 0x09, 0xac,
|
||
|
0xfb, 0xbd, 0x01, 0x85, 0xb0, 0x6e, 0xce, 0xd1, 0x3a, 0xcc, 0xaa, 0x02, 0x54, 0x96, 0xa5, 0x2e,
|
||
|
0x19, 0x51, 0xa2, 0x3b, 0xc4, 0xc5, 0x96, 0x12, 0x47, 0x1f, 0x40, 0x31, 0x59, 0xa5, 0x2a, 0x49,
|
||
|
0x6f, 0xa6, 0xbf, 0x25, 0xda, 0x1e, 0x09, 0x99, 0x44, 0x32, 0x7f, 0x68, 0x40, 0x3e, 0x54, 0x76,
|
||
|
0xa9, 0x97, 0xeb, 0x30, 0x77, 0xa5, 0xab, 0xa9, 0xa5, 0xd1, 0xab, 0x30, 0xef, 0x33, 0xdd, 0x09,
|
||
|
0x45, 0xc2, 0x2b, 0x33, 0xb2, 0x7a, 0x4b, 0x3e, 0x6b, 0x45, 0x34, 0xf3, 0x04, 0xe6, 0x47, 0x6c,
|
||
|
0x7d, 0x9e, 0x16, 0x99, 0x6f, 0xc1, 0x9c, 0xee, 0x16, 0x08, 0x66, 0xba, 0x0e, 0xeb, 0x86, 0x5a,
|
||
|
0xc4, 0x6f, 0x74, 0x1b, 0x80, 0xf9, 0x9f, 0x62, 0xfb, 0xe8, 0x9c, 0xcb, 0x80, 0x1b, 0x4b, 0x59,
|
||
|
0xab, 0x20, 0x28, 0xab, 0x82, 0x60, 0xfe, 0x35, 0x0b, 0x25, 0xd5, 0x1e, 0x2d, 0xcc, 0x86, 0x3d,
|
||
|
0x8e, 0xda, 0x63, 0x1d, 0x47, 0xa5, 0xa8, 0x91, 0xd6, 0xb6, 0xdd, 0xa8, 0x33, 0x8d, 0x76, 0xa9,
|
||
|
0xe3, 0x4b, 0xbb, 0x54, 0x56, 0x82, 0xdf, 0x9b, 0x0c, 0x3c, 0x8a, 0xec, 0x65, 0xed, 0xed, 0x25,
|
||
|
0x28, 0xe0, 0x33, 0x9f, 0xdb, 0x1d, 0xe2, 0xaa, 0xd4, 0xcc, 0x5a, 0x79, 0x41, 0x68, 0x8a, 0x2c,
|
||
|
0x88, 0x58, 0x70, 0x97, 0x88, 0x56, 0xed, 0x7c, 0x22, 0xbb, 0x5f, 0xc9, 0x2a, 0x28, 0x8a, 0xe5,
|
||
|
0x7c, 0x82, 0xf6, 0x61, 0x5e, 0xb3, 0x75, 0x5e, 0xe6, 0xa6, 0xca, 0x4b, 0x49, 0x81, 0xe8, 0x9c,
|
||
|
0x28, 0x9d, 0x98, 0x52, 0xa9, 0x33, 0x17, 0xe9, 0xc4, 0x94, 0xc6, 0x3a, 0x05, 0x5b, 0xeb, 0xcc,
|
||
|
0x4f, 0xad, 0x13, 0x53, 0xaa, 0x9e, 0xcc, 0xdf, 0x1a, 0x00, 0x71, 0x22, 0x44, 0x59, 0x0c, 0x1c,
|
||
|
0x1e, 0x95, 0x85, 0xf8, 0xfd, 0xcc, 0xae, 0x43, 0x05, 0x72, 0x1d, 0x12, 0x70, 0x1c, 0xf0, 0x4a,
|
||
|
0x56, 0xfa, 0x16, 0x3e, 0xa6, 0xbb, 0x28, 0xbf, 0x32, 0x60, 0xe6, 0x80, 0x62, 0x8c, 0x5a, 0x30,
|
||
|
0x23, 0xc6, 0xa7, 0x9e, 0xc8, 0x77, 0x26, 0xee, 0x08, 0x96, 0x14, 0x47, 0xdb, 0x90, 0xef, 0x74,
|
||
|
0xfd, 0x9e, 0x4b, 0x71, 0xa0, 0x2b, 0x77, 0x0a, 0xa8, 0x08, 0xc2, 0xfc, 0xa3, 0x01, 0xe5, 0xb1,
|
||
|
0xa2, 0x7b, 0xae, 0xd1, 0xdc, 0x85, 0x22, 0xa7, 0x18, 0x87, 0xb5, 0x90, 0x9d, 0x0a, 0x0c, 0x04,
|
||
|
0x84, 0xae, 0x84, 0xcf, 0x32, 0x70, 0x4d, 0x85, 0x1b, 0x5b, 0xf8, 0xdb, 0xc3, 0xb0, 0x81, 0x05,
|
||
|
0x8c, 0x3b, 0x41, 0x07, 0xdb, 0x89, 0x9e, 0x54, 0x0a, 0x89, 0x3b, 0xba, 0x37, 0x39, 0xb2, 0x2b,
|
||
|
0x4c, 0xea, 0x90, 0xee, 0x25, 0x5a, 0x1a, 0x2d, 0xc3, 0x75, 0x76, 0xe2, 0x0f, 0xd4, 0xa0, 0xb7,
|
||
|
0x7b, 0x84, 0x9c, 0x0c, 0x07, 0xd2, 0xad, 0xbc, 0x55, 0x16, 0x0c, 0x39, 0xee, 0xb7, 0x24, 0x19,
|
||
|
0xdd, 0x85, 0x17, 0x39, 0xe1, 0x4e, 0xcf, 0x56, 0xdb, 0x94, 0x68, 0x3f, 0x76, 0x87, 0x0c, 0x03,
|
||
|
0xae, 0xef, 0xf1, 0x0b, 0x92, 0xbb, 0x19, 0xe8, 0xb2, 0x6e, 0x0a, 0xd6, 0xa5, 0x42, 0xaa, 0xd5,
|
||
|
0xcd, 0xca, 0x56, 0x37, 0x26, 0xa4, 0x9a, 0xde, 0x19, 0xe4, 0xb6, 0x88, 0x27, 0xef, 0x46, 0x9c,
|
||
|
0x39, 0xe3, 0x4a, 0x99, 0xfb, 0x32, 0x5c, 0xeb, 0x0e, 0xfb, 0x4e, 0x60, 0x53, 0xec, 0xb8, 0xb2,
|
||
|
0xdc, 0x33, 0xd2, 0xcb, 0x79, 0x49, 0xb5, 0x34, 0xd1, 0xfc, 0x41, 0x16, 0xca, 0x51, 0x3e, 0xd8,
|
||
|
0x80, 0x04, 0x0c, 0xa3, 0x2d, 0x98, 0xa3, 0xb2, 0xf7, 0x6a, 0x13, 0xde, 0x98, 0x30, 0xd6, 0x52,
|
||
|
0xd6, 0xd2, 0x18, 0x22, 0xbd, 0x32, 0xd8, 0xae, 0xad, 0x41, 0x95, 0x1d, 0x25, 0x45, 0xd4, 0x4d,
|
||
|
0x7e, 0x19, 0xe6, 0xd4, 0x92, 0xac, 0x4b, 0x0c, 0x85, 0x2a, 0xe9, 0xa0, 0x53, 0xdb, 0x97, 0x1c,
|
||
|
0x4b, 0x9f, 0x40, 0x5d, 0x28, 0x32, 0x4c, 0x4f, 0x31, 0xb5, 0x7b, 0xc4, 0x53, 0x8b, 0x65, 0xb1,
|
||
|
0xb1, 0x91, 0xd6, 0xc6, 0x31, 0x67, 0x6b, 0xfb, 0x12, 0x6a, 0x8b, 0x78, 0xac, 0x15, 0x70, 0x7a,
|
||
|
0x6e, 0x01, 0x8b, 0x08, 0xd5, 0x00, 0xca, 0x63, 0x6c, 0xb4, 0x00, 0xd9, 0x13, 0x7c, 0xae, 0x4b,
|
||
|
0x54, 0xfc, 0x44, 0xad, 0xe4, 0xb6, 0x52, 0x6c, 0xd4, 0xd3, 0x1a, 0xa2, 0x13, 0xae, 0xd7, 0x9b,
|
||
|
0x95, 0xcc, 0xd7, 0x0d, 0xf3, 0xf3, 0x0c, 0x54, 0xb4, 0x7d, 0xbb, 0xe1, 0xfb, 0xc6, 0x36, 0xe6,
|
||
|
0x8e, 0xeb, 0x70, 0x07, 0x7d, 0x04, 0xb3, 0x8c, 0x3b, 0x9e, 0xba, 0x1e, 0xd7, 0x1a, 0xeb, 0x13,
|
||
|
0x3a, 0x7c, 0x01, 0x50, 0x84, 0xd5, 0xc3, 0x96, 0x02, 0x15, 0x6d, 0x5f, 0xdd, 0x90, 0xab, 0xbd,
|
||
|
0x2f, 0x94, 0x14, 0x88, 0x1e, 0x35, 0xaf, 0x03, 0xd2, 0xf3, 0x8b, 0x71, 0x8a, 0x9d, 0xbe, 0xba,
|
||
|
0xde, 0x59, 0x19, 0xbb, 0x05, 0xc5, 0xd9, 0x97, 0x0c, 0x79, 0xc5, 0xd5, 0x69, 0x31, 0x79, 0x92,
|
||
|
0xa7, 0x67, 0xa2, 0xd3, 0x98, 0xd2, 0xf8, 0xb4, 0xb9, 0x0b, 0xb3, 0xd2, 0x01, 0x54, 0x84, 0x5c,
|
||
|
0x7b, 0xe7, 0xbd, 0x9d, 0xdd, 0x0f, 0x76, 0x16, 0xbe, 0x80, 0xca, 0x50, 0x6c, 0xde, 0x6f, 0xbe,
|
||
|
0xdb, 0xb2, 0x9b, 0xef, 0xb6, 0x9a, 0xef, 0x2d, 0x18, 0x08, 0x60, 0xee, 0xfd, 0x76, 0xab, 0xdd,
|
||
|
0x5a, 0x5b, 0xc8, 0xa0, 0x79, 0x28, 0xb4, 0x1e, 0xb4, 0x9a, 0xed, 0x83, 0xcd, 0x9d, 0x8d, 0x85,
|
||
|
0xac, 0x78, 0x6c, 0xee, 0x6e, 0xef, 0x6d, 0xb5, 0x0e, 0x5a, 0x6b, 0x0b, 0x33, 0xe6, 0x4f, 0x0d,
|
||
|
0x78, 0x71, 0x03, 0xf3, 0x91, 0x1a, 0x9e, 0xa4, 0x43, 0x3d, 0x8f, 0x08, 0x9a, 0xff, 0x36, 0xe0,
|
||
|
0x56, 0x7b, 0xe0, 0x3a, 0x1c, 0xff, 0x5f, 0xd9, 0x85, 0x3e, 0x8c, 0x40, 0xf5, 0xa5, 0xce, 0x5e,
|
||
|
0xa1, 0x53, 0x68, 0x68, 0xf5, 0x64, 0xfe, 0xc4, 0x80, 0x9b, 0xeb, 0x7e, 0xe0, 0x6e, 0xfb, 0x8c,
|
||
|
0xf9, 0x81, 0xb7, 0xda, 0x23, 0x47, 0x6c, 0x22, 0x87, 0xdf, 0x87, 0xd2, 0x51, 0x8f, 0x1c, 0x69,
|
||
|
0x77, 0xc3, 0x85, 0x71, 0x52, 0x7f, 0x8b, 0x02, 0x43, 0xfd, 0x66, 0xe6, 0x77, 0xa0, 0x72, 0xd1,
|
||
|
0x24, 0xdd, 0x2d, 0x3f, 0x86, 0x1b, 0x7d, 0x45, 0xb7, 0x9f, 0x81, 0x5a, 0xd4, 0x8f, 0x75, 0x84,
|
||
|
0xda, 0xbf, 0x0b, 0xd7, 0x55, 0x0d, 0x08, 0x62, 0x18, 0x0a, 0xf9, 0xed, 0x40, 0x2e, 0x36, 0x57,
|
||
|
0xfe, 0x76, 0x20, 0x51, 0xe2, 0x8d, 0x5d, 0x34, 0x07, 0x59, 0x24, 0x25, 0x4b, 0xfe, 0x36, 0x7f,
|
||
|
0x66, 0xc0, 0xcd, 0x55, 0x87, 0x77, 0xba, 0xb1, 0x15, 0x93, 0x65, 0xa4, 0x0d, 0x79, 0xaa, 0xce,
|
||
|
0x87, 0x61, 0x49, 0xfd, 0x26, 0x79, 0xc1, 0x71, 0x2b, 0x82, 0x32, 0x7f, 0x94, 0x81, 0xca, 0x45,
|
||
|
0xbb, 0x74, 0x5a, 0x3c, 0x28, 0x50, 0xfd, 0x3b, 0x7c, 0x49, 0xdc, 0x4c, 0xab, 0xf4, 0x49, 0xa0,
|
||
|
0xb5, 0xf0, 0x87, 0x15, 0x63, 0x57, 0xbf, 0x6f, 0x40, 0x3e, 0xd2, 0xba, 0x0b, 0xc5, 0x44, 0x11,
|
||
|
0x4c, 0x99, 0x12, 0x88, 0x4b, 0x2f, 0x31, 0x18, 0x33, 0x4f, 0x1b, 0x8c, 0xe6, 0x9f, 0x0d, 0xb8,
|
||
|
0xb6, 0x81, 0xb9, 0x58, 0x5f, 0x27, 0x4a, 0xcf, 0x2e, 0x14, 0xaf, 0xfe, 0xa5, 0x08, 0x68, 0xfc,
|
||
|
0x91, 0xe8, 0x25, 0x28, 0x0c, 0x1c, 0x0f, 0xdb, 0xe2, 0xad, 0x4e, 0x76, 0x86, 0x59, 0x2b, 0x2f,
|
||
|
0x08, 0xfb, 0xfe, 0xa7, 0xf2, 0x9d, 0x47, 0x32, 0x39, 0x39, 0xc1, 0x81, 0x6e, 0xef, 0xf2, 0xf8,
|
||
|
0x81, 0x20, 0x98, 0x3f, 0x36, 0xa0, 0x1c, 0x39, 0xa1, 0xa3, 0xba, 0x3f, 0xfa, 0x92, 0x6e, 0x4c,
|
||
|
0xbb, 0x47, 0x27, 0x51, 0xd0, 0x6b, 0x50, 0x0e, 0xf0, 0x19, 0xb7, 0x13, 0xc6, 0xa8, 0xef, 0x0d,
|
||
|
0xf3, 0x82, 0xbc, 0x17, 0x19, 0xb4, 0x0d, 0xc5, 0x03, 0x42, 0x7a, 0x6b, 0x98, 0x3b, 0x7e, 0x4f,
|
||
|
0xbe, 0xcf, 0x09, 0x6d, 0xc9, 0x68, 0xe6, 0x05, 0x41, 0x46, 0xf2, 0x15, 0x28, 0x49, 0xe6, 0x29,
|
||
|
0xa6, 0x2c, 0xdc, 0x55, 0x0b, 0x56, 0x51, 0xd0, 0x0e, 0x15, 0x49, 0x74, 0xf4, 0xb2, 0xce, 0x4e,
|
||
|
0x34, 0xda, 0x0f, 0xb5, 0x98, 0xab, 0x74, 0xe8, 0xb2, 0xb9, 0x9b, 0xd6, 0xc1, 0x84, 0x79, 0x4a,
|
||
|
0x57, 0xc2, 0x56, 0xdd, 0xa5, 0x7d, 0x57, 0xdb, 0x92, 0x57, 0x84, 0x4d, 0x57, 0x8c, 0x5b, 0xa9,
|
||
|
0xd4, 0x0f, 0x4e, 0x49, 0xc7, 0x09, 0x4f, 0xe9, 0xe1, 0x2c, 0x38, 0x9b, 0x11, 0x63, 0xd3, 0x45,
|
||
|
0x2b, 0x70, 0xab, 0x43, 0x28, 0xc5, 0x3d, 0x87, 0x63, 0x37, 0x21, 0xc3, 0x84, 0x90, 0x4a, 0xe2,
|
||
|
0xcd, 0xf8, 0x40, 0x2c, 0xca, 0x36, 0xdd, 0xc6, 0x6f, 0x0c, 0x28, 0xb4, 0x42, 0xa3, 0xd1, 0xcf,
|
||
|
0x0d, 0xc8, 0xe9, 0x9d, 0x04, 0x7d, 0x6d, 0xe2, 0xad, 0x4d, 0x06, 0xae, 0x7a, 0x3b, 0x94, 0x4b,
|
||
|
0x7c, 0xa2, 0xad, 0x45, 0x1b, 0x8e, 0xf9, 0xe6, 0xf7, 0xfe, 0xf6, 0xcf, 0xcf, 0x32, 0x75, 0x73,
|
||
|
0x39, 0xfc, 0x5c, 0xfc, 0x68, 0xe4, 0x12, 0xbc, 0xbd, 0xbc, 0xfc, 0xb8, 0xae, 0xe2, 0xc0, 0x56,
|
||
|
0x94, 0x2a, 0xbc, 0x62, 0x2c, 0x37, 0x3e, 0xcf, 0x42, 0x51, 0x0d, 0x26, 0xf9, 0x16, 0x80, 0xfe,
|
||
|
0xa5, 0x4a, 0x71, 0xe4, 0x6b, 0xc4, 0x37, 0xd3, 0x5a, 0x7c, 0xf9, 0x2a, 0x51, 0x9d, 0x6a, 0x42,
|
||
|
0x9a, 0x1f, 0x4b, 0x87, 0x1e, 0xa2, 0x07, 0x4f, 0x75, 0x48, 0x09, 0xb0, 0xfa, 0xa3, 0x91, 0x99,
|
||
|
0x5f, 0xeb, 0x3a, 0xac, 0xfb, 0x78, 0x9c, 0x18, 0x7f, 0x86, 0x79, 0x8c, 0xfe, 0x63, 0x00, 0xba,
|
||
|
0xb8, 0x68, 0xa0, 0xfb, 0x93, 0xf5, 0xe9, 0x67, 0xe7, 0x31, 0x91, 0x1e, 0xfb, 0xd5, 0xe7, 0xe6,
|
||
|
0xf1, 0xca, 0xe8, 0x02, 0xd3, 0xf8, 0xc5, 0x2c, 0xdc, 0x6a, 0xaa, 0x51, 0x78, 0xdf, 0x75, 0x29,
|
||
|
0x66, 0x4c, 0xbc, 0x1f, 0xed, 0x73, 0x42, 0xc5, 0x92, 0xf9, 0x17, 0x03, 0x16, 0xc6, 0x37, 0x00,
|
||
|
0xf4, 0x4e, 0xfa, 0x8f, 0x8e, 0x97, 0xae, 0x33, 0xd5, 0x6f, 0x4d, 0x0f, 0xa0, 0x3a, 0xa3, 0x79,
|
||
|
0x4f, 0x86, 0xe9, 0x8e, 0xf9, 0xfa, 0xff, 0x08, 0x93, 0x98, 0x26, 0x6c, 0xe5, 0x38, 0x86, 0x58,
|
||
|
0x31, 0x96, 0xa5, 0x43, 0xe3, 0x63, 0x2e, 0xbd, 0x43, 0x4f, 0xd8, 0x06, 0xd2, 0x3b, 0xf4, 0xa4,
|
||
|
0x09, 0x3b, 0x81, 0x43, 0x47, 0x31, 0x84, 0x70, 0xe8, 0xef, 0x06, 0xe4, 0xf4, 0xdc, 0x48, 0xdf,
|
||
|
0x56, 0x46, 0xa7, 0x65, 0xf5, 0xde, 0xc4, 0x72, 0xda, 0xea, 0x8f, 0xa4, 0xd5, 0x87, 0xe8, 0xe0,
|
||
|
0x69, 0x56, 0xd7, 0x1f, 0x25, 0x26, 0x6d, 0x58, 0xa3, 0x49, 0x52, 0xb2, 0x42, 0x3d, 0xa5, 0x65,
|
||
|
0xf5, 0x4f, 0x06, 0x2c, 0x77, 0x48, 0x3f, 0xa5, 0x71, 0xab, 0x37, 0x2c, 0x49, 0x8f, 0x3a, 0xee,
|
||
|
0x1e, 0x25, 0x9c, 0xec, 0x19, 0x0f, 0xdb, 0x5a, 0xde, 0x23, 0x3d, 0x27, 0xf0, 0x6a, 0x84, 0x7a,
|
||
|
0x75, 0x0f, 0x07, 0xf2, 0x6f, 0x91, 0xba, 0x62, 0x39, 0x03, 0x9f, 0x3d, 0xed, 0xaf, 0xb7, 0xb7,
|
||
|
0xc6, 0xc8, 0xbf, 0xce, 0x64, 0xad, 0xd6, 0x83, 0xdf, 0x65, 0x6e, 0x6f, 0x28, 0xf4, 0x31, 0xe5,
|
||
|
0xb5, 0xc3, 0x3b, 0x07, 0x98, 0xf1, 0xa3, 0x39, 0xa9, 0xe7, 0xee, 0x7f, 0x03, 0x00, 0x00, 0xff,
|
||
|
0xff, 0xf0, 0x8a, 0x2f, 0x43, 0xe1, 0x1b, 0x00, 0x00,
|
||
|
}
|