github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-23 19:56:01 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #84771 from MikeSpreitzer/refactor-priority-config

Browse Source 
Refactored PriorityLevelConfiguration
This commit is contained in:
Kubernetes Prow Robot 2019-11-13 17:28:06 -08:00 committed by GitHub
commit 71d563b831
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 1097 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
api/openapi-spec/swagger.json generated
View File

@ -13993,6 +13993,46 @@
],
"type": "object"
},
"io.k8s.api.flowcontrol.v1alpha1.LimitResponse": {
"description": "LimitResponse defines how to handle requests that can not be executed right now.",
"properties": {
"queuing": {
"$ref": "#/definitions/io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration",
"description": "`queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `\"Queue\"`."
},
"type": {
"description": "`type` is \"Queue\" or \"Reject\". \"Queue\" means that requests that can not be executed upon arrival are held in a queue until they can be executed or a queuing limit is reached. \"Reject\" means that requests that can not be executed upon arrival are rejected. Required.",
"type": "string"
}
},
"required": [
"type"
],
"type": "object",
"x-kubernetes-unions": [
{
"discriminator": "type",
"fields-to-discriminateBy": {
"queuing": "Queuing"
}
}
]
},
"io.k8s.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration": {
"description": "LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues:\n * How are requests for this priority level limited?\n * What should be done with requests that exceed the limit?",
"properties": {
"assuredConcurrencyShares": {
"description": "`assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) --- the number of requests that may be executing at a time --- for each such priority level:\n\n ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) )\n\nbigger numbers of ACS mean more reserved concurrent requests (at the expense of every other PL). This field has a default value of 30.",
"format": "int32",
"type": "integer"
},
"limitResponse": {
"$ref": "#/definitions/io.k8s.api.flowcontrol.v1alpha1.LimitResponse",
"description": "`limitResponse` indicates what to do with requests that can not be executed right now"
}
},
"type": "object"
},
"io.k8s.api.flowcontrol.v1alpha1.NonResourcePolicyRule": {
"description": "NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request.",
"properties": {
@ -14161,21 +14201,29 @@
"type": "object"
},
"io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationSpec": {
"description": "PriorityLevelConfigurationSpec is specification of a priority level",
"description": "PriorityLevelConfigurationSpec specifies the configuration of a priority level.",
"properties": {
"queuing": {
"$ref": "#/definitions/io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration",
"description": "`queuing` holds the configuration parameters that are only meaningful for a priority level that does queuing (i.e., is not exempt). This field must be non-empty if and only if `queuingType` is `\"Queuing\"`."
"limited": {
"$ref": "#/definitions/io.k8s.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration",
"description": "`limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `\"Limited\"`."
},
"type": {
"description": "`type` indicates whether this priority level does queuing or is exempt. Valid values are \"Queuing\" and \"Exempt\". \"Exempt\" means that requests of this priority level are not subject to concurrency limits (and thus are never queued) and do not detract from the concurrency available for non-exempt requests. The \"Exempt\" type is useful for apiserver self-requests and system administrator use. Required.",
"description": "`type` indicates whether this priority level is subject to limitation on request execution. A value of `\"Exempt\"` means that requests of this priority level are not subject to a limit (and thus are never queued) and do not detract from the capacity made available to other priority levels. A value of `\"Limited\"` means that (a) requests of this priority level _are_ subject to limits and (b) some of the server's limited capacity is made available exclusively to this priority level. Required.",
"type": "string"
}
},
"required": [
"type"
],
"type": "object"
"type": "object",
"x-kubernetes-unions": [
{
"discriminator": "type",
"fields-to-discriminateBy": {
"limited": "Limited"
}
}
]
},
"io.k8s.api.flowcontrol.v1alpha1.PriorityLevelConfigurationStatus": {
"description": "PriorityLevelConfigurationStatus represents the current state of a \"request-priority\".",
@ -14195,13 +14243,8 @@
"type": "object"
},
"io.k8s.api.flowcontrol.v1alpha1.QueuingConfiguration": {
"description": "QueuingConfiguration holds the configuration parameters that are specific to a priority level that is subject to concurrency controls",
"description": "QueuingConfiguration holds the configuration parameters for queuing",
"properties": {
"assuredConcurrencyShares": {
"description": "`assuredConcurrencyShares` (ACS) must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) for each such priority level:\n\n ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) )\n\nbigger numbers of ACS mean more reserved concurrent requests (at the expense of every other PL). This field has a default value of 30.",
"format": "int32",
"type": "integer"
},
"handSize": {
"description": "`handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8.",
"format": "int32",

100
pkg/apis/flowcontrol/types.go
View File

@ -320,44 +320,53 @@ type PriorityLevelConfigurationList struct {
Items []PriorityLevelConfiguration
}
// PriorityLevelConfigurationSpec is specification of a priority level
// PriorityLevelConfigurationSpec specifies the configuration of a priority level.
// +union
type PriorityLevelConfigurationSpec struct {
// `type` indicates whether this priority level does
// queuing or is exempt. Valid values are "Queuing" and "Exempt".
// "Exempt" means that requests of this priority level are not subject
// to concurrency limits (and thus are never queued) and do not detract
// from the concurrency available for non-exempt requests. The "Exempt"
// type is useful for apiserver self-requests and system administrator use.
// `type` indicates whether this priority level is subject to
// limitation on request execution. A value of `"Exempt"` means
// that requests of this priority level are not subject to a limit
// (and thus are never queued) and do not detract from the
// capacity made available to other priority levels. A value of
// `"Limited"` means that (a) requests of this priority level
// _are_ subject to limits and (b) some of the server's limited
// capacity is made available exclusively to this priority level.
// Required.
Type PriorityLevelQueueingType
// +unionDiscriminator
Type PriorityLevelEnablement
// `queuing` holds the configuration parameters that are
// only meaningful for a priority level that does queuing (i.e.,
// is not exempt). This field must be non-empty if and only if
// `queuingType` is `"Queuing"`.
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
Queuing *QueuingConfiguration
Limited *LimitedPriorityLevelConfiguration
}
// PriorityLevelQueueingType identifies the queuing nature of a priority level
type PriorityLevelQueueingType string
// PriorityLevelEnablement indicates whether limits on execution are enabled for the priority level
type PriorityLevelEnablement string
// Supported queuing types.
// Supported priority level enablement values.
const (
// PriorityLevelQueuingTypeQueueing is the PriorityLevelQueueingType for priority levels that queue
PriorityLevelQueuingTypeQueueing PriorityLevelQueueingType = "Queuing"
// PriorityLevelEnablementExempt means that requests are not subject to limits
PriorityLevelEnablementExempt PriorityLevelEnablement = "Exempt"
// PriorityLevelQueuingTypeExempt is the PriorityLevelQueueingType for priority levels that are exempt from concurrency controls
PriorityLevelQueuingTypeExempt PriorityLevelQueueingType = "Exempt"
// PriorityLevelEnablementLimited means that requests are subject to limits
PriorityLevelEnablementLimited PriorityLevelEnablement = "Limited"
)
// QueuingConfiguration holds the configuration parameters that are specific to a priority level that is subject to concurrency controls
type QueuingConfiguration struct {
// `assuredConcurrencyShares` (ACS) must be a positive number. The
// server's concurrency limit (SCL) is divided among the
// concurrency-controlled priority levels in proportion to their
// assured concurrency shares. This produces the assured
// concurrency value (ACV) for each such priority level:
// LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits.
// It addresses two issues:
// * How are requests for this priority level limited?
// * What should be done with requests that exceed the limit?
type LimitedPriorityLevelConfiguration struct {
// `assuredConcurrencyShares` (ACS) configures the execution
// limit, which is a limit on the number of requests of this
// priority level that may be exeucting at a given time. ACS must
// be a positive number. The server's concurrency limit (SCL) is
// divided among the concurrency-controlled priority levels in
// proportion to their assured concurrency shares. This produces
// the assured concurrency value (ACV) --- the number of requests
// that may be executing at a time --- for each such priority
// level:
//
// ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) )
//
@ -367,6 +376,43 @@ type QueuingConfiguration struct {
// +optional
AssuredConcurrencyShares int32
// `limitResponse` indicates what to do with requests that can not be executed right now
LimitResponse LimitResponse
}
// LimitResponse defines how to handle requests that can not be executed right now.
// +union
type LimitResponse struct {
// `type` is "Queue" or "Reject".
// "Queue" means that requests that can not be executed upon arrival
// are held in a queue until they can be executed or a queuing limit
// is reached.
// "Reject" means that requests that can not be executed upon arrival
// are rejected.
// Required.
// +unionDiscriminator
Type LimitResponseType
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
Queuing *QueuingConfiguration
}
// LimitResponseType identifies how a Limited priority level handles a request that can not be executed right now
type LimitResponseType string
// Supported limit responses.
const (
// LimitResponseTypeQueue means that requests that can not be executed right now are queued until they can be executed or a queuing limit is hit
LimitResponseTypeQueue LimitResponseType = "Queue"
// LimitResponseTypeReject means that requests that can not be executed right now are rejected
LimitResponseTypeReject LimitResponseType = "Reject"
)
// QueuingConfiguration holds the configuration parameters for queuing
type QueuingConfiguration struct {
// `queues` is the number of queues for this priority level. The
// queues exist independently at each apiserver. The value must be
// positive. Setting it to 1 effectively precludes

10
pkg/apis/flowcontrol/v1alpha1/defaults.go
View File

@ -40,6 +40,12 @@ func SetDefaults_FlowSchemaSpec(spec *v1alpha1.FlowSchemaSpec) {
}
}
func SetDefaults_LimitedPriorityLevelConfiguration(lplc *v1alpha1.LimitedPriorityLevelConfiguration) {
if lplc.AssuredConcurrencyShares == 0 {
lplc.AssuredConcurrencyShares = PriorityLevelConfigurationDefaultAssuredConcurrencyShares
}
}
// SetDefaults_FlowSchema sets default values for flow schema
func SetDefaults_QueuingConfiguration(cfg *v1alpha1.QueuingConfiguration) {
if cfg.HandSize == 0 {
@ -51,8 +57,4 @@ func SetDefaults_QueuingConfiguration(cfg *v1alpha1.QueuingConfiguration) {
if cfg.QueueLengthLimit == 0 {
cfg.QueueLengthLimit = PriorityLevelConfigurationDefaultQueueLengthLimit
}
if cfg.AssuredConcurrencyShares == 0 {
cfg.AssuredConcurrencyShares = PriorityLevelConfigurationDefaultAssuredConcurrencyShares
}
}

78
pkg/apis/flowcontrol/v1alpha1/zz_generated.conversion.go generated
View File

@ -106,6 +106,26 @@ func RegisterConversions(s *runtime.Scheme) error {
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*v1alpha1.LimitResponse)(nil), (*flowcontrol.LimitResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_v1alpha1_LimitResponse_To_flowcontrol_LimitResponse(a.(*v1alpha1.LimitResponse), b.(*flowcontrol.LimitResponse), scope)
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*flowcontrol.LimitResponse)(nil), (*v1alpha1.LimitResponse)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_flowcontrol_LimitResponse_To_v1alpha1_LimitResponse(a.(*flowcontrol.LimitResponse), b.(*v1alpha1.LimitResponse), scope)
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*v1alpha1.LimitedPriorityLevelConfiguration)(nil), (*flowcontrol.LimitedPriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_v1alpha1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(a.(*v1alpha1.LimitedPriorityLevelConfiguration), b.(*flowcontrol.LimitedPriorityLevelConfiguration), scope)
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*flowcontrol.LimitedPriorityLevelConfiguration)(nil), (*v1alpha1.LimitedPriorityLevelConfiguration)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1alpha1_LimitedPriorityLevelConfiguration(a.(*flowcontrol.LimitedPriorityLevelConfiguration), b.(*v1alpha1.LimitedPriorityLevelConfiguration), scope)
}); err != nil {
return err
}
if err := s.AddGeneratedConversionFunc((*v1alpha1.NonResourcePolicyRule)(nil), (*flowcontrol.NonResourcePolicyRule)(nil), func(a, b interface{}, scope conversion.Scope) error {
return Convert_v1alpha1_NonResourcePolicyRule_To_flowcontrol_NonResourcePolicyRule(a.(*v1alpha1.NonResourcePolicyRule), b.(*flowcontrol.NonResourcePolicyRule), scope)
}); err != nil {
@ -411,6 +431,54 @@ func Convert_flowcontrol_GroupSubject_To_v1alpha1_GroupSubject(in *flowcontrol.G
return autoConvert_flowcontrol_GroupSubject_To_v1alpha1_GroupSubject(in, out, s)
}
func autoConvert_v1alpha1_LimitResponse_To_flowcontrol_LimitResponse(in *v1alpha1.LimitResponse, out *flowcontrol.LimitResponse, s conversion.Scope) error {
out.Type = flowcontrol.LimitResponseType(in.Type)
out.Queuing = (*flowcontrol.QueuingConfiguration)(unsafe.Pointer(in.Queuing))
return nil
}
// Convert_v1alpha1_LimitResponse_To_flowcontrol_LimitResponse is an autogenerated conversion function.
func Convert_v1alpha1_LimitResponse_To_flowcontrol_LimitResponse(in *v1alpha1.LimitResponse, out *flowcontrol.LimitResponse, s conversion.Scope) error {
return autoConvert_v1alpha1_LimitResponse_To_flowcontrol_LimitResponse(in, out, s)
}
func autoConvert_flowcontrol_LimitResponse_To_v1alpha1_LimitResponse(in *flowcontrol.LimitResponse, out *v1alpha1.LimitResponse, s conversion.Scope) error {
out.Type = v1alpha1.LimitResponseType(in.Type)
out.Queuing = (*v1alpha1.QueuingConfiguration)(unsafe.Pointer(in.Queuing))
return nil
}
// Convert_flowcontrol_LimitResponse_To_v1alpha1_LimitResponse is an autogenerated conversion function.
func Convert_flowcontrol_LimitResponse_To_v1alpha1_LimitResponse(in *flowcontrol.LimitResponse, out *v1alpha1.LimitResponse, s conversion.Scope) error {
return autoConvert_flowcontrol_LimitResponse_To_v1alpha1_LimitResponse(in, out, s)
}
func autoConvert_v1alpha1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(in *v1alpha1.LimitedPriorityLevelConfiguration, out *flowcontrol.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
out.AssuredConcurrencyShares = in.AssuredConcurrencyShares
if err := Convert_v1alpha1_LimitResponse_To_flowcontrol_LimitResponse(&in.LimitResponse, &out.LimitResponse, s); err != nil {
return err
}
return nil
}
// Convert_v1alpha1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration is an autogenerated conversion function.
func Convert_v1alpha1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(in *v1alpha1.LimitedPriorityLevelConfiguration, out *flowcontrol.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
return autoConvert_v1alpha1_LimitedPriorityLevelConfiguration_To_flowcontrol_LimitedPriorityLevelConfiguration(in, out, s)
}
func autoConvert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1alpha1_LimitedPriorityLevelConfiguration(in *flowcontrol.LimitedPriorityLevelConfiguration, out *v1alpha1.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
out.AssuredConcurrencyShares = in.AssuredConcurrencyShares
if err := Convert_flowcontrol_LimitResponse_To_v1alpha1_LimitResponse(&in.LimitResponse, &out.LimitResponse, s); err != nil {
return err
}
return nil
}
// Convert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1alpha1_LimitedPriorityLevelConfiguration is an autogenerated conversion function.
func Convert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1alpha1_LimitedPriorityLevelConfiguration(in *flowcontrol.LimitedPriorityLevelConfiguration, out *v1alpha1.LimitedPriorityLevelConfiguration, s conversion.Scope) error {
return autoConvert_flowcontrol_LimitedPriorityLevelConfiguration_To_v1alpha1_LimitedPriorityLevelConfiguration(in, out, s)
}
func autoConvert_v1alpha1_NonResourcePolicyRule_To_flowcontrol_NonResourcePolicyRule(in *v1alpha1.NonResourcePolicyRule, out *flowcontrol.NonResourcePolicyRule, s conversion.Scope) error {
out.Verbs = *(*[]string)(unsafe.Pointer(&in.Verbs))
out.NonResourceURLs = *(*[]string)(unsafe.Pointer(&in.NonResourceURLs))
@ -560,8 +628,8 @@ func Convert_flowcontrol_PriorityLevelConfigurationReference_To_v1alpha1_Priorit
}
func autoConvert_v1alpha1_PriorityLevelConfigurationSpec_To_flowcontrol_PriorityLevelConfigurationSpec(in *v1alpha1.PriorityLevelConfigurationSpec, out *flowcontrol.PriorityLevelConfigurationSpec, s conversion.Scope) error {
out.Type = flowcontrol.PriorityLevelQueueingType(in.Type)
out.Queuing = (*flowcontrol.QueuingConfiguration)(unsafe.Pointer(in.Queuing))
out.Type = flowcontrol.PriorityLevelEnablement(in.Type)
out.Limited = (*flowcontrol.LimitedPriorityLevelConfiguration)(unsafe.Pointer(in.Limited))
return nil
}
@ -571,8 +639,8 @@ func Convert_v1alpha1_PriorityLevelConfigurationSpec_To_flowcontrol_PriorityLeve
}
func autoConvert_flowcontrol_PriorityLevelConfigurationSpec_To_v1alpha1_PriorityLevelConfigurationSpec(in *flowcontrol.PriorityLevelConfigurationSpec, out *v1alpha1.PriorityLevelConfigurationSpec, s conversion.Scope) error {
out.Type = v1alpha1.PriorityLevelQueueingType(in.Type)
out.Queuing = (*v1alpha1.QueuingConfiguration)(unsafe.Pointer(in.Queuing))
out.Type = v1alpha1.PriorityLevelEnablement(in.Type)
out.Limited = (*v1alpha1.LimitedPriorityLevelConfiguration)(unsafe.Pointer(in.Limited))
return nil
}
@ -602,7 +670,6 @@ func Convert_flowcontrol_PriorityLevelConfigurationStatus_To_v1alpha1_PriorityLe
}
func autoConvert_v1alpha1_QueuingConfiguration_To_flowcontrol_QueuingConfiguration(in *v1alpha1.QueuingConfiguration, out *flowcontrol.QueuingConfiguration, s conversion.Scope) error {
out.AssuredConcurrencyShares = in.AssuredConcurrencyShares
out.Queues = in.Queues
out.HandSize = in.HandSize
out.QueueLengthLimit = in.QueueLengthLimit
@ -615,7 +682,6 @@ func Convert_v1alpha1_QueuingConfiguration_To_flowcontrol_QueuingConfiguration(i
}
func autoConvert_flowcontrol_QueuingConfiguration_To_v1alpha1_QueuingConfiguration(in *flowcontrol.QueuingConfiguration, out *v1alpha1.QueuingConfiguration, s conversion.Scope) error {
out.AssuredConcurrencyShares = in.AssuredConcurrencyShares
out.Queues = in.Queues
out.HandSize = in.HandSize
out.QueueLengthLimit = in.QueueLengthLimit

7
pkg/apis/flowcontrol/v1alpha1/zz_generated.defaults.go generated
View File

@ -52,8 +52,11 @@ func SetObjectDefaults_FlowSchemaList(in *v1alpha1.FlowSchemaList) {
}
func SetObjectDefaults_PriorityLevelConfiguration(in *v1alpha1.PriorityLevelConfiguration) {
if in.Spec.Queuing != nil {
SetDefaults_QueuingConfiguration(in.Spec.Queuing)
if in.Spec.Limited != nil {
SetDefaults_LimitedPriorityLevelConfiguration(in.Spec.Limited)
if in.Spec.Limited.LimitResponse.Queuing != nil {
SetDefaults_QueuingConfiguration(in.Spec.Limited.LimitResponse.Queuing)
}
}
}

60
pkg/apis/flowcontrol/validation/validation.go
View File

@ -60,9 +60,14 @@ var supportedSubjectKinds = sets.NewString(
string(flowcontrol.SubjectKindUser),
)
var supportedQueuingType = sets.NewString(
string(flowcontrol.PriorityLevelQueuingTypeQueueing),
string(flowcontrol.PriorityLevelQueuingTypeExempt),
var supportedPriorityLevelEnablement = sets.NewString(
string(flowcontrol.PriorityLevelEnablementExempt),
string(flowcontrol.PriorityLevelEnablementLimited),
)
var supportedLimitResponseType = sets.NewString(
string(flowcontrol.LimitResponseTypeQueue),
string(flowcontrol.LimitResponseTypeReject),
)
// ValidateFlowSchema validates the content of flow-schema
@ -288,18 +293,48 @@ func ValidatePriorityLevelConfigurationUpdate(old, pl *flowcontrol.PriorityLevel
func ValidatePriorityLevelConfigurationSpec(spec *flowcontrol.PriorityLevelConfigurationSpec, name string, fldPath *field.Path) field.ErrorList {
var allErrs field.ErrorList
switch spec.Type {
case flowcontrol.PriorityLevelQueuingTypeExempt:
if spec.Queuing != nil {
allErrs = append(allErrs, field.Forbidden(fldPath.Child("queuing"), "must be nil if the type is not Queuing"))
case flowcontrol.PriorityLevelEnablementExempt:
if spec.Limited != nil {
allErrs = append(allErrs, field.Forbidden(fldPath.Child("limited"), "must be nil if the type is not Limited"))
}
case flowcontrol.PriorityLevelQueuingTypeQueueing:
if spec.Queuing == nil {
allErrs = append(allErrs, field.Required(fldPath.Child("queuing"), "must not be empty"))
case flowcontrol.PriorityLevelEnablementLimited:
if spec.Limited == nil {
allErrs = append(allErrs, field.Required(fldPath.Child("limited"), "must not be empty"))
} else {
allErrs = append(allErrs, ValidatePriorityLevelQueuingConfiguration(spec.Queuing, fldPath.Child("queuing"))...)
allErrs = append(allErrs, ValidateLimitedPriorityLevelConfiguration(spec.Limited, fldPath.Child("limited"))...)
}
default:
allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), spec.Type, supportedQueuingType.List()))
allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), spec.Type, supportedPriorityLevelEnablement.List()))
}
return allErrs
}
// ValidateLimitedPriorityLevelConfiguration validates the configuration for an exeuction-limited priority level
func ValidateLimitedPriorityLevelConfiguration(lplc *flowcontrol.LimitedPriorityLevelConfiguration, fldPath *field.Path) field.ErrorList {
var allErrs field.ErrorList
if lplc.AssuredConcurrencyShares <= 0 {
allErrs = append(allErrs, field.Invalid(fldPath.Child("assuredConcurrencyShares"), lplc.AssuredConcurrencyShares, "must be positive"))
}
allErrs = append(allErrs, ValidateLimitResponse(lplc.LimitResponse, fldPath.Child("limitResponse"))...)
return allErrs
}
// ValidateLimitResponse validates a LimitResponse
func ValidateLimitResponse(lr flowcontrol.LimitResponse, fldPath *field.Path) field.ErrorList {
var allErrs field.ErrorList
switch lr.Type {
case flowcontrol.LimitResponseTypeReject:
if lr.Queuing != nil {
allErrs = append(allErrs, field.Forbidden(fldPath.Child("queuing"), "must be nil if the type is not Limited"))
}
case flowcontrol.LimitResponseTypeQueue:
if lr.Queuing == nil {
allErrs = append(allErrs, field.Required(fldPath.Child("queuing"), "must not be empty"))
} else {
allErrs = append(allErrs, ValidatePriorityLevelQueuingConfiguration(lr.Queuing, fldPath.Child("queuing"))...)
}
default:
allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), lr.Type, supportedLimitResponseType.List()))
}
return allErrs
}
@ -307,9 +342,6 @@ func ValidatePriorityLevelConfigurationSpec(spec *flowcontrol.PriorityLevelConfi
// ValidatePriorityLevelQueuingConfiguration validates queuing-configuration for a priority-level
func ValidatePriorityLevelQueuingConfiguration(queuing *flowcontrol.QueuingConfiguration, fldPath *field.Path) field.ErrorList {
var allErrs field.ErrorList
if queuing.AssuredConcurrencyShares <= 0 {
allErrs = append(allErrs, field.Invalid(fldPath.Child("assuredConcurrencyShares"), queuing.AssuredConcurrencyShares, "must be positive"))
}
if queuing.QueueLengthLimit <= 0 {
allErrs = append(allErrs, field.Invalid(fldPath.Child("queueLengthLimit"), queuing.QueueLengthLimit, "must be positive"))
}

108
pkg/apis/flowcontrol/validation/validation_test.go
View File

@ -392,14 +392,16 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Name: "system-foo",
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelQueuingTypeQueueing,
Queuing: &flowcontrol.QueuingConfiguration{
Type: flowcontrol.PriorityLevelEnablementLimited,
Limited: &flowcontrol.LimitedPriorityLevelConfiguration{
AssuredConcurrencyShares: 100,
Queues: 512,
HandSize: 4,
QueueLengthLimit: 100,
},
},
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeQueue,
Queuing: &flowcontrol.QueuingConfiguration{
Queues: 512,
HandSize: 4,
QueueLengthLimit: 100,
}}}},
},
expectedErrors: field.ErrorList{},
},
@ -410,7 +412,7 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Name: flowcontrol.PriorityLevelConfigurationNameExempt,
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelQueuingTypeExempt,
Type: flowcontrol.PriorityLevelEnablementExempt,
},
},
expectedErrors: field.ErrorList{},
@ -422,17 +424,19 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Name: "system-foo",
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelQueuingTypeQueueing,
Queuing: &flowcontrol.QueuingConfiguration{
Type: flowcontrol.PriorityLevelEnablementLimited,
Limited: &flowcontrol.LimitedPriorityLevelConfiguration{
AssuredConcurrencyShares: 100,
QueueLengthLimit: 100,
Queues: 512,
HandSize: 8,
},
},
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeQueue,
Queuing: &flowcontrol.QueuingConfiguration{
QueueLengthLimit: 100,
Queues: 512,
HandSize: 8,
}}}},
},
expectedErrors: field.ErrorList{
field.Invalid(field.NewPath("spec").Child("queuing").Child("handSize"), int32(8), "required entropy bits of deckSize 512 and handSize 8 should not be greater than 60"),
field.Invalid(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing").Child("handSize"), int32(8), "required entropy bits of deckSize 512 and handSize 8 should not be greater than 60"),
},
},
{
@ -442,17 +446,19 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Name: "system-foo",
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelQueuingTypeQueueing,
Queuing: &flowcontrol.QueuingConfiguration{
Type: flowcontrol.PriorityLevelEnablementLimited,
Limited: &flowcontrol.LimitedPriorityLevelConfiguration{
AssuredConcurrencyShares: 100,
QueueLengthLimit: 100,
Queues: 128,
HandSize: 10,
},
},
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeQueue,
Queuing: &flowcontrol.QueuingConfiguration{
QueueLengthLimit: 100,
Queues: 128,
HandSize: 10,
}}}},
},
expectedErrors: field.ErrorList{
field.Invalid(field.NewPath("spec").Child("queuing").Child("handSize"), int32(10), "required entropy bits of deckSize 128 and handSize 10 should not be greater than 60"),
field.Invalid(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing").Child("handSize"), int32(10), "required entropy bits of deckSize 128 and handSize 10 should not be greater than 60"),
},
},
{
@ -462,18 +468,20 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Name: "system-foo",
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelQueuingTypeQueueing,
Queuing: &flowcontrol.QueuingConfiguration{
Type: flowcontrol.PriorityLevelEnablementLimited,
Limited: &flowcontrol.LimitedPriorityLevelConfiguration{
AssuredConcurrencyShares: 100,
QueueLengthLimit: 100,
Queues: math.MaxInt32,
HandSize: 3,
},
},
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeQueue,
Queuing: &flowcontrol.QueuingConfiguration{
QueueLengthLimit: 100,
Queues: math.MaxInt32,
HandSize: 3,
}}}},
},
expectedErrors: field.ErrorList{
field.Invalid(field.NewPath("spec").Child("queuing").Child("handSize"), int32(3), "required entropy bits of deckSize 2147483647 and handSize 3 should not be greater than 60"),
field.Invalid(field.NewPath("spec").Child("queuing").Child("queues"), int32(math.MaxInt32), "must not be greater than 10000000"),
field.Invalid(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing").Child("handSize"), int32(3), "required entropy bits of deckSize 2147483647 and handSize 3 should not be greater than 60"),
field.Invalid(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing").Child("queues"), int32(math.MaxInt32), "must not be greater than 10000000"),
},
},
{
@ -483,14 +491,16 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Name: "system-foo",
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelQueuingTypeQueueing,
Queuing: &flowcontrol.QueuingConfiguration{
Type: flowcontrol.PriorityLevelEnablementLimited,
Limited: &flowcontrol.LimitedPriorityLevelConfiguration{
AssuredConcurrencyShares: 100,
QueueLengthLimit: 100,
Queues: 10 * 1000 * 1000, // 10^7
HandSize: 2,
},
},
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeQueue,
Queuing: &flowcontrol.QueuingConfiguration{
QueueLengthLimit: 100,
Queues: 10 * 1000 * 1000, // 10^7
HandSize: 2,
}}}},
},
expectedErrors: field.ErrorList{},
},
@ -501,17 +511,19 @@ func TestPriorityLevelConfigurationValidation(t *testing.T) {
Name: "system-foo",
},
Spec: flowcontrol.PriorityLevelConfigurationSpec{
Type: flowcontrol.PriorityLevelQueuingTypeQueueing,
Queuing: &flowcontrol.QueuingConfiguration{
Type: flowcontrol.PriorityLevelEnablementLimited,
Limited: &flowcontrol.LimitedPriorityLevelConfiguration{
AssuredConcurrencyShares: 100,
QueueLengthLimit: 100,
Queues: 7,
HandSize: 8,
},
},
LimitResponse: flowcontrol.LimitResponse{
Type: flowcontrol.LimitResponseTypeQueue,
Queuing: &flowcontrol.QueuingConfiguration{
QueueLengthLimit: 100,
Queues: 7,
HandSize: 8,
}}}},
},
expectedErrors: field.ErrorList{
field.Invalid(field.NewPath("spec").Child("queuing").Child("handSize"), int32(8), "should not be greater than queues (7)"),
field.Invalid(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing").Child("handSize"), int32(8), "should not be greater than queues (7)"),
},
},
}

