swarming/proto/config/pools.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: go.chromium.org/luci/swarming/proto/config/pools.proto

package configpb

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	_ "go.chromium.org/luci/common/proto"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

// Schema for pools.cfg service config file in luci-config.
//
// It defined a set of Pool objects, each one corresponding to a single Swarming
// pool dimension. Each Swarming task resided in some pool, and each Swarming
// bot belongs to at least one pool.
//
// Pools are used to isolate groups of tasks/bots from each other for security
// and capacity reasons. Two different pools should not interfere with each
// other at all (unless explicitly configured to share bots or accounts).
type PoolsCfg struct {
	// List of all defined pools.
	Pool []*Pool `protobuf:"bytes,1,rep,name=pool,proto3" json:"pool,omitempty"`
	// Configures the default isolate and CIPD services to use for all pools on
	// this server.
	DefaultExternalServices *ExternalServices `protobuf:"bytes,6,opt,name=default_external_services,json=defaultExternalServices,proto3" json:"default_external_services,omitempty"`
	// This is the "shared namespace" of task templates.
	//
	// Task templates allow pools to specify some property defaults (particularly
	// around caches, CIPD packages and Environment variables) for tasks created
	// within the pool. These templates can have 'include' statements, and those
	// include statements draw from this namespace.
	//
	// Swarming will do a 2-pass parse of these so order doesn't matter (i.e. If
	// A includes B, but is defined B-then-A, it's not an error).
	TaskTemplate []*TaskTemplate `protobuf:"bytes,3,rep,name=task_template,json=taskTemplate,proto3" json:"task_template,omitempty"`
	// This is the "shared namespace" of deployments.
	//
	// When pools specify a task_template_deployment, it draws from this
	// namespace.
	TaskTemplateDeployment []*TaskTemplateDeployment `protobuf:"bytes,4,rep,name=task_template_deployment,json=taskTemplateDeployment,proto3" json:"task_template_deployment,omitempty"`
	// Defines about how to monitor bots in a pool. Each pool above may refer to
	// one of the BotMonitoring message by name, which permits reusing
	// BotMonitoring definitions.
	BotMonitoring        []*BotMonitoring `protobuf:"bytes,5,rep,name=bot_monitoring,json=botMonitoring,proto3" json:"bot_monitoring,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *PoolsCfg) Reset()         { *m = PoolsCfg{} }
func (m *PoolsCfg) String() string { return proto.CompactTextString(m) }
func (*PoolsCfg) ProtoMessage()    {}
func (*PoolsCfg) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{0}
}

func (m *PoolsCfg) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PoolsCfg.Unmarshal(m, b)
}
func (m *PoolsCfg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PoolsCfg.Marshal(b, m, deterministic)
}
func (m *PoolsCfg) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PoolsCfg.Merge(m, src)
}
func (m *PoolsCfg) XXX_Size() int {
	return xxx_messageInfo_PoolsCfg.Size(m)
}
func (m *PoolsCfg) XXX_DiscardUnknown() {
	xxx_messageInfo_PoolsCfg.DiscardUnknown(m)
}

var xxx_messageInfo_PoolsCfg proto.InternalMessageInfo

func (m *PoolsCfg) GetPool() []*Pool {
	if m != nil {
		return m.Pool
	}
	return nil
}

func (m *PoolsCfg) GetDefaultExternalServices() *ExternalServices {
	if m != nil {
		return m.DefaultExternalServices
	}
	return nil
}

func (m *PoolsCfg) GetTaskTemplate() []*TaskTemplate {
	if m != nil {
		return m.TaskTemplate
	}
	return nil
}

func (m *PoolsCfg) GetTaskTemplateDeployment() []*TaskTemplateDeployment {
	if m != nil {
		return m.TaskTemplateDeployment
	}
	return nil
}

func (m *PoolsCfg) GetBotMonitoring() []*BotMonitoring {
	if m != nil {
		return m.BotMonitoring
	}
	return nil
}

// Properties of a single pool or a bunch of identically configured pools.
//
// In particular contains authorization configuration.
type Pool struct {
	// Names of the pools this config applies to.
	//
	// Tasks target the pool by specifying its name as 'pool' dimension, thus
	// names here should be valid dimension value.
	Name []string `protobuf:"bytes,1,rep,name=name,proto3" json:"name,omitempty"`
	// Contact information for people that own this pool.
	//
	// Not used in any ACLs, just informational field.
	Owners []string `protobuf:"bytes,2,rep,name=owners,proto3" json:"owners,omitempty"`
	// Defines who can schedule tasks in this pool.
	//
	// The checks here act as a second authorization layer, consulted after the
	// first server-global one (defined based on groups set in settings.cfg, see
	// AuthSettings in config.proto).
	Schedulers *Schedulers `protobuf:"bytes,3,opt,name=schedulers,proto3" json:"schedulers,omitempty"`
	// List of service account emails allowed to be used for tasks that target
	// this pool. Tasks specify the service account via 'service_account' field
	// in the tasks.New RPC.
	//
	// By associating accounts with pools in the config we make it more explicit
	// that a bot belonging to a pool eventually can get access to service
	// accounts of all tasks running in this pool (just by sitting there, grabbing
	// tasks and sniffing service account tokens).
	AllowedServiceAccount []string `protobuf:"bytes,4,rep,name=allowed_service_account,json=allowedServiceAccount,proto3" json:"allowed_service_account,omitempty"`
	// Same as 'allowed_service_account', but the set of service accounts is
	// specified through an auth group.
	AllowedServiceAccountGroup []string `protobuf:"bytes,5,rep,name=allowed_service_account_group,json=allowedServiceAccountGroup,proto3" json:"allowed_service_account_group,omitempty"`
	// Types that are valid to be assigned to TaskDeploymentScheme:
	//	*Pool_TaskTemplateDeployment
	//	*Pool_TaskTemplateDeploymentInline
	TaskDeploymentScheme isPool_TaskDeploymentScheme `protobuf_oneof:"task_deployment_scheme"`
	// Refer to one bot_monitoring at the file level by name.
	BotMonitoring string `protobuf:"bytes,8,opt,name=bot_monitoring,json=botMonitoring,proto3" json:"bot_monitoring,omitempty"`
	// If specified, this is the description of the external schedulers to be used
	// for tasks and bots for this pool that match the dimension set of a scheduler.
	// For a given task or bot, the first entry in this list that matches based on
	// dimension eligibility will be used.
	ExternalSchedulers   []*ExternalSchedulerConfig `protobuf:"bytes,9,rep,name=external_schedulers,json=externalSchedulers,proto3" json:"external_schedulers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *Pool) Reset()         { *m = Pool{} }
func (m *Pool) String() string { return proto.CompactTextString(m) }
func (*Pool) ProtoMessage()    {}
func (*Pool) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{1}
}

func (m *Pool) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Pool.Unmarshal(m, b)
}
func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Pool.Marshal(b, m, deterministic)
}
func (m *Pool) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Pool.Merge(m, src)
}
func (m *Pool) XXX_Size() int {
	return xxx_messageInfo_Pool.Size(m)
}
func (m *Pool) XXX_DiscardUnknown() {
	xxx_messageInfo_Pool.DiscardUnknown(m)
}

var xxx_messageInfo_Pool proto.InternalMessageInfo

