diff --git a/api/openapi-spec/swagger.json b/api/openapi-spec/swagger.json index 57a4ed4c7f16..064762c35a8b 100644 --- a/api/openapi-spec/swagger.json +++ b/api/openapi-spec/swagger.json @@ -13992,6 +13992,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": { @@ -14160,21 +14200,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\".", @@ -14194,13 +14242,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", diff --git a/pkg/apis/flowcontrol/types.go b/pkg/apis/flowcontrol/types.go index 9002a4b58b94..8dbc0335d2ec 100644 --- a/pkg/apis/flowcontrol/types.go +++ b/pkg/apis/flowcontrol/types.go @@ -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 diff --git a/pkg/apis/flowcontrol/v1alpha1/defaults.go b/pkg/apis/flowcontrol/v1alpha1/defaults.go index a86695929c21..c3bfdb208eed 100644 --- a/pkg/apis/flowcontrol/v1alpha1/defaults.go +++ b/pkg/apis/flowcontrol/v1alpha1/defaults.go @@ -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 - } - } diff --git a/pkg/apis/flowcontrol/v1alpha1/zz_generated.conversion.go b/pkg/apis/flowcontrol/v1alpha1/zz_generated.conversion.go index 4b462d24832b..1a93d8fe49e6 100644 --- a/pkg/apis/flowcontrol/v1alpha1/zz_generated.conversion.go +++ b/pkg/apis/flowcontrol/v1alpha1/zz_generated.conversion.go @@ -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 diff --git a/pkg/apis/flowcontrol/v1alpha1/zz_generated.defaults.go b/pkg/apis/flowcontrol/v1alpha1/zz_generated.defaults.go index 5645d517d331..d506ba8d6aa2 100644 --- a/pkg/apis/flowcontrol/v1alpha1/zz_generated.defaults.go +++ b/pkg/apis/flowcontrol/v1alpha1/zz_generated.defaults.go @@ -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) + } } } diff --git a/pkg/apis/flowcontrol/validation/validation.go b/pkg/apis/flowcontrol/validation/validation.go index 5fd3a93488cb..fee09ff26215 100644 --- a/pkg/apis/flowcontrol/validation/validation.go +++ b/pkg/apis/flowcontrol/validation/validation.go @@ -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 { + case flowcontrol.PriorityLevelEnablementLimited: + if spec.Limited == nil { + allErrs = append(allErrs, field.Required(fldPath.Child("limited"), "must not be empty")) + } else { + allErrs = append(allErrs, ValidateLimitedPriorityLevelConfiguration(spec.Limited, fldPath.Child("limited"))...) + } + default: + 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(spec.Queuing, fldPath.Child("queuing"))...) + allErrs = append(allErrs, ValidatePriorityLevelQueuingConfiguration(lr.Queuing, fldPath.Child("queuing"))...) } default: - allErrs = append(allErrs, field.NotSupported(fldPath.Child("type"), spec.Type, supportedQueuingType.List())) + 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")) } diff --git a/pkg/apis/flowcontrol/validation/validation_test.go b/pkg/apis/flowcontrol/validation/validation_test.go index 78e00acf7b1d..a02e3cf0ab9d 100644 --- a/pkg/apis/flowcontrol/validation/validation_test.go +++ b/pkg/apis/flowcontrol/validation/validation_test.go @@ -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)"), }, }, } diff --git a/pkg/apis/flowcontrol/zz_generated.deepcopy.go b/pkg/apis/flowcontrol/zz_generated.deepcopy.go index bb1b90fe75dd..85b6453d0858 100644 --- a/pkg/apis/flowcontrol/zz_generated.deepcopy.go +++ b/pkg/apis/flowcontrol/zz_generated.deepcopy.go @@ -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 } diff --git a/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.pb.go b/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.pb.go index db764c9c44a3..ef6b8fe648f4 100644 --- a/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.pb.go +++ b/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.pb.go @@ -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 - i = encodeVarintGenerated(dAtA, i, uint64(m.HandSize)) - i-- dAtA[i] = 0x18 - i = encodeVarintGenerated(dAtA, i, uint64(m.Queues)) + i = encodeVarintGenerated(dAtA, i, uint64(m.HandSize)) 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) } diff --git a/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.proto b/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.proto index 97fdcf65b8a1..9479a39bd4b9 100644 --- a/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.proto +++ b/staging/src/k8s.io/api/flowcontrol/v1alpha1/generated.proto @@ -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 diff --git a/staging/src/k8s.io/api/flowcontrol/v1alpha1/types.go b/staging/src/k8s.io/api/flowcontrol/v1alpha1/types.go index 50b49fd7d643..0eb9359fe58c 100644 --- a/staging/src/k8s.io/api/flowcontrol/v1alpha1/types.go +++ b/staging/src/k8s.io/api/flowcontrol/v1alpha1/types.go @@ -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 diff --git a/staging/src/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go b/staging/src/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go index 356ce68de0c0..d010989e960d 100644 --- a/staging/src/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go +++ b/staging/src/k8s.io/api/flowcontrol/v1alpha1/types_swagger_doc_generated.go @@ -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 { diff --git a/staging/src/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go b/staging/src/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go index c62e9bc3aa81..8fac95b97740 100644 --- a/staging/src/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go +++ b/staging/src/k8s.io/api/flowcontrol/v1alpha1/zz_generated.deepcopy.go @@ -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 }