46
pkg/apis/flowcontrol/zz_generated.deepcopy.go generated
View File

@ -186,6 +186,44 @@ func (in *GroupSubject) DeepCopy() *GroupSubject {
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitResponse) DeepCopyInto(out *LimitResponse) {
*out = *in
if in.Queuing != nil {
in, out := &in.Queuing, &out.Queuing
*out = new(QueuingConfiguration)
**out = **in
}
return
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitResponse.
func (in *LimitResponse) DeepCopy() *LimitResponse {
if in == nil {
return nil
}
out := new(LimitResponse)
in.DeepCopyInto(out)
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitedPriorityLevelConfiguration) DeepCopyInto(out *LimitedPriorityLevelConfiguration) {
*out = *in
in.LimitResponse.DeepCopyInto(&out.LimitResponse)
return
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitedPriorityLevelConfiguration.
func (in *LimitedPriorityLevelConfiguration) DeepCopy() *LimitedPriorityLevelConfiguration {
if in == nil {
return nil
}
out := new(LimitedPriorityLevelConfiguration)
in.DeepCopyInto(out)
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NonResourcePolicyRule) DeepCopyInto(out *NonResourcePolicyRule) {
*out = *in
@ -346,10 +384,10 @@ func (in *PriorityLevelConfigurationReference) DeepCopy() *PriorityLevelConfigur
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PriorityLevelConfigurationSpec) DeepCopyInto(out *PriorityLevelConfigurationSpec) {
*out = *in
if in.Queuing != nil {
in, out := &in.Queuing, &out.Queuing
*out = new(QueuingConfiguration)
**out = **in
if in.Limited != nil {
in, out := &in.Limited, &out.Limited
*out = new(LimitedPriorityLevelConfiguration)
(*in).DeepCopyInto(*out)
}
return
}

668
staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.pb.go generated
View File

@ -239,10 +239,66 @@ func (m *GroupSubject) XXX_DiscardUnknown() {
var xxx_messageInfo_GroupSubject proto.InternalMessageInfo
func (m *LimitResponse) Reset() { *m = LimitResponse{} }
func (*LimitResponse) ProtoMessage() {}
func (*LimitResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{7}
}
func (m *LimitResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LimitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
func (m *LimitResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_LimitResponse.Merge(m, src)
}
func (m *LimitResponse) XXX_Size() int {
return m.Size()
}
func (m *LimitResponse) XXX_DiscardUnknown() {
xxx_messageInfo_LimitResponse.DiscardUnknown(m)
}
var xxx_messageInfo_LimitResponse proto.InternalMessageInfo
func (m *LimitedPriorityLevelConfiguration) Reset() { *m = LimitedPriorityLevelConfiguration{} }
func (*LimitedPriorityLevelConfiguration) ProtoMessage() {}
func (*LimitedPriorityLevelConfiguration) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{8}
}
func (m *LimitedPriorityLevelConfiguration) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *LimitedPriorityLevelConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
func (m *LimitedPriorityLevelConfiguration) XXX_Merge(src proto.Message) {
xxx_messageInfo_LimitedPriorityLevelConfiguration.Merge(m, src)
}
func (m *LimitedPriorityLevelConfiguration) XXX_Size() int {
return m.Size()
}
func (m *LimitedPriorityLevelConfiguration) XXX_DiscardUnknown() {
xxx_messageInfo_LimitedPriorityLevelConfiguration.DiscardUnknown(m)
}
var xxx_messageInfo_LimitedPriorityLevelConfiguration proto.InternalMessageInfo
func (m *NonResourcePolicyRule) Reset() { *m = NonResourcePolicyRule{} }
func (*NonResourcePolicyRule) ProtoMessage() {}
func (*NonResourcePolicyRule) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{7}
return fileDescriptor_45ba024d525b289b, []int{9}
}
func (m *NonResourcePolicyRule) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -270,7 +326,7 @@ var xxx_messageInfo_NonResourcePolicyRule proto.InternalMessageInfo
func (m *PolicyRulesWithSubjects) Reset() { *m = PolicyRulesWithSubjects{} }
func (*PolicyRulesWithSubjects) ProtoMessage() {}
func (*PolicyRulesWithSubjects) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{8}
return fileDescriptor_45ba024d525b289b, []int{10}
}
func (m *PolicyRulesWithSubjects) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -298,7 +354,7 @@ var xxx_messageInfo_PolicyRulesWithSubjects proto.InternalMessageInfo
func (m *PriorityLevelConfiguration) Reset() { *m = PriorityLevelConfiguration{} }
func (*PriorityLevelConfiguration) ProtoMessage() {}
func (*PriorityLevelConfiguration) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{9}
return fileDescriptor_45ba024d525b289b, []int{11}
}
func (m *PriorityLevelConfiguration) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -326,7 +382,7 @@ var xxx_messageInfo_PriorityLevelConfiguration proto.InternalMessageInfo
func (m *PriorityLevelConfigurationCondition) Reset() { *m = PriorityLevelConfigurationCondition{} }
func (*PriorityLevelConfigurationCondition) ProtoMessage() {}
func (*PriorityLevelConfigurationCondition) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{10}
return fileDescriptor_45ba024d525b289b, []int{12}
}
func (m *PriorityLevelConfigurationCondition) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -354,7 +410,7 @@ var xxx_messageInfo_PriorityLevelConfigurationCondition proto.InternalMessageInf
func (m *PriorityLevelConfigurationList) Reset() { *m = PriorityLevelConfigurationList{} }
func (*PriorityLevelConfigurationList) ProtoMessage() {}
func (*PriorityLevelConfigurationList) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{11}
return fileDescriptor_45ba024d525b289b, []int{13}
}
func (m *PriorityLevelConfigurationList) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -382,7 +438,7 @@ var xxx_messageInfo_PriorityLevelConfigurationList proto.InternalMessageInfo
func (m *PriorityLevelConfigurationReference) Reset() { *m = PriorityLevelConfigurationReference{} }
func (*PriorityLevelConfigurationReference) ProtoMessage() {}
func (*PriorityLevelConfigurationReference) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{12}
return fileDescriptor_45ba024d525b289b, []int{14}
}
func (m *PriorityLevelConfigurationReference) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -410,7 +466,7 @@ var xxx_messageInfo_PriorityLevelConfigurationReference proto.InternalMessageInf
func (m *PriorityLevelConfigurationSpec) Reset() { *m = PriorityLevelConfigurationSpec{} }
func (*PriorityLevelConfigurationSpec) ProtoMessage() {}
func (*PriorityLevelConfigurationSpec) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{13}
return fileDescriptor_45ba024d525b289b, []int{15}
}
func (m *PriorityLevelConfigurationSpec) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -438,7 +494,7 @@ var xxx_messageInfo_PriorityLevelConfigurationSpec proto.InternalMessageInfo
func (m *PriorityLevelConfigurationStatus) Reset() { *m = PriorityLevelConfigurationStatus{} }
func (*PriorityLevelConfigurationStatus) ProtoMessage() {}
func (*PriorityLevelConfigurationStatus) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{14}
return fileDescriptor_45ba024d525b289b, []int{16}
}
func (m *PriorityLevelConfigurationStatus) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -466,7 +522,7 @@ var xxx_messageInfo_PriorityLevelConfigurationStatus proto.InternalMessageInfo
func (m *QueuingConfiguration) Reset() { *m = QueuingConfiguration{} }
func (*QueuingConfiguration) ProtoMessage() {}
func (*QueuingConfiguration) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{15}
return fileDescriptor_45ba024d525b289b, []int{17}
}
func (m *QueuingConfiguration) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -494,7 +550,7 @@ var xxx_messageInfo_QueuingConfiguration proto.InternalMessageInfo
func (m *ResourcePolicyRule) Reset() { *m = ResourcePolicyRule{} }
func (*ResourcePolicyRule) ProtoMessage() {}
func (*ResourcePolicyRule) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{16}
return fileDescriptor_45ba024d525b289b, []int{18}
}
func (m *ResourcePolicyRule) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -522,7 +578,7 @@ var xxx_messageInfo_ResourcePolicyRule proto.InternalMessageInfo
func (m *ServiceAccountSubject) Reset() { *m = ServiceAccountSubject{} }
func (*ServiceAccountSubject) ProtoMessage() {}
func (*ServiceAccountSubject) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{17}
return fileDescriptor_45ba024d525b289b, []int{19}
}
func (m *ServiceAccountSubject) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -550,7 +606,7 @@ var xxx_messageInfo_ServiceAccountSubject proto.InternalMessageInfo
func (m *Subject) Reset() { *m = Subject{} }
func (*Subject) ProtoMessage() {}
func (*Subject) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{18}
return fileDescriptor_45ba024d525b289b, []int{20}
}
func (m *Subject) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -578,7 +634,7 @@ var xxx_messageInfo_Subject proto.InternalMessageInfo
func (m *UserSubject) Reset() { *m = UserSubject{} }
func (*UserSubject) ProtoMessage() {}
func (*UserSubject) Descriptor() ([]byte, []int) {
return fileDescriptor_45ba024d525b289b, []int{19}
return fileDescriptor_45ba024d525b289b, []int{21}
}
func (m *UserSubject) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -611,6 +667,8 @@ func init() {
proto.RegisterType((*FlowSchemaSpec)(nil), "k8s.io.api.flowcontrol.v1alpha1.FlowSchemaSpec")
proto.RegisterType((*FlowSchemaStatus)(nil), "k8s.io.api.flowcontrol.v1alpha1.FlowSchemaStatus")
proto.RegisterType((*GroupSubject)(nil), "k8s.io.api.flowcontrol.v1alpha1.GroupSubject")
proto.RegisterType((*LimitResponse)(nil), "k8s.io.api.flowcontrol.v1alpha1.LimitResponse")
proto.RegisterType((*LimitedPriorityLevelConfiguration)(nil), "k8s.io.api.flowcontrol.v1alpha1.LimitedPriorityLevelConfiguration")
proto.RegisterType((*NonResourcePolicyRule)(nil), "k8s.io.api.flowcontrol.v1alpha1.NonResourcePolicyRule")
proto.RegisterType((*PolicyRulesWithSubjects)(nil), "k8s.io.api.flowcontrol.v1alpha1.PolicyRulesWithSubjects")
proto.RegisterType((*PriorityLevelConfiguration)(nil), "k8s.io.api.flowcontrol.v1alpha1.PriorityLevelConfiguration")
@ -631,94 +689,99 @@ func init() {
}
var fileDescriptor_45ba024d525b289b = []byte{
// 1386 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x56, 0xdd, 0x6e, 0xd4, 0xc6,
0x17, 0x8f, 0x37, 0xbb, 0x49, 0x76, 0x42, 0x3e, 0xfe, 0x93, 0x3f, 0xca, 0x36, 0x48, 0xbb, 0xa9,
0x2b, 0x15, 0x28, 0x60, 0x13, 0x4a, 0x29, 0x15, 0x42, 0x28, 0x06, 0x95, 0xaf, 0x24, 0x4d, 0x26,
0x40, 0x55, 0x44, 0x25, 0x26, 0xde, 0x89, 0x77, 0xc8, 0xae, 0xed, 0xce, 0xd8, 0x4b, 0x53, 0x71,
0x51, 0xa9, 0x0f, 0x50, 0x1e, 0x80, 0x07, 0xe8, 0x4b, 0x54, 0xea, 0x25, 0xaa, 0x7a, 0xc1, 0x25,
0x57, 0x2b, 0xb2, 0xbd, 0xed, 0x03, 0x54, 0x5c, 0x55, 0x33, 0x1e, 0xdb, 0xeb, 0xfd, 0xc8, 0x2e,
0x8d, 0xc4, 0x55, 0xef, 0xec, 0x73, 0xce, 0xef, 0x77, 0xce, 0x9c, 0x39, 0x67, 0xce, 0x01, 0xb7,
0xf6, 0x2e, 0x73, 0x83, 0x7a, 0xe6, 0x5e, 0xb8, 0x43, 0x98, 0x4b, 0x02, 0xc2, 0xcd, 0x26, 0x71,
0xab, 0x1e, 0x33, 0x95, 0x02, 0xfb, 0xd4, 0xdc, 0xad, 0x7b, 0x4f, 0x6d, 0xcf, 0x0d, 0x98, 0x57,
0x37, 0x9b, 0x2b, 0xb8, 0xee, 0xd7, 0xf0, 0x8a, 0xe9, 0x10, 0x97, 0x30, 0x1c, 0x90, 0xaa, 0xe1,
0x33, 0x2f, 0xf0, 0x60, 0x25, 0x02, 0x18, 0xd8, 0xa7, 0x46, 0x07, 0xc0, 0x88, 0x01, 0x4b, 0xe7,
0x1c, 0x1a, 0xd4, 0xc2, 0x1d, 0xc3, 0xf6, 0x1a, 0xa6, 0xe3, 0x39, 0x9e, 0x29, 0x71, 0x3b, 0xe1,
0xae, 0xfc, 0x93, 0x3f, 0xf2, 0x2b, 0xe2, 0x5b, 0xba, 0x98, 0x06, 0xd0, 0xc0, 0x76, 0x8d, 0xba,
0x84, 0xed, 0x9b, 0xfe, 0x9e, 0x23, 0x04, 0xdc, 0x6c, 0x90, 0x00, 0x9b, 0xcd, 0x9e, 0x28, 0x96,
0xcc, 0x41, 0x28, 0x16, 0xba, 0x01, 0x6d, 0x90, 0x1e, 0xc0, 0xa5, 0x61, 0x00, 0x6e, 0xd7, 0x48,
0x03, 0x77, 0xe3, 0xf4, 0x87, 0x60, 0xf1, 0xcb, 0xba, 0xf7, 0xf4, 0x06, 0xe5, 0x01, 0x75, 0x9d,
0x90, 0xf2, 0x1a, 0x61, 0xeb, 0x24, 0xa8, 0x79, 0x55, 0x78, 0x0d, 0xe4, 0x83, 0x7d, 0x9f, 0x94,
0xb4, 0x65, 0xed, 0x54, 0xd1, 0x3a, 0xf3, 0xb2, 0x55, 0x19, 0x6b, 0xb7, 0x2a, 0xf9, 0x7b, 0xfb,
0x3e, 0x79, 0xdb, 0xaa, 0x9c, 0x18, 0x00, 0x13, 0x6a, 0x24, 0x81, 0xfa, 0x8b, 0x1c, 0x00, 0xc2,
0x6a, 0x5b, 0xba, 0x86, 0x8f, 0xc1, 0x94, 0x38, 0x6e, 0x15, 0x07, 0x58, 0x72, 0x4e, 0x5f, 0x38,
0x6f, 0xa4, 0xc9, 0x4e, 0xa2, 0x36, 0xfc, 0x3d, 0x47, 0x08, 0xb8, 0x21, 0xac, 0x8d, 0xe6, 0x8a,
0xf1, 0xd5, 0xce, 0x13, 0x62, 0x07, 0xeb, 0x24, 0xc0, 0x16, 0x54, 0x51, 0x80, 0x54, 0x86, 0x12,
0x56, 0xb8, 0x05, 0xf2, 0xdc, 0x27, 0x76, 0x29, 0x27, 0xd9, 0x4d, 0x63, 0xc8, 0x55, 0x1a, 0x69,
0x70, 0xdb, 0x3e, 0xb1, 0xad, 0x63, 0xf1, 0x11, 0xc5, 0x1f, 0x92, 0x54, 0xf0, 0x1b, 0x30, 0xc1,
0x03, 0x1c, 0x84, 0xbc, 0x34, 0x2e, 0x49, 0x57, 0xde, 0x85, 0x54, 0x02, 0xad, 0x59, 0x45, 0x3b,
0x11, 0xfd, 0x23, 0x45, 0xa8, 0xbf, 0xce, 0x81, 0x85, 0xd4, 0xf8, 0xba, 0xe7, 0x56, 0x69, 0x40,
0x3d, 0x17, 0x5e, 0xc9, 0xe4, 0xfd, 0x64, 0x57, 0xde, 0x17, 0xfb, 0x40, 0xd2, 0x9c, 0xc3, 0x2f,
0x92, 0x78, 0x73, 0x12, 0xfe, 0x61, 0xd6, 0xf9, 0xdb, 0x56, 0x65, 0x2e, 0x81, 0x65, 0xe3, 0x81,
0x4d, 0x00, 0xeb, 0x98, 0x07, 0xf7, 0x18, 0x76, 0x79, 0x44, 0x4b, 0x1b, 0x44, 0x1d, 0xfb, 0x93,
0xd1, 0x6e, 0x4a, 0x20, 0xac, 0x25, 0xe5, 0x12, 0xae, 0xf5, 0xb0, 0xa1, 0x3e, 0x1e, 0xe0, 0xc7,
0x60, 0x82, 0x11, 0xcc, 0x3d, 0xb7, 0x94, 0x97, 0x21, 0x27, 0xf9, 0x42, 0x52, 0x8a, 0x94, 0x16,
0x9e, 0x06, 0x93, 0x0d, 0xc2, 0x39, 0x76, 0x48, 0xa9, 0x20, 0x0d, 0xe7, 0x94, 0xe1, 0xe4, 0x7a,
0x24, 0x46, 0xb1, 0x5e, 0xff, 0x4d, 0x03, 0xb3, 0x69, 0x9e, 0xd6, 0x28, 0x0f, 0xe0, 0xa3, 0x9e,
0xea, 0x33, 0x46, 0x3b, 0x93, 0x40, 0xcb, 0xda, 0x9b, 0x57, 0xee, 0xa6, 0x62, 0x49, 0x47, 0xe5,
0x6d, 0x82, 0x02, 0x0d, 0x48, 0x43, 0x64, 0x7d, 0xfc, 0xd4, 0xf4, 0x85, 0x33, 0xef, 0x50, 0x25,
0xd6, 0x8c, 0xe2, 0x2d, 0xdc, 0x16, 0x0c, 0x28, 0x22, 0xd2, 0xff, 0x1a, 0xef, 0x3c, 0x82, 0xa8,
0x48, 0xf8, 0x8b, 0x06, 0x96, 0x7c, 0x46, 0x3d, 0x46, 0x83, 0xfd, 0x35, 0xd2, 0x24, 0xf5, 0xeb,
0x9e, 0xbb, 0x4b, 0x9d, 0x90, 0x61, 0x91, 0x4b, 0x75, 0xaa, 0x1b, 0x43, 0x5d, 0x6f, 0x0e, 0xa4,
0x40, 0x64, 0x97, 0x30, 0xe2, 0xda, 0xc4, 0xd2, 0x55, 0x4c, 0x4b, 0x87, 0x18, 0x1f, 0x12, 0x0b,
0xbc, 0x03, 0x60, 0x03, 0x07, 0x22, 0xa7, 0xce, 0x26, 0x23, 0x36, 0xa9, 0x0a, 0x56, 0x59, 0x92,
0x85, 0xb4, 0x3e, 0xd6, 0x7b, 0x2c, 0x50, 0x1f, 0x14, 0xfc, 0x49, 0x03, 0x0b, 0xd5, 0xde, 0x87,
0x46, 0x55, 0xe6, 0xe5, 0x91, 0x52, 0xdd, 0xe7, 0xa1, 0xb2, 0x16, 0xdb, 0xad, 0xca, 0x42, 0x1f,
0x05, 0xea, 0xe7, 0x0d, 0x7e, 0x0b, 0x0a, 0x2c, 0xac, 0x13, 0x5e, 0xca, 0xcb, 0x1b, 0x1e, 0xee,
0x76, 0xd3, 0xab, 0x53, 0x7b, 0x1f, 0x09, 0xcc, 0xd7, 0x34, 0xa8, 0x6d, 0x87, 0xf2, 0xc5, 0xe2,
0xe9, 0x75, 0x4b, 0x15, 0x8a, 0x58, 0xf5, 0x67, 0x60, 0xbe, 0xfb, 0xe1, 0x80, 0x35, 0x00, 0xec,
0xb8, 0x57, 0x79, 0x49, 0x93, 0x7e, 0x2f, 0xbe, 0x43, 0x65, 0x25, 0x8d, 0x9e, 0x3e, 0x9b, 0x89,
0x88, 0xa3, 0x0e, 0x6e, 0xfd, 0x3c, 0x38, 0x76, 0x93, 0x79, 0xa1, 0xaf, 0x82, 0x84, 0xcb, 0x20,
0xef, 0xe2, 0x46, 0xfc, 0x04, 0x25, 0xef, 0xe2, 0x06, 0x6e, 0x10, 0x24, 0x35, 0xfa, 0x53, 0x70,
0x7c, 0x43, 0x14, 0x0c, 0xf7, 0x42, 0x66, 0x93, 0xf4, 0xac, 0xb0, 0x02, 0x0a, 0x4d, 0xc2, 0x76,
0xa2, 0x78, 0x8b, 0x56, 0x51, 0x9c, 0xf4, 0x81, 0x10, 0xa0, 0x48, 0x0e, 0xaf, 0x82, 0x39, 0x37,
0x45, 0xde, 0x47, 0x6b, 0xbc, 0x34, 0x21, 0x4d, 0x17, 0xda, 0xad, 0xca, 0xdc, 0x46, 0x56, 0x85,
0xba, 0x6d, 0xf5, 0x83, 0x1c, 0x58, 0x1c, 0x90, 0x5a, 0xf8, 0x00, 0x4c, 0x71, 0xf5, 0xad, 0xd2,
0x75, 0x6a, 0x68, 0xba, 0x14, 0x38, 0xed, 0xee, 0x98, 0x0d, 0x25, 0x5c, 0xd0, 0x07, 0x33, 0x4c,
0xc5, 0x20, 0x9d, 0xaa, 0x2e, 0xff, 0x74, 0x28, 0x79, 0x6f, 0x7e, 0xac, 0xe3, 0xca, 0xcf, 0x0c,
0xea, 0x64, 0x44, 0x59, 0x07, 0xf0, 0x19, 0x98, 0xef, 0x38, 0x78, 0xe4, 0x74, 0x5c, 0x3a, 0xbd,
0x34, 0xd4, 0x69, 0xdf, 0x7b, 0xb1, 0x4a, 0xca, 0xef, 0xfc, 0x46, 0x17, 0x2f, 0xea, 0xf1, 0xa4,
0xff, 0x91, 0x03, 0x87, 0x34, 0xfe, 0x7b, 0x18, 0xe4, 0x38, 0x33, 0xc8, 0xaf, 0x1d, 0xe1, 0x49,
0x1b, 0x38, 0xd8, 0x69, 0xd7, 0x60, 0x5f, 0x3d, 0x8a, 0x93, 0xc3, 0x07, 0xfd, 0xdf, 0x39, 0xf0,
0xd1, 0x60, 0x70, 0x3a, 0xf8, 0xef, 0x66, 0x06, 0xff, 0xe7, 0x5d, 0x83, 0xff, 0xe4, 0x08, 0x14,
0xff, 0x2d, 0x02, 0x5d, 0x8b, 0xc0, 0x1b, 0x0d, 0x94, 0x07, 0xe7, 0xed, 0x3d, 0x2c, 0x06, 0x8f,
0xb3, 0x8b, 0xc1, 0x95, 0x23, 0x54, 0xd9, 0x80, 0x45, 0xe1, 0xe6, 0x61, 0xc5, 0x95, 0x4c, 0xf4,
0x11, 0x9e, 0xf4, 0x5f, 0x0f, 0xcd, 0x95, 0xdc, 0x40, 0xae, 0x66, 0x2a, 0xf4, 0x74, 0x57, 0x85,
0x7e, 0x90, 0x41, 0x6f, 0x85, 0x24, 0x24, 0xd4, 0x75, 0x3a, 0x6a, 0xf2, 0x11, 0x98, 0xfc, 0x2e,
0x24, 0x21, 0x75, 0x1d, 0xd5, 0xd9, 0x9f, 0x0d, 0x4d, 0xc7, 0x56, 0x64, 0x9f, 0x4d, 0xc4, 0xb4,
0xb8, 0x6b, 0xa5, 0x41, 0x31, 0xa5, 0xfe, 0x42, 0x03, 0xcb, 0xc3, 0x7a, 0x14, 0x7e, 0xdf, 0x67,
0xa6, 0x1e, 0x65, 0x65, 0x1a, 0x7d, 0xc6, 0x3e, 0xcf, 0x81, 0xff, 0xf7, 0x3b, 0x0d, 0x7c, 0x04,
0x4a, 0x98, 0xf3, 0x90, 0x91, 0xea, 0x75, 0xcf, 0xb5, 0x43, 0x26, 0xee, 0x6b, 0x7f, 0xbb, 0x86,
0x19, 0xe1, 0x32, 0xd1, 0x05, 0x6b, 0x59, 0x51, 0x97, 0x56, 0x07, 0xd8, 0xa1, 0x81, 0x0c, 0xa2,
0xa9, 0x44, 0x82, 0x08, 0x57, 0xdb, 0x57, 0xd2, 0x54, 0xf2, 0x7e, 0x38, 0x52, 0x5a, 0x78, 0x16,
0x4c, 0xd5, 0xb0, 0x5b, 0xdd, 0xa6, 0x3f, 0x44, 0xad, 0x5e, 0x48, 0xcb, 0xfa, 0x96, 0x92, 0xa3,
0xc4, 0x02, 0xde, 0x00, 0xf3, 0x12, 0xb7, 0x46, 0x5c, 0x27, 0xa8, 0xad, 0xd1, 0x06, 0x0d, 0x64,
0xd3, 0x16, 0xd2, 0x39, 0xb3, 0xd5, 0xa5, 0x47, 0x3d, 0x08, 0xfd, 0x67, 0x0d, 0xc0, 0x7f, 0xb3,
0x42, 0x9c, 0x01, 0x45, 0xec, 0x53, 0xb9, 0xb1, 0x44, 0x8d, 0x55, 0xb4, 0x66, 0xda, 0xad, 0x4a,
0x71, 0x75, 0xf3, 0x76, 0x24, 0x44, 0xa9, 0x5e, 0x18, 0xc7, 0xb3, 0x35, 0x9a, 0xa1, 0xca, 0x38,
0x76, 0xcc, 0x51, 0xaa, 0xd7, 0x9f, 0x80, 0xe3, 0xdb, 0x84, 0x35, 0xa9, 0x4d, 0x56, 0x6d, 0xdb,
0x0b, 0xdd, 0x20, 0xde, 0x88, 0x4c, 0x50, 0x14, 0x4d, 0xc2, 0x7d, 0x6c, 0xc7, 0xe5, 0xff, 0x3f,
0x75, 0xd2, 0xe2, 0x46, 0xac, 0x40, 0xa9, 0x4d, 0xd2, 0x6f, 0xb9, 0x81, 0xfd, 0xf6, 0x7b, 0x0e,
0x4c, 0xa6, 0xf4, 0xf9, 0x3d, 0xea, 0x56, 0x15, 0xf3, 0x89, 0xd8, 0xfa, 0x2e, 0x75, 0xab, 0x6f,
0x5b, 0x95, 0x69, 0x65, 0x26, 0x7e, 0x91, 0x34, 0x84, 0x77, 0x40, 0x3e, 0xe4, 0x84, 0xa9, 0x3e,
0x3a, 0x3b, 0xb4, 0x82, 0xef, 0x73, 0xc2, 0xe2, 0x55, 0x67, 0x4a, 0x50, 0x0b, 0x01, 0x92, 0x1c,
0x70, 0x03, 0x14, 0x1c, 0x91, 0x2b, 0xf5, 0xc4, 0x9f, 0x1b, 0x4a, 0xd6, 0xb9, 0x2b, 0x46, 0xd7,
0x23, 0x25, 0x28, 0xa2, 0x81, 0x0c, 0xcc, 0xf2, 0x4c, 0x12, 0x65, 0x69, 0x8c, 0xb2, 0xba, 0xf4,
0xcd, 0xbd, 0x05, 0xdb, 0xad, 0xca, 0x6c, 0x56, 0x85, 0xba, 0x3c, 0xe8, 0x26, 0x98, 0xee, 0x38,
0xe2, 0xf0, 0xd7, 0xce, 0x32, 0x5e, 0x1e, 0x94, 0xc7, 0x5e, 0x1d, 0x94, 0xc7, 0x5e, 0x1f, 0x94,
0xc7, 0x7e, 0x6c, 0x97, 0xb5, 0x97, 0xed, 0xb2, 0xf6, 0xaa, 0x5d, 0xd6, 0x5e, 0xb7, 0xcb, 0xda,
0x9b, 0x76, 0x59, 0x7b, 0xfe, 0x67, 0x79, 0xec, 0xe1, 0x54, 0x1c, 0xda, 0x3f, 0x01, 0x00, 0x00,
0xff, 0xff, 0x14, 0x4f, 0x2e, 0xc5, 0x62, 0x12, 0x00, 0x00,
// 1459 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x57, 0x4d, 0x6f, 0x13, 0xc7,
0x1b, 0xcf, 0x3a, 0x76, 0x12, 0x4f, 0xc8, 0x0b, 0x93, 0x3f, 0x8a, 0x15, 0x24, 0x3b, 0xec, 0x5f,
0x2a, 0xb4, 0xc0, 0x2e, 0xa1, 0x40, 0xa9, 0x50, 0x85, 0xb2, 0xd0, 0xf2, 0x96, 0xa4, 0xc9, 0x04,
0xa8, 0x8a, 0xa8, 0xc4, 0x64, 0x3d, 0xb1, 0x87, 0xd8, 0xbb, 0xdb, 0x99, 0x5d, 0xd3, 0x54, 0x1c,
0x2a, 0xf5, 0x03, 0xb4, 0x1f, 0x80, 0x63, 0x0f, 0x3d, 0xf7, 0x13, 0xf4, 0x18, 0x55, 0x3d, 0x70,
0xe4, 0x64, 0x11, 0xf7, 0x5a, 0xf5, 0x5c, 0x71, 0xaa, 0x66, 0x76, 0x76, 0xd7, 0xeb, 0x77, 0x1a,
0x89, 0x53, 0x6f, 0xde, 0xe7, 0xe5, 0xf7, 0xbc, 0xcc, 0x33, 0xcf, 0xfc, 0x0c, 0x6e, 0xef, 0x5d,
0xe5, 0x06, 0x75, 0xcd, 0xbd, 0x60, 0x87, 0x30, 0x87, 0xf8, 0x84, 0x9b, 0x0d, 0xe2, 0x94, 0x5d,
0x66, 0x2a, 0x05, 0xf6, 0xa8, 0xb9, 0x5b, 0x73, 0x9f, 0xd9, 0xae, 0xe3, 0x33, 0xb7, 0x66, 0x36,
0x56, 0x70, 0xcd, 0xab, 0xe2, 0x15, 0xb3, 0x42, 0x1c, 0xc2, 0xb0, 0x4f, 0xca, 0x86, 0xc7, 0x5c,
0xdf, 0x85, 0xa5, 0xd0, 0xc1, 0xc0, 0x1e, 0x35, 0xda, 0x1c, 0x8c, 0xc8, 0x61, 0xe9, 0x7c, 0x85,
0xfa, 0xd5, 0x60, 0xc7, 0xb0, 0xdd, 0xba, 0x59, 0x71, 0x2b, 0xae, 0x29, 0xfd, 0x76, 0x82, 0x5d,
0xf9, 0x25, 0x3f, 0xe4, 0xaf, 0x10, 0x6f, 0xe9, 0x52, 0x92, 0x40, 0x1d, 0xdb, 0x55, 0xea, 0x10,
0xb6, 0x6f, 0x7a, 0x7b, 0x15, 0x21, 0xe0, 0x66, 0x9d, 0xf8, 0xd8, 0x6c, 0x74, 0x65, 0xb1, 0x64,
0xf6, 0xf3, 0x62, 0x81, 0xe3, 0xd3, 0x3a, 0xe9, 0x72, 0xb8, 0x32, 0xcc, 0x81, 0xdb, 0x55, 0x52,
0xc7, 0x9d, 0x7e, 0xfa, 0x23, 0xb0, 0xf8, 0x59, 0xcd, 0x7d, 0x76, 0x93, 0x72, 0x9f, 0x3a, 0x95,
0x80, 0xf2, 0x2a, 0x61, 0xeb, 0xc4, 0xaf, 0xba, 0x65, 0x78, 0x1d, 0x64, 0xfd, 0x7d, 0x8f, 0x14,
0xb4, 0x65, 0xed, 0x4c, 0xde, 0x3a, 0x7b, 0xd0, 0x2c, 0x8d, 0xb5, 0x9a, 0xa5, 0xec, 0xfd, 0x7d,
0x8f, 0xbc, 0x69, 0x96, 0x4e, 0xf6, 0x71, 0x13, 0x6a, 0x24, 0x1d, 0xf5, 0x17, 0x19, 0x00, 0x84,
0xd5, 0xb6, 0x0c, 0x0d, 0x9f, 0x80, 0x29, 0x51, 0x6e, 0x19, 0xfb, 0x58, 0x62, 0x4e, 0x5f, 0xbc,
0x60, 0x24, 0xcd, 0x8e, 0xb3, 0x36, 0xbc, 0xbd, 0x8a, 0x10, 0x70, 0x43, 0x58, 0x1b, 0x8d, 0x15,
0xe3, 0xf3, 0x9d, 0xa7, 0xc4, 0xf6, 0xd7, 0x89, 0x8f, 0x2d, 0xa8, 0xb2, 0x00, 0x89, 0x0c, 0xc5,
0xa8, 0x70, 0x0b, 0x64, 0xb9, 0x47, 0xec, 0x42, 0x46, 0xa2, 0x9b, 0xc6, 0x90, 0xa3, 0x34, 0x92,
0xe4, 0xb6, 0x3d, 0x62, 0x5b, 0xc7, 0xa2, 0x12, 0xc5, 0x17, 0x92, 0x50, 0xf0, 0x4b, 0x30, 0xc1,
0x7d, 0xec, 0x07, 0xbc, 0x30, 0x2e, 0x41, 0x57, 0xde, 0x06, 0x54, 0x3a, 0x5a, 0xb3, 0x0a, 0x76,
0x22, 0xfc, 0x46, 0x0a, 0x50, 0x7f, 0x95, 0x01, 0x0b, 0x89, 0xf1, 0x0d, 0xd7, 0x29, 0x53, 0x9f,
0xba, 0x0e, 0xbc, 0x96, 0xea, 0xfb, 0xe9, 0x8e, 0xbe, 0x2f, 0xf6, 0x70, 0x49, 0x7a, 0x0e, 0x3f,
0x8e, 0xf3, 0xcd, 0x48, 0xf7, 0x53, 0xe9, 0xe0, 0x6f, 0x9a, 0xa5, 0xb9, 0xd8, 0x2d, 0x9d, 0x0f,
0x6c, 0x00, 0x58, 0xc3, 0xdc, 0xbf, 0xcf, 0xb0, 0xc3, 0x43, 0x58, 0x5a, 0x27, 0xaa, 0xec, 0x0f,
0x46, 0x3b, 0x29, 0xe1, 0x61, 0x2d, 0xa9, 0x90, 0x70, 0xad, 0x0b, 0x0d, 0xf5, 0x88, 0x00, 0xdf,
0x03, 0x13, 0x8c, 0x60, 0xee, 0x3a, 0x85, 0xac, 0x4c, 0x39, 0xee, 0x17, 0x92, 0x52, 0xa4, 0xb4,
0xf0, 0x7d, 0x30, 0x59, 0x27, 0x9c, 0xe3, 0x0a, 0x29, 0xe4, 0xa4, 0xe1, 0x9c, 0x32, 0x9c, 0x5c,
0x0f, 0xc5, 0x28, 0xd2, 0xeb, 0xbf, 0x6a, 0x60, 0x36, 0xe9, 0xd3, 0x1a, 0xe5, 0x3e, 0x7c, 0xdc,
0x35, 0x7d, 0xc6, 0x68, 0x35, 0x09, 0x6f, 0x39, 0x7b, 0xf3, 0x2a, 0xdc, 0x54, 0x24, 0x69, 0x9b,
0xbc, 0x4d, 0x90, 0xa3, 0x3e, 0xa9, 0x8b, 0xae, 0x8f, 0x9f, 0x99, 0xbe, 0x78, 0xf6, 0x2d, 0xa6,
0xc4, 0x9a, 0x51, 0xb8, 0xb9, 0x3b, 0x02, 0x01, 0x85, 0x40, 0xfa, 0x9f, 0xe3, 0xed, 0x25, 0x88,
0x89, 0x84, 0x3f, 0x6b, 0x60, 0xc9, 0x63, 0xd4, 0x65, 0xd4, 0xdf, 0x5f, 0x23, 0x0d, 0x52, 0xbb,
0xe1, 0x3a, 0xbb, 0xb4, 0x12, 0x30, 0x2c, 0x7a, 0xa9, 0xaa, 0xba, 0x39, 0x34, 0xf4, 0x66, 0x5f,
0x08, 0x44, 0x76, 0x09, 0x23, 0x8e, 0x4d, 0x2c, 0x5d, 0xe5, 0xb4, 0x34, 0xc0, 0x78, 0x40, 0x2e,
0xf0, 0x2e, 0x80, 0x75, 0xec, 0x8b, 0x9e, 0x56, 0x36, 0x19, 0xb1, 0x49, 0x59, 0xa0, 0xca, 0x91,
0xcc, 0x25, 0xf3, 0xb1, 0xde, 0x65, 0x81, 0x7a, 0x78, 0xc1, 0xef, 0x35, 0xb0, 0x50, 0xee, 0x5e,
0x34, 0x6a, 0x32, 0xaf, 0x8e, 0xd4, 0xea, 0x1e, 0x8b, 0xca, 0x5a, 0x6c, 0x35, 0x4b, 0x0b, 0x3d,
0x14, 0xa8, 0x57, 0x34, 0xf8, 0x15, 0xc8, 0xb1, 0xa0, 0x46, 0x78, 0x21, 0x2b, 0x4f, 0x78, 0x78,
0xd8, 0x4d, 0xb7, 0x46, 0xed, 0x7d, 0x24, 0x7c, 0xbe, 0xa0, 0x7e, 0x75, 0x3b, 0x90, 0x1b, 0x8b,
0x27, 0xc7, 0x2d, 0x55, 0x28, 0x44, 0xd5, 0x9f, 0x83, 0xf9, 0xce, 0xc5, 0x01, 0xab, 0x00, 0xd8,
0xd1, 0x5d, 0xe5, 0x05, 0x4d, 0xc6, 0xbd, 0xf4, 0x16, 0x93, 0x15, 0x5f, 0xf4, 0x64, 0x6d, 0xc6,
0x22, 0x8e, 0xda, 0xb0, 0xf5, 0x0b, 0xe0, 0xd8, 0x2d, 0xe6, 0x06, 0x9e, 0x4a, 0x12, 0x2e, 0x83,
0xac, 0x83, 0xeb, 0xd1, 0x0a, 0x8a, 0xf7, 0xe2, 0x06, 0xae, 0x13, 0x24, 0x35, 0xfa, 0x4f, 0x1a,
0x98, 0x59, 0xa3, 0x75, 0xea, 0x23, 0xc2, 0x3d, 0xd7, 0xe1, 0x04, 0x5e, 0x4e, 0xad, 0xad, 0x53,
0x1d, 0x6b, 0xeb, 0x78, 0xca, 0xb8, 0x6d, 0x61, 0x3d, 0x06, 0x93, 0x5f, 0x07, 0x24, 0xa0, 0x4e,
0x45, 0xad, 0xed, 0xcb, 0x43, 0x2b, 0xdc, 0x0a, 0xed, 0x53, 0x13, 0x67, 0x4d, 0x8b, 0x45, 0xa0,
0x34, 0x28, 0x82, 0xd4, 0xff, 0xd2, 0xc0, 0x29, 0x19, 0x99, 0x94, 0xfb, 0x4f, 0x32, 0x7c, 0x0c,
0x0a, 0x98, 0xf3, 0x80, 0x91, 0xf2, 0x0d, 0xd7, 0xb1, 0x03, 0x26, 0xee, 0xc0, 0xfe, 0x76, 0x15,
0x33, 0xc2, 0x65, 0x39, 0x39, 0x6b, 0x59, 0x95, 0x53, 0x58, 0xed, 0x63, 0x87, 0xfa, 0x22, 0xc0,
0x3d, 0x30, 0x53, 0x6b, 0x2f, 0x5e, 0xd5, 0x69, 0x0c, 0xad, 0x33, 0xd5, 0x32, 0xeb, 0x84, 0x4a,
0x21, 0xdd, 0x76, 0x94, 0xc6, 0xd6, 0x9f, 0x81, 0x13, 0x1b, 0xe2, 0x22, 0x73, 0x37, 0x60, 0x36,
0x49, 0x66, 0x10, 0x96, 0x40, 0xae, 0x41, 0xd8, 0x4e, 0x38, 0x47, 0x79, 0x2b, 0x2f, 0x26, 0xf0,
0xa1, 0x10, 0xa0, 0x50, 0x0e, 0x3f, 0x01, 0x73, 0x4e, 0xe2, 0xf9, 0x00, 0xad, 0xf1, 0xc2, 0x84,
0x34, 0x5d, 0x68, 0x35, 0x4b, 0x73, 0x1b, 0x69, 0x15, 0xea, 0xb4, 0xd5, 0x0f, 0x33, 0x60, 0xb1,
0xcf, 0xc8, 0xc3, 0x87, 0x60, 0x8a, 0xab, 0xdf, 0x6a, 0x8c, 0xcf, 0x0c, 0x2d, 0x5e, 0x39, 0x27,
0x5b, 0x37, 0x42, 0x43, 0x31, 0x16, 0xf4, 0xc0, 0x0c, 0x53, 0x39, 0xc8, 0xa0, 0x6a, 0xfb, 0x7e,
0x38, 0x14, 0xbc, 0xbb, 0x3f, 0x49, 0x7b, 0x51, 0x3b, 0x22, 0x4a, 0x07, 0x80, 0xcf, 0xc1, 0x7c,
0x5b, 0xe1, 0x61, 0xd0, 0x71, 0x19, 0xf4, 0xca, 0xd0, 0xa0, 0x3d, 0xcf, 0xc5, 0x2a, 0xa8, 0xb8,
0xf3, 0x1b, 0x1d, 0xb8, 0xa8, 0x2b, 0x92, 0xfe, 0x7b, 0x06, 0x0c, 0x58, 0xc8, 0xef, 0x80, 0x60,
0xe1, 0x14, 0xc1, 0xba, 0x7e, 0x84, 0xa7, 0xa6, 0x2f, 0xe1, 0xa2, 0x1d, 0x84, 0x6b, 0xf5, 0x28,
0x41, 0x06, 0x13, 0xb0, 0xbf, 0x33, 0xe0, 0xff, 0xfd, 0x9d, 0x13, 0x42, 0x76, 0x2f, 0xb5, 0xd9,
0x3e, 0xea, 0xd8, 0x6c, 0xa7, 0x47, 0x80, 0xf8, 0x8f, 0xa0, 0x75, 0x10, 0xb4, 0xd7, 0x1a, 0x28,
0xf6, 0xef, 0xdb, 0x3b, 0x20, 0x6c, 0x4f, 0xd2, 0x84, 0xed, 0xda, 0x11, 0xa6, 0xac, 0x0f, 0x81,
0xbb, 0x35, 0x68, 0xb8, 0x62, 0xa6, 0x35, 0xc2, 0x53, 0x7b, 0x30, 0xb0, 0x57, 0x92, 0x19, 0x0e,
0xf9, 0xcb, 0x90, 0xf2, 0xfe, 0xd4, 0xc1, 0x3b, 0x35, 0x52, 0x27, 0x8e, 0xaf, 0x26, 0x92, 0x82,
0xc9, 0x5a, 0xf8, 0x44, 0xaa, 0x7b, 0x6d, 0x8d, 0xf6, 0x32, 0x0d, 0x7a, 0x52, 0xc3, 0xe7, 0x58,
0x99, 0xa1, 0x08, 0x5f, 0x7f, 0xa1, 0x81, 0xe5, 0x61, 0xd7, 0x15, 0x7e, 0xd3, 0x83, 0xf6, 0x1c,
0x85, 0xd5, 0x8e, 0x4e, 0x83, 0x7e, 0xd1, 0xc0, 0xff, 0x7a, 0x91, 0x0b, 0x71, 0x03, 0x04, 0xa3,
0x88, 0xe9, 0x40, 0x7c, 0x03, 0xb6, 0xa4, 0x14, 0x29, 0x2d, 0x3c, 0x07, 0xa6, 0xaa, 0xd8, 0x29,
0x6f, 0xd3, 0x6f, 0x23, 0xb2, 0x1b, 0xcf, 0xe0, 0x6d, 0x25, 0x47, 0xb1, 0x05, 0xbc, 0x09, 0xe6,
0xa5, 0xdf, 0x1a, 0x71, 0x2a, 0x7e, 0x55, 0x36, 0x4b, 0xde, 0xe6, 0x5c, 0xf2, 0x28, 0x6c, 0x75,
0xe8, 0x51, 0x97, 0x87, 0xfe, 0x83, 0x06, 0xe0, 0xbf, 0x79, 0xef, 0xcf, 0x82, 0x3c, 0xf6, 0xa8,
0xa4, 0x7d, 0xe1, 0x2d, 0xc8, 0x5b, 0x33, 0xad, 0x66, 0x29, 0xbf, 0xba, 0x79, 0x27, 0x14, 0xa2,
0x44, 0x2f, 0x8c, 0xa3, 0x87, 0x30, 0x7c, 0xf0, 0x94, 0x71, 0x14, 0x98, 0xa3, 0x44, 0xaf, 0x3f,
0x05, 0x27, 0xb6, 0x09, 0x6b, 0x50, 0x9b, 0xac, 0xda, 0xb6, 0x1b, 0x38, 0x7e, 0x44, 0x2b, 0x4d,
0x90, 0x17, 0x13, 0xcd, 0x3d, 0x6c, 0x47, 0xb3, 0x7a, 0x5c, 0x55, 0x9a, 0xdf, 0x88, 0x14, 0x28,
0xb1, 0x89, 0x2f, 0x47, 0xa6, 0xef, 0xe5, 0xf8, 0x2d, 0x03, 0x26, 0x13, 0xf8, 0xec, 0x1e, 0x75,
0xca, 0x0a, 0xf9, 0x64, 0x64, 0x7d, 0x8f, 0x3a, 0xe5, 0x37, 0xcd, 0xd2, 0xb4, 0x32, 0x13, 0x9f,
0x48, 0x1a, 0xc2, 0xbb, 0x20, 0x1b, 0x70, 0xc2, 0xd4, 0xd8, 0x9f, 0x1b, 0x3a, 0x63, 0x0f, 0x38,
0x61, 0x11, 0x2f, 0x99, 0x12, 0xd0, 0x42, 0x80, 0x24, 0x06, 0xdc, 0x00, 0xb9, 0x8a, 0xe8, 0x95,
0xda, 0xc7, 0xe7, 0x87, 0x82, 0xb5, 0x13, 0xee, 0xf0, 0x78, 0xa4, 0x04, 0x85, 0x30, 0x90, 0x81,
0x59, 0x9e, 0x6a, 0xa2, 0x5c, 0xbe, 0xa3, 0xf0, 0x8c, 0x9e, 0xbd, 0xb7, 0x60, 0xab, 0x59, 0x9a,
0x4d, 0xab, 0x50, 0x47, 0x04, 0xdd, 0x04, 0xd3, 0x6d, 0x25, 0x0e, 0x5f, 0x4d, 0x96, 0x71, 0x70,
0x58, 0x1c, 0x7b, 0x79, 0x58, 0x1c, 0x7b, 0x75, 0x58, 0x1c, 0xfb, 0xae, 0x55, 0xd4, 0x0e, 0x5a,
0x45, 0xed, 0x65, 0xab, 0xa8, 0xbd, 0x6a, 0x15, 0xb5, 0xd7, 0xad, 0xa2, 0xf6, 0xe3, 0x1f, 0xc5,
0xb1, 0x47, 0x53, 0x51, 0x6a, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0xcb, 0xe4, 0x65, 0x97, 0xa7,
0x13, 0x00, 0x00,
}
func (m *FlowDistinguisherMethod) Marshal() (dAtA []byte, err error) {
@ -1029,6 +1092,82 @@ func (m *GroupSubject) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *LimitResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *LimitResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LimitResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Queuing != nil {
{
size, err := m.Queuing.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenerated(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
i -= len(m.Type)
copy(dAtA[i:], m.Type)
i = encodeVarintGenerated(dAtA, i, uint64(len(m.Type)))
i--
dAtA[i] = 0xa
return len(dAtA) - i, nil
}
func (m *LimitedPriorityLevelConfiguration) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *LimitedPriorityLevelConfiguration) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *LimitedPriorityLevelConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
{
size, err := m.LimitResponse.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintGenerated(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
i = encodeVarintGenerated(dAtA, i, uint64(m.AssuredConcurrencyShares))
i--
dAtA[i] = 0x8
return len(dAtA) - i, nil
}
func (m *NonResourcePolicyRule) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -1336,9 +1475,9 @@ func (m *PriorityLevelConfigurationSpec) MarshalToSizedBuffer(dAtA []byte) (int,
_ = i
var l int
_ = l
if m.Queuing != nil {
if m.Limited != nil {
{
size, err := m.Queuing.MarshalToSizedBuffer(dAtA[:i])
size, err := m.Limited.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
@ -1415,14 +1554,11 @@ func (m *QueuingConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = l
i = encodeVarintGenerated(dAtA, i, uint64(m.QueueLengthLimit))
i--
dAtA[i] = 0x20
dAtA[i] = 0x18
i = encodeVarintGenerated(dAtA, i, uint64(m.HandSize))
i--
dAtA[i] = 0x18
i = encodeVarintGenerated(dAtA, i, uint64(m.Queues))
i--
dAtA[i] = 0x10
i = encodeVarintGenerated(dAtA, i, uint64(m.AssuredConcurrencyShares))
i = encodeVarintGenerated(dAtA, i, uint64(m.Queues))
i--
dAtA[i] = 0x8
return len(dAtA) - i, nil
@ -1724,6 +1860,33 @@ func (m *GroupSubject) Size() (n int) {
return n
}
func (m *LimitResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Type)
n += 1 + l + sovGenerated(uint64(l))
if m.Queuing != nil {
l = m.Queuing.Size()
n += 1 + l + sovGenerated(uint64(l))
}
return n
}
func (m *LimitedPriorityLevelConfiguration) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
n += 1 + sovGenerated(uint64(m.AssuredConcurrencyShares))
l = m.LimitResponse.Size()
n += 1 + l + sovGenerated(uint64(l))
return n
}
func (m *NonResourcePolicyRule) Size() (n int) {
if m == nil {
return 0
@ -1842,8 +2005,8 @@ func (m *PriorityLevelConfigurationSpec) Size() (n int) {
_ = l
l = len(m.Type)
n += 1 + l + sovGenerated(uint64(l))
if m.Queuing != nil {
l = m.Queuing.Size()
if m.Limited != nil {
l = m.Limited.Size()
n += 1 + l + sovGenerated(uint64(l))
}
return n
@ -1870,7 +2033,6 @@ func (m *QueuingConfiguration) Size() (n int) {
}
var l int
_ = l
n += 1 + sovGenerated(uint64(m.AssuredConcurrencyShares))
n += 1 + sovGenerated(uint64(m.Queues))
n += 1 + sovGenerated(uint64(m.HandSize))
n += 1 + sovGenerated(uint64(m.QueueLengthLimit))
@ -2052,6 +2214,28 @@ func (this *GroupSubject) String() string {
}, "")
return s
}
func (this *LimitResponse) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&LimitResponse{`,
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
`Queuing:` + strings.Replace(this.Queuing.String(), "QueuingConfiguration", "QueuingConfiguration", 1) + `,`,
`}`,
}, "")
return s
}
func (this *LimitedPriorityLevelConfiguration) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&LimitedPriorityLevelConfiguration{`,
`AssuredConcurrencyShares:` + fmt.Sprintf("%v", this.AssuredConcurrencyShares) + `,`,
`LimitResponse:` + strings.Replace(strings.Replace(this.LimitResponse.String(), "LimitResponse", "LimitResponse", 1), `&`, ``, 1) + `,`,
`}`,
}, "")
return s
}
func (this *NonResourcePolicyRule) String() string {
if this == nil {
return "nil"
@ -2148,7 +2332,7 @@ func (this *PriorityLevelConfigurationSpec) String() string {
}
s := strings.Join([]string{`&PriorityLevelConfigurationSpec{`,
`Type:` + fmt.Sprintf("%v", this.Type) + `,`,
`Queuing:` + strings.Replace(this.Queuing.String(), "QueuingConfiguration", "QueuingConfiguration", 1) + `,`,
`Limited:` + strings.Replace(this.Limited.String(), "LimitedPriorityLevelConfiguration", "LimitedPriorityLevelConfiguration", 1) + `,`,
`}`,
}, "")
return s
@ -2173,7 +2357,6 @@ func (this *QueuingConfiguration) String() string {
return "nil"
}
s := strings.Join([]string{`&QueuingConfiguration{`,
`AssuredConcurrencyShares:` + fmt.Sprintf("%v", this.AssuredConcurrencyShares) + `,`,
`Queues:` + fmt.Sprintf("%v", this.Queues) + `,`,
`HandSize:` + fmt.Sprintf("%v", this.HandSize) + `,`,
`QueueLengthLimit:` + fmt.Sprintf("%v", this.QueueLengthLimit) + `,`,
@ -3153,6 +3336,232 @@ func (m *GroupSubject) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *LimitResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: LimitResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LimitResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthGenerated
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Type = LimitResponseType(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Queuing", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenerated
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Queuing == nil {
m.Queuing = &QueuingConfiguration{}
}
if err := m.Queuing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *LimitedPriorityLevelConfiguration) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: LimitedPriorityLevelConfiguration: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: LimitedPriorityLevelConfiguration: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AssuredConcurrencyShares", wireType)
}
m.AssuredConcurrencyShares = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.AssuredConcurrencyShares |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LimitResponse", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthGenerated
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthGenerated
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.LimitResponse.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipGenerated(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthGenerated
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *NonResourcePolicyRule) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -4055,11 +4464,11 @@ func (m *PriorityLevelConfigurationSpec) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Type = PriorityLevelQueueingType(dAtA[iNdEx:postIndex])
m.Type = PriorityLevelEnablement(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Queuing", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Limited", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
@ -4086,10 +4495,10 @@ func (m *PriorityLevelConfigurationSpec) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Queuing == nil {
m.Queuing = &QueuingConfiguration{}
if m.Limited == nil {
m.Limited = &LimitedPriorityLevelConfiguration{}
}
if err := m.Queuing.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
if err := m.Limited.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
@ -4234,25 +4643,6 @@ func (m *QueuingConfiguration) Unmarshal(dAtA []byte) error {
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field AssuredConcurrencyShares", wireType)
}
m.AssuredConcurrencyShares = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenerated
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.AssuredConcurrencyShares |= int32(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Queues", wireType)
}
@ -4271,7 +4661,7 @@ func (m *QueuingConfiguration) Unmarshal(dAtA []byte) error {
break
}
}
case 3:
case 2:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field HandSize", wireType)
}
@ -4290,7 +4680,7 @@ func (m *QueuingConfiguration) Unmarshal(dAtA []byte) error {
break
}
}
case 4:
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field QueueLengthLimit", wireType)
}

94
staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.proto
View File

@ -133,6 +133,52 @@ message GroupSubject {
optional string name = 1;
}
// LimitResponse defines how to handle requests that can not be executed right now.
// +union
message LimitResponse {
// `type` is "Queue" or "Reject".
// "Queue" means that requests that can not be executed upon arrival
// are held in a queue until they can be executed or a queuing limit
// is reached.
// "Reject" means that requests that can not be executed upon arrival
// are rejected.
// Required.
// +unionDiscriminator
optional string type = 1;
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
optional QueuingConfiguration queuing = 2;
}
// LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits.
// It addresses two issues:
// * How are requests for this priority level limited?
// * What should be done with requests that exceed the limit?
message LimitedPriorityLevelConfiguration {
// `assuredConcurrencyShares` (ACS) configures the execution
// limit, which is a limit on the number of requests of this
// priority level that may be exeucting at a given time. ACS must
// be a positive number. The server's concurrency limit (SCL) is
// divided among the concurrency-controlled priority levels in
// proportion to their assured concurrency shares. This produces
// the assured concurrency value (ACV) --- the number of requests
// that may be executing at a time --- for each such priority
// level:
//
// ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) )
//
// bigger numbers of ACS mean more reserved concurrent requests (at the
// expense of every other PL).
// This field has a default value of 30.
// +optional
optional int32 assuredConcurrencyShares = 1;
// `limitResponse` indicates what to do with requests that can not be executed right now
optional LimitResponse limitResponse = 2;
}
// NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the
// target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member
// of verbs matches the request and (b) at least one member of nonResourceURLs matches the request.
@ -240,23 +286,25 @@ message PriorityLevelConfigurationReference {
optional string name = 1;
}
// PriorityLevelConfigurationSpec is specification of a priority level
// PriorityLevelConfigurationSpec specifies the configuration of a priority level.
// +union
message PriorityLevelConfigurationSpec {
// `type` indicates whether this priority level does
// queuing or is exempt. Valid values are "Queuing" and "Exempt".
// "Exempt" means that requests of this priority level are not subject
// to concurrency limits (and thus are never queued) and do not detract
// from the concurrency available for non-exempt requests. The "Exempt"
// type is useful for apiserver self-requests and system administrator use.
// `type` indicates whether this priority level is subject to
// limitation on request execution. A value of `"Exempt"` means
// that requests of this priority level are not subject to a limit
// (and thus are never queued) and do not detract from the
// capacity made available to other priority levels. A value of
// `"Limited"` means that (a) requests of this priority level
// _are_ subject to limits and (b) some of the server's limited
// capacity is made available exclusively to this priority level.
// Required.
// +unionDiscriminator
optional string type = 1;
// `queuing` holds the configuration parameters that are
// only meaningful for a priority level that does queuing (i.e.,
// is not exempt). This field must be non-empty if and only if
// `queuingType` is `"Queuing"`.
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
optional QueuingConfiguration queuing = 2;
optional LimitedPriorityLevelConfiguration limited = 2;
}
// PriorityLevelConfigurationStatus represents the current state of a "request-priority".
@ -268,22 +316,8 @@ message PriorityLevelConfigurationStatus {
repeated PriorityLevelConfigurationCondition conditions = 1;
}
// QueuingConfiguration holds the configuration parameters that are specific to a priority level that is subject to concurrency controls
// QueuingConfiguration holds the configuration parameters for queuing
message QueuingConfiguration {
// `assuredConcurrencyShares` (ACS) must be a positive number. The
// server's concurrency limit (SCL) is divided among the
// concurrency-controlled priority levels in proportion to their
// assured concurrency shares. This produces the assured
// concurrency value (ACV) for each such priority level:
//
// ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) )
//
// bigger numbers of ACS mean more reserved concurrent requests (at the
// expense of every other PL).
// This field has a default value of 30.
// +optional
optional int32 assuredConcurrencyShares = 1;
// `queues` is the number of queues for this priority level. The
// queues exist independently at each apiserver. The value must be
// positive. Setting it to 1 effectively precludes
@ -291,7 +325,7 @@ message QueuingConfiguration {
// associated flow schemas irrelevant. This field has a default
// value of 64.
// +optional
optional int32 queues = 2;
optional int32 queues = 1;
// `handSize` is a small positive number that configures the
// shuffle sharding of requests into queues. When enqueuing a request
@ -305,14 +339,14 @@ message QueuingConfiguration {
// documentation for more extensive guidance on setting this
// field. This field has a default value of 8.
// +optional
optional int32 handSize = 3;
optional int32 handSize = 2;
// `queueLengthLimit` is the maximum number of requests allowed to
// be waiting in a given queue of this priority level at a time;
// excess requests are rejected. This value must be positive. If
// not specified, it will be defaulted to 50.
// +optional
optional int32 queueLengthLimit = 4;
optional int32 queueLengthLimit = 3;
}
// ResourcePolicyRule is a predicate that matches some resource requests, testing the request's verb and the target

106
staging/src/k8s.io/api/flowcontrol/v1alpha1/types.go
View File

@ -320,44 +320,53 @@ type PriorityLevelConfigurationList struct {
Items []PriorityLevelConfiguration `json:"items" protobuf:"bytes,2,rep,name=items"`
}
// PriorityLevelConfigurationSpec is specification of a priority level
// PriorityLevelConfigurationSpec specifies the configuration of a priority level.
// +union
type PriorityLevelConfigurationSpec struct {
// `type` indicates whether this priority level does
// queuing or is exempt. Valid values are "Queuing" and "Exempt".
// "Exempt" means that requests of this priority level are not subject
// to concurrency limits (and thus are never queued) and do not detract
// from the concurrency available for non-exempt requests. The "Exempt"
// type is useful for apiserver self-requests and system administrator use.
// `type` indicates whether this priority level is subject to
// limitation on request execution. A value of `"Exempt"` means
// that requests of this priority level are not subject to a limit
// (and thus are never queued) and do not detract from the
// capacity made available to other priority levels. A value of
// `"Limited"` means that (a) requests of this priority level
// _are_ subject to limits and (b) some of the server's limited
// capacity is made available exclusively to this priority level.
// Required.
Type PriorityLevelQueueingType `json:"type" protobuf:"varint,1,opt,name=type"`
// +unionDiscriminator
Type PriorityLevelEnablement `json:"type" protobuf:"bytes,1,opt,name=type"`
// `queuing` holds the configuration parameters that are
// only meaningful for a priority level that does queuing (i.e.,
// is not exempt). This field must be non-empty if and only if
// `queuingType` is `"Queuing"`.
// `limited` specifies how requests are handled for a Limited priority level.
// This field must be non-empty if and only if `type` is `"Limited"`.
// +optional
Queuing *QueuingConfiguration `json:"queuing,omitempty" protobuf:"bytes,2,opt,name=queuing"`
Limited *LimitedPriorityLevelConfiguration `json:"limited,omitempty" protobuf:"bytes,2,opt,name=limited"`
}
// PriorityLevelQueueingType identifies the queuing nature of a priority level
type PriorityLevelQueueingType string
// PriorityLevelEnablement indicates whether limits on execution are enabled for the priority level
type PriorityLevelEnablement string
// Supported queuing types.
// Supported priority level enablement values.
const (
// PriorityLevelQueuingTypeQueueing is the PriorityLevelQueueingType for priority levels that queue
PriorityLevelQueuingTypeQueueing PriorityLevelQueueingType = "Queuing"
// PriorityLevelEnablementExempt means that requests are not subject to limits
PriorityLevelEnablementExempt PriorityLevelEnablement = "Exempt"
// PriorityLevelQueuingTypeExempt is the PriorityLevelQueueingType for priority levels that are exempt from concurrency controls
PriorityLevelQueuingTypeExempt PriorityLevelQueueingType = "Exempt"
// PriorityLevelEnablementLimited means that requests are subject to limits
PriorityLevelEnablementLimited PriorityLevelEnablement = "Limited"
)
// QueuingConfiguration holds the configuration parameters that are specific to a priority level that is subject to concurrency controls
type QueuingConfiguration struct {
// `assuredConcurrencyShares` (ACS) must be a positive number. The
// server's concurrency limit (SCL) is divided among the
// concurrency-controlled priority levels in proportion to their
// assured concurrency shares. This produces the assured
// concurrency value (ACV) for each such priority level:
// LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits.
// It addresses two issues:
// * How are requests for this priority level limited?
// * What should be done with requests that exceed the limit?
type LimitedPriorityLevelConfiguration struct {
// `assuredConcurrencyShares` (ACS) configures the execution
// limit, which is a limit on the number of requests of this
// priority level that may be exeucting at a given time. ACS must
// be a positive number. The server's concurrency limit (SCL) is
// divided among the concurrency-controlled priority levels in
// proportion to their assured concurrency shares. This produces
// the assured concurrency value (ACV) --- the number of requests
// that may be executing at a time --- for each such priority
// level:
//
// ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) )
//
@ -367,6 +376,43 @@ type QueuingConfiguration struct {
// +optional
AssuredConcurrencyShares int32 `json:"assuredConcurrencyShares" protobuf:"varint,1,opt,name=assuredConcurrencyShares"`
// `limitResponse` indicates what to do with requests that can not be executed right now
LimitResponse LimitResponse `json:"limitResponse,omitempty" protobuf:"bytes,2,opt,name=limitResponse"`
}
// LimitResponse defines how to handle requests that can not be executed right now.
// +union
type LimitResponse struct {
// `type` is "Queue" or "Reject".
// "Queue" means that requests that can not be executed upon arrival
// are held in a queue until they can be executed or a queuing limit
// is reached.
// "Reject" means that requests that can not be executed upon arrival
// are rejected.
// Required.
// +unionDiscriminator
Type LimitResponseType `json:"type" protobuf:"bytes,1,opt,name=type"`
// `queuing` holds the configuration parameters for queuing.
// This field may be non-empty only if `type` is `"Queue"`.
// +optional
Queuing *QueuingConfiguration `json:"queuing,omitempty" protobuf:"bytes,2,opt,name=queuing"`
}
// LimitResponseType identifies how a Limited priority level handles a request that can not be executed right now
type LimitResponseType string
// Supported limit responses.
const (
// LimitResponseTypeQueue means that requests that can not be executed right now are queued until they can be executed or a queuing limit is hit
LimitResponseTypeQueue LimitResponseType = "Queue"
// LimitResponseTypeReject means that requests that can not be executed right now are rejected
LimitResponseTypeReject LimitResponseType = "Reject"
)
// QueuingConfiguration holds the configuration parameters for queuing
type QueuingConfiguration struct {
// `queues` is the number of queues for this priority level. The
// queues exist independently at each apiserver. The value must be
// positive. Setting it to 1 effectively precludes
@ -374,7 +420,7 @@ type QueuingConfiguration struct {
// associated flow schemas irrelevant. This field has a default
// value of 64.
// +optional
Queues int32 `json:"queues" protobuf:"varint,2,opt,name=queues"`
Queues int32 `json:"queues" protobuf:"varint,1,opt,name=queues"`
// `handSize` is a small positive number that configures the
// shuffle sharding of requests into queues. When enqueuing a request
@ -388,14 +434,14 @@ type QueuingConfiguration struct {
// documentation for more extensive guidance on setting this
// field. This field has a default value of 8.
// +optional
HandSize int32 `json:"handSize" protobuf:"varint,3,opt,name=handSize"`
HandSize int32 `json:"handSize" protobuf:"varint,2,opt,name=handSize"`
// `queueLengthLimit` is the maximum number of requests allowed to
// be waiting in a given queue of this priority level at a time;
// excess requests are rejected. This value must be positive. If
// not specified, it will be defaulted to 50.
// +optional
QueueLengthLimit int32 `json:"queueLengthLimit" protobuf:"varint,4,opt,name=queueLengthLimit"`
QueueLengthLimit int32 `json:"queueLengthLimit" protobuf:"varint,3,opt,name=queueLengthLimit"`
}
// PriorityLevelConfigurationConditionType is a valid value for PriorityLevelConfigurationStatusCondition.Type

35
staging/src/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go generated
View File

@ -100,6 +100,26 @@ func (GroupSubject) SwaggerDoc() map[string]string {
return map_GroupSubject
}
var map_LimitResponse = map[string]string{
"": "LimitResponse defines how to handle requests that can not be executed right now.",
"type": "`type` is \"Queue\" or \"Reject\". \"Queue\" means that requests that can not be executed upon arrival are held in a queue until they can be executed or a queuing limit is reached. \"Reject\" means that requests that can not be executed upon arrival are rejected. Required.",
"queuing": "`queuing` holds the configuration parameters for queuing. This field may be non-empty only if `type` is `\"Queue\"`.",
}
func (LimitResponse) SwaggerDoc() map[string]string {
return map_LimitResponse
}
var map_LimitedPriorityLevelConfiguration = map[string]string{
"": "LimitedPriorityLevelConfiguration specifies how to handle requests that are subject to limits. It addresses two issues:\n * How are requests for this priority level limited?\n * What should be done with requests that exceed the limit?",
"assuredConcurrencyShares": "`assuredConcurrencyShares` (ACS) configures the execution limit, which is a limit on the number of requests of this priority level that may be exeucting at a given time. ACS must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) ",
"limitResponse": "`limitResponse` indicates what to do with requests that can not be executed right now",
}
func (LimitedPriorityLevelConfiguration) SwaggerDoc() map[string]string {
return map_LimitedPriorityLevelConfiguration
}
var map_NonResourcePolicyRule = map[string]string{
"": "NonResourcePolicyRule is a predicate that matches non-resource requests according to their verb and the target non-resource URL. A NonResourcePolicyRule matches a request if and only if both (a) at least one member of verbs matches the request and (b) at least one member of nonResourceURLs matches the request.",
"verbs": "`verbs` is a list of matching verbs and may not be empty. \"*\" matches all verbs. If it is present, it must be the only entry. Required.",
@ -165,9 +185,9 @@ func (PriorityLevelConfigurationReference) SwaggerDoc() map[string]string {
}
var map_PriorityLevelConfigurationSpec = map[string]string{
"": "PriorityLevelConfigurationSpec is specification of a priority level",
"type": "`type` indicates whether this priority level does queuing or is exempt. Valid values are \"Queuing\" and \"Exempt\". \"Exempt\" means that requests of this priority level are not subject to concurrency limits (and thus are never queued) and do not detract from the concurrency available for non-exempt requests. The \"Exempt\" type is useful for apiserver self-requests and system administrator use. Required.",
"queuing": "`queuing` holds the configuration parameters that are only meaningful for a priority level that does queuing (i.e., is not exempt). This field must be non-empty if and only if `queuingType` is `\"Queuing\"`.",
"": "PriorityLevelConfigurationSpec specifies the configuration of a priority level.",
"type": "`type` indicates whether this priority level is subject to limitation on request execution. A value of `\"Exempt\"` means that requests of this priority level are not subject to a limit (and thus are never queued) and do not detract from the capacity made available to other priority levels. A value of `\"Limited\"` means that (a) requests of this priority level _are_ subject to limits and (b) some of the server's limited capacity is made available exclusively to this priority level. Required.",
"limited": "`limited` specifies how requests are handled for a Limited priority level. This field must be non-empty if and only if `type` is `\"Limited\"`.",
}
func (PriorityLevelConfigurationSpec) SwaggerDoc() map[string]string {
@ -184,11 +204,10 @@ func (PriorityLevelConfigurationStatus) SwaggerDoc() map[string]string {
}
var map_QueuingConfiguration = map[string]string{
"": "QueuingConfiguration holds the configuration parameters that are specific to a priority level that is subject to concurrency controls",
"assuredConcurrencyShares": "`assuredConcurrencyShares` (ACS) must be a positive number. The server's concurrency limit (SCL) is divided among the concurrency-controlled priority levels in proportion to their assured concurrency shares. This produces the assured concurrency value (ACV) for each such priority level:\n\n ACV(l) = ceil( SCL * ACS(l) / ( sum[priority levels k] ACS(k) ) )\n\nbigger numbers of ACS mean more reserved concurrent requests (at the expense of every other PL). This field has a default value of 30.",
"queues": "`queues` is the number of queues for this priority level. The queues exist independently at each apiserver. The value must be positive. Setting it to 1 effectively precludes shufflesharding and thus makes the distinguisher method of associated flow schemas irrelevant. This field has a default value of 64.",
"handSize": "`handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8.",
"queueLengthLimit": "`queueLengthLimit` is the maximum number of requests allowed to be waiting in a given queue of this priority level at a time; excess requests are rejected. This value must be positive. If not specified, it will be defaulted to 50.",
"": "QueuingConfiguration holds the configuration parameters for queuing",
"queues": "`queues` is the number of queues for this priority level. The queues exist independently at each apiserver. The value must be positive. Setting it to 1 effectively precludes shufflesharding and thus makes the distinguisher method of associated flow schemas irrelevant. This field has a default value of 64.",
"handSize": "`handSize` is a small positive number that configures the shuffle sharding of requests into queues. When enqueuing a request at this priority level the request's flow identifier (a string pair) is hashed and the hash value is used to shuffle the list of queues and deal a hand of the size specified here. The request is put into one of the shortest queues in that hand. `handSize` must be no larger than `queues`, and should be significantly smaller (so that a few heavy flows do not saturate most of the queues). See the user-facing documentation for more extensive guidance on setting this field. This field has a default value of 8.",
"queueLengthLimit": "`queueLengthLimit` is the maximum number of requests allowed to be waiting in a given queue of this priority level at a time; excess requests are rejected. This value must be positive. If not specified, it will be defaulted to 50.",
}
func (QueuingConfiguration) SwaggerDoc() map[string]string {

46
staging/src/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go generated
View File

@ -186,6 +186,44 @@ func (in *GroupSubject) DeepCopy() *GroupSubject {
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitResponse) DeepCopyInto(out *LimitResponse) {
*out = *in
if in.Queuing != nil {
in, out := &in.Queuing, &out.Queuing
*out = new(QueuingConfiguration)
**out = **in
}
return
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitResponse.
func (in *LimitResponse) DeepCopy() *LimitResponse {
if in == nil {
return nil
}
out := new(LimitResponse)
in.DeepCopyInto(out)
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *LimitedPriorityLevelConfiguration) DeepCopyInto(out *LimitedPriorityLevelConfiguration) {
*out = *in
in.LimitResponse.DeepCopyInto(&out.LimitResponse)
return
}
// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitedPriorityLevelConfiguration.
func (in *LimitedPriorityLevelConfiguration) DeepCopy() *LimitedPriorityLevelConfiguration {
if in == nil {
return nil
}
out := new(LimitedPriorityLevelConfiguration)
in.DeepCopyInto(out)
return out
}
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *NonResourcePolicyRule) DeepCopyInto(out *NonResourcePolicyRule) {
*out = *in
@ -346,10 +384,10 @@ func (in *PriorityLevelConfigurationReference) DeepCopy() *PriorityLevelConfigur
// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.
func (in *PriorityLevelConfigurationSpec) DeepCopyInto(out *PriorityLevelConfigurationSpec) {
*out = *in
if in.Queuing != nil {
in, out := &in.Queuing, &out.Queuing
*out = new(QueuingConfiguration)
**out = **in
if in.Limited != nil {
in, out := &in.Limited, &out.Limited
*out = new(LimitedPriorityLevelConfiguration)
(*in).DeepCopyInto(*out)
}
return
}