| // Code generated by protoc-gen-go. DO NOT EDIT. |
| // source: incubator-yunikorn-scheduler-interface/si.proto |
| |
| package si |
| |
| import ( |
| context "context" |
| fmt "fmt" |
| proto "github.com/golang/protobuf/proto" |
| descriptor "github.com/golang/protobuf/protoc-gen-go/descriptor" |
| grpc "google.golang.org/grpc" |
| codes "google.golang.org/grpc/codes" |
| status "google.golang.org/grpc/status" |
| 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 TerminationType int32 |
| |
| const ( |
| TerminationType_STOPPED_BY_RM TerminationType = 0 |
| TerminationType_TIMEOUT TerminationType = 1 |
| TerminationType_PREEMPTED_BY_SCHEDULER TerminationType = 2 |
| TerminationType_PLACEHOLDER_REPLACED TerminationType = 3 |
| ) |
| |
| var TerminationType_name = map[int32]string{ |
| 0: "STOPPED_BY_RM", |
| 1: "TIMEOUT", |
| 2: "PREEMPTED_BY_SCHEDULER", |
| 3: "PLACEHOLDER_REPLACED", |
| } |
| |
| var TerminationType_value = map[string]int32{ |
| "STOPPED_BY_RM": 0, |
| "TIMEOUT": 1, |
| "PREEMPTED_BY_SCHEDULER": 2, |
| "PLACEHOLDER_REPLACED": 3, |
| } |
| |
| func (x TerminationType) String() string { |
| return proto.EnumName(TerminationType_name, int32(x)) |
| } |
| |
| func (TerminationType) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{0} |
| } |
| |
| // Scheduler can send action to RM. |
| type UpdateResponse_ActionFromScheduler int32 |
| |
| const ( |
| // Nothing needs to do |
| UpdateResponse_NOACTION UpdateResponse_ActionFromScheduler = 0 |
| // Something is wrong, RM needs to stop the RM, and re-register with scheduler. |
| UpdateResponse_RESYNC UpdateResponse_ActionFromScheduler = 1 |
| ) |
| |
| var UpdateResponse_ActionFromScheduler_name = map[int32]string{ |
| 0: "NOACTION", |
| 1: "RESYNC", |
| } |
| |
| var UpdateResponse_ActionFromScheduler_value = map[string]int32{ |
| "NOACTION": 0, |
| "RESYNC": 1, |
| } |
| |
| func (x UpdateResponse_ActionFromScheduler) String() string { |
| return proto.EnumName(UpdateResponse_ActionFromScheduler_name, int32(x)) |
| } |
| |
| func (UpdateResponse_ActionFromScheduler) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{3, 0} |
| } |
| |
| // Following 4 operators can be specified, by default is "IN". |
| // When EXIST/NOT_EXISTS specified, scheduler only check if given targetKey |
| // appears on node attribute or allocation tag. |
| type AffinityTargetExpression_AffinityTargetOperator int32 |
| |
| const ( |
| AffinityTargetExpression_IN AffinityTargetExpression_AffinityTargetOperator = 0 |
| AffinityTargetExpression_NOT_IN AffinityTargetExpression_AffinityTargetOperator = 1 |
| AffinityTargetExpression_EXIST AffinityTargetExpression_AffinityTargetOperator = 2 |
| AffinityTargetExpression_NOT_EXIST AffinityTargetExpression_AffinityTargetOperator = 3 |
| ) |
| |
| var AffinityTargetExpression_AffinityTargetOperator_name = map[int32]string{ |
| 0: "IN", |
| 1: "NOT_IN", |
| 2: "EXIST", |
| 3: "NOT_EXIST", |
| } |
| |
| var AffinityTargetExpression_AffinityTargetOperator_value = map[string]int32{ |
| "IN": 0, |
| "NOT_IN": 1, |
| "EXIST": 2, |
| "NOT_EXIST": 3, |
| } |
| |
| func (x AffinityTargetExpression_AffinityTargetOperator) String() string { |
| return proto.EnumName(AffinityTargetExpression_AffinityTargetOperator_name, int32(x)) |
| } |
| |
| func (AffinityTargetExpression_AffinityTargetOperator) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{20, 0} |
| } |
| |
| // Action from RM |
| type UpdateNodeInfo_ActionFromRM int32 |
| |
| const ( |
| // Update node resources, attributes. |
| UpdateNodeInfo_UPDATE UpdateNodeInfo_ActionFromRM = 0 |
| // Do not allocate new allocations on the node. |
| UpdateNodeInfo_DRAIN_NODE UpdateNodeInfo_ActionFromRM = 1 |
| // Decomission node, it will immediately stop allocations on the node and |
| // remove the node from schedulable lists. |
| UpdateNodeInfo_DECOMISSION UpdateNodeInfo_ActionFromRM = 2 |
| // From Draining state to SCHEDULABLE state. |
| // If node is not in draining state, error will be thrown |
| UpdateNodeInfo_DRAIN_TO_SCHEDULABLE UpdateNodeInfo_ActionFromRM = 3 |
| ) |
| |
| var UpdateNodeInfo_ActionFromRM_name = map[int32]string{ |
| 0: "UPDATE", |
| 1: "DRAIN_NODE", |
| 2: "DECOMISSION", |
| 3: "DRAIN_TO_SCHEDULABLE", |
| } |
| |
| var UpdateNodeInfo_ActionFromRM_value = map[string]int32{ |
| "UPDATE": 0, |
| "DRAIN_NODE": 1, |
| "DECOMISSION": 2, |
| "DRAIN_TO_SCHEDULABLE": 3, |
| } |
| |
| func (x UpdateNodeInfo_ActionFromRM) String() string { |
| return proto.EnumName(UpdateNodeInfo_ActionFromRM_name, int32(x)) |
| } |
| |
| func (UpdateNodeInfo_ActionFromRM) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{26, 0} |
| } |
| |
| // container scheduling states |
| type UpdateContainerSchedulingStateRequest_SchedulingState int32 |
| |
| const ( |
| // the container is being skipped by the scheduler |
| UpdateContainerSchedulingStateRequest_SKIPPED UpdateContainerSchedulingStateRequest_SchedulingState = 0 |
| // the container is scheduled and it has been assigned to a node |
| UpdateContainerSchedulingStateRequest_SCHEDULED UpdateContainerSchedulingStateRequest_SchedulingState = 1 |
| // the container is reserved on some node, but not yet assigned |
| UpdateContainerSchedulingStateRequest_RESERVED UpdateContainerSchedulingStateRequest_SchedulingState = 2 |
| // scheduler has visited all candidate nodes for this container |
| // but non of them could satisfy this container's requirement |
| UpdateContainerSchedulingStateRequest_FAILED UpdateContainerSchedulingStateRequest_SchedulingState = 3 |
| ) |
| |
| var UpdateContainerSchedulingStateRequest_SchedulingState_name = map[int32]string{ |
| 0: "SKIPPED", |
| 1: "SCHEDULED", |
| 2: "RESERVED", |
| 3: "FAILED", |
| } |
| |
| var UpdateContainerSchedulingStateRequest_SchedulingState_value = map[string]int32{ |
| "SKIPPED": 0, |
| "SCHEDULED": 1, |
| "RESERVED": 2, |
| "FAILED": 3, |
| } |
| |
| func (x UpdateContainerSchedulingStateRequest_SchedulingState) String() string { |
| return proto.EnumName(UpdateContainerSchedulingStateRequest_SchedulingState_name, int32(x)) |
| } |
| |
| func (UpdateContainerSchedulingStateRequest_SchedulingState) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{34, 0} |
| } |
| |
| type EventRecord_Type int32 |
| |
| const ( |
| EventRecord_REQUEST EventRecord_Type = 0 |
| EventRecord_APP EventRecord_Type = 1 |
| EventRecord_NODE EventRecord_Type = 2 |
| EventRecord_QUEUE EventRecord_Type = 3 |
| ) |
| |
| var EventRecord_Type_name = map[int32]string{ |
| 0: "REQUEST", |
| 1: "APP", |
| 2: "NODE", |
| 3: "QUEUE", |
| } |
| |
| var EventRecord_Type_value = map[string]int32{ |
| "REQUEST": 0, |
| "APP": 1, |
| "NODE": 2, |
| "QUEUE": 3, |
| } |
| |
| func (x EventRecord_Type) String() string { |
| return proto.EnumName(EventRecord_Type_name, int32(x)) |
| } |
| |
| func (EventRecord_Type) EnumDescriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{37, 0} |
| } |
| |
| // |
| //service MetricsService { |
| //} |
| type RegisterResourceManagerRequest struct { |
| // An ID which can uniquely identify a RM **cluster**. (For example, if a RM cluster has multiple manager instances for HA purpose, they should use the same information when do registration). |
| // If RM register with the same ID, all previous scheduling state in memory will be cleaned up, and expect RM report full scheduling state after registration. |
| RmID string `protobuf:"bytes,1,opt,name=rmID,proto3" json:"rmID,omitempty"` |
| // Version of RM scheduler interface client. |
| Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` |
| // Policy group name: |
| // This defines which policy to use. Policy should be statically configured. (Think about network security group concept of ec2). |
| // Different RMs can refer to the same policyGroup if their static configuration is identical. |
| PolicyGroup string `protobuf:"bytes,3,opt,name=policyGroup,proto3" json:"policyGroup,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *RegisterResourceManagerRequest) Reset() { *m = RegisterResourceManagerRequest{} } |
| func (m *RegisterResourceManagerRequest) String() string { return proto.CompactTextString(m) } |
| func (*RegisterResourceManagerRequest) ProtoMessage() {} |
| func (*RegisterResourceManagerRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{0} |
| } |
| |
| func (m *RegisterResourceManagerRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_RegisterResourceManagerRequest.Unmarshal(m, b) |
| } |
| func (m *RegisterResourceManagerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_RegisterResourceManagerRequest.Marshal(b, m, deterministic) |
| } |
| func (m *RegisterResourceManagerRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RegisterResourceManagerRequest.Merge(m, src) |
| } |
| func (m *RegisterResourceManagerRequest) XXX_Size() int { |
| return xxx_messageInfo_RegisterResourceManagerRequest.Size(m) |
| } |
| func (m *RegisterResourceManagerRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_RegisterResourceManagerRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RegisterResourceManagerRequest proto.InternalMessageInfo |
| |
| func (m *RegisterResourceManagerRequest) GetRmID() string { |
| if m != nil { |
| return m.RmID |
| } |
| return "" |
| } |
| |
| func (m *RegisterResourceManagerRequest) GetVersion() string { |
| if m != nil { |
| return m.Version |
| } |
| return "" |
| } |
| |
| func (m *RegisterResourceManagerRequest) GetPolicyGroup() string { |
| if m != nil { |
| return m.PolicyGroup |
| } |
| return "" |
| } |
| |
| // Upon success, scheduler returns RegisterResourceManagerResponse to RM, otherwise RM receives exception. |
| type RegisterResourceManagerResponse struct { |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *RegisterResourceManagerResponse) Reset() { *m = RegisterResourceManagerResponse{} } |
| func (m *RegisterResourceManagerResponse) String() string { return proto.CompactTextString(m) } |
| func (*RegisterResourceManagerResponse) ProtoMessage() {} |
| func (*RegisterResourceManagerResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{1} |
| } |
| |
| func (m *RegisterResourceManagerResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_RegisterResourceManagerResponse.Unmarshal(m, b) |
| } |
| func (m *RegisterResourceManagerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_RegisterResourceManagerResponse.Marshal(b, m, deterministic) |
| } |
| func (m *RegisterResourceManagerResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RegisterResourceManagerResponse.Merge(m, src) |
| } |
| func (m *RegisterResourceManagerResponse) XXX_Size() int { |
| return xxx_messageInfo_RegisterResourceManagerResponse.Size(m) |
| } |
| func (m *RegisterResourceManagerResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_RegisterResourceManagerResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RegisterResourceManagerResponse proto.InternalMessageInfo |
| |
| type UpdateRequest struct { |
| // New allocation requests or replace existing allocation request (if allocationID is same) |
| Asks []*AllocationAsk `protobuf:"bytes,1,rep,name=asks,proto3" json:"asks,omitempty"` |
| // Allocations can be released. |
| Releases *AllocationReleasesRequest `protobuf:"bytes,2,opt,name=releases,proto3" json:"releases,omitempty"` |
| // New node can be scheduled. If a node is notified to be "unscheduable", it needs to be part of this field as well. |
| NewSchedulableNodes []*NewNodeInfo `protobuf:"bytes,3,rep,name=newSchedulableNodes,proto3" json:"newSchedulableNodes,omitempty"` |
| // Update nodes for existing schedulable nodes. |
| // May include: |
| // - Node resource changes. (Like grows/shrinks node resource) |
| // - Node attribute changes. (Including node-partition concept like YARN, and concept like "local images". |
| // |
| // Should not include: |
| // - Allocation-related changes with the node. |
| // - Realtime Utilizations. |
| UpdatedNodes []*UpdateNodeInfo `protobuf:"bytes,4,rep,name=updatedNodes,proto3" json:"updatedNodes,omitempty"` |
| // UtilizationReports for allocation and nodes. |
| UtilizationReports []*UtilizationReport `protobuf:"bytes,5,rep,name=utilizationReports,proto3" json:"utilizationReports,omitempty"` |
| // ID of RM, this will be used to identify which RM of the request comes from. |
| RmID string `protobuf:"bytes,6,opt,name=rmID,proto3" json:"rmID,omitempty"` |
| // RM should explicitly add application when allocation request also explictly belongs to application. |
| // This is optional if allocation request doesn't belong to a application. (Independent allocation) |
| NewApplications []*AddApplicationRequest `protobuf:"bytes,8,rep,name=newApplications,proto3" json:"newApplications,omitempty"` |
| // RM can also remove applications, all allocation/allocation requests associated with the application will be removed |
| RemoveApplications []*RemoveApplicationRequest `protobuf:"bytes,9,rep,name=removeApplications,proto3" json:"removeApplications,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UpdateRequest) Reset() { *m = UpdateRequest{} } |
| func (m *UpdateRequest) String() string { return proto.CompactTextString(m) } |
| func (*UpdateRequest) ProtoMessage() {} |
| func (*UpdateRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{2} |
| } |
| |
| func (m *UpdateRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UpdateRequest.Unmarshal(m, b) |
| } |
| func (m *UpdateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UpdateRequest.Marshal(b, m, deterministic) |
| } |
| func (m *UpdateRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UpdateRequest.Merge(m, src) |
| } |
| func (m *UpdateRequest) XXX_Size() int { |
| return xxx_messageInfo_UpdateRequest.Size(m) |
| } |
| func (m *UpdateRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_UpdateRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UpdateRequest proto.InternalMessageInfo |
| |
| func (m *UpdateRequest) GetAsks() []*AllocationAsk { |
| if m != nil { |
| return m.Asks |
| } |
| return nil |
| } |
| |
| func (m *UpdateRequest) GetReleases() *AllocationReleasesRequest { |
| if m != nil { |
| return m.Releases |
| } |
| return nil |
| } |
| |
| func (m *UpdateRequest) GetNewSchedulableNodes() []*NewNodeInfo { |
| if m != nil { |
| return m.NewSchedulableNodes |
| } |
| return nil |
| } |
| |
| func (m *UpdateRequest) GetUpdatedNodes() []*UpdateNodeInfo { |
| if m != nil { |
| return m.UpdatedNodes |
| } |
| return nil |
| } |
| |
| func (m *UpdateRequest) GetUtilizationReports() []*UtilizationReport { |
| if m != nil { |
| return m.UtilizationReports |
| } |
| return nil |
| } |
| |
| func (m *UpdateRequest) GetRmID() string { |
| if m != nil { |
| return m.RmID |
| } |
| return "" |
| } |
| |
| func (m *UpdateRequest) GetNewApplications() []*AddApplicationRequest { |
| if m != nil { |
| return m.NewApplications |
| } |
| return nil |
| } |
| |
| func (m *UpdateRequest) GetRemoveApplications() []*RemoveApplicationRequest { |
| if m != nil { |
| return m.RemoveApplications |
| } |
| return nil |
| } |
| |
| type UpdateResponse struct { |
| // What RM needs to do, scheduler can send control code to RM when something goes wrong. |
| // Don't use/expand this field for other general purposed actions. (Like kill a remote container process). |
| Action UpdateResponse_ActionFromScheduler `protobuf:"varint,1,opt,name=action,proto3,enum=si.v1.UpdateResponse_ActionFromScheduler" json:"action,omitempty"` |
| // New allocations |
| NewAllocations []*Allocation `protobuf:"bytes,2,rep,name=newAllocations,proto3" json:"newAllocations,omitempty"` |
| // Released allocations, this could be either ack from scheduler when RM asks to terminate some allocations. |
| // Or it could be decision made by scheduler (such as preemption or timeout). |
| ReleasedAllocations []*AllocationRelease `protobuf:"bytes,3,rep,name=releasedAllocations,proto3" json:"releasedAllocations,omitempty"` |
| // Released allocation asks(placeholder), when the placeholder allocation times out |
| ReleasedAllocationAsks []*AllocationAskRelease `protobuf:"bytes,4,rep,name=releasedAllocationAsks,proto3" json:"releasedAllocationAsks,omitempty"` |
| // Rejected allocation requests |
| RejectedAllocations []*RejectedAllocationAsk `protobuf:"bytes,5,rep,name=rejectedAllocations,proto3" json:"rejectedAllocations,omitempty"` |
| // Suggested node update. |
| // This could include: |
| // 1) Schedulable resources on each node. This can be used when we want to run |
| // two resource management systems side-by-side. For example, YARN/K8s running side by side. |
| // and update YARN NodeManager / Kubelet resource dynamically. |
| // 2) Other recommendations. |
| NodeRecommendations []*NodeRecommendation `protobuf:"bytes,6,rep,name=nodeRecommendations,proto3" json:"nodeRecommendations,omitempty"` |
| // Rejected Applications |
| RejectedApplications []*RejectedApplication `protobuf:"bytes,7,rep,name=rejectedApplications,proto3" json:"rejectedApplications,omitempty"` |
| // Accepted Applications |
| AcceptedApplications []*AcceptedApplication `protobuf:"bytes,8,rep,name=acceptedApplications,proto3" json:"acceptedApplications,omitempty"` |
| // Updated Applications |
| UpdatedApplications []*UpdatedApplication `protobuf:"bytes,9,rep,name=updatedApplications,proto3" json:"updatedApplications,omitempty"` |
| // Rejected Node Registrations |
| RejectedNodes []*RejectedNode `protobuf:"bytes,10,rep,name=rejectedNodes,proto3" json:"rejectedNodes,omitempty"` |
| // Accepted Node Registrations |
| AcceptedNodes []*AcceptedNode `protobuf:"bytes,11,rep,name=acceptedNodes,proto3" json:"acceptedNodes,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UpdateResponse) Reset() { *m = UpdateResponse{} } |
| func (m *UpdateResponse) String() string { return proto.CompactTextString(m) } |
| func (*UpdateResponse) ProtoMessage() {} |
| func (*UpdateResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{3} |
| } |
| |
| func (m *UpdateResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UpdateResponse.Unmarshal(m, b) |
| } |
| func (m *UpdateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UpdateResponse.Marshal(b, m, deterministic) |
| } |
| func (m *UpdateResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UpdateResponse.Merge(m, src) |
| } |
| func (m *UpdateResponse) XXX_Size() int { |
| return xxx_messageInfo_UpdateResponse.Size(m) |
| } |
| func (m *UpdateResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_UpdateResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UpdateResponse proto.InternalMessageInfo |
| |
| func (m *UpdateResponse) GetAction() UpdateResponse_ActionFromScheduler { |
| if m != nil { |
| return m.Action |
| } |
| return UpdateResponse_NOACTION |
| } |
| |
| func (m *UpdateResponse) GetNewAllocations() []*Allocation { |
| if m != nil { |
| return m.NewAllocations |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetReleasedAllocations() []*AllocationRelease { |
| if m != nil { |
| return m.ReleasedAllocations |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetReleasedAllocationAsks() []*AllocationAskRelease { |
| if m != nil { |
| return m.ReleasedAllocationAsks |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetRejectedAllocations() []*RejectedAllocationAsk { |
| if m != nil { |
| return m.RejectedAllocations |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetNodeRecommendations() []*NodeRecommendation { |
| if m != nil { |
| return m.NodeRecommendations |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetRejectedApplications() []*RejectedApplication { |
| if m != nil { |
| return m.RejectedApplications |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetAcceptedApplications() []*AcceptedApplication { |
| if m != nil { |
| return m.AcceptedApplications |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetUpdatedApplications() []*UpdatedApplication { |
| if m != nil { |
| return m.UpdatedApplications |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetRejectedNodes() []*RejectedNode { |
| if m != nil { |
| return m.RejectedNodes |
| } |
| return nil |
| } |
| |
| func (m *UpdateResponse) GetAcceptedNodes() []*AcceptedNode { |
| if m != nil { |
| return m.AcceptedNodes |
| } |
| return nil |
| } |
| |
| type UpdatedApplication struct { |
| // The application ID that was updated |
| ApplicationID string `protobuf:"bytes,1,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // State of the application |
| State string `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"` |
| // Timestamp of the state transition |
| StateTransitionTimestamp int64 `protobuf:"varint,3,opt,name=stateTransitionTimestamp,proto3" json:"stateTransitionTimestamp,omitempty"` |
| // Detailed message |
| Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UpdatedApplication) Reset() { *m = UpdatedApplication{} } |
| func (m *UpdatedApplication) String() string { return proto.CompactTextString(m) } |
| func (*UpdatedApplication) ProtoMessage() {} |
| func (*UpdatedApplication) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{4} |
| } |
| |
| func (m *UpdatedApplication) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UpdatedApplication.Unmarshal(m, b) |
| } |
| func (m *UpdatedApplication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UpdatedApplication.Marshal(b, m, deterministic) |
| } |
| func (m *UpdatedApplication) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UpdatedApplication.Merge(m, src) |
| } |
| func (m *UpdatedApplication) XXX_Size() int { |
| return xxx_messageInfo_UpdatedApplication.Size(m) |
| } |
| func (m *UpdatedApplication) XXX_DiscardUnknown() { |
| xxx_messageInfo_UpdatedApplication.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UpdatedApplication proto.InternalMessageInfo |
| |
| func (m *UpdatedApplication) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *UpdatedApplication) GetState() string { |
| if m != nil { |
| return m.State |
| } |
| return "" |
| } |
| |
| func (m *UpdatedApplication) GetStateTransitionTimestamp() int64 { |
| if m != nil { |
| return m.StateTransitionTimestamp |
| } |
| return 0 |
| } |
| |
| func (m *UpdatedApplication) GetMessage() string { |
| if m != nil { |
| return m.Message |
| } |
| return "" |
| } |
| |
| type RejectedApplication struct { |
| // The application ID that was rejected |
| ApplicationID string `protobuf:"bytes,1,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // A human-readable reason message |
| Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *RejectedApplication) Reset() { *m = RejectedApplication{} } |
| func (m *RejectedApplication) String() string { return proto.CompactTextString(m) } |
| func (*RejectedApplication) ProtoMessage() {} |
| func (*RejectedApplication) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{5} |
| } |
| |
| func (m *RejectedApplication) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_RejectedApplication.Unmarshal(m, b) |
| } |
| func (m *RejectedApplication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_RejectedApplication.Marshal(b, m, deterministic) |
| } |
| func (m *RejectedApplication) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RejectedApplication.Merge(m, src) |
| } |
| func (m *RejectedApplication) XXX_Size() int { |
| return xxx_messageInfo_RejectedApplication.Size(m) |
| } |
| func (m *RejectedApplication) XXX_DiscardUnknown() { |
| xxx_messageInfo_RejectedApplication.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RejectedApplication proto.InternalMessageInfo |
| |
| func (m *RejectedApplication) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *RejectedApplication) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type AcceptedApplication struct { |
| // The application ID that was accepted |
| ApplicationID string `protobuf:"bytes,1,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AcceptedApplication) Reset() { *m = AcceptedApplication{} } |
| func (m *AcceptedApplication) String() string { return proto.CompactTextString(m) } |
| func (*AcceptedApplication) ProtoMessage() {} |
| func (*AcceptedApplication) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{6} |
| } |
| |
| func (m *AcceptedApplication) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AcceptedApplication.Unmarshal(m, b) |
| } |
| func (m *AcceptedApplication) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AcceptedApplication.Marshal(b, m, deterministic) |
| } |
| func (m *AcceptedApplication) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AcceptedApplication.Merge(m, src) |
| } |
| func (m *AcceptedApplication) XXX_Size() int { |
| return xxx_messageInfo_AcceptedApplication.Size(m) |
| } |
| func (m *AcceptedApplication) XXX_DiscardUnknown() { |
| xxx_messageInfo_AcceptedApplication.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AcceptedApplication proto.InternalMessageInfo |
| |
| func (m *AcceptedApplication) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| type RejectedNode struct { |
| // The node ID that was rejected |
| NodeID string `protobuf:"bytes,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"` |
| // A human-readable reason message |
| Reason string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *RejectedNode) Reset() { *m = RejectedNode{} } |
| func (m *RejectedNode) String() string { return proto.CompactTextString(m) } |
| func (*RejectedNode) ProtoMessage() {} |
| func (*RejectedNode) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{7} |
| } |
| |
| func (m *RejectedNode) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_RejectedNode.Unmarshal(m, b) |
| } |
| func (m *RejectedNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_RejectedNode.Marshal(b, m, deterministic) |
| } |
| func (m *RejectedNode) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RejectedNode.Merge(m, src) |
| } |
| func (m *RejectedNode) XXX_Size() int { |
| return xxx_messageInfo_RejectedNode.Size(m) |
| } |
| func (m *RejectedNode) XXX_DiscardUnknown() { |
| xxx_messageInfo_RejectedNode.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RejectedNode proto.InternalMessageInfo |
| |
| func (m *RejectedNode) GetNodeID() string { |
| if m != nil { |
| return m.NodeID |
| } |
| return "" |
| } |
| |
| func (m *RejectedNode) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type AcceptedNode struct { |
| // The node ID that was accepted |
| NodeID string `protobuf:"bytes,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AcceptedNode) Reset() { *m = AcceptedNode{} } |
| func (m *AcceptedNode) String() string { return proto.CompactTextString(m) } |
| func (*AcceptedNode) ProtoMessage() {} |
| func (*AcceptedNode) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{8} |
| } |
| |
| func (m *AcceptedNode) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AcceptedNode.Unmarshal(m, b) |
| } |
| func (m *AcceptedNode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AcceptedNode.Marshal(b, m, deterministic) |
| } |
| func (m *AcceptedNode) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AcceptedNode.Merge(m, src) |
| } |
| func (m *AcceptedNode) XXX_Size() int { |
| return xxx_messageInfo_AcceptedNode.Size(m) |
| } |
| func (m *AcceptedNode) XXX_DiscardUnknown() { |
| xxx_messageInfo_AcceptedNode.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AcceptedNode proto.InternalMessageInfo |
| |
| func (m *AcceptedNode) GetNodeID() string { |
| if m != nil { |
| return m.NodeID |
| } |
| return "" |
| } |
| |
| type Priority struct { |
| // Types that are valid to be assigned to Priority: |
| // *Priority_PriorityValue |
| // *Priority_PriorityClassName |
| Priority isPriority_Priority `protobuf_oneof:"priority"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Priority) Reset() { *m = Priority{} } |
| func (m *Priority) String() string { return proto.CompactTextString(m) } |
| func (*Priority) ProtoMessage() {} |
| func (*Priority) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{9} |
| } |
| |
| func (m *Priority) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Priority.Unmarshal(m, b) |
| } |
| func (m *Priority) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Priority.Marshal(b, m, deterministic) |
| } |
| func (m *Priority) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Priority.Merge(m, src) |
| } |
| func (m *Priority) XXX_Size() int { |
| return xxx_messageInfo_Priority.Size(m) |
| } |
| func (m *Priority) XXX_DiscardUnknown() { |
| xxx_messageInfo_Priority.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Priority proto.InternalMessageInfo |
| |
| type isPriority_Priority interface { |
| isPriority_Priority() |
| } |
| |
| type Priority_PriorityValue struct { |
| PriorityValue int32 `protobuf:"varint,1,opt,name=priorityValue,proto3,oneof"` |
| } |
| |
| type Priority_PriorityClassName struct { |
| PriorityClassName string `protobuf:"bytes,2,opt,name=priorityClassName,proto3,oneof"` |
| } |
| |
| func (*Priority_PriorityValue) isPriority_Priority() {} |
| |
| func (*Priority_PriorityClassName) isPriority_Priority() {} |
| |
| func (m *Priority) GetPriority() isPriority_Priority { |
| if m != nil { |
| return m.Priority |
| } |
| return nil |
| } |
| |
| func (m *Priority) GetPriorityValue() int32 { |
| if x, ok := m.GetPriority().(*Priority_PriorityValue); ok { |
| return x.PriorityValue |
| } |
| return 0 |
| } |
| |
| func (m *Priority) GetPriorityClassName() string { |
| if x, ok := m.GetPriority().(*Priority_PriorityClassName); ok { |
| return x.PriorityClassName |
| } |
| return "" |
| } |
| |
| // XXX_OneofWrappers is for the internal use of the proto package. |
| func (*Priority) XXX_OneofWrappers() []interface{} { |
| return []interface{}{ |
| (*Priority_PriorityValue)(nil), |
| (*Priority_PriorityClassName)(nil), |
| } |
| } |
| |
| // A sparse map of resource to Quantity. |
| type Resource struct { |
| Resources map[string]*Quantity `protobuf:"bytes,1,rep,name=resources,proto3" json:"resources,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 *Resource) Reset() { *m = Resource{} } |
| func (m *Resource) String() string { return proto.CompactTextString(m) } |
| func (*Resource) ProtoMessage() {} |
| func (*Resource) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{10} |
| } |
| |
| func (m *Resource) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Resource.Unmarshal(m, b) |
| } |
| func (m *Resource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Resource.Marshal(b, m, deterministic) |
| } |
| func (m *Resource) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Resource.Merge(m, src) |
| } |
| func (m *Resource) XXX_Size() int { |
| return xxx_messageInfo_Resource.Size(m) |
| } |
| func (m *Resource) XXX_DiscardUnknown() { |
| xxx_messageInfo_Resource.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Resource proto.InternalMessageInfo |
| |
| func (m *Resource) GetResources() map[string]*Quantity { |
| if m != nil { |
| return m.Resources |
| } |
| return nil |
| } |
| |
| // Quantity includes a single int64 value |
| type Quantity struct { |
| Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Quantity) Reset() { *m = Quantity{} } |
| func (m *Quantity) String() string { return proto.CompactTextString(m) } |
| func (*Quantity) ProtoMessage() {} |
| func (*Quantity) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{11} |
| } |
| |
| func (m *Quantity) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Quantity.Unmarshal(m, b) |
| } |
| func (m *Quantity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Quantity.Marshal(b, m, deterministic) |
| } |
| func (m *Quantity) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Quantity.Merge(m, src) |
| } |
| func (m *Quantity) XXX_Size() int { |
| return xxx_messageInfo_Quantity.Size(m) |
| } |
| func (m *Quantity) XXX_DiscardUnknown() { |
| xxx_messageInfo_Quantity.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Quantity proto.InternalMessageInfo |
| |
| func (m *Quantity) GetValue() int64 { |
| if m != nil { |
| return m.Value |
| } |
| return 0 |
| } |
| |
| type AllocationAsk struct { |
| // Allocation key is used by both of scheduler and RM to track allocations. |
| // It doesn't have to be same as RM's internal allocation id (such as Pod name of K8s or ContainerID of YARN). |
| // Allocations from the same AllocationAsk which are returned to the RM at the same time will have the same allocationKey. |
| // The request is considered an update of the existing AllocationAsk if an ALlocationAsk with the same allocationKey |
| // already exists. |
| AllocationKey string `protobuf:"bytes,1,opt,name=allocationKey,proto3" json:"allocationKey,omitempty"` |
| // The application ID this allocation ask belongs to |
| ApplicationID string `protobuf:"bytes,2,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // The partition the application belongs to |
| PartitionName string `protobuf:"bytes,3,opt,name=partitionName,proto3" json:"partitionName,omitempty"` |
| // The amount of resources per ask |
| ResourceAsk *Resource `protobuf:"bytes,4,opt,name=resourceAsk,proto3" json:"resourceAsk,omitempty"` |
| // Maximum number of allocations |
| MaxAllocations int32 `protobuf:"varint,5,opt,name=maxAllocations,proto3" json:"maxAllocations,omitempty"` |
| // Priority of ask |
| Priority *Priority `protobuf:"bytes,6,opt,name=priority,proto3" json:"priority,omitempty"` |
| // Execution timeout: How long this allocation will be terminated (by scheduler) |
| // once allocated by scheduler, 0 or negative value means never expire. |
| ExecutionTimeoutMilliSeconds int64 `protobuf:"varint,7,opt,name=executionTimeoutMilliSeconds,proto3" json:"executionTimeoutMilliSeconds,omitempty"` |
| // A set of tags for this spscific AllocationAsk. Allocation level tags are used in placing this specific |
| // ask on nodes in the cluster. These tags are used in the PlacementConstraints. |
| // These tags are optional. |
| Tags map[string]string `protobuf:"bytes,8,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| // Placement constraint defines how this allocation should be placed in the cluster. |
| // if not set, no placement constraint will be applied. |
| PlacementConstraint *PlacementConstraint `protobuf:"bytes,9,opt,name=placementConstraint,proto3" json:"placementConstraint,omitempty"` |
| // The name of the TaskGroup this ask belongs to |
| TaskGroupName string `protobuf:"bytes,10,opt,name=taskGroupName,proto3" json:"taskGroupName,omitempty"` |
| // Is this a placeholder ask (true) or a real ask (false), defaults to false |
| // ignored if the taskGroupName is not set |
| Placeholder bool `protobuf:"varint,11,opt,name=placeholder,proto3" json:"placeholder,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AllocationAsk) Reset() { *m = AllocationAsk{} } |
| func (m *AllocationAsk) String() string { return proto.CompactTextString(m) } |
| func (*AllocationAsk) ProtoMessage() {} |
| func (*AllocationAsk) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{12} |
| } |
| |
| func (m *AllocationAsk) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AllocationAsk.Unmarshal(m, b) |
| } |
| func (m *AllocationAsk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AllocationAsk.Marshal(b, m, deterministic) |
| } |
| func (m *AllocationAsk) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllocationAsk.Merge(m, src) |
| } |
| func (m *AllocationAsk) XXX_Size() int { |
| return xxx_messageInfo_AllocationAsk.Size(m) |
| } |
| func (m *AllocationAsk) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllocationAsk.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllocationAsk proto.InternalMessageInfo |
| |
| func (m *AllocationAsk) GetAllocationKey() string { |
| if m != nil { |
| return m.AllocationKey |
| } |
| return "" |
| } |
| |
| func (m *AllocationAsk) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *AllocationAsk) GetPartitionName() string { |
| if m != nil { |
| return m.PartitionName |
| } |
| return "" |
| } |
| |
| func (m *AllocationAsk) GetResourceAsk() *Resource { |
| if m != nil { |
| return m.ResourceAsk |
| } |
| return nil |
| } |
| |
| func (m *AllocationAsk) GetMaxAllocations() int32 { |
| if m != nil { |
| return m.MaxAllocations |
| } |
| return 0 |
| } |
| |
| func (m *AllocationAsk) GetPriority() *Priority { |
| if m != nil { |
| return m.Priority |
| } |
| return nil |
| } |
| |
| func (m *AllocationAsk) GetExecutionTimeoutMilliSeconds() int64 { |
| if m != nil { |
| return m.ExecutionTimeoutMilliSeconds |
| } |
| return 0 |
| } |
| |
| func (m *AllocationAsk) GetTags() map[string]string { |
| if m != nil { |
| return m.Tags |
| } |
| return nil |
| } |
| |
| func (m *AllocationAsk) GetPlacementConstraint() *PlacementConstraint { |
| if m != nil { |
| return m.PlacementConstraint |
| } |
| return nil |
| } |
| |
| func (m *AllocationAsk) GetTaskGroupName() string { |
| if m != nil { |
| return m.TaskGroupName |
| } |
| return "" |
| } |
| |
| func (m *AllocationAsk) GetPlaceholder() bool { |
| if m != nil { |
| return m.Placeholder |
| } |
| return false |
| } |
| |
| type AddApplicationRequest struct { |
| // The ID of the application, must be unique |
| ApplicationID string `protobuf:"bytes,1,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // The queue this application is requesting. The scheduler will place the application into a |
| // queue according to policy, taking into account the requested queue as per the policy. |
| QueueName string `protobuf:"bytes,2,opt,name=queueName,proto3" json:"queueName,omitempty"` |
| // The partition the application belongs to |
| PartitionName string `protobuf:"bytes,3,opt,name=partitionName,proto3" json:"partitionName,omitempty"` |
| // The user group information of the application owner |
| Ugi *UserGroupInformation `protobuf:"bytes,4,opt,name=ugi,proto3" json:"ugi,omitempty"` |
| // A set of tags for the application. These tags provide application level generic inforamtion. |
| // The tags are optional and are used in placing an appliction or scheduling. |
| // Application tags are not considered when processing AllocationAsks. |
| Tags map[string]string `protobuf:"bytes,5,rep,name=tags,proto3" json:"tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| // Execution timeout: How long this application can be in a running state |
| // 0 or negative value means never expire. |
| ExecutionTimeoutMilliSeconds int64 `protobuf:"varint,6,opt,name=executionTimeoutMilliSeconds,proto3" json:"executionTimeoutMilliSeconds,omitempty"` |
| // The total amount of resources gang placeholders will request |
| PlaceholderAsk *Resource `protobuf:"bytes,7,opt,name=placeholderAsk,proto3" json:"placeholderAsk,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AddApplicationRequest) Reset() { *m = AddApplicationRequest{} } |
| func (m *AddApplicationRequest) String() string { return proto.CompactTextString(m) } |
| func (*AddApplicationRequest) ProtoMessage() {} |
| func (*AddApplicationRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{13} |
| } |
| |
| func (m *AddApplicationRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AddApplicationRequest.Unmarshal(m, b) |
| } |
| func (m *AddApplicationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AddApplicationRequest.Marshal(b, m, deterministic) |
| } |
| func (m *AddApplicationRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AddApplicationRequest.Merge(m, src) |
| } |
| func (m *AddApplicationRequest) XXX_Size() int { |
| return xxx_messageInfo_AddApplicationRequest.Size(m) |
| } |
| func (m *AddApplicationRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_AddApplicationRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AddApplicationRequest proto.InternalMessageInfo |
| |
| func (m *AddApplicationRequest) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *AddApplicationRequest) GetQueueName() string { |
| if m != nil { |
| return m.QueueName |
| } |
| return "" |
| } |
| |
| func (m *AddApplicationRequest) GetPartitionName() string { |
| if m != nil { |
| return m.PartitionName |
| } |
| return "" |
| } |
| |
| func (m *AddApplicationRequest) GetUgi() *UserGroupInformation { |
| if m != nil { |
| return m.Ugi |
| } |
| return nil |
| } |
| |
| func (m *AddApplicationRequest) GetTags() map[string]string { |
| if m != nil { |
| return m.Tags |
| } |
| return nil |
| } |
| |
| func (m *AddApplicationRequest) GetExecutionTimeoutMilliSeconds() int64 { |
| if m != nil { |
| return m.ExecutionTimeoutMilliSeconds |
| } |
| return 0 |
| } |
| |
| func (m *AddApplicationRequest) GetPlaceholderAsk() *Resource { |
| if m != nil { |
| return m.PlaceholderAsk |
| } |
| return nil |
| } |
| |
| type RemoveApplicationRequest struct { |
| // The ID of the application to remove |
| ApplicationID string `protobuf:"bytes,1,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // The partition the application belongs to |
| PartitionName string `protobuf:"bytes,2,opt,name=partitionName,proto3" json:"partitionName,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *RemoveApplicationRequest) Reset() { *m = RemoveApplicationRequest{} } |
| func (m *RemoveApplicationRequest) String() string { return proto.CompactTextString(m) } |
| func (*RemoveApplicationRequest) ProtoMessage() {} |
| func (*RemoveApplicationRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{14} |
| } |
| |
| func (m *RemoveApplicationRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_RemoveApplicationRequest.Unmarshal(m, b) |
| } |
| func (m *RemoveApplicationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_RemoveApplicationRequest.Marshal(b, m, deterministic) |
| } |
| func (m *RemoveApplicationRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RemoveApplicationRequest.Merge(m, src) |
| } |
| func (m *RemoveApplicationRequest) XXX_Size() int { |
| return xxx_messageInfo_RemoveApplicationRequest.Size(m) |
| } |
| func (m *RemoveApplicationRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_RemoveApplicationRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RemoveApplicationRequest proto.InternalMessageInfo |
| |
| func (m *RemoveApplicationRequest) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *RemoveApplicationRequest) GetPartitionName() string { |
| if m != nil { |
| return m.PartitionName |
| } |
| return "" |
| } |
| |
| type UserGroupInformation struct { |
| // the user name |
| User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"` |
| // the list of groups of the user, can be empty |
| Groups []string `protobuf:"bytes,2,rep,name=groups,proto3" json:"groups,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UserGroupInformation) Reset() { *m = UserGroupInformation{} } |
| func (m *UserGroupInformation) String() string { return proto.CompactTextString(m) } |
| func (*UserGroupInformation) ProtoMessage() {} |
| func (*UserGroupInformation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{15} |
| } |
| |
| func (m *UserGroupInformation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UserGroupInformation.Unmarshal(m, b) |
| } |
| func (m *UserGroupInformation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UserGroupInformation.Marshal(b, m, deterministic) |
| } |
| func (m *UserGroupInformation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UserGroupInformation.Merge(m, src) |
| } |
| func (m *UserGroupInformation) XXX_Size() int { |
| return xxx_messageInfo_UserGroupInformation.Size(m) |
| } |
| func (m *UserGroupInformation) XXX_DiscardUnknown() { |
| xxx_messageInfo_UserGroupInformation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UserGroupInformation proto.InternalMessageInfo |
| |
| func (m *UserGroupInformation) GetUser() string { |
| if m != nil { |
| return m.User |
| } |
| return "" |
| } |
| |
| func (m *UserGroupInformation) GetGroups() []string { |
| if m != nil { |
| return m.Groups |
| } |
| return nil |
| } |
| |
| // PlacementConstraint could have simplePlacementConstraint or |
| // CompositePlacementConstraint. One of them will be set. |
| type PlacementConstraint struct { |
| // Types that are valid to be assigned to Constraint: |
| // *PlacementConstraint_SimpleConstraint |
| Constraint isPlacementConstraint_Constraint `protobuf_oneof:"constraint"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *PlacementConstraint) Reset() { *m = PlacementConstraint{} } |
| func (m *PlacementConstraint) String() string { return proto.CompactTextString(m) } |
| func (*PlacementConstraint) ProtoMessage() {} |
| func (*PlacementConstraint) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{16} |
| } |
| |
| func (m *PlacementConstraint) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_PlacementConstraint.Unmarshal(m, b) |
| } |
| func (m *PlacementConstraint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_PlacementConstraint.Marshal(b, m, deterministic) |
| } |
| func (m *PlacementConstraint) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_PlacementConstraint.Merge(m, src) |
| } |
| func (m *PlacementConstraint) XXX_Size() int { |
| return xxx_messageInfo_PlacementConstraint.Size(m) |
| } |
| func (m *PlacementConstraint) XXX_DiscardUnknown() { |
| xxx_messageInfo_PlacementConstraint.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_PlacementConstraint proto.InternalMessageInfo |
| |
| type isPlacementConstraint_Constraint interface { |
| isPlacementConstraint_Constraint() |
| } |
| |
| type PlacementConstraint_SimpleConstraint struct { |
| SimpleConstraint *SimplePlacementConstraint `protobuf:"bytes,1,opt,name=simpleConstraint,proto3,oneof"` |
| } |
| |
| func (*PlacementConstraint_SimpleConstraint) isPlacementConstraint_Constraint() {} |
| |
| func (m *PlacementConstraint) GetConstraint() isPlacementConstraint_Constraint { |
| if m != nil { |
| return m.Constraint |
| } |
| return nil |
| } |
| |
| func (m *PlacementConstraint) GetSimpleConstraint() *SimplePlacementConstraint { |
| if x, ok := m.GetConstraint().(*PlacementConstraint_SimpleConstraint); ok { |
| return x.SimpleConstraint |
| } |
| return nil |
| } |
| |
| // XXX_OneofWrappers is for the internal use of the proto package. |
| func (*PlacementConstraint) XXX_OneofWrappers() []interface{} { |
| return []interface{}{ |
| (*PlacementConstraint_SimpleConstraint)(nil), |
| } |
| } |
| |
| // Simple placement constraint represent constraint for affinity/anti-affinity |
| // to node attribute or allocation tags. |
| // When both of NodeAffinityConstraints and AllocationAffinityConstraints |
| // specified, both will be checked and verified while scheduling. |
| type SimplePlacementConstraint struct { |
| // Constraint |
| NodeAffinityConstraint *NodeAffinityConstraints `protobuf:"bytes,1,opt,name=nodeAffinityConstraint,proto3" json:"nodeAffinityConstraint,omitempty"` |
| AllocationAffinityAttribute *AllocationAffinityConstraints `protobuf:"bytes,2,opt,name=allocationAffinityAttribute,proto3" json:"allocationAffinityAttribute,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *SimplePlacementConstraint) Reset() { *m = SimplePlacementConstraint{} } |
| func (m *SimplePlacementConstraint) String() string { return proto.CompactTextString(m) } |
| func (*SimplePlacementConstraint) ProtoMessage() {} |
| func (*SimplePlacementConstraint) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{17} |
| } |
| |
| func (m *SimplePlacementConstraint) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_SimplePlacementConstraint.Unmarshal(m, b) |
| } |
| func (m *SimplePlacementConstraint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_SimplePlacementConstraint.Marshal(b, m, deterministic) |
| } |
| func (m *SimplePlacementConstraint) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_SimplePlacementConstraint.Merge(m, src) |
| } |
| func (m *SimplePlacementConstraint) XXX_Size() int { |
| return xxx_messageInfo_SimplePlacementConstraint.Size(m) |
| } |
| func (m *SimplePlacementConstraint) XXX_DiscardUnknown() { |
| xxx_messageInfo_SimplePlacementConstraint.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_SimplePlacementConstraint proto.InternalMessageInfo |
| |
| func (m *SimplePlacementConstraint) GetNodeAffinityConstraint() *NodeAffinityConstraints { |
| if m != nil { |
| return m.NodeAffinityConstraint |
| } |
| return nil |
| } |
| |
| func (m *SimplePlacementConstraint) GetAllocationAffinityAttribute() *AllocationAffinityConstraints { |
| if m != nil { |
| return m.AllocationAffinityAttribute |
| } |
| return nil |
| } |
| |
| // Affinity to node, multiple AffinityTargetExpression will be specified, |
| // They will be connected by AND. |
| type NodeAffinityConstraints struct { |
| TargetExpressions []*AffinityTargetExpression `protobuf:"bytes,2,rep,name=targetExpressions,proto3" json:"targetExpressions,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *NodeAffinityConstraints) Reset() { *m = NodeAffinityConstraints{} } |
| func (m *NodeAffinityConstraints) String() string { return proto.CompactTextString(m) } |
| func (*NodeAffinityConstraints) ProtoMessage() {} |
| func (*NodeAffinityConstraints) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{18} |
| } |
| |
| func (m *NodeAffinityConstraints) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_NodeAffinityConstraints.Unmarshal(m, b) |
| } |
| func (m *NodeAffinityConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_NodeAffinityConstraints.Marshal(b, m, deterministic) |
| } |
| func (m *NodeAffinityConstraints) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NodeAffinityConstraints.Merge(m, src) |
| } |
| func (m *NodeAffinityConstraints) XXX_Size() int { |
| return xxx_messageInfo_NodeAffinityConstraints.Size(m) |
| } |
| func (m *NodeAffinityConstraints) XXX_DiscardUnknown() { |
| xxx_messageInfo_NodeAffinityConstraints.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NodeAffinityConstraints proto.InternalMessageInfo |
| |
| func (m *NodeAffinityConstraints) GetTargetExpressions() []*AffinityTargetExpression { |
| if m != nil { |
| return m.TargetExpressions |
| } |
| return nil |
| } |
| |
| // Affinity to allocations (containers). |
| // Affinity is single-direction, which means if RM wants to do mutual affinity/ |
| // anti-affinity between allocations, same constraints need to be added |
| // to all allocation asks. |
| type AllocationAffinityConstraints struct { |
| // Scope: scope is key of node attribute, which determines if >1 allocations |
| // in the same group or not. |
| // When allocations on node(s) which have same node attribute value |
| // for given node attribute key == scope. They're in the same group. |
| // |
| // e.g. when user wants to do anti-affinity between allocation on node |
| // basis, scope can be set to "hostname", max-cardinality = 1; |
| Scope string `protobuf:"bytes,1,opt,name=scope,proto3" json:"scope,omitempty"` |
| TragetExpressions []*AffinityTargetExpression `protobuf:"bytes,2,rep,name=tragetExpressions,proto3" json:"tragetExpressions,omitempty"` |
| MinCardinality int32 `protobuf:"varint,3,opt,name=minCardinality,proto3" json:"minCardinality,omitempty"` |
| MaxCardinality int32 `protobuf:"varint,4,opt,name=maxCardinality,proto3" json:"maxCardinality,omitempty"` |
| // Is this a required (hard) or preferred (soft) request. |
| Required bool `protobuf:"varint,5,opt,name=required,proto3" json:"required,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AllocationAffinityConstraints) Reset() { *m = AllocationAffinityConstraints{} } |
| func (m *AllocationAffinityConstraints) String() string { return proto.CompactTextString(m) } |
| func (*AllocationAffinityConstraints) ProtoMessage() {} |
| func (*AllocationAffinityConstraints) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{19} |
| } |
| |
| func (m *AllocationAffinityConstraints) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AllocationAffinityConstraints.Unmarshal(m, b) |
| } |
| func (m *AllocationAffinityConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AllocationAffinityConstraints.Marshal(b, m, deterministic) |
| } |
| func (m *AllocationAffinityConstraints) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllocationAffinityConstraints.Merge(m, src) |
| } |
| func (m *AllocationAffinityConstraints) XXX_Size() int { |
| return xxx_messageInfo_AllocationAffinityConstraints.Size(m) |
| } |
| func (m *AllocationAffinityConstraints) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllocationAffinityConstraints.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllocationAffinityConstraints proto.InternalMessageInfo |
| |
| func (m *AllocationAffinityConstraints) GetScope() string { |
| if m != nil { |
| return m.Scope |
| } |
| return "" |
| } |
| |
| func (m *AllocationAffinityConstraints) GetTragetExpressions() []*AffinityTargetExpression { |
| if m != nil { |
| return m.TragetExpressions |
| } |
| return nil |
| } |
| |
| func (m *AllocationAffinityConstraints) GetMinCardinality() int32 { |
| if m != nil { |
| return m.MinCardinality |
| } |
| return 0 |
| } |
| |
| func (m *AllocationAffinityConstraints) GetMaxCardinality() int32 { |
| if m != nil { |
| return m.MaxCardinality |
| } |
| return 0 |
| } |
| |
| func (m *AllocationAffinityConstraints) GetRequired() bool { |
| if m != nil { |
| return m.Required |
| } |
| return false |
| } |
| |
| type AffinityTargetExpression struct { |
| TargetOperator *AffinityTargetExpression `protobuf:"bytes,1,opt,name=targetOperator,proto3" json:"targetOperator,omitempty"` |
| TargetKey string `protobuf:"bytes,2,opt,name=targetKey,proto3" json:"targetKey,omitempty"` |
| TargetValues []string `protobuf:"bytes,3,rep,name=targetValues,proto3" json:"targetValues,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AffinityTargetExpression) Reset() { *m = AffinityTargetExpression{} } |
| func (m *AffinityTargetExpression) String() string { return proto.CompactTextString(m) } |
| func (*AffinityTargetExpression) ProtoMessage() {} |
| func (*AffinityTargetExpression) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{20} |
| } |
| |
| func (m *AffinityTargetExpression) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AffinityTargetExpression.Unmarshal(m, b) |
| } |
| func (m *AffinityTargetExpression) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AffinityTargetExpression.Marshal(b, m, deterministic) |
| } |
| func (m *AffinityTargetExpression) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AffinityTargetExpression.Merge(m, src) |
| } |
| func (m *AffinityTargetExpression) XXX_Size() int { |
| return xxx_messageInfo_AffinityTargetExpression.Size(m) |
| } |
| func (m *AffinityTargetExpression) XXX_DiscardUnknown() { |
| xxx_messageInfo_AffinityTargetExpression.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AffinityTargetExpression proto.InternalMessageInfo |
| |
| func (m *AffinityTargetExpression) GetTargetOperator() *AffinityTargetExpression { |
| if m != nil { |
| return m.TargetOperator |
| } |
| return nil |
| } |
| |
| func (m *AffinityTargetExpression) GetTargetKey() string { |
| if m != nil { |
| return m.TargetKey |
| } |
| return "" |
| } |
| |
| func (m *AffinityTargetExpression) GetTargetValues() []string { |
| if m != nil { |
| return m.TargetValues |
| } |
| return nil |
| } |
| |
| type Allocation struct { |
| // AllocationKey from AllocationAsk |
| AllocationKey string `protobuf:"bytes,1,opt,name=allocationKey,proto3" json:"allocationKey,omitempty"` |
| // Allocation tags from AllocationAsk |
| AllocationTags map[string]string `protobuf:"bytes,2,rep,name=allocationTags,proto3" json:"allocationTags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| // UUID of the allocation |
| UUID string `protobuf:"bytes,3,opt,name=UUID,proto3" json:"UUID,omitempty"` |
| // Resource for each allocation |
| ResourcePerAlloc *Resource `protobuf:"bytes,5,opt,name=resourcePerAlloc,proto3" json:"resourcePerAlloc,omitempty"` |
| // Priority of ask |
| Priority *Priority `protobuf:"bytes,6,opt,name=priority,proto3" json:"priority,omitempty"` |
| // Queue which the allocation belongs to |
| QueueName string `protobuf:"bytes,7,opt,name=queueName,proto3" json:"queueName,omitempty"` |
| // Node which the allocation belongs to |
| NodeID string `protobuf:"bytes,8,opt,name=nodeID,proto3" json:"nodeID,omitempty"` |
| // The ID of the application |
| ApplicationID string `protobuf:"bytes,9,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // Partition of the allocation |
| PartitionName string `protobuf:"bytes,10,opt,name=partitionName,proto3" json:"partitionName,omitempty"` |
| // The name of the TaskGroup this allocation belongs to |
| TaskGroupName string `protobuf:"bytes,11,opt,name=taskGroupName,proto3" json:"taskGroupName,omitempty"` |
| // Is this a placeholder allocation (true) or a real allocation (false), defaults to false |
| // ignored if the taskGroupName is not set |
| Placeholder bool `protobuf:"varint,12,opt,name=placeholder,proto3" json:"placeholder,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *Allocation) Reset() { *m = Allocation{} } |
| func (m *Allocation) String() string { return proto.CompactTextString(m) } |
| func (*Allocation) ProtoMessage() {} |
| func (*Allocation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{21} |
| } |
| |
| func (m *Allocation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_Allocation.Unmarshal(m, b) |
| } |
| func (m *Allocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_Allocation.Marshal(b, m, deterministic) |
| } |
| func (m *Allocation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_Allocation.Merge(m, src) |
| } |
| func (m *Allocation) XXX_Size() int { |
| return xxx_messageInfo_Allocation.Size(m) |
| } |
| func (m *Allocation) XXX_DiscardUnknown() { |
| xxx_messageInfo_Allocation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_Allocation proto.InternalMessageInfo |
| |
| func (m *Allocation) GetAllocationKey() string { |
| if m != nil { |
| return m.AllocationKey |
| } |
| return "" |
| } |
| |
| func (m *Allocation) GetAllocationTags() map[string]string { |
| if m != nil { |
| return m.AllocationTags |
| } |
| return nil |
| } |
| |
| func (m *Allocation) GetUUID() string { |
| if m != nil { |
| return m.UUID |
| } |
| return "" |
| } |
| |
| func (m *Allocation) GetResourcePerAlloc() *Resource { |
| if m != nil { |
| return m.ResourcePerAlloc |
| } |
| return nil |
| } |
| |
| func (m *Allocation) GetPriority() *Priority { |
| if m != nil { |
| return m.Priority |
| } |
| return nil |
| } |
| |
| func (m *Allocation) GetQueueName() string { |
| if m != nil { |
| return m.QueueName |
| } |
| return "" |
| } |
| |
| func (m *Allocation) GetNodeID() string { |
| if m != nil { |
| return m.NodeID |
| } |
| return "" |
| } |
| |
| func (m *Allocation) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *Allocation) GetPartitionName() string { |
| if m != nil { |
| return m.PartitionName |
| } |
| return "" |
| } |
| |
| func (m *Allocation) GetTaskGroupName() string { |
| if m != nil { |
| return m.TaskGroupName |
| } |
| return "" |
| } |
| |
| func (m *Allocation) GetPlaceholder() bool { |
| if m != nil { |
| return m.Placeholder |
| } |
| return false |
| } |
| |
| type AllocationReleasesRequest struct { |
| // The allocations to release |
| AllocationsToRelease []*AllocationRelease `protobuf:"bytes,1,rep,name=allocationsToRelease,proto3" json:"allocationsToRelease,omitempty"` |
| // The asks to release |
| AllocationAsksToRelease []*AllocationAskRelease `protobuf:"bytes,2,rep,name=allocationAsksToRelease,proto3" json:"allocationAsksToRelease,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AllocationReleasesRequest) Reset() { *m = AllocationReleasesRequest{} } |
| func (m *AllocationReleasesRequest) String() string { return proto.CompactTextString(m) } |
| func (*AllocationReleasesRequest) ProtoMessage() {} |
| func (*AllocationReleasesRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{22} |
| } |
| |
| func (m *AllocationReleasesRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AllocationReleasesRequest.Unmarshal(m, b) |
| } |
| func (m *AllocationReleasesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AllocationReleasesRequest.Marshal(b, m, deterministic) |
| } |
| func (m *AllocationReleasesRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllocationReleasesRequest.Merge(m, src) |
| } |
| func (m *AllocationReleasesRequest) XXX_Size() int { |
| return xxx_messageInfo_AllocationReleasesRequest.Size(m) |
| } |
| func (m *AllocationReleasesRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllocationReleasesRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllocationReleasesRequest proto.InternalMessageInfo |
| |
| func (m *AllocationReleasesRequest) GetAllocationsToRelease() []*AllocationRelease { |
| if m != nil { |
| return m.AllocationsToRelease |
| } |
| return nil |
| } |
| |
| func (m *AllocationReleasesRequest) GetAllocationAsksToRelease() []*AllocationAskRelease { |
| if m != nil { |
| return m.AllocationAsksToRelease |
| } |
| return nil |
| } |
| |
| // Release allocation: this is a bidirectional message. The Terminationtype defines the origin, or creator, |
| // as per the comment. The confirmation or response from the receiver is the same message with the same |
| // termination type set. |
| type AllocationRelease struct { |
| // The name of the partition the allocation belongs to |
| PartitionName string `protobuf:"bytes,1,opt,name=partitionName,proto3" json:"partitionName,omitempty"` |
| // The application the allocation belongs to |
| ApplicationID string `protobuf:"bytes,2,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // The UUID of the allocation to release, if not set all allocations are released for |
| // the applicationID |
| UUID string `protobuf:"bytes,3,opt,name=UUID,proto3" json:"UUID,omitempty"` |
| // Termination type of the released allocation |
| TerminationType TerminationType `protobuf:"varint,4,opt,name=terminationType,proto3,enum=si.v1.TerminationType" json:"terminationType,omitempty"` |
| // human-readable message |
| Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AllocationRelease) Reset() { *m = AllocationRelease{} } |
| func (m *AllocationRelease) String() string { return proto.CompactTextString(m) } |
| func (*AllocationRelease) ProtoMessage() {} |
| func (*AllocationRelease) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{23} |
| } |
| |
| func (m *AllocationRelease) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AllocationRelease.Unmarshal(m, b) |
| } |
| func (m *AllocationRelease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AllocationRelease.Marshal(b, m, deterministic) |
| } |
| func (m *AllocationRelease) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllocationRelease.Merge(m, src) |
| } |
| func (m *AllocationRelease) XXX_Size() int { |
| return xxx_messageInfo_AllocationRelease.Size(m) |
| } |
| func (m *AllocationRelease) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllocationRelease.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllocationRelease proto.InternalMessageInfo |
| |
| func (m *AllocationRelease) GetPartitionName() string { |
| if m != nil { |
| return m.PartitionName |
| } |
| return "" |
| } |
| |
| func (m *AllocationRelease) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *AllocationRelease) GetUUID() string { |
| if m != nil { |
| return m.UUID |
| } |
| return "" |
| } |
| |
| func (m *AllocationRelease) GetTerminationType() TerminationType { |
| if m != nil { |
| return m.TerminationType |
| } |
| return TerminationType_STOPPED_BY_RM |
| } |
| |
| func (m *AllocationRelease) GetMessage() string { |
| if m != nil { |
| return m.Message |
| } |
| return "" |
| } |
| |
| // Release ask |
| type AllocationAskRelease struct { |
| // Which partition to release the ask from, required. |
| PartitionName string `protobuf:"bytes,1,opt,name=partitionName,proto3" json:"partitionName,omitempty"` |
| // optional, when this is set, filter allocation key by application id. |
| // when application id is set and allocationKey is not set, release all allocations key under the application id. |
| ApplicationID string `protobuf:"bytes,2,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // optional, when this is set, only release allocation ask by specified |
| Allocationkey string `protobuf:"bytes,3,opt,name=allocationkey,proto3" json:"allocationkey,omitempty"` |
| // Termination type of the released allocation ask |
| TerminationType TerminationType `protobuf:"varint,4,opt,name=terminationType,proto3,enum=si.v1.TerminationType" json:"terminationType,omitempty"` |
| // For human-readable message |
| Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AllocationAskRelease) Reset() { *m = AllocationAskRelease{} } |
| func (m *AllocationAskRelease) String() string { return proto.CompactTextString(m) } |
| func (*AllocationAskRelease) ProtoMessage() {} |
| func (*AllocationAskRelease) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{24} |
| } |
| |
| func (m *AllocationAskRelease) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AllocationAskRelease.Unmarshal(m, b) |
| } |
| func (m *AllocationAskRelease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AllocationAskRelease.Marshal(b, m, deterministic) |
| } |
| func (m *AllocationAskRelease) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AllocationAskRelease.Merge(m, src) |
| } |
| func (m *AllocationAskRelease) XXX_Size() int { |
| return xxx_messageInfo_AllocationAskRelease.Size(m) |
| } |
| func (m *AllocationAskRelease) XXX_DiscardUnknown() { |
| xxx_messageInfo_AllocationAskRelease.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AllocationAskRelease proto.InternalMessageInfo |
| |
| func (m *AllocationAskRelease) GetPartitionName() string { |
| if m != nil { |
| return m.PartitionName |
| } |
| return "" |
| } |
| |
| func (m *AllocationAskRelease) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *AllocationAskRelease) GetAllocationkey() string { |
| if m != nil { |
| return m.Allocationkey |
| } |
| return "" |
| } |
| |
| func (m *AllocationAskRelease) GetTerminationType() TerminationType { |
| if m != nil { |
| return m.TerminationType |
| } |
| return TerminationType_STOPPED_BY_RM |
| } |
| |
| func (m *AllocationAskRelease) GetMessage() string { |
| if m != nil { |
| return m.Message |
| } |
| return "" |
| } |
| |
| type NewNodeInfo struct { |
| // ID of node, must be unique |
| NodeID string `protobuf:"bytes,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"` |
| // node attributes |
| Attributes map[string]string `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| // Schedulable Resource |
| SchedulableResource *Resource `protobuf:"bytes,3,opt,name=schedulableResource,proto3" json:"schedulableResource,omitempty"` |
| // Occupied Resource |
| OccupiedResource *Resource `protobuf:"bytes,4,opt,name=occupiedResource,proto3" json:"occupiedResource,omitempty"` |
| // Allocated resources, this will be added when node registered to RM (recovery) |
| ExistingAllocations []*Allocation `protobuf:"bytes,5,rep,name=existingAllocations,proto3" json:"existingAllocations,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *NewNodeInfo) Reset() { *m = NewNodeInfo{} } |
| func (m *NewNodeInfo) String() string { return proto.CompactTextString(m) } |
| func (*NewNodeInfo) ProtoMessage() {} |
| func (*NewNodeInfo) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{25} |
| } |
| |
| func (m *NewNodeInfo) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_NewNodeInfo.Unmarshal(m, b) |
| } |
| func (m *NewNodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_NewNodeInfo.Marshal(b, m, deterministic) |
| } |
| func (m *NewNodeInfo) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NewNodeInfo.Merge(m, src) |
| } |
| func (m *NewNodeInfo) XXX_Size() int { |
| return xxx_messageInfo_NewNodeInfo.Size(m) |
| } |
| func (m *NewNodeInfo) XXX_DiscardUnknown() { |
| xxx_messageInfo_NewNodeInfo.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NewNodeInfo proto.InternalMessageInfo |
| |
| func (m *NewNodeInfo) GetNodeID() string { |
| if m != nil { |
| return m.NodeID |
| } |
| return "" |
| } |
| |
| func (m *NewNodeInfo) GetAttributes() map[string]string { |
| if m != nil { |
| return m.Attributes |
| } |
| return nil |
| } |
| |
| func (m *NewNodeInfo) GetSchedulableResource() *Resource { |
| if m != nil { |
| return m.SchedulableResource |
| } |
| return nil |
| } |
| |
| func (m *NewNodeInfo) GetOccupiedResource() *Resource { |
| if m != nil { |
| return m.OccupiedResource |
| } |
| return nil |
| } |
| |
| func (m *NewNodeInfo) GetExistingAllocations() []*Allocation { |
| if m != nil { |
| return m.ExistingAllocations |
| } |
| return nil |
| } |
| |
| type UpdateNodeInfo struct { |
| // ID of node, the node must exist to be updated |
| NodeID string `protobuf:"bytes,1,opt,name=nodeID,proto3" json:"nodeID,omitempty"` |
| // New attributes of node, which will replace previously reported attribute. |
| Attributes map[string]string `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` |
| // new schedulable resource, scheduler may preempt allocations on the |
| // node or schedule more allocations accordingly. |
| SchedulableResource *Resource `protobuf:"bytes,3,opt,name=schedulableResource,proto3" json:"schedulableResource,omitempty"` |
| // when the scheduler is co-exist with some other schedulers, some node |
| // resources might be occupied (allocated) by other schedulers. |
| OccupiedResource *Resource `protobuf:"bytes,4,opt,name=occupiedResource,proto3" json:"occupiedResource,omitempty"` |
| // Action to perform by the scheduler |
| Action UpdateNodeInfo_ActionFromRM `protobuf:"varint,5,opt,name=action,proto3,enum=si.v1.UpdateNodeInfo_ActionFromRM" json:"action,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UpdateNodeInfo) Reset() { *m = UpdateNodeInfo{} } |
| func (m *UpdateNodeInfo) String() string { return proto.CompactTextString(m) } |
| func (*UpdateNodeInfo) ProtoMessage() {} |
| func (*UpdateNodeInfo) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{26} |
| } |
| |
| func (m *UpdateNodeInfo) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UpdateNodeInfo.Unmarshal(m, b) |
| } |
| func (m *UpdateNodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UpdateNodeInfo.Marshal(b, m, deterministic) |
| } |
| func (m *UpdateNodeInfo) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UpdateNodeInfo.Merge(m, src) |
| } |
| func (m *UpdateNodeInfo) XXX_Size() int { |
| return xxx_messageInfo_UpdateNodeInfo.Size(m) |
| } |
| func (m *UpdateNodeInfo) XXX_DiscardUnknown() { |
| xxx_messageInfo_UpdateNodeInfo.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UpdateNodeInfo proto.InternalMessageInfo |
| |
| func (m *UpdateNodeInfo) GetNodeID() string { |
| if m != nil { |
| return m.NodeID |
| } |
| return "" |
| } |
| |
| func (m *UpdateNodeInfo) GetAttributes() map[string]string { |
| if m != nil { |
| return m.Attributes |
| } |
| return nil |
| } |
| |
| func (m *UpdateNodeInfo) GetSchedulableResource() *Resource { |
| if m != nil { |
| return m.SchedulableResource |
| } |
| return nil |
| } |
| |
| func (m *UpdateNodeInfo) GetOccupiedResource() *Resource { |
| if m != nil { |
| return m.OccupiedResource |
| } |
| return nil |
| } |
| |
| func (m *UpdateNodeInfo) GetAction() UpdateNodeInfo_ActionFromRM { |
| if m != nil { |
| return m.Action |
| } |
| return UpdateNodeInfo_UPDATE |
| } |
| |
| type UtilizationReport struct { |
| // it could be either a nodeID or allocation UUID. |
| ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"` |
| // Actual used resource |
| ActualUsedResource *Resource `protobuf:"bytes,2,opt,name=actualUsedResource,proto3" json:"actualUsedResource,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UtilizationReport) Reset() { *m = UtilizationReport{} } |
| func (m *UtilizationReport) String() string { return proto.CompactTextString(m) } |
| func (*UtilizationReport) ProtoMessage() {} |
| func (*UtilizationReport) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{27} |
| } |
| |
| func (m *UtilizationReport) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UtilizationReport.Unmarshal(m, b) |
| } |
| func (m *UtilizationReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UtilizationReport.Marshal(b, m, deterministic) |
| } |
| func (m *UtilizationReport) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UtilizationReport.Merge(m, src) |
| } |
| func (m *UtilizationReport) XXX_Size() int { |
| return xxx_messageInfo_UtilizationReport.Size(m) |
| } |
| func (m *UtilizationReport) XXX_DiscardUnknown() { |
| xxx_messageInfo_UtilizationReport.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UtilizationReport proto.InternalMessageInfo |
| |
| func (m *UtilizationReport) GetID() string { |
| if m != nil { |
| return m.ID |
| } |
| return "" |
| } |
| |
| func (m *UtilizationReport) GetActualUsedResource() *Resource { |
| if m != nil { |
| return m.ActualUsedResource |
| } |
| return nil |
| } |
| |
| type RejectedAllocationAsk struct { |
| AllocationKey string `protobuf:"bytes,1,opt,name=allocationKey,proto3" json:"allocationKey,omitempty"` |
| // The ID of the application |
| ApplicationID string `protobuf:"bytes,2,opt,name=applicationID,proto3" json:"applicationID,omitempty"` |
| // A human-readable reason message |
| Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *RejectedAllocationAsk) Reset() { *m = RejectedAllocationAsk{} } |
| func (m *RejectedAllocationAsk) String() string { return proto.CompactTextString(m) } |
| func (*RejectedAllocationAsk) ProtoMessage() {} |
| func (*RejectedAllocationAsk) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{28} |
| } |
| |
| func (m *RejectedAllocationAsk) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_RejectedAllocationAsk.Unmarshal(m, b) |
| } |
| func (m *RejectedAllocationAsk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_RejectedAllocationAsk.Marshal(b, m, deterministic) |
| } |
| func (m *RejectedAllocationAsk) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_RejectedAllocationAsk.Merge(m, src) |
| } |
| func (m *RejectedAllocationAsk) XXX_Size() int { |
| return xxx_messageInfo_RejectedAllocationAsk.Size(m) |
| } |
| func (m *RejectedAllocationAsk) XXX_DiscardUnknown() { |
| xxx_messageInfo_RejectedAllocationAsk.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_RejectedAllocationAsk proto.InternalMessageInfo |
| |
| func (m *RejectedAllocationAsk) GetAllocationKey() string { |
| if m != nil { |
| return m.AllocationKey |
| } |
| return "" |
| } |
| |
| func (m *RejectedAllocationAsk) GetApplicationID() string { |
| if m != nil { |
| return m.ApplicationID |
| } |
| return "" |
| } |
| |
| func (m *RejectedAllocationAsk) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type NodeRecommendation struct { |
| RecommendedSchedulableResource *Resource `protobuf:"bytes,1,opt,name=recommendedSchedulableResource,proto3" json:"recommendedSchedulableResource,omitempty"` |
| // Any other human-readable message |
| Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *NodeRecommendation) Reset() { *m = NodeRecommendation{} } |
| func (m *NodeRecommendation) String() string { return proto.CompactTextString(m) } |
| func (*NodeRecommendation) ProtoMessage() {} |
| func (*NodeRecommendation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{29} |
| } |
| |
| func (m *NodeRecommendation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_NodeRecommendation.Unmarshal(m, b) |
| } |
| func (m *NodeRecommendation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_NodeRecommendation.Marshal(b, m, deterministic) |
| } |
| func (m *NodeRecommendation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_NodeRecommendation.Merge(m, src) |
| } |
| func (m *NodeRecommendation) XXX_Size() int { |
| return xxx_messageInfo_NodeRecommendation.Size(m) |
| } |
| func (m *NodeRecommendation) XXX_DiscardUnknown() { |
| xxx_messageInfo_NodeRecommendation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_NodeRecommendation proto.InternalMessageInfo |
| |
| func (m *NodeRecommendation) GetRecommendedSchedulableResource() *Resource { |
| if m != nil { |
| return m.RecommendedSchedulableResource |
| } |
| return nil |
| } |
| |
| func (m *NodeRecommendation) GetMessage() string { |
| if m != nil { |
| return m.Message |
| } |
| return "" |
| } |
| |
| type PredicatesArgs struct { |
| // allocation key identifies a container, the predicates function is going to check |
| // if this container is eligible to be placed ont to a node. |
| AllocationKey string `protobuf:"bytes,1,opt,name=allocationKey,proto3" json:"allocationKey,omitempty"` |
| // the node ID the container is assigned to. |
| NodeID string `protobuf:"bytes,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"` |
| // run the predicates for alloactions (true) or reservations (false) |
| Allocate bool `protobuf:"varint,3,opt,name=allocate,proto3" json:"allocate,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *PredicatesArgs) Reset() { *m = PredicatesArgs{} } |
| func (m *PredicatesArgs) String() string { return proto.CompactTextString(m) } |
| func (*PredicatesArgs) ProtoMessage() {} |
| func (*PredicatesArgs) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{30} |
| } |
| |
| func (m *PredicatesArgs) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_PredicatesArgs.Unmarshal(m, b) |
| } |
| func (m *PredicatesArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_PredicatesArgs.Marshal(b, m, deterministic) |
| } |
| func (m *PredicatesArgs) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_PredicatesArgs.Merge(m, src) |
| } |
| func (m *PredicatesArgs) XXX_Size() int { |
| return xxx_messageInfo_PredicatesArgs.Size(m) |
| } |
| func (m *PredicatesArgs) XXX_DiscardUnknown() { |
| xxx_messageInfo_PredicatesArgs.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_PredicatesArgs proto.InternalMessageInfo |
| |
| func (m *PredicatesArgs) GetAllocationKey() string { |
| if m != nil { |
| return m.AllocationKey |
| } |
| return "" |
| } |
| |
| func (m *PredicatesArgs) GetNodeID() string { |
| if m != nil { |
| return m.NodeID |
| } |
| return "" |
| } |
| |
| func (m *PredicatesArgs) GetAllocate() bool { |
| if m != nil { |
| return m.Allocate |
| } |
| return false |
| } |
| |
| type ReSyncSchedulerCacheArgs struct { |
| // a list of assumed allocations, this will be sync'd to scheduler cache. |
| AssumedAllocations []*AssumedAllocation `protobuf:"bytes,1,rep,name=assumedAllocations,proto3" json:"assumedAllocations,omitempty"` |
| // a list of allocations to forget |
| ForgetAllocations []*ForgotAllocation `protobuf:"bytes,2,rep,name=forgetAllocations,proto3" json:"forgetAllocations,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *ReSyncSchedulerCacheArgs) Reset() { *m = ReSyncSchedulerCacheArgs{} } |
| func (m *ReSyncSchedulerCacheArgs) String() string { return proto.CompactTextString(m) } |
| func (*ReSyncSchedulerCacheArgs) ProtoMessage() {} |
| func (*ReSyncSchedulerCacheArgs) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{31} |
| } |
| |
| func (m *ReSyncSchedulerCacheArgs) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_ReSyncSchedulerCacheArgs.Unmarshal(m, b) |
| } |
| func (m *ReSyncSchedulerCacheArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_ReSyncSchedulerCacheArgs.Marshal(b, m, deterministic) |
| } |
| func (m *ReSyncSchedulerCacheArgs) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ReSyncSchedulerCacheArgs.Merge(m, src) |
| } |
| func (m *ReSyncSchedulerCacheArgs) XXX_Size() int { |
| return xxx_messageInfo_ReSyncSchedulerCacheArgs.Size(m) |
| } |
| func (m *ReSyncSchedulerCacheArgs) XXX_DiscardUnknown() { |
| xxx_messageInfo_ReSyncSchedulerCacheArgs.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ReSyncSchedulerCacheArgs proto.InternalMessageInfo |
| |
| func (m *ReSyncSchedulerCacheArgs) GetAssumedAllocations() []*AssumedAllocation { |
| if m != nil { |
| return m.AssumedAllocations |
| } |
| return nil |
| } |
| |
| func (m *ReSyncSchedulerCacheArgs) GetForgetAllocations() []*ForgotAllocation { |
| if m != nil { |
| return m.ForgetAllocations |
| } |
| return nil |
| } |
| |
| type AssumedAllocation struct { |
| // allocation key used to identify a container. |
| AllocationKey string `protobuf:"bytes,1,opt,name=allocationKey,proto3" json:"allocationKey,omitempty"` |
| // the node ID the container is assumed to be allocated to, this info is stored in scheduler cache. |
| NodeID string `protobuf:"bytes,2,opt,name=nodeID,proto3" json:"nodeID,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AssumedAllocation) Reset() { *m = AssumedAllocation{} } |
| func (m *AssumedAllocation) String() string { return proto.CompactTextString(m) } |
| func (*AssumedAllocation) ProtoMessage() {} |
| func (*AssumedAllocation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{32} |
| } |
| |
| func (m *AssumedAllocation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AssumedAllocation.Unmarshal(m, b) |
| } |
| func (m *AssumedAllocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AssumedAllocation.Marshal(b, m, deterministic) |
| } |
| func (m *AssumedAllocation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AssumedAllocation.Merge(m, src) |
| } |
| func (m *AssumedAllocation) XXX_Size() int { |
| return xxx_messageInfo_AssumedAllocation.Size(m) |
| } |
| func (m *AssumedAllocation) XXX_DiscardUnknown() { |
| xxx_messageInfo_AssumedAllocation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AssumedAllocation proto.InternalMessageInfo |
| |
| func (m *AssumedAllocation) GetAllocationKey() string { |
| if m != nil { |
| return m.AllocationKey |
| } |
| return "" |
| } |
| |
| func (m *AssumedAllocation) GetNodeID() string { |
| if m != nil { |
| return m.NodeID |
| } |
| return "" |
| } |
| |
| type ForgotAllocation struct { |
| // allocation key used to identify a container. |
| AllocationKey string `protobuf:"bytes,1,opt,name=allocationKey,proto3" json:"allocationKey,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *ForgotAllocation) Reset() { *m = ForgotAllocation{} } |
| func (m *ForgotAllocation) String() string { return proto.CompactTextString(m) } |
| func (*ForgotAllocation) ProtoMessage() {} |
| func (*ForgotAllocation) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{33} |
| } |
| |
| func (m *ForgotAllocation) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_ForgotAllocation.Unmarshal(m, b) |
| } |
| func (m *ForgotAllocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_ForgotAllocation.Marshal(b, m, deterministic) |
| } |
| func (m *ForgotAllocation) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_ForgotAllocation.Merge(m, src) |
| } |
| func (m *ForgotAllocation) XXX_Size() int { |
| return xxx_messageInfo_ForgotAllocation.Size(m) |
| } |
| func (m *ForgotAllocation) XXX_DiscardUnknown() { |
| xxx_messageInfo_ForgotAllocation.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_ForgotAllocation proto.InternalMessageInfo |
| |
| func (m *ForgotAllocation) GetAllocationKey() string { |
| if m != nil { |
| return m.AllocationKey |
| } |
| return "" |
| } |
| |
| type UpdateContainerSchedulingStateRequest struct { |
| // application ID |
| ApplicartionID string `protobuf:"bytes,1,opt,name=applicartionID,proto3" json:"applicartionID,omitempty"` |
| // allocation key used to identify a container. |
| AllocationKey string `protobuf:"bytes,2,opt,name=allocationKey,proto3" json:"allocationKey,omitempty"` |
| // container scheduling state |
| State UpdateContainerSchedulingStateRequest_SchedulingState `protobuf:"varint,3,opt,name=state,proto3,enum=si.v1.UpdateContainerSchedulingStateRequest_SchedulingState" json:"state,omitempty"` |
| // an optional plain message to explain why it is in such state |
| Reason string `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UpdateContainerSchedulingStateRequest) Reset() { *m = UpdateContainerSchedulingStateRequest{} } |
| func (m *UpdateContainerSchedulingStateRequest) String() string { return proto.CompactTextString(m) } |
| func (*UpdateContainerSchedulingStateRequest) ProtoMessage() {} |
| func (*UpdateContainerSchedulingStateRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{34} |
| } |
| |
| func (m *UpdateContainerSchedulingStateRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UpdateContainerSchedulingStateRequest.Unmarshal(m, b) |
| } |
| func (m *UpdateContainerSchedulingStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UpdateContainerSchedulingStateRequest.Marshal(b, m, deterministic) |
| } |
| func (m *UpdateContainerSchedulingStateRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UpdateContainerSchedulingStateRequest.Merge(m, src) |
| } |
| func (m *UpdateContainerSchedulingStateRequest) XXX_Size() int { |
| return xxx_messageInfo_UpdateContainerSchedulingStateRequest.Size(m) |
| } |
| func (m *UpdateContainerSchedulingStateRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_UpdateContainerSchedulingStateRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UpdateContainerSchedulingStateRequest proto.InternalMessageInfo |
| |
| func (m *UpdateContainerSchedulingStateRequest) GetApplicartionID() string { |
| if m != nil { |
| return m.ApplicartionID |
| } |
| return "" |
| } |
| |
| func (m *UpdateContainerSchedulingStateRequest) GetAllocationKey() string { |
| if m != nil { |
| return m.AllocationKey |
| } |
| return "" |
| } |
| |
| func (m *UpdateContainerSchedulingStateRequest) GetState() UpdateContainerSchedulingStateRequest_SchedulingState { |
| if m != nil { |
| return m.State |
| } |
| return UpdateContainerSchedulingStateRequest_SKIPPED |
| } |
| |
| func (m *UpdateContainerSchedulingStateRequest) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type UpdateConfigurationRequest struct { |
| // New config what needs to be saved |
| Configs string `protobuf:"bytes,1,opt,name=configs,proto3" json:"configs,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UpdateConfigurationRequest) Reset() { *m = UpdateConfigurationRequest{} } |
| func (m *UpdateConfigurationRequest) String() string { return proto.CompactTextString(m) } |
| func (*UpdateConfigurationRequest) ProtoMessage() {} |
| func (*UpdateConfigurationRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{35} |
| } |
| |
| func (m *UpdateConfigurationRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UpdateConfigurationRequest.Unmarshal(m, b) |
| } |
| func (m *UpdateConfigurationRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UpdateConfigurationRequest.Marshal(b, m, deterministic) |
| } |
| func (m *UpdateConfigurationRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UpdateConfigurationRequest.Merge(m, src) |
| } |
| func (m *UpdateConfigurationRequest) XXX_Size() int { |
| return xxx_messageInfo_UpdateConfigurationRequest.Size(m) |
| } |
| func (m *UpdateConfigurationRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_UpdateConfigurationRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UpdateConfigurationRequest proto.InternalMessageInfo |
| |
| func (m *UpdateConfigurationRequest) GetConfigs() string { |
| if m != nil { |
| return m.Configs |
| } |
| return "" |
| } |
| |
| type UpdateConfigurationResponse struct { |
| // flag that marks the config update success or failure |
| Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"` |
| // the old configuration what was changed |
| OldConfig string `protobuf:"bytes,2,opt,name=oldConfig,proto3" json:"oldConfig,omitempty"` |
| // reason in case of failure |
| Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *UpdateConfigurationResponse) Reset() { *m = UpdateConfigurationResponse{} } |
| func (m *UpdateConfigurationResponse) String() string { return proto.CompactTextString(m) } |
| func (*UpdateConfigurationResponse) ProtoMessage() {} |
| func (*UpdateConfigurationResponse) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{36} |
| } |
| |
| func (m *UpdateConfigurationResponse) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_UpdateConfigurationResponse.Unmarshal(m, b) |
| } |
| func (m *UpdateConfigurationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_UpdateConfigurationResponse.Marshal(b, m, deterministic) |
| } |
| func (m *UpdateConfigurationResponse) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_UpdateConfigurationResponse.Merge(m, src) |
| } |
| func (m *UpdateConfigurationResponse) XXX_Size() int { |
| return xxx_messageInfo_UpdateConfigurationResponse.Size(m) |
| } |
| func (m *UpdateConfigurationResponse) XXX_DiscardUnknown() { |
| xxx_messageInfo_UpdateConfigurationResponse.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_UpdateConfigurationResponse proto.InternalMessageInfo |
| |
| func (m *UpdateConfigurationResponse) GetSuccess() bool { |
| if m != nil { |
| return m.Success |
| } |
| return false |
| } |
| |
| func (m *UpdateConfigurationResponse) GetOldConfig() string { |
| if m != nil { |
| return m.OldConfig |
| } |
| return "" |
| } |
| |
| func (m *UpdateConfigurationResponse) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| type EventRecord struct { |
| // the type of the object associated with the event |
| Type EventRecord_Type `protobuf:"varint,1,opt,name=type,proto3,enum=si.v1.EventRecord_Type" json:"type,omitempty"` |
| // ID of the object associated with the event |
| ObjectID string `protobuf:"bytes,2,opt,name=objectID,proto3" json:"objectID,omitempty"` |
| // the group this object belongs to |
| // it specifies the application ID for allocations and the queue for applications |
| GroupID string `protobuf:"bytes,3,opt,name=groupID,proto3" json:"groupID,omitempty"` |
| // the reason of this event |
| Reason string `protobuf:"bytes,4,opt,name=reason,proto3" json:"reason,omitempty"` |
| // the detailed message as string |
| Message string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"` |
| // timestamp of the event |
| TimestampNano int64 `protobuf:"varint,6,opt,name=timestampNano,proto3" json:"timestampNano,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *EventRecord) Reset() { *m = EventRecord{} } |
| func (m *EventRecord) String() string { return proto.CompactTextString(m) } |
| func (*EventRecord) ProtoMessage() {} |
| func (*EventRecord) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{37} |
| } |
| |
| func (m *EventRecord) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_EventRecord.Unmarshal(m, b) |
| } |
| func (m *EventRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_EventRecord.Marshal(b, m, deterministic) |
| } |
| func (m *EventRecord) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_EventRecord.Merge(m, src) |
| } |
| func (m *EventRecord) XXX_Size() int { |
| return xxx_messageInfo_EventRecord.Size(m) |
| } |
| func (m *EventRecord) XXX_DiscardUnknown() { |
| xxx_messageInfo_EventRecord.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_EventRecord proto.InternalMessageInfo |
| |
| func (m *EventRecord) GetType() EventRecord_Type { |
| if m != nil { |
| return m.Type |
| } |
| return EventRecord_REQUEST |
| } |
| |
| func (m *EventRecord) GetObjectID() string { |
| if m != nil { |
| return m.ObjectID |
| } |
| return "" |
| } |
| |
| func (m *EventRecord) GetGroupID() string { |
| if m != nil { |
| return m.GroupID |
| } |
| return "" |
| } |
| |
| func (m *EventRecord) GetReason() string { |
| if m != nil { |
| return m.Reason |
| } |
| return "" |
| } |
| |
| func (m *EventRecord) GetMessage() string { |
| if m != nil { |
| return m.Message |
| } |
| return "" |
| } |
| |
| func (m *EventRecord) GetTimestampNano() int64 { |
| if m != nil { |
| return m.TimestampNano |
| } |
| return 0 |
| } |
| |
| // auto scaling metrics at a certain point of time |
| type AutoScalingMetrics struct { |
| // a list of outstanding requests that desires for additional resources |
| OutstandingRequests []*OutstandingResourceRequest `protobuf:"bytes,1,rep,name=outstandingRequests,proto3" json:"outstandingRequests,omitempty"` |
| XXX_NoUnkeyedLiteral struct{} `json:"-"` |
| XXX_unrecognized []byte `json:"-"` |
| XXX_sizecache int32 `json:"-"` |
| } |
| |
| func (m *AutoScalingMetrics) Reset() { *m = AutoScalingMetrics{} } |
| func (m *AutoScalingMetrics) String() string { return proto.CompactTextString(m) } |
| func (*AutoScalingMetrics) ProtoMessage() {} |
| func (*AutoScalingMetrics) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{38} |
| } |
| |
| func (m *AutoScalingMetrics) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_AutoScalingMetrics.Unmarshal(m, b) |
| } |
| func (m *AutoScalingMetrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_AutoScalingMetrics.Marshal(b, m, deterministic) |
| } |
| func (m *AutoScalingMetrics) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_AutoScalingMetrics.Merge(m, src) |
| } |
| func (m *AutoScalingMetrics) XXX_Size() int { |
| return xxx_messageInfo_AutoScalingMetrics.Size(m) |
| } |
| func (m *AutoScalingMetrics) XXX_DiscardUnknown() { |
| xxx_messageInfo_AutoScalingMetrics.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_AutoScalingMetrics proto.InternalMessageInfo |
| |
| func (m *AutoScalingMetrics) GetOutstandingRequests() []*OutstandingResourceRequest { |
| if m != nil { |
| return m.OutstandingRequests |
| } |
| return nil |
| } |
| |
| type OutstandingResourceRequest struct { |
| // an unique ID |
| RequestID string `protobuf:"bytes,1,opt,name=requestID,proto3" json:"requestID,omitempty"` |
| // resource specification |
| Resource *Resource `protobuf:"bytes,2,opt,name=resource,proto3" json:"resource,omitempty"` |
| // an arbitrary map for tags, this stores some useful information that can help the decision |
| Tags map[string]string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags,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 *OutstandingResourceRequest) Reset() { *m = OutstandingResourceRequest{} } |
| func (m *OutstandingResourceRequest) String() string { return proto.CompactTextString(m) } |
| func (*OutstandingResourceRequest) ProtoMessage() {} |
| func (*OutstandingResourceRequest) Descriptor() ([]byte, []int) { |
| return fileDescriptor_bcd2636ebca16c8c, []int{39} |
| } |
| |
| func (m *OutstandingResourceRequest) XXX_Unmarshal(b []byte) error { |
| return xxx_messageInfo_OutstandingResourceRequest.Unmarshal(m, b) |
| } |
| func (m *OutstandingResourceRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
| return xxx_messageInfo_OutstandingResourceRequest.Marshal(b, m, deterministic) |
| } |
| func (m *OutstandingResourceRequest) XXX_Merge(src proto.Message) { |
| xxx_messageInfo_OutstandingResourceRequest.Merge(m, src) |
| } |
| func (m *OutstandingResourceRequest) XXX_Size() int { |
| return xxx_messageInfo_OutstandingResourceRequest.Size(m) |
| } |
| func (m *OutstandingResourceRequest) XXX_DiscardUnknown() { |
| xxx_messageInfo_OutstandingResourceRequest.DiscardUnknown(m) |
| } |
| |
| var xxx_messageInfo_OutstandingResourceRequest proto.InternalMessageInfo |
| |
| func (m *OutstandingResourceRequest) GetRequestID() string { |
| if m != nil { |
| return m.RequestID |
| } |
| return "" |
| } |
| |
| func (m *OutstandingResourceRequest) GetResource() *Resource { |
| if m != nil { |
| return m.Resource |
| } |
| return nil |
| } |
| |
| func (m *OutstandingResourceRequest) GetTags() map[string]string { |
| if m != nil { |
| return m.Tags |
| } |
| return nil |
| } |
| |
| var E_SiSecret = &proto.ExtensionDesc{ |
| ExtendedType: (*descriptor.FieldOptions)(nil), |
| ExtensionType: (*bool)(nil), |
| Field: 1059, |
| Name: "si.v1.si_secret", |
| Tag: "varint,1059,opt,name=si_secret", |
| Filename: "incubator-yunikorn-scheduler-interface/si.proto", |
| } |
| |
| func init() { |
| proto.RegisterEnum("si.v1.TerminationType", TerminationType_name, TerminationType_value) |
| proto.RegisterEnum("si.v1.UpdateResponse_ActionFromScheduler", UpdateResponse_ActionFromScheduler_name, UpdateResponse_ActionFromScheduler_value) |
| proto.RegisterEnum("si.v1.AffinityTargetExpression_AffinityTargetOperator", AffinityTargetExpression_AffinityTargetOperator_name, AffinityTargetExpression_AffinityTargetOperator_value) |
| proto.RegisterEnum("si.v1.UpdateNodeInfo_ActionFromRM", UpdateNodeInfo_ActionFromRM_name, UpdateNodeInfo_ActionFromRM_value) |
| proto.RegisterEnum("si.v1.UpdateContainerSchedulingStateRequest_SchedulingState", UpdateContainerSchedulingStateRequest_SchedulingState_name, UpdateContainerSchedulingStateRequest_SchedulingState_value) |
| proto.RegisterEnum("si.v1.EventRecord_Type", EventRecord_Type_name, EventRecord_Type_value) |
| proto.RegisterType((*RegisterResourceManagerRequest)(nil), "si.v1.RegisterResourceManagerRequest") |
| proto.RegisterType((*RegisterResourceManagerResponse)(nil), "si.v1.RegisterResourceManagerResponse") |
| proto.RegisterType((*UpdateRequest)(nil), "si.v1.UpdateRequest") |
| proto.RegisterType((*UpdateResponse)(nil), "si.v1.UpdateResponse") |
| proto.RegisterType((*UpdatedApplication)(nil), "si.v1.UpdatedApplication") |
| proto.RegisterType((*RejectedApplication)(nil), "si.v1.RejectedApplication") |
| proto.RegisterType((*AcceptedApplication)(nil), "si.v1.AcceptedApplication") |
| proto.RegisterType((*RejectedNode)(nil), "si.v1.RejectedNode") |
| proto.RegisterType((*AcceptedNode)(nil), "si.v1.AcceptedNode") |
| proto.RegisterType((*Priority)(nil), "si.v1.Priority") |
| proto.RegisterType((*Resource)(nil), "si.v1.Resource") |
| proto.RegisterMapType((map[string]*Quantity)(nil), "si.v1.Resource.ResourcesEntry") |
| proto.RegisterType((*Quantity)(nil), "si.v1.Quantity") |
| proto.RegisterType((*AllocationAsk)(nil), "si.v1.AllocationAsk") |
| proto.RegisterMapType((map[string]string)(nil), "si.v1.AllocationAsk.TagsEntry") |
| proto.RegisterType((*AddApplicationRequest)(nil), "si.v1.AddApplicationRequest") |
| proto.RegisterMapType((map[string]string)(nil), "si.v1.AddApplicationRequest.TagsEntry") |
| proto.RegisterType((*RemoveApplicationRequest)(nil), "si.v1.RemoveApplicationRequest") |
| proto.RegisterType((*UserGroupInformation)(nil), "si.v1.UserGroupInformation") |
| proto.RegisterType((*PlacementConstraint)(nil), "si.v1.PlacementConstraint") |
| proto.RegisterType((*SimplePlacementConstraint)(nil), "si.v1.SimplePlacementConstraint") |
| proto.RegisterType((*NodeAffinityConstraints)(nil), "si.v1.NodeAffinityConstraints") |
| proto.RegisterType((*AllocationAffinityConstraints)(nil), "si.v1.AllocationAffinityConstraints") |
| proto.RegisterType((*AffinityTargetExpression)(nil), "si.v1.AffinityTargetExpression") |
| proto.RegisterType((*Allocation)(nil), "si.v1.Allocation") |
| proto.RegisterMapType((map[string]string)(nil), "si.v1.Allocation.AllocationTagsEntry") |
| proto.RegisterType((*AllocationReleasesRequest)(nil), "si.v1.AllocationReleasesRequest") |
| proto.RegisterType((*AllocationRelease)(nil), "si.v1.AllocationRelease") |
| proto.RegisterType((*AllocationAskRelease)(nil), "si.v1.AllocationAskRelease") |
| proto.RegisterType((*NewNodeInfo)(nil), "si.v1.NewNodeInfo") |
| proto.RegisterMapType((map[string]string)(nil), "si.v1.NewNodeInfo.AttributesEntry") |
| proto.RegisterType((*UpdateNodeInfo)(nil), "si.v1.UpdateNodeInfo") |
| proto.RegisterMapType((map[string]string)(nil), "si.v1.UpdateNodeInfo.AttributesEntry") |
| proto.RegisterType((*UtilizationReport)(nil), "si.v1.UtilizationReport") |
| proto.RegisterType((*RejectedAllocationAsk)(nil), "si.v1.RejectedAllocationAsk") |
| proto.RegisterType((*NodeRecommendation)(nil), "si.v1.NodeRecommendation") |
| proto.RegisterType((*PredicatesArgs)(nil), "si.v1.PredicatesArgs") |
| proto.RegisterType((*ReSyncSchedulerCacheArgs)(nil), "si.v1.ReSyncSchedulerCacheArgs") |
| proto.RegisterType((*AssumedAllocation)(nil), "si.v1.AssumedAllocation") |
| proto.RegisterType((*ForgotAllocation)(nil), "si.v1.ForgotAllocation") |
| proto.RegisterType((*UpdateContainerSchedulingStateRequest)(nil), "si.v1.UpdateContainerSchedulingStateRequest") |
| proto.RegisterType((*UpdateConfigurationRequest)(nil), "si.v1.UpdateConfigurationRequest") |
| proto.RegisterType((*UpdateConfigurationResponse)(nil), "si.v1.UpdateConfigurationResponse") |
| proto.RegisterType((*EventRecord)(nil), "si.v1.EventRecord") |
| proto.RegisterType((*AutoScalingMetrics)(nil), "si.v1.AutoScalingMetrics") |
| proto.RegisterType((*OutstandingResourceRequest)(nil), "si.v1.OutstandingResourceRequest") |
| proto.RegisterMapType((map[string]string)(nil), "si.v1.OutstandingResourceRequest.TagsEntry") |
| proto.RegisterExtension(E_SiSecret) |
| } |
| |
| func init() { |
| proto.RegisterFile("incubator-yunikorn-scheduler-interface/si.proto", fileDescriptor_bcd2636ebca16c8c) |
| } |
| |
| var fileDescriptor_bcd2636ebca16c8c = []byte{ |
| // 2583 bytes of a gzipped FileDescriptorProto |
| 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x72, 0xdb, 0xc8, |
| 0xf1, 0x17, 0x48, 0x4a, 0x22, 0x9b, 0x12, 0x45, 0x0d, 0x65, 0x99, 0xd6, 0xee, 0x7a, 0xb5, 0xa8, |
| 0xb5, 0x4a, 0xff, 0xff, 0x96, 0xe9, 0x58, 0xa9, 0xca, 0xae, 0x3f, 0x92, 0x0d, 0x25, 0x42, 0x16, |
| 0x63, 0x89, 0xa4, 0x87, 0xa4, 0x93, 0xcd, 0x45, 0x05, 0x81, 0x23, 0x1a, 0x16, 0x09, 0xd0, 0x33, |
| 0x80, 0x6c, 0x25, 0x0f, 0x90, 0x4b, 0xee, 0xb9, 0x27, 0x55, 0x39, 0x24, 0xd7, 0x3c, 0x40, 0xf2, |
| 0x04, 0xc9, 0x3d, 0x97, 0xa4, 0x2a, 0xd7, 0xad, 0xe4, 0x9e, 0x4b, 0x6a, 0x06, 0x03, 0x10, 0x5f, |
| 0xb4, 0x68, 0xef, 0xa6, 0x2a, 0x37, 0x4c, 0xe3, 0xd7, 0x8d, 0x9e, 0xee, 0x9e, 0xee, 0x9e, 0x26, |
| 0xe1, 0x9e, 0x69, 0x19, 0xee, 0x99, 0xee, 0xd8, 0xf4, 0xee, 0x95, 0x6b, 0x99, 0x17, 0x36, 0xb5, |
| 0xee, 0x32, 0xe3, 0x05, 0x19, 0xb8, 0x23, 0x42, 0xef, 0x9a, 0x96, 0x43, 0xe8, 0xb9, 0x6e, 0x90, |
| 0x7b, 0xcc, 0xac, 0x4d, 0xa8, 0xed, 0xd8, 0x68, 0x91, 0x99, 0xb5, 0xcb, 0xfb, 0x5b, 0xdb, 0x43, |
| 0xdb, 0x1e, 0x8e, 0xc8, 0x3d, 0x41, 0x3c, 0x73, 0xcf, 0xef, 0x0d, 0x08, 0x33, 0xa8, 0x39, 0x71, |
| 0x6c, 0xea, 0x01, 0xd5, 0x09, 0xdc, 0xc6, 0x64, 0x68, 0x32, 0x87, 0x50, 0x4c, 0x98, 0xed, 0x52, |
| 0x83, 0x9c, 0xe8, 0x96, 0x3e, 0xe4, 0xcb, 0x57, 0x2e, 0x61, 0x0e, 0x42, 0x90, 0xa3, 0xe3, 0x66, |
| 0xa3, 0xaa, 0x6c, 0x2b, 0xbb, 0x05, 0x2c, 0x9e, 0x51, 0x15, 0x96, 0x2f, 0x09, 0x65, 0xa6, 0x6d, |
| 0x55, 0x33, 0x82, 0xec, 0x2f, 0xd1, 0x36, 0x14, 0x27, 0xf6, 0xc8, 0x34, 0xae, 0x9e, 0x50, 0xdb, |
| 0x9d, 0x54, 0xb3, 0xe2, 0x6d, 0x98, 0xa4, 0x7e, 0x02, 0x1f, 0xcf, 0xfc, 0x22, 0x9b, 0xd8, 0x16, |
| 0x23, 0xea, 0x3f, 0xb3, 0xb0, 0xda, 0x9f, 0x0c, 0x74, 0x87, 0xf8, 0x4a, 0xec, 0x42, 0x4e, 0x67, |
| 0x17, 0xac, 0xaa, 0x6c, 0x67, 0x77, 0x8b, 0x7b, 0x1b, 0x35, 0xb1, 0xbd, 0x5a, 0x7d, 0x34, 0xb2, |
| 0x0d, 0xdd, 0x31, 0x6d, 0xab, 0xce, 0x2e, 0xb0, 0x40, 0xa0, 0xc7, 0x90, 0xa7, 0x64, 0x44, 0x74, |
| 0x46, 0x98, 0xd0, 0xad, 0xb8, 0xb7, 0x9d, 0x40, 0x63, 0x09, 0x90, 0xd2, 0x71, 0xc0, 0x81, 0x1a, |
| 0x50, 0xb1, 0xc8, 0xeb, 0xae, 0x67, 0x5a, 0xfd, 0x6c, 0x44, 0x5a, 0xf6, 0x80, 0xb0, 0x6a, 0x56, |
| 0x7c, 0x16, 0x49, 0x41, 0x2d, 0xf2, 0x9a, 0x93, 0x9b, 0xd6, 0xb9, 0x8d, 0xd3, 0xe0, 0xe8, 0x01, |
| 0xac, 0xb8, 0x42, 0xfd, 0x81, 0xc7, 0x9e, 0x13, 0xec, 0x37, 0x24, 0xbb, 0xb7, 0xb3, 0x40, 0x42, |
| 0x04, 0x8a, 0x8e, 0x00, 0xb9, 0x8e, 0x39, 0x32, 0x7f, 0x26, 0x15, 0x9d, 0xd8, 0xd4, 0x61, 0xd5, |
| 0x45, 0x21, 0xa0, 0xea, 0x0b, 0x88, 0x03, 0x70, 0x0a, 0x4f, 0xe0, 0xb7, 0xa5, 0x90, 0xdf, 0x0e, |
| 0x61, 0xcd, 0x22, 0xaf, 0xeb, 0x93, 0xc9, 0xc8, 0xf4, 0x2c, 0xc1, 0xaa, 0x79, 0x21, 0xfa, 0x43, |
| 0xdf, 0x46, 0x83, 0x41, 0xe8, 0xad, 0x6f, 0x9f, 0x38, 0x13, 0x6a, 0x03, 0xa2, 0x64, 0x6c, 0x5f, |
| 0x92, 0x88, 0xa8, 0x82, 0x10, 0xf5, 0xb1, 0x14, 0x85, 0xe3, 0x00, 0x5f, 0x5a, 0x0a, 0xab, 0xfa, |
| 0xb7, 0x25, 0x28, 0xf9, 0x1e, 0xf7, 0x82, 0x00, 0xd5, 0x61, 0x49, 0x37, 0xf8, 0x5b, 0x11, 0x79, |
| 0xa5, 0xbd, 0xff, 0x8b, 0x98, 0xcf, 0x87, 0xd5, 0xea, 0x02, 0x73, 0x48, 0xed, 0x71, 0xd7, 0x3f, |
| 0x10, 0x58, 0x32, 0xa2, 0x07, 0x50, 0xe2, 0x9a, 0x07, 0x7e, 0xe7, 0x11, 0xc1, 0x55, 0x5c, 0x4f, |
| 0x46, 0x44, 0x0c, 0x88, 0x7e, 0x04, 0x15, 0x19, 0x14, 0x83, 0x30, 0x7f, 0x36, 0xe2, 0x88, 0x44, |
| 0x44, 0xe1, 0x34, 0x26, 0xd4, 0x85, 0xcd, 0x24, 0xb9, 0xce, 0xc3, 0xd9, 0x0b, 0x8c, 0x0f, 0x52, |
| 0xc3, 0x59, 0x4a, 0x9c, 0xc1, 0x8a, 0x5a, 0x5c, 0xc1, 0x97, 0xc4, 0x70, 0xa2, 0x0a, 0x2e, 0x46, |
| 0xdc, 0x89, 0x13, 0x08, 0x2e, 0x39, 0x8d, 0x11, 0x3d, 0x85, 0x8a, 0x65, 0x0f, 0x08, 0x26, 0x86, |
| 0x3d, 0x1e, 0x13, 0x6b, 0x20, 0xe5, 0x2d, 0x09, 0x79, 0xb7, 0xfc, 0xc8, 0x4f, 0x20, 0x70, 0x1a, |
| 0x17, 0x6a, 0xc1, 0x46, 0xf0, 0x8d, 0x70, 0x84, 0x2c, 0x0b, 0x69, 0x5b, 0x71, 0xed, 0x42, 0x31, |
| 0x92, 0xca, 0xc7, 0xe5, 0xe9, 0x86, 0x41, 0x26, 0x71, 0x79, 0xf9, 0x88, 0xbc, 0x7a, 0x12, 0x82, |
| 0x53, 0xf9, 0xf8, 0x66, 0xe5, 0xa9, 0x4b, 0x09, 0xe0, 0x5b, 0x91, 0x40, 0x8b, 0x48, 0x4b, 0xe3, |
| 0x42, 0x0f, 0x60, 0xd5, 0x57, 0xda, 0x3b, 0xee, 0x20, 0xc4, 0x54, 0x62, 0xbb, 0x14, 0xb6, 0x8b, |
| 0x22, 0x39, 0xab, 0xaf, 0x9f, 0xc7, 0x5a, 0x8c, 0xb0, 0xd6, 0x43, 0xef, 0x70, 0x14, 0xa9, 0xde, |
| 0x83, 0x4a, 0x4a, 0xe8, 0xa3, 0x15, 0xc8, 0xb7, 0xda, 0xf5, 0x83, 0x5e, 0xb3, 0xdd, 0x2a, 0x2f, |
| 0x20, 0x80, 0x25, 0xac, 0x75, 0xbf, 0x6a, 0x1d, 0x94, 0x15, 0xf5, 0xb7, 0x0a, 0xa0, 0xe4, 0x96, |
| 0xd0, 0xa7, 0xb0, 0xaa, 0x4f, 0x97, 0x41, 0x9e, 0x8f, 0x12, 0xd1, 0x06, 0x2c, 0x32, 0x47, 0x77, |
| 0x88, 0x4c, 0xf7, 0xde, 0x02, 0x3d, 0x84, 0xaa, 0x78, 0xe8, 0x51, 0xdd, 0x62, 0x26, 0x87, 0xf6, |
| 0xcc, 0x31, 0x61, 0x8e, 0x3e, 0xf6, 0x32, 0x7f, 0x16, 0xcf, 0x7c, 0xcf, 0x4b, 0xc8, 0x98, 0x30, |
| 0xa6, 0x0f, 0x49, 0x35, 0xe7, 0x95, 0x10, 0xb9, 0x54, 0xbb, 0x50, 0x49, 0x89, 0x8c, 0x39, 0x15, |
| 0xdd, 0x84, 0x25, 0x4a, 0x74, 0x16, 0x14, 0x26, 0xb9, 0x52, 0x1f, 0x71, 0x73, 0x25, 0x22, 0x61, |
| 0x3e, 0xa1, 0xea, 0x0f, 0x60, 0x25, 0xec, 0x45, 0xfe, 0x11, 0x1e, 0xf5, 0x01, 0x5c, 0xae, 0x66, |
| 0x7e, 0x7c, 0x07, 0x56, 0xc2, 0xae, 0x9c, 0xc5, 0xaf, 0x5a, 0x90, 0xef, 0x50, 0xd3, 0xa6, 0xa6, |
| 0x73, 0x85, 0x76, 0x60, 0x75, 0x22, 0x9f, 0x9f, 0xeb, 0x23, 0x97, 0x08, 0xe8, 0xe2, 0xd1, 0x02, |
| 0x8e, 0x92, 0x51, 0x0d, 0xd6, 0x7d, 0xc2, 0xc1, 0x48, 0x67, 0xac, 0xa5, 0x8f, 0xa5, 0x97, 0x8e, |
| 0x16, 0x70, 0xf2, 0xd5, 0x3e, 0x40, 0xde, 0x27, 0xaa, 0xbf, 0x52, 0x20, 0xef, 0xd7, 0x60, 0xf4, |
| 0x18, 0x0a, 0x54, 0x3e, 0xfb, 0x75, 0xf6, 0x76, 0x10, 0xc2, 0x1e, 0x3d, 0x78, 0x60, 0x9a, 0xe5, |
| 0xd0, 0x2b, 0x3c, 0x65, 0xd8, 0x3a, 0x81, 0x52, 0xf4, 0x25, 0x2a, 0x43, 0xf6, 0x82, 0x5c, 0xc9, |
| 0x1d, 0xf2, 0x47, 0x74, 0x07, 0x16, 0x2f, 0xc5, 0x56, 0xbc, 0xba, 0xbc, 0x26, 0xa5, 0x3f, 0x73, |
| 0x75, 0xcb, 0x31, 0x9d, 0x2b, 0xec, 0xbd, 0x7d, 0x98, 0xf9, 0x42, 0x51, 0xb7, 0x21, 0xef, 0x93, |
| 0x79, 0xec, 0x5d, 0x06, 0x16, 0xc8, 0x4a, 0x94, 0xfa, 0x97, 0x1c, 0xac, 0x46, 0xd2, 0x9a, 0xf0, |
| 0x65, 0x40, 0x78, 0x1a, 0x7c, 0x3a, 0x4a, 0x4c, 0x7a, 0x3c, 0x93, 0x16, 0x46, 0x9f, 0xc2, 0xea, |
| 0x44, 0xa7, 0x8e, 0x88, 0x59, 0x61, 0x51, 0xaf, 0x91, 0x89, 0x12, 0xd1, 0x7d, 0x28, 0xfa, 0x16, |
| 0xa8, 0xb3, 0x0b, 0x11, 0xc7, 0xd3, 0x6d, 0xf9, 0xe6, 0xc0, 0x61, 0x0c, 0xda, 0x81, 0xd2, 0x58, |
| 0x7f, 0x13, 0xcd, 0xd8, 0xca, 0xee, 0x22, 0x8e, 0x51, 0xd1, 0x67, 0x53, 0x37, 0x89, 0x0a, 0x3e, |
| 0x95, 0xeb, 0x47, 0x08, 0x0e, 0x00, 0x68, 0x1f, 0x3e, 0x24, 0x6f, 0x88, 0xe1, 0xfa, 0x27, 0xcc, |
| 0x76, 0x9d, 0x13, 0x73, 0x34, 0x32, 0xbb, 0xc4, 0xb0, 0xad, 0x01, 0x4f, 0xbb, 0xdc, 0x70, 0x6f, |
| 0xc5, 0xa0, 0x3d, 0xc8, 0x39, 0xfa, 0xd0, 0x4f, 0xa9, 0xb7, 0xd3, 0x4a, 0x52, 0xad, 0xa7, 0x0f, |
| 0xa5, 0xe7, 0x05, 0x16, 0x1d, 0x43, 0x65, 0x32, 0xd2, 0x0d, 0x32, 0x26, 0x96, 0x73, 0x60, 0x5b, |
| 0xcc, 0xa1, 0xba, 0x69, 0x39, 0xd5, 0x82, 0xd0, 0xd7, 0xcf, 0xca, 0x9d, 0x24, 0x02, 0xa7, 0xb1, |
| 0x71, 0x9b, 0x3b, 0x3a, 0xbb, 0x10, 0x5d, 0xa2, 0xb0, 0x39, 0x78, 0x36, 0x8f, 0x10, 0x45, 0x83, |
| 0xc9, 0x99, 0x5f, 0xd8, 0xa3, 0x01, 0xa1, 0xd5, 0xe2, 0xb6, 0xb2, 0x9b, 0xc7, 0x61, 0xd2, 0xd6, |
| 0xe7, 0x50, 0x08, 0x14, 0x4d, 0x89, 0xc2, 0x8d, 0x70, 0x14, 0x16, 0xc2, 0x41, 0xf7, 0xeb, 0x2c, |
| 0xdc, 0x48, 0x6d, 0x80, 0xe6, 0xcc, 0x3d, 0x1f, 0x42, 0xe1, 0x95, 0x4b, 0x5c, 0x32, 0x3d, 0x82, |
| 0x78, 0x4a, 0x98, 0x33, 0xa4, 0xee, 0x42, 0xd6, 0x1d, 0x9a, 0x32, 0x94, 0xfc, 0xc6, 0xa0, 0xcf, |
| 0x08, 0x15, 0x16, 0xe0, 0x0d, 0x23, 0x1d, 0x7b, 0xaa, 0x71, 0x1c, 0x7a, 0x28, 0xbd, 0xe6, 0x95, |
| 0xfd, 0x9d, 0xb7, 0x75, 0x71, 0x09, 0xef, 0x5d, 0x17, 0x35, 0x4b, 0x73, 0x44, 0xcd, 0xe7, 0x50, |
| 0x0a, 0x99, 0x9e, 0x1f, 0x82, 0xe5, 0xf4, 0x43, 0x10, 0x83, 0xbd, 0xbf, 0x93, 0xce, 0xa1, 0x3a, |
| 0xab, 0xb3, 0x9c, 0xd3, 0x4d, 0x09, 0x47, 0x64, 0x52, 0x1c, 0xa1, 0xee, 0xc3, 0x46, 0x9a, 0xd9, |
| 0x79, 0x5b, 0xed, 0x32, 0x42, 0xfd, 0xeb, 0x10, 0x7f, 0xe6, 0xf9, 0x7c, 0xc8, 0x71, 0x5e, 0x7f, |
| 0x59, 0xc0, 0x72, 0xa5, 0x32, 0xa8, 0xa4, 0x44, 0x3f, 0x6a, 0x41, 0x99, 0x99, 0xe3, 0xc9, 0x88, |
| 0x84, 0xce, 0x8c, 0x12, 0xb9, 0xaa, 0x74, 0xc5, 0xeb, 0x14, 0xde, 0xa3, 0x05, 0x9c, 0xe0, 0xdd, |
| 0x5f, 0x01, 0x30, 0x82, 0x95, 0xfa, 0x57, 0x05, 0x6e, 0xcd, 0xe4, 0x47, 0xcf, 0x61, 0x93, 0x17, |
| 0x9b, 0xfa, 0xf9, 0xb9, 0x69, 0xf1, 0xba, 0x10, 0xd7, 0xe0, 0x76, 0xa8, 0xd3, 0x4b, 0x82, 0x18, |
| 0x9e, 0xc1, 0x8d, 0xce, 0xe1, 0x83, 0x69, 0x9e, 0xf5, 0xdf, 0xd7, 0x1d, 0x87, 0x9a, 0x67, 0xae, |
| 0xe3, 0x67, 0xfc, 0x4f, 0x93, 0x59, 0x25, 0xe5, 0x13, 0x6f, 0x13, 0xa4, 0xbe, 0x80, 0x9b, 0x33, |
| 0x54, 0x43, 0x27, 0xb0, 0xee, 0xe8, 0x74, 0x48, 0x1c, 0xed, 0xcd, 0x84, 0x12, 0xc6, 0x42, 0x0d, |
| 0xbf, 0x7f, 0x27, 0xf1, 0xd9, 0x7a, 0x31, 0x1c, 0x4e, 0x72, 0xaa, 0xff, 0x52, 0xe0, 0xa3, 0xb7, |
| 0x2a, 0x2a, 0x9a, 0x22, 0xc3, 0x9e, 0x10, 0x19, 0x0b, 0xde, 0x42, 0xa8, 0x41, 0xf5, 0xf7, 0x55, |
| 0x23, 0xce, 0x29, 0x0a, 0x86, 0x69, 0x1d, 0xe8, 0x74, 0x60, 0x5a, 0xfa, 0x88, 0x97, 0x83, 0xac, |
| 0x2c, 0x18, 0x11, 0xaa, 0x2c, 0x2c, 0x61, 0x5c, 0x2e, 0x28, 0x2c, 0x61, 0xdc, 0x16, 0xbf, 0x1f, |
| 0xbf, 0x72, 0x4d, 0x4a, 0x06, 0xa2, 0xf4, 0xe4, 0x71, 0xb0, 0x56, 0xbf, 0x56, 0xa0, 0x3a, 0x4b, |
| 0x37, 0xf4, 0x04, 0x4a, 0x9e, 0x91, 0xda, 0x13, 0x42, 0x75, 0xc7, 0xa6, 0x32, 0x62, 0xae, 0xdd, |
| 0x54, 0x8c, 0x8d, 0xa7, 0x49, 0x8f, 0xc2, 0x6b, 0xb4, 0x4c, 0x93, 0x01, 0x01, 0xa9, 0xb0, 0xe2, |
| 0x2d, 0x44, 0x7b, 0xe3, 0xdd, 0xb8, 0x0a, 0x38, 0x42, 0x53, 0x0f, 0x61, 0x33, 0xfa, 0xb5, 0x40, |
| 0xf6, 0x12, 0x64, 0x9a, 0xb2, 0xf1, 0x6d, 0xb5, 0x7b, 0xa7, 0xcd, 0x56, 0x59, 0x41, 0x05, 0x58, |
| 0xd4, 0x7e, 0xd2, 0xec, 0xf6, 0xca, 0x19, 0xb4, 0x0a, 0x05, 0x4e, 0xf6, 0x96, 0x59, 0xf5, 0x97, |
| 0x39, 0x80, 0xa9, 0x8b, 0xe7, 0x6c, 0x20, 0x4e, 0xa0, 0x34, 0x25, 0xf0, 0x1c, 0x26, 0x9d, 0x7b, |
| 0x27, 0x11, 0xdc, 0xa1, 0xc7, 0x69, 0xee, 0x8d, 0x31, 0xf3, 0x7c, 0xd2, 0xef, 0x37, 0x1b, 0xb2, |
| 0x1a, 0x88, 0x67, 0xf4, 0x08, 0xca, 0x7e, 0xcf, 0xd0, 0x21, 0x54, 0x48, 0x11, 0xbe, 0x4a, 0xc9, |
| 0xab, 0x09, 0xe0, 0xbb, 0x75, 0x0e, 0x91, 0x92, 0xb5, 0x1c, 0x2f, 0x59, 0xd3, 0x3e, 0x35, 0x1f, |
| 0xe9, 0x73, 0x13, 0x79, 0xb6, 0x30, 0x57, 0x9e, 0x85, 0xb4, 0x82, 0x97, 0xa8, 0xfa, 0xc5, 0x39, |
| 0xaa, 0xfe, 0x4a, 0xb2, 0xea, 0xd7, 0xa1, 0x92, 0x62, 0xee, 0x77, 0x2a, 0x2d, 0x7f, 0x54, 0xe0, |
| 0xd6, 0xcc, 0x21, 0x11, 0x3a, 0x86, 0x8d, 0xa9, 0xeb, 0x58, 0xcf, 0x96, 0xef, 0x65, 0xab, 0x3c, |
| 0x7b, 0x24, 0x90, 0xca, 0x85, 0xfa, 0x70, 0x53, 0x8f, 0x5c, 0xe8, 0xa7, 0x02, 0x33, 0xd7, 0x0f, |
| 0x05, 0x66, 0xf1, 0xaa, 0x7f, 0x56, 0x60, 0x3d, 0xa1, 0x42, 0xd2, 0x13, 0xca, 0x0c, 0x4f, 0xcc, |
| 0xd1, 0x19, 0xa7, 0xc5, 0xeb, 0x0f, 0x61, 0xcd, 0x21, 0x74, 0x6c, 0x5a, 0x9e, 0xf1, 0xaf, 0x26, |
| 0xde, 0x9d, 0xae, 0xb4, 0xb7, 0x29, 0x37, 0xd1, 0x8b, 0xbe, 0xc5, 0x71, 0x78, 0xf8, 0x36, 0xb8, |
| 0x18, 0xbd, 0x0d, 0xfe, 0x43, 0x81, 0x8d, 0x34, 0x1b, 0x7c, 0xab, 0x9b, 0x8a, 0x9c, 0x7c, 0x1e, |
| 0x2f, 0xd9, 0xf8, 0xc9, 0xe7, 0x91, 0xf3, 0xdf, 0xdc, 0xe6, 0xd7, 0x19, 0x28, 0x86, 0xe6, 0x8a, |
| 0x33, 0xaf, 0x98, 0xfb, 0x00, 0xba, 0x5f, 0x0c, 0xfd, 0xcc, 0xa3, 0x26, 0xe7, 0x92, 0xb5, 0xa0, |
| 0x62, 0xca, 0xb4, 0x13, 0xe2, 0x42, 0x75, 0xa8, 0xb0, 0xe9, 0xc8, 0xd2, 0x4f, 0x25, 0x62, 0xcf, |
| 0x29, 0x19, 0x26, 0x0d, 0xcb, 0x33, 0x94, 0x6d, 0x18, 0xee, 0xc4, 0x24, 0x83, 0x80, 0x7f, 0xc6, |
| 0xf5, 0x27, 0x01, 0x44, 0x07, 0x50, 0x21, 0x6f, 0x4c, 0xe6, 0x98, 0xd6, 0x30, 0x39, 0xba, 0x4a, |
| 0x99, 0xcd, 0xa5, 0xa1, 0xb7, 0xbe, 0x0f, 0x6b, 0xb1, 0x3d, 0xbe, 0xd3, 0x59, 0xff, 0x53, 0xd6, |
| 0x1f, 0x38, 0x5e, 0x6b, 0x72, 0x2d, 0xc5, 0xe4, 0x77, 0x52, 0x67, 0xb9, 0xff, 0xd3, 0x56, 0x7f, |
| 0x18, 0xcc, 0x53, 0x17, 0x45, 0xd0, 0xaa, 0x33, 0xb6, 0x10, 0x0c, 0x95, 0xf0, 0x89, 0x3f, 0x48, |
| 0xfd, 0xa6, 0xc6, 0xee, 0xc3, 0x4a, 0x58, 0x2c, 0xaf, 0xce, 0xfd, 0x4e, 0xa3, 0xde, 0xd3, 0xca, |
| 0x0b, 0xa8, 0x04, 0xd0, 0xc0, 0xf5, 0x66, 0xeb, 0xb4, 0xd5, 0x6e, 0x68, 0x65, 0x05, 0xad, 0x41, |
| 0xb1, 0xa1, 0x1d, 0xb4, 0x4f, 0x9a, 0xdd, 0x6e, 0xb3, 0xdd, 0x2a, 0x67, 0x50, 0x15, 0x36, 0x3c, |
| 0x40, 0xaf, 0x7d, 0xda, 0x3d, 0x38, 0xd2, 0x1a, 0xfd, 0xe3, 0xfa, 0xfe, 0xb1, 0x56, 0xce, 0xaa, |
| 0x03, 0x58, 0x4f, 0x8c, 0xc2, 0x51, 0x09, 0x32, 0x81, 0x07, 0x33, 0xcd, 0x06, 0xfa, 0x12, 0x90, |
| 0x6e, 0x38, 0xae, 0x3e, 0xea, 0xb3, 0x90, 0xd5, 0x32, 0xe9, 0x56, 0x4b, 0x81, 0xaa, 0x3f, 0x87, |
| 0x1b, 0xa9, 0x63, 0xd4, 0x6f, 0x75, 0xde, 0x30, 0x9d, 0x1c, 0x65, 0x23, 0x93, 0xa3, 0x5f, 0x28, |
| 0x80, 0x92, 0x43, 0x57, 0xf4, 0x63, 0xb8, 0x4d, 0x7d, 0x0a, 0x19, 0x74, 0x53, 0xc2, 0x4a, 0x49, |
| 0xdf, 0xe0, 0x35, 0x6c, 0xe1, 0x04, 0x95, 0x89, 0x26, 0xa8, 0x97, 0x50, 0xea, 0x50, 0x32, 0xe0, |
| 0x2a, 0x13, 0x56, 0xa7, 0x43, 0x36, 0xe7, 0xfe, 0xa7, 0xa7, 0x2a, 0x13, 0x39, 0x55, 0x5b, 0x90, |
| 0x97, 0x40, 0xef, 0x0c, 0xe4, 0x71, 0xb0, 0x56, 0x7f, 0xaf, 0xf0, 0x4b, 0x5e, 0xf7, 0xca, 0x32, |
| 0x82, 0xc1, 0xe6, 0x81, 0x6e, 0xbc, 0x20, 0xe2, 0xb3, 0x47, 0x80, 0x74, 0xc6, 0xdc, 0x71, 0x74, |
| 0xee, 0x1d, 0xab, 0xc2, 0x71, 0x00, 0x4e, 0xe1, 0x41, 0x1a, 0xac, 0x9f, 0xdb, 0xbc, 0x7d, 0x4c, |
| 0xfe, 0x42, 0x70, 0x53, 0x0a, 0x3a, 0xb4, 0xe9, 0xd0, 0x0e, 0xbd, 0xc7, 0x49, 0x0e, 0xf5, 0x19, |
| 0xac, 0x27, 0xbe, 0xf7, 0xcd, 0x8c, 0xa3, 0x7e, 0x01, 0xe5, 0xf8, 0x97, 0xe7, 0x93, 0xa8, 0xfe, |
| 0x2e, 0x03, 0x77, 0xbc, 0x13, 0x7d, 0x60, 0x5b, 0x8e, 0x6e, 0x5a, 0x84, 0x4a, 0x1b, 0x9a, 0xd6, |
| 0xb0, 0xeb, 0x84, 0x7e, 0x52, 0xdb, 0x81, 0x92, 0x8c, 0x41, 0x1a, 0xb9, 0x2d, 0xc7, 0xa8, 0xc9, |
| 0xef, 0x66, 0xd2, 0x76, 0x82, 0xfd, 0x01, 0x71, 0x56, 0x24, 0x97, 0xc7, 0x91, 0xe4, 0x72, 0x8d, |
| 0x2a, 0xb5, 0x38, 0x59, 0x8e, 0x97, 0xa7, 0x87, 0x22, 0x17, 0x39, 0x14, 0x4f, 0x60, 0x2d, 0xc6, |
| 0x81, 0x8a, 0xb0, 0xdc, 0x7d, 0xda, 0xec, 0x74, 0xb4, 0x46, 0x79, 0x81, 0x77, 0xf9, 0x32, 0x51, |
| 0x68, 0x8d, 0xb2, 0x82, 0x56, 0x20, 0x8f, 0xb5, 0xae, 0x86, 0x9f, 0x6b, 0x8d, 0x72, 0x86, 0xe7, |
| 0x9e, 0xc3, 0x7a, 0x93, 0xbf, 0xc9, 0xaa, 0xdf, 0x83, 0xad, 0x40, 0xc1, 0x73, 0x73, 0xe8, 0xd2, |
| 0xc8, 0x34, 0xa1, 0x0a, 0xcb, 0x86, 0xa0, 0x33, 0x69, 0x19, 0x7f, 0xa9, 0x8e, 0xe1, 0x83, 0x54, |
| 0x3e, 0xf9, 0xcb, 0x55, 0x15, 0x96, 0x99, 0x6b, 0x18, 0x84, 0x79, 0x8c, 0x79, 0xec, 0x2f, 0x79, |
| 0xbb, 0x6d, 0x8f, 0x06, 0x1e, 0x97, 0x7f, 0xf5, 0x09, 0x08, 0x33, 0x93, 0xc0, 0xbf, 0x15, 0x28, |
| 0x6a, 0x97, 0xc4, 0x72, 0x78, 0x16, 0xa0, 0x03, 0xf4, 0x19, 0xe4, 0x9c, 0x2b, 0x79, 0xed, 0x2c, |
| 0x05, 0xa1, 0x1a, 0x42, 0xd4, 0x44, 0xf7, 0x21, 0x40, 0xfc, 0x9c, 0xd9, 0x67, 0x3c, 0x7d, 0x05, |
| 0x41, 0x16, 0xac, 0xb9, 0xa2, 0x62, 0x52, 0x11, 0xb4, 0x73, 0xfe, 0x72, 0x96, 0xe9, 0x67, 0x37, |
| 0x30, 0xa2, 0x8f, 0xf7, 0x87, 0xfb, 0x2d, 0xdd, 0xb2, 0xe5, 0xf8, 0x28, 0x4a, 0x54, 0xef, 0x43, |
| 0x4e, 0x34, 0x42, 0x45, 0x58, 0xc6, 0xda, 0xb3, 0xbe, 0xd6, 0xed, 0x95, 0x17, 0xd0, 0x32, 0x64, |
| 0xeb, 0x9d, 0x4e, 0x59, 0x41, 0x79, 0xc8, 0x89, 0x2a, 0x90, 0xe1, 0x77, 0xb6, 0x67, 0x7d, 0xad, |
| 0xcf, 0xb3, 0xbc, 0x09, 0xa8, 0xee, 0x3a, 0x76, 0xd7, 0xd0, 0xb9, 0xbb, 0x4f, 0x88, 0x43, 0x4d, |
| 0x83, 0xa1, 0x2e, 0x54, 0x6c, 0xd7, 0x61, 0x8e, 0x6e, 0x0d, 0x4c, 0x6b, 0x28, 0x5d, 0xe6, 0xa7, |
| 0x81, 0x4f, 0xa4, 0x49, 0xda, 0x61, 0x84, 0xcc, 0x80, 0xf2, 0x47, 0xc8, 0x34, 0x6e, 0xf5, 0xef, |
| 0x0a, 0x6c, 0xcd, 0xe6, 0xe1, 0xde, 0xa3, 0xde, 0x63, 0x70, 0x58, 0xa6, 0x04, 0x7e, 0xef, 0xa2, |
| 0xd7, 0x94, 0x97, 0x00, 0x80, 0xbe, 0x94, 0x73, 0x3b, 0xef, 0xf7, 0xc4, 0xcf, 0xae, 0xd5, 0x37, |
| 0x3e, 0xbc, 0x7b, 0xef, 0xf9, 0xd9, 0xff, 0x0f, 0x61, 0x2d, 0xd6, 0xa6, 0xa2, 0x75, 0x58, 0xed, |
| 0xf6, 0xda, 0xfc, 0xf0, 0x9c, 0xee, 0x7f, 0x75, 0x8a, 0x4f, 0xca, 0x0b, 0xdc, 0x3f, 0xbd, 0xe6, |
| 0x89, 0xd6, 0xee, 0xf7, 0xca, 0x0a, 0xda, 0x82, 0xcd, 0x0e, 0xd6, 0xb4, 0x93, 0x4e, 0xcf, 0x43, |
| 0xf8, 0x87, 0x0b, 0x7b, 0xd5, 0xb9, 0x73, 0x5c, 0x3f, 0xd0, 0x8e, 0xda, 0xc7, 0x0d, 0x0d, 0x9f, |
| 0x62, 0x4d, 0xac, 0x1a, 0xe5, 0xec, 0xde, 0x1f, 0x14, 0x28, 0x4c, 0x7f, 0x97, 0x7a, 0x09, 0x37, |
| 0x67, 0xfc, 0xea, 0x8f, 0xee, 0x04, 0x66, 0x7a, 0xdb, 0xff, 0x10, 0xb6, 0x76, 0xae, 0x83, 0xc9, |
| 0x3f, 0x0f, 0x2c, 0xa0, 0x47, 0xb0, 0xe4, 0x1d, 0x4f, 0xb4, 0x11, 0xfb, 0xcd, 0xd8, 0x93, 0x74, |
| 0x23, 0xf5, 0x97, 0x64, 0x75, 0x61, 0x57, 0xf9, 0x8e, 0xf2, 0xf0, 0x11, 0x14, 0x98, 0x79, 0xca, |
| 0x88, 0x41, 0x89, 0x83, 0x3e, 0xaa, 0x79, 0x7f, 0xa0, 0xa8, 0xf9, 0x7f, 0xa0, 0xa8, 0x1d, 0x9a, |
| 0x64, 0x34, 0x68, 0x4f, 0xbc, 0x5a, 0xf1, 0x9b, 0xbc, 0x57, 0xb8, 0x98, 0xd9, 0x15, 0xf8, 0xfd, |
| 0xdc, 0x4f, 0x33, 0xcc, 0x3c, 0x5b, 0x12, 0xe8, 0xef, 0xfe, 0x27, 0x00, 0x00, 0xff, 0xff, 0xd1, |
| 0x2d, 0xb5, 0xaa, 0xb6, 0x21, 0x00, 0x00, |
| } |
| |
| // 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 |
| |
| // SchedulerClient is the client API for Scheduler service. |
| // |
| // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. |
| type SchedulerClient interface { |
| // Register a RM, if it is a reconnect from previous RM the call will |
| // trigger a cleanup of all in-memory data and resync with RM. |
| RegisterResourceManager(ctx context.Context, in *RegisterResourceManagerRequest, opts ...grpc.CallOption) (*RegisterResourceManagerResponse, error) |
| // Update Scheduler status (this includes node status update, allocation request |
| // updates, etc. And receive updates from scheduler for allocation changes, |
| // any required status changes, etc. |
| Update(ctx context.Context, opts ...grpc.CallOption) (Scheduler_UpdateClient, error) |
| } |
| |
| type schedulerClient struct { |
| cc *grpc.ClientConn |
| } |
| |
| func NewSchedulerClient(cc *grpc.ClientConn) SchedulerClient { |
| return &schedulerClient{cc} |
| } |
| |
| func (c *schedulerClient) RegisterResourceManager(ctx context.Context, in *RegisterResourceManagerRequest, opts ...grpc.CallOption) (*RegisterResourceManagerResponse, error) { |
| out := new(RegisterResourceManagerResponse) |
| err := c.cc.Invoke(ctx, "/si.v1.Scheduler/RegisterResourceManager", in, out, opts...) |
| if err != nil { |
| return nil, err |
| } |
| return out, nil |
| } |
| |
| func (c *schedulerClient) Update(ctx context.Context, opts ...grpc.CallOption) (Scheduler_UpdateClient, error) { |
| stream, err := c.cc.NewStream(ctx, &_Scheduler_serviceDesc.Streams[0], "/si.v1.Scheduler/Update", opts...) |
| if err != nil { |
| return nil, err |
| } |
| x := &schedulerUpdateClient{stream} |
| return x, nil |
| } |
| |
| type Scheduler_UpdateClient interface { |
| Send(*UpdateRequest) error |
| Recv() (*UpdateResponse, error) |
| grpc.ClientStream |
| } |
| |
| type schedulerUpdateClient struct { |
| grpc.ClientStream |
| } |
| |
| func (x *schedulerUpdateClient) Send(m *UpdateRequest) error { |
| return x.ClientStream.SendMsg(m) |
| } |
| |
| func (x *schedulerUpdateClient) Recv() (*UpdateResponse, error) { |
| m := new(UpdateResponse) |
| if err := x.ClientStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| // SchedulerServer is the server API for Scheduler service. |
| type SchedulerServer interface { |
| // Register a RM, if it is a reconnect from previous RM the call will |
| // trigger a cleanup of all in-memory data and resync with RM. |
| RegisterResourceManager(context.Context, *RegisterResourceManagerRequest) (*RegisterResourceManagerResponse, error) |
| // Update Scheduler status (this includes node status update, allocation request |
| // updates, etc. And receive updates from scheduler for allocation changes, |
| // any required status changes, etc. |
| Update(Scheduler_UpdateServer) error |
| } |
| |
| // UnimplementedSchedulerServer can be embedded to have forward compatible implementations. |
| type UnimplementedSchedulerServer struct { |
| } |
| |
| func (*UnimplementedSchedulerServer) RegisterResourceManager(ctx context.Context, req *RegisterResourceManagerRequest) (*RegisterResourceManagerResponse, error) { |
| return nil, status.Errorf(codes.Unimplemented, "method RegisterResourceManager not implemented") |
| } |
| func (*UnimplementedSchedulerServer) Update(srv Scheduler_UpdateServer) error { |
| return status.Errorf(codes.Unimplemented, "method Update not implemented") |
| } |
| |
| func RegisterSchedulerServer(s *grpc.Server, srv SchedulerServer) { |
| s.RegisterService(&_Scheduler_serviceDesc, srv) |
| } |
| |
| func _Scheduler_RegisterResourceManager_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
| in := new(RegisterResourceManagerRequest) |
| if err := dec(in); err != nil { |
| return nil, err |
| } |
| if interceptor == nil { |
| return srv.(SchedulerServer).RegisterResourceManager(ctx, in) |
| } |
| info := &grpc.UnaryServerInfo{ |
| Server: srv, |
| FullMethod: "/si.v1.Scheduler/RegisterResourceManager", |
| } |
| handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
| return srv.(SchedulerServer).RegisterResourceManager(ctx, req.(*RegisterResourceManagerRequest)) |
| } |
| return interceptor(ctx, in, info, handler) |
| } |
| |
| func _Scheduler_Update_Handler(srv interface{}, stream grpc.ServerStream) error { |
| return srv.(SchedulerServer).Update(&schedulerUpdateServer{stream}) |
| } |
| |
| type Scheduler_UpdateServer interface { |
| Send(*UpdateResponse) error |
| Recv() (*UpdateRequest, error) |
| grpc.ServerStream |
| } |
| |
| type schedulerUpdateServer struct { |
| grpc.ServerStream |
| } |
| |
| func (x *schedulerUpdateServer) Send(m *UpdateResponse) error { |
| return x.ServerStream.SendMsg(m) |
| } |
| |
| func (x *schedulerUpdateServer) Recv() (*UpdateRequest, error) { |
| m := new(UpdateRequest) |
| if err := x.ServerStream.RecvMsg(m); err != nil { |
| return nil, err |
| } |
| return m, nil |
| } |
| |
| var _Scheduler_serviceDesc = grpc.ServiceDesc{ |
| ServiceName: "si.v1.Scheduler", |
| HandlerType: (*SchedulerServer)(nil), |
| Methods: []grpc.MethodDesc{ |
| { |
| MethodName: "RegisterResourceManager", |
| Handler: _Scheduler_RegisterResourceManager_Handler, |
| }, |
| }, |
| Streams: []grpc.StreamDesc{ |
| { |
| StreamName: "Update", |
| Handler: _Scheduler_Update_Handler, |
| ServerStreams: true, |
| ClientStreams: true, |
| }, |
| }, |
| Metadata: "incubator-yunikorn-scheduler-interface/si.proto", |
| } |