func (m *Pool) GetName() []string {
	if m != nil {
		return m.Name
	}
	return nil
}

func (m *Pool) GetOwners() []string {
	if m != nil {
		return m.Owners
	}
	return nil
}

func (m *Pool) GetSchedulers() *Schedulers {
	if m != nil {
		return m.Schedulers
	}
	return nil
}

func (m *Pool) GetAllowedServiceAccount() []string {
	if m != nil {
		return m.AllowedServiceAccount
	}
	return nil
}

func (m *Pool) GetAllowedServiceAccountGroup() []string {
	if m != nil {
		return m.AllowedServiceAccountGroup
	}
	return nil
}

type isPool_TaskDeploymentScheme interface {
	isPool_TaskDeploymentScheme()
}

type Pool_TaskTemplateDeployment struct {
	TaskTemplateDeployment string `protobuf:"bytes,6,opt,name=task_template_deployment,json=taskTemplateDeployment,proto3,oneof"`
}

type Pool_TaskTemplateDeploymentInline struct {
	TaskTemplateDeploymentInline *TaskTemplateDeployment `protobuf:"bytes,7,opt,name=task_template_deployment_inline,json=taskTemplateDeploymentInline,proto3,oneof"`
}

func (*Pool_TaskTemplateDeployment) isPool_TaskDeploymentScheme() {}

func (*Pool_TaskTemplateDeploymentInline) isPool_TaskDeploymentScheme() {}

func (m *Pool) GetTaskDeploymentScheme() isPool_TaskDeploymentScheme {
	if m != nil {
		return m.TaskDeploymentScheme
	}
	return nil
}

func (m *Pool) GetTaskTemplateDeployment() string {
	if x, ok := m.GetTaskDeploymentScheme().(*Pool_TaskTemplateDeployment); ok {
		return x.TaskTemplateDeployment
	}
	return ""
}

func (m *Pool) GetTaskTemplateDeploymentInline() *TaskTemplateDeployment {
	if x, ok := m.GetTaskDeploymentScheme().(*Pool_TaskTemplateDeploymentInline); ok {
		return x.TaskTemplateDeploymentInline
	}
	return nil
}

func (m *Pool) GetBotMonitoring() string {
	if m != nil {
		return m.BotMonitoring
	}
	return ""
}

func (m *Pool) GetExternalSchedulers() []*ExternalSchedulerConfig {
	if m != nil {
		return m.ExternalSchedulers
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Pool) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Pool_TaskTemplateDeployment)(nil),
		(*Pool_TaskTemplateDeploymentInline)(nil),
	}
}

// Defines who can schedule tasks in a pool.
type Schedulers struct {
	// Emails of individual end-users.
	//
	// Useful to avoid creating one-person groups.
	User []string `protobuf:"bytes,1,rep,name=user,proto3" json:"user,omitempty"`
	// List of groups with end-users.
	Group []string `protobuf:"bytes,2,rep,name=group,proto3" json:"group,omitempty"`
	// See TrustedDelegation comment.
	TrustedDelegation    []*TrustedDelegation `protobuf:"bytes,3,rep,name=trusted_delegation,json=trustedDelegation,proto3" json:"trusted_delegation,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Schedulers) Reset()         { *m = Schedulers{} }
func (m *Schedulers) String() string { return proto.CompactTextString(m) }
func (*Schedulers) ProtoMessage()    {}
func (*Schedulers) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{2}
}

func (m *Schedulers) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Schedulers.Unmarshal(m, b)
}
func (m *Schedulers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Schedulers.Marshal(b, m, deterministic)
}
func (m *Schedulers) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Schedulers.Merge(m, src)
}
func (m *Schedulers) XXX_Size() int {
	return xxx_messageInfo_Schedulers.Size(m)
}
func (m *Schedulers) XXX_DiscardUnknown() {
	xxx_messageInfo_Schedulers.DiscardUnknown(m)
}

var xxx_messageInfo_Schedulers proto.InternalMessageInfo

func (m *Schedulers) GetUser() []string {
	if m != nil {
		return m.User
	}
	return nil
}

func (m *Schedulers) GetGroup() []string {
	if m != nil {
		return m.Group
	}
	return nil
}

func (m *Schedulers) GetTrustedDelegation() []*TrustedDelegation {
	if m != nil {
		return m.TrustedDelegation
	}
	return nil
}

// Defines a delegatee trusted to make authorization decisions for who can use
// a pool.
//
// This is based on LUCI delegation protocol. Imagine an end user U calling
// Swarming through an intermediary service X. In this case U is a delegator and
// X is a delegatee. When X calls Swarming, it makes an RPC to the token server
// to make a delegation token that says "<X can call Swarming on behalf of U>".
//
// This token is then sent to the Swarming with the RPC. Swarming sees that
// the direct peer it's talking to is X, but the call should be performed under
// the authority of U.
//
// We extend this to also allow X make authorization decisions about whether U
// can use particular Swarming resource or not. The result of this decision is
// encoded in the delegation token as a set of "key:value" tags. Swarming then
// can treat presence of such tags as a signal that the particular call is
// allowed.
//
// In this scenario we totally trust X to make the correct decision.
type TrustedDelegation struct {
	// Email of a trusted delegatee (the one who's minting the delegation token).
	PeerId string `protobuf:"bytes,1,opt,name=peer_id,json=peerId,proto3" json:"peer_id,omitempty"`
	// A list of tags to expected in the delegation token to allow the usage of
	// a pool.
	//
	// Presence of any of the specified tags are enough. The format of these tags
	// generally depends on what service is doing the delegation.
	RequireAnyOf         *TrustedDelegation_TagList `protobuf:"bytes,2,opt,name=require_any_of,json=requireAnyOf,proto3" json:"require_any_of,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

func (m *TrustedDelegation) Reset()         { *m = TrustedDelegation{} }
func (m *TrustedDelegation) String() string { return proto.CompactTextString(m) }
func (*TrustedDelegation) ProtoMessage()    {}
func (*TrustedDelegation) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{3}
}

func (m *TrustedDelegation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TrustedDelegation.Unmarshal(m, b)
}
func (m *TrustedDelegation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TrustedDelegation.Marshal(b, m, deterministic)
}
func (m *TrustedDelegation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrustedDelegation.Merge(m, src)
}
func (m *TrustedDelegation) XXX_Size() int {
	return xxx_messageInfo_TrustedDelegation.Size(m)
}
func (m *TrustedDelegation) XXX_DiscardUnknown() {
	xxx_messageInfo_TrustedDelegation.DiscardUnknown(m)
}

var xxx_messageInfo_TrustedDelegation proto.InternalMessageInfo

func (m *TrustedDelegation) GetPeerId() string {
	if m != nil {
		return m.PeerId
	}
	return ""
}

func (m *TrustedDelegation) GetRequireAnyOf() *TrustedDelegation_TagList {
	if m != nil {
		return m.RequireAnyOf
	}
	return nil
}

