---
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  annotations:
    controller-gen.kubebuilder.io/version: v0.13.0
  name: seataservers.operator.seata.apache.org
spec:
  group: operator.seata.apache.org
  names:
    kind: SeataServer
    listKind: SeataServerList
    plural: seataservers
    singular: seataserver
  scope: Namespaced
  versions:
  - name: v1alpha1
    schema:
      openAPIV3Schema:
        description: SeataServer is the Schema for the seataservers 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: SeataServerSpec defines the desired state of SeataServer
            properties:
              containerName:
                default: seata-server
                type: string
              env:
                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:
                default: seataio/seata-server:latest
                type: string
              persistence:
                properties:
                  spec:
                    description: PersistentVolumeClaimSpec is the spec to describe
                      PVC for the container This field is optional. If no PVC is specified
                      default persistent volume will get created.
                    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.
                              Requests cannot exceed Limits. 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
                  volumeReclaimPolicy:
                    description: VolumeReclaimPolicy is a seata operator configuration.
                      If it's set to Delete, the corresponding PVCs will be deleted
                      by the operator when seata server cluster is deleted. The default
                      value is Retain.
                    enum:
                    - Delete
                    - Retain
                    type: string
                type: object
              ports:
                properties:
                  consolePort:
                    default: 7091
                    format: int32
                    type: integer
                  raftPort:
                    default: 9091
                    format: int32
                    type: integer
                  servicePort:
                    default: 8091
                    format: int32
                    type: integer
                type: object
              replicas:
                default: 1
                format: int32
                minimum: 1
                type: integer
              resources:
                description: ResourceRequirements describes the compute resource requirements.
                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. Requests cannot exceed Limits.
                      More info: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/'
                    type: object
                type: object
              serviceName:
                default: seata-server-cluster
                type: string
              store:
                description: Store defines the storage configuration for SeataServer
                properties:
                  resources:
                    properties:
                      requests:
                        properties:
                          storage:
                            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
                        type: object
                    type: object
                type: object
            type: object
          status:
            description: SeataServerStatus defines the observed state of SeataServer
            properties:
              errors:
                items:
                  description: SeataServerError defines the error of SeataServer
                  properties:
                    message:
                      type: string
                    timestamp:
                      format: date-time
                      type: string
                    type:
                      type: string
                  required:
                  - message
                  - timestamp
                  - type
                  type: object
                type: array
              readyReplicas:
                format: int32
                type: integer
              replicas:
                format: int32
                type: integer
              synchronized:
                type: boolean
            required:
            - replicas
            - synchronized
            type: object
        type: object
    served: true
    storage: true
    subresources:
      status: {}
