---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.10.0
  creationTimestamp: null
  name: balancers.balancer.x-k8s.io
spec:
  group: balancer.x-k8s.io
  names:
    kind: Balancer
    listKind: BalancerList
    plural: balancers
    singular: balancer
  scope: Namespaced
  versions:
  - name: v1alpha1
    schema:
      openAPIV3Schema:
        description: Balancer is an object used to automatically keep the desired
          number of replicas (pods) distributed among the specified set of targets
          (deployments or other objects that expose the Scale subresource).
        properties:
          apiVersion:
            description: 'APIVersion defines the versioned schema of this representation
              of an object. Servers should convert recognized schemas to the latest
              internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources'
            type: string
          kind:
            description: 'Kind is a string value representing the REST resource this
              object represents. Servers may infer this from the endpoint the client
              submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds'
            type: string
          metadata:
            type: object
          spec:
            description: 'Specification of the Balancer behavior. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status.'
            properties:
              policy:
                description: Policy defines how the balancer should distribute replicas
                  among targets.
                properties:
                  fallback:
                    description: Fallback contains specification of how to recognize
                      and what to do if some replicas fail to start in one or more
                      targets. No fallback happens if not-set.
                    properties:
                      startupTimeoutSeconds:
                        description: StartupTimeoutSeconds defines how long will the
                          Balancer wait before considering a pending/not-started pod
                          as blocked and starting another replica in some other target.
                          Once the replica is finally started, replicas in other targets
                          may be stopped.
                        format: int32
                        minimum: 0
                        type: integer
                    required:
                    - startupTimeoutSeconds
                    type: object
                  policyName:
                    description: PolicyName decides how to balance replicas across
                      the targets. Depending on the name one of the fields Priorities
                      or Proportions must be set.
                    type: string
                  priorities:
                    description: Priorities contains detailed specification of how
                      to balance when balancer policy name is set to Priority.
                    properties:
                      targetOrder:
                        description: TargetOrder is the priority-based list of Balancer
                          targets names. The first target on the list gets the replicas
                          until its maxReplicas is reached (or replicas fail to start).
                          Then the replicas go to the second target and so on. MinReplicas
                          is guaranteed to be fulfilled, irrespective of the order,
                          presence on the list, and/or total Balancer's replica count.
                        items:
                          type: string
                        minItems: 2
                        type: array
                    required:
                    - targetOrder
                    type: object
                  proportions:
                    description: Proportions contains detailed specification of how
                      to balance when balancer policy name is set to Proportional.
                    properties:
                      targetProportions:
                        additionalProperties:
                          format: int32
                          type: integer
                        description: TargetProportions is a map from Balancer targets
                          names to rates. Replicas are distributed so that the max
                          difference between the current replica share and the desired
                          replica share is minimized. Once a target reaches maxReplicas
                          it is removed from the calculations and replicas are distributed
                          with the updated proportions. MinReplicas is guaranteed
                          for a target, irrespective of the total Balancer's replica
                          count, proportions or the presence in the map.
                        minProperties: 2
                        type: object
                    required:
                    - targetProportions
                    type: object
                required:
                - policyName
                type: object
              replicas:
                description: Replicas is the number of pods that should be distributed
                  among the declared targets according to the specified policy.
                format: int32
                minimum: 0
                type: integer
              selector:
                description: Selector that groups the pods from all targets together
                  (and only those). Ideally it should match the selector used by the
                  Service built on top of the Balancer. All pods selectable by targets'
                  selector must match to this selector, however target's selector
                  don't have to be a superset of this one (although it is recommended).
                properties:
                  matchExpressions:
                    description: matchExpressions is a list of label selector requirements.
                      The requirements are ANDed.
                    items:
                      description: A label selector requirement is a selector that
                        contains values, a key, and an operator that relates the key
                        and values.
                      properties:
                        key:
                          description: key is the label key that the selector applies
                            to.
                          type: string
                        operator:
                          description: operator represents a key's relationship to
                            a set of values. Valid operators are In, NotIn, Exists
                            and DoesNotExist.
                          type: string
                        values:
                          description: values is an array of string values. If the
                            operator is In or NotIn, the values array must be non-empty.
                            If the operator is Exists or DoesNotExist, the values
                            array must be empty. This array is replaced during a strategic
                            merge patch.
                          items:
                            type: string
                          type: array
                      required:
                      - key
                      - operator
                      type: object
                    type: array
                  matchLabels:
                    additionalProperties:
                      type: string
                    description: matchLabels is a map of {key,value} pairs. A single
                      {key,value} in the matchLabels map is equivalent to an element
                      of matchExpressions, whose key field is "key", the operator
                      is "In", and the values array contains only "value". The requirements
                      are ANDed.
                    type: object
                type: object
                x-kubernetes-map-type: atomic
              targets:
                description: Targets is a list of targets between which Balancer tries
                  to distribute replicas.
                items:
                  description: BalancerTarget is the declaration of one of the targets
                    between which the balancer tries to distribute replicas.
                  properties:
                    maxReplicas:
                      description: MaxReplicas is the maximum number of replicas inside
                        of this target. Balancer will set at most this amount on the
                        target, even if the total desired number of replicas for the
                        Balancer is higher. There will be no limit if not provided.
                      format: int32
                      minimum: 0
                      type: integer
                    minReplicas:
                      description: MinReplicas is the minimum number of replicas inside
                        of this target. Balancer will set at least this amount on
                        the target, even if the total desired number of replicas for
                        Balancer is lower. 0 will be used (no min) if not provided.
                      format: int32
                      minimum: 0
                      type: integer
                    name:
                      description: Name of the target.
                      minLength: 1
                      type: string
                    scaleTargetRef:
                      description: ScaleTargetRef is a reference that points to a
                        target resource to balance. The target needs to expose the
                        Scale subresource.
                      properties:
                        apiVersion:
                          description: API version of the referent
                          type: string
                        kind:
                          description: 'Kind of the referent; More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds"'
                          type: string
                        name:
                          description: 'Name of the referent; More info: http://kubernetes.io/docs/user-guide/identifiers#names'
                          type: string
                      required:
                      - kind
                      - name
                      type: object
                  required:
                  - name
                  - scaleTargetRef
                  type: object
                minItems: 2
                type: array
            required:
            - policy
            - replicas
            - selector
            - targets
            type: object
          status:
            description: Current information about the Balancer.
            properties:
              conditions:
                description: Conditions is the set of conditions required for this
                  Balancer to work properly, and indicates whether or not those conditions
                  are met.
                items:
                  description: "Condition contains details for one aspect of the current
                    state of this API Resource. --- This struct is intended for direct
                    use as an array at the field path .status.conditions.  For example,
                    \n type FooStatus struct{ // Represents the observations of a
                    foo's current state. // Known .status.conditions.type are: \"Available\",
                    \"Progressing\", and \"Degraded\" // +patchMergeKey=type // +patchStrategy=merge
                    // +listType=map // +listMapKey=type Conditions []metav1.Condition
                    `json:\"conditions,omitempty\" patchStrategy:\"merge\" patchMergeKey:\"type\"
                    protobuf:\"bytes,1,rep,name=conditions\"` \n // other fields }"
                  properties:
                    lastTransitionTime:
                      description: lastTransitionTime is the last time the condition
                        transitioned from one status to another. This should be when
                        the underlying condition changed.  If that is not known, then
                        using the time when the API field changed is acceptable.
                      format: date-time
                      type: string
                    message:
                      description: message is a human readable message indicating
                        details about the transition. This may be an empty string.
                      maxLength: 32768
                      type: string
                    observedGeneration:
                      description: observedGeneration represents the .metadata.generation
                        that the condition was set based upon. For instance, if .metadata.generation
                        is currently 12, but the .status.conditions[x].observedGeneration
                        is 9, the condition is out of date with respect to the current
                        state of the instance.
                      format: int64
                      minimum: 0
                      type: integer
                    reason:
                      description: reason contains a programmatic identifier indicating
                        the reason for the condition's last transition. Producers
                        of specific condition types may define expected values and
                        meanings for this field, and whether the values are considered
                        a guaranteed API. The value should be a CamelCase string.
                        This field may not be empty.
                      maxLength: 1024
                      minLength: 1
                      pattern: ^[A-Za-z]([A-Za-z0-9_,:]*[A-Za-z0-9_])?$
                      type: string
                    status:
                      description: status of the condition, one of True, False, Unknown.
                      enum:
                      - "True"
                      - "False"
                      - Unknown
                      type: string
                    type:
                      description: type of condition in CamelCase or in foo.example.com/CamelCase.
                        --- Many .condition.type values are consistent across resources
                        like Available, but because arbitrary conditions can be useful
                        (see .node.status.conditions), the ability to deconflict is
                        important. The regex it matches is (dns1123SubdomainFmt/)?(qualifiedNameFmt)
                      maxLength: 316
                      pattern: ^([a-z0-9]([-a-z0-9]*[a-z0-9])?(\.[a-z0-9]([-a-z0-9]*[a-z0-9])?)*/)?(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])$
                      type: string
                  required:
                  - lastTransitionTime
                  - message
                  - reason
                  - status
                  - type
                  type: object
                type: array
              replicas:
                description: Replicas is an actual number of observed pods matching
                  Balancer selector.
                format: int32
                type: integer
              selector:
                description: 'Selector is a query over pods that should match the
                  replicas count. This is same as the label selector but in the string
                  format to avoid introspection by clients. The string will be in
                  the same format as the query-param syntax. More info about label
                  selectors: http://kubernetes.io/docs/user-guide/labels#label-selectors'
                type: string
            required:
            - replicas
            - selector
            type: object
        required:
        - spec
        type: object
    served: true
    storage: true
    subresources:
      scale:
        labelSelectorPath: .status.selector
        specReplicasPath: .spec.replicas
        statusReplicasPath: .status.replicas
      status: {}