type TrustedDelegation_TagList struct {
	Tag                  []string `protobuf:"bytes,1,rep,name=tag,proto3" json:"tag,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TrustedDelegation_TagList) Reset()         { *m = TrustedDelegation_TagList{} }
func (m *TrustedDelegation_TagList) String() string { return proto.CompactTextString(m) }
func (*TrustedDelegation_TagList) ProtoMessage()    {}
func (*TrustedDelegation_TagList) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{3, 0}
}

func (m *TrustedDelegation_TagList) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TrustedDelegation_TagList.Unmarshal(m, b)
}
func (m *TrustedDelegation_TagList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TrustedDelegation_TagList.Marshal(b, m, deterministic)
}
func (m *TrustedDelegation_TagList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TrustedDelegation_TagList.Merge(m, src)
}
func (m *TrustedDelegation_TagList) XXX_Size() int {
	return xxx_messageInfo_TrustedDelegation_TagList.Size(m)
}
func (m *TrustedDelegation_TagList) XXX_DiscardUnknown() {
	xxx_messageInfo_TrustedDelegation_TagList.DiscardUnknown(m)
}

var xxx_messageInfo_TrustedDelegation_TagList proto.InternalMessageInfo

func (m *TrustedDelegation_TagList) GetTag() []string {
	if m != nil {
		return m.Tag
	}
	return nil
}

// A TaskTemplate describes a set of properties (caches, CIPD packages and
// envvars) which apply to tasks created within a swarming pool.
//
// TaskTemplates may either be defined inline inside of
// a TaskTemplateDeployment, or in "shared namespace" of the
// PoolsCfg.task_template field.
//
// TaskTemplates may also include other TaskTemplates by name from the "shared
// namespace" in PoolsCfg. Swarming calculates the final value for a given
// TaskTemplate by applying all of its `include` fields depth-first, and then by
// applying the properties in the body of the TaskTemplate. Includes may never
// be repeated, including transitively. This means that "diamond shaped
// dependencies" are forbidden (i.e. A<-B<-D and A<-C<-D would be forbidden
// because `A` is included in `D` twice (via both C and B)).
type TaskTemplate struct {
	// This gives the template a name for the 'include' field below. This only
	// applies to templates defined within the PoolsCfg message (i.e. the
	// top-level message), not to templates inlined into a TaskTemplateDeployment.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Includes properties from the named other TaskTemplate. This can only
	// include templates defined in the top-level PoolsCfg message.
	Include []string `protobuf:"bytes,2,rep,name=include,proto3" json:"include,omitempty"`
	// CacheEntries are keyed by `name`, and `path` is overridden wholesale.
	//
	// It is illegal to have any TaskTemplate with multiple cache entries mapping
	// to the same path. It is illegal to have any cache paths overlap with cipd
	// package paths.
	Cache []*TaskTemplate_CacheEntry `protobuf:"bytes,3,rep,name=cache,proto3" json:"cache,omitempty"`
	// CipdPackages are keyed by (path, name), and `version` is overridden
	// wholesale.
	//
	// It is illegal to have any cipd paths overlap with cache entry paths.
	CipdPackage []*TaskTemplate_CipdPackage `protobuf:"bytes,4,rep,name=cipd_package,json=cipdPackage,proto3" json:"cipd_package,omitempty"`
	// Env vars are keyed by the `var` field,
	//
	// `value` fields overwrite included values.
	// `soft` fields overwrite included values.
	// `prefix` fields append to included values. For example, Doing:
	//
	//     {name: "1" env { var: "PATH" prefix: "a" }}
	//     {name: "2" env { var: "PATH" prefix: "b" }}
	//     {name: "3" include: "1" include: "2" }
	//
	//  Is equivalent to:
	//
	//     {name: "3" env { var: "PATH" prefix: "a" prefix: "b" }}
	//
	//
	// Full Example:
	//
	//   env {
	//     var: "PATH"
	//     value: "/disable_system_path"
	//     prefix: "a"
	//     prefix: "b"
	//     prefix: "c"
	//     soft: true
	//   }
	//   env {
	//     var: "OTHER"
	//     value: "1"
	//   }
	//   env {
	//     var: "PYTHONPATH"
	//     prefix: "a"
	//   }
	//
	// Results in, essentially:
	//
	//   $PATH=/path/to/a:/path/to/b:/path/to/c:/disable_system_path
	//   $OTHER=1
	//   $PYTHONPATH=/path/to/a:$PYTHONPATH
	Env                  []*TaskTemplate_Env `protobuf:"bytes,5,rep,name=env,proto3" json:"env,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *TaskTemplate) Reset()         { *m = TaskTemplate{} }
func (m *TaskTemplate) String() string { return proto.CompactTextString(m) }
func (*TaskTemplate) ProtoMessage()    {}
func (*TaskTemplate) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{4}
}

func (m *TaskTemplate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskTemplate.Unmarshal(m, b)
}
func (m *TaskTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskTemplate.Marshal(b, m, deterministic)
}
func (m *TaskTemplate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskTemplate.Merge(m, src)
}
func (m *TaskTemplate) XXX_Size() int {
	return xxx_messageInfo_TaskTemplate.Size(m)
}
func (m *TaskTemplate) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskTemplate.DiscardUnknown(m)
}

var xxx_messageInfo_TaskTemplate proto.InternalMessageInfo

func (m *TaskTemplate) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *TaskTemplate) GetInclude() []string {
	if m != nil {
		return m.Include
	}
	return nil
}

func (m *TaskTemplate) GetCache() []*TaskTemplate_CacheEntry {
	if m != nil {
		return m.Cache
	}
	return nil
}

func (m *TaskTemplate) GetCipdPackage() []*TaskTemplate_CipdPackage {
	if m != nil {
		return m.CipdPackage
	}
	return nil
}

func (m *TaskTemplate) GetEnv() []*TaskTemplate_Env {
	if m != nil {
		return m.Env
	}
	return nil
}

type TaskTemplate_CacheEntry struct {
	// The name of the cache (required).
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The path relative to the task root to mount the cache (required).
	Path                 string   `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskTemplate_CacheEntry) Reset()         { *m = TaskTemplate_CacheEntry{} }
func (m *TaskTemplate_CacheEntry) String() string { return proto.CompactTextString(m) }
func (*TaskTemplate_CacheEntry) ProtoMessage()    {}
func (*TaskTemplate_CacheEntry) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{4, 0}
}

func (m *TaskTemplate_CacheEntry) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskTemplate_CacheEntry.Unmarshal(m, b)
}
func (m *TaskTemplate_CacheEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskTemplate_CacheEntry.Marshal(b, m, deterministic)
}
func (m *TaskTemplate_CacheEntry) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskTemplate_CacheEntry.Merge(m, src)
}
func (m *TaskTemplate_CacheEntry) XXX_Size() int {
	return xxx_messageInfo_TaskTemplate_CacheEntry.Size(m)
}
func (m *TaskTemplate_CacheEntry) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskTemplate_CacheEntry.DiscardUnknown(m)
}

var xxx_messageInfo_TaskTemplate_CacheEntry proto.InternalMessageInfo

func (m *TaskTemplate_CacheEntry) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *TaskTemplate_CacheEntry) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

type TaskTemplate_CipdPackage struct {
	// The relative to the task root to unpack the CIPD package. A blank value
	// is permitted and means 'the root directory of the task'.
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
	// The CIPD package name template to use (required).
	Pkg string `protobuf:"bytes,2,opt,name=pkg,proto3" json:"pkg,omitempty"`
	// The version of the CIPD package to use (required).
	Version              string   `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskTemplate_CipdPackage) Reset()         { *m = TaskTemplate_CipdPackage{} }
