[VOL-3678] First implementation of the BBSim-sadis-server
Change-Id: I5077a8f861f4cc6af9759f31a4a415042c05eba3
diff --git a/vendor/k8s.io/api/flowcontrol/v1alpha1/types.go b/vendor/k8s.io/api/flowcontrol/v1alpha1/types.go
new file mode 100644
index 0000000..a67c6dd
--- /dev/null
+++ b/vendor/k8s.io/api/flowcontrol/v1alpha1/types.go
@@ -0,0 +1,519 @@
+/*
+Copyright 2019 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v1alpha1
+
+import (
+ metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// These are valid wildcards.
+const (
+ APIGroupAll = "*"
+ ResourceAll = "*"
+ VerbAll = "*"
+ NonResourceAll = "*"
+ NameAll = "*"
+
+ NamespaceEvery = "*" // matches every particular namespace
+)
+
+// System preset priority level names
+const (
+ PriorityLevelConfigurationNameExempt = "exempt"
+ PriorityLevelConfigurationNameCatchAll = "catch-all"
+ FlowSchemaNameExempt = "exempt"
+ FlowSchemaNameCatchAll = "catch-all"
+)
+
+// Conditions
+const (
+ FlowSchemaConditionDangling = "Dangling"
+
+ PriorityLevelConfigurationConditionConcurrencyShared = "ConcurrencyShared"
+)
+
+// Constants used by api validation.
+const (
+ FlowSchemaMaxMatchingPrecedence int32 = 10000
+)
+
+// +genclient
+// +genclient:nonNamespaced
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// FlowSchema defines the schema of a group of flows. Note that a flow is made up of a set of inbound API requests with
+// similar attributes and is identified by a pair of strings: the name of the FlowSchema and a "flow distinguisher".
+type FlowSchema struct {
+ metav1.TypeMeta `json:",inline"`
+ // `metadata` is the standard object's metadata.
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+ // +optional
+ metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+ // `spec` is the specification of the desired behavior of a FlowSchema.
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
+ // +optional
+ Spec FlowSchemaSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+ // `status` is the current status of a FlowSchema.
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
+ // +optional
+ Status FlowSchemaStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// FlowSchemaList is a list of FlowSchema objects.
+type FlowSchemaList struct {
+ metav1.TypeMeta `json:",inline"`
+ // `metadata` is the standard list metadata.
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+ // +optional
+ metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+
+ // `items` is a list of FlowSchemas.
+ Items []FlowSchema `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// FlowSchemaSpec describes how the FlowSchema's specification looks like.
+type FlowSchemaSpec struct {
+ // `priorityLevelConfiguration` should reference a PriorityLevelConfiguration in the cluster. If the reference cannot
+ // be resolved, the FlowSchema will be ignored and marked as invalid in its status.
+ // Required.
+ PriorityLevelConfiguration PriorityLevelConfigurationReference `json:"priorityLevelConfiguration" protobuf:"bytes,1,opt,name=priorityLevelConfiguration"`
+ // `matchingPrecedence` is used to choose among the FlowSchemas that match a given request. The chosen
+ // FlowSchema is among those with the numerically lowest (which we take to be logically highest)
+ // MatchingPrecedence. Each MatchingPrecedence value must be ranged in [1,10000].
+ // Note that if the precedence is not specified, it will be set to 1000 as default.
+ // +optional
+ MatchingPrecedence int32 `json:"matchingPrecedence" protobuf:"varint,2,opt,name=matchingPrecedence"`
+ // `distinguisherMethod` defines how to compute the flow distinguisher for requests that match this schema.
+ // `nil` specifies that the distinguisher is disabled and thus will always be the empty string.
+ // +optional
+ DistinguisherMethod *FlowDistinguisherMethod `json:"distinguisherMethod,omitempty" protobuf:"bytes,3,opt,name=distinguisherMethod"`
+ // `rules` describes which requests will match this flow schema. This FlowSchema matches a request if and only if
+ // at least one member of rules matches the request.
+ // if it is an empty slice, there will be no requests matching the FlowSchema.
+ // +listType=atomic
+ // +optional
+ Rules []PolicyRulesWithSubjects `json:"rules,omitempty" protobuf:"bytes,4,rep,name=rules"`
+}
+
+// FlowDistinguisherMethodType is the type of flow distinguisher method
+type FlowDistinguisherMethodType string
+
+// These are valid flow-distinguisher methods.
+const (
+ // FlowDistinguisherMethodByUserType specifies that the flow distinguisher is the username in the request.
+ // This type is used to provide some insulation between users.
+ FlowDistinguisherMethodByUserType FlowDistinguisherMethodType = "ByUser"
+
+ // FlowDistinguisherMethodByNamespaceType specifies that the flow distinguisher is the namespace of the
+ // object that the request acts upon. If the object is not namespaced, or if the request is a non-resource
+ // request, then the distinguisher will be the empty string. An example usage of this type is to provide
+ // some insulation between tenants in a situation where there are multiple tenants and each namespace
+ // is dedicated to a tenant.
+ FlowDistinguisherMethodByNamespaceType FlowDistinguisherMethodType = "ByNamespace"
+)
+
+// FlowDistinguisherMethod specifies the method of a flow distinguisher.
+type FlowDistinguisherMethod struct {
+ // `type` is the type of flow distinguisher method
+ // The supported types are "ByUser" and "ByNamespace".
+ // Required.
+ Type FlowDistinguisherMethodType `json:"type" protobuf:"bytes,1,opt,name=type"`
+}
+
+// PriorityLevelConfigurationReference contains information that points to the "request-priority" being used.
+type PriorityLevelConfigurationReference struct {
+ // `name` is the name of the priority level configuration being referenced
+ // Required.
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
+}
+
+// PolicyRulesWithSubjects prescribes a test that applies to a request to an apiserver. The test considers the subject
+// making the request, the verb being requested, and the resource to be acted upon. This PolicyRulesWithSubjects matches
+// a request if and only if both (a) at least one member of subjects matches the request and (b) at least one member
+// of resourceRules or nonResourceRules matches the request.
+type PolicyRulesWithSubjects struct {
+ // subjects is the list of normal user, serviceaccount, or group that this rule cares about.
+ // There must be at least one member in this slice.
+ // A slice that includes both the system:authenticated and system:unauthenticated user groups matches every request.
+ // +listType=atomic
+ // Required.
+ Subjects []Subject `json:"subjects" protobuf:"bytes,1,rep,name=subjects"`
+ // `resourceRules` is a slice of ResourcePolicyRules that identify matching requests according to their verb and the
+ // target resource.
+ // At least one of `resourceRules` and `nonResourceRules` has to be non-empty.
+ // +listType=atomic
+ // +optional
+ ResourceRules []ResourcePolicyRule `json:"resourceRules,omitempty" protobuf:"bytes,2,opt,name=resourceRules"`
+ // `nonResourceRules` is a list of NonResourcePolicyRules that identify matching requests according to their verb
+ // and the target non-resource URL.
+ // +listType=atomic
+ // +optional
+ NonResourceRules []NonResourcePolicyRule `json:"nonResourceRules,omitempty" protobuf:"bytes,3,opt,name=nonResourceRules"`
+}
+
+// Subject matches the originator of a request, as identified by the request authentication system. There are three
+// ways of matching an originator; by user, group, or service account.
+// +union
+type Subject struct {
+ // Required
+ // +unionDiscriminator
+ Kind SubjectKind `json:"kind" protobuf:"bytes,1,opt,name=kind"`
+ // +optional
+ User *UserSubject `json:"user,omitempty" protobuf:"bytes,2,opt,name=user"`
+ // +optional
+ Group *GroupSubject `json:"group,omitempty" protobuf:"bytes,3,opt,name=group"`
+ // +optional
+ ServiceAccount *ServiceAccountSubject `json:"serviceAccount,omitempty" protobuf:"bytes,4,opt,name=serviceAccount"`
+}
+
+// SubjectKind is the kind of subject.
+type SubjectKind string
+
+// Supported subject's kinds.
+const (
+ SubjectKindUser SubjectKind = "User"
+ SubjectKindGroup SubjectKind = "Group"
+ SubjectKindServiceAccount SubjectKind = "ServiceAccount"
+)
+
+// UserSubject holds detailed information for user-kind subject.
+type UserSubject struct {
+ // `name` is the username that matches, or "*" to match all usernames.
+ // Required.
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
+}
+
+// GroupSubject holds detailed information for group-kind subject.
+type GroupSubject struct {
+ // name is the user group that matches, or "*" to match all user groups.
+ // See https://github.com/kubernetes/apiserver/blob/master/pkg/authentication/user/user.go for some
+ // well-known group names.
+ // Required.
+ Name string `json:"name" protobuf:"bytes,1,opt,name=name"`
+}
+
+// ServiceAccountSubject holds detailed information for service-account-kind subject.
+type ServiceAccountSubject struct {
+ // `namespace` is the namespace of matching ServiceAccount objects.
+ // Required.
+ Namespace string `json:"namespace" protobuf:"bytes,1,opt,name=namespace"`
+ // `name` is the name of matching ServiceAccount objects, or "*" to match regardless of name.
+ // Required.
+ Name string `json:"name" protobuf:"bytes,2,opt,name=name"`
+}
+
+// ResourcePolicyRule is a predicate that matches some resource
+// requests, testing the request's verb and the target resource. A
+// ResourcePolicyRule matches a resource request if and only if: (a)
+// at least one member of verbs matches the request, (b) at least one
+// member of apiGroups matches the request, (c) at least one member of
+// resources matches the request, and (d) least one member of
+// namespaces matches the request.
+type ResourcePolicyRule struct {
+ // `verbs` is a list of matching verbs and may not be empty.
+ // "*" matches all verbs and, if present, must be the only entry.
+ // +listType=set
+ // Required.
+ Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"`
+
+ // `apiGroups` is a list of matching API groups and may not be empty.
+ // "*" matches all API groups and, if present, must be the only entry.
+ // +listType=set
+ // Required.
+ APIGroups []string `json:"apiGroups" protobuf:"bytes,2,rep,name=apiGroups"`
+
+ // `resources` is a list of matching resources (i.e., lowercase
+ // and plural) with, if desired, subresource. For example, [
+ // "services", "nodes/status" ]. This list may not be empty.
+ // "*" matches all resources and, if present, must be the only entry.
+ // Required.
+ // +listType=set
+ Resources []string `json:"resources" protobuf:"bytes,3,rep,name=resources"`
+
+ // `clusterScope` indicates whether to match requests that do not
+ // specify a namespace (which happens either because the resource
+ // is not namespaced or the request targets all namespaces).
+ // If this field is omitted or false then the `namespaces` field
+ // must contain a non-empty list.
+ // +optional
+ ClusterScope bool `json:"clusterScope,omitempty" protobuf:"varint,4,opt,name=clusterScope"`
+
+ // `namespaces` is a list of target namespaces that restricts
+ // matches. A request that specifies a target namespace matches
+ // only if either (a) this list contains that target namespace or
+ // (b) this list contains "*". Note that "*" matches any
+ // specified namespace but does not match a request that _does
+ // not specify_ a namespace (see the `clusterScope` field for
+ // that).
+ // This list may be empty, but only if `clusterScope` is true.
+ // +optional
+ // +listType=set
+ Namespaces []string `json:"namespaces" protobuf:"bytes,5,rep,name=namespaces"`
+}
+
+// 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.
+type NonResourcePolicyRule struct {
+ // `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.
+ // +listType=set
+ // Required.
+ Verbs []string `json:"verbs" protobuf:"bytes,1,rep,name=verbs"`
+ // `nonResourceURLs` is a set of url prefixes that a user should have access to and may not be empty.
+ // For example:
+ // - "/healthz" is legal
+ // - "/hea*" is illegal
+ // - "/hea" is legal but matches nothing
+ // - "/hea/*" also matches nothing
+ // - "/healthz/*" matches all per-component health checks.
+ // "*" matches all non-resource urls. if it is present, it must be the only entry.
+ // +listType=set
+ // Required.
+ NonResourceURLs []string `json:"nonResourceURLs" protobuf:"bytes,6,rep,name=nonResourceURLs"`
+}
+
+// FlowSchemaStatus represents the current state of a FlowSchema.
+type FlowSchemaStatus struct {
+ // `conditions` is a list of the current states of FlowSchema.
+ // +listType=map
+ // +listMapKey=type
+ // +optional
+ Conditions []FlowSchemaCondition `json:"conditions,omitempty" protobuf:"bytes,1,rep,name=conditions"`
+}
+
+// FlowSchemaCondition describes conditions for a FlowSchema.
+type FlowSchemaCondition struct {
+ // `type` is the type of the condition.
+ // Required.
+ Type FlowSchemaConditionType `json:"type,omitempty" protobuf:"bytes,1,opt,name=type"`
+ // `status` is the status of the condition.
+ // Can be True, False, Unknown.
+ // Required.
+ Status ConditionStatus `json:"status,omitempty" protobuf:"bytes,2,opt,name=status"`
+ // `lastTransitionTime` is the last time the condition transitioned from one status to another.
+ LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,3,opt,name=lastTransitionTime"`
+ // `reason` is a unique, one-word, CamelCase reason for the condition's last transition.
+ Reason string `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason"`
+ // `message` is a human-readable message indicating details about last transition.
+ Message string `json:"message,omitempty" protobuf:"bytes,5,opt,name=message"`
+}
+
+// FlowSchemaConditionType is a valid value for FlowSchemaStatusCondition.Type
+type FlowSchemaConditionType string
+
+// +genclient
+// +genclient:nonNamespaced
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// PriorityLevelConfiguration represents the configuration of a priority level.
+type PriorityLevelConfiguration struct {
+ metav1.TypeMeta `json:",inline"`
+ // `metadata` is the standard object's metadata.
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+ // +optional
+ metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+ // `spec` is the specification of the desired behavior of a "request-priority".
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
+ // +optional
+ Spec PriorityLevelConfigurationSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
+ // `status` is the current status of a "request-priority".
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
+ // +optional
+ Status PriorityLevelConfigurationStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
+}
+
+// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
+
+// PriorityLevelConfigurationList is a list of PriorityLevelConfiguration objects.
+type PriorityLevelConfigurationList struct {
+ metav1.TypeMeta `json:",inline"`
+ // `metadata` is the standard object's metadata.
+ // More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
+ // +optional
+ metav1.ListMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
+ // `items` is a list of request-priorities.
+ Items []PriorityLevelConfiguration `json:"items" protobuf:"bytes,2,rep,name=items"`
+}
+
+// PriorityLevelConfigurationSpec specifies the configuration of a priority level.
+// +union
+type PriorityLevelConfigurationSpec struct {
+ // `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
+ Type PriorityLevelEnablement `json:"type" protobuf:"bytes,1,opt,name=type"`
+
+ // `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
+ Limited *LimitedPriorityLevelConfiguration `json:"limited,omitempty" protobuf:"bytes,2,opt,name=limited"`
+}
+
+// PriorityLevelEnablement indicates whether limits on execution are enabled for the priority level
+type PriorityLevelEnablement string
+
+// Supported priority level enablement values.
+const (
+ // PriorityLevelEnablementExempt means that requests are not subject to limits
+ PriorityLevelEnablementExempt PriorityLevelEnablement = "Exempt"
+
+ // PriorityLevelEnablementLimited means that requests are subject to limits
+ PriorityLevelEnablementLimited PriorityLevelEnablement = "Limited"
+)
+
+// 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) ) )
+ //
+ // 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
+ 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
+ // shufflesharding and thus makes the distinguisher method of
+ // associated flow schemas irrelevant. This field has a default
+ // value of 64.
+ // +optional
+ 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
+ // 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.
+ // +optional
+ 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,3,opt,name=queueLengthLimit"`
+}
+
+// PriorityLevelConfigurationConditionType is a valid value for PriorityLevelConfigurationStatusCondition.Type
+type PriorityLevelConfigurationConditionType string
+
+// PriorityLevelConfigurationStatus represents the current state of a "request-priority".
+type PriorityLevelConfigurationStatus struct {
+ // `conditions` is the current state of "request-priority".
+ // +listType=map
+ // +listMapKey=type
+ // +optional
+ Conditions []PriorityLevelConfigurationCondition `json:"conditions,omitempty" protobuf:"bytes,1,rep,name=conditions"`
+}
+
+// PriorityLevelConfigurationCondition defines the condition of priority level.
+type PriorityLevelConfigurationCondition struct {
+ // `type` is the type of the condition.
+ // Required.
+ Type PriorityLevelConfigurationConditionType `json:"type,omitempty" protobuf:"bytes,1,opt,name=type"`
+ // `status` is the status of the condition.
+ // Can be True, False, Unknown.
+ // Required.
+ Status ConditionStatus `json:"status,omitempty" protobuf:"bytes,2,opt,name=status"`
+ // `lastTransitionTime` is the last time the condition transitioned from one status to another.
+ LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty" protobuf:"bytes,3,opt,name=lastTransitionTime"`
+ // `reason` is a unique, one-word, CamelCase reason for the condition's last transition.
+ Reason string `json:"reason,omitempty" protobuf:"bytes,4,opt,name=reason"`
+ // `message` is a human-readable message indicating details about last transition.
+ Message string `json:"message,omitempty" protobuf:"bytes,5,opt,name=message"`
+}
+
+// ConditionStatus is the status of the condition.
+type ConditionStatus string
+
+// These are valid condition statuses. "ConditionTrue" means a resource is in the condition.
+// "ConditionFalse" means a resource is not in the condition. "ConditionUnknown" means kubernetes
+// can't decide if a resource is in the condition or not. In the future, we could add other
+// intermediate conditions, e.g. ConditionDegraded.
+const (
+ ConditionTrue ConditionStatus = "True"
+ ConditionFalse ConditionStatus = "False"
+ ConditionUnknown ConditionStatus = "Unknown"
+)