go/test_platform/steps/scheduler_traffic_split.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: test_platform/steps/scheduler_traffic_split.proto

package steps

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	test_platform "go.chromium.org/chromiumos/infra/proto/go/test_platform"
	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

type SchedulerTrafficSplitRequests struct {
	// Each SchedulerTrafficSplitRequest is handled independently.
	Requests             []*SchedulerTrafficSplitRequest          `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"`
	TaggedRequests       map[string]*SchedulerTrafficSplitRequest `protobuf:"bytes,2,rep,name=tagged_requests,json=taggedRequests,proto3" json:"tagged_requests,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 *SchedulerTrafficSplitRequests) Reset()         { *m = SchedulerTrafficSplitRequests{} }
func (m *SchedulerTrafficSplitRequests) String() string { return proto.CompactTextString(m) }
func (*SchedulerTrafficSplitRequests) ProtoMessage()    {}
func (*SchedulerTrafficSplitRequests) Descriptor() ([]byte, []int) {
	return fileDescriptor_263137ec0e6b85de, []int{0}
}

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

var xxx_messageInfo_SchedulerTrafficSplitRequests proto.InternalMessageInfo

func (m *SchedulerTrafficSplitRequests) GetRequests() []*SchedulerTrafficSplitRequest {
	if m != nil {
		return m.Requests
	}
	return nil
}

func (m *SchedulerTrafficSplitRequests) GetTaggedRequests() map[string]*SchedulerTrafficSplitRequest {
	if m != nil {
		return m.TaggedRequests
	}
	return nil
}

type SchedulerTrafficSplitResponses struct {
	// Each SchedulerTrafficSplitResponse corresponds to a single
	// SchedulerTrafficSplitRequest handled independently.
	Responses            []*SchedulerTrafficSplitResponse          `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	TaggedResponses      map[string]*SchedulerTrafficSplitResponse `protobuf:"bytes,2,rep,name=tagged_responses,json=taggedResponses,proto3" json:"tagged_responses,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 *SchedulerTrafficSplitResponses) Reset()         { *m = SchedulerTrafficSplitResponses{} }
func (m *SchedulerTrafficSplitResponses) String() string { return proto.CompactTextString(m) }
func (*SchedulerTrafficSplitResponses) ProtoMessage()    {}
func (*SchedulerTrafficSplitResponses) Descriptor() ([]byte, []int) {
	return fileDescriptor_263137ec0e6b85de, []int{1}
}

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

var xxx_messageInfo_SchedulerTrafficSplitResponses proto.InternalMessageInfo

func (m *SchedulerTrafficSplitResponses) GetResponses() []*SchedulerTrafficSplitResponse {
	if m != nil {
		return m.Responses
	}
	return nil
}

func (m *SchedulerTrafficSplitResponses) GetTaggedResponses() map[string]*SchedulerTrafficSplitResponse {
	if m != nil {
		return m.TaggedResponses
	}
	return nil
}

// SchedulerTrafficSplitRequest is the request to the step that determines the
// traffic split between backend schedulers.
type SchedulerTrafficSplitRequest struct {
	Request              *test_platform.Request `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerTrafficSplitRequest proto.InternalMessageInfo

func (m *SchedulerTrafficSplitRequest) GetRequest() *test_platform.Request {
	if m != nil {
		return m.Request
	}
	return nil
}

// SchedulerTrafficSplitResponse is the response from the step that determines
// the traffic split between backend schedulers.
type SchedulerTrafficSplitResponse struct {
	SkylabRequest        *test_platform.Request `protobuf:"bytes,2,opt,name=skylab_request,json=skylabRequest,proto3" json:"skylab_request,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerTrafficSplitResponse proto.InternalMessageInfo

func (m *SchedulerTrafficSplitResponse) GetSkylabRequest() *test_platform.Request {
	if m != nil {
		return m.SkylabRequest
	}
	return nil
}

func init() {
	proto.RegisterType((*SchedulerTrafficSplitRequests)(nil), "test_platform.steps.SchedulerTrafficSplitRequests")
	proto.RegisterMapType((map[string]*SchedulerTrafficSplitRequest)(nil), "test_platform.steps.SchedulerTrafficSplitRequests.TaggedRequestsEntry")
	proto.RegisterType((*SchedulerTrafficSplitResponses)(nil), "test_platform.steps.SchedulerTrafficSplitResponses")
	proto.RegisterMapType((map[string]*SchedulerTrafficSplitResponse)(nil), "test_platform.steps.SchedulerTrafficSplitResponses.TaggedResponsesEntry")
	proto.RegisterType((*SchedulerTrafficSplitRequest)(nil), "test_platform.steps.SchedulerTrafficSplitRequest")
	proto.RegisterType((*SchedulerTrafficSplitResponse)(nil), "test_platform.steps.SchedulerTrafficSplitResponse")
}

func init() {
	proto.RegisterFile("test_platform/steps/scheduler_traffic_split.proto", fileDescriptor_263137ec0e6b85de)
}

var fileDescriptor_263137ec0e6b85de = []byte{
	// 388 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x94, 0x5f, 0x6b, 0xf2, 0x30,
	0x14, 0xc6, 0x69, 0x7d, 0xdf, 0x4d, 0x23, 0xd3, 0x12, 0xc7, 0x10, 0xf7, 0x07, 0xf1, 0xca, 0xab,
	0x66, 0xba, 0x9b, 0x31, 0x90, 0xc1, 0x60, 0x9b, 0x0c, 0x06, 0xa3, 0xca, 0x2e, 0x76, 0x53, 0xaa,
	0xa6, 0xb5, 0x58, 0x4d, 0x97, 0x93, 0x0a, 0x7e, 0xd0, 0x5d, 0xef, 0xab, 0x0c, 0x9b, 0xa6, 0xae,
	0xa3, 0x0a, 0x7a, 0xe7, 0x89, 0xcf, 0xf3, 0x3b, 0x39, 0x4f, 0x92, 0xa2, 0x8e, 0xa0, 0x20, 0xec,
	0x30, 0x70, 0x84, 0xcb, 0xf8, 0x9c, 0x80, 0xa0, 0x21, 0x10, 0x18, 0x4f, 0xe9, 0x24, 0x0a, 0x28,
	0xb7, 0x05, 0x77, 0x5c, 0xd7, 0x1f, 0xdb, 0x10, 0x06, 0xbe, 0x30, 0x43, 0xce, 0x04, 0xc3, 0xb5,
	0x8c, 0xc5, 0x8c, 0x2d, 0x8d, 0xf3, 0x2c, 0x87, 0xd3, 0xcf, 0x88, 0x42, 0xe2, 0x68, 0x7d, 0xe9,
	0xe8, 0x72, 0xa0, 0x98, 0x43, 0x89, 0x1c, 0xac, 0x89, 0x96, 0x94, 0x01, 0x7e, 0x45, 0xc5, 0xc4,
	0x02, 0x75, 0xad, 0x59, 0x68, 0x97, 0xbb, 0x1d, 0x33, 0xa7, 0x8d, 0xb9, 0x8b, 0x62, 0xa5, 0x08,
	0xcc, 0x50, 0x55, 0x38, 0x9e, 0x47, 0x27, 0x76, 0x4a, 0xd5, 0x63, 0xea, 0xd3, 0xde, 0x54, 0x30,
	0x87, 0x31, 0x49, 0x95, 0x8f, 0x0b, 0xc1, 0x57, 0x56, 0x45, 0x64, 0x16, 0x1b, 0x02, 0xd5, 0x72,
	0x64, 0xd8, 0x40, 0x85, 0x19, 0x5d, 0xd5, 0xb5, 0xa6, 0xd6, 0x2e, 0x59, 0xeb, 0x9f, 0xf8, 0x19,
	0xfd, 0x5f, 0x3a, 0x41, 0x44, 0xeb, 0x7a, 0x53, 0x3b, 0x6c, 0x4a, 0xe9, 0xbf, 0xd3, 0x6f, 0xb5,
	0xd6, 0xb7, 0x8e, 0xae, 0xb6, 0x68, 0x21, 0x64, 0x0b, 0xa0, 0x80, 0xdf, 0x50, 0x89, 0xab, 0x22,
	0x49, 0xb6, 0xbb, 0x4f, 0x4f, 0x69, 0xb5, 0x36, 0x10, 0x0c, 0xc8, 0x48, 0xb3, 0x55, 0x60, 0x19,
	0x6e, 0x7f, 0x7f, 0xf0, 0x26, 0xdd, 0xa4, 0x96, 0xf1, 0x56, 0x45, 0x76, 0xb5, 0xb1, 0x44, 0xa7,
	0x79, 0xc2, 0x9c, 0x80, 0xfb, 0xd9, 0x80, 0x0f, 0x19, 0xf6, 0x57, 0xc2, 0xef, 0xe8, 0x62, 0xd7,
	0x61, 0xe0, 0x6b, 0x74, 0x9c, 0xdc, 0xb0, 0x78, 0x0f, 0xe5, 0xee, 0xd9, 0x9f, 0x7e, 0xea, 0xd4,
	0x94, 0xec, 0xe5, 0x5f, 0x51, 0x37, 0x0a, 0xad, 0xc9, 0xd6, 0x07, 0x21, 0xf7, 0x80, 0x7b, 0xa8,
	0x02, 0xb3, 0x55, 0xe0, 0x8c, 0xd4, 0x0d, 0x4e, 0xe6, 0xd9, 0xc6, 0x3f, 0x91, 0x6a, 0x2b, 0xed,
	0xa2, 0x19, 0xfa, 0xc3, 0xfd, 0x47, 0xcf, 0x63, 0xe6, 0x78, 0xca, 0xd9, 0xdc, 0x8f, 0xe6, 0x26,
	0xe3, 0x1e, 0x51, 0x05, 0x03, 0xe2, 0x2f, 0x5c, 0xee, 0x90, 0xf8, 0x85, 0x12, 0x8f, 0x91, 0x9c,
	0x0f, 0xc1, 0xe8, 0x28, 0xfe, 0xf7, 0xe6, 0x27, 0x00, 0x00, 0xff, 0xff, 0xa3, 0x26, 0xf0, 0xb9,
	0x26, 0x04, 0x00, 0x00,
}