func (m *TaskTemplate_CipdPackage) String() string { return proto.CompactTextString(m) }
func (*TaskTemplate_CipdPackage) ProtoMessage()    {}
func (*TaskTemplate_CipdPackage) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{4, 1}
}

func (m *TaskTemplate_CipdPackage) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskTemplate_CipdPackage.Unmarshal(m, b)
}
func (m *TaskTemplate_CipdPackage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskTemplate_CipdPackage.Marshal(b, m, deterministic)
}
func (m *TaskTemplate_CipdPackage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskTemplate_CipdPackage.Merge(m, src)
}
func (m *TaskTemplate_CipdPackage) XXX_Size() int {
	return xxx_messageInfo_TaskTemplate_CipdPackage.Size(m)
}
func (m *TaskTemplate_CipdPackage) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskTemplate_CipdPackage.DiscardUnknown(m)
}

var xxx_messageInfo_TaskTemplate_CipdPackage proto.InternalMessageInfo

func (m *TaskTemplate_CipdPackage) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *TaskTemplate_CipdPackage) GetPkg() string {
	if m != nil {
		return m.Pkg
	}
	return ""
}

func (m *TaskTemplate_CipdPackage) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

type TaskTemplate_Env struct {
	// The envvar you want to set (required).
	Var string `protobuf:"bytes,1,opt,name=var,proto3" json:"var,omitempty"`
	// The envvar value you want to set. Any prefixes are prepended to this
	// value. If the value is unset, prefixes will be prepended to the bot's
	// current value of this envvar (see examples)
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	// Paths relative to the task root to prepend to this envvar on the bot.
	// These will be resolved to absolute paths on the bot.
	Prefix []string `protobuf:"bytes,3,rep,name=prefix,proto3" json:"prefix,omitempty"`
	// If true, tasks setting this EnvVar can overwrite the value and/or the
	// prefix. Otherwise, tasks will not be permitted to to set any env var or
	// env_prefix for this var.
	//
	// This should be True for envvars you expect tasks to extend, like $PATH.
	// Note that this only affects envvar manipulation at the Swarming API
	// level; once the task is running it can (of course) manipulate the env
	// however it wants.
	Soft                 bool     `protobuf:"varint,4,opt,name=soft,proto3" json:"soft,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskTemplate_Env) Reset()         { *m = TaskTemplate_Env{} }
func (m *TaskTemplate_Env) String() string { return proto.CompactTextString(m) }
func (*TaskTemplate_Env) ProtoMessage()    {}
func (*TaskTemplate_Env) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{4, 2}
}

func (m *TaskTemplate_Env) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskTemplate_Env.Unmarshal(m, b)
}
func (m *TaskTemplate_Env) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskTemplate_Env.Marshal(b, m, deterministic)
}
func (m *TaskTemplate_Env) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskTemplate_Env.Merge(m, src)
}
func (m *TaskTemplate_Env) XXX_Size() int {
	return xxx_messageInfo_TaskTemplate_Env.Size(m)
}
func (m *TaskTemplate_Env) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskTemplate_Env.DiscardUnknown(m)
}

var xxx_messageInfo_TaskTemplate_Env proto.InternalMessageInfo

func (m *TaskTemplate_Env) GetVar() string {
	if m != nil {
		return m.Var
	}
	return ""
}

func (m *TaskTemplate_Env) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *TaskTemplate_Env) GetPrefix() []string {
	if m != nil {
		return m.Prefix
	}
	return nil
}

func (m *TaskTemplate_Env) GetSoft() bool {
	if m != nil {
		return m.Soft
	}
	return false
}

// This is a tuple of (prod template, canary template, canary_chance), so that it
// can be referenced from multiple pools simultaneously as a single unit.
type TaskTemplateDeployment struct {
	// This gives the deployment a name for the 'task_template_deployment' field
	// in PoolCfg.
	//
	// When this TaskTemplateDeployment is inlined into another message (e.g.
	// `TaskTemplate.task_template_deployment_inline`), the name field must not be
	// specified.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Most Deployments will have a TaskTemplate with just a single include
	// directive.
	//
	// However, pools which substantially differ from other ones could define an
	// entire template inline without being forced to put it in the shared
	// namespace.
	//
	// The name field in this template (and the canary template) must not be
	// specified.
	Prod *TaskTemplate `protobuf:"bytes,2,opt,name=prod,proto3" json:"prod,omitempty"`
	// The canary template can be defined like the `prod` field above. If this is
	// defined and `canary_chance` is greater than 0, then this template will be
	// selected instead of `prod`.
	Canary *TaskTemplate `protobuf:"bytes,3,opt,name=canary,proto3" json:"canary,omitempty"`
	// range [0, 9999] where each tick corresponds to %0.01 chance of selecting
	// the template. Exactly 0 means 'canary is disabled', meaning that tasks
	// in this pool will always get the prod template.
	//
	// Examples:
	//   * 1     ".01% chance of picking canary"
	//   * 10    ".1% chance of picking canary"
	//   * 100   "1% chance of picking canary"
	//   * 1000  "10% chance of picking canary"
	//   * 5000  "50% chance of picking canary"
	//   * 7500  "75% chance of picking canary"
	//   * 9999  "99.99% chance of picking canary"
	CanaryChance         int32    `protobuf:"varint,4,opt,name=canary_chance,json=canaryChance,proto3" json:"canary_chance,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TaskTemplateDeployment) Reset()         { *m = TaskTemplateDeployment{} }
func (m *TaskTemplateDeployment) String() string { return proto.CompactTextString(m) }
func (*TaskTemplateDeployment) ProtoMessage()    {}
func (*TaskTemplateDeployment) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{5}
}

func (m *TaskTemplateDeployment) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TaskTemplateDeployment.Unmarshal(m, b)
}
func (m *TaskTemplateDeployment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TaskTemplateDeployment.Marshal(b, m, deterministic)
}
func (m *TaskTemplateDeployment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TaskTemplateDeployment.Merge(m, src)
}
func (m *TaskTemplateDeployment) XXX_Size() int {
	return xxx_messageInfo_TaskTemplateDeployment.Size(m)
}
func (m *TaskTemplateDeployment) XXX_DiscardUnknown() {
	xxx_messageInfo_TaskTemplateDeployment.DiscardUnknown(m)
}

var xxx_messageInfo_TaskTemplateDeployment proto.InternalMessageInfo

func (m *TaskTemplateDeployment) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *TaskTemplateDeployment) GetProd() *TaskTemplate {
	if m != nil {
		return m.Prod
	}
	return nil
}

func (m *TaskTemplateDeployment) GetCanary() *TaskTemplate {
	if m != nil {
		return m.Canary
	}
	return nil
}

func (m *TaskTemplateDeployment) GetCanaryChance() int32 {
	if m != nil {
		return m.CanaryChance
	}
	return 0
}

