apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.11.1
  creationTimestamp: null
  name: dragonflies.dragonflydb.io
spec:
  group: dragonflydb.io
  names:
    kind: Dragonfly
    listKind: DragonflyList
    plural: dragonflies
    singular: dragonfly
  scope: Namespaced
  versions:
    - name: v1alpha1
      schema:
        openAPIV3Schema:
          description: Dragonfly is the Schema for the dragonflies API
          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: DragonflySpec defines the desired state of Dragonfly
              properties:
                aclFromSecret:
                  description: (Optional) Acl file Secret to pass to the container
                  properties:
                    key:
                      description:
                        The key of the secret to select from.  Must be a
                        valid secret key.
                      type: string
                    name:
                      description:
                        "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                        TODO: Add other useful fields. apiVersion, kind, uid?"
                      type: string
                    optional:
                      description: Specify whether the Secret or its key must be defined
                      type: boolean
                  required:
                    - key
                  type: object
                  x-kubernetes-map-type: atomic
                affinity:
                  description: (Optional) Dragonfly pod affinity
                  properties:
                    nodeAffinity:
                      description:
                        Describes node affinity scheduling rules for the
                        pod.
                      properties:
                        preferredDuringSchedulingIgnoredDuringExecution:
                          description:
                            The scheduler will prefer to schedule pods to
                            nodes that satisfy the affinity expressions specified by
                            this field, but it may choose a node that violates one or
                            more of the expressions. The node that is most preferred
                            is the one with the greatest sum of weights, i.e. for each
                            node that meets all of the scheduling requirements (resource
                            request, requiredDuringScheduling affinity expressions,
                            etc.), compute a sum by iterating through the elements of
                            this field and adding "weight" to the sum if the node matches
                            the corresponding matchExpressions; the node(s) with the
                            highest sum are the most preferred.
                          items:
                            description:
                              An empty preferred scheduling term matches
                              all objects with implicit weight 0 (i.e. it's a no-op).
                              A null preferred scheduling term matches no objects (i.e.
                              is also a no-op).
                            properties:
                              preference:
                                description:
                                  A node selector term, associated with the
                                  corresponding weight.
                                properties:
                                  matchExpressions:
                                    description:
                                      A list of node selector requirements
                                      by node's labels.
                                    items:
                                      description:
                                        A node selector requirement is a
                                        selector that contains values, a key, and an
                                        operator that relates the key and values.
                                      properties:
                                        key:
                                          description:
                                            The label key that the selector
                                            applies to.
                                          type: string
                                        operator:
                                          description:
                                            Represents a key's relationship
                                            to a set of values. Valid operators are
                                            In, NotIn, Exists, DoesNotExist. Gt, and
                                            Lt.
                                          type: string
                                        values:
                                          description:
                                            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. If the operator is Gt or
                                            Lt, the values array must have a single
                                            element, which will be interpreted as an
                                            integer. This array is replaced during a
                                            strategic merge patch.
                                          items:
                                            type: string
                                          type: array
                                      required:
                                        - key
                                        - operator
                                      type: object
                                    type: array
                                  matchFields:
                                    description:
                                      A list of node selector requirements
                                      by node's fields.
                                    items:
                                      description:
                                        A node selector requirement is a
                                        selector that contains values, a key, and an
                                        operator that relates the key and values.
                                      properties:
                                        key:
                                          description:
                                            The label key that the selector
                                            applies to.
                                          type: string
                                        operator:
                                          description:
                                            Represents a key's relationship
                                            to a set of values. Valid operators are
                                            In, NotIn, Exists, DoesNotExist. Gt, and
                                            Lt.
                                          type: string
                                        values:
                                          description:
                                            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. If the operator is Gt or
                                            Lt, the values array must have a single
                                            element, which will be interpreted as an
                                            integer. This array is replaced during a
                                            strategic merge patch.
                                          items:
                                            type: string
                                          type: array
                                      required:
                                        - key
                                        - operator
                                      type: object
                                    type: array
                                type: object
                                x-kubernetes-map-type: atomic
                              weight:
                                description:
                                  Weight associated with matching the corresponding
                                  nodeSelectorTerm, in the range 1-100.
                                format: int32
                                type: integer
                            required:
                              - preference
                              - weight
                            type: object
                          type: array
                        requiredDuringSchedulingIgnoredDuringExecution:
                          description:
                            If the affinity requirements specified by this
                            field are not met at scheduling time, the pod will not be
                            scheduled onto the node. If the affinity requirements specified
                            by this field cease to be met at some point during pod execution
                            (e.g. due to an update), the system may or may not try to
                            eventually evict the pod from its node.
                          properties:
                            nodeSelectorTerms:
                              description:
                                Required. A list of node selector terms.
                                The terms are ORed.
                              items:
                                description:
                                  A null or empty node selector term matches
                                  no objects. The requirements of them are ANDed. The
                                  TopologySelectorTerm type implements a subset of the
                                  NodeSelectorTerm.
                                properties:
                                  matchExpressions:
                                    description:
                                      A list of node selector requirements
                                      by node's labels.
                                    items:
                                      description:
                                        A node selector requirement is a
                                        selector that contains values, a key, and an
                                        operator that relates the key and values.
                                      properties:
                                        key:
                                          description:
                                            The label key that the selector
                                            applies to.
                                          type: string
                                        operator:
                                          description:
                                            Represents a key's relationship
                                            to a set of values. Valid operators are
                                            In, NotIn, Exists, DoesNotExist. Gt, and
                                            Lt.
                                          type: string
                                        values:
                                          description:
                                            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. If the operator is Gt or
                                            Lt, the values array must have a single
                                            element, which will be interpreted as an
                                            integer. This array is replaced during a
                                            strategic merge patch.
                                          items:
                                            type: string
                                          type: array
                                      required:
                                        - key
                                        - operator
                                      type: object
                                    type: array
                                  matchFields:
                                    description:
                                      A list of node selector requirements
                                      by node's fields.
                                    items:
                                      description:
                                        A node selector requirement is a
                                        selector that contains values, a key, and an
                                        operator that relates the key and values.
                                      properties:
                                        key:
                                          description:
                                            The label key that the selector
                                            applies to.
                                          type: string
                                        operator:
                                          description:
                                            Represents a key's relationship
                                            to a set of values. Valid operators are
                                            In, NotIn, Exists, DoesNotExist. Gt, and
                                            Lt.
                                          type: string
                                        values:
                                          description:
                                            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. If the operator is Gt or
                                            Lt, the values array must have a single
                                            element, which will be interpreted as an
                                            integer. This array is replaced during a
                                            strategic merge patch.
                                          items:
                                            type: string
                                          type: array
                                      required:
                                        - key
                                        - operator
                                      type: object
                                    type: array
                                type: object
                                x-kubernetes-map-type: atomic
                              type: array
                          required:
                            - nodeSelectorTerms
                          type: object
                          x-kubernetes-map-type: atomic
                      type: object
                    podAffinity:
                      description:
                        Describes pod affinity scheduling rules (e.g. co-locate
                        this pod in the same node, zone, etc. as some other pod(s)).
                      properties:
                        preferredDuringSchedulingIgnoredDuringExecution:
                          description:
                            The scheduler will prefer to schedule pods to
                            nodes that satisfy the affinity expressions specified by
                            this field, but it may choose a node that violates one or
                            more of the expressions. The node that is most preferred
                            is the one with the greatest sum of weights, i.e. for each
                            node that meets all of the scheduling requirements (resource
                            request, requiredDuringScheduling affinity expressions,
                            etc.), compute a sum by iterating through the elements of
                            this field and adding "weight" to the sum if the node has
                            pods which matches the corresponding podAffinityTerm; the
                            node(s) with the highest sum are the most preferred.
                          items:
                            description:
                              The weights of all of the matched WeightedPodAffinityTerm
                              fields are added per-node to find the most preferred node(s)
                            properties:
                              podAffinityTerm:
                                description:
                                  Required. A pod affinity term, associated
                                  with the corresponding weight.
                                properties:
                                  labelSelector:
                                    description:
                                      A label query over a set of resources,
                                      in this case pods.
                                    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
                                  namespaceSelector:
                                    description:
                                      A label query over the set of namespaces
                                      that the term applies to. The term is applied
                                      to the union of the namespaces selected by this
                                      field and the ones listed in the namespaces field.
                                      null selector and null or empty namespaces list
                                      means "this pod's namespace". An empty selector
                                      ({}) matches all namespaces.
                                    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
                                  namespaces:
                                    description:
                                      namespaces specifies a static list
                                      of namespace names that the term applies to. The
                                      term is applied to the union of the namespaces
                                      listed in this field and the ones selected by
                                      namespaceSelector. null or empty namespaces list
                                      and null namespaceSelector means "this pod's namespace".
                                    items:
                                      type: string
                                    type: array
                                  topologyKey:
                                    description:
                                      This pod should be co-located (affinity)
                                      or not co-located (anti-affinity) with the pods
                                      matching the labelSelector in the specified namespaces,
                                      where co-located is defined as running on a node
                                      whose value of the label with key topologyKey
                                      matches that of any node on which any of the selected
                                      pods is running. Empty topologyKey is not allowed.
                                    type: string
                                required:
                                  - topologyKey
                                type: object
                              weight:
                                description:
                                  weight associated with matching the corresponding
                                  podAffinityTerm, in the range 1-100.
                                format: int32
                                type: integer
                            required:
                              - podAffinityTerm
                              - weight
                            type: object
                          type: array
                        requiredDuringSchedulingIgnoredDuringExecution:
                          description:
                            If the affinity requirements specified by this
                            field are not met at scheduling time, the pod will not be
                            scheduled onto the node. If the affinity requirements specified
                            by this field cease to be met at some point during pod execution
                            (e.g. due to a pod label update), the system may or may
                            not try to eventually evict the pod from its node. When
                            there are multiple elements, the lists of nodes corresponding
                            to each podAffinityTerm are intersected, i.e. all terms
                            must be satisfied.
                          items:
                            description:
                              Defines a set of pods (namely those matching
                              the labelSelector relative to the given namespace(s))
                              that this pod should be co-located (affinity) or not co-located
                              (anti-affinity) with, where co-located is defined as running
                              on a node whose value of the label with key <topologyKey>
                              matches that of any node on which a pod of the set of
                              pods is running
                            properties:
                              labelSelector:
                                description:
                                  A label query over a set of resources,
                                  in this case pods.
                                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
                              namespaceSelector:
                                description:
                                  A label query over the set of namespaces
                                  that the term applies to. The term is applied to the
                                  union of the namespaces selected by this field and
                                  the ones listed in the namespaces field. null selector
                                  and null or empty namespaces list means "this pod's
                                  namespace". An empty selector ({}) matches all namespaces.
                                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
                              namespaces:
                                description:
                                  namespaces specifies a static list of namespace
                                  names that the term applies to. The term is applied
                                  to the union of the namespaces listed in this field
                                  and the ones selected by namespaceSelector. null or
                                  empty namespaces list and null namespaceSelector means
                                  "this pod's namespace".
                                items:
                                  type: string
                                type: array
                              topologyKey:
                                description:
                                  This pod should be co-located (affinity)
                                  or not co-located (anti-affinity) with the pods matching
                                  the labelSelector in the specified namespaces, where
                                  co-located is defined as running on a node whose value
                                  of the label with key topologyKey matches that of
                                  any node on which any of the selected pods is running.
                                  Empty topologyKey is not allowed.
                                type: string
                            required:
                              - topologyKey
                            type: object
                          type: array
                      type: object
                    podAntiAffinity:
                      description:
                        Describes pod anti-affinity scheduling rules (e.g.
                        avoid putting this pod in the same node, zone, etc. as some
                        other pod(s)).
                      properties:
                        preferredDuringSchedulingIgnoredDuringExecution:
                          description:
                            The scheduler will prefer to schedule pods to
                            nodes that satisfy the anti-affinity expressions specified
                            by this field, but it may choose a node that violates one
                            or more of the expressions. The node that is most preferred
                            is the one with the greatest sum of weights, i.e. for each
                            node that meets all of the scheduling requirements (resource
                            request, requiredDuringScheduling anti-affinity expressions,
                            etc.), compute a sum by iterating through the elements of
                            this field and adding "weight" to the sum if the node has
                            pods which matches the corresponding podAffinityTerm; the
                            node(s) with the highest sum are the most preferred.
                          items:
                            description:
                              The weights of all of the matched WeightedPodAffinityTerm
                              fields are added per-node to find the most preferred node(s)
                            properties:
                              podAffinityTerm:
                                description:
                                  Required. A pod affinity term, associated
                                  with the corresponding weight.
                                properties:
                                  labelSelector:
                                    description:
                                      A label query over a set of resources,
                                      in this case pods.
                                    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
                                  namespaceSelector:
                                    description:
                                      A label query over the set of namespaces
                                      that the term applies to. The term is applied
                                      to the union of the namespaces selected by this
                                      field and the ones listed in the namespaces field.
                                      null selector and null or empty namespaces list
                                      means "this pod's namespace". An empty selector
                                      ({}) matches all namespaces.
                                    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
                                  namespaces:
                                    description:
                                      namespaces specifies a static list
                                      of namespace names that the term applies to. The
                                      term is applied to the union of the namespaces
                                      listed in this field and the ones selected by
                                      namespaceSelector. null or empty namespaces list
                                      and null namespaceSelector means "this pod's namespace".
                                    items:
                                      type: string
                                    type: array
                                  topologyKey:
                                    description:
                                      This pod should be co-located (affinity)
                                      or not co-located (anti-affinity) with the pods
                                      matching the labelSelector in the specified namespaces,
                                      where co-located is defined as running on a node
                                      whose value of the label with key topologyKey
                                      matches that of any node on which any of the selected
                                      pods is running. Empty topologyKey is not allowed.
                                    type: string
                                required:
                                  - topologyKey
                                type: object
                              weight:
                                description:
                                  weight associated with matching the corresponding
                                  podAffinityTerm, in the range 1-100.
                                format: int32
                                type: integer
                            required:
                              - podAffinityTerm
                              - weight
                            type: object
                          type: array
                        requiredDuringSchedulingIgnoredDuringExecution:
                          description:
                            If the anti-affinity requirements specified by
                            this field are not met at scheduling time, the pod will
                            not be scheduled onto the node. If the anti-affinity requirements
                            specified by this field cease to be met at some point during
                            pod execution (e.g. due to a pod label update), the system
                            may or may not try to eventually evict the pod from its
                            node. When there are multiple elements, the lists of nodes
                            corresponding to each podAffinityTerm are intersected, i.e.
                            all terms must be satisfied.
                          items:
                            description:
                              Defines a set of pods (namely those matching
                              the labelSelector relative to the given namespace(s))
                              that this pod should be co-located (affinity) or not co-located
                              (anti-affinity) with, where co-located is defined as running
                              on a node whose value of the label with key <topologyKey>
                              matches that of any node on which a pod of the set of
                              pods is running
                            properties:
                              labelSelector:
                                description:
                                  A label query over a set of resources,
                                  in this case pods.
                                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
                              namespaceSelector:
                                description:
                                  A label query over the set of namespaces
                                  that the term applies to. The term is applied to the
                                  union of the namespaces selected by this field and
                                  the ones listed in the namespaces field. null selector
                                  and null or empty namespaces list means "this pod's
                                  namespace". An empty selector ({}) matches all namespaces.
                                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
                              namespaces:
                                description:
                                  namespaces specifies a static list of namespace
                                  names that the term applies to. The term is applied
                                  to the union of the namespaces listed in this field
                                  and the ones selected by namespaceSelector. null or
                                  empty namespaces list and null namespaceSelector means
                                  "this pod's namespace".
                                items:
                                  type: string
                                type: array
                              topologyKey:
                                description:
                                  This pod should be co-located (affinity)
                                  or not co-located (anti-affinity) with the pods matching
                                  the labelSelector in the specified namespaces, where
                                  co-located is defined as running on a node whose value
                                  of the label with key topologyKey matches that of
                                  any node on which any of the selected pods is running.
                                  Empty topologyKey is not allowed.
                                type: string
                            required:
                              - topologyKey
                            type: object
                          type: array
                      type: object
                  type: object
                annotations:
                  additionalProperties:
                    type: string
                  description: (Optional) Annotations to add to the Dragonfly pods.
                  type: object
                args:
                  description:
                    (Optional) Dragonfly container args to pass to the container
                    Refer to the Dragonfly documentation for the list of supported args
                  items:
                    type: string
                  type: array
                authentication:
                  description: (Optional) Dragonfly Authentication mechanism
                  properties:
                    clientCaCertSecret:
                      description:
                        (Optional) If specified, the Dragonfly instance will
                        check if the client certificate is signed by this CA. Server
                        TLS must be enabled for this.
                      properties:
                        key:
                          description:
                            The key of the secret to select from.  Must be
                            a valid secret key.
                          type: string
                        name:
                          description:
                            "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                            TODO: Add other useful fields. apiVersion, kind, uid?"
                          type: string
                        optional:
                          description:
                            Specify whether the Secret or its key must be
                            defined
                          type: boolean
                      required:
                        - key
                      type: object
                      x-kubernetes-map-type: atomic
                    passwordFromSecret:
                      description:
                        (Optional) Dragonfly Password from Secret as a reference
                        to a specific key
                      properties:
                        key:
                          description:
                            The key of the secret to select from.  Must be
                            a valid secret key.
                          type: string
                        name:
                          description:
                            "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                            TODO: Add other useful fields. apiVersion, kind, uid?"
                          type: string
                        optional:
                          description:
                            Specify whether the Secret or its key must be
                            defined
                          type: boolean
                      required:
                        - key
                      type: object
                      x-kubernetes-map-type: atomic
                  type: object
                env:
                  description: (Optional) Env variables to add to the Dragonfly pods.
                  items:
                    description:
                      EnvVar represents an environment variable present in
                      a Container.
                    properties:
                      name:
                        description: Name of the environment variable. Must be a C_IDENTIFIER.
                        type: string
                      value:
                        description:
                          'Variable references $(VAR_NAME) are expanded using
                          the previously defined environment variables in the container
                          and any service environment variables. If a variable cannot
                          be resolved, the reference in the input string will be unchanged.
                          Double $$ are reduced to a single $, which allows for escaping
                          the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the
                          string literal "$(VAR_NAME)". Escaped references will never
                          be expanded, regardless of whether the variable exists or
                          not. Defaults to "".'
                        type: string
                      valueFrom:
                        description:
                          Source for the environment variable's value. Cannot
                          be used if value is not empty.
                        properties:
                          configMapKeyRef:
                            description: Selects a key of a ConfigMap.
                            properties:
                              key:
                                description: The key to select.
                                type: string
                              name:
                                description:
                                  "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                                  TODO: Add other useful fields. apiVersion, kind, uid?"
                                type: string
                              optional:
                                description:
                                  Specify whether the ConfigMap or its key
                                  must be defined
                                type: boolean
                            required:
                              - key
                            type: object
                            x-kubernetes-map-type: atomic
                          fieldRef:
                            description:
                              "Selects a field of the pod: supports metadata.name,
                              metadata.namespace, `metadata.labels['<KEY>']`, `metadata.annotations['<KEY>']`,
                              spec.nodeName, spec.serviceAccountName, status.hostIP,
                              status.podIP, status.podIPs."
                            properties:
                              apiVersion:
                                description:
                                  Version of the schema the FieldPath is
                                  written in terms of, defaults to "v1".
                                type: string
                              fieldPath:
                                description:
                                  Path of the field to select in the specified
                                  API version.
                                type: string
                            required:
                              - fieldPath
                            type: object
                            x-kubernetes-map-type: atomic
                          resourceFieldRef:
                            description:
                              "Selects a resource of the container: only
                              resources limits and requests (limits.cpu, limits.memory,
                              limits.ephemeral-storage, requests.cpu, requests.memory
                              and requests.ephemeral-storage) are currently supported."
                            properties:
                              containerName:
                                description:
                                  "Container name: required for volumes,
                                  optional for env vars"
                                type: string
                              divisor:
                                anyOf:
                                  - type: integer
                                  - type: string
                                description:
                                  Specifies the output format of the exposed
                                  resources, defaults to "1"
                                pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                x-kubernetes-int-or-string: true
                              resource:
                                description: "Required: resource to select"
                                type: string
                            required:
                              - resource
                            type: object
                            x-kubernetes-map-type: atomic
                          secretKeyRef:
                            description: Selects a key of a secret in the pod's namespace
                            properties:
                              key:
                                description:
                                  The key of the secret to select from.  Must
                                  be a valid secret key.
                                type: string
                              name:
                                description:
                                  "Name of the referent. More info: https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
                                  TODO: Add other useful fields. apiVersion, kind, uid?"
                                type: string
                              optional:
                                description:
                                  Specify whether the Secret or its key must
                                  be defined
                                type: boolean
                            required:
                              - key
                            type: object
                            x-kubernetes-map-type: atomic
                        type: object
                    required:
                      - name
                    type: object
                  type: array
                image:
                  description: Image is the Dragonfly image to use
                  type: string
                labels:
                  additionalProperties:
                    type: string
                  description: (Optional) Labels to add to the Dragonfly pods.
                  type: object
                nodeSelector:
                  additionalProperties:
                    type: string
                  description: (Optional) Dragonfly pod node selector
                  type: object
                priorityClassName:
                  description: (Optional) Dragonfly pod priority class name
                  type: string
                replicas:
                  description:
                    Replicas is the total number of Dragonfly instances including
                    the master
                  format: int32
                  type: integer
                resources:
                  description:
                    (Optional) Dragonfly container resource limits. Any container
                    limits can be specified.
                  properties:
                    claims:
                      description:
                        "Claims lists the names of resources, defined in
                        spec.resourceClaims, that are used by this container. \n This
                        is an alpha field and requires enabling the DynamicResourceAllocation
                        feature gate. \n This field is immutable. It can only be set
                        for containers."
                      items:
                        description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                        properties:
                          name:
                            description:
                              Name must match the name of one entry in pod.spec.resourceClaims
                              of the Pod where this field is used. It makes that resource
                              available inside a container.
                            type: string
                        required:
                          - name
                        type: object
                      type: array
                      x-kubernetes-list-map-keys:
                        - name
                      x-kubernetes-list-type: map
                    limits:
                      additionalProperties:
                        anyOf:
                          - type: integer
                          - type: string
                        pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                        x-kubernetes-int-or-string: true
                      description:
                        "Limits describes the maximum amount of compute resources
                        allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/"
                      type: object
                    requests:
                      additionalProperties:
                        anyOf:
                          - type: integer
                          - type: string
                        pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                        x-kubernetes-int-or-string: true
                      description:
                        "Requests describes the minimum amount of compute
                        resources required. If Requests is omitted for a container,
                        it defaults to Limits if that is explicitly specified, otherwise
                        to an implementation-defined value. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/"
                      type: object
                  type: object
                serviceAccountName:
                  description: (Optional) Dragonfly pod service account name
                  type: string
                serviceSpec:
                  description: (Optional) Dragonfly Service configuration
                  properties:
                    annotations:
                      additionalProperties:
                        type: string
                      description: (Optional) Dragonfly Service Annotations
                      type: object
                    type:
                      description: (Optional) Dragonfly Service type
                      type: string
                  type: object
                snapshot:
                  description: (Optional) Dragonfly Snapshot configuration
                  properties:
                    cron:
                      description: (Optional) Dragonfly snapshot schedule
                      type: string
                    dir:
                      description:
                        (Optional) The path to the snapshot directory This
                        can also be an S3 URI with the prefix `s3://` when using S3
                        as the snapshot backend
                      type: string
                    persistentVolumeClaimSpec:
                      description: (Optional) Dragonfly PVC spec
                      properties:
                        accessModes:
                          description:
                            "accessModes contains the desired access modes
                            the volume should have. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1"
                          items:
                            type: string
                          type: array
                        dataSource:
                          description:
                            "dataSource field can be used to specify either:
                            * An existing VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)
                            * An existing PVC (PersistentVolumeClaim) If the provisioner
                            or an external controller can support the specified data
                            source, it will create a new volume based on the contents
                            of the specified data source. When the AnyVolumeDataSource
                            feature gate is enabled, dataSource contents will be copied
                            to dataSourceRef, and dataSourceRef contents will be copied
                            to dataSource when dataSourceRef.namespace is not specified.
                            If the namespace is specified, then dataSourceRef will not
                            be copied to dataSource."
                          properties:
                            apiGroup:
                              description:
                                APIGroup is the group for the resource being
                                referenced. If APIGroup is not specified, the specified
                                Kind must be in the core API group. For any other third-party
                                types, APIGroup is required.
                              type: string
                            kind:
                              description: Kind is the type of resource being referenced
                              type: string
                            name:
                              description: Name is the name of resource being referenced
                              type: string
                          required:
                            - kind
                            - name
                          type: object
                          x-kubernetes-map-type: atomic
                        dataSourceRef:
                          description:
                            "dataSourceRef specifies the object from which
                            to populate the volume with data, if a non-empty volume
                            is desired. This may be any object from a non-empty API
                            group (non core object) or a PersistentVolumeClaim object.
                            When this field is specified, volume binding will only succeed
                            if the type of the specified object matches some installed
                            volume populator or dynamic provisioner. This field will
                            replace the functionality of the dataSource field and as
                            such if both fields are non-empty, they must have the same
                            value. For backwards compatibility, when namespace isn't
                            specified in dataSourceRef, both fields (dataSource and
                            dataSourceRef) will be set to the same value automatically
                            if one of them is empty and the other is non-empty. When
                            namespace is specified in dataSourceRef, dataSource isn't
                            set to the same value and must be empty. There are three
                            important differences between dataSource and dataSourceRef:
                            * While dataSource only allows two specific types of objects,
                            dataSourceRef allows any non-core object, as well as PersistentVolumeClaim
                            objects. * While dataSource ignores disallowed values (dropping
                            them), dataSourceRef preserves all values, and generates
                            an error if a disallowed value is specified. * While dataSource
                            only allows local objects, dataSourceRef allows objects
                            in any namespaces. (Beta) Using this field requires the
                            AnyVolumeDataSource feature gate to be enabled. (Alpha)
                            Using the namespace field of dataSourceRef requires the
                            CrossNamespaceVolumeDataSource feature gate to be enabled."
                          properties:
                            apiGroup:
                              description:
                                APIGroup is the group for the resource being
                                referenced. If APIGroup is not specified, the specified
                                Kind must be in the core API group. For any other third-party
                                types, APIGroup is required.
                              type: string
                            kind:
                              description: Kind is the type of resource being referenced
                              type: string
                            name:
                              description: Name is the name of resource being referenced
                              type: string
                            namespace:
                              description:
                                Namespace is the namespace of resource being
                                referenced Note that when a namespace is specified,
                                a gateway.networking.k8s.io/ReferenceGrant object is
                                required in the referent namespace to allow that namespace's
                                owner to accept the reference. See the ReferenceGrant
                                documentation for details. (Alpha) This field requires
                                the CrossNamespaceVolumeDataSource feature gate to be
                                enabled.
                              type: string
                          required:
                            - kind
                            - name
                          type: object
                        resources:
                          description:
                            "resources represents the minimum resources the
                            volume should have. If RecoverVolumeExpansionFailure feature
                            is enabled users are allowed to specify resource requirements
                            that are lower than previous value but must still be higher
                            than capacity recorded in the status field of the claim.
                            More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources"
                          properties:
                            claims:
                              description:
                                "Claims lists the names of resources, defined
                                in spec.resourceClaims, that are used by this container.
                                \n This is an alpha field and requires enabling the
                                DynamicResourceAllocation feature gate. \n This field
                                is immutable. It can only be set for containers."
                              items:
                                description: ResourceClaim references one entry in PodSpec.ResourceClaims.
                                properties:
                                  name:
                                    description:
                                      Name must match the name of one entry
                                      in pod.spec.resourceClaims of the Pod where this
                                      field is used. It makes that resource available
                                      inside a container.
                                    type: string
                                required:
                                  - name
                                type: object
                              type: array
                              x-kubernetes-list-map-keys:
                                - name
                              x-kubernetes-list-type: map
                            limits:
                              additionalProperties:
                                anyOf:
                                  - type: integer
                                  - type: string
                                pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                x-kubernetes-int-or-string: true
                              description:
                                "Limits describes the maximum amount of compute
                                resources allowed. More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/"
                              type: object
                            requests:
                              additionalProperties:
                                anyOf:
                                  - type: integer
                                  - type: string
                                pattern: ^(\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))(([KMGTPE]i)|[numkMGTPE]|([eE](\+|-)?(([0-9]+(\.[0-9]*)?)|(\.[0-9]+))))?$
                                x-kubernetes-int-or-string: true
                              description:
                                "Requests describes the minimum amount of
                                compute resources required. If Requests is omitted for
                                a container, it defaults to Limits if that is explicitly
                                specified, otherwise to an implementation-defined value.
                                More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/"
                              type: object
                          type: object
                        selector:
                          description:
                            selector is a label query over volumes to consider
                            for binding.
                          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
                        storageClassName:
                          description:
                            "storageClassName is the name of the StorageClass
                            required by the claim. More info: https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1"
                          type: string
                        volumeMode:
                          description:
                            volumeMode defines what type of volume is required
                            by the claim. Value of Filesystem is implied when not included
                            in claim spec.
                          type: string
                        volumeName:
                          description:
                            volumeName is the binding reference to the PersistentVolume
                            backing this claim.
                          type: string
                      type: object
                  type: object
                tlsSecretRef:
                  description:
                    (Optional) Dragonfly TLS secret to used for TLS Connections
                    to Dragonfly. Dragonfly instance  must have access to this secret
                    and be in the same namespace
                  properties:
                    name:
                      description:
                        name is unique within a namespace to reference a
                        secret resource.
                      type: string
                    namespace:
                      description:
                        namespace defines the space within which the secret
                        name must be unique.
                      type: string
                  type: object
                  x-kubernetes-map-type: atomic
                tolerations:
                  description: (Optional) Dragonfly pod tolerations
                  items:
                    description:
                      The pod this Toleration is attached to tolerates any
                      taint that matches the triple <key,value,effect> using the matching
                      operator <operator>.
                    properties:
                      effect:
                        description:
                          Effect indicates the taint effect to match. Empty
                          means match all taint effects. When specified, allowed values
                          are NoSchedule, PreferNoSchedule and NoExecute.
                        type: string
                      key:
                        description:
                          Key is the taint key that the toleration applies
                          to. Empty means match all taint keys. If the key is empty,
                          operator must be Exists; this combination means to match all
                          values and all keys.
                        type: string
                      operator:
                        description:
                          Operator represents a key's relationship to the
                          value. Valid operators are Exists and Equal. Defaults to Equal.
                          Exists is equivalent to wildcard for value, so that a pod
                          can tolerate all taints of a particular category.
                        type: string
                      tolerationSeconds:
                        description:
                          TolerationSeconds represents the period of time
                          the toleration (which must be of effect NoExecute, otherwise
                          this field is ignored) tolerates the taint. By default, it
                          is not set, which means tolerate the taint forever (do not
                          evict). Zero and negative values will be treated as 0 (evict
                          immediately) by the system.
                        format: int64
                        type: integer
                      value:
                        description:
                          Value is the taint value the toleration matches
                          to. If the operator is Exists, the value should be empty,
                          otherwise just a regular string.
                        type: string
                    type: object
                  type: array
                topologySpreadConstraints:
                  description: (Optional) Dragonfly pod topologySpreadConstraints
                  items:
                    description: The pod this TopologySpreadConstraints is attached
                    properties:
                      maxSkew:
                        description:
                          the degree to which Pods may be unevenly distributed.
                          You must specify this field and the number must be greater than zero.
                          Its semantics differ according to the value of whenUnsatisfiable
                        format: int32
                        type: integer
                      minDomains:
                        description:
                          (Optional) indicates a minimum number of eligible domains.
                          This field is optional. A domain is a particular instance of a topology.
                          An eligible domain is a domain whose nodes match the node selector
                        format: int32
                        type: integer
                      topologyKey:
                        description:
                          the key of node labels. Nodes that have a label with this key and
                          identical values are considered to be in the same topology. We call each
                          instance of a topology (in other words, a <key, value> pair) a domain.
                          The scheduler will try to put a balanced number of pods into each domain.
                          Also, we define an eligible domain as a domain whose nodes meet the
                          requirements of nodeAffinityPolicy and nodeTaintsPolicy.
                        type: string
                      whenUnsatisfiable:
                        description:
                          DoNotSchedule (default) tells the scheduler not to schedule it.
                          ScheduleAnyway tells the scheduler to still schedule it while prioritizing
                          nodes that minimize the skew.
                        type: string
                      labelSelector:
                        description: A label query over a set of resources,
                          in this case pods.
                        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
                      matchLabelKeys:
                        description:
                          field is a beta-level field and enabled by default in 1.27.
                          You can disable it by disabling the MatchLabelKeysInPodTopologySpread
                        items:
                          type: string
                        type: array
                      nodeAffinityPolicy:
                        description:
                          indicates how we will treat Pod's nodeAffinity/nodeSelector
                          when calculating pod topology spread skew. Options are Honor or Ignore
                        type: string
                      nodeTaintsPolicy:
                        description: indicates how we will treat node taints when calculating pod topology spread skew. Honor or Ignore
                        type: string
                    type: object
                  type: array
              type: object
            status:
              description: DragonflyStatus defines the observed state of Dragonfly
              properties:
                isRollingUpdate:
                  description:
                    IsRollingUpdate is true if the Dragonfly instance is
                    being updated
                  type: boolean
                phase:
                  description:
                    'Status of the Dragonfly Instance It can be one of the
                    following: - "ready": The Dragonfly instance is ready to serve requests
                    - "configuring-replication": The controller is updating the master
                    of the Dragonfly instance - "resources-created": The Dragonfly instance
                    resources were created but not yet configured'
                  type: string
              type: object
          type: object
      served: true
      storage: true
      subresources:
        status: {}