// Defines about how to monitor bots.
type BotMonitoring struct {
	// Name is used by Pool to describe how to monitor bots in this pool.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Dimension keys to be used to bucket the bots.
	//
	// The algorithm for a key with multiple values is:
	//   def simplify(values):
	//     values = sorted(values)
	//     return '|'.join(
	//         v for i, v in enumerate(values)
	//         if not any(v.startswith(value) for v in values[i+1:]))
	//
	// For example, if 'os' is specified and a bot has the values
	// ['Linux', 'Ubuntu', 'Ubuntu-16.04'], the bucket value used for this bot
	// will be 'Linux|Ubuntu-16.04'.
	//
	// Then whole algorithm then works for each key:
	//   def bucket(keys, bot_dimensions):
	//     return ';'.join(
	//         '%s:%s' % (key, simplify(bot_dimensions.get(values, []))
	//         for key in keys)
	//
	// so the end result may look like: 'os:Linux|Ubuntu-16.04;pool:Testers'.
	//
	// More precisely, when this is used, the other bot dimensions are ignored.
	// 'pool' is always implicit.
	DimensionKey         []string `protobuf:"bytes,2,rep,name=dimension_key,json=dimensionKey,proto3" json:"dimension_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BotMonitoring) Reset()         { *m = BotMonitoring{} }
func (m *BotMonitoring) String() string { return proto.CompactTextString(m) }
func (*BotMonitoring) ProtoMessage()    {}
func (*BotMonitoring) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{6}
}

func (m *BotMonitoring) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BotMonitoring.Unmarshal(m, b)
}
func (m *BotMonitoring) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BotMonitoring.Marshal(b, m, deterministic)
}
func (m *BotMonitoring) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BotMonitoring.Merge(m, src)
}
func (m *BotMonitoring) XXX_Size() int {
	return xxx_messageInfo_BotMonitoring.Size(m)
}
func (m *BotMonitoring) XXX_DiscardUnknown() {
	xxx_messageInfo_BotMonitoring.DiscardUnknown(m)
}

var xxx_messageInfo_BotMonitoring proto.InternalMessageInfo

func (m *BotMonitoring) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *BotMonitoring) GetDimensionKey() []string {
	if m != nil {
		return m.DimensionKey
	}
	return nil
}

// Describes an external scheduler used by a particular swarming pool and
// dimension set, via the external scheduler API.
type ExternalSchedulerConfig struct {
	// Service address of external scheduler.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// Scheduler id within the external scheduler service to use. This value
	// is opaque to swarming.
	Id string `protobuf:"bytes,2,opt,name=id,proto3" json:"id,omitempty"`
	// Dimensions is a list of dimension strings in "key:value" format (e.g.
	// ["os:foo", "featureX:bar"]) that determines eligibility for a bot or task
	// to use this external scheduler. In particular:
	// - a bot will be eligible if it contains all of these dimensions.
	// - a task will be eligible if all its slices contain all these dimensions.
	//
	// Note of care: if this list is empty, that means all requests in the pool
	// are eligible to be forwarded to it.
	//
	// Note: To be deprecated, in favor of: any_dimensions and all_dimensions.
	Dimensions []string `protobuf:"bytes,3,rep,name=dimensions,proto3" json:"dimensions,omitempty"`
	// If not enabled, this external scheduler config will be ignored. This
	// makes it safer to add new configs (the naive approach of adding a config
	// with empty dimentions list would cause all requests to be routed to
	// that config).
	Enabled           bool `protobuf:"varint,4,opt,name=enabled,proto3" json:"enabled,omitempty"`
	FallbackWhenEmpty bool `protobuf:"varint,5,opt,name=fallback_when_empty,json=fallbackWhenEmpty,proto3" json:"fallback_when_empty,omitempty"` // Deprecated: Do not use.
	// A task or bot must have all of these dimensions in order to match this
	// dimension set.
	//
	// Note: Support not yet implemented.
	AllDimensions []string `protobuf:"bytes,6,rep,name=all_dimensions,json=allDimensions,proto3" json:"all_dimensions,omitempty"`
	// If any_dimensions is defined, a task or bot must have any of these
	// dimensions in order to match this dimension set.
	//
	// Note: Support not yet implemented.
	AnyDimensions []string `protobuf:"bytes,7,rep,name=any_dimensions,json=anyDimensions,proto3" json:"any_dimensions,omitempty"`
	// If true, allows the swarming native scheduler to reap tasks that would
	// otherwise be owned by this external scheduler, if the external scheduler
	// returns no results.
	//
	// This field should be enabled temporarily when first turning on a new
	// external scheduler config, to allow tasks that existing prior to that time
	// to still have a chance to run. After prior tasks have aged out of the
	// system, this flag should be disabled, to get stricter consistency between
	// swarming's state and external scheduler's state.
	AllowEsFallback      bool     `protobuf:"varint,8,opt,name=allow_es_fallback,json=allowEsFallback,proto3" json:"allow_es_fallback,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExternalSchedulerConfig) Reset()         { *m = ExternalSchedulerConfig{} }
func (m *ExternalSchedulerConfig) String() string { return proto.CompactTextString(m) }
func (*ExternalSchedulerConfig) ProtoMessage()    {}
func (*ExternalSchedulerConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{7}
}

func (m *ExternalSchedulerConfig) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExternalSchedulerConfig.Unmarshal(m, b)
}
func (m *ExternalSchedulerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExternalSchedulerConfig.Marshal(b, m, deterministic)
}
func (m *ExternalSchedulerConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExternalSchedulerConfig.Merge(m, src)
}
func (m *ExternalSchedulerConfig) XXX_Size() int {
	return xxx_messageInfo_ExternalSchedulerConfig.Size(m)
}
func (m *ExternalSchedulerConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_ExternalSchedulerConfig.DiscardUnknown(m)
}

var xxx_messageInfo_ExternalSchedulerConfig proto.InternalMessageInfo

func (m *ExternalSchedulerConfig) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *ExternalSchedulerConfig) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *ExternalSchedulerConfig) GetDimensions() []string {
	if m != nil {
		return m.Dimensions
	}
	return nil
}

func (m *ExternalSchedulerConfig) GetEnabled() bool {
	if m != nil {
		return m.Enabled
	}
	return false
}

// Deprecated: Do not use.
func (m *ExternalSchedulerConfig) GetFallbackWhenEmpty() bool {
	if m != nil {
		return m.FallbackWhenEmpty
	}
	return false
}

func (m *ExternalSchedulerConfig) GetAllDimensions() []string {
	if m != nil {
		return m.AllDimensions
	}
	return nil
}

func (m *ExternalSchedulerConfig) GetAnyDimensions() []string {
	if m != nil {
		return m.AnyDimensions
	}
	return nil
}

func (m *ExternalSchedulerConfig) GetAllowEsFallback() bool {
	if m != nil {
		return m.AllowEsFallback
	}
	return false
}

type ExternalServices struct {
	Isolate              *ExternalServices_Isolate `protobuf:"bytes,1,opt,name=isolate,proto3" json:"isolate,omitempty"`
	Cipd                 *ExternalServices_CIPD    `protobuf:"bytes,2,opt,name=cipd,proto3" json:"cipd,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *ExternalServices) Reset()         { *m = ExternalServices{} }
func (m *ExternalServices) String() string { return proto.CompactTextString(m) }
func (*ExternalServices) ProtoMessage()    {}
func (*ExternalServices) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{8}
}

func (m *ExternalServices) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExternalServices.Unmarshal(m, b)
}
func (m *ExternalServices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExternalServices.Marshal(b, m, deterministic)
}
func (m *ExternalServices) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExternalServices.Merge(m, src)
}
func (m *ExternalServices) XXX_Size() int {
	return xxx_messageInfo_ExternalServices.Size(m)
}
func (m *ExternalServices) XXX_DiscardUnknown() {
	xxx_messageInfo_ExternalServices.DiscardUnknown(m)
}

var xxx_messageInfo_ExternalServices proto.InternalMessageInfo

func (m *ExternalServices) GetIsolate() *ExternalServices_Isolate {
	if m != nil {
		return m.Isolate
	}
	return nil
}

func (m *ExternalServices) GetCipd() *ExternalServices_CIPD {
	if m != nil {
		return m.Cipd
	}
	return nil
}

type ExternalServices_Isolate struct {
	// (required) URL of the default isolate server to use if it is not
	// specified in the task.
	//
	// Must start with "https://" or "http://".
	//
	// e.g. "https://isolateserver.appspot.com"
	Server string `protobuf:"bytes,1,opt,name=server,proto3" json:"server,omitempty"`
	// (required) Default namespace to use if it is not specified in a task,
	// e.g. "default-gzip"
	Namespace            string   `protobuf:"bytes,2,opt,name=namespace,proto3" json:"namespace,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExternalServices_Isolate) Reset()         { *m = ExternalServices_Isolate{} }
func (m *ExternalServices_Isolate) String() string { return proto.CompactTextString(m) }
func (*ExternalServices_Isolate) ProtoMessage()    {}
func (*ExternalServices_Isolate) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{8, 0}
}

func (m *ExternalServices_Isolate) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExternalServices_Isolate.Unmarshal(m, b)
}
func (m *ExternalServices_Isolate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExternalServices_Isolate.Marshal(b, m, deterministic)
}
func (m *ExternalServices_Isolate) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExternalServices_Isolate.Merge(m, src)
}
func (m *ExternalServices_Isolate) XXX_Size() int {
	return xxx_messageInfo_ExternalServices_Isolate.Size(m)
}
func (m *ExternalServices_Isolate) XXX_DiscardUnknown() {
	xxx_messageInfo_ExternalServices_Isolate.DiscardUnknown(m)
}

var xxx_messageInfo_ExternalServices_Isolate proto.InternalMessageInfo

func (m *ExternalServices_Isolate) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

func (m *ExternalServices_Isolate) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type ExternalServices_CIPD struct {
	// (required) URL of the default CIPD server to use, if it is not specified
	// in the task.
	//
	// Must start with "https://" or "http://".
	//
	// e.g. "https://chrome-infra-packages.appspot.com"
	Server string `protobuf:"bytes,1,opt,name=server,proto3" json:"server,omitempty"`
	// (required) The version of the cipd client to use. This is the
	// 'infra/tools/cipd/${platform}' package, but because it's part of the
	// bootstrap needs special logic to handle its installation.
	ClientVersion        string   `protobuf:"bytes,2,opt,name=client_version,json=clientVersion,proto3" json:"client_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExternalServices_CIPD) Reset()         { *m = ExternalServices_CIPD{} }
func (m *ExternalServices_CIPD) String() string { return proto.CompactTextString(m) }
func (*ExternalServices_CIPD) ProtoMessage()    {}
func (*ExternalServices_CIPD) Descriptor() ([]byte, []int) {
	return fileDescriptor_34aa853d71145463, []int{8, 1}
}

func (m *ExternalServices_CIPD) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExternalServices_CIPD.Unmarshal(m, b)
}
func (m *ExternalServices_CIPD) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExternalServices_CIPD.Marshal(b, m, deterministic)
}
func (m *ExternalServices_CIPD) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExternalServices_CIPD.Merge(m, src)
}
func (m *ExternalServices_CIPD) XXX_Size() int {
	return xxx_messageInfo_ExternalServices_CIPD.Size(m)
}
func (m *ExternalServices_CIPD) XXX_DiscardUnknown() {
	xxx_messageInfo_ExternalServices_CIPD.DiscardUnknown(m)
}

var xxx_messageInfo_ExternalServices_CIPD proto.InternalMessageInfo

func (m *ExternalServices_CIPD) GetServer() string {
	if m != nil {
		return m.Server
	}
	return ""
}

func (m *ExternalServices_CIPD) GetClientVersion() string {
	if m != nil {
		return m.ClientVersion
	}
	return ""
}

func init() {
	proto.RegisterType((*PoolsCfg)(nil), "swarming.config.PoolsCfg")
	proto.RegisterType((*Pool)(nil), "swarming.config.Pool")
	proto.RegisterType((*Schedulers)(nil), "swarming.config.Schedulers")
	proto.RegisterType((*TrustedDelegation)(nil), "swarming.config.TrustedDelegation")
	proto.RegisterType((*TrustedDelegation_TagList)(nil), "swarming.config.TrustedDelegation.TagList")
	proto.RegisterType((*TaskTemplate)(nil), "swarming.config.TaskTemplate")
	proto.RegisterType((*TaskTemplate_CacheEntry)(nil), "swarming.config.TaskTemplate.CacheEntry")
	proto.RegisterType((*TaskTemplate_CipdPackage)(nil), "swarming.config.TaskTemplate.CipdPackage")
	proto.RegisterType((*TaskTemplate_Env)(nil), "swarming.config.TaskTemplate.Env")
	proto.RegisterType((*TaskTemplateDeployment)(nil), "swarming.config.TaskTemplateDeployment")
	proto.RegisterType((*BotMonitoring)(nil), "swarming.config.BotMonitoring")
	proto.RegisterType((*ExternalSchedulerConfig)(nil), "swarming.config.ExternalSchedulerConfig")
	proto.RegisterType((*ExternalServices)(nil), "swarming.config.ExternalServices")
	proto.RegisterType((*ExternalServices_Isolate)(nil), "swarming.config.ExternalServices.Isolate")
	proto.RegisterType((*ExternalServices_CIPD)(nil), "swarming.config.ExternalServices.CIPD")
}

func init() {
	proto.RegisterFile("go.chromium.org/luci/swarming/proto/config/pools.proto", fileDescriptor_34aa853d71145463)
}

var fileDescriptor_34aa853d71145463 = []byte{
	// 1159 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x56, 0x4f, 0x73, 0x1b, 0x35,
	0x14, 0xaf, 0xff, 0xc4, 0x8e, 0x5f, 0xec, 0xb4, 0x51, 0x69, 0xb3, 0xb8, 0x7f, 0x68, 0x9d, 0x29,
	0x24, 0x9d, 0xc1, 0x1e, 0x12, 0xe8, 0x21, 0x9d, 0x81, 0x49, 0x1c, 0x43, 0x02, 0xed, 0x10, 0xd4,
	0x0c, 0x4c, 0x99, 0x61, 0x76, 0xe4, 0x5d, 0x79, 0xbd, 0xe3, 0x5d, 0x49, 0xac, 0x64, 0xa7, 0xbe,
	0x70, 0x86, 0xcf, 0xd0, 0x1b, 0x57, 0xae, 0xdc, 0xf8, 0x30, 0x7c, 0x13, 0x86, 0x91, 0x56, 0x6b,
	0xbb, 0xb1, 0x1d, 0xf7, 0xb4, 0x7a, 0xef, 0xfd, 0xde, 0x4f, 0xda, 0xf7, 0x4f, 0x82, 0x67, 0x01,
	0x6f, 0x7a, 0xfd, 0x84, 0xc7, 0xe1, 0x30, 0x6e, 0xf2, 0x24, 0x68, 0x45, 0x43, 0x2f, 0x6c, 0xc9,
	0x4b, 0x92, 0xc4, 0x21, 0x0b, 0x5a, 0x22, 0xe1, 0x8a, 0xb7, 0x3c, 0xce, 0x7a, 0x61, 0xd0, 0x12,
	0x9c, 0x47, 0xb2, 0x69, 0x54, 0xe8, 0x66, 0x06, 0x69, 0xa6, 0xc6, 0x7a, 0x6b, 0x21, 0x91, 0xc7,
	0xe3, 0x98, 0x33, 0x4b, 0xc3, 0x85, 0x0a, 0x39, 0xb3, 0x0c, 0x8d, 0xdf, 0x0b, 0xb0, 0x7e, 0xae,
	0x19, 0xdb, 0xbd, 0x00, 0xed, 0x41, 0x51, 0xb3, 0x3b, 0xb9, 0x47, 0x85, 0xdd, 0x8d, 0xfd, 0x3b,
	0xcd, 0x2b, 0xec, 0x4d, 0x0d, 0xc4, 0x06, 0x82, 0x7e, 0x81, 0x0f, 0x7d, 0xda, 0x23, 0xc3, 0x48,
	0xb9, 0xf4, 0x8d, 0xa2, 0x09, 0x23, 0x91, 0x2b, 0x69, 0x32, 0x0a, 0x3d, 0x2a, 0x9d, 0xd2, 0xa3,
	0xdc, 0xee, 0xc6, 0xfe, 0xe3, 0x39, 0xff, 0x8e, 0x45, 0xbe, 0xb2, 0x40, 0xbc, 0x6d, 0x39, 0xae,
	0x1a, 0xd0, 0x31, 0xd4, 0x14, 0x91, 0x03, 0x57, 0xd1, 0x58, 0x44, 0x44, 0x51, 0xa7, 0x60, 0x8e,
	0xf4, 0x60, 0x8e, 0xf2, 0x82, 0xc8, 0xc1, 0x85, 0x05, 0xe1, 0xaa, 0x9a, 0x91, 0x10, 0x01, 0xe7,
	0x1d, 0x0e, 0xd7, 0xa7, 0x22, 0xe2, 0xe3, 0x98, 0x32, 0xe5, 0x14, 0x0d, 0xdd, 0x27, 0xd7, 0xd2,
	0x9d, 0x4c, 0xe0, 0xf8, 0xae, 0x5a, 0xa8, 0x47, 0x1d, 0xd8, 0xec, 0x72, 0xe5, 0xc6, 0x9c, 0x85,
	0x8a, 0x27, 0x21, 0x0b, 0x9c, 0x35, 0x43, 0xfc, 0x70, 0x8e, 0xf8, 0x98, 0xab, 0x97, 0x13, 0x14,
	0xae, 0x75, 0x67, 0xc5, 0x6f, 0x8b, 0xeb, 0xf9, 0x5b, 0x85, 0xc6, 0xdf, 0x45, 0x28, 0xea, 0x08,
	0x23, 0x04, 0x45, 0x46, 0x62, 0x6a, 0xd2, 0x50, 0xc1, 0x66, 0x8d, 0xee, 0x42, 0x89, 0x5f, 0x32,
	0x9a, 0x48, 0x27, 0x6f, 0xb4, 0x56, 0x42, 0xcf, 0x01, 0xa4, 0xd7, 0xa7, 0xfe, 0x30, 0xd2, 0xb6,
	0x82, 0x09, 0xfc, 0xbd, 0xb9, 0xdd, 0x5f, 0x4d, 0x20, 0x78, 0x06, 0x8e, 0x9e, 0xc1, 0x36, 0x89,
	0x22, 0x7e, 0x49, 0xfd, 0x2c, 0x77, 0x2e, 0xf1, 0x3c, 0x3e, 0xb4, 0x01, 0xaa, 0xe0, 0x3b, 0xd6,
	0x6c, 0xf3, 0x72, 0x94, 0x1a, 0xd1, 0x11, 0x3c, 0x58, 0xe2, 0xe7, 0x06, 0x09, 0x1f, 0x0a, 0x13,
	0x85, 0x0a, 0xae, 0x2f, 0xf4, 0xfe, 0x46, 0x23, 0xd0, 0xe1, 0x35, 0xc9, 0xd1, 0xe5, 0x53, 0x39,
	0xbd, 0xb1, 0x34, 0xea, 0x02, 0x3e, 0x5a, 0xe6, 0xeb, 0x86, 0x2c, 0x0a, 0x19, 0x75, 0xca, 0x26,
	0x10, 0xef, 0x9b, 0xdf, 0xd3, 0x1b, 0xf8, 0xfe, 0xe2, 0xbd, 0xce, 0x0c, 0x1d, 0x7a, 0x32, 0x97,
	0xe7, 0x75, 0x7d, 0xc6, 0x2b, 0x79, 0x44, 0xaf, 0xe1, 0xf6, 0xb4, 0x19, 0xa6, 0x59, 0xa9, 0x98,
	0x9a, 0xd8, 0x5d, 0xde, 0x0e, 0x19, 0xb4, 0x6d, 0xf4, 0x18, 0xd1, 0xab, 0x06, 0x79, 0xec, 0x80,
	0x89, 0xc6, 0xec, 0xaf, 0xea, 0x1d, 0x62, 0xda, 0xf8, 0x23, 0x07, 0x30, 0x05, 0xea, 0xe2, 0x19,
	0x4a, 0x9a, 0x64, 0xc5, 0xa3, 0xd7, 0xe8, 0x03, 0x58, 0x4b, 0xf3, 0x92, 0xd6, 0x4e, 0x2a, 0xa0,
	0x1f, 0x00, 0xa9, 0x64, 0x28, 0x15, 0xf5, 0x5d, 0x9f, 0x46, 0x34, 0x20, 0x7a, 0x2e, 0xd8, 0x46,
	0x6b, 0xcc, 0x47, 0x2e, 0x85, 0x9e, 0x4c, 0x90, 0x78, 0x4b, 0x5d, 0x55, 0x35, 0xde, 0xe6, 0x60,
	0x6b, 0x0e, 0x88, 0xb6, 0xa1, 0x2c, 0x28, 0x4d, 0xdc, 0xd0, 0x77, 0x72, 0x26, 0x6c, 0x25, 0x2d,
	0x9e, 0xf9, 0xe8, 0x1c, 0x36, 0x13, 0xfa, 0xeb, 0x30, 0x4c, 0xa8, 0x4b, 0xd8, 0xd8, 0xe5, 0x3d,
	0x27, 0x6f, 0xf2, 0xf6, 0x74, 0xf5, 0xee, 0xcd, 0x0b, 0x12, 0xbc, 0x08, 0xa5, 0xc2, 0x55, 0xcb,
	0x70, 0xc4, 0xc6, 0xdf, 0xf7, 0xea, 0xf7, 0xa0, 0x6c, 0x0d, 0xe8, 0x16, 0x14, 0x14, 0x09, 0x6c,
	0x1c, 0xf4, 0xb2, 0xf1, 0x6f, 0x01, 0xaa, 0xb3, 0x05, 0x30, 0xd3, 0x68, 0xb9, 0x49, 0xa3, 0x39,
	0x50, 0x0e, 0x99, 0x17, 0x0d, 0x7d, 0x6a, 0xa3, 0x95, 0x89, 0xe8, 0x4b, 0x58, 0xf3, 0x88, 0xd7,
	0xcf, 0x66, 0xd1, 0xee, 0xb5, 0xc5, 0xd5, 0x6c, 0x6b, 0x68, 0x87, 0xa9, 0x64, 0x8c, 0x53, 0x37,
	0xf4, 0x02, 0xaa, 0x5e, 0x28, 0x7c, 0x57, 0x10, 0x6f, 0x40, 0x02, 0x6a, 0x67, 0xd0, 0xde, 0x0a,
	0x9a, 0x50, 0xf8, 0xe7, 0xa9, 0x03, 0xde, 0xf0, 0xa6, 0x02, 0x3a, 0x80, 0x02, 0x65, 0x23, 0x3b,
	0x6f, 0x1e, 0x5f, 0x4f, 0xd2, 0x61, 0x23, 0xac, 0xd1, 0xf5, 0xcf, 0x01, 0xa6, 0xe7, 0x5a, 0xf8,
	0xfb, 0x08, 0x8a, 0x82, 0xa8, 0xbe, 0x49, 0x44, 0x05, 0x9b, 0x75, 0xfd, 0x25, 0x6c, 0xcc, 0x1c,
	0x63, 0x02, 0xc9, 0x4d, 0x21, 0x3a, 0xd8, 0x62, 0x10, 0x58, 0x2f, 0xbd, 0xd4, 0x71, 0x1c, 0xd1,
	0x44, 0xa6, 0x25, 0xa5, 0xb5, 0x99, 0x58, 0x7f, 0x0d, 0x85, 0x0e, 0x1b, 0x69, 0x97, 0x11, 0x49,
	0x2c, 0x8b, 0x5e, 0xea, 0x32, 0x1d, 0x91, 0x68, 0x48, 0x2d, 0x4d, 0x2a, 0xe8, 0xc9, 0x27, 0x12,
	0xda, 0x0b, 0xdf, 0x98, 0xb8, 0xeb, 0xe2, 0x31, 0x92, 0x3e, 0x86, 0xe4, 0x3d, 0x3d, 0xa9, 0x72,
	0xbb, 0xeb, 0xd8, 0xac, 0x1b, 0xff, 0xe4, 0xe0, 0xee, 0xe2, 0x16, 0x5f, 0xf8, 0xb3, 0x9f, 0x41,
	0x51, 0x24, 0xdc, 0xb7, 0x55, 0xb7, 0xe2, 0x72, 0x31, 0x50, 0xf4, 0x05, 0x94, 0x3c, 0xc2, 0x48,
	0x32, 0xb6, 0xb3, 0x76, 0x85, 0x93, 0x05, 0xa3, 0x1d, 0xa8, 0xa5, 0x2b, 0xd7, 0xeb, 0x13, 0xe6,
	0x51, 0x73, 0xea, 0x35, 0x5c, 0x4d, 0x95, 0x6d, 0xa3, 0x6b, 0x9c, 0x42, 0xed, 0x9d, 0x6b, 0x62,
	0xe1, 0x99, 0x77, 0xa0, 0xe6, 0x87, 0x31, 0x65, 0x3a, 0x94, 0xee, 0x80, 0x8e, 0x6d, 0x95, 0x56,
	0x27, 0xca, 0xef, 0xe8, 0xb8, 0xf1, 0x57, 0x1e, 0xb6, 0x97, 0x4c, 0x17, 0x9d, 0x18, 0xe2, 0xfb,
	0x09, 0x95, 0xd2, 0xf2, 0x66, 0x22, 0xda, 0x84, 0x7c, 0xe8, 0xdb, 0xe0, 0xe7, 0x43, 0x1f, 0x3d,
	0x04, 0x98, 0xb0, 0x4a, 0x1b, 0xfd, 0x19, 0x8d, 0x66, 0xa2, 0x8c, 0x74, 0x23, 0xea, 0xdb, 0x24,
	0x64, 0x22, 0xda, 0x87, 0xdb, 0x3d, 0x12, 0x45, 0x5d, 0xe2, 0x0d, 0xdc, 0xcb, 0x3e, 0x65, 0x2e,
	0x8d, 0x85, 0x1a, 0x3b, 0x6b, 0x1a, 0x75, 0x9c, 0x77, 0x72, 0x78, 0x2b, 0x33, 0xff, 0xd4, 0xa7,
	0xac, 0xa3, 0x8d, 0x7a, 0xc6, 0x92, 0x28, 0x72, 0x67, 0x76, 0x2c, 0x99, 0x1d, 0x6b, 0x24, 0x8a,
	0x4e, 0xa6, 0x9b, 0x6a, 0x18, 0x1b, 0xcf, 0xc2, 0xca, 0x16, 0xc6, 0xc6, 0x33, 0xb0, 0xa7, 0xb0,
	0x65, 0x6e, 0x1f, 0x97, 0x4a, 0x37, 0xdb, 0xcb, 0x0c, 0xed, 0x75, 0x7c, 0xd3, 0x18, 0x3a, 0xf2,
	0x6b, 0xab, 0x6e, 0xbc, 0xcd, 0xc3, 0xad, 0xb9, 0x17, 0x48, 0x1b, 0xca, 0xa1, 0xe4, 0xe6, 0xed,
	0x91, 0x33, 0x99, 0xde, 0x5b, 0xf9, 0x9c, 0x69, 0x9e, 0xa5, 0x0e, 0x38, 0xf3, 0x44, 0x87, 0x50,
	0xd4, 0x3d, 0x6b, 0x0b, 0xec, 0xe3, 0xd5, 0x0c, 0xed, 0xb3, 0xf3, 0x13, 0x6c, 0x7c, 0xea, 0x5f,
	0x41, 0xd9, 0xf2, 0xe9, 0x16, 0xd0, 0xf7, 0x2c, 0xcd, 0xba, 0xc5, 0x4a, 0xe8, 0x3e, 0x54, 0x74,
	0x4d, 0x48, 0x41, 0xbc, 0xac, 0x69, 0xa6, 0x8a, 0x7a, 0x07, 0x8a, 0x9a, 0x6e, 0xa9, 0xf7, 0x13,
	0xd8, 0xf4, 0xa2, 0x50, 0xdf, 0x24, 0x59, 0xa3, 0xa6, 0x14, 0xb5, 0x54, 0xfb, 0x63, 0xaa, 0x3c,
	0xfe, 0xed, 0xcf, 0xff, 0x76, 0x3a, 0xd0, 0xee, 0x2b, 0x25, 0xe4, 0x61, 0xcb, 0x3c, 0x28, 0x3f,
	0xb5, 0xc7, 0x27, 0x42, 0x48, 0xc1, 0x55, 0xd3, 0xe3, 0x71, 0xcb, 0xdc, 0x46, 0x44, 0xb6, 0xb2,
	0x47, 0xe0, 0xe4, 0xf5, 0x7a, 0x98, 0x3e, 0x58, 0xbd, 0x5e, 0xf0, 0xf3, 0xc1, 0xfb, 0x3f, 0x73,
	0x9f, 0xa7, 0x1f, 0xd1, 0xed, 0x96, 0x8c, 0xfa, 0xe0, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbb,
	0x1c, 0xc5, 0x24, 0x24, 0x0b, 0x00, 0x00,
}