From e6918187568dbd01842d8d1d2c808ce16a894239 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 21 Apr 2024 13:54:28 +0200 Subject: Adding upstream version 18.2.2. Signed-off-by: Daniel Baumann --- src/pybind/mgr/rook/.gitignore | 1 + src/pybind/mgr/rook/CMakeLists.txt | 20 + src/pybind/mgr/rook/__init__.py | 5 + src/pybind/mgr/rook/ci/Dockerfile | 3 + src/pybind/mgr/rook/ci/run-rook-e2e-tests.sh | 9 + .../mgr/rook/ci/scripts/bootstrap-rook-cluster.sh | 135 + src/pybind/mgr/rook/ci/tests/features/rook.feature | 12 + .../rook/ci/tests/features/steps/implementation.py | 21 + .../mgr/rook/ci/tests/features/steps/utils.py | 29 + src/pybind/mgr/rook/generate_rook_ceph_client.sh | 14 + src/pybind/mgr/rook/module.py | 727 ++++ src/pybind/mgr/rook/requirements.txt | 2 + .../.github/workflows/generate.yml | 21 + src/pybind/mgr/rook/rook-client-python/.gitignore | 12 + src/pybind/mgr/rook/rook-client-python/LICENSE | 201 + src/pybind/mgr/rook/rook-client-python/README.md | 81 + src/pybind/mgr/rook/rook-client-python/conftest.py | 11 + src/pybind/mgr/rook/rook-client-python/generate.sh | 35 + .../rook-client-python/generate_model_classes.py | 402 ++ src/pybind/mgr/rook/rook-client-python/mypy.ini | 7 + .../mgr/rook/rook-client-python/requirements.txt | 7 + .../rook-client-python/rook-python-client-demo.gif | Bin 0 -> 119572 bytes .../rook-client-python/rook_client/__init__.py | 1 + .../rook/rook-client-python/rook_client/_helper.py | 128 + .../rook-client-python/rook_client/_helper.py.orig | 133 + .../rook_client/cassandra/__init__.py | 0 .../rook_client/cassandra/cluster.py | 317 ++ .../rook_client/ceph/__init__.py | 0 .../rook_client/ceph/cephblockpool.py | 1193 ++++++ .../rook_client/ceph/cephclient.py | 157 + .../rook_client/ceph/cephcluster.py | 3959 ++++++++++++++++++++ .../rook_client/ceph/cephfilesystem.py | 1771 +++++++++ .../rook_client/ceph/cephfilesystemmirror.py | 1013 +++++ .../rook-client-python/rook_client/ceph/cephnfs.py | 1111 ++++++ .../rook_client/ceph/cephobjectrealm.py | 154 + .../rook_client/ceph/cephobjectstore.py | 2631 +++++++++++++ .../rook_client/ceph/cephobjectstoreuser.py | 157 + .../rook_client/ceph/cephobjectzone.py | 797 ++++ .../rook_client/ceph/cephobjectzonegroup.py | 131 + .../rook_client/ceph/cephrbdmirror.py | 1066 ++++++ .../rook_client/ceph/objectbucket.py | 252 ++ .../rook_client/ceph/objectbucketclaim.py | 147 + .../rook-client-python/rook_client/ceph/volume.py | 177 + .../rook_client/ceph/volumereplication.py | 363 ++ .../rook_client/ceph/volumereplicationclass.py | 121 + .../rook/rook-client-python/rook_client/py.typed | 1 + .../rook_client/tests/__init__.py | 0 .../rook_client/tests/test_README.py | 28 + .../rook_client/tests/test_examples.py | 52 + .../rook_client/tests/test_properties.py | 13 + src/pybind/mgr/rook/rook-client-python/setup.py | 20 + src/pybind/mgr/rook/rook-client-python/tox.ini | 24 + src/pybind/mgr/rook/rook_client/__init__.py | 1 + src/pybind/mgr/rook/rook_client/_helper.py | 128 + src/pybind/mgr/rook/rook_cluster.py | 1591 ++++++++ src/pybind/mgr/rook/tests/__init__.py | 0 src/pybind/mgr/rook/tests/fixtures.py | 11 + src/pybind/mgr/rook/tests/test_placement.py | 100 + src/pybind/mgr/rook/tests/test_rook.py | 120 + 59 files changed, 19623 insertions(+) create mode 100644 src/pybind/mgr/rook/.gitignore create mode 100644 src/pybind/mgr/rook/CMakeLists.txt create mode 100644 src/pybind/mgr/rook/__init__.py create mode 100644 src/pybind/mgr/rook/ci/Dockerfile create mode 100755 src/pybind/mgr/rook/ci/run-rook-e2e-tests.sh create mode 100755 src/pybind/mgr/rook/ci/scripts/bootstrap-rook-cluster.sh create mode 100644 src/pybind/mgr/rook/ci/tests/features/rook.feature create mode 100644 src/pybind/mgr/rook/ci/tests/features/steps/implementation.py create mode 100644 src/pybind/mgr/rook/ci/tests/features/steps/utils.py create mode 100755 src/pybind/mgr/rook/generate_rook_ceph_client.sh create mode 100644 src/pybind/mgr/rook/module.py create mode 100644 src/pybind/mgr/rook/requirements.txt create mode 100644 src/pybind/mgr/rook/rook-client-python/.github/workflows/generate.yml create mode 100644 src/pybind/mgr/rook/rook-client-python/.gitignore create mode 100644 src/pybind/mgr/rook/rook-client-python/LICENSE create mode 100644 src/pybind/mgr/rook/rook-client-python/README.md create mode 100644 src/pybind/mgr/rook/rook-client-python/conftest.py create mode 100755 src/pybind/mgr/rook/rook-client-python/generate.sh create mode 100644 src/pybind/mgr/rook/rook-client-python/generate_model_classes.py create mode 100644 src/pybind/mgr/rook/rook-client-python/mypy.ini create mode 100644 src/pybind/mgr/rook/rook-client-python/requirements.txt create mode 100644 src/pybind/mgr/rook/rook-client-python/rook-python-client-demo.gif create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/__init__.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py.orig create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/__init__.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/cluster.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/__init__.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephblockpool.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephclient.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephcluster.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystem.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystemmirror.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephnfs.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectrealm.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstoreuser.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzone.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzonegroup.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephrbdmirror.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucket.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucketclaim.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volume.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplication.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplicationclass.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/py.typed create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/tests/__init__.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_README.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_examples.py create mode 100644 src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_properties.py create mode 100644 src/pybind/mgr/rook/rook-client-python/setup.py create mode 100644 src/pybind/mgr/rook/rook-client-python/tox.ini create mode 100644 src/pybind/mgr/rook/rook_client/__init__.py create mode 100644 src/pybind/mgr/rook/rook_client/_helper.py create mode 100644 src/pybind/mgr/rook/rook_cluster.py create mode 100644 src/pybind/mgr/rook/tests/__init__.py create mode 100644 src/pybind/mgr/rook/tests/fixtures.py create mode 100644 src/pybind/mgr/rook/tests/test_placement.py create mode 100644 src/pybind/mgr/rook/tests/test_rook.py (limited to 'src/pybind/mgr/rook') diff --git a/src/pybind/mgr/rook/.gitignore b/src/pybind/mgr/rook/.gitignore new file mode 100644 index 000000000..211c13153 --- /dev/null +++ b/src/pybind/mgr/rook/.gitignore @@ -0,0 +1 @@ +rook_client diff --git a/src/pybind/mgr/rook/CMakeLists.txt b/src/pybind/mgr/rook/CMakeLists.txt new file mode 100644 index 000000000..79e4e9a2e --- /dev/null +++ b/src/pybind/mgr/rook/CMakeLists.txt @@ -0,0 +1,20 @@ +include(ExternalProject) + +ExternalProject_Add(mgr-rook-client + SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/rook-client-python/rook_client" + # use INSTALL_DIR for destination dir + INSTALL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/rook_client" + CONFIGURE_COMMAND "" + BUILD_COMMAND ${CMAKE_COMMAND} -E make_directory + COMMAND ${CMAKE_COMMAND} -E copy_directory /ceph /ceph + COMMAND ${CMAKE_COMMAND} -E copy /__init__.py + COMMAND ${CMAKE_COMMAND} -E copy /_helper.py + BUILD_BYPRODUCTS "/__init__.py" + INSTALL_COMMAND "") + +add_dependencies(ceph-mgr mgr-rook-client) + +install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + DESTINATION ${CEPH_INSTALL_DATADIR}/mgr + ${mgr_module_install_excludes} + REGEX "rook-client-python.*" EXCLUDE) diff --git a/src/pybind/mgr/rook/__init__.py b/src/pybind/mgr/rook/__init__.py new file mode 100644 index 000000000..b16bddb73 --- /dev/null +++ b/src/pybind/mgr/rook/__init__.py @@ -0,0 +1,5 @@ +import os +if 'UNITTEST' in os.environ: + import tests + +from .module import RookOrchestrator diff --git a/src/pybind/mgr/rook/ci/Dockerfile b/src/pybind/mgr/rook/ci/Dockerfile new file mode 100644 index 000000000..30ebea574 --- /dev/null +++ b/src/pybind/mgr/rook/ci/Dockerfile @@ -0,0 +1,3 @@ +FROM quay.io/ceph/daemon-base:latest-main +COPY ./tmp_build/orchestrator /usr/share/ceph/mgr/orchestrator +COPY ./tmp_build/rook /usr/share/ceph/mgr/rook diff --git a/src/pybind/mgr/rook/ci/run-rook-e2e-tests.sh b/src/pybind/mgr/rook/ci/run-rook-e2e-tests.sh new file mode 100755 index 000000000..a43e01a89 --- /dev/null +++ b/src/pybind/mgr/rook/ci/run-rook-e2e-tests.sh @@ -0,0 +1,9 @@ +#!/usr/bin/env bash + +set -ex + +# Execute tests +: ${CEPH_DEV_FOLDER:=${PWD}} +${CEPH_DEV_FOLDER}/src/pybind/mgr/rook/ci/scripts/bootstrap-rook-cluster.sh +cd ${CEPH_DEV_FOLDER}/src/pybind/mgr/rook/ci/tests +behave diff --git a/src/pybind/mgr/rook/ci/scripts/bootstrap-rook-cluster.sh b/src/pybind/mgr/rook/ci/scripts/bootstrap-rook-cluster.sh new file mode 100755 index 000000000..4b97df6ba --- /dev/null +++ b/src/pybind/mgr/rook/ci/scripts/bootstrap-rook-cluster.sh @@ -0,0 +1,135 @@ +#!/usr/bin/env bash + +set -eEx + +: ${CEPH_DEV_FOLDER:=${PWD}} +KUBECTL="minikube kubectl --" + +# We build a local ceph image that contains the latest code +# plus changes from the PR. This image will be used by the docker +# running inside the minikube to start the different ceph pods +LOCAL_CEPH_IMG="local/ceph" + +on_error() { + echo "on error" + minikube delete +} + +configure_libvirt(){ + sudo usermod -aG libvirt $(id -un) + sudo su -l $USER # Avoid having to log out and log in for group addition to take effect. + sudo systemctl enable --now libvirtd + sudo systemctl restart libvirtd + sleep 10 # wait some time for libvirtd service to restart +} + +setup_minikube_env() { + + # Check if Minikube is running + if minikube status > /dev/null 2>&1; then + echo "Minikube is running" + minikube stop + minikube delete + else + echo "Minikube is not running" + fi + + rm -rf ~/.minikube + minikube start --memory="4096" --cpus="2" --disk-size=10g --extra-disks=1 --driver kvm2 + # point Docker env to use docker daemon running on minikube + eval $(minikube docker-env -p minikube) +} + +build_ceph_image() { + wget -q -O cluster-test.yaml https://raw.githubusercontent.com/rook/rook/master/deploy/examples/cluster-test.yaml + CURR_CEPH_IMG=$(grep -E '^\s*image:\s+' cluster-test.yaml | sed 's/.*image: *\([^ ]*\)/\1/') + + cd ${CEPH_DEV_FOLDER}/src/pybind/mgr/rook/ci + mkdir -p tmp_build/rook + mkdir -p tmp_build/orchestrator + cp ./../../orchestrator/*.py tmp_build/orchestrator + cp ../*.py tmp_build/rook + + # we use the following tag to trick the Docker + # running inside minikube so it uses this image instead + # of pulling it from the registry + docker build --tag ${LOCAL_CEPH_IMG} . + docker tag ${LOCAL_CEPH_IMG} ${CURR_CEPH_IMG} + + # cleanup + rm -rf tmp_build + cd ${CEPH_DEV_FOLDER} +} + +create_rook_cluster() { + wget -q -O cluster-test.yaml https://raw.githubusercontent.com/rook/rook/master/deploy/examples/cluster-test.yaml + $KUBECTL create -f https://raw.githubusercontent.com/rook/rook/master/deploy/examples/crds.yaml + $KUBECTL create -f https://raw.githubusercontent.com/rook/rook/master/deploy/examples/common.yaml + $KUBECTL create -f https://raw.githubusercontent.com/rook/rook/master/deploy/examples/operator.yaml + $KUBECTL create -f cluster-test.yaml + $KUBECTL create -f https://raw.githubusercontent.com/rook/rook/master/deploy/examples/dashboard-external-http.yaml + $KUBECTL create -f https://raw.githubusercontent.com/rook/rook/master/deploy/examples/toolbox.yaml +} + +wait_for_rook_operator() { + local max_attempts=10 + local sleep_interval=20 + local attempts=0 + $KUBECTL rollout status deployment rook-ceph-operator -n rook-ceph --timeout=180s + PHASE=$($KUBECTL get cephclusters.ceph.rook.io -n rook-ceph -o jsonpath='{.items[?(@.kind == "CephCluster")].status.phase}') + echo "PHASE: $PHASE" + while ! $KUBECTL get cephclusters.ceph.rook.io -n rook-ceph -o jsonpath='{.items[?(@.kind == "CephCluster")].status.phase}' | grep -q "Ready"; do + echo "Waiting for cluster to be ready..." + sleep $sleep_interval + attempts=$((attempts+1)) + if [ $attempts -ge $max_attempts ]; then + echo "Maximum number of attempts ($max_attempts) reached. Exiting..." + return 1 + fi + done +} + +wait_for_ceph_cluster() { + local max_attempts=10 + local sleep_interval=20 + local attempts=0 + $KUBECTL rollout status deployment rook-ceph-tools -n rook-ceph --timeout=30s + while ! $KUBECTL get cephclusters.ceph.rook.io -n rook-ceph -o jsonpath='{.items[?(@.kind == "CephCluster")].status.ceph.health}' | grep -q "HEALTH_OK"; do + echo "Waiting for Ceph cluster installed" + sleep $sleep_interval + attempts=$((attempts+1)) + if [ $attempts -ge $max_attempts ]; then + echo "Maximum number of attempts ($max_attempts) reached. Exiting..." + return 1 + fi + done + echo "Ceph cluster installed and running" +} + +show_info() { + DASHBOARD_PASSWORD=$($KUBECTL -n rook-ceph get secret rook-ceph-dashboard-password -o jsonpath="{['data']['password']}" | base64 --decode && echo) + IP_ADDR=$($KUBECTL get po --selector="app=rook-ceph-mgr" -n rook-ceph --output jsonpath='{.items[*].status.hostIP}') + PORT="$($KUBECTL -n rook-ceph -o=jsonpath='{.spec.ports[?(@.name == "dashboard")].nodePort}' get services rook-ceph-mgr-dashboard-external-http)" + BASE_URL="http://$IP_ADDR:$PORT" + echo "===========================" + echo "Ceph Dashboard: " + echo " IP_ADDRESS: $BASE_URL" + echo " PASSWORD: $DASHBOARD_PASSWORD" + echo "===========================" +} + +#################################################################### +#################################################################### + +trap 'on_error $? $LINENO' ERR + +configure_libvirt +setup_minikube_env +build_ceph_image +create_rook_cluster +wait_for_rook_operator +wait_for_ceph_cluster +show_info + +#################################################################### +#################################################################### diff --git a/src/pybind/mgr/rook/ci/tests/features/rook.feature b/src/pybind/mgr/rook/ci/tests/features/rook.feature new file mode 100644 index 000000000..ae0478f8b --- /dev/null +++ b/src/pybind/mgr/rook/ci/tests/features/rook.feature @@ -0,0 +1,12 @@ +Feature: Testing Rook orchestrator commands + Ceph has been installed using the cluster CRD available in deploy/examples/cluster-test.yaml and + + Scenario: Verify ceph cluster health + When I run + """ + ceph health | grep HEALTH + """ + Then I get + """ + HEALTH_OK + """ diff --git a/src/pybind/mgr/rook/ci/tests/features/steps/implementation.py b/src/pybind/mgr/rook/ci/tests/features/steps/implementation.py new file mode 100644 index 000000000..adde61afd --- /dev/null +++ b/src/pybind/mgr/rook/ci/tests/features/steps/implementation.py @@ -0,0 +1,21 @@ +from behave import * +from utils import * +import re + +@when("I run") +def run_step(context): + context.output = run_commands(context.text) + +@then("I get") +def verify_result_step(context): + print(f"Output is:\n{context.output}\n--------------\n") + assert context.text == context.output + +@then("I get something like") +def verify_fuzzy_result_step(context): + output_lines = context.output.split("\n") + expected_lines = context.text.split("\n") + num_lines = min(len(output_lines), len(expected_lines)) + for n in range(num_lines): + if not re.match(expected_lines[n], output_lines[n]): + raise diff --git a/src/pybind/mgr/rook/ci/tests/features/steps/utils.py b/src/pybind/mgr/rook/ci/tests/features/steps/utils.py new file mode 100644 index 000000000..41a71d0fb --- /dev/null +++ b/src/pybind/mgr/rook/ci/tests/features/steps/utils.py @@ -0,0 +1,29 @@ +import subprocess + +ROOK_CEPH_COMMAND = "minikube kubectl -- -n rook-ceph exec -it deploy/rook-ceph-tools -- " +CLUSTER_COMMAND = "minikube kubectl -- " + + +def execute_command(command: str) -> str: + output = "" + try: + proc = subprocess.run(command, shell=True, capture_output=True, text=True) + output = proc.stdout + except Exception as ex: + output = f"Error executing command: {ex}" + + return output + + +def run_commands(commands: str) -> str: + commands_list = commands.split("\n") + output = "" + for cmd in commands_list: + if cmd.startswith("ceph"): + prefix = ROOK_CEPH_COMMAND + else: + prefix = CLUSTER_COMMAND + command = prefix + cmd + output = execute_command(command) + + return output.strip("\n") diff --git a/src/pybind/mgr/rook/generate_rook_ceph_client.sh b/src/pybind/mgr/rook/generate_rook_ceph_client.sh new file mode 100755 index 000000000..c9ad15ce0 --- /dev/null +++ b/src/pybind/mgr/rook/generate_rook_ceph_client.sh @@ -0,0 +1,14 @@ +#!/bin/sh + +set -e + +script_location="$(dirname "$(readlink -f "$0")")" +cd "$script_location" + +rm -rf rook_client + + +cp -r ./rook-client-python/rook_client . +rm -rf rook_client/cassandra +rm -rf rook_client/edgefs +rm -rf rook_client/tests diff --git a/src/pybind/mgr/rook/module.py b/src/pybind/mgr/rook/module.py new file mode 100644 index 000000000..fa75db2cf --- /dev/null +++ b/src/pybind/mgr/rook/module.py @@ -0,0 +1,727 @@ +import datetime +import logging +import re +import threading +import functools +import os +import json + +from ceph.deployment import inventory +from ceph.deployment.service_spec import ServiceSpec, NFSServiceSpec, RGWSpec, PlacementSpec +from ceph.utils import datetime_now + +from typing import List, Dict, Optional, Callable, Any, TypeVar, Tuple, TYPE_CHECKING + +try: + from ceph.deployment.drive_group import DriveGroupSpec +except ImportError: + pass # just for type checking + +try: + from kubernetes import client, config + from kubernetes.client.rest import ApiException + + kubernetes_imported = True + + # https://github.com/kubernetes-client/python/issues/895 + from kubernetes.client.models.v1_container_image import V1ContainerImage + def names(self: Any, names: Any) -> None: + self._names = names + V1ContainerImage.names = V1ContainerImage.names.setter(names) + +except ImportError: + kubernetes_imported = False + client = None + config = None + +from mgr_module import MgrModule, Option, NFS_POOL_NAME +import orchestrator +from orchestrator import handle_orch_error, OrchResult, raise_if_exception + +from .rook_cluster import RookCluster + +T = TypeVar('T') +FuncT = TypeVar('FuncT', bound=Callable) +ServiceSpecT = TypeVar('ServiceSpecT', bound=ServiceSpec) + + +class RookEnv(object): + def __init__(self) -> None: + # POD_NAMESPACE already exist for Rook 0.9 + self.namespace = os.environ.get('POD_NAMESPACE', 'rook-ceph') + + # ROOK_CEPH_CLUSTER_CRD_NAME is new is Rook 1.0 + self.cluster_name = os.environ.get('ROOK_CEPH_CLUSTER_CRD_NAME', self.namespace) + + self.operator_namespace = os.environ.get('ROOK_OPERATOR_NAMESPACE', self.namespace) + self.crd_version = os.environ.get('ROOK_CEPH_CLUSTER_CRD_VERSION', 'v1') + self.api_name = "ceph.rook.io/" + self.crd_version + + def api_version_match(self) -> bool: + return self.crd_version == 'v1' + + def has_namespace(self) -> bool: + return 'POD_NAMESPACE' in os.environ + + +class RookOrchestrator(MgrModule, orchestrator.Orchestrator): + """ + Writes are a two-phase thing, firstly sending + the write to the k8s API (fast) and then waiting + for the corresponding change to appear in the + Ceph cluster (slow) + + Right now, we are calling the k8s API synchronously. + """ + + MODULE_OPTIONS: List[Option] = [ + # TODO: configure k8s API addr instead of assuming local + Option( + 'storage_class', + type='str', + default='local', + desc='storage class name for LSO-discovered PVs', + ), + Option( + 'drive_group_interval', + type='float', + default=300.0, + desc='interval in seconds between re-application of applied drive_groups', + ), + ] + + @staticmethod + def can_run() -> Tuple[bool, str]: + if not kubernetes_imported: + return False, "`kubernetes` python module not found" + if not RookEnv().api_version_match(): + return False, "Rook version unsupported." + return True, '' + + def available(self) -> Tuple[bool, str, Dict[str, Any]]: + if not kubernetes_imported: + return False, "`kubernetes` python module not found", {} + elif not self._rook_env.has_namespace(): + return False, "ceph-mgr not running in Rook cluster", {} + + try: + self.k8s.list_namespaced_pod(self._rook_env.namespace) + except ApiException as e: + return False, "Cannot reach Kubernetes API: {}".format(e), {} + else: + return True, "", {} + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super(RookOrchestrator, self).__init__(*args, **kwargs) + + self._initialized = threading.Event() + self._k8s_CoreV1_api: Optional[client.CoreV1Api] = None + self._k8s_BatchV1_api: Optional[client.BatchV1Api] = None + self._k8s_CustomObjects_api: Optional[client.CustomObjectsApi] = None + self._k8s_StorageV1_api: Optional[client.StorageV1Api] = None + self._rook_cluster: Optional[RookCluster] = None + self._rook_env = RookEnv() + self._k8s_AppsV1_api: Optional[client.AppsV1Api] = None + + self.config_notify() + if TYPE_CHECKING: + self.storage_class = 'foo' + self.drive_group_interval = 10.0 + + self._load_drive_groups() + self._shutdown = threading.Event() + + def config_notify(self) -> None: + """ + This method is called whenever one of our config options is changed. + + TODO: this method should be moved into mgr_module.py + """ + for opt in self.MODULE_OPTIONS: + setattr(self, + opt['name'], # type: ignore + self.get_module_option(opt['name'])) # type: ignore + self.log.debug(' mgr option %s = %s', + opt['name'], getattr(self, opt['name'])) # type: ignore + assert isinstance(self.storage_class, str) + assert isinstance(self.drive_group_interval, float) + + if self._rook_cluster: + self._rook_cluster.storage_class_name = self.storage_class + + def shutdown(self) -> None: + self._shutdown.set() + + @property + def k8s(self): + # type: () -> client.CoreV1Api + self._initialized.wait() + assert self._k8s_CoreV1_api is not None + return self._k8s_CoreV1_api + + @property + def rook_cluster(self): + # type: () -> RookCluster + self._initialized.wait() + assert self._rook_cluster is not None + return self._rook_cluster + + def serve(self) -> None: + # For deployed clusters, we should always be running inside + # a Rook cluster. For development convenience, also support + # running outside (reading ~/.kube config) + + if self._rook_env.has_namespace(): + config.load_incluster_config() + else: + self.log.warning("DEVELOPMENT ONLY: Reading kube config from ~") + config.load_kube_config() + + # So that I can do port forwarding from my workstation - jcsp + from kubernetes.client import configuration + configuration.verify_ssl = False + + self._k8s_CoreV1_api = client.CoreV1Api() + self._k8s_BatchV1_api = client.BatchV1Api() + self._k8s_CustomObjects_api = client.CustomObjectsApi() + self._k8s_StorageV1_api = client.StorageV1Api() + self._k8s_AppsV1_api = client.AppsV1Api() + + try: + # XXX mystery hack -- I need to do an API call from + # this context, or subsequent API usage from handle_command + # fails with SSLError('bad handshake'). Suspect some kind of + # thread context setup in SSL lib? + self._k8s_CoreV1_api.list_namespaced_pod(self._rook_env.namespace) + except ApiException: + # Ignore here to make self.available() fail with a proper error message + pass + + assert isinstance(self.storage_class, str) + + self._rook_cluster = RookCluster( + self._k8s_CoreV1_api, + self._k8s_BatchV1_api, + self._k8s_CustomObjects_api, + self._k8s_StorageV1_api, + self._k8s_AppsV1_api, + self._rook_env, + self.storage_class) + + self._initialized.set() + self.config_notify() + + while not self._shutdown.is_set(): + self._apply_drivegroups(list(self._drive_group_map.values())) + self._shutdown.wait(self.drive_group_interval) + + @handle_orch_error + def get_inventory(self, host_filter: Optional[orchestrator.InventoryFilter] = None, refresh: bool = False) -> List[orchestrator.InventoryHost]: + host_list = None + if host_filter and host_filter.hosts: + # Explicit host list + host_list = host_filter.hosts + elif host_filter and host_filter.labels: + # TODO: query k8s API to resolve to host list, and pass + # it into RookCluster.get_discovered_devices + raise NotImplementedError() + + discovered_devs = self.rook_cluster.get_discovered_devices(host_list) + + result = [] + for host_name, host_devs in discovered_devs.items(): + devs = [] + for d in host_devs: + devs.append(d) + + result.append(orchestrator.InventoryHost(host_name, inventory.Devices(devs))) + + return result + + @handle_orch_error + def get_hosts(self): + # type: () -> List[orchestrator.HostSpec] + return self.rook_cluster.get_hosts() + + @handle_orch_error + def describe_service(self, + service_type: Optional[str] = None, + service_name: Optional[str] = None, + refresh: bool = False) -> List[orchestrator.ServiceDescription]: + now = datetime_now() + + # CephCluster + cl = self.rook_cluster.rook_api_get( + "cephclusters/{0}".format(self.rook_cluster.rook_env.cluster_name)) + self.log.debug('CephCluster %s' % cl) + image_name = cl['spec'].get('cephVersion', {}).get('image', None) + num_nodes = len(self.rook_cluster.get_node_names()) + + spec = {} + if service_type == 'mon' or service_type is None: + spec['mon'] = orchestrator.ServiceDescription( + spec=ServiceSpec( + 'mon', + placement=PlacementSpec( + count=cl['spec'].get('mon', {}).get('count', 1), + ), + ), + size=cl['spec'].get('mon', {}).get('count', 1), + container_image_name=image_name, + last_refresh=now, + ) + if service_type == 'mgr' or service_type is None: + spec['mgr'] = orchestrator.ServiceDescription( + spec=ServiceSpec( + 'mgr', + placement=PlacementSpec.from_string('count:1'), + ), + size=1, + container_image_name=image_name, + last_refresh=now, + ) + + if ( + service_type == 'crash' or service_type is None + and not cl['spec'].get('crashCollector', {}).get('disable', False) + ): + spec['crash'] = orchestrator.ServiceDescription( + spec=ServiceSpec( + 'crash', + placement=PlacementSpec.from_string('*'), + ), + size=num_nodes, + container_image_name=image_name, + last_refresh=now, + ) + + if service_type == 'mds' or service_type is None: + # CephFilesystems + all_fs = self.rook_cluster.get_resource("cephfilesystems") + for fs in all_fs: + svc = 'mds.' + fs['metadata']['name'] + if svc in spec: + continue + # FIXME: we are conflating active (+ standby) with count + active = fs['spec'].get('metadataServer', {}).get('activeCount', 1) + total_mds = active + if fs['spec'].get('metadataServer', {}).get('activeStandby', False): + total_mds = active * 2 + spec[svc] = orchestrator.ServiceDescription( + spec=ServiceSpec( + service_type='mds', + service_id=fs['metadata']['name'], + placement=PlacementSpec(count=active), + ), + size=total_mds, + container_image_name=image_name, + last_refresh=now, + ) + + if service_type == 'rgw' or service_type is None: + # CephObjectstores + all_zones = self.rook_cluster.get_resource("cephobjectstores") + for zone in all_zones: + svc = 'rgw.' + zone['metadata']['name'] + if svc in spec: + continue + active = zone['spec']['gateway']['instances']; + if 'securePort' in zone['spec']['gateway']: + ssl = True + port = zone['spec']['gateway']['securePort'] + else: + ssl = False + port = zone['spec']['gateway']['port'] or 80 + rgw_zone = zone['spec'].get('zone', {}).get('name') or None + spec[svc] = orchestrator.ServiceDescription( + spec=RGWSpec( + service_id=zone['metadata']['name'], + rgw_zone=rgw_zone, + ssl=ssl, + rgw_frontend_port=port, + placement=PlacementSpec(count=active), + ), + size=active, + container_image_name=image_name, + last_refresh=now, + ) + + if service_type == 'nfs' or service_type is None: + # CephNFSes + all_nfs = self.rook_cluster.get_resource("cephnfses") + nfs_pods = self.rook_cluster.describe_pods('nfs', None, None) + for nfs in all_nfs: + # Starting with V.17.2.0, the 'rados' spec part in 'cephnfs' resources does not contain the 'pool' item + if 'pool' in nfs['spec']['rados']: + if nfs['spec']['rados']['pool'] != NFS_POOL_NAME: + continue + nfs_name = nfs['metadata']['name'] + svc = 'nfs.' + nfs_name + if svc in spec: + continue + active = nfs['spec'].get('server', {}).get('active') + creation_timestamp = datetime.datetime.strptime(nfs['metadata']['creationTimestamp'], '%Y-%m-%dT%H:%M:%SZ') + spec[svc] = orchestrator.ServiceDescription( + spec=NFSServiceSpec( + service_id=nfs_name, + placement=PlacementSpec(count=active), + ), + size=active, + last_refresh=now, + running=len([1 for pod in nfs_pods if pod['labels']['ceph_nfs'] == nfs_name]), + created=creation_timestamp.astimezone(tz=datetime.timezone.utc) + ) + if service_type == 'osd' or service_type is None: + # OSDs + # FIXME: map running OSDs back to their respective services... + + # the catch-all unmanaged + all_osds = self.rook_cluster.get_osds() + svc = 'osd' + spec[svc] = orchestrator.ServiceDescription( + spec=DriveGroupSpec( + unmanaged=True, + service_type='osd', + ), + size=len(all_osds), + last_refresh=now, + running=sum(osd.status.phase == 'Running' for osd in all_osds) + ) + + # drivegroups + for name, dg in self._drive_group_map.items(): + spec[f'osd.{name}'] = orchestrator.ServiceDescription( + spec=dg, + last_refresh=now, + size=0, + running=0, + ) + + if service_type == 'rbd-mirror' or service_type is None: + # rbd-mirrors + all_mirrors = self.rook_cluster.get_resource("cephrbdmirrors") + for mirror in all_mirrors: + logging.warn(mirror) + mirror_name = mirror['metadata']['name'] + svc = 'rbd-mirror.' + mirror_name + if svc in spec: + continue + spec[svc] = orchestrator.ServiceDescription( + spec=ServiceSpec( + service_id=mirror_name, + service_type="rbd-mirror", + placement=PlacementSpec(count=1), + ), + size=1, + last_refresh=now, + ) + + for dd in self._list_daemons(): + if dd.service_name() not in spec: + continue + service = spec[dd.service_name()] + service.running += 1 + if not service.container_image_id: + service.container_image_id = dd.container_image_id + if not service.container_image_name: + service.container_image_name = dd.container_image_name + if service.last_refresh is None or not dd.last_refresh or dd.last_refresh < service.last_refresh: + service.last_refresh = dd.last_refresh + if service.created is None or dd.created is None or dd.created < service.created: + service.created = dd.created + + return [v for k, v in spec.items()] + + @handle_orch_error + def list_daemons(self, + service_name: Optional[str] = None, + daemon_type: Optional[str] = None, + daemon_id: Optional[str] = None, + host: Optional[str] = None, + refresh: bool = False) -> List[orchestrator.DaemonDescription]: + return self._list_daemons(service_name=service_name, + daemon_type=daemon_type, + daemon_id=daemon_id, + host=host, + refresh=refresh) + + def _list_daemons(self, + service_name: Optional[str] = None, + daemon_type: Optional[str] = None, + daemon_id: Optional[str] = None, + host: Optional[str] = None, + refresh: bool = False) -> List[orchestrator.DaemonDescription]: + pods = self.rook_cluster.describe_pods(daemon_type, daemon_id, host) + self.log.debug('pods %s' % pods) + result = [] + for p in pods: + sd = orchestrator.DaemonDescription() + sd.hostname = p['hostname'] + + # In Rook environments, the 'ceph-exporter' daemon is named 'exporter' whereas + # in the orchestrator interface, it is named 'ceph-exporter'. The purpose of the + # following adjustment is to ensure that the 'daemon_type' is correctly set. + # Without this adjustment, the 'service_to_daemon_types' lookup would fail, as + # it would be searching for a non-existent entry called 'exporter + if p['labels']['app'] == 'rook-ceph-exporter': + sd.daemon_type = 'ceph-exporter' + else: + sd.daemon_type = p['labels']['app'].replace('rook-ceph-', '') + + status = { + 'Pending': orchestrator.DaemonDescriptionStatus.starting, + 'Running': orchestrator.DaemonDescriptionStatus.running, + 'Succeeded': orchestrator.DaemonDescriptionStatus.stopped, + 'Failed': orchestrator.DaemonDescriptionStatus.error, + 'Unknown': orchestrator.DaemonDescriptionStatus.unknown, + }[p['phase']] + sd.status = status + + if 'ceph_daemon_id' in p['labels']: + sd.daemon_id = p['labels']['ceph_daemon_id'] + elif 'ceph-osd-id' in p['labels']: + sd.daemon_id = p['labels']['ceph-osd-id'] + else: + # Unknown type -- skip it + continue + + if service_name is not None and service_name != sd.service_name(): + continue + sd.container_image_name = p['container_image_name'] + sd.container_image_id = p['container_image_id'] + sd.created = p['created'] + sd.last_configured = p['created'] + sd.last_deployed = p['created'] + sd.started = p['started'] + sd.last_refresh = p['refreshed'] + result.append(sd) + + return result + + def _get_pool_params(self) -> Tuple[int, str]: + num_replicas = self.get_ceph_option('osd_pool_default_size') + assert type(num_replicas) is int + + leaf_type_id = self.get_ceph_option('osd_crush_chooseleaf_type') + assert type(leaf_type_id) is int + crush = self.get('osd_map_crush') + leaf_type = 'host' + for t in crush['types']: + if t['type_id'] == leaf_type_id: + leaf_type = t['name'] + break + return num_replicas, leaf_type + + @handle_orch_error + def remove_service(self, service_name: str, force: bool = False) -> str: + if service_name == 'rbd-mirror': + return self.rook_cluster.rm_service('cephrbdmirrors', 'default-rbd-mirror') + service_type, service_id = service_name.split('.', 1) + if service_type == 'mds': + return self.rook_cluster.rm_service('cephfilesystems', service_id) + elif service_type == 'rgw': + return self.rook_cluster.rm_service('cephobjectstores', service_id) + elif service_type == 'nfs': + ret, out, err = self.mon_command({ + 'prefix': 'auth ls' + }) + matches = re.findall(rf'client\.nfs-ganesha\.{service_id}\..*', out) + for match in matches: + self.check_mon_command({ + 'prefix': 'auth rm', + 'entity': match + }) + return self.rook_cluster.rm_service('cephnfses', service_id) + elif service_type == 'rbd-mirror': + return self.rook_cluster.rm_service('cephrbdmirrors', service_id) + elif service_type == 'osd': + if service_id in self._drive_group_map: + del self._drive_group_map[service_id] + self._save_drive_groups() + return f'Removed {service_name}' + elif service_type == 'ingress': + self.log.info("{0} service '{1}' does not exist".format('ingress', service_id)) + return 'The Rook orchestrator does not currently support ingress' + else: + raise orchestrator.OrchestratorError(f'Service type {service_type} not supported') + + def zap_device(self, host: str, path: str) -> OrchResult[str]: + try: + self.rook_cluster.create_zap_job(host, path) + except Exception as e: + logging.error(e) + return OrchResult(None, Exception("Unable to zap device: " + str(e.with_traceback(None)))) + return OrchResult(f'{path} on {host} zapped') + + @handle_orch_error + def apply_mon(self, spec): + # type: (ServiceSpec) -> str + if spec.placement.hosts or spec.placement.label: + raise RuntimeError("Host list or label is not supported by rook.") + + return self.rook_cluster.update_mon_count(spec.placement.count) + + def apply_rbd_mirror(self, spec: ServiceSpec) -> OrchResult[str]: + try: + self.rook_cluster.rbd_mirror(spec) + return OrchResult("Success") + except Exception as e: + return OrchResult(None, e) + + @handle_orch_error + def apply_mds(self, spec): + # type: (ServiceSpec) -> str + num_replicas, leaf_type = self._get_pool_params() + return self.rook_cluster.apply_filesystem(spec, num_replicas, leaf_type) + + @handle_orch_error + def apply_rgw(self, spec): + # type: (RGWSpec) -> str + num_replicas, leaf_type = self._get_pool_params() + return self.rook_cluster.apply_objectstore(spec, num_replicas, leaf_type) + + @handle_orch_error + def apply_nfs(self, spec): + # type: (NFSServiceSpec) -> str + try: + return self.rook_cluster.apply_nfsgw(spec, self) + except Exception as e: + logging.error(e) + return "Unable to create NFS daemon, check logs for more traceback\n" + str(e.with_traceback(None)) + + @handle_orch_error + def remove_daemons(self, names: List[str]) -> List[str]: + return self.rook_cluster.remove_pods(names) + + def apply_drivegroups(self, specs: List[DriveGroupSpec]) -> OrchResult[List[str]]: + for drive_group in specs: + self._drive_group_map[str(drive_group.service_id)] = drive_group + self._save_drive_groups() + return OrchResult(self._apply_drivegroups(specs)) + + def _apply_drivegroups(self, ls: List[DriveGroupSpec]) -> List[str]: + all_hosts = raise_if_exception(self.get_hosts()) + result_list: List[str] = [] + for drive_group in ls: + matching_hosts = drive_group.placement.filter_matching_hosts( + lambda label=None, as_hostspec=None: all_hosts + ) + + if not self.rook_cluster.node_exists(matching_hosts[0]): + raise RuntimeError("Node '{0}' is not in the Kubernetes " + "cluster".format(matching_hosts)) + + # Validate whether cluster CRD can accept individual OSD + # creations (i.e. not useAllDevices) + if not self.rook_cluster.can_create_osd(): + raise RuntimeError("Rook cluster configuration does not " + "support OSD creation.") + result_list.append(self.rook_cluster.add_osds(drive_group, matching_hosts)) + return result_list + + def _load_drive_groups(self) -> None: + stored_drive_group = self.get_store("drive_group_map") + self._drive_group_map: Dict[str, DriveGroupSpec] = {} + if stored_drive_group: + for name, dg in json.loads(stored_drive_group).items(): + try: + self._drive_group_map[name] = DriveGroupSpec.from_json(dg) + except ValueError as e: + self.log.error(f'Failed to load drive group {name} ({dg}): {e}') + + def _save_drive_groups(self) -> None: + json_drive_group_map = { + name: dg.to_json() for name, dg in self._drive_group_map.items() + } + self.set_store("drive_group_map", json.dumps(json_drive_group_map)) + + def remove_osds(self, + osd_ids: List[str], + replace: bool = False, + force: bool = False, + zap: bool = False, + no_destroy: bool = False) -> OrchResult[str]: + assert self._rook_cluster is not None + if zap: + raise RuntimeError("Rook does not support zapping devices during OSD removal.") + res = self._rook_cluster.remove_osds(osd_ids, replace, force, self.mon_command) + return OrchResult(res) + + def add_host_label(self, host: str, label: str) -> OrchResult[str]: + return self.rook_cluster.add_host_label(host, label) + + def remove_host_label(self, host: str, label: str, force: bool = False) -> OrchResult[str]: + return self.rook_cluster.remove_host_label(host, label) + """ + @handle_orch_error + def create_osds(self, drive_group): + # type: (DriveGroupSpec) -> str + # Creates OSDs from a drive group specification. + + # $: ceph orch osd create -i + + # The drivegroup file must only contain one spec at a time. + # + + targets = [] # type: List[str] + if drive_group.data_devices and drive_group.data_devices.paths: + targets += [d.path for d in drive_group.data_devices.paths] + if drive_group.data_directories: + targets += drive_group.data_directories + + all_hosts = raise_if_exception(self.get_hosts()) + + matching_hosts = drive_group.placement.filter_matching_hosts(lambda label=None, as_hostspec=None: all_hosts) + + assert len(matching_hosts) == 1 + + if not self.rook_cluster.node_exists(matching_hosts[0]): + raise RuntimeError("Node '{0}' is not in the Kubernetes " + "cluster".format(matching_hosts)) + + # Validate whether cluster CRD can accept individual OSD + # creations (i.e. not useAllDevices) + if not self.rook_cluster.can_create_osd(): + raise RuntimeError("Rook cluster configuration does not " + "support OSD creation.") + + return self.rook_cluster.add_osds(drive_group, matching_hosts) + + # TODO: this was the code to update the progress reference: + + @handle_orch_error + def has_osds(matching_hosts: List[str]) -> bool: + + # Find OSD pods on this host + pod_osd_ids = set() + pods = self.k8s.list_namespaced_pod(self._rook_env.namespace, + label_selector="rook_cluster={},app=rook-ceph-osd".format(self._rook_env.cluster_name), + field_selector="spec.nodeName={0}".format( + matching_hosts[0] + )).items + for p in pods: + pod_osd_ids.add(int(p.metadata.labels['ceph-osd-id'])) + + self.log.debug('pod_osd_ids={0}'.format(pod_osd_ids)) + + found = [] + osdmap = self.get("osd_map") + for osd in osdmap['osds']: + osd_id = osd['osd'] + if osd_id not in pod_osd_ids: + continue + + metadata = self.get_metadata('osd', "%s" % osd_id) + if metadata and metadata['devices'] in targets: + found.append(osd_id) + else: + self.log.info("ignoring osd {0} {1}".format( + osd_id, metadata['devices'] if metadata else 'DNE' + )) + + return found is not None + """ + + @handle_orch_error + def blink_device_light(self, ident_fault: str, on: bool, locs: List[orchestrator.DeviceLightLoc]) -> List[str]: + return self.rook_cluster.blink_light(ident_fault, on, locs) diff --git a/src/pybind/mgr/rook/requirements.txt b/src/pybind/mgr/rook/requirements.txt new file mode 100644 index 000000000..378de08e6 --- /dev/null +++ b/src/pybind/mgr/rook/requirements.txt @@ -0,0 +1,2 @@ +kubernetes +jsonpatch \ No newline at end of file diff --git a/src/pybind/mgr/rook/rook-client-python/.github/workflows/generate.yml b/src/pybind/mgr/rook/rook-client-python/.github/workflows/generate.yml new file mode 100644 index 000000000..97ac5a222 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/.github/workflows/generate.yml @@ -0,0 +1,21 @@ +name: Python application + +on: [push, pull_request] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: Set up Python 3.8 + uses: actions/setup-python@v1 + with: + python-version: 3.8 + - name: clone rook + run: | + git clone --depth 1 https://github.com/rook/rook.git + - name: Run generate.sh + run: | + ./generate.sh $PWD/rook diff --git a/src/pybind/mgr/rook/rook-client-python/.gitignore b/src/pybind/mgr/rook/rook-client-python/.gitignore new file mode 100644 index 000000000..b0eb1b49c --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/.gitignore @@ -0,0 +1,12 @@ +.coverage +.eggs/ +.idea/ +.mypy_cache/ +rook_client.egg-info/ +venv/ +downloads/ +__pycache__ +*.pyc +rook_client/tests/test_README.py +.tox +wheelhouse/ diff --git a/src/pybind/mgr/rook/rook-client-python/LICENSE b/src/pybind/mgr/rook/rook-client-python/LICENSE new file mode 100644 index 000000000..8e8487438 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2016 The Rook Authors. All rights reserved. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/src/pybind/mgr/rook/rook-client-python/README.md b/src/pybind/mgr/rook/rook-client-python/README.md new file mode 100644 index 000000000..1ff4ba077 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/README.md @@ -0,0 +1,81 @@ +# `rook-client` Python API Classes + +The Rook CRDs are evolving over time and to verify that clients make use of the correct definitions, +this project provides generated API classes to let users write correct clients easily. + +Right now, it supports three operators: + +* Ceph +* Edgefs +* Cassandra + +It is used to type check client code against the Rook API using [mypy](mypy-lang.org). + +Inspired by [kubernetes-client/python](https://github.com/kubernetes-client/python/tree/master/kubernetes/client/models) + +Main uses case is the mgr/rook orchestrator module of the Ceph MGR + +## Code Generation + +This project contains a `generate_model_classes.py` which can generate +model classes from Kubernetes CRDs and is **independent** of Rook. + +Usage: + +``` +python generate_model_classes.py +``` + +## Installing `rook-client` + +To install `rook-client`, run: + +```bash +pip install -e 'git+https://github.com/ceph/rook-client-python#egg=rook-client' +``` + + +## Usage + +```python +def objectstore(api_name, name, namespace, instances): + from rook_client.ceph import cephobjectstore as cos + rook_os = cos.CephObjectStore( + apiVersion=api_name, + metadata=dict( + name=name, + namespace=namespace + ), + spec=cos.Spec( + metadataPool=cos.MetadataPool( + failureDomain='host', + replicated=cos.Replicated( + size=1 + ) + ), + dataPool=cos.DataPool( + failureDomain='osd', + replicated=cos.Replicated( + size=1 + ) + ), + gateway=cos.Gateway( + port=80, + instances=instances + ) + ) + ) + return rook_os.to_json() +``` + +## Demo + +![](rook-python-client-demo.gif) + +## Regenerate + +To re-generate the python files, run + +```bash +./generate.sh +``` diff --git a/src/pybind/mgr/rook/rook-client-python/conftest.py b/src/pybind/mgr/rook/rook-client-python/conftest.py new file mode 100644 index 000000000..77d6eb358 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/conftest.py @@ -0,0 +1,11 @@ +import pytest + +def pytest_addoption(parser): + parser.addoption( + "--crd_base", action="store", help="base path to the crd yamls" + ) + + +@pytest.fixture +def crd_base(request): + return request.config.getoption("--crd_base") diff --git a/src/pybind/mgr/rook/rook-client-python/generate.sh b/src/pybind/mgr/rook/rook-client-python/generate.sh new file mode 100755 index 000000000..f7de74aeb --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/generate.sh @@ -0,0 +1,35 @@ +#!/bin/bash + +set -ex + +if [ -z "$1" ] ; then + rook_base="${GOPATH:-$HOME/go}/src/github.com/rook/rook" +else + rook_base="$1" +fi +crd_base="$rook_base/cluster/examples/kubernetes" + +cd "$(dirname "$0")" + +if ! [ -x "$(command -v python3)" ]; then + echo 'Error: python3 is not installed.' >&2 + exit 1 +fi + +if [ ! -d venv ] +then + python3 -m venv venv + . venv/bin/activate + pip install -r requirements.txt +else + . venv/bin/activate +fi + +python generate_model_classes.py "$crd_base/ceph/crds.yaml" "rook_client/ceph" +#python generate_model_classes.py "$crd_base/cassandra/operator.yaml" "rook_client/cassandra" + +python setup.py develop + +tox --skip-missing-interpreters=true -- --crd_base="$crd_base" + +deactivate diff --git a/src/pybind/mgr/rook/rook-client-python/generate_model_classes.py b/src/pybind/mgr/rook/rook-client-python/generate_model_classes.py new file mode 100644 index 000000000..110995bad --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/generate_model_classes.py @@ -0,0 +1,402 @@ +""" +Generate Python files containing data Python models classes for +all properties of the all CRDs in the file + +**Note**: generate_model_classes.py is independent of Rook or Ceph. It can be used for all + CRDs. + +For example: + python3 -m venv venv + pip install -r requirements.txt + python generate_model_classes.py + python setup.py develop + +Usage: + generate_model_classes.py +""" +import os +from abc import ABC, abstractmethod +from collections import OrderedDict +from typing import List, Union, Iterator, Optional, Dict, TypeVar, Callable +import copy + +import yaml +try: + from dataclasses import dataclass +except ImportError: + from attr import dataclass # type: ignore + +T = TypeVar('T') +K = TypeVar('K') + +header = '''""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +''' + +@dataclass # type: ignore +class CRDBase(ABC): + name: str + nullable: bool + required: bool + + @property + def py_name(self): + if self.name == 'exec': + return 'exec_1' + return self.name.replace('-', '_') + + @property + @abstractmethod + def py_type(self): + ... + + @property + def py_type_escaped(self): + return self.py_type + + + @abstractmethod + def flatten(self) -> Iterator[Union['CRDClass', 'CRDList', 'CRDAttribute']]: + ... + + @abstractmethod + def toplevel(self) -> str: + ... + + def py_property(self): + return f""" +@property +def {self.py_name}(self): + # type: () -> {self.py_property_return_type} + return self._property_impl('{self.py_name}') + +@{self.py_name}.setter +def {self.py_name}(self, new_val): + # type: ({self.py_param_type}) -> None + self._{self.py_name} = new_val + """.strip() + + @property + def py_param(self): + if not self.has_default: + return f'{self.py_name}, # type: {self.py_param_type}' + return f'{self.py_name}=_omit, # type: {self.py_param_type}' + + @property + def has_default(self): + return not self.required + + @property + def py_param_type(self): + return f'Optional[{self.py_type}]' if (self.nullable or not self.required) else self.py_type + + @property + def py_property_return_type(self): + return f'Optional[{self.py_type}]' if (self.nullable) else self.py_type + +@dataclass +class CRDAttribute(CRDBase): + type: str + default_value: str='_omit' + + @property + def py_param(self): + if not self.has_default: + return f'{self.py_name}, # type: {self.py_param_type}' + return f'{self.py_name}={self.default_value}, # type: {self.py_param_type}' + + @property + def has_default(self): + return not self.required or self.default_value != '_omit' + + @property + def py_type(self): + return { + 'integer': 'int', + 'boolean': 'bool', + 'string': 'str', + 'object': 'Any', + 'number': 'float', + 'x-kubernetes-int-or-string': 'Union[int, str]', + }[self.type] + + def flatten(self) -> Iterator[Union['CRDClass', 'CRDList', 'CRDAttribute']]: + yield from () + + def toplevel(self): + return '' + + def __hash__(self): + return hash(repr(self)) + + +@dataclass +class CRDList(CRDBase): + items: 'CRDClass' + + @property + def py_name(self): + return self.name + + @property + def py_type(self): + return self.name[0].upper() + self.name[1:] + 'List' + + @property + def py_type_escaped(self): + return f"'{self.py_type}'" + + @property + def py_param_type(self): + inner = f'Union[List[{self.items.py_type}], CrdObjectList]' + return f'Optional[{inner}]' if (self.nullable or not self.required) else inner + + @property + def py_property_return_type(self): + inner = f'Union[List[{self.items.py_type}], CrdObjectList]' + return f'Optional[{inner}]' if (self.nullable) else inner + + def flatten(self) -> Iterator[Union['CRDClass', 'CRDList', 'CRDAttribute']]: + yield from self.items.flatten() + yield self + + def toplevel(self): + py_type = self.items.py_type + if py_type == 'Any': + py_type = 'None' + + return f""" +class {self.py_type}(CrdObjectList): +{indent('_items_type = ' + py_type)} +""".strip() + + def __eq__(self, other): + if type(self) != type(other): + return False + return self.toplevel() == other.toplevel() + + def __hash__(self): + return hash(self.toplevel()) + + +@dataclass +class CRDClass(CRDBase): + attrs: List[Union[CRDAttribute, 'CRDClass']] + base_class: str = 'CrdObject' + + def toplevel(self) -> str: + ps = '\n\n'.join(a.py_property() for a in self.attrs) + return f"""class {self.py_type}({self.base_class}): +{indent(self.py_properties())} + +{indent(self.py_init())} + +{indent(ps)} +""".strip() + + @property + def sub_classes(self) -> List["CRDClass"]: + return [a for a in self.attrs if isinstance(a, CRDClass)] + + @property + def py_type(self): + return self.name[0].upper() + self.name[1:] + + @property + def py_type_escaped(self): + return f"'{self.py_type}'" + + + def py_properties(self): + def a_to_tuple(a): + return ', '.join((f"'{a.name}'", + f"'{a.py_name}'", + a.py_type_escaped.replace('Any', 'object'), + str(a.required), + str(a.nullable))) + + attrlist = ',\n'.join([f'({a_to_tuple(a)})' for a in self.attrs]) + return f"""_properties = [\n{indent(attrlist)}\n]""" + + def flatten(self) -> Iterator[Union['CRDClass', 'CRDList', 'CRDAttribute']]: + for sub_cls in self.attrs: + yield from sub_cls.flatten() + yield self + + def py_init(self): + sorted_attrs = sorted(self.attrs, key=lambda a: a.has_default) + params = '\n'.join(a.py_param for a in sorted_attrs) + params_set = '\n'.join(f'{a.py_name}={a.py_name},' for a in sorted_attrs) + return f""" +def __init__(self, +{indent(params, indent=4+9)} + ): + super({self.py_type}, self).__init__( +{indent(params_set, indent=8)} + ) +""".strip() + + def __eq__(self, other): + if type(self) != type(other): + return False + return self.toplevel() == other.toplevel() + + def __hash__(self): + return hash(self.toplevel()) + + +def indent(s, indent=4): + return '\n'.join(' '*indent + l for l in s.splitlines()) + + +def handle_property(elem_name, elem: dict, required: bool): + nullable = elem.get('nullable', False) + if 'properties' in elem: + ps = elem['properties'] + required_elems = elem.get('required', []) + sub_props = [handle_property(k, v, k in required_elems) for k, v in ps.items()] + return CRDClass(elem_name, nullable, required, sub_props) + elif 'items' in elem: + item = handle_property(elem_name + 'Item', elem['items'], False) + return CRDList(elem_name, nullable, required, item) + elif 'type' in elem: + return CRDAttribute(elem_name, nullable, required, elem['type']) + elif elem == {}: + return CRDAttribute(elem_name, nullable, required, 'object') + elif 'x-kubernetes-int-or-string' in elem: + return CRDAttribute(elem_name, nullable, required, 'x-kubernetes-int-or-string') + + assert False, str((elem_name, elem)) + +def spec_get_schema(c_dict: Dict) -> Dict: + try: + return c_dict['spec']['validation']['openAPIV3Schema'] + except (KeyError, TypeError): + pass + versions = c_dict['spec']['versions'] + if len(versions) != 1: + raise RuntimeError(f'todo: {[v["name"] for v in versions]}') + return c_dict['spec']['versions'][0]["schema"]['openAPIV3Schema'] + +def handle_crd(c_dict: dict) -> Optional[CRDClass]: + try: + name = c_dict['spec']['names']['kind'] + s = spec_get_schema(c_dict) + except (KeyError, TypeError): + return None + s['required'] = ['spec'] + c = handle_property(name, s, True) + if 'apiVersion' not in [a.name for a in c.attrs]: + c.attrs.append(CRDAttribute('apiVersion', False, True, 'string')) + if 'metadata' not in [a.name for a in c.attrs]: + c.attrs.append(CRDAttribute('metadata', False, True, 'object')) + if 'status' not in [a.name for a in c.attrs]: + c.attrs.append(CRDAttribute('status', False, False, 'object')) + return CRDClass(c.name, False, True, c.attrs, base_class='CrdClass') + + +def local(yaml_filename): + with open(yaml_filename) as f: + yamls = yaml.safe_load_all(f.read()) + for y in yamls: + try: + yield y + except AttributeError: + pass + + +def remove_duplicates_by(items: List[T], key: Callable[[T], K], unify: Callable[[T, T], T]) -> List[T]: + res: OrderedDict[K, T] = OrderedDict() + for i in items: + k = key(i) + if k in res: + res[k] = unify(res[k], i) + else: + res[k] = i + return list(res.values()) + + +def remove_duplicates(items: List[T]) -> List[T]: + return list(OrderedDict.fromkeys(items).keys()) + + +def unify_classes(left: CRDBase, right: CRDBase) -> CRDBase: + assert left.name == right.name + + if isinstance(left, CRDClass) and isinstance(right, CRDClass): + assert left.py_type == right.py_type + assert left.base_class == right.base_class + ret = CRDClass( + name=left.name, + nullable=left.nullable or right.nullable, + required=False, + attrs=remove_duplicates_by(right.attrs + left.attrs, lambda a: a.name, unify_classes), # type: ignore + base_class=left.base_class + ) + for a in ret.attrs: + # we have to set all required properties to False + a.required = False + return ret + + elif isinstance(left, CRDAttribute) and isinstance(right, CRDAttribute): + assert left.type == right.type + assert left.name == right.name + assert left.default_value == right.default_value + return CRDAttribute( + name=left.name, + nullable=left.nullable or right.nullable, + required=False, + type=left.type, + default_value=left.default_value + ) + elif type(left) != type(right): + # handwaving + return CRDAttribute( + name=left.name, + nullable=left.nullable or right.nullable, + required=False, + type='object' + ) + else: + assert left == right, (repr(left), repr(right)) + return left + + +def get_toplevels(crd: CRDBase) -> List[str]: + elems: List[CRDBase] = remove_duplicates(list(crd.flatten())) + res = remove_duplicates_by(elems, lambda c: c.py_type, unify_classes) + return [e.toplevel() for e in res] + + +def main(yaml_filename, outfolder): + for crd in local(yaml_filename): + valid_crd = handle_crd(crd) + if valid_crd is not None: + try: + os.mkdir(outfolder) + except FileExistsError: + pass + open(f'{outfolder}/__init__.py', 'w').close() + + with open(f'{outfolder}/{valid_crd.name.lower()}.py', 'w') as f: + f.write(header) + classes = get_toplevels(valid_crd) + f.write('\n\n\n'.join(classes)) + f.write('\n') + + +if __name__ == '__main__': + from docopt import docopt + args = docopt(__doc__) + yaml_filename = '/dev/stdin' if args[""] == '-' else args[""] + main(yaml_filename, args[""]) \ No newline at end of file diff --git a/src/pybind/mgr/rook/rook-client-python/mypy.ini b/src/pybind/mgr/rook/rook-client-python/mypy.ini new file mode 100644 index 000000000..cd26ff97e --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/mypy.ini @@ -0,0 +1,7 @@ +[mypy] +strict_optional = True +no_implicit_optional = True +ignore_missing_imports = True +warn_incomplete_stub = True +check_untyped_defs = True +show_error_context = True diff --git a/src/pybind/mgr/rook/rook-client-python/requirements.txt b/src/pybind/mgr/rook/rook-client-python/requirements.txt new file mode 100644 index 000000000..b94f3424c --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/requirements.txt @@ -0,0 +1,7 @@ +pytest +requests +pyyaml +markdown +-e git+https://github.com/ryneeverett/mkcodes.git@8b073b6ca0773008ca2a06ffd1c22b2c1fc1cce4#egg=mkcodes +docopt +tox diff --git a/src/pybind/mgr/rook/rook-client-python/rook-python-client-demo.gif b/src/pybind/mgr/rook/rook-client-python/rook-python-client-demo.gif new file mode 100644 index 000000000..0a9139a13 Binary files /dev/null and b/src/pybind/mgr/rook/rook-client-python/rook-python-client-demo.gif differ diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/__init__.py new file mode 100644 index 000000000..3fa2272dd --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/__init__.py @@ -0,0 +1 @@ +from ._helper import STRICT \ No newline at end of file diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py new file mode 100644 index 000000000..382d04c27 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py @@ -0,0 +1,128 @@ +import logging +import sys +try: + from typing import List, Dict, Any, Optional +except ImportError: + pass + +logger = logging.getLogger(__name__) + +# Tricking mypy to think `_omit`'s type is NoneType +# To make us not add things like `Union[Optional[str], OmitType]` +NoneType = type(None) +_omit = None # type: NoneType +_omit = object() # type: ignore + + +# Don't add any additionalProperties to objects. Useful for completeness testing +STRICT = False + +def _str_to_class(cls, typ_str): + if isinstance(typ_str, str): + return getattr(sys.modules[cls.__module__], typ_str) + return typ_str + + +def _property_from_json(cls, data, breadcrumb, name, py_name, typ_str, required, nullable): + if not required and name not in data: + return _omit + try: + obj = data[name] + except KeyError as e: + raise ValueError('KeyError in {}: {}'.format(breadcrumb, e)) + if nullable and obj is None: + return obj + typ = _str_to_class(cls, typ_str) + if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList): + return typ.from_json(obj, breadcrumb + '.' + name) + return obj + + +class CrdObject(object): + _properties = [] # type: List + + def __init__(self, **kwargs): + for prop in self._properties: + setattr(self, prop[1], kwargs.pop(prop[1])) + if kwargs: + raise TypeError( + '{} got unexpected arguments {}'.format(self.__class__.__name__, kwargs.keys())) + self._additionalProperties = {} # type: Dict[str, Any] + + def _property_impl(self, name): + obj = getattr(self, '_' + name) + if obj is _omit: + raise AttributeError(name + ' not found') + return obj + + def _property_to_json(self, name, py_name, typ_str, required, nullable): + obj = getattr(self, '_' + py_name) + typ = _str_to_class(self.__class__, typ_str) + if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList): + if nullable and obj is None: + return obj + if not required and obj is _omit: + return obj + return obj.to_json() + else: + return obj + + def to_json(self): + # type: () -> Dict[str, Any] + res = {p[0]: self._property_to_json(*p) for p in self._properties} + res.update(self._additionalProperties) + return {k: v for k, v in res.items() if v is not _omit} + + @classmethod + def from_json(cls, data, breadcrumb=''): + try: + sanitized = { + p[1]: _property_from_json(cls, data, breadcrumb, *p) for p in cls._properties + } + extra = {k:v for k,v in data.items() if k not in sanitized} + ret = cls(**sanitized) + ret._additionalProperties = {} if STRICT else extra + return ret + except (TypeError, AttributeError, KeyError): + logger.exception(breadcrumb) + raise + + +class CrdClass(CrdObject): + @classmethod + def from_json(cls, data, breadcrumb=''): + kind = data['kind'] + if kind != cls.__name__: + raise ValueError("kind mismatch: {} != {}".format(kind, cls.__name__)) + return super(CrdClass, cls).from_json(data, breadcrumb) + + def to_json(self): + ret = super(CrdClass, self).to_json() + ret['kind'] = self.__class__.__name__ + return ret + + +class CrdObjectList(list): + # Py3: Replace `Any` with `TypeVar('T_CrdObject', bound='CrdObject')` + _items_type = None # type: Optional[Any] + + def to_json(self): + # type: () -> List + if self._items_type is None: + return self + if issubclass(self._items_type, CrdObject) or issubclass(self._items_type, CrdObjectList): + return [e.to_json() for e in self] + return list(self) + + + @classmethod + def from_json(cls, data, breadcrumb=''): + if cls._items_type is None: + return cls(data) + if issubclass(cls._items_type, CrdObject) or issubclass(cls._items_type, CrdObjectList): + return cls(cls._items_type.from_json(e, breadcrumb + '[{}]'.format(i)) for i, e in enumerate(data)) + return cls(data) + + def __repr__(self): + return '{}({})'.format(self.__class__.__name__, repr(list(self))) + diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py.orig b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py.orig new file mode 100644 index 000000000..73ea7370f --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/_helper.py.orig @@ -0,0 +1,133 @@ +import logging +import sys +try: + from typing import List, Dict, Any, Optional +except ImportError: + pass + +logger = logging.getLogger(__name__) + +# Tricking mypy to think `_omit`'s type is NoneType +# To make us not add things like `Union[Optional[str], OmitType]` +NoneType = type(None) +_omit = None # type: NoneType +_omit = object() # type: ignore + + +# Don't add any additionalProperties to objects. Useful for completeness testing +STRICT = False + +def _str_to_class(cls, typ_str): + if isinstance(typ_str, str): + return getattr(sys.modules[cls.__module__], typ_str) + return typ_str + + +def _property_from_json(cls, data, breadcrumb, name, py_name, typ_str, required, nullable): + if not required and name not in data: + return _omit + try: + obj = data[name] + except KeyError as e: + raise ValueError('KeyError in {}: {}'.format(breadcrumb, e)) + if nullable and obj is None: + return obj + typ = _str_to_class(cls, typ_str) + if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList): + return typ.from_json(obj, breadcrumb + '.' + name) + return obj + + +class CrdObject(object): + _properties = [] # type: List + + def __init__(self, **kwargs): + for prop in self._properties: + setattr(self, prop[1], kwargs.pop(prop[1])) + if kwargs: + raise TypeError( + '{} got unexpected arguments {}'.format(self.__class__.__name__, kwargs.keys())) + self._additionalProperties = {} # type: Dict[str, Any] + + def _property_impl(self, name): + obj = getattr(self, '_' + name) + if obj is _omit: + raise AttributeError(name + ' not found') + return obj + + def _property_to_json(self, name, py_name, typ_str, required, nullable): + obj = getattr(self, '_' + py_name) + typ = _str_to_class(self.__class__, typ_str) + if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList): + if nullable and obj is None: + return obj + if not required and obj is _omit: + return obj + return obj.to_json() + else: + return obj + + def to_json(self): + # type: () -> Dict[str, Any] + res = {p[0]: self._property_to_json(*p) for p in self._properties} + res.update(self._additionalProperties) + return {k: v for k, v in res.items() if v is not _omit} + + @classmethod + def from_json(cls, data, breadcrumb=''): + try: + sanitized = { + p[1]: _property_from_json(cls, data, breadcrumb, *p) for p in cls._properties + } + extra = {k:v for k,v in data.items() if k not in sanitized} + ret = cls(**sanitized) + ret._additionalProperties = {} if STRICT else extra + return ret + except (TypeError, AttributeError, KeyError): + logger.exception(breadcrumb) + raise + + +class CrdClass(CrdObject): + @classmethod + def from_json(cls, data, breadcrumb=''): + kind = data['kind'] + if kind != cls.__name__: + raise ValueError("kind mismatch: {} != {}".format(kind, cls.__name__)) + return super(CrdClass, cls).from_json(data, breadcrumb) + + def to_json(self): + ret = super(CrdClass, self).to_json() + ret['kind'] = self.__class__.__name__ + return ret + + +class CrdObjectList(list): + # Py3: Replace `Any` with `TypeVar('T_CrdObject', bound='CrdObject')` + _items_type = None # type: Optional[Any] + + def to_json(self): + # type: () -> List + if self._items_type is None: + return self + if issubclass(self._items_type, CrdObject) or issubclass(self._items_type, CrdObjectList): + return [e.to_json() for e in self] + return list(self) + + + @classmethod + def from_json(cls, data, breadcrumb=''): + if cls._items_type is None: + return cls(data) + if issubclass(cls._items_type, CrdObject) or issubclass(cls._items_type, CrdObjectList): +<<<<<<< HEAD + return cls(cls._items_type.from_json(e, breadcrumb + '[]') for e in data) + return cls(data) + + def __repr__(self): + return '{}({})'.format(self.__class__.__name__, repr(list(self))) +======= + return cls(cls._items_type.from_json(e, breadcrumb + '[{}]'.format(i)) for i, e in enumerate(data)) + return data +>>>>>>> 2e4a0b5 (Better ex message for missing required elements) + diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/cluster.py b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/cluster.py new file mode 100644 index 000000000..4fa3afc61 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/cluster.py @@ -0,0 +1,317 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Storage(CrdObject): + _properties = [ + ('volumeClaimTemplates', 'volumeClaimTemplates', object, True, False) + ] + + def __init__(self, + volumeClaimTemplates, # type: Any + ): + super(Storage, self).__init__( + volumeClaimTemplates=volumeClaimTemplates, + ) + + @property + def volumeClaimTemplates(self): + # type: () -> Any + return self._property_impl('volumeClaimTemplates') + + @volumeClaimTemplates.setter + def volumeClaimTemplates(self, new_val): + # type: (Any) -> None + self._volumeClaimTemplates = new_val + + +class Resources(CrdObject): + _properties = [ + ('cassandra', 'cassandra', object, True, False), + ('sidecar', 'sidecar', object, True, False) + ] + + def __init__(self, + cassandra, # type: Any + sidecar, # type: Any + ): + super(Resources, self).__init__( + cassandra=cassandra, + sidecar=sidecar, + ) + + @property + def cassandra(self): + # type: () -> Any + return self._property_impl('cassandra') + + @cassandra.setter + def cassandra(self, new_val): + # type: (Any) -> None + self._cassandra = new_val + + @property + def sidecar(self): + # type: () -> Any + return self._property_impl('sidecar') + + @sidecar.setter + def sidecar(self, new_val): + # type: (Any) -> None + self._sidecar = new_val + + +class Racks(CrdObject): + _properties = [ + ('name', 'name', str, True, False), + ('members', 'members', int, True, False), + ('configMapName', 'configMapName', str, False, False), + ('jmxExporterConfigMapName', 'jmxExporterConfigMapName', str, False, False), + ('storage', 'storage', Storage, True, False), + ('placement', 'placement', object, False, False), + ('resources', 'resources', Resources, True, False), + ('sidecarImage', 'sidecarImage', object, False, False) + ] + + def __init__(self, + name, # type: str + members, # type: int + storage, # type: Storage + resources, # type: Resources + configMapName=_omit, # type: Optional[str] + jmxExporterConfigMapName=_omit, # type: Optional[str] + placement=_omit, # type: Optional[Any] + sidecarImage=_omit, # type: Optional[Any] + ): + super(Racks, self).__init__( + name=name, + members=members, + storage=storage, + resources=resources, + configMapName=configMapName, + jmxExporterConfigMapName=jmxExporterConfigMapName, + placement=placement, + sidecarImage=sidecarImage, + ) + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (str) -> None + self._name = new_val + + @property + def members(self): + # type: () -> int + return self._property_impl('members') + + @members.setter + def members(self, new_val): + # type: (int) -> None + self._members = new_val + + @property + def configMapName(self): + # type: () -> str + return self._property_impl('configMapName') + + @configMapName.setter + def configMapName(self, new_val): + # type: (Optional[str]) -> None + self._configMapName = new_val + + @property + def jmxExporterConfigMapName(self): + # type: () -> str + return self._property_impl('jmxExporterConfigMapName') + + @jmxExporterConfigMapName.setter + def jmxExporterConfigMapName(self, new_val): + # type: (Optional[str]) -> None + self._jmxExporterConfigMapName = new_val + + @property + def storage(self): + # type: () -> Storage + return self._property_impl('storage') + + @storage.setter + def storage(self, new_val): + # type: (Storage) -> None + self._storage = new_val + + @property + def placement(self): + # type: () -> Any + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Any]) -> None + self._placement = new_val + + @property + def resources(self): + # type: () -> Resources + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Resources) -> None + self._resources = new_val + + @property + def sidecarImage(self): + # type: () -> Any + return self._property_impl('sidecarImage') + + @sidecarImage.setter + def sidecarImage(self, new_val): + # type: (Optional[Any]) -> None + self._sidecarImage = new_val + + +class Datacenter(CrdObject): + _properties = [ + ('name', 'name', str, True, False), + ('racks', 'racks', Racks, False, False) + ] + + def __init__(self, + name, # type: str + racks=_omit, # type: Optional[Racks] + ): + super(Datacenter, self).__init__( + name=name, + racks=racks, + ) + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (str) -> None + self._name = new_val + + @property + def racks(self): + # type: () -> Racks + return self._property_impl('racks') + + @racks.setter + def racks(self, new_val): + # type: (Optional[Racks]) -> None + self._racks = new_val + + +class Spec(CrdObject): + _properties = [ + ('version', 'version', str, True, False), + ('datacenter', 'datacenter', Datacenter, True, False) + ] + + def __init__(self, + version, # type: str + datacenter, # type: Datacenter + ): + super(Spec, self).__init__( + version=version, + datacenter=datacenter, + ) + + @property + def version(self): + # type: () -> str + return self._property_impl('version') + + @version.setter + def version(self, new_val): + # type: (str) -> None + self._version = new_val + + @property + def datacenter(self): + # type: () -> Datacenter + return self._property_impl('datacenter') + + @datacenter.setter + def datacenter(self, new_val): + # type: (Datacenter) -> None + self._datacenter = new_val + + +class Cluster(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, True, False), + ('metadata', 'metadata', object, True, False), + ('status', 'status', object, False, False), + ('spec', 'spec', Spec, True, False) + ] + + def __init__(self, + apiVersion, # type: str + metadata, # type: Any + spec, # type: Spec + status=_omit, # type: Optional[Any] + ): + super(Cluster, self).__init__( + apiVersion=apiVersion, + metadata=metadata, + spec=spec, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (str) -> None + self._apiVersion = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Any) -> None + self._metadata = new_val + + @property + def status(self): + # type: () -> Any + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Any]) -> None + self._status = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephblockpool.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephblockpool.py new file mode 100644 index 000000000..34e953eac --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephblockpool.py @@ -0,0 +1,1193 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class ErasureCoded(CrdObject): + _properties = [ + ('algorithm', 'algorithm', str, False, False), + ('codingChunks', 'codingChunks', int, True, False), + ('dataChunks', 'dataChunks', int, True, False) + ] + + def __init__(self, + codingChunks, # type: int + dataChunks, # type: int + algorithm=_omit, # type: Optional[str] + ): + super(ErasureCoded, self).__init__( + codingChunks=codingChunks, + dataChunks=dataChunks, + algorithm=algorithm, + ) + + @property + def algorithm(self): + # type: () -> str + return self._property_impl('algorithm') + + @algorithm.setter + def algorithm(self, new_val): + # type: (Optional[str]) -> None + self._algorithm = new_val + + @property + def codingChunks(self): + # type: () -> int + return self._property_impl('codingChunks') + + @codingChunks.setter + def codingChunks(self, new_val): + # type: (int) -> None + self._codingChunks = new_val + + @property + def dataChunks(self): + # type: () -> int + return self._property_impl('dataChunks') + + @dataChunks.setter + def dataChunks(self, new_val): + # type: (int) -> None + self._dataChunks = new_val + + +class SnapshotSchedulesItem(CrdObject): + _properties = [ + ('image', 'image', str, False, False), + ('items', 'items', 'ItemsList', False, False), + ('namespace', 'namespace', str, False, False), + ('pool', 'pool', str, False, False), + ('interval', 'interval', str, False, False), + ('startTime', 'startTime', str, False, False) + ] + + def __init__(self, + image=_omit, # type: Optional[str] + items=_omit, # type: Optional[Union[List[ItemsItem], CrdObjectList]] + namespace=_omit, # type: Optional[str] + pool=_omit, # type: Optional[str] + interval=_omit, # type: Optional[str] + startTime=_omit, # type: Optional[str] + ): + super(SnapshotSchedulesItem, self).__init__( + image=image, + items=items, + namespace=namespace, + pool=pool, + interval=interval, + startTime=startTime, + ) + + @property + def image(self): + # type: () -> str + return self._property_impl('image') + + @image.setter + def image(self, new_val): + # type: (Optional[str]) -> None + self._image = new_val + + @property + def items(self): + # type: () -> Union[List[ItemsItem], CrdObjectList] + return self._property_impl('items') + + @items.setter + def items(self, new_val): + # type: (Optional[Union[List[ItemsItem], CrdObjectList]]) -> None + self._items = new_val + + @property + def namespace(self): + # type: () -> str + return self._property_impl('namespace') + + @namespace.setter + def namespace(self, new_val): + # type: (Optional[str]) -> None + self._namespace = new_val + + @property + def pool(self): + # type: () -> str + return self._property_impl('pool') + + @pool.setter + def pool(self, new_val): + # type: (Optional[str]) -> None + self._pool = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def startTime(self): + # type: () -> str + return self._property_impl('startTime') + + @startTime.setter + def startTime(self, new_val): + # type: (Optional[str]) -> None + self._startTime = new_val + + +class SnapshotSchedulesList(CrdObjectList): + _items_type = SnapshotSchedulesItem + + +class Mirroring(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('mode', 'mode', str, False, False), + ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + mode=_omit, # type: Optional[str] + snapshotSchedules=_omit, # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]] + ): + super(Mirroring, self).__init__( + enabled=enabled, + mode=mode, + snapshotSchedules=snapshotSchedules, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def mode(self): + # type: () -> str + return self._property_impl('mode') + + @mode.setter + def mode(self, new_val): + # type: (Optional[str]) -> None + self._mode = new_val + + @property + def snapshotSchedules(self): + # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList] + return self._property_impl('snapshotSchedules') + + @snapshotSchedules.setter + def snapshotSchedules(self, new_val): + # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None + self._snapshotSchedules = new_val + + +class Quotas(CrdObject): + _properties = [ + ('maxBytes', 'maxBytes', int, False, False), + ('maxObjects', 'maxObjects', int, False, False), + ('maxSize', 'maxSize', str, False, False) + ] + + def __init__(self, + maxBytes=_omit, # type: Optional[int] + maxObjects=_omit, # type: Optional[int] + maxSize=_omit, # type: Optional[str] + ): + super(Quotas, self).__init__( + maxBytes=maxBytes, + maxObjects=maxObjects, + maxSize=maxSize, + ) + + @property + def maxBytes(self): + # type: () -> int + return self._property_impl('maxBytes') + + @maxBytes.setter + def maxBytes(self, new_val): + # type: (Optional[int]) -> None + self._maxBytes = new_val + + @property + def maxObjects(self): + # type: () -> int + return self._property_impl('maxObjects') + + @maxObjects.setter + def maxObjects(self, new_val): + # type: (Optional[int]) -> None + self._maxObjects = new_val + + @property + def maxSize(self): + # type: () -> str + return self._property_impl('maxSize') + + @maxSize.setter + def maxSize(self, new_val): + # type: (Optional[str]) -> None + self._maxSize = new_val + + +class Replicated(CrdObject): + _properties = [ + ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False), + ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False), + ('size', 'size', int, True, False), + ('subFailureDomain', 'subFailureDomain', str, False, False), + ('targetSizeRatio', 'targetSizeRatio', float, False, False) + ] + + def __init__(self, + size, # type: int + replicasPerFailureDomain=_omit, # type: Optional[int] + requireSafeReplicaSize=_omit, # type: Optional[bool] + subFailureDomain=_omit, # type: Optional[str] + targetSizeRatio=_omit, # type: Optional[float] + ): + super(Replicated, self).__init__( + size=size, + replicasPerFailureDomain=replicasPerFailureDomain, + requireSafeReplicaSize=requireSafeReplicaSize, + subFailureDomain=subFailureDomain, + targetSizeRatio=targetSizeRatio, + ) + + @property + def replicasPerFailureDomain(self): + # type: () -> int + return self._property_impl('replicasPerFailureDomain') + + @replicasPerFailureDomain.setter + def replicasPerFailureDomain(self, new_val): + # type: (Optional[int]) -> None + self._replicasPerFailureDomain = new_val + + @property + def requireSafeReplicaSize(self): + # type: () -> bool + return self._property_impl('requireSafeReplicaSize') + + @requireSafeReplicaSize.setter + def requireSafeReplicaSize(self, new_val): + # type: (Optional[bool]) -> None + self._requireSafeReplicaSize = new_val + + @property + def size(self): + # type: () -> int + return self._property_impl('size') + + @size.setter + def size(self, new_val): + # type: (int) -> None + self._size = new_val + + @property + def subFailureDomain(self): + # type: () -> str + return self._property_impl('subFailureDomain') + + @subFailureDomain.setter + def subFailureDomain(self, new_val): + # type: (Optional[str]) -> None + self._subFailureDomain = new_val + + @property + def targetSizeRatio(self): + # type: () -> float + return self._property_impl('targetSizeRatio') + + @targetSizeRatio.setter + def targetSizeRatio(self, new_val): + # type: (Optional[float]) -> None + self._targetSizeRatio = new_val + + +class Mirror(CrdObject): + _properties = [ + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Mirror, self).__init__( + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class StatusCheck(CrdObject): + _properties = [ + ('mirror', 'mirror', 'Mirror', False, True) + ] + + def __init__(self, + mirror=_omit, # type: Optional[Mirror] + ): + super(StatusCheck, self).__init__( + mirror=mirror, + ) + + @property + def mirror(self): + # type: () -> Optional[Mirror] + return self._property_impl('mirror') + + @mirror.setter + def mirror(self, new_val): + # type: (Optional[Mirror]) -> None + self._mirror = new_val + + +class Spec(CrdObject): + _properties = [ + ('compressionMode', 'compressionMode', str, False, True), + ('crushRoot', 'crushRoot', str, False, True), + ('deviceClass', 'deviceClass', str, False, True), + ('enableRBDStats', 'enableRBDStats', bool, False, False), + ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False), + ('failureDomain', 'failureDomain', str, False, False), + ('mirroring', 'mirroring', 'Mirroring', False, False), + ('parameters', 'parameters', object, False, True), + ('quotas', 'quotas', 'Quotas', False, True), + ('replicated', 'replicated', 'Replicated', False, False), + ('statusCheck', 'statusCheck', 'StatusCheck', False, False) + ] + + def __init__(self, + compressionMode=_omit, # type: Optional[str] + crushRoot=_omit, # type: Optional[str] + deviceClass=_omit, # type: Optional[str] + enableRBDStats=_omit, # type: Optional[bool] + erasureCoded=_omit, # type: Optional[ErasureCoded] + failureDomain=_omit, # type: Optional[str] + mirroring=_omit, # type: Optional[Mirroring] + parameters=_omit, # type: Optional[Any] + quotas=_omit, # type: Optional[Quotas] + replicated=_omit, # type: Optional[Replicated] + statusCheck=_omit, # type: Optional[StatusCheck] + ): + super(Spec, self).__init__( + compressionMode=compressionMode, + crushRoot=crushRoot, + deviceClass=deviceClass, + enableRBDStats=enableRBDStats, + erasureCoded=erasureCoded, + failureDomain=failureDomain, + mirroring=mirroring, + parameters=parameters, + quotas=quotas, + replicated=replicated, + statusCheck=statusCheck, + ) + + @property + def compressionMode(self): + # type: () -> Optional[str] + return self._property_impl('compressionMode') + + @compressionMode.setter + def compressionMode(self, new_val): + # type: (Optional[str]) -> None + self._compressionMode = new_val + + @property + def crushRoot(self): + # type: () -> Optional[str] + return self._property_impl('crushRoot') + + @crushRoot.setter + def crushRoot(self, new_val): + # type: (Optional[str]) -> None + self._crushRoot = new_val + + @property + def deviceClass(self): + # type: () -> Optional[str] + return self._property_impl('deviceClass') + + @deviceClass.setter + def deviceClass(self, new_val): + # type: (Optional[str]) -> None + self._deviceClass = new_val + + @property + def enableRBDStats(self): + # type: () -> bool + return self._property_impl('enableRBDStats') + + @enableRBDStats.setter + def enableRBDStats(self, new_val): + # type: (Optional[bool]) -> None + self._enableRBDStats = new_val + + @property + def erasureCoded(self): + # type: () -> ErasureCoded + return self._property_impl('erasureCoded') + + @erasureCoded.setter + def erasureCoded(self, new_val): + # type: (Optional[ErasureCoded]) -> None + self._erasureCoded = new_val + + @property + def failureDomain(self): + # type: () -> str + return self._property_impl('failureDomain') + + @failureDomain.setter + def failureDomain(self, new_val): + # type: (Optional[str]) -> None + self._failureDomain = new_val + + @property + def mirroring(self): + # type: () -> Mirroring + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def parameters(self): + # type: () -> Optional[Any] + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def quotas(self): + # type: () -> Optional[Quotas] + return self._property_impl('quotas') + + @quotas.setter + def quotas(self, new_val): + # type: (Optional[Quotas]) -> None + self._quotas = new_val + + @property + def replicated(self): + # type: () -> Replicated + return self._property_impl('replicated') + + @replicated.setter + def replicated(self, new_val): + # type: (Optional[Replicated]) -> None + self._replicated = new_val + + @property + def statusCheck(self): + # type: () -> StatusCheck + return self._property_impl('statusCheck') + + @statusCheck.setter + def statusCheck(self, new_val): + # type: (Optional[StatusCheck]) -> None + self._statusCheck = new_val + + +class PeersItem(CrdObject): + _properties = [ + ('client_name', 'client_name', str, False, False), + ('direction', 'direction', str, False, False), + ('mirror_uuid', 'mirror_uuid', str, False, False), + ('site_name', 'site_name', str, False, False), + ('uuid', 'uuid', str, False, False) + ] + + def __init__(self, + client_name=_omit, # type: Optional[str] + direction=_omit, # type: Optional[str] + mirror_uuid=_omit, # type: Optional[str] + site_name=_omit, # type: Optional[str] + uuid=_omit, # type: Optional[str] + ): + super(PeersItem, self).__init__( + client_name=client_name, + direction=direction, + mirror_uuid=mirror_uuid, + site_name=site_name, + uuid=uuid, + ) + + @property + def client_name(self): + # type: () -> str + return self._property_impl('client_name') + + @client_name.setter + def client_name(self, new_val): + # type: (Optional[str]) -> None + self._client_name = new_val + + @property + def direction(self): + # type: () -> str + return self._property_impl('direction') + + @direction.setter + def direction(self, new_val): + # type: (Optional[str]) -> None + self._direction = new_val + + @property + def mirror_uuid(self): + # type: () -> str + return self._property_impl('mirror_uuid') + + @mirror_uuid.setter + def mirror_uuid(self, new_val): + # type: (Optional[str]) -> None + self._mirror_uuid = new_val + + @property + def site_name(self): + # type: () -> str + return self._property_impl('site_name') + + @site_name.setter + def site_name(self, new_val): + # type: (Optional[str]) -> None + self._site_name = new_val + + @property + def uuid(self): + # type: () -> str + return self._property_impl('uuid') + + @uuid.setter + def uuid(self, new_val): + # type: (Optional[str]) -> None + self._uuid = new_val + + +class PeersList(CrdObjectList): + _items_type = PeersItem + + +class MirroringInfo(CrdObject): + _properties = [ + ('details', 'details', str, False, False), + ('lastChanged', 'lastChanged', str, False, False), + ('lastChecked', 'lastChecked', str, False, False), + ('mode', 'mode', str, False, False), + ('peers', 'peers', 'PeersList', False, False), + ('site_name', 'site_name', str, False, False) + ] + + def __init__(self, + details=_omit, # type: Optional[str] + lastChanged=_omit, # type: Optional[str] + lastChecked=_omit, # type: Optional[str] + mode=_omit, # type: Optional[str] + peers=_omit, # type: Optional[Union[List[PeersItem], CrdObjectList]] + site_name=_omit, # type: Optional[str] + ): + super(MirroringInfo, self).__init__( + details=details, + lastChanged=lastChanged, + lastChecked=lastChecked, + mode=mode, + peers=peers, + site_name=site_name, + ) + + @property + def details(self): + # type: () -> str + return self._property_impl('details') + + @details.setter + def details(self, new_val): + # type: (Optional[str]) -> None + self._details = new_val + + @property + def lastChanged(self): + # type: () -> str + return self._property_impl('lastChanged') + + @lastChanged.setter + def lastChanged(self, new_val): + # type: (Optional[str]) -> None + self._lastChanged = new_val + + @property + def lastChecked(self): + # type: () -> str + return self._property_impl('lastChecked') + + @lastChecked.setter + def lastChecked(self, new_val): + # type: (Optional[str]) -> None + self._lastChecked = new_val + + @property + def mode(self): + # type: () -> str + return self._property_impl('mode') + + @mode.setter + def mode(self, new_val): + # type: (Optional[str]) -> None + self._mode = new_val + + @property + def peers(self): + # type: () -> Union[List[PeersItem], CrdObjectList] + return self._property_impl('peers') + + @peers.setter + def peers(self, new_val): + # type: (Optional[Union[List[PeersItem], CrdObjectList]]) -> None + self._peers = new_val + + @property + def site_name(self): + # type: () -> str + return self._property_impl('site_name') + + @site_name.setter + def site_name(self, new_val): + # type: (Optional[str]) -> None + self._site_name = new_val + + +class States(CrdObject): + _properties = [ + ('error', 'error', int, False, False), + ('replaying', 'replaying', int, False, False), + ('starting_replay', 'starting_replay', int, False, False), + ('stopped', 'stopped', int, False, False), + ('stopping_replay', 'stopping_replay', int, False, False), + ('syncing', 'syncing', int, False, False), + ('unknown', 'unknown', int, False, False) + ] + + def __init__(self, + error=_omit, # type: Optional[int] + replaying=_omit, # type: Optional[int] + starting_replay=_omit, # type: Optional[int] + stopped=_omit, # type: Optional[int] + stopping_replay=_omit, # type: Optional[int] + syncing=_omit, # type: Optional[int] + unknown=_omit, # type: Optional[int] + ): + super(States, self).__init__( + error=error, + replaying=replaying, + starting_replay=starting_replay, + stopped=stopped, + stopping_replay=stopping_replay, + syncing=syncing, + unknown=unknown, + ) + + @property + def error(self): + # type: () -> int + return self._property_impl('error') + + @error.setter + def error(self, new_val): + # type: (Optional[int]) -> None + self._error = new_val + + @property + def replaying(self): + # type: () -> int + return self._property_impl('replaying') + + @replaying.setter + def replaying(self, new_val): + # type: (Optional[int]) -> None + self._replaying = new_val + + @property + def starting_replay(self): + # type: () -> int + return self._property_impl('starting_replay') + + @starting_replay.setter + def starting_replay(self, new_val): + # type: (Optional[int]) -> None + self._starting_replay = new_val + + @property + def stopped(self): + # type: () -> int + return self._property_impl('stopped') + + @stopped.setter + def stopped(self, new_val): + # type: (Optional[int]) -> None + self._stopped = new_val + + @property + def stopping_replay(self): + # type: () -> int + return self._property_impl('stopping_replay') + + @stopping_replay.setter + def stopping_replay(self, new_val): + # type: (Optional[int]) -> None + self._stopping_replay = new_val + + @property + def syncing(self): + # type: () -> int + return self._property_impl('syncing') + + @syncing.setter + def syncing(self, new_val): + # type: (Optional[int]) -> None + self._syncing = new_val + + @property + def unknown(self): + # type: () -> int + return self._property_impl('unknown') + + @unknown.setter + def unknown(self, new_val): + # type: (Optional[int]) -> None + self._unknown = new_val + + +class Summary(CrdObject): + _properties = [ + ('daemon_health', 'daemon_health', str, False, False), + ('health', 'health', str, False, False), + ('image_health', 'image_health', str, False, False), + ('states', 'states', 'States', False, True) + ] + + def __init__(self, + daemon_health=_omit, # type: Optional[str] + health=_omit, # type: Optional[str] + image_health=_omit, # type: Optional[str] + states=_omit, # type: Optional[States] + ): + super(Summary, self).__init__( + daemon_health=daemon_health, + health=health, + image_health=image_health, + states=states, + ) + + @property + def daemon_health(self): + # type: () -> str + return self._property_impl('daemon_health') + + @daemon_health.setter + def daemon_health(self, new_val): + # type: (Optional[str]) -> None + self._daemon_health = new_val + + @property + def health(self): + # type: () -> str + return self._property_impl('health') + + @health.setter + def health(self, new_val): + # type: (Optional[str]) -> None + self._health = new_val + + @property + def image_health(self): + # type: () -> str + return self._property_impl('image_health') + + @image_health.setter + def image_health(self, new_val): + # type: (Optional[str]) -> None + self._image_health = new_val + + @property + def states(self): + # type: () -> Optional[States] + return self._property_impl('states') + + @states.setter + def states(self, new_val): + # type: (Optional[States]) -> None + self._states = new_val + + +class MirroringStatus(CrdObject): + _properties = [ + ('details', 'details', str, False, False), + ('lastChanged', 'lastChanged', str, False, False), + ('lastChecked', 'lastChecked', str, False, False), + ('summary', 'summary', 'Summary', False, False) + ] + + def __init__(self, + details=_omit, # type: Optional[str] + lastChanged=_omit, # type: Optional[str] + lastChecked=_omit, # type: Optional[str] + summary=_omit, # type: Optional[Summary] + ): + super(MirroringStatus, self).__init__( + details=details, + lastChanged=lastChanged, + lastChecked=lastChecked, + summary=summary, + ) + + @property + def details(self): + # type: () -> str + return self._property_impl('details') + + @details.setter + def details(self, new_val): + # type: (Optional[str]) -> None + self._details = new_val + + @property + def lastChanged(self): + # type: () -> str + return self._property_impl('lastChanged') + + @lastChanged.setter + def lastChanged(self, new_val): + # type: (Optional[str]) -> None + self._lastChanged = new_val + + @property + def lastChecked(self): + # type: () -> str + return self._property_impl('lastChecked') + + @lastChecked.setter + def lastChecked(self, new_val): + # type: (Optional[str]) -> None + self._lastChecked = new_val + + @property + def summary(self): + # type: () -> Summary + return self._property_impl('summary') + + @summary.setter + def summary(self, new_val): + # type: (Optional[Summary]) -> None + self._summary = new_val + + +class ItemsItem(CrdObject): + _properties = [ + ('interval', 'interval', str, False, False), + ('start_time', 'start_time', str, False, False) + ] + + def __init__(self, + interval=_omit, # type: Optional[str] + start_time=_omit, # type: Optional[str] + ): + super(ItemsItem, self).__init__( + interval=interval, + start_time=start_time, + ) + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def start_time(self): + # type: () -> str + return self._property_impl('start_time') + + @start_time.setter + def start_time(self, new_val): + # type: (Optional[str]) -> None + self._start_time = new_val + + +class ItemsList(CrdObjectList): + _items_type = ItemsItem + + +class SnapshotScheduleStatus(CrdObject): + _properties = [ + ('details', 'details', str, False, False), + ('lastChanged', 'lastChanged', str, False, False), + ('lastChecked', 'lastChecked', str, False, False), + ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, True) + ] + + def __init__(self, + details=_omit, # type: Optional[str] + lastChanged=_omit, # type: Optional[str] + lastChecked=_omit, # type: Optional[str] + snapshotSchedules=_omit, # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]] + ): + super(SnapshotScheduleStatus, self).__init__( + details=details, + lastChanged=lastChanged, + lastChecked=lastChecked, + snapshotSchedules=snapshotSchedules, + ) + + @property + def details(self): + # type: () -> str + return self._property_impl('details') + + @details.setter + def details(self, new_val): + # type: (Optional[str]) -> None + self._details = new_val + + @property + def lastChanged(self): + # type: () -> str + return self._property_impl('lastChanged') + + @lastChanged.setter + def lastChanged(self, new_val): + # type: (Optional[str]) -> None + self._lastChanged = new_val + + @property + def lastChecked(self): + # type: () -> str + return self._property_impl('lastChecked') + + @lastChecked.setter + def lastChecked(self, new_val): + # type: (Optional[str]) -> None + self._lastChecked = new_val + + @property + def snapshotSchedules(self): + # type: () -> Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]] + return self._property_impl('snapshotSchedules') + + @snapshotSchedules.setter + def snapshotSchedules(self, new_val): + # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None + self._snapshotSchedules = new_val + + +class Status(CrdObject): + _properties = [ + ('info', 'info', object, False, True), + ('mirroringInfo', 'mirroringInfo', 'MirroringInfo', False, False), + ('mirroringStatus', 'mirroringStatus', 'MirroringStatus', False, False), + ('phase', 'phase', str, False, False), + ('snapshotScheduleStatus', 'snapshotScheduleStatus', 'SnapshotScheduleStatus', False, False) + ] + + def __init__(self, + info=_omit, # type: Optional[Any] + mirroringInfo=_omit, # type: Optional[MirroringInfo] + mirroringStatus=_omit, # type: Optional[MirroringStatus] + phase=_omit, # type: Optional[str] + snapshotScheduleStatus=_omit, # type: Optional[SnapshotScheduleStatus] + ): + super(Status, self).__init__( + info=info, + mirroringInfo=mirroringInfo, + mirroringStatus=mirroringStatus, + phase=phase, + snapshotScheduleStatus=snapshotScheduleStatus, + ) + + @property + def info(self): + # type: () -> Optional[Any] + return self._property_impl('info') + + @info.setter + def info(self, new_val): + # type: (Optional[Any]) -> None + self._info = new_val + + @property + def mirroringInfo(self): + # type: () -> MirroringInfo + return self._property_impl('mirroringInfo') + + @mirroringInfo.setter + def mirroringInfo(self, new_val): + # type: (Optional[MirroringInfo]) -> None + self._mirroringInfo = new_val + + @property + def mirroringStatus(self): + # type: () -> MirroringStatus + return self._property_impl('mirroringStatus') + + @mirroringStatus.setter + def mirroringStatus(self, new_val): + # type: (Optional[MirroringStatus]) -> None + self._mirroringStatus = new_val + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + @property + def snapshotScheduleStatus(self): + # type: () -> SnapshotScheduleStatus + return self._property_impl('snapshotScheduleStatus') + + @snapshotScheduleStatus.setter + def snapshotScheduleStatus(self, new_val): + # type: (Optional[SnapshotScheduleStatus]) -> None + self._snapshotScheduleStatus = new_val + + +class CephBlockPool(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephBlockPool, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephclient.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephclient.py new file mode 100644 index 000000000..c7f8c7863 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephclient.py @@ -0,0 +1,157 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Spec(CrdObject): + _properties = [ + ('caps', 'caps', object, True, False), + ('name', 'name', str, False, False) + ] + + def __init__(self, + caps, # type: Any + name=_omit, # type: Optional[str] + ): + super(Spec, self).__init__( + caps=caps, + name=name, + ) + + @property + def caps(self): + # type: () -> Any + return self._property_impl('caps') + + @caps.setter + def caps(self, new_val): + # type: (Any) -> None + self._caps = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + +class Status(CrdObject): + _properties = [ + ('info', 'info', object, False, True), + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + info=_omit, # type: Optional[Any] + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + info=info, + phase=phase, + ) + + @property + def info(self): + # type: () -> Optional[Any] + return self._property_impl('info') + + @info.setter + def info(self, new_val): + # type: (Optional[Any]) -> None + self._info = new_val + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephClient(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephClient, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephcluster.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephcluster.py new file mode 100644 index 000000000..00cdbc817 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephcluster.py @@ -0,0 +1,3959 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class CephVersion(CrdObject): + _properties = [ + ('allowUnsupported', 'allowUnsupported', bool, False, False), + ('image', 'image', str, False, False) + ] + + def __init__(self, + allowUnsupported=_omit, # type: Optional[bool] + image=_omit, # type: Optional[str] + ): + super(CephVersion, self).__init__( + allowUnsupported=allowUnsupported, + image=image, + ) + + @property + def allowUnsupported(self): + # type: () -> bool + return self._property_impl('allowUnsupported') + + @allowUnsupported.setter + def allowUnsupported(self, new_val): + # type: (Optional[bool]) -> None + self._allowUnsupported = new_val + + @property + def image(self): + # type: () -> str + return self._property_impl('image') + + @image.setter + def image(self, new_val): + # type: (Optional[str]) -> None + self._image = new_val + + +class SanitizeDisks(CrdObject): + _properties = [ + ('dataSource', 'dataSource', str, False, False), + ('iteration', 'iteration', int, False, False), + ('method', 'method', str, False, False) + ] + + def __init__(self, + dataSource=_omit, # type: Optional[str] + iteration=_omit, # type: Optional[int] + method=_omit, # type: Optional[str] + ): + super(SanitizeDisks, self).__init__( + dataSource=dataSource, + iteration=iteration, + method=method, + ) + + @property + def dataSource(self): + # type: () -> str + return self._property_impl('dataSource') + + @dataSource.setter + def dataSource(self, new_val): + # type: (Optional[str]) -> None + self._dataSource = new_val + + @property + def iteration(self): + # type: () -> int + return self._property_impl('iteration') + + @iteration.setter + def iteration(self, new_val): + # type: (Optional[int]) -> None + self._iteration = new_val + + @property + def method(self): + # type: () -> str + return self._property_impl('method') + + @method.setter + def method(self, new_val): + # type: (Optional[str]) -> None + self._method = new_val + + +class CleanupPolicy(CrdObject): + _properties = [ + ('allowUninstallWithVolumes', 'allowUninstallWithVolumes', bool, False, False), + ('confirmation', 'confirmation', str, False, True), + ('sanitizeDisks', 'sanitizeDisks', 'SanitizeDisks', False, True) + ] + + def __init__(self, + allowUninstallWithVolumes=_omit, # type: Optional[bool] + confirmation=_omit, # type: Optional[str] + sanitizeDisks=_omit, # type: Optional[SanitizeDisks] + ): + super(CleanupPolicy, self).__init__( + allowUninstallWithVolumes=allowUninstallWithVolumes, + confirmation=confirmation, + sanitizeDisks=sanitizeDisks, + ) + + @property + def allowUninstallWithVolumes(self): + # type: () -> bool + return self._property_impl('allowUninstallWithVolumes') + + @allowUninstallWithVolumes.setter + def allowUninstallWithVolumes(self, new_val): + # type: (Optional[bool]) -> None + self._allowUninstallWithVolumes = new_val + + @property + def confirmation(self): + # type: () -> Optional[str] + return self._property_impl('confirmation') + + @confirmation.setter + def confirmation(self, new_val): + # type: (Optional[str]) -> None + self._confirmation = new_val + + @property + def sanitizeDisks(self): + # type: () -> Optional[SanitizeDisks] + return self._property_impl('sanitizeDisks') + + @sanitizeDisks.setter + def sanitizeDisks(self, new_val): + # type: (Optional[SanitizeDisks]) -> None + self._sanitizeDisks = new_val + + +class CrashCollector(CrdObject): + _properties = [ + ('daysToRetain', 'daysToRetain', int, False, False), + ('disable', 'disable', bool, False, False) + ] + + def __init__(self, + daysToRetain=_omit, # type: Optional[int] + disable=_omit, # type: Optional[bool] + ): + super(CrashCollector, self).__init__( + daysToRetain=daysToRetain, + disable=disable, + ) + + @property + def daysToRetain(self): + # type: () -> int + return self._property_impl('daysToRetain') + + @daysToRetain.setter + def daysToRetain(self, new_val): + # type: (Optional[int]) -> None + self._daysToRetain = new_val + + @property + def disable(self): + # type: () -> bool + return self._property_impl('disable') + + @disable.setter + def disable(self, new_val): + # type: (Optional[bool]) -> None + self._disable = new_val + + +class Dashboard(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('port', 'port', int, False, False), + ('ssl', 'ssl', bool, False, False), + ('urlPrefix', 'urlPrefix', str, False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + port=_omit, # type: Optional[int] + ssl=_omit, # type: Optional[bool] + urlPrefix=_omit, # type: Optional[str] + ): + super(Dashboard, self).__init__( + enabled=enabled, + port=port, + ssl=ssl, + urlPrefix=urlPrefix, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def port(self): + # type: () -> int + return self._property_impl('port') + + @port.setter + def port(self, new_val): + # type: (Optional[int]) -> None + self._port = new_val + + @property + def ssl(self): + # type: () -> bool + return self._property_impl('ssl') + + @ssl.setter + def ssl(self, new_val): + # type: (Optional[bool]) -> None + self._ssl = new_val + + @property + def urlPrefix(self): + # type: () -> str + return self._property_impl('urlPrefix') + + @urlPrefix.setter + def urlPrefix(self, new_val): + # type: (Optional[str]) -> None + self._urlPrefix = new_val + + +class DisruptionManagement(CrdObject): + _properties = [ + ('machineDisruptionBudgetNamespace', 'machineDisruptionBudgetNamespace', str, False, False), + ('manageMachineDisruptionBudgets', 'manageMachineDisruptionBudgets', bool, False, False), + ('managePodBudgets', 'managePodBudgets', bool, False, False), + ('osdMaintenanceTimeout', 'osdMaintenanceTimeout', int, False, False), + ('pgHealthCheckTimeout', 'pgHealthCheckTimeout', int, False, False) + ] + + def __init__(self, + machineDisruptionBudgetNamespace=_omit, # type: Optional[str] + manageMachineDisruptionBudgets=_omit, # type: Optional[bool] + managePodBudgets=_omit, # type: Optional[bool] + osdMaintenanceTimeout=_omit, # type: Optional[int] + pgHealthCheckTimeout=_omit, # type: Optional[int] + ): + super(DisruptionManagement, self).__init__( + machineDisruptionBudgetNamespace=machineDisruptionBudgetNamespace, + manageMachineDisruptionBudgets=manageMachineDisruptionBudgets, + managePodBudgets=managePodBudgets, + osdMaintenanceTimeout=osdMaintenanceTimeout, + pgHealthCheckTimeout=pgHealthCheckTimeout, + ) + + @property + def machineDisruptionBudgetNamespace(self): + # type: () -> str + return self._property_impl('machineDisruptionBudgetNamespace') + + @machineDisruptionBudgetNamespace.setter + def machineDisruptionBudgetNamespace(self, new_val): + # type: (Optional[str]) -> None + self._machineDisruptionBudgetNamespace = new_val + + @property + def manageMachineDisruptionBudgets(self): + # type: () -> bool + return self._property_impl('manageMachineDisruptionBudgets') + + @manageMachineDisruptionBudgets.setter + def manageMachineDisruptionBudgets(self, new_val): + # type: (Optional[bool]) -> None + self._manageMachineDisruptionBudgets = new_val + + @property + def managePodBudgets(self): + # type: () -> bool + return self._property_impl('managePodBudgets') + + @managePodBudgets.setter + def managePodBudgets(self, new_val): + # type: (Optional[bool]) -> None + self._managePodBudgets = new_val + + @property + def osdMaintenanceTimeout(self): + # type: () -> int + return self._property_impl('osdMaintenanceTimeout') + + @osdMaintenanceTimeout.setter + def osdMaintenanceTimeout(self, new_val): + # type: (Optional[int]) -> None + self._osdMaintenanceTimeout = new_val + + @property + def pgHealthCheckTimeout(self): + # type: () -> int + return self._property_impl('pgHealthCheckTimeout') + + @pgHealthCheckTimeout.setter + def pgHealthCheckTimeout(self, new_val): + # type: (Optional[int]) -> None + self._pgHealthCheckTimeout = new_val + + +class External(CrdObject): + _properties = [ + ('enable', 'enable', bool, False, False) + ] + + def __init__(self, + enable=_omit, # type: Optional[bool] + ): + super(External, self).__init__( + enable=enable, + ) + + @property + def enable(self): + # type: () -> bool + return self._property_impl('enable') + + @enable.setter + def enable(self, new_val): + # type: (Optional[bool]) -> None + self._enable = new_val + + +class Mon(CrdObject): + _properties = [ + ('allowMultiplePerNode', 'allowMultiplePerNode', bool, False, False), + ('count', 'count', int, False, False), + ('stretchCluster', 'stretchCluster', 'StretchCluster', False, False), + ('volumeClaimTemplate', 'volumeClaimTemplate', 'VolumeClaimTemplate', False, False), + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + allowMultiplePerNode=_omit, # type: Optional[bool] + count=_omit, # type: Optional[int] + stretchCluster=_omit, # type: Optional[StretchCluster] + volumeClaimTemplate=_omit, # type: Optional[VolumeClaimTemplate] + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Mon, self).__init__( + allowMultiplePerNode=allowMultiplePerNode, + count=count, + stretchCluster=stretchCluster, + volumeClaimTemplate=volumeClaimTemplate, + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def allowMultiplePerNode(self): + # type: () -> bool + return self._property_impl('allowMultiplePerNode') + + @allowMultiplePerNode.setter + def allowMultiplePerNode(self, new_val): + # type: (Optional[bool]) -> None + self._allowMultiplePerNode = new_val + + @property + def count(self): + # type: () -> int + return self._property_impl('count') + + @count.setter + def count(self, new_val): + # type: (Optional[int]) -> None + self._count = new_val + + @property + def stretchCluster(self): + # type: () -> StretchCluster + return self._property_impl('stretchCluster') + + @stretchCluster.setter + def stretchCluster(self, new_val): + # type: (Optional[StretchCluster]) -> None + self._stretchCluster = new_val + + @property + def volumeClaimTemplate(self): + # type: () -> VolumeClaimTemplate + return self._property_impl('volumeClaimTemplate') + + @volumeClaimTemplate.setter + def volumeClaimTemplate(self, new_val): + # type: (Optional[VolumeClaimTemplate]) -> None + self._volumeClaimTemplate = new_val + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class Osd(CrdObject): + _properties = [ + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Osd, self).__init__( + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class Status(CrdObject): + _properties = [ + ('ceph', 'ceph', 'Ceph', False, False), + ('conditions', 'conditions', 'ConditionsList', False, False), + ('message', 'message', str, False, False), + ('phase', 'phase', str, False, False), + ('state', 'state', str, False, False), + ('storage', 'storage', 'Storage', False, False), + ('version', 'version', 'Version', False, False), + ('accessModes', 'accessModes', 'AccessModesList', False, False), + ('capacity', 'capacity', object, False, False), + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + ceph=_omit, # type: Optional[Ceph] + conditions=_omit, # type: Optional[Union[List[ConditionsItem], CrdObjectList]] + message=_omit, # type: Optional[str] + phase=_omit, # type: Optional[str] + state=_omit, # type: Optional[str] + storage=_omit, # type: Optional[Storage] + version=_omit, # type: Optional[Version] + accessModes=_omit, # type: Optional[Union[List[str], CrdObjectList]] + capacity=_omit, # type: Optional[Any] + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + ceph=ceph, + conditions=conditions, + message=message, + phase=phase, + state=state, + storage=storage, + version=version, + accessModes=accessModes, + capacity=capacity, + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def ceph(self): + # type: () -> Ceph + return self._property_impl('ceph') + + @ceph.setter + def ceph(self, new_val): + # type: (Optional[Ceph]) -> None + self._ceph = new_val + + @property + def conditions(self): + # type: () -> Union[List[ConditionsItem], CrdObjectList] + return self._property_impl('conditions') + + @conditions.setter + def conditions(self, new_val): + # type: (Optional[Union[List[ConditionsItem], CrdObjectList]]) -> None + self._conditions = new_val + + @property + def message(self): + # type: () -> str + return self._property_impl('message') + + @message.setter + def message(self, new_val): + # type: (Optional[str]) -> None + self._message = new_val + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + @property + def state(self): + # type: () -> str + return self._property_impl('state') + + @state.setter + def state(self, new_val): + # type: (Optional[str]) -> None + self._state = new_val + + @property + def storage(self): + # type: () -> Storage + return self._property_impl('storage') + + @storage.setter + def storage(self, new_val): + # type: (Optional[Storage]) -> None + self._storage = new_val + + @property + def version(self): + # type: () -> Version + return self._property_impl('version') + + @version.setter + def version(self, new_val): + # type: (Optional[Version]) -> None + self._version = new_val + + @property + def accessModes(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('accessModes') + + @accessModes.setter + def accessModes(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._accessModes = new_val + + @property + def capacity(self): + # type: () -> Any + return self._property_impl('capacity') + + @capacity.setter + def capacity(self, new_val): + # type: (Optional[Any]) -> None + self._capacity = new_val + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class DaemonHealth(CrdObject): + _properties = [ + ('mon', 'mon', 'Mon', False, True), + ('osd', 'osd', 'Osd', False, True), + ('status', 'status', 'Status', False, True) + ] + + def __init__(self, + mon=_omit, # type: Optional[Mon] + osd=_omit, # type: Optional[Osd] + status=_omit, # type: Optional[Status] + ): + super(DaemonHealth, self).__init__( + mon=mon, + osd=osd, + status=status, + ) + + @property + def mon(self): + # type: () -> Optional[Mon] + return self._property_impl('mon') + + @mon.setter + def mon(self, new_val): + # type: (Optional[Mon]) -> None + self._mon = new_val + + @property + def osd(self): + # type: () -> Optional[Osd] + return self._property_impl('osd') + + @osd.setter + def osd(self, new_val): + # type: (Optional[Osd]) -> None + self._osd = new_val + + @property + def status(self): + # type: () -> Optional[Status] + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val + + +class HealthCheck(CrdObject): + _properties = [ + ('daemonHealth', 'daemonHealth', 'DaemonHealth', False, True), + ('livenessProbe', 'livenessProbe', object, False, False) + ] + + def __init__(self, + daemonHealth=_omit, # type: Optional[DaemonHealth] + livenessProbe=_omit, # type: Optional[Any] + ): + super(HealthCheck, self).__init__( + daemonHealth=daemonHealth, + livenessProbe=livenessProbe, + ) + + @property + def daemonHealth(self): + # type: () -> Optional[DaemonHealth] + return self._property_impl('daemonHealth') + + @daemonHealth.setter + def daemonHealth(self, new_val): + # type: (Optional[DaemonHealth]) -> None + self._daemonHealth = new_val + + @property + def livenessProbe(self): + # type: () -> Any + return self._property_impl('livenessProbe') + + @livenessProbe.setter + def livenessProbe(self, new_val): + # type: (Optional[Any]) -> None + self._livenessProbe = new_val + + +class LogCollector(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('periodicity', 'periodicity', str, False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + periodicity=_omit, # type: Optional[str] + ): + super(LogCollector, self).__init__( + enabled=enabled, + periodicity=periodicity, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def periodicity(self): + # type: () -> str + return self._property_impl('periodicity') + + @periodicity.setter + def periodicity(self, new_val): + # type: (Optional[str]) -> None + self._periodicity = new_val + + +class ModulesItem(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('name', 'name', str, False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + name=_omit, # type: Optional[str] + ): + super(ModulesItem, self).__init__( + enabled=enabled, + name=name, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + +class ModulesList(CrdObjectList): + _items_type = ModulesItem + + +class Mgr(CrdObject): + _properties = [ + ('allowMultiplePerNode', 'allowMultiplePerNode', bool, False, False), + ('count', 'count', int, False, False), + ('modules', 'modules', 'ModulesList', False, True) + ] + + def __init__(self, + allowMultiplePerNode=_omit, # type: Optional[bool] + count=_omit, # type: Optional[int] + modules=_omit, # type: Optional[Union[List[ModulesItem], CrdObjectList]] + ): + super(Mgr, self).__init__( + allowMultiplePerNode=allowMultiplePerNode, + count=count, + modules=modules, + ) + + @property + def allowMultiplePerNode(self): + # type: () -> bool + return self._property_impl('allowMultiplePerNode') + + @allowMultiplePerNode.setter + def allowMultiplePerNode(self, new_val): + # type: (Optional[bool]) -> None + self._allowMultiplePerNode = new_val + + @property + def count(self): + # type: () -> int + return self._property_impl('count') + + @count.setter + def count(self, new_val): + # type: (Optional[int]) -> None + self._count = new_val + + @property + def modules(self): + # type: () -> Optional[Union[List[ModulesItem], CrdObjectList]] + return self._property_impl('modules') + + @modules.setter + def modules(self, new_val): + # type: (Optional[Union[List[ModulesItem], CrdObjectList]]) -> None + self._modules = new_val + + +class FinalizersList(CrdObjectList): + _items_type = str + + +class Metadata(CrdObject): + _properties = [ + ('annotations', 'annotations', object, False, False), + ('finalizers', 'finalizers', 'FinalizersList', False, False), + ('labels', 'labels', object, False, False), + ('name', 'name', str, False, False), + ('namespace', 'namespace', str, False, False) + ] + + def __init__(self, + annotations=_omit, # type: Optional[Any] + finalizers=_omit, # type: Optional[Union[List[str], CrdObjectList]] + labels=_omit, # type: Optional[Any] + name=_omit, # type: Optional[str] + namespace=_omit, # type: Optional[str] + ): + super(Metadata, self).__init__( + annotations=annotations, + finalizers=finalizers, + labels=labels, + name=name, + namespace=namespace, + ) + + @property + def annotations(self): + # type: () -> Any + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + @property + def finalizers(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('finalizers') + + @finalizers.setter + def finalizers(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._finalizers = new_val + + @property + def labels(self): + # type: () -> Any + return self._property_impl('labels') + + @labels.setter + def labels(self, new_val): + # type: (Optional[Any]) -> None + self._labels = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + @property + def namespace(self): + # type: () -> str + return self._property_impl('namespace') + + @namespace.setter + def namespace(self, new_val): + # type: (Optional[str]) -> None + self._namespace = new_val + + +class AccessModesList(CrdObjectList): + _items_type = str + + +class DataSource(CrdObject): + _properties = [ + ('apiGroup', 'apiGroup', str, False, False), + ('kind', 'kind', str, True, False), + ('name', 'name', str, True, False) + ] + + def __init__(self, + kind, # type: str + name, # type: str + apiGroup=_omit, # type: Optional[str] + ): + super(DataSource, self).__init__( + kind=kind, + name=name, + apiGroup=apiGroup, + ) + + @property + def apiGroup(self): + # type: () -> str + return self._property_impl('apiGroup') + + @apiGroup.setter + def apiGroup(self, new_val): + # type: (Optional[str]) -> None + self._apiGroup = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (str) -> None + self._kind = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (str) -> None + self._name = new_val + + +class Resources(CrdObject): + _properties = [ + ('limits', 'limits', object, False, False), + ('requests', 'requests', object, False, False) + ] + + def __init__(self, + limits=_omit, # type: Optional[Any] + requests=_omit, # type: Optional[Any] + ): + super(Resources, self).__init__( + limits=limits, + requests=requests, + ) + + @property + def limits(self): + # type: () -> Any + return self._property_impl('limits') + + @limits.setter + def limits(self, new_val): + # type: (Optional[Any]) -> None + self._limits = new_val + + @property + def requests(self): + # type: () -> Any + return self._property_impl('requests') + + @requests.setter + def requests(self, new_val): + # type: (Optional[Any]) -> None + self._requests = new_val + + +class ValuesList(CrdObjectList): + _items_type = str + + +class MatchExpressionsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchExpressionsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchExpressionsList(CrdObjectList): + _items_type = MatchExpressionsItem + + +class Selector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(Selector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class Spec(CrdObject): + _properties = [ + ('annotations', 'annotations', object, False, True), + ('cephVersion', 'cephVersion', 'CephVersion', False, True), + ('cleanupPolicy', 'cleanupPolicy', 'CleanupPolicy', False, True), + ('continueUpgradeAfterChecksEvenIfNotHealthy', 'continueUpgradeAfterChecksEvenIfNotHealthy', bool, False, False), + ('crashCollector', 'crashCollector', 'CrashCollector', False, True), + ('dashboard', 'dashboard', 'Dashboard', False, True), + ('dataDirHostPath', 'dataDirHostPath', str, False, False), + ('disruptionManagement', 'disruptionManagement', 'DisruptionManagement', False, True), + ('external', 'external', 'External', False, True), + ('healthCheck', 'healthCheck', 'HealthCheck', False, True), + ('labels', 'labels', object, False, True), + ('logCollector', 'logCollector', 'LogCollector', False, True), + ('mgr', 'mgr', 'Mgr', False, True), + ('mon', 'mon', 'Mon', False, True), + ('monitoring', 'monitoring', 'Monitoring', False, True), + ('network', 'network', 'Network', False, True), + ('placement', 'placement', object, False, True), + ('priorityClassNames', 'priorityClassNames', object, False, True), + ('removeOSDsIfOutAndSafeToRemove', 'removeOSDsIfOutAndSafeToRemove', bool, False, False), + ('resources', 'resources', object, False, True), + ('security', 'security', 'Security', False, True), + ('skipUpgradeChecks', 'skipUpgradeChecks', bool, False, False), + ('storage', 'storage', 'Storage', False, True), + ('waitTimeoutForHealthyOSDInMinutes', 'waitTimeoutForHealthyOSDInMinutes', int, False, False), + ('accessModes', 'accessModes', 'AccessModesList', False, False), + ('dataSource', 'dataSource', 'DataSource', False, False), + ('selector', 'selector', 'Selector', False, False), + ('storageClassName', 'storageClassName', str, False, False), + ('volumeMode', 'volumeMode', str, False, False), + ('volumeName', 'volumeName', str, False, False) + ] + + def __init__(self, + annotations=_omit, # type: Optional[Any] + cephVersion=_omit, # type: Optional[CephVersion] + cleanupPolicy=_omit, # type: Optional[CleanupPolicy] + continueUpgradeAfterChecksEvenIfNotHealthy=_omit, # type: Optional[bool] + crashCollector=_omit, # type: Optional[CrashCollector] + dashboard=_omit, # type: Optional[Dashboard] + dataDirHostPath=_omit, # type: Optional[str] + disruptionManagement=_omit, # type: Optional[DisruptionManagement] + external=_omit, # type: Optional[External] + healthCheck=_omit, # type: Optional[HealthCheck] + labels=_omit, # type: Optional[Any] + logCollector=_omit, # type: Optional[LogCollector] + mgr=_omit, # type: Optional[Mgr] + mon=_omit, # type: Optional[Mon] + monitoring=_omit, # type: Optional[Monitoring] + network=_omit, # type: Optional[Network] + placement=_omit, # type: Optional[Any] + priorityClassNames=_omit, # type: Optional[Any] + removeOSDsIfOutAndSafeToRemove=_omit, # type: Optional[bool] + resources=_omit, # type: Optional[Any] + security=_omit, # type: Optional[Security] + skipUpgradeChecks=_omit, # type: Optional[bool] + storage=_omit, # type: Optional[Storage] + waitTimeoutForHealthyOSDInMinutes=_omit, # type: Optional[int] + accessModes=_omit, # type: Optional[Union[List[str], CrdObjectList]] + dataSource=_omit, # type: Optional[DataSource] + selector=_omit, # type: Optional[Selector] + storageClassName=_omit, # type: Optional[str] + volumeMode=_omit, # type: Optional[str] + volumeName=_omit, # type: Optional[str] + ): + super(Spec, self).__init__( + annotations=annotations, + cephVersion=cephVersion, + cleanupPolicy=cleanupPolicy, + continueUpgradeAfterChecksEvenIfNotHealthy=continueUpgradeAfterChecksEvenIfNotHealthy, + crashCollector=crashCollector, + dashboard=dashboard, + dataDirHostPath=dataDirHostPath, + disruptionManagement=disruptionManagement, + external=external, + healthCheck=healthCheck, + labels=labels, + logCollector=logCollector, + mgr=mgr, + mon=mon, + monitoring=monitoring, + network=network, + placement=placement, + priorityClassNames=priorityClassNames, + removeOSDsIfOutAndSafeToRemove=removeOSDsIfOutAndSafeToRemove, + resources=resources, + security=security, + skipUpgradeChecks=skipUpgradeChecks, + storage=storage, + waitTimeoutForHealthyOSDInMinutes=waitTimeoutForHealthyOSDInMinutes, + accessModes=accessModes, + dataSource=dataSource, + selector=selector, + storageClassName=storageClassName, + volumeMode=volumeMode, + volumeName=volumeName, + ) + + @property + def annotations(self): + # type: () -> Optional[Any] + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + @property + def cephVersion(self): + # type: () -> Optional[CephVersion] + return self._property_impl('cephVersion') + + @cephVersion.setter + def cephVersion(self, new_val): + # type: (Optional[CephVersion]) -> None + self._cephVersion = new_val + + @property + def cleanupPolicy(self): + # type: () -> Optional[CleanupPolicy] + return self._property_impl('cleanupPolicy') + + @cleanupPolicy.setter + def cleanupPolicy(self, new_val): + # type: (Optional[CleanupPolicy]) -> None + self._cleanupPolicy = new_val + + @property + def continueUpgradeAfterChecksEvenIfNotHealthy(self): + # type: () -> bool + return self._property_impl('continueUpgradeAfterChecksEvenIfNotHealthy') + + @continueUpgradeAfterChecksEvenIfNotHealthy.setter + def continueUpgradeAfterChecksEvenIfNotHealthy(self, new_val): + # type: (Optional[bool]) -> None + self._continueUpgradeAfterChecksEvenIfNotHealthy = new_val + + @property + def crashCollector(self): + # type: () -> Optional[CrashCollector] + return self._property_impl('crashCollector') + + @crashCollector.setter + def crashCollector(self, new_val): + # type: (Optional[CrashCollector]) -> None + self._crashCollector = new_val + + @property + def dashboard(self): + # type: () -> Optional[Dashboard] + return self._property_impl('dashboard') + + @dashboard.setter + def dashboard(self, new_val): + # type: (Optional[Dashboard]) -> None + self._dashboard = new_val + + @property + def dataDirHostPath(self): + # type: () -> str + return self._property_impl('dataDirHostPath') + + @dataDirHostPath.setter + def dataDirHostPath(self, new_val): + # type: (Optional[str]) -> None + self._dataDirHostPath = new_val + + @property + def disruptionManagement(self): + # type: () -> Optional[DisruptionManagement] + return self._property_impl('disruptionManagement') + + @disruptionManagement.setter + def disruptionManagement(self, new_val): + # type: (Optional[DisruptionManagement]) -> None + self._disruptionManagement = new_val + + @property + def external(self): + # type: () -> Optional[External] + return self._property_impl('external') + + @external.setter + def external(self, new_val): + # type: (Optional[External]) -> None + self._external = new_val + + @property + def healthCheck(self): + # type: () -> Optional[HealthCheck] + return self._property_impl('healthCheck') + + @healthCheck.setter + def healthCheck(self, new_val): + # type: (Optional[HealthCheck]) -> None + self._healthCheck = new_val + + @property + def labels(self): + # type: () -> Optional[Any] + return self._property_impl('labels') + + @labels.setter + def labels(self, new_val): + # type: (Optional[Any]) -> None + self._labels = new_val + + @property + def logCollector(self): + # type: () -> Optional[LogCollector] + return self._property_impl('logCollector') + + @logCollector.setter + def logCollector(self, new_val): + # type: (Optional[LogCollector]) -> None + self._logCollector = new_val + + @property + def mgr(self): + # type: () -> Optional[Mgr] + return self._property_impl('mgr') + + @mgr.setter + def mgr(self, new_val): + # type: (Optional[Mgr]) -> None + self._mgr = new_val + + @property + def mon(self): + # type: () -> Optional[Mon] + return self._property_impl('mon') + + @mon.setter + def mon(self, new_val): + # type: (Optional[Mon]) -> None + self._mon = new_val + + @property + def monitoring(self): + # type: () -> Optional[Monitoring] + return self._property_impl('monitoring') + + @monitoring.setter + def monitoring(self, new_val): + # type: (Optional[Monitoring]) -> None + self._monitoring = new_val + + @property + def network(self): + # type: () -> Optional[Network] + return self._property_impl('network') + + @network.setter + def network(self, new_val): + # type: (Optional[Network]) -> None + self._network = new_val + + @property + def placement(self): + # type: () -> Optional[Any] + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Any]) -> None + self._placement = new_val + + @property + def priorityClassNames(self): + # type: () -> Optional[Any] + return self._property_impl('priorityClassNames') + + @priorityClassNames.setter + def priorityClassNames(self, new_val): + # type: (Optional[Any]) -> None + self._priorityClassNames = new_val + + @property + def removeOSDsIfOutAndSafeToRemove(self): + # type: () -> bool + return self._property_impl('removeOSDsIfOutAndSafeToRemove') + + @removeOSDsIfOutAndSafeToRemove.setter + def removeOSDsIfOutAndSafeToRemove(self, new_val): + # type: (Optional[bool]) -> None + self._removeOSDsIfOutAndSafeToRemove = new_val + + @property + def resources(self): + # type: () -> Optional[Any] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Any]) -> None + self._resources = new_val + + @property + def security(self): + # type: () -> Optional[Security] + return self._property_impl('security') + + @security.setter + def security(self, new_val): + # type: (Optional[Security]) -> None + self._security = new_val + + @property + def skipUpgradeChecks(self): + # type: () -> bool + return self._property_impl('skipUpgradeChecks') + + @skipUpgradeChecks.setter + def skipUpgradeChecks(self, new_val): + # type: (Optional[bool]) -> None + self._skipUpgradeChecks = new_val + + @property + def storage(self): + # type: () -> Optional[Storage] + return self._property_impl('storage') + + @storage.setter + def storage(self, new_val): + # type: (Optional[Storage]) -> None + self._storage = new_val + + @property + def waitTimeoutForHealthyOSDInMinutes(self): + # type: () -> int + return self._property_impl('waitTimeoutForHealthyOSDInMinutes') + + @waitTimeoutForHealthyOSDInMinutes.setter + def waitTimeoutForHealthyOSDInMinutes(self, new_val): + # type: (Optional[int]) -> None + self._waitTimeoutForHealthyOSDInMinutes = new_val + + @property + def accessModes(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('accessModes') + + @accessModes.setter + def accessModes(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._accessModes = new_val + + @property + def dataSource(self): + # type: () -> DataSource + return self._property_impl('dataSource') + + @dataSource.setter + def dataSource(self, new_val): + # type: (Optional[DataSource]) -> None + self._dataSource = new_val + + @property + def selector(self): + # type: () -> Selector + return self._property_impl('selector') + + @selector.setter + def selector(self, new_val): + # type: (Optional[Selector]) -> None + self._selector = new_val + + @property + def storageClassName(self): + # type: () -> str + return self._property_impl('storageClassName') + + @storageClassName.setter + def storageClassName(self, new_val): + # type: (Optional[str]) -> None + self._storageClassName = new_val + + @property + def volumeMode(self): + # type: () -> str + return self._property_impl('volumeMode') + + @volumeMode.setter + def volumeMode(self, new_val): + # type: (Optional[str]) -> None + self._volumeMode = new_val + + @property + def volumeName(self): + # type: () -> str + return self._property_impl('volumeName') + + @volumeName.setter + def volumeName(self, new_val): + # type: (Optional[str]) -> None + self._volumeName = new_val + + +class ConditionsItem(CrdObject): + _properties = [ + ('lastHeartbeatTime', 'lastHeartbeatTime', str, False, False), + ('lastTransitionTime', 'lastTransitionTime', str, False, False), + ('message', 'message', str, False, False), + ('reason', 'reason', str, False, False), + ('status', 'status', str, False, False), + ('type', 'type', str, False, False), + ('lastProbeTime', 'lastProbeTime', str, False, False) + ] + + def __init__(self, + lastHeartbeatTime=_omit, # type: Optional[str] + lastTransitionTime=_omit, # type: Optional[str] + message=_omit, # type: Optional[str] + reason=_omit, # type: Optional[str] + status=_omit, # type: Optional[str] + type=_omit, # type: Optional[str] + lastProbeTime=_omit, # type: Optional[str] + ): + super(ConditionsItem, self).__init__( + lastHeartbeatTime=lastHeartbeatTime, + lastTransitionTime=lastTransitionTime, + message=message, + reason=reason, + status=status, + type=type, + lastProbeTime=lastProbeTime, + ) + + @property + def lastHeartbeatTime(self): + # type: () -> str + return self._property_impl('lastHeartbeatTime') + + @lastHeartbeatTime.setter + def lastHeartbeatTime(self, new_val): + # type: (Optional[str]) -> None + self._lastHeartbeatTime = new_val + + @property + def lastTransitionTime(self): + # type: () -> str + return self._property_impl('lastTransitionTime') + + @lastTransitionTime.setter + def lastTransitionTime(self, new_val): + # type: (Optional[str]) -> None + self._lastTransitionTime = new_val + + @property + def message(self): + # type: () -> str + return self._property_impl('message') + + @message.setter + def message(self, new_val): + # type: (Optional[str]) -> None + self._message = new_val + + @property + def reason(self): + # type: () -> str + return self._property_impl('reason') + + @reason.setter + def reason(self, new_val): + # type: (Optional[str]) -> None + self._reason = new_val + + @property + def status(self): + # type: () -> str + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[str]) -> None + self._status = new_val + + @property + def type(self): + # type: () -> str + return self._property_impl('type') + + @type.setter + def type(self, new_val): + # type: (Optional[str]) -> None + self._type = new_val + + @property + def lastProbeTime(self): + # type: () -> str + return self._property_impl('lastProbeTime') + + @lastProbeTime.setter + def lastProbeTime(self, new_val): + # type: (Optional[str]) -> None + self._lastProbeTime = new_val + + +class ConditionsList(CrdObjectList): + _items_type = ConditionsItem + + +class VolumeClaimTemplate(CrdObject): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', 'Metadata', False, False), + ('spec', 'spec', 'Spec', False, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Metadata] + spec=_omit, # type: Optional[Spec] + status=_omit, # type: Optional[Status] + ): + super(VolumeClaimTemplate, self).__init__( + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + spec=spec, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Metadata + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Metadata]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Optional[Spec]) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val + + +class ZonesItem(CrdObject): + _properties = [ + ('arbiter', 'arbiter', bool, False, False), + ('name', 'name', str, False, False), + ('volumeClaimTemplate', 'volumeClaimTemplate', 'VolumeClaimTemplate', False, False) + ] + + def __init__(self, + arbiter=_omit, # type: Optional[bool] + name=_omit, # type: Optional[str] + volumeClaimTemplate=_omit, # type: Optional[VolumeClaimTemplate] + ): + super(ZonesItem, self).__init__( + arbiter=arbiter, + name=name, + volumeClaimTemplate=volumeClaimTemplate, + ) + + @property + def arbiter(self): + # type: () -> bool + return self._property_impl('arbiter') + + @arbiter.setter + def arbiter(self, new_val): + # type: (Optional[bool]) -> None + self._arbiter = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + @property + def volumeClaimTemplate(self): + # type: () -> VolumeClaimTemplate + return self._property_impl('volumeClaimTemplate') + + @volumeClaimTemplate.setter + def volumeClaimTemplate(self, new_val): + # type: (Optional[VolumeClaimTemplate]) -> None + self._volumeClaimTemplate = new_val + + +class ZonesList(CrdObjectList): + _items_type = ZonesItem + + +class StretchCluster(CrdObject): + _properties = [ + ('failureDomainLabel', 'failureDomainLabel', str, False, False), + ('subFailureDomain', 'subFailureDomain', str, False, False), + ('zones', 'zones', 'ZonesList', False, True) + ] + + def __init__(self, + failureDomainLabel=_omit, # type: Optional[str] + subFailureDomain=_omit, # type: Optional[str] + zones=_omit, # type: Optional[Union[List[ZonesItem], CrdObjectList]] + ): + super(StretchCluster, self).__init__( + failureDomainLabel=failureDomainLabel, + subFailureDomain=subFailureDomain, + zones=zones, + ) + + @property + def failureDomainLabel(self): + # type: () -> str + return self._property_impl('failureDomainLabel') + + @failureDomainLabel.setter + def failureDomainLabel(self, new_val): + # type: (Optional[str]) -> None + self._failureDomainLabel = new_val + + @property + def subFailureDomain(self): + # type: () -> str + return self._property_impl('subFailureDomain') + + @subFailureDomain.setter + def subFailureDomain(self, new_val): + # type: (Optional[str]) -> None + self._subFailureDomain = new_val + + @property + def zones(self): + # type: () -> Optional[Union[List[ZonesItem], CrdObjectList]] + return self._property_impl('zones') + + @zones.setter + def zones(self, new_val): + # type: (Optional[Union[List[ZonesItem], CrdObjectList]]) -> None + self._zones = new_val + + +class TargetRef(CrdObject): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('fieldPath', 'fieldPath', str, False, False), + ('kind', 'kind', str, False, False), + ('name', 'name', str, False, False), + ('namespace', 'namespace', str, False, False), + ('resourceVersion', 'resourceVersion', str, False, False), + ('uid', 'uid', str, False, False) + ] + + def __init__(self, + apiVersion=_omit, # type: Optional[str] + fieldPath=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + name=_omit, # type: Optional[str] + namespace=_omit, # type: Optional[str] + resourceVersion=_omit, # type: Optional[str] + uid=_omit, # type: Optional[str] + ): + super(TargetRef, self).__init__( + apiVersion=apiVersion, + fieldPath=fieldPath, + kind=kind, + name=name, + namespace=namespace, + resourceVersion=resourceVersion, + uid=uid, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def fieldPath(self): + # type: () -> str + return self._property_impl('fieldPath') + + @fieldPath.setter + def fieldPath(self, new_val): + # type: (Optional[str]) -> None + self._fieldPath = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + @property + def namespace(self): + # type: () -> str + return self._property_impl('namespace') + + @namespace.setter + def namespace(self, new_val): + # type: (Optional[str]) -> None + self._namespace = new_val + + @property + def resourceVersion(self): + # type: () -> str + return self._property_impl('resourceVersion') + + @resourceVersion.setter + def resourceVersion(self, new_val): + # type: (Optional[str]) -> None + self._resourceVersion = new_val + + @property + def uid(self): + # type: () -> str + return self._property_impl('uid') + + @uid.setter + def uid(self, new_val): + # type: (Optional[str]) -> None + self._uid = new_val + + +class ExternalMgrEndpointsItem(CrdObject): + _properties = [ + ('hostname', 'hostname', str, False, False), + ('ip', 'ip', str, True, False), + ('nodeName', 'nodeName', str, False, False), + ('targetRef', 'targetRef', 'TargetRef', False, False) + ] + + def __init__(self, + ip, # type: str + hostname=_omit, # type: Optional[str] + nodeName=_omit, # type: Optional[str] + targetRef=_omit, # type: Optional[TargetRef] + ): + super(ExternalMgrEndpointsItem, self).__init__( + ip=ip, + hostname=hostname, + nodeName=nodeName, + targetRef=targetRef, + ) + + @property + def hostname(self): + # type: () -> str + return self._property_impl('hostname') + + @hostname.setter + def hostname(self, new_val): + # type: (Optional[str]) -> None + self._hostname = new_val + + @property + def ip(self): + # type: () -> str + return self._property_impl('ip') + + @ip.setter + def ip(self, new_val): + # type: (str) -> None + self._ip = new_val + + @property + def nodeName(self): + # type: () -> str + return self._property_impl('nodeName') + + @nodeName.setter + def nodeName(self, new_val): + # type: (Optional[str]) -> None + self._nodeName = new_val + + @property + def targetRef(self): + # type: () -> TargetRef + return self._property_impl('targetRef') + + @targetRef.setter + def targetRef(self, new_val): + # type: (Optional[TargetRef]) -> None + self._targetRef = new_val + + +class ExternalMgrEndpointsList(CrdObjectList): + _items_type = ExternalMgrEndpointsItem + + +class Monitoring(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('externalMgrEndpoints', 'externalMgrEndpoints', 'ExternalMgrEndpointsList', False, True), + ('externalMgrPrometheusPort', 'externalMgrPrometheusPort', int, False, False), + ('rulesNamespace', 'rulesNamespace', str, False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + externalMgrEndpoints=_omit, # type: Optional[Union[List[ExternalMgrEndpointsItem], CrdObjectList]] + externalMgrPrometheusPort=_omit, # type: Optional[int] + rulesNamespace=_omit, # type: Optional[str] + ): + super(Monitoring, self).__init__( + enabled=enabled, + externalMgrEndpoints=externalMgrEndpoints, + externalMgrPrometheusPort=externalMgrPrometheusPort, + rulesNamespace=rulesNamespace, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def externalMgrEndpoints(self): + # type: () -> Optional[Union[List[ExternalMgrEndpointsItem], CrdObjectList]] + return self._property_impl('externalMgrEndpoints') + + @externalMgrEndpoints.setter + def externalMgrEndpoints(self, new_val): + # type: (Optional[Union[List[ExternalMgrEndpointsItem], CrdObjectList]]) -> None + self._externalMgrEndpoints = new_val + + @property + def externalMgrPrometheusPort(self): + # type: () -> int + return self._property_impl('externalMgrPrometheusPort') + + @externalMgrPrometheusPort.setter + def externalMgrPrometheusPort(self, new_val): + # type: (Optional[int]) -> None + self._externalMgrPrometheusPort = new_val + + @property + def rulesNamespace(self): + # type: () -> str + return self._property_impl('rulesNamespace') + + @rulesNamespace.setter + def rulesNamespace(self, new_val): + # type: (Optional[str]) -> None + self._rulesNamespace = new_val + + +class Network(CrdObject): + _properties = [ + ('dualStack', 'dualStack', bool, False, False), + ('hostNetwork', 'hostNetwork', bool, False, False), + ('ipFamily', 'ipFamily', str, False, True), + ('provider', 'provider', str, False, True), + ('selectors', 'selectors', object, False, True) + ] + + def __init__(self, + dualStack=_omit, # type: Optional[bool] + hostNetwork=_omit, # type: Optional[bool] + ipFamily=_omit, # type: Optional[str] + provider=_omit, # type: Optional[str] + selectors=_omit, # type: Optional[Any] + ): + super(Network, self).__init__( + dualStack=dualStack, + hostNetwork=hostNetwork, + ipFamily=ipFamily, + provider=provider, + selectors=selectors, + ) + + @property + def dualStack(self): + # type: () -> bool + return self._property_impl('dualStack') + + @dualStack.setter + def dualStack(self, new_val): + # type: (Optional[bool]) -> None + self._dualStack = new_val + + @property + def hostNetwork(self): + # type: () -> bool + return self._property_impl('hostNetwork') + + @hostNetwork.setter + def hostNetwork(self, new_val): + # type: (Optional[bool]) -> None + self._hostNetwork = new_val + + @property + def ipFamily(self): + # type: () -> Optional[str] + return self._property_impl('ipFamily') + + @ipFamily.setter + def ipFamily(self, new_val): + # type: (Optional[str]) -> None + self._ipFamily = new_val + + @property + def provider(self): + # type: () -> Optional[str] + return self._property_impl('provider') + + @provider.setter + def provider(self, new_val): + # type: (Optional[str]) -> None + self._provider = new_val + + @property + def selectors(self): + # type: () -> Optional[Any] + return self._property_impl('selectors') + + @selectors.setter + def selectors(self, new_val): + # type: (Optional[Any]) -> None + self._selectors = new_val + + +class Kms(CrdObject): + _properties = [ + ('connectionDetails', 'connectionDetails', object, False, True), + ('tokenSecretName', 'tokenSecretName', str, False, False) + ] + + def __init__(self, + connectionDetails=_omit, # type: Optional[Any] + tokenSecretName=_omit, # type: Optional[str] + ): + super(Kms, self).__init__( + connectionDetails=connectionDetails, + tokenSecretName=tokenSecretName, + ) + + @property + def connectionDetails(self): + # type: () -> Optional[Any] + return self._property_impl('connectionDetails') + + @connectionDetails.setter + def connectionDetails(self, new_val): + # type: (Optional[Any]) -> None + self._connectionDetails = new_val + + @property + def tokenSecretName(self): + # type: () -> str + return self._property_impl('tokenSecretName') + + @tokenSecretName.setter + def tokenSecretName(self, new_val): + # type: (Optional[str]) -> None + self._tokenSecretName = new_val + + +class Security(CrdObject): + _properties = [ + ('kms', 'kms', 'Kms', False, True) + ] + + def __init__(self, + kms=_omit, # type: Optional[Kms] + ): + super(Security, self).__init__( + kms=kms, + ) + + @property + def kms(self): + # type: () -> Optional[Kms] + return self._property_impl('kms') + + @kms.setter + def kms(self, new_val): + # type: (Optional[Kms]) -> None + self._kms = new_val + + +class DevicesItem(CrdObject): + _properties = [ + ('config', 'config', object, False, False), + ('fullpath', 'fullpath', str, False, False), + ('name', 'name', str, False, False) + ] + + def __init__(self, + config=_omit, # type: Optional[Any] + fullpath=_omit, # type: Optional[str] + name=_omit, # type: Optional[str] + ): + super(DevicesItem, self).__init__( + config=config, + fullpath=fullpath, + name=name, + ) + + @property + def config(self): + # type: () -> Any + return self._property_impl('config') + + @config.setter + def config(self, new_val): + # type: (Optional[Any]) -> None + self._config = new_val + + @property + def fullpath(self): + # type: () -> str + return self._property_impl('fullpath') + + @fullpath.setter + def fullpath(self, new_val): + # type: (Optional[str]) -> None + self._fullpath = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + +class DevicesList(CrdObjectList): + _items_type = DevicesItem + + +class VolumeClaimTemplatesItem(CrdObject): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', 'Metadata', False, False), + ('spec', 'spec', 'Spec', False, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Metadata] + spec=_omit, # type: Optional[Spec] + status=_omit, # type: Optional[Status] + ): + super(VolumeClaimTemplatesItem, self).__init__( + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + spec=spec, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Metadata + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Metadata]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Optional[Spec]) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val + + +class VolumeClaimTemplatesList(CrdObjectList): + _items_type = VolumeClaimTemplatesItem + + +class NodesItem(CrdObject): + _properties = [ + ('config', 'config', object, False, True), + ('deviceFilter', 'deviceFilter', str, False, False), + ('devicePathFilter', 'devicePathFilter', str, False, False), + ('devices', 'devices', 'DevicesList', False, True), + ('name', 'name', str, False, False), + ('resources', 'resources', 'Resources', False, True), + ('useAllDevices', 'useAllDevices', bool, False, False), + ('volumeClaimTemplates', 'volumeClaimTemplates', 'VolumeClaimTemplatesList', False, False) + ] + + def __init__(self, + config=_omit, # type: Optional[Any] + deviceFilter=_omit, # type: Optional[str] + devicePathFilter=_omit, # type: Optional[str] + devices=_omit, # type: Optional[Union[List[DevicesItem], CrdObjectList]] + name=_omit, # type: Optional[str] + resources=_omit, # type: Optional[Resources] + useAllDevices=_omit, # type: Optional[bool] + volumeClaimTemplates=_omit, # type: Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]] + ): + super(NodesItem, self).__init__( + config=config, + deviceFilter=deviceFilter, + devicePathFilter=devicePathFilter, + devices=devices, + name=name, + resources=resources, + useAllDevices=useAllDevices, + volumeClaimTemplates=volumeClaimTemplates, + ) + + @property + def config(self): + # type: () -> Optional[Any] + return self._property_impl('config') + + @config.setter + def config(self, new_val): + # type: (Optional[Any]) -> None + self._config = new_val + + @property + def deviceFilter(self): + # type: () -> str + return self._property_impl('deviceFilter') + + @deviceFilter.setter + def deviceFilter(self, new_val): + # type: (Optional[str]) -> None + self._deviceFilter = new_val + + @property + def devicePathFilter(self): + # type: () -> str + return self._property_impl('devicePathFilter') + + @devicePathFilter.setter + def devicePathFilter(self, new_val): + # type: (Optional[str]) -> None + self._devicePathFilter = new_val + + @property + def devices(self): + # type: () -> Optional[Union[List[DevicesItem], CrdObjectList]] + return self._property_impl('devices') + + @devices.setter + def devices(self, new_val): + # type: (Optional[Union[List[DevicesItem], CrdObjectList]]) -> None + self._devices = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + @property + def resources(self): + # type: () -> Optional[Resources] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Resources]) -> None + self._resources = new_val + + @property + def useAllDevices(self): + # type: () -> bool + return self._property_impl('useAllDevices') + + @useAllDevices.setter + def useAllDevices(self, new_val): + # type: (Optional[bool]) -> None + self._useAllDevices = new_val + + @property + def volumeClaimTemplates(self): + # type: () -> Union[List[VolumeClaimTemplatesItem], CrdObjectList] + return self._property_impl('volumeClaimTemplates') + + @volumeClaimTemplates.setter + def volumeClaimTemplates(self, new_val): + # type: (Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]]) -> None + self._volumeClaimTemplates = new_val + + +class NodesList(CrdObjectList): + _items_type = NodesItem + + +class MatchFieldsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchFieldsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchFieldsList(CrdObjectList): + _items_type = MatchFieldsItem + + +class Preference(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(Preference, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False), + ('weight', 'weight', int, False, False), + ('preference', 'preference', 'Preference', False, False) + ] + + def __init__(self, + podAffinityTerm=_omit, # type: Optional[PodAffinityTerm] + weight=_omit, # type: Optional[int] + preference=_omit, # type: Optional[Preference] + ): + super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + podAffinityTerm=podAffinityTerm, + weight=weight, + preference=preference, + ) + + @property + def podAffinityTerm(self): + # type: () -> PodAffinityTerm + return self._property_impl('podAffinityTerm') + + @podAffinityTerm.setter + def podAffinityTerm(self, new_val): + # type: (Optional[PodAffinityTerm]) -> None + self._podAffinityTerm = new_val + + @property + def weight(self): + # type: () -> int + return self._property_impl('weight') + + @weight.setter + def weight(self, new_val): + # type: (Optional[int]) -> None + self._weight = new_val + + @property + def preference(self): + # type: () -> Preference + return self._property_impl('preference') + + @preference.setter + def preference(self, new_val): + # type: (Optional[Preference]) -> None + self._preference = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem + + +class NodeSelectorTermsItem(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(NodeSelectorTermsItem, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class NodeSelectorTermsList(CrdObjectList): + _items_type = NodeSelectorTermsItem + + +class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject): + _properties = [ + ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False) + ] + + def __init__(self, + nodeSelectorTerms, # type: Union[List[NodeSelectorTermsItem], CrdObjectList] + ): + super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__( + nodeSelectorTerms=nodeSelectorTerms, + ) + + @property + def nodeSelectorTerms(self): + # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList] + return self._property_impl('nodeSelectorTerms') + + @nodeSelectorTerms.setter + def nodeSelectorTerms(self, new_val): + # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None + self._nodeSelectorTerms = new_val + + +class NodeAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution] + ): + super(NodeAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> RequiredDuringSchedulingIgnoredDuringExecution + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class LabelSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(LabelSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespaceSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(NamespaceSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespacesList(CrdObjectList): + _items_type = str + + +class PodAffinityTerm(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(PodAffinityTerm, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem + + +class PodAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class PodAntiAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAntiAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class TolerationsItem(CrdObject): + _properties = [ + ('effect', 'effect', str, False, False), + ('key', 'key', str, False, False), + ('operator', 'operator', str, False, False), + ('tolerationSeconds', 'tolerationSeconds', int, False, False), + ('value', 'value', str, False, False) + ] + + def __init__(self, + effect=_omit, # type: Optional[str] + key=_omit, # type: Optional[str] + operator=_omit, # type: Optional[str] + tolerationSeconds=_omit, # type: Optional[int] + value=_omit, # type: Optional[str] + ): + super(TolerationsItem, self).__init__( + effect=effect, + key=key, + operator=operator, + tolerationSeconds=tolerationSeconds, + value=value, + ) + + @property + def effect(self): + # type: () -> str + return self._property_impl('effect') + + @effect.setter + def effect(self, new_val): + # type: (Optional[str]) -> None + self._effect = new_val + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (Optional[str]) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (Optional[str]) -> None + self._operator = new_val + + @property + def tolerationSeconds(self): + # type: () -> int + return self._property_impl('tolerationSeconds') + + @tolerationSeconds.setter + def tolerationSeconds(self, new_val): + # type: (Optional[int]) -> None + self._tolerationSeconds = new_val + + @property + def value(self): + # type: () -> str + return self._property_impl('value') + + @value.setter + def value(self, new_val): + # type: (Optional[str]) -> None + self._value = new_val + + +class TolerationsList(CrdObjectList): + _items_type = TolerationsItem + + +class TopologySpreadConstraintsItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('maxSkew', 'maxSkew', int, True, False), + ('topologyKey', 'topologyKey', str, True, False), + ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False) + ] + + def __init__(self, + maxSkew, # type: int + topologyKey, # type: str + whenUnsatisfiable, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + ): + super(TopologySpreadConstraintsItem, self).__init__( + maxSkew=maxSkew, + topologyKey=topologyKey, + whenUnsatisfiable=whenUnsatisfiable, + labelSelector=labelSelector, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def maxSkew(self): + # type: () -> int + return self._property_impl('maxSkew') + + @maxSkew.setter + def maxSkew(self, new_val): + # type: (int) -> None + self._maxSkew = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + @property + def whenUnsatisfiable(self): + # type: () -> str + return self._property_impl('whenUnsatisfiable') + + @whenUnsatisfiable.setter + def whenUnsatisfiable(self, new_val): + # type: (str) -> None + self._whenUnsatisfiable = new_val + + +class TopologySpreadConstraintsList(CrdObjectList): + _items_type = TopologySpreadConstraintsItem + + +class Placement(CrdObject): + _properties = [ + ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False), + ('podAffinity', 'podAffinity', 'PodAffinity', False, False), + ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False), + ('tolerations', 'tolerations', 'TolerationsList', False, False), + ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False) + ] + + def __init__(self, + nodeAffinity=_omit, # type: Optional[NodeAffinity] + podAffinity=_omit, # type: Optional[PodAffinity] + podAntiAffinity=_omit, # type: Optional[PodAntiAffinity] + tolerations=_omit, # type: Optional[Union[List[TolerationsItem], CrdObjectList]] + topologySpreadConstraints=_omit, # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]] + ): + super(Placement, self).__init__( + nodeAffinity=nodeAffinity, + podAffinity=podAffinity, + podAntiAffinity=podAntiAffinity, + tolerations=tolerations, + topologySpreadConstraints=topologySpreadConstraints, + ) + + @property + def nodeAffinity(self): + # type: () -> NodeAffinity + return self._property_impl('nodeAffinity') + + @nodeAffinity.setter + def nodeAffinity(self, new_val): + # type: (Optional[NodeAffinity]) -> None + self._nodeAffinity = new_val + + @property + def podAffinity(self): + # type: () -> PodAffinity + return self._property_impl('podAffinity') + + @podAffinity.setter + def podAffinity(self, new_val): + # type: (Optional[PodAffinity]) -> None + self._podAffinity = new_val + + @property + def podAntiAffinity(self): + # type: () -> PodAntiAffinity + return self._property_impl('podAntiAffinity') + + @podAntiAffinity.setter + def podAntiAffinity(self, new_val): + # type: (Optional[PodAntiAffinity]) -> None + self._podAntiAffinity = new_val + + @property + def tolerations(self): + # type: () -> Union[List[TolerationsItem], CrdObjectList] + return self._property_impl('tolerations') + + @tolerations.setter + def tolerations(self, new_val): + # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None + self._tolerations = new_val + + @property + def topologySpreadConstraints(self): + # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList] + return self._property_impl('topologySpreadConstraints') + + @topologySpreadConstraints.setter + def topologySpreadConstraints(self, new_val): + # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None + self._topologySpreadConstraints = new_val + + +class PreparePlacement(CrdObject): + _properties = [ + ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False), + ('podAffinity', 'podAffinity', 'PodAffinity', False, False), + ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False), + ('tolerations', 'tolerations', 'TolerationsList', False, False), + ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False) + ] + + def __init__(self, + nodeAffinity=_omit, # type: Optional[NodeAffinity] + podAffinity=_omit, # type: Optional[PodAffinity] + podAntiAffinity=_omit, # type: Optional[PodAntiAffinity] + tolerations=_omit, # type: Optional[Union[List[TolerationsItem], CrdObjectList]] + topologySpreadConstraints=_omit, # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]] + ): + super(PreparePlacement, self).__init__( + nodeAffinity=nodeAffinity, + podAffinity=podAffinity, + podAntiAffinity=podAntiAffinity, + tolerations=tolerations, + topologySpreadConstraints=topologySpreadConstraints, + ) + + @property + def nodeAffinity(self): + # type: () -> NodeAffinity + return self._property_impl('nodeAffinity') + + @nodeAffinity.setter + def nodeAffinity(self, new_val): + # type: (Optional[NodeAffinity]) -> None + self._nodeAffinity = new_val + + @property + def podAffinity(self): + # type: () -> PodAffinity + return self._property_impl('podAffinity') + + @podAffinity.setter + def podAffinity(self, new_val): + # type: (Optional[PodAffinity]) -> None + self._podAffinity = new_val + + @property + def podAntiAffinity(self): + # type: () -> PodAntiAffinity + return self._property_impl('podAntiAffinity') + + @podAntiAffinity.setter + def podAntiAffinity(self, new_val): + # type: (Optional[PodAntiAffinity]) -> None + self._podAntiAffinity = new_val + + @property + def tolerations(self): + # type: () -> Union[List[TolerationsItem], CrdObjectList] + return self._property_impl('tolerations') + + @tolerations.setter + def tolerations(self, new_val): + # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None + self._tolerations = new_val + + @property + def topologySpreadConstraints(self): + # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList] + return self._property_impl('topologySpreadConstraints') + + @topologySpreadConstraints.setter + def topologySpreadConstraints(self, new_val): + # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None + self._topologySpreadConstraints = new_val + + +class StorageClassDeviceSetsItem(CrdObject): + _properties = [ + ('config', 'config', object, False, True), + ('count', 'count', int, True, False), + ('encrypted', 'encrypted', bool, False, False), + ('name', 'name', str, True, False), + ('placement', 'placement', 'Placement', False, True), + ('portable', 'portable', bool, False, False), + ('preparePlacement', 'preparePlacement', 'PreparePlacement', False, True), + ('resources', 'resources', 'Resources', False, True), + ('schedulerName', 'schedulerName', str, False, False), + ('tuneDeviceClass', 'tuneDeviceClass', bool, False, False), + ('tuneFastDeviceClass', 'tuneFastDeviceClass', bool, False, False), + ('volumeClaimTemplates', 'volumeClaimTemplates', 'VolumeClaimTemplatesList', True, False) + ] + + def __init__(self, + count, # type: int + name, # type: str + volumeClaimTemplates, # type: Union[List[VolumeClaimTemplatesItem], CrdObjectList] + config=_omit, # type: Optional[Any] + encrypted=_omit, # type: Optional[bool] + placement=_omit, # type: Optional[Placement] + portable=_omit, # type: Optional[bool] + preparePlacement=_omit, # type: Optional[PreparePlacement] + resources=_omit, # type: Optional[Resources] + schedulerName=_omit, # type: Optional[str] + tuneDeviceClass=_omit, # type: Optional[bool] + tuneFastDeviceClass=_omit, # type: Optional[bool] + ): + super(StorageClassDeviceSetsItem, self).__init__( + count=count, + name=name, + volumeClaimTemplates=volumeClaimTemplates, + config=config, + encrypted=encrypted, + placement=placement, + portable=portable, + preparePlacement=preparePlacement, + resources=resources, + schedulerName=schedulerName, + tuneDeviceClass=tuneDeviceClass, + tuneFastDeviceClass=tuneFastDeviceClass, + ) + + @property + def config(self): + # type: () -> Optional[Any] + return self._property_impl('config') + + @config.setter + def config(self, new_val): + # type: (Optional[Any]) -> None + self._config = new_val + + @property + def count(self): + # type: () -> int + return self._property_impl('count') + + @count.setter + def count(self, new_val): + # type: (int) -> None + self._count = new_val + + @property + def encrypted(self): + # type: () -> bool + return self._property_impl('encrypted') + + @encrypted.setter + def encrypted(self, new_val): + # type: (Optional[bool]) -> None + self._encrypted = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (str) -> None + self._name = new_val + + @property + def placement(self): + # type: () -> Optional[Placement] + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Placement]) -> None + self._placement = new_val + + @property + def portable(self): + # type: () -> bool + return self._property_impl('portable') + + @portable.setter + def portable(self, new_val): + # type: (Optional[bool]) -> None + self._portable = new_val + + @property + def preparePlacement(self): + # type: () -> Optional[PreparePlacement] + return self._property_impl('preparePlacement') + + @preparePlacement.setter + def preparePlacement(self, new_val): + # type: (Optional[PreparePlacement]) -> None + self._preparePlacement = new_val + + @property + def resources(self): + # type: () -> Optional[Resources] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Resources]) -> None + self._resources = new_val + + @property + def schedulerName(self): + # type: () -> str + return self._property_impl('schedulerName') + + @schedulerName.setter + def schedulerName(self, new_val): + # type: (Optional[str]) -> None + self._schedulerName = new_val + + @property + def tuneDeviceClass(self): + # type: () -> bool + return self._property_impl('tuneDeviceClass') + + @tuneDeviceClass.setter + def tuneDeviceClass(self, new_val): + # type: (Optional[bool]) -> None + self._tuneDeviceClass = new_val + + @property + def tuneFastDeviceClass(self): + # type: () -> bool + return self._property_impl('tuneFastDeviceClass') + + @tuneFastDeviceClass.setter + def tuneFastDeviceClass(self, new_val): + # type: (Optional[bool]) -> None + self._tuneFastDeviceClass = new_val + + @property + def volumeClaimTemplates(self): + # type: () -> Union[List[VolumeClaimTemplatesItem], CrdObjectList] + return self._property_impl('volumeClaimTemplates') + + @volumeClaimTemplates.setter + def volumeClaimTemplates(self, new_val): + # type: (Union[List[VolumeClaimTemplatesItem], CrdObjectList]) -> None + self._volumeClaimTemplates = new_val + + +class StorageClassDeviceSetsList(CrdObjectList): + _items_type = StorageClassDeviceSetsItem + + +class Storage(CrdObject): + _properties = [ + ('deviceClasses', 'deviceClasses', 'DeviceClassesList', False, False), + ('config', 'config', object, False, True), + ('deviceFilter', 'deviceFilter', str, False, False), + ('devicePathFilter', 'devicePathFilter', str, False, False), + ('devices', 'devices', 'DevicesList', False, True), + ('nodes', 'nodes', 'NodesList', False, True), + ('storageClassDeviceSets', 'storageClassDeviceSets', 'StorageClassDeviceSetsList', False, True), + ('useAllDevices', 'useAllDevices', bool, False, False), + ('useAllNodes', 'useAllNodes', bool, False, False), + ('volumeClaimTemplates', 'volumeClaimTemplates', 'VolumeClaimTemplatesList', False, False) + ] + + def __init__(self, + deviceClasses=_omit, # type: Optional[Union[List[DeviceClassesItem], CrdObjectList]] + config=_omit, # type: Optional[Any] + deviceFilter=_omit, # type: Optional[str] + devicePathFilter=_omit, # type: Optional[str] + devices=_omit, # type: Optional[Union[List[DevicesItem], CrdObjectList]] + nodes=_omit, # type: Optional[Union[List[NodesItem], CrdObjectList]] + storageClassDeviceSets=_omit, # type: Optional[Union[List[StorageClassDeviceSetsItem], CrdObjectList]] + useAllDevices=_omit, # type: Optional[bool] + useAllNodes=_omit, # type: Optional[bool] + volumeClaimTemplates=_omit, # type: Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]] + ): + super(Storage, self).__init__( + deviceClasses=deviceClasses, + config=config, + deviceFilter=deviceFilter, + devicePathFilter=devicePathFilter, + devices=devices, + nodes=nodes, + storageClassDeviceSets=storageClassDeviceSets, + useAllDevices=useAllDevices, + useAllNodes=useAllNodes, + volumeClaimTemplates=volumeClaimTemplates, + ) + + @property + def deviceClasses(self): + # type: () -> Union[List[DeviceClassesItem], CrdObjectList] + return self._property_impl('deviceClasses') + + @deviceClasses.setter + def deviceClasses(self, new_val): + # type: (Optional[Union[List[DeviceClassesItem], CrdObjectList]]) -> None + self._deviceClasses = new_val + + @property + def config(self): + # type: () -> Optional[Any] + return self._property_impl('config') + + @config.setter + def config(self, new_val): + # type: (Optional[Any]) -> None + self._config = new_val + + @property + def deviceFilter(self): + # type: () -> str + return self._property_impl('deviceFilter') + + @deviceFilter.setter + def deviceFilter(self, new_val): + # type: (Optional[str]) -> None + self._deviceFilter = new_val + + @property + def devicePathFilter(self): + # type: () -> str + return self._property_impl('devicePathFilter') + + @devicePathFilter.setter + def devicePathFilter(self, new_val): + # type: (Optional[str]) -> None + self._devicePathFilter = new_val + + @property + def devices(self): + # type: () -> Optional[Union[List[DevicesItem], CrdObjectList]] + return self._property_impl('devices') + + @devices.setter + def devices(self, new_val): + # type: (Optional[Union[List[DevicesItem], CrdObjectList]]) -> None + self._devices = new_val + + @property + def nodes(self): + # type: () -> Optional[Union[List[NodesItem], CrdObjectList]] + return self._property_impl('nodes') + + @nodes.setter + def nodes(self, new_val): + # type: (Optional[Union[List[NodesItem], CrdObjectList]]) -> None + self._nodes = new_val + + @property + def storageClassDeviceSets(self): + # type: () -> Optional[Union[List[StorageClassDeviceSetsItem], CrdObjectList]] + return self._property_impl('storageClassDeviceSets') + + @storageClassDeviceSets.setter + def storageClassDeviceSets(self, new_val): + # type: (Optional[Union[List[StorageClassDeviceSetsItem], CrdObjectList]]) -> None + self._storageClassDeviceSets = new_val + + @property + def useAllDevices(self): + # type: () -> bool + return self._property_impl('useAllDevices') + + @useAllDevices.setter + def useAllDevices(self, new_val): + # type: (Optional[bool]) -> None + self._useAllDevices = new_val + + @property + def useAllNodes(self): + # type: () -> bool + return self._property_impl('useAllNodes') + + @useAllNodes.setter + def useAllNodes(self, new_val): + # type: (Optional[bool]) -> None + self._useAllNodes = new_val + + @property + def volumeClaimTemplates(self): + # type: () -> Union[List[VolumeClaimTemplatesItem], CrdObjectList] + return self._property_impl('volumeClaimTemplates') + + @volumeClaimTemplates.setter + def volumeClaimTemplates(self, new_val): + # type: (Optional[Union[List[VolumeClaimTemplatesItem], CrdObjectList]]) -> None + self._volumeClaimTemplates = new_val + + +class Capacity(CrdObject): + _properties = [ + ('bytesAvailable', 'bytesAvailable', int, False, False), + ('bytesTotal', 'bytesTotal', int, False, False), + ('bytesUsed', 'bytesUsed', int, False, False), + ('lastUpdated', 'lastUpdated', str, False, False) + ] + + def __init__(self, + bytesAvailable=_omit, # type: Optional[int] + bytesTotal=_omit, # type: Optional[int] + bytesUsed=_omit, # type: Optional[int] + lastUpdated=_omit, # type: Optional[str] + ): + super(Capacity, self).__init__( + bytesAvailable=bytesAvailable, + bytesTotal=bytesTotal, + bytesUsed=bytesUsed, + lastUpdated=lastUpdated, + ) + + @property + def bytesAvailable(self): + # type: () -> int + return self._property_impl('bytesAvailable') + + @bytesAvailable.setter + def bytesAvailable(self, new_val): + # type: (Optional[int]) -> None + self._bytesAvailable = new_val + + @property + def bytesTotal(self): + # type: () -> int + return self._property_impl('bytesTotal') + + @bytesTotal.setter + def bytesTotal(self, new_val): + # type: (Optional[int]) -> None + self._bytesTotal = new_val + + @property + def bytesUsed(self): + # type: () -> int + return self._property_impl('bytesUsed') + + @bytesUsed.setter + def bytesUsed(self, new_val): + # type: (Optional[int]) -> None + self._bytesUsed = new_val + + @property + def lastUpdated(self): + # type: () -> str + return self._property_impl('lastUpdated') + + @lastUpdated.setter + def lastUpdated(self, new_val): + # type: (Optional[str]) -> None + self._lastUpdated = new_val + + +class Versions(CrdObject): + _properties = [ + ('cephfs-mirror', 'cephfs_mirror', object, False, False), + ('mds', 'mds', object, False, False), + ('mgr', 'mgr', object, False, False), + ('mon', 'mon', object, False, False), + ('osd', 'osd', object, False, False), + ('overall', 'overall', object, False, False), + ('rbd-mirror', 'rbd_mirror', object, False, False), + ('rgw', 'rgw', object, False, False) + ] + + def __init__(self, + cephfs_mirror=_omit, # type: Optional[Any] + mds=_omit, # type: Optional[Any] + mgr=_omit, # type: Optional[Any] + mon=_omit, # type: Optional[Any] + osd=_omit, # type: Optional[Any] + overall=_omit, # type: Optional[Any] + rbd_mirror=_omit, # type: Optional[Any] + rgw=_omit, # type: Optional[Any] + ): + super(Versions, self).__init__( + cephfs_mirror=cephfs_mirror, + mds=mds, + mgr=mgr, + mon=mon, + osd=osd, + overall=overall, + rbd_mirror=rbd_mirror, + rgw=rgw, + ) + + @property + def cephfs_mirror(self): + # type: () -> Any + return self._property_impl('cephfs_mirror') + + @cephfs_mirror.setter + def cephfs_mirror(self, new_val): + # type: (Optional[Any]) -> None + self._cephfs_mirror = new_val + + @property + def mds(self): + # type: () -> Any + return self._property_impl('mds') + + @mds.setter + def mds(self, new_val): + # type: (Optional[Any]) -> None + self._mds = new_val + + @property + def mgr(self): + # type: () -> Any + return self._property_impl('mgr') + + @mgr.setter + def mgr(self, new_val): + # type: (Optional[Any]) -> None + self._mgr = new_val + + @property + def mon(self): + # type: () -> Any + return self._property_impl('mon') + + @mon.setter + def mon(self, new_val): + # type: (Optional[Any]) -> None + self._mon = new_val + + @property + def osd(self): + # type: () -> Any + return self._property_impl('osd') + + @osd.setter + def osd(self, new_val): + # type: (Optional[Any]) -> None + self._osd = new_val + + @property + def overall(self): + # type: () -> Any + return self._property_impl('overall') + + @overall.setter + def overall(self, new_val): + # type: (Optional[Any]) -> None + self._overall = new_val + + @property + def rbd_mirror(self): + # type: () -> Any + return self._property_impl('rbd_mirror') + + @rbd_mirror.setter + def rbd_mirror(self, new_val): + # type: (Optional[Any]) -> None + self._rbd_mirror = new_val + + @property + def rgw(self): + # type: () -> Any + return self._property_impl('rgw') + + @rgw.setter + def rgw(self, new_val): + # type: (Optional[Any]) -> None + self._rgw = new_val + + +class Ceph(CrdObject): + _properties = [ + ('capacity', 'capacity', 'Capacity', False, False), + ('details', 'details', object, False, False), + ('health', 'health', str, False, False), + ('lastChanged', 'lastChanged', str, False, False), + ('lastChecked', 'lastChecked', str, False, False), + ('previousHealth', 'previousHealth', str, False, False), + ('versions', 'versions', 'Versions', False, False) + ] + + def __init__(self, + capacity=_omit, # type: Optional[Capacity] + details=_omit, # type: Optional[Any] + health=_omit, # type: Optional[str] + lastChanged=_omit, # type: Optional[str] + lastChecked=_omit, # type: Optional[str] + previousHealth=_omit, # type: Optional[str] + versions=_omit, # type: Optional[Versions] + ): + super(Ceph, self).__init__( + capacity=capacity, + details=details, + health=health, + lastChanged=lastChanged, + lastChecked=lastChecked, + previousHealth=previousHealth, + versions=versions, + ) + + @property + def capacity(self): + # type: () -> Capacity + return self._property_impl('capacity') + + @capacity.setter + def capacity(self, new_val): + # type: (Optional[Capacity]) -> None + self._capacity = new_val + + @property + def details(self): + # type: () -> Any + return self._property_impl('details') + + @details.setter + def details(self, new_val): + # type: (Optional[Any]) -> None + self._details = new_val + + @property + def health(self): + # type: () -> str + return self._property_impl('health') + + @health.setter + def health(self, new_val): + # type: (Optional[str]) -> None + self._health = new_val + + @property + def lastChanged(self): + # type: () -> str + return self._property_impl('lastChanged') + + @lastChanged.setter + def lastChanged(self, new_val): + # type: (Optional[str]) -> None + self._lastChanged = new_val + + @property + def lastChecked(self): + # type: () -> str + return self._property_impl('lastChecked') + + @lastChecked.setter + def lastChecked(self, new_val): + # type: (Optional[str]) -> None + self._lastChecked = new_val + + @property + def previousHealth(self): + # type: () -> str + return self._property_impl('previousHealth') + + @previousHealth.setter + def previousHealth(self, new_val): + # type: (Optional[str]) -> None + self._previousHealth = new_val + + @property + def versions(self): + # type: () -> Versions + return self._property_impl('versions') + + @versions.setter + def versions(self, new_val): + # type: (Optional[Versions]) -> None + self._versions = new_val + + +class DeviceClassesItem(CrdObject): + _properties = [ + ('name', 'name', str, False, False) + ] + + def __init__(self, + name=_omit, # type: Optional[str] + ): + super(DeviceClassesItem, self).__init__( + name=name, + ) + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + +class DeviceClassesList(CrdObjectList): + _items_type = DeviceClassesItem + + +class Version(CrdObject): + _properties = [ + ('image', 'image', str, False, False), + ('version', 'version', str, False, False) + ] + + def __init__(self, + image=_omit, # type: Optional[str] + version=_omit, # type: Optional[str] + ): + super(Version, self).__init__( + image=image, + version=version, + ) + + @property + def image(self): + # type: () -> str + return self._property_impl('image') + + @image.setter + def image(self, new_val): + # type: (Optional[str]) -> None + self._image = new_val + + @property + def version(self): + # type: () -> str + return self._property_impl('version') + + @version.setter + def version(self, new_val): + # type: (Optional[str]) -> None + self._version = new_val + + +class CephCluster(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, True) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephCluster, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Optional[Status] + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystem.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystem.py new file mode 100644 index 000000000..c1eaa6dbc --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystem.py @@ -0,0 +1,1771 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class ErasureCoded(CrdObject): + _properties = [ + ('algorithm', 'algorithm', str, False, False), + ('codingChunks', 'codingChunks', int, True, False), + ('dataChunks', 'dataChunks', int, True, False) + ] + + def __init__(self, + codingChunks, # type: int + dataChunks, # type: int + algorithm=_omit, # type: Optional[str] + ): + super(ErasureCoded, self).__init__( + codingChunks=codingChunks, + dataChunks=dataChunks, + algorithm=algorithm, + ) + + @property + def algorithm(self): + # type: () -> str + return self._property_impl('algorithm') + + @algorithm.setter + def algorithm(self, new_val): + # type: (Optional[str]) -> None + self._algorithm = new_val + + @property + def codingChunks(self): + # type: () -> int + return self._property_impl('codingChunks') + + @codingChunks.setter + def codingChunks(self, new_val): + # type: (int) -> None + self._codingChunks = new_val + + @property + def dataChunks(self): + # type: () -> int + return self._property_impl('dataChunks') + + @dataChunks.setter + def dataChunks(self, new_val): + # type: (int) -> None + self._dataChunks = new_val + + +class SnapshotSchedulesItem(CrdObject): + _properties = [ + ('interval', 'interval', str, False, False), + ('startTime', 'startTime', str, False, False) + ] + + def __init__(self, + interval=_omit, # type: Optional[str] + startTime=_omit, # type: Optional[str] + ): + super(SnapshotSchedulesItem, self).__init__( + interval=interval, + startTime=startTime, + ) + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def startTime(self): + # type: () -> str + return self._property_impl('startTime') + + @startTime.setter + def startTime(self, new_val): + # type: (Optional[str]) -> None + self._startTime = new_val + + +class SnapshotSchedulesList(CrdObjectList): + _items_type = SnapshotSchedulesItem + + +class Mirroring(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('mode', 'mode', str, False, False), + ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + mode=_omit, # type: Optional[str] + snapshotSchedules=_omit, # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]] + ): + super(Mirroring, self).__init__( + enabled=enabled, + mode=mode, + snapshotSchedules=snapshotSchedules, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def mode(self): + # type: () -> str + return self._property_impl('mode') + + @mode.setter + def mode(self, new_val): + # type: (Optional[str]) -> None + self._mode = new_val + + @property + def snapshotSchedules(self): + # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList] + return self._property_impl('snapshotSchedules') + + @snapshotSchedules.setter + def snapshotSchedules(self, new_val): + # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None + self._snapshotSchedules = new_val + + +class Quotas(CrdObject): + _properties = [ + ('maxBytes', 'maxBytes', int, False, False), + ('maxObjects', 'maxObjects', int, False, False), + ('maxSize', 'maxSize', str, False, False) + ] + + def __init__(self, + maxBytes=_omit, # type: Optional[int] + maxObjects=_omit, # type: Optional[int] + maxSize=_omit, # type: Optional[str] + ): + super(Quotas, self).__init__( + maxBytes=maxBytes, + maxObjects=maxObjects, + maxSize=maxSize, + ) + + @property + def maxBytes(self): + # type: () -> int + return self._property_impl('maxBytes') + + @maxBytes.setter + def maxBytes(self, new_val): + # type: (Optional[int]) -> None + self._maxBytes = new_val + + @property + def maxObjects(self): + # type: () -> int + return self._property_impl('maxObjects') + + @maxObjects.setter + def maxObjects(self, new_val): + # type: (Optional[int]) -> None + self._maxObjects = new_val + + @property + def maxSize(self): + # type: () -> str + return self._property_impl('maxSize') + + @maxSize.setter + def maxSize(self, new_val): + # type: (Optional[str]) -> None + self._maxSize = new_val + + +class Replicated(CrdObject): + _properties = [ + ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False), + ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False), + ('size', 'size', int, True, False), + ('subFailureDomain', 'subFailureDomain', str, False, False), + ('targetSizeRatio', 'targetSizeRatio', float, False, False) + ] + + def __init__(self, + size, # type: int + replicasPerFailureDomain=_omit, # type: Optional[int] + requireSafeReplicaSize=_omit, # type: Optional[bool] + subFailureDomain=_omit, # type: Optional[str] + targetSizeRatio=_omit, # type: Optional[float] + ): + super(Replicated, self).__init__( + size=size, + replicasPerFailureDomain=replicasPerFailureDomain, + requireSafeReplicaSize=requireSafeReplicaSize, + subFailureDomain=subFailureDomain, + targetSizeRatio=targetSizeRatio, + ) + + @property + def replicasPerFailureDomain(self): + # type: () -> int + return self._property_impl('replicasPerFailureDomain') + + @replicasPerFailureDomain.setter + def replicasPerFailureDomain(self, new_val): + # type: (Optional[int]) -> None + self._replicasPerFailureDomain = new_val + + @property + def requireSafeReplicaSize(self): + # type: () -> bool + return self._property_impl('requireSafeReplicaSize') + + @requireSafeReplicaSize.setter + def requireSafeReplicaSize(self, new_val): + # type: (Optional[bool]) -> None + self._requireSafeReplicaSize = new_val + + @property + def size(self): + # type: () -> int + return self._property_impl('size') + + @size.setter + def size(self, new_val): + # type: (int) -> None + self._size = new_val + + @property + def subFailureDomain(self): + # type: () -> str + return self._property_impl('subFailureDomain') + + @subFailureDomain.setter + def subFailureDomain(self, new_val): + # type: (Optional[str]) -> None + self._subFailureDomain = new_val + + @property + def targetSizeRatio(self): + # type: () -> float + return self._property_impl('targetSizeRatio') + + @targetSizeRatio.setter + def targetSizeRatio(self, new_val): + # type: (Optional[float]) -> None + self._targetSizeRatio = new_val + + +class Mirror(CrdObject): + _properties = [ + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Mirror, self).__init__( + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class StatusCheck(CrdObject): + _properties = [ + ('mirror', 'mirror', 'Mirror', False, True) + ] + + def __init__(self, + mirror=_omit, # type: Optional[Mirror] + ): + super(StatusCheck, self).__init__( + mirror=mirror, + ) + + @property + def mirror(self): + # type: () -> Optional[Mirror] + return self._property_impl('mirror') + + @mirror.setter + def mirror(self, new_val): + # type: (Optional[Mirror]) -> None + self._mirror = new_val + + +class DataPoolsItem(CrdObject): + _properties = [ + ('compressionMode', 'compressionMode', str, False, True), + ('crushRoot', 'crushRoot', str, False, True), + ('deviceClass', 'deviceClass', str, False, True), + ('enableRBDStats', 'enableRBDStats', bool, False, False), + ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False), + ('failureDomain', 'failureDomain', str, False, False), + ('mirroring', 'mirroring', 'Mirroring', False, False), + ('parameters', 'parameters', object, False, True), + ('quotas', 'quotas', 'Quotas', False, True), + ('replicated', 'replicated', 'Replicated', False, False), + ('statusCheck', 'statusCheck', 'StatusCheck', False, False) + ] + + def __init__(self, + compressionMode=_omit, # type: Optional[str] + crushRoot=_omit, # type: Optional[str] + deviceClass=_omit, # type: Optional[str] + enableRBDStats=_omit, # type: Optional[bool] + erasureCoded=_omit, # type: Optional[ErasureCoded] + failureDomain=_omit, # type: Optional[str] + mirroring=_omit, # type: Optional[Mirroring] + parameters=_omit, # type: Optional[Any] + quotas=_omit, # type: Optional[Quotas] + replicated=_omit, # type: Optional[Replicated] + statusCheck=_omit, # type: Optional[StatusCheck] + ): + super(DataPoolsItem, self).__init__( + compressionMode=compressionMode, + crushRoot=crushRoot, + deviceClass=deviceClass, + enableRBDStats=enableRBDStats, + erasureCoded=erasureCoded, + failureDomain=failureDomain, + mirroring=mirroring, + parameters=parameters, + quotas=quotas, + replicated=replicated, + statusCheck=statusCheck, + ) + + @property + def compressionMode(self): + # type: () -> Optional[str] + return self._property_impl('compressionMode') + + @compressionMode.setter + def compressionMode(self, new_val): + # type: (Optional[str]) -> None + self._compressionMode = new_val + + @property + def crushRoot(self): + # type: () -> Optional[str] + return self._property_impl('crushRoot') + + @crushRoot.setter + def crushRoot(self, new_val): + # type: (Optional[str]) -> None + self._crushRoot = new_val + + @property + def deviceClass(self): + # type: () -> Optional[str] + return self._property_impl('deviceClass') + + @deviceClass.setter + def deviceClass(self, new_val): + # type: (Optional[str]) -> None + self._deviceClass = new_val + + @property + def enableRBDStats(self): + # type: () -> bool + return self._property_impl('enableRBDStats') + + @enableRBDStats.setter + def enableRBDStats(self, new_val): + # type: (Optional[bool]) -> None + self._enableRBDStats = new_val + + @property + def erasureCoded(self): + # type: () -> ErasureCoded + return self._property_impl('erasureCoded') + + @erasureCoded.setter + def erasureCoded(self, new_val): + # type: (Optional[ErasureCoded]) -> None + self._erasureCoded = new_val + + @property + def failureDomain(self): + # type: () -> str + return self._property_impl('failureDomain') + + @failureDomain.setter + def failureDomain(self, new_val): + # type: (Optional[str]) -> None + self._failureDomain = new_val + + @property + def mirroring(self): + # type: () -> Mirroring + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def parameters(self): + # type: () -> Optional[Any] + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def quotas(self): + # type: () -> Optional[Quotas] + return self._property_impl('quotas') + + @quotas.setter + def quotas(self, new_val): + # type: (Optional[Quotas]) -> None + self._quotas = new_val + + @property + def replicated(self): + # type: () -> Replicated + return self._property_impl('replicated') + + @replicated.setter + def replicated(self, new_val): + # type: (Optional[Replicated]) -> None + self._replicated = new_val + + @property + def statusCheck(self): + # type: () -> StatusCheck + return self._property_impl('statusCheck') + + @statusCheck.setter + def statusCheck(self, new_val): + # type: (Optional[StatusCheck]) -> None + self._statusCheck = new_val + + +class DataPoolsList(CrdObjectList): + _items_type = DataPoolsItem + + +class MetadataPool(CrdObject): + _properties = [ + ('compressionMode', 'compressionMode', str, False, True), + ('crushRoot', 'crushRoot', str, False, True), + ('deviceClass', 'deviceClass', str, False, True), + ('enableRBDStats', 'enableRBDStats', bool, False, False), + ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False), + ('failureDomain', 'failureDomain', str, False, False), + ('mirroring', 'mirroring', 'Mirroring', False, False), + ('parameters', 'parameters', object, False, True), + ('quotas', 'quotas', 'Quotas', False, True), + ('replicated', 'replicated', 'Replicated', False, False), + ('statusCheck', 'statusCheck', 'StatusCheck', False, False) + ] + + def __init__(self, + compressionMode=_omit, # type: Optional[str] + crushRoot=_omit, # type: Optional[str] + deviceClass=_omit, # type: Optional[str] + enableRBDStats=_omit, # type: Optional[bool] + erasureCoded=_omit, # type: Optional[ErasureCoded] + failureDomain=_omit, # type: Optional[str] + mirroring=_omit, # type: Optional[Mirroring] + parameters=_omit, # type: Optional[Any] + quotas=_omit, # type: Optional[Quotas] + replicated=_omit, # type: Optional[Replicated] + statusCheck=_omit, # type: Optional[StatusCheck] + ): + super(MetadataPool, self).__init__( + compressionMode=compressionMode, + crushRoot=crushRoot, + deviceClass=deviceClass, + enableRBDStats=enableRBDStats, + erasureCoded=erasureCoded, + failureDomain=failureDomain, + mirroring=mirroring, + parameters=parameters, + quotas=quotas, + replicated=replicated, + statusCheck=statusCheck, + ) + + @property + def compressionMode(self): + # type: () -> Optional[str] + return self._property_impl('compressionMode') + + @compressionMode.setter + def compressionMode(self, new_val): + # type: (Optional[str]) -> None + self._compressionMode = new_val + + @property + def crushRoot(self): + # type: () -> Optional[str] + return self._property_impl('crushRoot') + + @crushRoot.setter + def crushRoot(self, new_val): + # type: (Optional[str]) -> None + self._crushRoot = new_val + + @property + def deviceClass(self): + # type: () -> Optional[str] + return self._property_impl('deviceClass') + + @deviceClass.setter + def deviceClass(self, new_val): + # type: (Optional[str]) -> None + self._deviceClass = new_val + + @property + def enableRBDStats(self): + # type: () -> bool + return self._property_impl('enableRBDStats') + + @enableRBDStats.setter + def enableRBDStats(self, new_val): + # type: (Optional[bool]) -> None + self._enableRBDStats = new_val + + @property + def erasureCoded(self): + # type: () -> ErasureCoded + return self._property_impl('erasureCoded') + + @erasureCoded.setter + def erasureCoded(self, new_val): + # type: (Optional[ErasureCoded]) -> None + self._erasureCoded = new_val + + @property + def failureDomain(self): + # type: () -> str + return self._property_impl('failureDomain') + + @failureDomain.setter + def failureDomain(self, new_val): + # type: (Optional[str]) -> None + self._failureDomain = new_val + + @property + def mirroring(self): + # type: () -> Mirroring + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def parameters(self): + # type: () -> Optional[Any] + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def quotas(self): + # type: () -> Optional[Quotas] + return self._property_impl('quotas') + + @quotas.setter + def quotas(self, new_val): + # type: (Optional[Quotas]) -> None + self._quotas = new_val + + @property + def replicated(self): + # type: () -> Replicated + return self._property_impl('replicated') + + @replicated.setter + def replicated(self, new_val): + # type: (Optional[Replicated]) -> None + self._replicated = new_val + + @property + def statusCheck(self): + # type: () -> StatusCheck + return self._property_impl('statusCheck') + + @statusCheck.setter + def statusCheck(self, new_val): + # type: (Optional[StatusCheck]) -> None + self._statusCheck = new_val + + +class ValuesList(CrdObjectList): + _items_type = str + + +class MatchExpressionsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchExpressionsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchExpressionsList(CrdObjectList): + _items_type = MatchExpressionsItem + + +class MatchFieldsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchFieldsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchFieldsList(CrdObjectList): + _items_type = MatchFieldsItem + + +class Preference(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(Preference, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False), + ('weight', 'weight', int, False, False), + ('preference', 'preference', 'Preference', False, False) + ] + + def __init__(self, + podAffinityTerm=_omit, # type: Optional[PodAffinityTerm] + weight=_omit, # type: Optional[int] + preference=_omit, # type: Optional[Preference] + ): + super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + podAffinityTerm=podAffinityTerm, + weight=weight, + preference=preference, + ) + + @property + def podAffinityTerm(self): + # type: () -> PodAffinityTerm + return self._property_impl('podAffinityTerm') + + @podAffinityTerm.setter + def podAffinityTerm(self, new_val): + # type: (Optional[PodAffinityTerm]) -> None + self._podAffinityTerm = new_val + + @property + def weight(self): + # type: () -> int + return self._property_impl('weight') + + @weight.setter + def weight(self, new_val): + # type: (Optional[int]) -> None + self._weight = new_val + + @property + def preference(self): + # type: () -> Preference + return self._property_impl('preference') + + @preference.setter + def preference(self, new_val): + # type: (Optional[Preference]) -> None + self._preference = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem + + +class NodeSelectorTermsItem(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(NodeSelectorTermsItem, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class NodeSelectorTermsList(CrdObjectList): + _items_type = NodeSelectorTermsItem + + +class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject): + _properties = [ + ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False) + ] + + def __init__(self, + nodeSelectorTerms, # type: Union[List[NodeSelectorTermsItem], CrdObjectList] + ): + super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__( + nodeSelectorTerms=nodeSelectorTerms, + ) + + @property + def nodeSelectorTerms(self): + # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList] + return self._property_impl('nodeSelectorTerms') + + @nodeSelectorTerms.setter + def nodeSelectorTerms(self, new_val): + # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None + self._nodeSelectorTerms = new_val + + +class NodeAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution] + ): + super(NodeAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> RequiredDuringSchedulingIgnoredDuringExecution + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class LabelSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(LabelSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespaceSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(NamespaceSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespacesList(CrdObjectList): + _items_type = str + + +class PodAffinityTerm(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(PodAffinityTerm, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem + + +class PodAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class PodAntiAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAntiAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class TolerationsItem(CrdObject): + _properties = [ + ('effect', 'effect', str, False, False), + ('key', 'key', str, False, False), + ('operator', 'operator', str, False, False), + ('tolerationSeconds', 'tolerationSeconds', int, False, False), + ('value', 'value', str, False, False) + ] + + def __init__(self, + effect=_omit, # type: Optional[str] + key=_omit, # type: Optional[str] + operator=_omit, # type: Optional[str] + tolerationSeconds=_omit, # type: Optional[int] + value=_omit, # type: Optional[str] + ): + super(TolerationsItem, self).__init__( + effect=effect, + key=key, + operator=operator, + tolerationSeconds=tolerationSeconds, + value=value, + ) + + @property + def effect(self): + # type: () -> str + return self._property_impl('effect') + + @effect.setter + def effect(self, new_val): + # type: (Optional[str]) -> None + self._effect = new_val + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (Optional[str]) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (Optional[str]) -> None + self._operator = new_val + + @property + def tolerationSeconds(self): + # type: () -> int + return self._property_impl('tolerationSeconds') + + @tolerationSeconds.setter + def tolerationSeconds(self, new_val): + # type: (Optional[int]) -> None + self._tolerationSeconds = new_val + + @property + def value(self): + # type: () -> str + return self._property_impl('value') + + @value.setter + def value(self, new_val): + # type: (Optional[str]) -> None + self._value = new_val + + +class TolerationsList(CrdObjectList): + _items_type = TolerationsItem + + +class TopologySpreadConstraintsItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('maxSkew', 'maxSkew', int, True, False), + ('topologyKey', 'topologyKey', str, True, False), + ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False) + ] + + def __init__(self, + maxSkew, # type: int + topologyKey, # type: str + whenUnsatisfiable, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + ): + super(TopologySpreadConstraintsItem, self).__init__( + maxSkew=maxSkew, + topologyKey=topologyKey, + whenUnsatisfiable=whenUnsatisfiable, + labelSelector=labelSelector, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def maxSkew(self): + # type: () -> int + return self._property_impl('maxSkew') + + @maxSkew.setter + def maxSkew(self, new_val): + # type: (int) -> None + self._maxSkew = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + @property + def whenUnsatisfiable(self): + # type: () -> str + return self._property_impl('whenUnsatisfiable') + + @whenUnsatisfiable.setter + def whenUnsatisfiable(self, new_val): + # type: (str) -> None + self._whenUnsatisfiable = new_val + + +class TopologySpreadConstraintsList(CrdObjectList): + _items_type = TopologySpreadConstraintsItem + + +class Placement(CrdObject): + _properties = [ + ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False), + ('podAffinity', 'podAffinity', 'PodAffinity', False, False), + ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False), + ('tolerations', 'tolerations', 'TolerationsList', False, False), + ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False) + ] + + def __init__(self, + nodeAffinity=_omit, # type: Optional[NodeAffinity] + podAffinity=_omit, # type: Optional[PodAffinity] + podAntiAffinity=_omit, # type: Optional[PodAntiAffinity] + tolerations=_omit, # type: Optional[Union[List[TolerationsItem], CrdObjectList]] + topologySpreadConstraints=_omit, # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]] + ): + super(Placement, self).__init__( + nodeAffinity=nodeAffinity, + podAffinity=podAffinity, + podAntiAffinity=podAntiAffinity, + tolerations=tolerations, + topologySpreadConstraints=topologySpreadConstraints, + ) + + @property + def nodeAffinity(self): + # type: () -> NodeAffinity + return self._property_impl('nodeAffinity') + + @nodeAffinity.setter + def nodeAffinity(self, new_val): + # type: (Optional[NodeAffinity]) -> None + self._nodeAffinity = new_val + + @property + def podAffinity(self): + # type: () -> PodAffinity + return self._property_impl('podAffinity') + + @podAffinity.setter + def podAffinity(self, new_val): + # type: (Optional[PodAffinity]) -> None + self._podAffinity = new_val + + @property + def podAntiAffinity(self): + # type: () -> PodAntiAffinity + return self._property_impl('podAntiAffinity') + + @podAntiAffinity.setter + def podAntiAffinity(self, new_val): + # type: (Optional[PodAntiAffinity]) -> None + self._podAntiAffinity = new_val + + @property + def tolerations(self): + # type: () -> Union[List[TolerationsItem], CrdObjectList] + return self._property_impl('tolerations') + + @tolerations.setter + def tolerations(self, new_val): + # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None + self._tolerations = new_val + + @property + def topologySpreadConstraints(self): + # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList] + return self._property_impl('topologySpreadConstraints') + + @topologySpreadConstraints.setter + def topologySpreadConstraints(self, new_val): + # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None + self._topologySpreadConstraints = new_val + + +class Resources(CrdObject): + _properties = [ + ('limits', 'limits', object, False, False), + ('requests', 'requests', object, False, False) + ] + + def __init__(self, + limits=_omit, # type: Optional[Any] + requests=_omit, # type: Optional[Any] + ): + super(Resources, self).__init__( + limits=limits, + requests=requests, + ) + + @property + def limits(self): + # type: () -> Any + return self._property_impl('limits') + + @limits.setter + def limits(self, new_val): + # type: (Optional[Any]) -> None + self._limits = new_val + + @property + def requests(self): + # type: () -> Any + return self._property_impl('requests') + + @requests.setter + def requests(self, new_val): + # type: (Optional[Any]) -> None + self._requests = new_val + + +class MetadataServer(CrdObject): + _properties = [ + ('activeCount', 'activeCount', int, True, False), + ('activeStandby', 'activeStandby', bool, False, False), + ('annotations', 'annotations', object, False, True), + ('labels', 'labels', object, False, True), + ('placement', 'placement', 'Placement', False, True), + ('priorityClassName', 'priorityClassName', str, False, False), + ('resources', 'resources', 'Resources', False, True) + ] + + def __init__(self, + activeCount, # type: int + activeStandby=_omit, # type: Optional[bool] + annotations=_omit, # type: Optional[Any] + labels=_omit, # type: Optional[Any] + placement=_omit, # type: Optional[Placement] + priorityClassName=_omit, # type: Optional[str] + resources=_omit, # type: Optional[Resources] + ): + super(MetadataServer, self).__init__( + activeCount=activeCount, + activeStandby=activeStandby, + annotations=annotations, + labels=labels, + placement=placement, + priorityClassName=priorityClassName, + resources=resources, + ) + + @property + def activeCount(self): + # type: () -> int + return self._property_impl('activeCount') + + @activeCount.setter + def activeCount(self, new_val): + # type: (int) -> None + self._activeCount = new_val + + @property + def activeStandby(self): + # type: () -> bool + return self._property_impl('activeStandby') + + @activeStandby.setter + def activeStandby(self, new_val): + # type: (Optional[bool]) -> None + self._activeStandby = new_val + + @property + def annotations(self): + # type: () -> Optional[Any] + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + @property + def labels(self): + # type: () -> Optional[Any] + return self._property_impl('labels') + + @labels.setter + def labels(self, new_val): + # type: (Optional[Any]) -> None + self._labels = new_val + + @property + def placement(self): + # type: () -> Optional[Placement] + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Placement]) -> None + self._placement = new_val + + @property + def priorityClassName(self): + # type: () -> str + return self._property_impl('priorityClassName') + + @priorityClassName.setter + def priorityClassName(self, new_val): + # type: (Optional[str]) -> None + self._priorityClassName = new_val + + @property + def resources(self): + # type: () -> Optional[Resources] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Resources]) -> None + self._resources = new_val + + +class Spec(CrdObject): + _properties = [ + ('dataPools', 'dataPools', 'DataPoolsList', True, True), + ('metadataPool', 'metadataPool', 'MetadataPool', True, True), + ('metadataServer', 'metadataServer', 'MetadataServer', True, False), + ('mirroring', 'mirroring', 'Mirroring', False, True), + ('preserveFilesystemOnDelete', 'preserveFilesystemOnDelete', bool, False, False), + ('preservePoolsOnDelete', 'preservePoolsOnDelete', bool, False, False) + ] + + def __init__(self, + dataPools, # type: Optional[Union[List[DataPoolsItem], CrdObjectList]] + metadataPool, # type: Optional[MetadataPool] + metadataServer, # type: MetadataServer + mirroring=_omit, # type: Optional[Mirroring] + preserveFilesystemOnDelete=_omit, # type: Optional[bool] + preservePoolsOnDelete=_omit, # type: Optional[bool] + ): + super(Spec, self).__init__( + dataPools=dataPools, + metadataPool=metadataPool, + metadataServer=metadataServer, + mirroring=mirroring, + preserveFilesystemOnDelete=preserveFilesystemOnDelete, + preservePoolsOnDelete=preservePoolsOnDelete, + ) + + @property + def dataPools(self): + # type: () -> Optional[Union[List[DataPoolsItem], CrdObjectList]] + return self._property_impl('dataPools') + + @dataPools.setter + def dataPools(self, new_val): + # type: (Optional[Union[List[DataPoolsItem], CrdObjectList]]) -> None + self._dataPools = new_val + + @property + def metadataPool(self): + # type: () -> Optional[MetadataPool] + return self._property_impl('metadataPool') + + @metadataPool.setter + def metadataPool(self, new_val): + # type: (Optional[MetadataPool]) -> None + self._metadataPool = new_val + + @property + def metadataServer(self): + # type: () -> MetadataServer + return self._property_impl('metadataServer') + + @metadataServer.setter + def metadataServer(self, new_val): + # type: (MetadataServer) -> None + self._metadataServer = new_val + + @property + def mirroring(self): + # type: () -> Optional[Mirroring] + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def preserveFilesystemOnDelete(self): + # type: () -> bool + return self._property_impl('preserveFilesystemOnDelete') + + @preserveFilesystemOnDelete.setter + def preserveFilesystemOnDelete(self, new_val): + # type: (Optional[bool]) -> None + self._preserveFilesystemOnDelete = new_val + + @property + def preservePoolsOnDelete(self): + # type: () -> bool + return self._property_impl('preservePoolsOnDelete') + + @preservePoolsOnDelete.setter + def preservePoolsOnDelete(self, new_val): + # type: (Optional[bool]) -> None + self._preservePoolsOnDelete = new_val + + +class Status(CrdObject): + _properties = [ + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + phase=phase, + ) + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephFilesystem(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephFilesystem, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystemmirror.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystemmirror.py new file mode 100644 index 000000000..a57fde263 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephfilesystemmirror.py @@ -0,0 +1,1013 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class ValuesList(CrdObjectList): + _items_type = str + + +class MatchExpressionsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchExpressionsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchExpressionsList(CrdObjectList): + _items_type = MatchExpressionsItem + + +class MatchFieldsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchFieldsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchFieldsList(CrdObjectList): + _items_type = MatchFieldsItem + + +class Preference(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(Preference, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False), + ('weight', 'weight', int, False, False), + ('preference', 'preference', 'Preference', False, False) + ] + + def __init__(self, + podAffinityTerm=_omit, # type: Optional[PodAffinityTerm] + weight=_omit, # type: Optional[int] + preference=_omit, # type: Optional[Preference] + ): + super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + podAffinityTerm=podAffinityTerm, + weight=weight, + preference=preference, + ) + + @property + def podAffinityTerm(self): + # type: () -> PodAffinityTerm + return self._property_impl('podAffinityTerm') + + @podAffinityTerm.setter + def podAffinityTerm(self, new_val): + # type: (Optional[PodAffinityTerm]) -> None + self._podAffinityTerm = new_val + + @property + def weight(self): + # type: () -> int + return self._property_impl('weight') + + @weight.setter + def weight(self, new_val): + # type: (Optional[int]) -> None + self._weight = new_val + + @property + def preference(self): + # type: () -> Preference + return self._property_impl('preference') + + @preference.setter + def preference(self, new_val): + # type: (Optional[Preference]) -> None + self._preference = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem + + +class NodeSelectorTermsItem(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(NodeSelectorTermsItem, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class NodeSelectorTermsList(CrdObjectList): + _items_type = NodeSelectorTermsItem + + +class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject): + _properties = [ + ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False) + ] + + def __init__(self, + nodeSelectorTerms, # type: Union[List[NodeSelectorTermsItem], CrdObjectList] + ): + super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__( + nodeSelectorTerms=nodeSelectorTerms, + ) + + @property + def nodeSelectorTerms(self): + # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList] + return self._property_impl('nodeSelectorTerms') + + @nodeSelectorTerms.setter + def nodeSelectorTerms(self, new_val): + # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None + self._nodeSelectorTerms = new_val + + +class NodeAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution] + ): + super(NodeAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> RequiredDuringSchedulingIgnoredDuringExecution + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class LabelSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(LabelSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespaceSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(NamespaceSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespacesList(CrdObjectList): + _items_type = str + + +class PodAffinityTerm(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(PodAffinityTerm, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem + + +class PodAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class PodAntiAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAntiAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class TolerationsItem(CrdObject): + _properties = [ + ('effect', 'effect', str, False, False), + ('key', 'key', str, False, False), + ('operator', 'operator', str, False, False), + ('tolerationSeconds', 'tolerationSeconds', int, False, False), + ('value', 'value', str, False, False) + ] + + def __init__(self, + effect=_omit, # type: Optional[str] + key=_omit, # type: Optional[str] + operator=_omit, # type: Optional[str] + tolerationSeconds=_omit, # type: Optional[int] + value=_omit, # type: Optional[str] + ): + super(TolerationsItem, self).__init__( + effect=effect, + key=key, + operator=operator, + tolerationSeconds=tolerationSeconds, + value=value, + ) + + @property + def effect(self): + # type: () -> str + return self._property_impl('effect') + + @effect.setter + def effect(self, new_val): + # type: (Optional[str]) -> None + self._effect = new_val + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (Optional[str]) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (Optional[str]) -> None + self._operator = new_val + + @property + def tolerationSeconds(self): + # type: () -> int + return self._property_impl('tolerationSeconds') + + @tolerationSeconds.setter + def tolerationSeconds(self, new_val): + # type: (Optional[int]) -> None + self._tolerationSeconds = new_val + + @property + def value(self): + # type: () -> str + return self._property_impl('value') + + @value.setter + def value(self, new_val): + # type: (Optional[str]) -> None + self._value = new_val + + +class TolerationsList(CrdObjectList): + _items_type = TolerationsItem + + +class TopologySpreadConstraintsItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('maxSkew', 'maxSkew', int, True, False), + ('topologyKey', 'topologyKey', str, True, False), + ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False) + ] + + def __init__(self, + maxSkew, # type: int + topologyKey, # type: str + whenUnsatisfiable, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + ): + super(TopologySpreadConstraintsItem, self).__init__( + maxSkew=maxSkew, + topologyKey=topologyKey, + whenUnsatisfiable=whenUnsatisfiable, + labelSelector=labelSelector, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def maxSkew(self): + # type: () -> int + return self._property_impl('maxSkew') + + @maxSkew.setter + def maxSkew(self, new_val): + # type: (int) -> None + self._maxSkew = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + @property + def whenUnsatisfiable(self): + # type: () -> str + return self._property_impl('whenUnsatisfiable') + + @whenUnsatisfiable.setter + def whenUnsatisfiable(self, new_val): + # type: (str) -> None + self._whenUnsatisfiable = new_val + + +class TopologySpreadConstraintsList(CrdObjectList): + _items_type = TopologySpreadConstraintsItem + + +class Placement(CrdObject): + _properties = [ + ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False), + ('podAffinity', 'podAffinity', 'PodAffinity', False, False), + ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False), + ('tolerations', 'tolerations', 'TolerationsList', False, False), + ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False) + ] + + def __init__(self, + nodeAffinity=_omit, # type: Optional[NodeAffinity] + podAffinity=_omit, # type: Optional[PodAffinity] + podAntiAffinity=_omit, # type: Optional[PodAntiAffinity] + tolerations=_omit, # type: Optional[Union[List[TolerationsItem], CrdObjectList]] + topologySpreadConstraints=_omit, # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]] + ): + super(Placement, self).__init__( + nodeAffinity=nodeAffinity, + podAffinity=podAffinity, + podAntiAffinity=podAntiAffinity, + tolerations=tolerations, + topologySpreadConstraints=topologySpreadConstraints, + ) + + @property + def nodeAffinity(self): + # type: () -> NodeAffinity + return self._property_impl('nodeAffinity') + + @nodeAffinity.setter + def nodeAffinity(self, new_val): + # type: (Optional[NodeAffinity]) -> None + self._nodeAffinity = new_val + + @property + def podAffinity(self): + # type: () -> PodAffinity + return self._property_impl('podAffinity') + + @podAffinity.setter + def podAffinity(self, new_val): + # type: (Optional[PodAffinity]) -> None + self._podAffinity = new_val + + @property + def podAntiAffinity(self): + # type: () -> PodAntiAffinity + return self._property_impl('podAntiAffinity') + + @podAntiAffinity.setter + def podAntiAffinity(self, new_val): + # type: (Optional[PodAntiAffinity]) -> None + self._podAntiAffinity = new_val + + @property + def tolerations(self): + # type: () -> Union[List[TolerationsItem], CrdObjectList] + return self._property_impl('tolerations') + + @tolerations.setter + def tolerations(self, new_val): + # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None + self._tolerations = new_val + + @property + def topologySpreadConstraints(self): + # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList] + return self._property_impl('topologySpreadConstraints') + + @topologySpreadConstraints.setter + def topologySpreadConstraints(self, new_val): + # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None + self._topologySpreadConstraints = new_val + + +class Resources(CrdObject): + _properties = [ + ('limits', 'limits', object, False, False), + ('requests', 'requests', object, False, False) + ] + + def __init__(self, + limits=_omit, # type: Optional[Any] + requests=_omit, # type: Optional[Any] + ): + super(Resources, self).__init__( + limits=limits, + requests=requests, + ) + + @property + def limits(self): + # type: () -> Any + return self._property_impl('limits') + + @limits.setter + def limits(self, new_val): + # type: (Optional[Any]) -> None + self._limits = new_val + + @property + def requests(self): + # type: () -> Any + return self._property_impl('requests') + + @requests.setter + def requests(self, new_val): + # type: (Optional[Any]) -> None + self._requests = new_val + + +class Spec(CrdObject): + _properties = [ + ('annotations', 'annotations', object, False, True), + ('labels', 'labels', object, False, True), + ('placement', 'placement', 'Placement', False, True), + ('priorityClassName', 'priorityClassName', str, False, False), + ('resources', 'resources', 'Resources', False, True) + ] + + def __init__(self, + annotations=_omit, # type: Optional[Any] + labels=_omit, # type: Optional[Any] + placement=_omit, # type: Optional[Placement] + priorityClassName=_omit, # type: Optional[str] + resources=_omit, # type: Optional[Resources] + ): + super(Spec, self).__init__( + annotations=annotations, + labels=labels, + placement=placement, + priorityClassName=priorityClassName, + resources=resources, + ) + + @property + def annotations(self): + # type: () -> Optional[Any] + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + @property + def labels(self): + # type: () -> Optional[Any] + return self._property_impl('labels') + + @labels.setter + def labels(self, new_val): + # type: (Optional[Any]) -> None + self._labels = new_val + + @property + def placement(self): + # type: () -> Optional[Placement] + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Placement]) -> None + self._placement = new_val + + @property + def priorityClassName(self): + # type: () -> str + return self._property_impl('priorityClassName') + + @priorityClassName.setter + def priorityClassName(self, new_val): + # type: (Optional[str]) -> None + self._priorityClassName = new_val + + @property + def resources(self): + # type: () -> Optional[Resources] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Resources]) -> None + self._resources = new_val + + +class Status(CrdObject): + _properties = [ + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + phase=phase, + ) + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephFilesystemMirror(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephFilesystemMirror, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephnfs.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephnfs.py new file mode 100644 index 000000000..af069f303 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephnfs.py @@ -0,0 +1,1111 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Rados(CrdObject): + _properties = [ + ('namespace', 'namespace', str, True, False), + ('pool', 'pool', str, True, False) + ] + + def __init__(self, + namespace, # type: str + pool, # type: str + ): + super(Rados, self).__init__( + namespace=namespace, + pool=pool, + ) + + @property + def namespace(self): + # type: () -> str + return self._property_impl('namespace') + + @namespace.setter + def namespace(self, new_val): + # type: (str) -> None + self._namespace = new_val + + @property + def pool(self): + # type: () -> str + return self._property_impl('pool') + + @pool.setter + def pool(self, new_val): + # type: (str) -> None + self._pool = new_val + + +class ValuesList(CrdObjectList): + _items_type = str + + +class MatchExpressionsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchExpressionsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchExpressionsList(CrdObjectList): + _items_type = MatchExpressionsItem + + +class MatchFieldsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchFieldsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchFieldsList(CrdObjectList): + _items_type = MatchFieldsItem + + +class Preference(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(Preference, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False), + ('weight', 'weight', int, False, False), + ('preference', 'preference', 'Preference', False, False) + ] + + def __init__(self, + podAffinityTerm=_omit, # type: Optional[PodAffinityTerm] + weight=_omit, # type: Optional[int] + preference=_omit, # type: Optional[Preference] + ): + super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + podAffinityTerm=podAffinityTerm, + weight=weight, + preference=preference, + ) + + @property + def podAffinityTerm(self): + # type: () -> PodAffinityTerm + return self._property_impl('podAffinityTerm') + + @podAffinityTerm.setter + def podAffinityTerm(self, new_val): + # type: (Optional[PodAffinityTerm]) -> None + self._podAffinityTerm = new_val + + @property + def weight(self): + # type: () -> int + return self._property_impl('weight') + + @weight.setter + def weight(self, new_val): + # type: (Optional[int]) -> None + self._weight = new_val + + @property + def preference(self): + # type: () -> Preference + return self._property_impl('preference') + + @preference.setter + def preference(self, new_val): + # type: (Optional[Preference]) -> None + self._preference = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem + + +class NodeSelectorTermsItem(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(NodeSelectorTermsItem, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class NodeSelectorTermsList(CrdObjectList): + _items_type = NodeSelectorTermsItem + + +class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject): + _properties = [ + ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False) + ] + + def __init__(self, + nodeSelectorTerms, # type: Union[List[NodeSelectorTermsItem], CrdObjectList] + ): + super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__( + nodeSelectorTerms=nodeSelectorTerms, + ) + + @property + def nodeSelectorTerms(self): + # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList] + return self._property_impl('nodeSelectorTerms') + + @nodeSelectorTerms.setter + def nodeSelectorTerms(self, new_val): + # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None + self._nodeSelectorTerms = new_val + + +class NodeAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution] + ): + super(NodeAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> RequiredDuringSchedulingIgnoredDuringExecution + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class LabelSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(LabelSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespaceSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(NamespaceSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespacesList(CrdObjectList): + _items_type = str + + +class PodAffinityTerm(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(PodAffinityTerm, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem + + +class PodAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class PodAntiAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAntiAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class TolerationsItem(CrdObject): + _properties = [ + ('effect', 'effect', str, False, False), + ('key', 'key', str, False, False), + ('operator', 'operator', str, False, False), + ('tolerationSeconds', 'tolerationSeconds', int, False, False), + ('value', 'value', str, False, False) + ] + + def __init__(self, + effect=_omit, # type: Optional[str] + key=_omit, # type: Optional[str] + operator=_omit, # type: Optional[str] + tolerationSeconds=_omit, # type: Optional[int] + value=_omit, # type: Optional[str] + ): + super(TolerationsItem, self).__init__( + effect=effect, + key=key, + operator=operator, + tolerationSeconds=tolerationSeconds, + value=value, + ) + + @property + def effect(self): + # type: () -> str + return self._property_impl('effect') + + @effect.setter + def effect(self, new_val): + # type: (Optional[str]) -> None + self._effect = new_val + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (Optional[str]) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (Optional[str]) -> None + self._operator = new_val + + @property + def tolerationSeconds(self): + # type: () -> int + return self._property_impl('tolerationSeconds') + + @tolerationSeconds.setter + def tolerationSeconds(self, new_val): + # type: (Optional[int]) -> None + self._tolerationSeconds = new_val + + @property + def value(self): + # type: () -> str + return self._property_impl('value') + + @value.setter + def value(self, new_val): + # type: (Optional[str]) -> None + self._value = new_val + + +class TolerationsList(CrdObjectList): + _items_type = TolerationsItem + + +class TopologySpreadConstraintsItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('maxSkew', 'maxSkew', int, True, False), + ('topologyKey', 'topologyKey', str, True, False), + ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False) + ] + + def __init__(self, + maxSkew, # type: int + topologyKey, # type: str + whenUnsatisfiable, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + ): + super(TopologySpreadConstraintsItem, self).__init__( + maxSkew=maxSkew, + topologyKey=topologyKey, + whenUnsatisfiable=whenUnsatisfiable, + labelSelector=labelSelector, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def maxSkew(self): + # type: () -> int + return self._property_impl('maxSkew') + + @maxSkew.setter + def maxSkew(self, new_val): + # type: (int) -> None + self._maxSkew = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + @property + def whenUnsatisfiable(self): + # type: () -> str + return self._property_impl('whenUnsatisfiable') + + @whenUnsatisfiable.setter + def whenUnsatisfiable(self, new_val): + # type: (str) -> None + self._whenUnsatisfiable = new_val + + +class TopologySpreadConstraintsList(CrdObjectList): + _items_type = TopologySpreadConstraintsItem + + +class Placement(CrdObject): + _properties = [ + ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False), + ('podAffinity', 'podAffinity', 'PodAffinity', False, False), + ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False), + ('tolerations', 'tolerations', 'TolerationsList', False, False), + ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False) + ] + + def __init__(self, + nodeAffinity=_omit, # type: Optional[NodeAffinity] + podAffinity=_omit, # type: Optional[PodAffinity] + podAntiAffinity=_omit, # type: Optional[PodAntiAffinity] + tolerations=_omit, # type: Optional[Union[List[TolerationsItem], CrdObjectList]] + topologySpreadConstraints=_omit, # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]] + ): + super(Placement, self).__init__( + nodeAffinity=nodeAffinity, + podAffinity=podAffinity, + podAntiAffinity=podAntiAffinity, + tolerations=tolerations, + topologySpreadConstraints=topologySpreadConstraints, + ) + + @property + def nodeAffinity(self): + # type: () -> NodeAffinity + return self._property_impl('nodeAffinity') + + @nodeAffinity.setter + def nodeAffinity(self, new_val): + # type: (Optional[NodeAffinity]) -> None + self._nodeAffinity = new_val + + @property + def podAffinity(self): + # type: () -> PodAffinity + return self._property_impl('podAffinity') + + @podAffinity.setter + def podAffinity(self, new_val): + # type: (Optional[PodAffinity]) -> None + self._podAffinity = new_val + + @property + def podAntiAffinity(self): + # type: () -> PodAntiAffinity + return self._property_impl('podAntiAffinity') + + @podAntiAffinity.setter + def podAntiAffinity(self, new_val): + # type: (Optional[PodAntiAffinity]) -> None + self._podAntiAffinity = new_val + + @property + def tolerations(self): + # type: () -> Union[List[TolerationsItem], CrdObjectList] + return self._property_impl('tolerations') + + @tolerations.setter + def tolerations(self, new_val): + # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None + self._tolerations = new_val + + @property + def topologySpreadConstraints(self): + # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList] + return self._property_impl('topologySpreadConstraints') + + @topologySpreadConstraints.setter + def topologySpreadConstraints(self, new_val): + # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None + self._topologySpreadConstraints = new_val + + +class Resources(CrdObject): + _properties = [ + ('limits', 'limits', object, False, False), + ('requests', 'requests', object, False, False) + ] + + def __init__(self, + limits=_omit, # type: Optional[Any] + requests=_omit, # type: Optional[Any] + ): + super(Resources, self).__init__( + limits=limits, + requests=requests, + ) + + @property + def limits(self): + # type: () -> Any + return self._property_impl('limits') + + @limits.setter + def limits(self, new_val): + # type: (Optional[Any]) -> None + self._limits = new_val + + @property + def requests(self): + # type: () -> Any + return self._property_impl('requests') + + @requests.setter + def requests(self, new_val): + # type: (Optional[Any]) -> None + self._requests = new_val + + +class Server(CrdObject): + _properties = [ + ('active', 'active', int, True, False), + ('annotations', 'annotations', object, False, True), + ('labels', 'labels', object, False, True), + ('logLevel', 'logLevel', str, False, False), + ('placement', 'placement', 'Placement', False, True), + ('priorityClassName', 'priorityClassName', str, False, False), + ('resources', 'resources', 'Resources', False, True) + ] + + def __init__(self, + active, # type: int + annotations=_omit, # type: Optional[Any] + labels=_omit, # type: Optional[Any] + logLevel=_omit, # type: Optional[str] + placement=_omit, # type: Optional[Placement] + priorityClassName=_omit, # type: Optional[str] + resources=_omit, # type: Optional[Resources] + ): + super(Server, self).__init__( + active=active, + annotations=annotations, + labels=labels, + logLevel=logLevel, + placement=placement, + priorityClassName=priorityClassName, + resources=resources, + ) + + @property + def active(self): + # type: () -> int + return self._property_impl('active') + + @active.setter + def active(self, new_val): + # type: (int) -> None + self._active = new_val + + @property + def annotations(self): + # type: () -> Optional[Any] + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + @property + def labels(self): + # type: () -> Optional[Any] + return self._property_impl('labels') + + @labels.setter + def labels(self, new_val): + # type: (Optional[Any]) -> None + self._labels = new_val + + @property + def logLevel(self): + # type: () -> str + return self._property_impl('logLevel') + + @logLevel.setter + def logLevel(self, new_val): + # type: (Optional[str]) -> None + self._logLevel = new_val + + @property + def placement(self): + # type: () -> Optional[Placement] + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Placement]) -> None + self._placement = new_val + + @property + def priorityClassName(self): + # type: () -> str + return self._property_impl('priorityClassName') + + @priorityClassName.setter + def priorityClassName(self, new_val): + # type: (Optional[str]) -> None + self._priorityClassName = new_val + + @property + def resources(self): + # type: () -> Optional[Resources] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Resources]) -> None + self._resources = new_val + + +class Spec(CrdObject): + _properties = [ + ('rados', 'rados', 'Rados', True, False), + ('server', 'server', 'Server', True, False) + ] + + def __init__(self, + rados, # type: Rados + server, # type: Server + ): + super(Spec, self).__init__( + rados=rados, + server=server, + ) + + @property + def rados(self): + # type: () -> Rados + return self._property_impl('rados') + + @rados.setter + def rados(self, new_val): + # type: (Rados) -> None + self._rados = new_val + + @property + def server(self): + # type: () -> Server + return self._property_impl('server') + + @server.setter + def server(self, new_val): + # type: (Server) -> None + self._server = new_val + + +class Status(CrdObject): + _properties = [ + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + phase=phase, + ) + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephNFS(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephNFS, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectrealm.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectrealm.py new file mode 100644 index 000000000..eeac3f3f5 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectrealm.py @@ -0,0 +1,154 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Pull(CrdObject): + _properties = [ + ('endpoint', 'endpoint', str, True, False) + ] + + def __init__(self, + endpoint, # type: str + ): + super(Pull, self).__init__( + endpoint=endpoint, + ) + + @property + def endpoint(self): + # type: () -> str + return self._property_impl('endpoint') + + @endpoint.setter + def endpoint(self, new_val): + # type: (str) -> None + self._endpoint = new_val + + +class Spec(CrdObject): + _properties = [ + ('pull', 'pull', 'Pull', True, False) + ] + + def __init__(self, + pull, # type: Pull + ): + super(Spec, self).__init__( + pull=pull, + ) + + @property + def pull(self): + # type: () -> Pull + return self._property_impl('pull') + + @pull.setter + def pull(self, new_val): + # type: (Pull) -> None + self._pull = new_val + + +class Status(CrdObject): + _properties = [ + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + phase=phase, + ) + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephObjectRealm(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, True), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Optional[Spec] + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephObjectRealm, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Optional[Spec] + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Optional[Spec]) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py new file mode 100644 index 000000000..2c7d7cb74 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstore.py @@ -0,0 +1,2631 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class ErasureCoded(CrdObject): + _properties = [ + ('algorithm', 'algorithm', str, False, False), + ('codingChunks', 'codingChunks', int, True, False), + ('dataChunks', 'dataChunks', int, True, False) + ] + + def __init__(self, + codingChunks, # type: int + dataChunks, # type: int + algorithm=_omit, # type: Optional[str] + ): + super(ErasureCoded, self).__init__( + codingChunks=codingChunks, + dataChunks=dataChunks, + algorithm=algorithm, + ) + + @property + def algorithm(self): + # type: () -> str + return self._property_impl('algorithm') + + @algorithm.setter + def algorithm(self, new_val): + # type: (Optional[str]) -> None + self._algorithm = new_val + + @property + def codingChunks(self): + # type: () -> int + return self._property_impl('codingChunks') + + @codingChunks.setter + def codingChunks(self, new_val): + # type: (int) -> None + self._codingChunks = new_val + + @property + def dataChunks(self): + # type: () -> int + return self._property_impl('dataChunks') + + @dataChunks.setter + def dataChunks(self, new_val): + # type: (int) -> None + self._dataChunks = new_val + + +class SnapshotSchedulesItem(CrdObject): + _properties = [ + ('interval', 'interval', str, False, False), + ('startTime', 'startTime', str, False, False) + ] + + def __init__(self, + interval=_omit, # type: Optional[str] + startTime=_omit, # type: Optional[str] + ): + super(SnapshotSchedulesItem, self).__init__( + interval=interval, + startTime=startTime, + ) + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def startTime(self): + # type: () -> str + return self._property_impl('startTime') + + @startTime.setter + def startTime(self, new_val): + # type: (Optional[str]) -> None + self._startTime = new_val + + +class SnapshotSchedulesList(CrdObjectList): + _items_type = SnapshotSchedulesItem + + +class Mirroring(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('mode', 'mode', str, False, False), + ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + mode=_omit, # type: Optional[str] + snapshotSchedules=_omit, # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]] + ): + super(Mirroring, self).__init__( + enabled=enabled, + mode=mode, + snapshotSchedules=snapshotSchedules, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def mode(self): + # type: () -> str + return self._property_impl('mode') + + @mode.setter + def mode(self, new_val): + # type: (Optional[str]) -> None + self._mode = new_val + + @property + def snapshotSchedules(self): + # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList] + return self._property_impl('snapshotSchedules') + + @snapshotSchedules.setter + def snapshotSchedules(self, new_val): + # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None + self._snapshotSchedules = new_val + + +class Quotas(CrdObject): + _properties = [ + ('maxBytes', 'maxBytes', int, False, False), + ('maxObjects', 'maxObjects', int, False, False), + ('maxSize', 'maxSize', str, False, False) + ] + + def __init__(self, + maxBytes=_omit, # type: Optional[int] + maxObjects=_omit, # type: Optional[int] + maxSize=_omit, # type: Optional[str] + ): + super(Quotas, self).__init__( + maxBytes=maxBytes, + maxObjects=maxObjects, + maxSize=maxSize, + ) + + @property + def maxBytes(self): + # type: () -> int + return self._property_impl('maxBytes') + + @maxBytes.setter + def maxBytes(self, new_val): + # type: (Optional[int]) -> None + self._maxBytes = new_val + + @property + def maxObjects(self): + # type: () -> int + return self._property_impl('maxObjects') + + @maxObjects.setter + def maxObjects(self, new_val): + # type: (Optional[int]) -> None + self._maxObjects = new_val + + @property + def maxSize(self): + # type: () -> str + return self._property_impl('maxSize') + + @maxSize.setter + def maxSize(self, new_val): + # type: (Optional[str]) -> None + self._maxSize = new_val + + +class Replicated(CrdObject): + _properties = [ + ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False), + ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False), + ('size', 'size', int, True, False), + ('subFailureDomain', 'subFailureDomain', str, False, False), + ('targetSizeRatio', 'targetSizeRatio', float, False, False) + ] + + def __init__(self, + size, # type: int + replicasPerFailureDomain=_omit, # type: Optional[int] + requireSafeReplicaSize=_omit, # type: Optional[bool] + subFailureDomain=_omit, # type: Optional[str] + targetSizeRatio=_omit, # type: Optional[float] + ): + super(Replicated, self).__init__( + size=size, + replicasPerFailureDomain=replicasPerFailureDomain, + requireSafeReplicaSize=requireSafeReplicaSize, + subFailureDomain=subFailureDomain, + targetSizeRatio=targetSizeRatio, + ) + + @property + def replicasPerFailureDomain(self): + # type: () -> int + return self._property_impl('replicasPerFailureDomain') + + @replicasPerFailureDomain.setter + def replicasPerFailureDomain(self, new_val): + # type: (Optional[int]) -> None + self._replicasPerFailureDomain = new_val + + @property + def requireSafeReplicaSize(self): + # type: () -> bool + return self._property_impl('requireSafeReplicaSize') + + @requireSafeReplicaSize.setter + def requireSafeReplicaSize(self, new_val): + # type: (Optional[bool]) -> None + self._requireSafeReplicaSize = new_val + + @property + def size(self): + # type: () -> int + return self._property_impl('size') + + @size.setter + def size(self, new_val): + # type: (int) -> None + self._size = new_val + + @property + def subFailureDomain(self): + # type: () -> str + return self._property_impl('subFailureDomain') + + @subFailureDomain.setter + def subFailureDomain(self, new_val): + # type: (Optional[str]) -> None + self._subFailureDomain = new_val + + @property + def targetSizeRatio(self): + # type: () -> float + return self._property_impl('targetSizeRatio') + + @targetSizeRatio.setter + def targetSizeRatio(self, new_val): + # type: (Optional[float]) -> None + self._targetSizeRatio = new_val + + +class Mirror(CrdObject): + _properties = [ + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Mirror, self).__init__( + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class StatusCheck(CrdObject): + _properties = [ + ('mirror', 'mirror', 'Mirror', False, True) + ] + + def __init__(self, + mirror=_omit, # type: Optional[Mirror] + ): + super(StatusCheck, self).__init__( + mirror=mirror, + ) + + @property + def mirror(self): + # type: () -> Optional[Mirror] + return self._property_impl('mirror') + + @mirror.setter + def mirror(self, new_val): + # type: (Optional[Mirror]) -> None + self._mirror = new_val + + +class DataPool(CrdObject): + _properties = [ + ('compressionMode', 'compressionMode', str, False, True), + ('crushRoot', 'crushRoot', str, False, True), + ('deviceClass', 'deviceClass', str, False, True), + ('enableRBDStats', 'enableRBDStats', bool, False, False), + ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False), + ('failureDomain', 'failureDomain', str, False, False), + ('mirroring', 'mirroring', 'Mirroring', False, False), + ('parameters', 'parameters', object, False, True), + ('quotas', 'quotas', 'Quotas', False, True), + ('replicated', 'replicated', 'Replicated', False, False), + ('statusCheck', 'statusCheck', 'StatusCheck', False, False) + ] + + def __init__(self, + compressionMode=_omit, # type: Optional[str] + crushRoot=_omit, # type: Optional[str] + deviceClass=_omit, # type: Optional[str] + enableRBDStats=_omit, # type: Optional[bool] + erasureCoded=_omit, # type: Optional[ErasureCoded] + failureDomain=_omit, # type: Optional[str] + mirroring=_omit, # type: Optional[Mirroring] + parameters=_omit, # type: Optional[Any] + quotas=_omit, # type: Optional[Quotas] + replicated=_omit, # type: Optional[Replicated] + statusCheck=_omit, # type: Optional[StatusCheck] + ): + super(DataPool, self).__init__( + compressionMode=compressionMode, + crushRoot=crushRoot, + deviceClass=deviceClass, + enableRBDStats=enableRBDStats, + erasureCoded=erasureCoded, + failureDomain=failureDomain, + mirroring=mirroring, + parameters=parameters, + quotas=quotas, + replicated=replicated, + statusCheck=statusCheck, + ) + + @property + def compressionMode(self): + # type: () -> Optional[str] + return self._property_impl('compressionMode') + + @compressionMode.setter + def compressionMode(self, new_val): + # type: (Optional[str]) -> None + self._compressionMode = new_val + + @property + def crushRoot(self): + # type: () -> Optional[str] + return self._property_impl('crushRoot') + + @crushRoot.setter + def crushRoot(self, new_val): + # type: (Optional[str]) -> None + self._crushRoot = new_val + + @property + def deviceClass(self): + # type: () -> Optional[str] + return self._property_impl('deviceClass') + + @deviceClass.setter + def deviceClass(self, new_val): + # type: (Optional[str]) -> None + self._deviceClass = new_val + + @property + def enableRBDStats(self): + # type: () -> bool + return self._property_impl('enableRBDStats') + + @enableRBDStats.setter + def enableRBDStats(self, new_val): + # type: (Optional[bool]) -> None + self._enableRBDStats = new_val + + @property + def erasureCoded(self): + # type: () -> ErasureCoded + return self._property_impl('erasureCoded') + + @erasureCoded.setter + def erasureCoded(self, new_val): + # type: (Optional[ErasureCoded]) -> None + self._erasureCoded = new_val + + @property + def failureDomain(self): + # type: () -> str + return self._property_impl('failureDomain') + + @failureDomain.setter + def failureDomain(self, new_val): + # type: (Optional[str]) -> None + self._failureDomain = new_val + + @property + def mirroring(self): + # type: () -> Mirroring + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def parameters(self): + # type: () -> Optional[Any] + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def quotas(self): + # type: () -> Optional[Quotas] + return self._property_impl('quotas') + + @quotas.setter + def quotas(self, new_val): + # type: (Optional[Quotas]) -> None + self._quotas = new_val + + @property + def replicated(self): + # type: () -> Replicated + return self._property_impl('replicated') + + @replicated.setter + def replicated(self, new_val): + # type: (Optional[Replicated]) -> None + self._replicated = new_val + + @property + def statusCheck(self): + # type: () -> StatusCheck + return self._property_impl('statusCheck') + + @statusCheck.setter + def statusCheck(self, new_val): + # type: (Optional[StatusCheck]) -> None + self._statusCheck = new_val + + +class TargetRef(CrdObject): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('fieldPath', 'fieldPath', str, False, False), + ('kind', 'kind', str, False, False), + ('name', 'name', str, False, False), + ('namespace', 'namespace', str, False, False), + ('resourceVersion', 'resourceVersion', str, False, False), + ('uid', 'uid', str, False, False) + ] + + def __init__(self, + apiVersion=_omit, # type: Optional[str] + fieldPath=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + name=_omit, # type: Optional[str] + namespace=_omit, # type: Optional[str] + resourceVersion=_omit, # type: Optional[str] + uid=_omit, # type: Optional[str] + ): + super(TargetRef, self).__init__( + apiVersion=apiVersion, + fieldPath=fieldPath, + kind=kind, + name=name, + namespace=namespace, + resourceVersion=resourceVersion, + uid=uid, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def fieldPath(self): + # type: () -> str + return self._property_impl('fieldPath') + + @fieldPath.setter + def fieldPath(self, new_val): + # type: (Optional[str]) -> None + self._fieldPath = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (Optional[str]) -> None + self._name = new_val + + @property + def namespace(self): + # type: () -> str + return self._property_impl('namespace') + + @namespace.setter + def namespace(self, new_val): + # type: (Optional[str]) -> None + self._namespace = new_val + + @property + def resourceVersion(self): + # type: () -> str + return self._property_impl('resourceVersion') + + @resourceVersion.setter + def resourceVersion(self, new_val): + # type: (Optional[str]) -> None + self._resourceVersion = new_val + + @property + def uid(self): + # type: () -> str + return self._property_impl('uid') + + @uid.setter + def uid(self, new_val): + # type: (Optional[str]) -> None + self._uid = new_val + + +class ExternalRgwEndpointsItem(CrdObject): + _properties = [ + ('hostname', 'hostname', str, False, False), + ('ip', 'ip', str, True, False), + ('nodeName', 'nodeName', str, False, False), + ('targetRef', 'targetRef', 'TargetRef', False, False) + ] + + def __init__(self, + ip, # type: str + hostname=_omit, # type: Optional[str] + nodeName=_omit, # type: Optional[str] + targetRef=_omit, # type: Optional[TargetRef] + ): + super(ExternalRgwEndpointsItem, self).__init__( + ip=ip, + hostname=hostname, + nodeName=nodeName, + targetRef=targetRef, + ) + + @property + def hostname(self): + # type: () -> str + return self._property_impl('hostname') + + @hostname.setter + def hostname(self, new_val): + # type: (Optional[str]) -> None + self._hostname = new_val + + @property + def ip(self): + # type: () -> str + return self._property_impl('ip') + + @ip.setter + def ip(self, new_val): + # type: (str) -> None + self._ip = new_val + + @property + def nodeName(self): + # type: () -> str + return self._property_impl('nodeName') + + @nodeName.setter + def nodeName(self, new_val): + # type: (Optional[str]) -> None + self._nodeName = new_val + + @property + def targetRef(self): + # type: () -> TargetRef + return self._property_impl('targetRef') + + @targetRef.setter + def targetRef(self, new_val): + # type: (Optional[TargetRef]) -> None + self._targetRef = new_val + + +class ExternalRgwEndpointsList(CrdObjectList): + _items_type = ExternalRgwEndpointsItem + + +class ValuesList(CrdObjectList): + _items_type = str + + +class MatchExpressionsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchExpressionsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchExpressionsList(CrdObjectList): + _items_type = MatchExpressionsItem + + +class MatchFieldsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchFieldsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchFieldsList(CrdObjectList): + _items_type = MatchFieldsItem + + +class Preference(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(Preference, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False), + ('weight', 'weight', int, False, False), + ('preference', 'preference', 'Preference', False, False) + ] + + def __init__(self, + podAffinityTerm=_omit, # type: Optional[PodAffinityTerm] + weight=_omit, # type: Optional[int] + preference=_omit, # type: Optional[Preference] + ): + super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + podAffinityTerm=podAffinityTerm, + weight=weight, + preference=preference, + ) + + @property + def podAffinityTerm(self): + # type: () -> PodAffinityTerm + return self._property_impl('podAffinityTerm') + + @podAffinityTerm.setter + def podAffinityTerm(self, new_val): + # type: (Optional[PodAffinityTerm]) -> None + self._podAffinityTerm = new_val + + @property + def weight(self): + # type: () -> int + return self._property_impl('weight') + + @weight.setter + def weight(self, new_val): + # type: (Optional[int]) -> None + self._weight = new_val + + @property + def preference(self): + # type: () -> Preference + return self._property_impl('preference') + + @preference.setter + def preference(self, new_val): + # type: (Optional[Preference]) -> None + self._preference = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem + + +class NodeSelectorTermsItem(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(NodeSelectorTermsItem, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class NodeSelectorTermsList(CrdObjectList): + _items_type = NodeSelectorTermsItem + + +class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject): + _properties = [ + ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False) + ] + + def __init__(self, + nodeSelectorTerms, # type: Union[List[NodeSelectorTermsItem], CrdObjectList] + ): + super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__( + nodeSelectorTerms=nodeSelectorTerms, + ) + + @property + def nodeSelectorTerms(self): + # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList] + return self._property_impl('nodeSelectorTerms') + + @nodeSelectorTerms.setter + def nodeSelectorTerms(self, new_val): + # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None + self._nodeSelectorTerms = new_val + + +class NodeAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution] + ): + super(NodeAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> RequiredDuringSchedulingIgnoredDuringExecution + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class LabelSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(LabelSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespaceSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(NamespaceSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespacesList(CrdObjectList): + _items_type = str + + +class PodAffinityTerm(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(PodAffinityTerm, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem + + +class PodAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class PodAntiAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAntiAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class TolerationsItem(CrdObject): + _properties = [ + ('effect', 'effect', str, False, False), + ('key', 'key', str, False, False), + ('operator', 'operator', str, False, False), + ('tolerationSeconds', 'tolerationSeconds', int, False, False), + ('value', 'value', str, False, False) + ] + + def __init__(self, + effect=_omit, # type: Optional[str] + key=_omit, # type: Optional[str] + operator=_omit, # type: Optional[str] + tolerationSeconds=_omit, # type: Optional[int] + value=_omit, # type: Optional[str] + ): + super(TolerationsItem, self).__init__( + effect=effect, + key=key, + operator=operator, + tolerationSeconds=tolerationSeconds, + value=value, + ) + + @property + def effect(self): + # type: () -> str + return self._property_impl('effect') + + @effect.setter + def effect(self, new_val): + # type: (Optional[str]) -> None + self._effect = new_val + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (Optional[str]) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (Optional[str]) -> None + self._operator = new_val + + @property + def tolerationSeconds(self): + # type: () -> int + return self._property_impl('tolerationSeconds') + + @tolerationSeconds.setter + def tolerationSeconds(self, new_val): + # type: (Optional[int]) -> None + self._tolerationSeconds = new_val + + @property + def value(self): + # type: () -> str + return self._property_impl('value') + + @value.setter + def value(self, new_val): + # type: (Optional[str]) -> None + self._value = new_val + + +class TolerationsList(CrdObjectList): + _items_type = TolerationsItem + + +class TopologySpreadConstraintsItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('maxSkew', 'maxSkew', int, True, False), + ('topologyKey', 'topologyKey', str, True, False), + ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False) + ] + + def __init__(self, + maxSkew, # type: int + topologyKey, # type: str + whenUnsatisfiable, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + ): + super(TopologySpreadConstraintsItem, self).__init__( + maxSkew=maxSkew, + topologyKey=topologyKey, + whenUnsatisfiable=whenUnsatisfiable, + labelSelector=labelSelector, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def maxSkew(self): + # type: () -> int + return self._property_impl('maxSkew') + + @maxSkew.setter + def maxSkew(self, new_val): + # type: (int) -> None + self._maxSkew = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + @property + def whenUnsatisfiable(self): + # type: () -> str + return self._property_impl('whenUnsatisfiable') + + @whenUnsatisfiable.setter + def whenUnsatisfiable(self, new_val): + # type: (str) -> None + self._whenUnsatisfiable = new_val + + +class TopologySpreadConstraintsList(CrdObjectList): + _items_type = TopologySpreadConstraintsItem + + +class Placement(CrdObject): + _properties = [ + ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False), + ('podAffinity', 'podAffinity', 'PodAffinity', False, False), + ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False), + ('tolerations', 'tolerations', 'TolerationsList', False, False), + ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False) + ] + + def __init__(self, + nodeAffinity=_omit, # type: Optional[NodeAffinity] + podAffinity=_omit, # type: Optional[PodAffinity] + podAntiAffinity=_omit, # type: Optional[PodAntiAffinity] + tolerations=_omit, # type: Optional[Union[List[TolerationsItem], CrdObjectList]] + topologySpreadConstraints=_omit, # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]] + ): + super(Placement, self).__init__( + nodeAffinity=nodeAffinity, + podAffinity=podAffinity, + podAntiAffinity=podAntiAffinity, + tolerations=tolerations, + topologySpreadConstraints=topologySpreadConstraints, + ) + + @property + def nodeAffinity(self): + # type: () -> NodeAffinity + return self._property_impl('nodeAffinity') + + @nodeAffinity.setter + def nodeAffinity(self, new_val): + # type: (Optional[NodeAffinity]) -> None + self._nodeAffinity = new_val + + @property + def podAffinity(self): + # type: () -> PodAffinity + return self._property_impl('podAffinity') + + @podAffinity.setter + def podAffinity(self, new_val): + # type: (Optional[PodAffinity]) -> None + self._podAffinity = new_val + + @property + def podAntiAffinity(self): + # type: () -> PodAntiAffinity + return self._property_impl('podAntiAffinity') + + @podAntiAffinity.setter + def podAntiAffinity(self, new_val): + # type: (Optional[PodAntiAffinity]) -> None + self._podAntiAffinity = new_val + + @property + def tolerations(self): + # type: () -> Union[List[TolerationsItem], CrdObjectList] + return self._property_impl('tolerations') + + @tolerations.setter + def tolerations(self, new_val): + # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None + self._tolerations = new_val + + @property + def topologySpreadConstraints(self): + # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList] + return self._property_impl('topologySpreadConstraints') + + @topologySpreadConstraints.setter + def topologySpreadConstraints(self, new_val): + # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None + self._topologySpreadConstraints = new_val + + +class Resources(CrdObject): + _properties = [ + ('limits', 'limits', object, False, False), + ('requests', 'requests', object, False, False) + ] + + def __init__(self, + limits=_omit, # type: Optional[Any] + requests=_omit, # type: Optional[Any] + ): + super(Resources, self).__init__( + limits=limits, + requests=requests, + ) + + @property + def limits(self): + # type: () -> Any + return self._property_impl('limits') + + @limits.setter + def limits(self, new_val): + # type: (Optional[Any]) -> None + self._limits = new_val + + @property + def requests(self): + # type: () -> Any + return self._property_impl('requests') + + @requests.setter + def requests(self, new_val): + # type: (Optional[Any]) -> None + self._requests = new_val + + +class Service(CrdObject): + _properties = [ + ('annotations', 'annotations', object, False, False) + ] + + def __init__(self, + annotations=_omit, # type: Optional[Any] + ): + super(Service, self).__init__( + annotations=annotations, + ) + + @property + def annotations(self): + # type: () -> Any + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + +class Gateway(CrdObject): + _properties = [ + ('annotations', 'annotations', object, False, True), + ('externalRgwEndpoints', 'externalRgwEndpoints', 'ExternalRgwEndpointsList', False, True), + ('instances', 'instances', int, True, False), + ('labels', 'labels', object, False, True), + ('placement', 'placement', 'Placement', False, True), + ('port', 'port', int, False, False), + ('priorityClassName', 'priorityClassName', str, False, False), + ('resources', 'resources', 'Resources', False, True), + ('securePort', 'securePort', int, False, True), + ('service', 'service', 'Service', False, True), + ('sslCertificateRef', 'sslCertificateRef', str, False, True) + ] + + def __init__(self, + instances, # type: int + annotations=_omit, # type: Optional[Any] + externalRgwEndpoints=_omit, # type: Optional[Union[List[ExternalRgwEndpointsItem], CrdObjectList]] + labels=_omit, # type: Optional[Any] + placement=_omit, # type: Optional[Placement] + port=_omit, # type: Optional[int] + priorityClassName=_omit, # type: Optional[str] + resources=_omit, # type: Optional[Resources] + securePort=_omit, # type: Optional[int] + service=_omit, # type: Optional[Service] + sslCertificateRef=_omit, # type: Optional[str] + ): + super(Gateway, self).__init__( + instances=instances, + annotations=annotations, + externalRgwEndpoints=externalRgwEndpoints, + labels=labels, + placement=placement, + port=port, + priorityClassName=priorityClassName, + resources=resources, + securePort=securePort, + service=service, + sslCertificateRef=sslCertificateRef, + ) + + @property + def annotations(self): + # type: () -> Optional[Any] + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + @property + def externalRgwEndpoints(self): + # type: () -> Optional[Union[List[ExternalRgwEndpointsItem], CrdObjectList]] + return self._property_impl('externalRgwEndpoints') + + @externalRgwEndpoints.setter + def externalRgwEndpoints(self, new_val): + # type: (Optional[Union[List[ExternalRgwEndpointsItem], CrdObjectList]]) -> None + self._externalRgwEndpoints = new_val + + @property + def instances(self): + # type: () -> int + return self._property_impl('instances') + + @instances.setter + def instances(self, new_val): + # type: (int) -> None + self._instances = new_val + + @property + def labels(self): + # type: () -> Optional[Any] + return self._property_impl('labels') + + @labels.setter + def labels(self, new_val): + # type: (Optional[Any]) -> None + self._labels = new_val + + @property + def placement(self): + # type: () -> Optional[Placement] + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Placement]) -> None + self._placement = new_val + + @property + def port(self): + # type: () -> int + return self._property_impl('port') + + @port.setter + def port(self, new_val): + # type: (Optional[int]) -> None + self._port = new_val + + @property + def priorityClassName(self): + # type: () -> str + return self._property_impl('priorityClassName') + + @priorityClassName.setter + def priorityClassName(self, new_val): + # type: (Optional[str]) -> None + self._priorityClassName = new_val + + @property + def resources(self): + # type: () -> Optional[Resources] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Resources]) -> None + self._resources = new_val + + @property + def securePort(self): + # type: () -> Optional[int] + return self._property_impl('securePort') + + @securePort.setter + def securePort(self, new_val): + # type: (Optional[int]) -> None + self._securePort = new_val + + @property + def service(self): + # type: () -> Optional[Service] + return self._property_impl('service') + + @service.setter + def service(self, new_val): + # type: (Optional[Service]) -> None + self._service = new_val + + @property + def sslCertificateRef(self): + # type: () -> Optional[str] + return self._property_impl('sslCertificateRef') + + @sslCertificateRef.setter + def sslCertificateRef(self, new_val): + # type: (Optional[str]) -> None + self._sslCertificateRef = new_val + + +class Bucket(CrdObject): + _properties = [ + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Bucket, self).__init__( + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class CommandList(CrdObjectList): + _items_type = str + + +class Exec(CrdObject): + _properties = [ + ('command', 'command', 'CommandList', False, False) + ] + + def __init__(self, + command=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(Exec, self).__init__( + command=command, + ) + + @property + def command(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('command') + + @command.setter + def command(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._command = new_val + + +class HttpHeadersItem(CrdObject): + _properties = [ + ('name', 'name', str, True, False), + ('value', 'value', str, True, False) + ] + + def __init__(self, + name, # type: str + value, # type: str + ): + super(HttpHeadersItem, self).__init__( + name=name, + value=value, + ) + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (str) -> None + self._name = new_val + + @property + def value(self): + # type: () -> str + return self._property_impl('value') + + @value.setter + def value(self, new_val): + # type: (str) -> None + self._value = new_val + + +class HttpHeadersList(CrdObjectList): + _items_type = HttpHeadersItem + + +class HttpGet(CrdObject): + _properties = [ + ('host', 'host', str, False, False), + ('httpHeaders', 'httpHeaders', 'HttpHeadersList', False, False), + ('path', 'path', str, False, False), + ('port', 'port', Union[int, str], True, False), + ('scheme', 'scheme', str, False, False) + ] + + def __init__(self, + port, # type: Union[int, str] + host=_omit, # type: Optional[str] + httpHeaders=_omit, # type: Optional[Union[List[HttpHeadersItem], CrdObjectList]] + path=_omit, # type: Optional[str] + scheme=_omit, # type: Optional[str] + ): + super(HttpGet, self).__init__( + port=port, + host=host, + httpHeaders=httpHeaders, + path=path, + scheme=scheme, + ) + + @property + def host(self): + # type: () -> str + return self._property_impl('host') + + @host.setter + def host(self, new_val): + # type: (Optional[str]) -> None + self._host = new_val + + @property + def httpHeaders(self): + # type: () -> Union[List[HttpHeadersItem], CrdObjectList] + return self._property_impl('httpHeaders') + + @httpHeaders.setter + def httpHeaders(self, new_val): + # type: (Optional[Union[List[HttpHeadersItem], CrdObjectList]]) -> None + self._httpHeaders = new_val + + @property + def path(self): + # type: () -> str + return self._property_impl('path') + + @path.setter + def path(self, new_val): + # type: (Optional[str]) -> None + self._path = new_val + + @property + def port(self): + # type: () -> Union[int, str] + return self._property_impl('port') + + @port.setter + def port(self, new_val): + # type: (Union[int, str]) -> None + self._port = new_val + + @property + def scheme(self): + # type: () -> str + return self._property_impl('scheme') + + @scheme.setter + def scheme(self, new_val): + # type: (Optional[str]) -> None + self._scheme = new_val + + +class TcpSocket(CrdObject): + _properties = [ + ('host', 'host', str, False, False), + ('port', 'port', Union[int, str], True, False) + ] + + def __init__(self, + port, # type: Union[int, str] + host=_omit, # type: Optional[str] + ): + super(TcpSocket, self).__init__( + port=port, + host=host, + ) + + @property + def host(self): + # type: () -> str + return self._property_impl('host') + + @host.setter + def host(self, new_val): + # type: (Optional[str]) -> None + self._host = new_val + + @property + def port(self): + # type: () -> Union[int, str] + return self._property_impl('port') + + @port.setter + def port(self, new_val): + # type: (Union[int, str]) -> None + self._port = new_val + + +class Probe(CrdObject): + _properties = [ + ('exec', 'exec_1', 'Exec', False, False), + ('failureThreshold', 'failureThreshold', int, False, False), + ('httpGet', 'httpGet', 'HttpGet', False, False), + ('initialDelaySeconds', 'initialDelaySeconds', int, False, False), + ('periodSeconds', 'periodSeconds', int, False, False), + ('successThreshold', 'successThreshold', int, False, False), + ('tcpSocket', 'tcpSocket', 'TcpSocket', False, False), + ('terminationGracePeriodSeconds', 'terminationGracePeriodSeconds', int, False, False), + ('timeoutSeconds', 'timeoutSeconds', int, False, False) + ] + + def __init__(self, + exec_1=_omit, # type: Optional[Exec] + failureThreshold=_omit, # type: Optional[int] + httpGet=_omit, # type: Optional[HttpGet] + initialDelaySeconds=_omit, # type: Optional[int] + periodSeconds=_omit, # type: Optional[int] + successThreshold=_omit, # type: Optional[int] + tcpSocket=_omit, # type: Optional[TcpSocket] + terminationGracePeriodSeconds=_omit, # type: Optional[int] + timeoutSeconds=_omit, # type: Optional[int] + ): + super(Probe, self).__init__( + exec_1=exec_1, + failureThreshold=failureThreshold, + httpGet=httpGet, + initialDelaySeconds=initialDelaySeconds, + periodSeconds=periodSeconds, + successThreshold=successThreshold, + tcpSocket=tcpSocket, + terminationGracePeriodSeconds=terminationGracePeriodSeconds, + timeoutSeconds=timeoutSeconds, + ) + + @property + def exec_1(self): + # type: () -> Exec + return self._property_impl('exec_1') + + @exec_1.setter + def exec_1(self, new_val): + # type: (Optional[Exec]) -> None + self._exec_1 = new_val + + @property + def failureThreshold(self): + # type: () -> int + return self._property_impl('failureThreshold') + + @failureThreshold.setter + def failureThreshold(self, new_val): + # type: (Optional[int]) -> None + self._failureThreshold = new_val + + @property + def httpGet(self): + # type: () -> HttpGet + return self._property_impl('httpGet') + + @httpGet.setter + def httpGet(self, new_val): + # type: (Optional[HttpGet]) -> None + self._httpGet = new_val + + @property + def initialDelaySeconds(self): + # type: () -> int + return self._property_impl('initialDelaySeconds') + + @initialDelaySeconds.setter + def initialDelaySeconds(self, new_val): + # type: (Optional[int]) -> None + self._initialDelaySeconds = new_val + + @property + def periodSeconds(self): + # type: () -> int + return self._property_impl('periodSeconds') + + @periodSeconds.setter + def periodSeconds(self, new_val): + # type: (Optional[int]) -> None + self._periodSeconds = new_val + + @property + def successThreshold(self): + # type: () -> int + return self._property_impl('successThreshold') + + @successThreshold.setter + def successThreshold(self, new_val): + # type: (Optional[int]) -> None + self._successThreshold = new_val + + @property + def tcpSocket(self): + # type: () -> TcpSocket + return self._property_impl('tcpSocket') + + @tcpSocket.setter + def tcpSocket(self, new_val): + # type: (Optional[TcpSocket]) -> None + self._tcpSocket = new_val + + @property + def terminationGracePeriodSeconds(self): + # type: () -> int + return self._property_impl('terminationGracePeriodSeconds') + + @terminationGracePeriodSeconds.setter + def terminationGracePeriodSeconds(self, new_val): + # type: (Optional[int]) -> None + self._terminationGracePeriodSeconds = new_val + + @property + def timeoutSeconds(self): + # type: () -> int + return self._property_impl('timeoutSeconds') + + @timeoutSeconds.setter + def timeoutSeconds(self, new_val): + # type: (Optional[int]) -> None + self._timeoutSeconds = new_val + + +class LivenessProbe(CrdObject): + _properties = [ + ('disabled', 'disabled', bool, False, False), + ('probe', 'probe', 'Probe', False, False) + ] + + def __init__(self, + disabled=_omit, # type: Optional[bool] + probe=_omit, # type: Optional[Probe] + ): + super(LivenessProbe, self).__init__( + disabled=disabled, + probe=probe, + ) + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def probe(self): + # type: () -> Probe + return self._property_impl('probe') + + @probe.setter + def probe(self, new_val): + # type: (Optional[Probe]) -> None + self._probe = new_val + + +class HealthCheck(CrdObject): + _properties = [ + ('bucket', 'bucket', 'Bucket', False, False), + ('livenessProbe', 'livenessProbe', 'LivenessProbe', False, False) + ] + + def __init__(self, + bucket=_omit, # type: Optional[Bucket] + livenessProbe=_omit, # type: Optional[LivenessProbe] + ): + super(HealthCheck, self).__init__( + bucket=bucket, + livenessProbe=livenessProbe, + ) + + @property + def bucket(self): + # type: () -> Bucket + return self._property_impl('bucket') + + @bucket.setter + def bucket(self, new_val): + # type: (Optional[Bucket]) -> None + self._bucket = new_val + + @property + def livenessProbe(self): + # type: () -> LivenessProbe + return self._property_impl('livenessProbe') + + @livenessProbe.setter + def livenessProbe(self, new_val): + # type: (Optional[LivenessProbe]) -> None + self._livenessProbe = new_val + + +class MetadataPool(CrdObject): + _properties = [ + ('compressionMode', 'compressionMode', str, False, True), + ('crushRoot', 'crushRoot', str, False, True), + ('deviceClass', 'deviceClass', str, False, True), + ('enableRBDStats', 'enableRBDStats', bool, False, False), + ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False), + ('failureDomain', 'failureDomain', str, False, False), + ('mirroring', 'mirroring', 'Mirroring', False, False), + ('parameters', 'parameters', object, False, True), + ('quotas', 'quotas', 'Quotas', False, True), + ('replicated', 'replicated', 'Replicated', False, False), + ('statusCheck', 'statusCheck', 'StatusCheck', False, False) + ] + + def __init__(self, + compressionMode=_omit, # type: Optional[str] + crushRoot=_omit, # type: Optional[str] + deviceClass=_omit, # type: Optional[str] + enableRBDStats=_omit, # type: Optional[bool] + erasureCoded=_omit, # type: Optional[ErasureCoded] + failureDomain=_omit, # type: Optional[str] + mirroring=_omit, # type: Optional[Mirroring] + parameters=_omit, # type: Optional[Any] + quotas=_omit, # type: Optional[Quotas] + replicated=_omit, # type: Optional[Replicated] + statusCheck=_omit, # type: Optional[StatusCheck] + ): + super(MetadataPool, self).__init__( + compressionMode=compressionMode, + crushRoot=crushRoot, + deviceClass=deviceClass, + enableRBDStats=enableRBDStats, + erasureCoded=erasureCoded, + failureDomain=failureDomain, + mirroring=mirroring, + parameters=parameters, + quotas=quotas, + replicated=replicated, + statusCheck=statusCheck, + ) + + @property + def compressionMode(self): + # type: () -> Optional[str] + return self._property_impl('compressionMode') + + @compressionMode.setter + def compressionMode(self, new_val): + # type: (Optional[str]) -> None + self._compressionMode = new_val + + @property + def crushRoot(self): + # type: () -> Optional[str] + return self._property_impl('crushRoot') + + @crushRoot.setter + def crushRoot(self, new_val): + # type: (Optional[str]) -> None + self._crushRoot = new_val + + @property + def deviceClass(self): + # type: () -> Optional[str] + return self._property_impl('deviceClass') + + @deviceClass.setter + def deviceClass(self, new_val): + # type: (Optional[str]) -> None + self._deviceClass = new_val + + @property + def enableRBDStats(self): + # type: () -> bool + return self._property_impl('enableRBDStats') + + @enableRBDStats.setter + def enableRBDStats(self, new_val): + # type: (Optional[bool]) -> None + self._enableRBDStats = new_val + + @property + def erasureCoded(self): + # type: () -> ErasureCoded + return self._property_impl('erasureCoded') + + @erasureCoded.setter + def erasureCoded(self, new_val): + # type: (Optional[ErasureCoded]) -> None + self._erasureCoded = new_val + + @property + def failureDomain(self): + # type: () -> str + return self._property_impl('failureDomain') + + @failureDomain.setter + def failureDomain(self, new_val): + # type: (Optional[str]) -> None + self._failureDomain = new_val + + @property + def mirroring(self): + # type: () -> Mirroring + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def parameters(self): + # type: () -> Optional[Any] + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def quotas(self): + # type: () -> Optional[Quotas] + return self._property_impl('quotas') + + @quotas.setter + def quotas(self, new_val): + # type: (Optional[Quotas]) -> None + self._quotas = new_val + + @property + def replicated(self): + # type: () -> Replicated + return self._property_impl('replicated') + + @replicated.setter + def replicated(self, new_val): + # type: (Optional[Replicated]) -> None + self._replicated = new_val + + @property + def statusCheck(self): + # type: () -> StatusCheck + return self._property_impl('statusCheck') + + @statusCheck.setter + def statusCheck(self, new_val): + # type: (Optional[StatusCheck]) -> None + self._statusCheck = new_val + + +class Kms(CrdObject): + _properties = [ + ('connectionDetails', 'connectionDetails', object, False, True), + ('tokenSecretName', 'tokenSecretName', str, False, False) + ] + + def __init__(self, + connectionDetails=_omit, # type: Optional[Any] + tokenSecretName=_omit, # type: Optional[str] + ): + super(Kms, self).__init__( + connectionDetails=connectionDetails, + tokenSecretName=tokenSecretName, + ) + + @property + def connectionDetails(self): + # type: () -> Optional[Any] + return self._property_impl('connectionDetails') + + @connectionDetails.setter + def connectionDetails(self, new_val): + # type: (Optional[Any]) -> None + self._connectionDetails = new_val + + @property + def tokenSecretName(self): + # type: () -> str + return self._property_impl('tokenSecretName') + + @tokenSecretName.setter + def tokenSecretName(self, new_val): + # type: (Optional[str]) -> None + self._tokenSecretName = new_val + + +class Security(CrdObject): + _properties = [ + ('kms', 'kms', 'Kms', False, True) + ] + + def __init__(self, + kms=_omit, # type: Optional[Kms] + ): + super(Security, self).__init__( + kms=kms, + ) + + @property + def kms(self): + # type: () -> Optional[Kms] + return self._property_impl('kms') + + @kms.setter + def kms(self, new_val): + # type: (Optional[Kms]) -> None + self._kms = new_val + + +class Zone(CrdObject): + _properties = [ + ('name', 'name', str, True, False) + ] + + def __init__(self, + name, # type: str + ): + super(Zone, self).__init__( + name=name, + ) + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (str) -> None + self._name = new_val + + +class Spec(CrdObject): + _properties = [ + ('dataPool', 'dataPool', 'DataPool', False, True), + ('gateway', 'gateway', 'Gateway', False, True), + ('healthCheck', 'healthCheck', 'HealthCheck', False, True), + ('metadataPool', 'metadataPool', 'MetadataPool', False, True), + ('preservePoolsOnDelete', 'preservePoolsOnDelete', bool, False, False), + ('security', 'security', 'Security', False, True), + ('zone', 'zone', 'Zone', False, True) + ] + + def __init__(self, + dataPool=_omit, # type: Optional[DataPool] + gateway=_omit, # type: Optional[Gateway] + healthCheck=_omit, # type: Optional[HealthCheck] + metadataPool=_omit, # type: Optional[MetadataPool] + preservePoolsOnDelete=_omit, # type: Optional[bool] + security=_omit, # type: Optional[Security] + zone=_omit, # type: Optional[Zone] + ): + super(Spec, self).__init__( + dataPool=dataPool, + gateway=gateway, + healthCheck=healthCheck, + metadataPool=metadataPool, + preservePoolsOnDelete=preservePoolsOnDelete, + security=security, + zone=zone, + ) + + @property + def dataPool(self): + # type: () -> Optional[DataPool] + return self._property_impl('dataPool') + + @dataPool.setter + def dataPool(self, new_val): + # type: (Optional[DataPool]) -> None + self._dataPool = new_val + + @property + def gateway(self): + # type: () -> Optional[Gateway] + return self._property_impl('gateway') + + @gateway.setter + def gateway(self, new_val): + # type: (Optional[Gateway]) -> None + self._gateway = new_val + + @property + def healthCheck(self): + # type: () -> Optional[HealthCheck] + return self._property_impl('healthCheck') + + @healthCheck.setter + def healthCheck(self, new_val): + # type: (Optional[HealthCheck]) -> None + self._healthCheck = new_val + + @property + def metadataPool(self): + # type: () -> Optional[MetadataPool] + return self._property_impl('metadataPool') + + @metadataPool.setter + def metadataPool(self, new_val): + # type: (Optional[MetadataPool]) -> None + self._metadataPool = new_val + + @property + def preservePoolsOnDelete(self): + # type: () -> bool + return self._property_impl('preservePoolsOnDelete') + + @preservePoolsOnDelete.setter + def preservePoolsOnDelete(self, new_val): + # type: (Optional[bool]) -> None + self._preservePoolsOnDelete = new_val + + @property + def security(self): + # type: () -> Optional[Security] + return self._property_impl('security') + + @security.setter + def security(self, new_val): + # type: (Optional[Security]) -> None + self._security = new_val + + @property + def zone(self): + # type: () -> Optional[Zone] + return self._property_impl('zone') + + @zone.setter + def zone(self, new_val): + # type: (Optional[Zone]) -> None + self._zone = new_val + + +class BucketStatus(CrdObject): + _properties = [ + ('details', 'details', str, False, False), + ('health', 'health', str, False, False), + ('lastChanged', 'lastChanged', str, False, False), + ('lastChecked', 'lastChecked', str, False, False) + ] + + def __init__(self, + details=_omit, # type: Optional[str] + health=_omit, # type: Optional[str] + lastChanged=_omit, # type: Optional[str] + lastChecked=_omit, # type: Optional[str] + ): + super(BucketStatus, self).__init__( + details=details, + health=health, + lastChanged=lastChanged, + lastChecked=lastChecked, + ) + + @property + def details(self): + # type: () -> str + return self._property_impl('details') + + @details.setter + def details(self, new_val): + # type: (Optional[str]) -> None + self._details = new_val + + @property + def health(self): + # type: () -> str + return self._property_impl('health') + + @health.setter + def health(self, new_val): + # type: (Optional[str]) -> None + self._health = new_val + + @property + def lastChanged(self): + # type: () -> str + return self._property_impl('lastChanged') + + @lastChanged.setter + def lastChanged(self, new_val): + # type: (Optional[str]) -> None + self._lastChanged = new_val + + @property + def lastChecked(self): + # type: () -> str + return self._property_impl('lastChecked') + + @lastChecked.setter + def lastChecked(self, new_val): + # type: (Optional[str]) -> None + self._lastChecked = new_val + + +class Status(CrdObject): + _properties = [ + ('bucketStatus', 'bucketStatus', 'BucketStatus', False, False), + ('info', 'info', object, False, True), + ('message', 'message', str, False, False), + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + bucketStatus=_omit, # type: Optional[BucketStatus] + info=_omit, # type: Optional[Any] + message=_omit, # type: Optional[str] + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + bucketStatus=bucketStatus, + info=info, + message=message, + phase=phase, + ) + + @property + def bucketStatus(self): + # type: () -> BucketStatus + return self._property_impl('bucketStatus') + + @bucketStatus.setter + def bucketStatus(self, new_val): + # type: (Optional[BucketStatus]) -> None + self._bucketStatus = new_val + + @property + def info(self): + # type: () -> Optional[Any] + return self._property_impl('info') + + @info.setter + def info(self, new_val): + # type: (Optional[Any]) -> None + self._info = new_val + + @property + def message(self): + # type: () -> str + return self._property_impl('message') + + @message.setter + def message(self, new_val): + # type: (Optional[str]) -> None + self._message = new_val + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephObjectStore(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephObjectStore, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstoreuser.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstoreuser.py new file mode 100644 index 000000000..5947aaa4f --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectstoreuser.py @@ -0,0 +1,157 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Spec(CrdObject): + _properties = [ + ('displayName', 'displayName', str, False, False), + ('store', 'store', str, False, False) + ] + + def __init__(self, + displayName=_omit, # type: Optional[str] + store=_omit, # type: Optional[str] + ): + super(Spec, self).__init__( + displayName=displayName, + store=store, + ) + + @property + def displayName(self): + # type: () -> str + return self._property_impl('displayName') + + @displayName.setter + def displayName(self, new_val): + # type: (Optional[str]) -> None + self._displayName = new_val + + @property + def store(self): + # type: () -> str + return self._property_impl('store') + + @store.setter + def store(self, new_val): + # type: (Optional[str]) -> None + self._store = new_val + + +class Status(CrdObject): + _properties = [ + ('info', 'info', object, False, True), + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + info=_omit, # type: Optional[Any] + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + info=info, + phase=phase, + ) + + @property + def info(self): + # type: () -> Optional[Any] + return self._property_impl('info') + + @info.setter + def info(self, new_val): + # type: (Optional[Any]) -> None + self._info = new_val + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephObjectStoreUser(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephObjectStoreUser, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzone.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzone.py new file mode 100644 index 000000000..7ba5f510f --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzone.py @@ -0,0 +1,797 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class ErasureCoded(CrdObject): + _properties = [ + ('algorithm', 'algorithm', str, False, False), + ('codingChunks', 'codingChunks', int, True, False), + ('dataChunks', 'dataChunks', int, True, False) + ] + + def __init__(self, + codingChunks, # type: int + dataChunks, # type: int + algorithm=_omit, # type: Optional[str] + ): + super(ErasureCoded, self).__init__( + codingChunks=codingChunks, + dataChunks=dataChunks, + algorithm=algorithm, + ) + + @property + def algorithm(self): + # type: () -> str + return self._property_impl('algorithm') + + @algorithm.setter + def algorithm(self, new_val): + # type: (Optional[str]) -> None + self._algorithm = new_val + + @property + def codingChunks(self): + # type: () -> int + return self._property_impl('codingChunks') + + @codingChunks.setter + def codingChunks(self, new_val): + # type: (int) -> None + self._codingChunks = new_val + + @property + def dataChunks(self): + # type: () -> int + return self._property_impl('dataChunks') + + @dataChunks.setter + def dataChunks(self, new_val): + # type: (int) -> None + self._dataChunks = new_val + + +class SnapshotSchedulesItem(CrdObject): + _properties = [ + ('interval', 'interval', str, False, False), + ('startTime', 'startTime', str, False, False) + ] + + def __init__(self, + interval=_omit, # type: Optional[str] + startTime=_omit, # type: Optional[str] + ): + super(SnapshotSchedulesItem, self).__init__( + interval=interval, + startTime=startTime, + ) + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def startTime(self): + # type: () -> str + return self._property_impl('startTime') + + @startTime.setter + def startTime(self, new_val): + # type: (Optional[str]) -> None + self._startTime = new_val + + +class SnapshotSchedulesList(CrdObjectList): + _items_type = SnapshotSchedulesItem + + +class Mirroring(CrdObject): + _properties = [ + ('enabled', 'enabled', bool, False, False), + ('mode', 'mode', str, False, False), + ('snapshotSchedules', 'snapshotSchedules', 'SnapshotSchedulesList', False, False) + ] + + def __init__(self, + enabled=_omit, # type: Optional[bool] + mode=_omit, # type: Optional[str] + snapshotSchedules=_omit, # type: Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]] + ): + super(Mirroring, self).__init__( + enabled=enabled, + mode=mode, + snapshotSchedules=snapshotSchedules, + ) + + @property + def enabled(self): + # type: () -> bool + return self._property_impl('enabled') + + @enabled.setter + def enabled(self, new_val): + # type: (Optional[bool]) -> None + self._enabled = new_val + + @property + def mode(self): + # type: () -> str + return self._property_impl('mode') + + @mode.setter + def mode(self, new_val): + # type: (Optional[str]) -> None + self._mode = new_val + + @property + def snapshotSchedules(self): + # type: () -> Union[List[SnapshotSchedulesItem], CrdObjectList] + return self._property_impl('snapshotSchedules') + + @snapshotSchedules.setter + def snapshotSchedules(self, new_val): + # type: (Optional[Union[List[SnapshotSchedulesItem], CrdObjectList]]) -> None + self._snapshotSchedules = new_val + + +class Quotas(CrdObject): + _properties = [ + ('maxBytes', 'maxBytes', int, False, False), + ('maxObjects', 'maxObjects', int, False, False), + ('maxSize', 'maxSize', str, False, False) + ] + + def __init__(self, + maxBytes=_omit, # type: Optional[int] + maxObjects=_omit, # type: Optional[int] + maxSize=_omit, # type: Optional[str] + ): + super(Quotas, self).__init__( + maxBytes=maxBytes, + maxObjects=maxObjects, + maxSize=maxSize, + ) + + @property + def maxBytes(self): + # type: () -> int + return self._property_impl('maxBytes') + + @maxBytes.setter + def maxBytes(self, new_val): + # type: (Optional[int]) -> None + self._maxBytes = new_val + + @property + def maxObjects(self): + # type: () -> int + return self._property_impl('maxObjects') + + @maxObjects.setter + def maxObjects(self, new_val): + # type: (Optional[int]) -> None + self._maxObjects = new_val + + @property + def maxSize(self): + # type: () -> str + return self._property_impl('maxSize') + + @maxSize.setter + def maxSize(self, new_val): + # type: (Optional[str]) -> None + self._maxSize = new_val + + +class Replicated(CrdObject): + _properties = [ + ('replicasPerFailureDomain', 'replicasPerFailureDomain', int, False, False), + ('requireSafeReplicaSize', 'requireSafeReplicaSize', bool, False, False), + ('size', 'size', int, True, False), + ('subFailureDomain', 'subFailureDomain', str, False, False), + ('targetSizeRatio', 'targetSizeRatio', float, False, False) + ] + + def __init__(self, + size, # type: int + replicasPerFailureDomain=_omit, # type: Optional[int] + requireSafeReplicaSize=_omit, # type: Optional[bool] + subFailureDomain=_omit, # type: Optional[str] + targetSizeRatio=_omit, # type: Optional[float] + ): + super(Replicated, self).__init__( + size=size, + replicasPerFailureDomain=replicasPerFailureDomain, + requireSafeReplicaSize=requireSafeReplicaSize, + subFailureDomain=subFailureDomain, + targetSizeRatio=targetSizeRatio, + ) + + @property + def replicasPerFailureDomain(self): + # type: () -> int + return self._property_impl('replicasPerFailureDomain') + + @replicasPerFailureDomain.setter + def replicasPerFailureDomain(self, new_val): + # type: (Optional[int]) -> None + self._replicasPerFailureDomain = new_val + + @property + def requireSafeReplicaSize(self): + # type: () -> bool + return self._property_impl('requireSafeReplicaSize') + + @requireSafeReplicaSize.setter + def requireSafeReplicaSize(self, new_val): + # type: (Optional[bool]) -> None + self._requireSafeReplicaSize = new_val + + @property + def size(self): + # type: () -> int + return self._property_impl('size') + + @size.setter + def size(self, new_val): + # type: (int) -> None + self._size = new_val + + @property + def subFailureDomain(self): + # type: () -> str + return self._property_impl('subFailureDomain') + + @subFailureDomain.setter + def subFailureDomain(self, new_val): + # type: (Optional[str]) -> None + self._subFailureDomain = new_val + + @property + def targetSizeRatio(self): + # type: () -> float + return self._property_impl('targetSizeRatio') + + @targetSizeRatio.setter + def targetSizeRatio(self, new_val): + # type: (Optional[float]) -> None + self._targetSizeRatio = new_val + + +class Mirror(CrdObject): + _properties = [ + ('disabled', 'disabled', bool, False, False), + ('interval', 'interval', str, False, False), + ('timeout', 'timeout', str, False, False) + ] + + def __init__(self, + disabled=_omit, # type: Optional[bool] + interval=_omit, # type: Optional[str] + timeout=_omit, # type: Optional[str] + ): + super(Mirror, self).__init__( + disabled=disabled, + interval=interval, + timeout=timeout, + ) + + @property + def disabled(self): + # type: () -> bool + return self._property_impl('disabled') + + @disabled.setter + def disabled(self, new_val): + # type: (Optional[bool]) -> None + self._disabled = new_val + + @property + def interval(self): + # type: () -> str + return self._property_impl('interval') + + @interval.setter + def interval(self, new_val): + # type: (Optional[str]) -> None + self._interval = new_val + + @property + def timeout(self): + # type: () -> str + return self._property_impl('timeout') + + @timeout.setter + def timeout(self, new_val): + # type: (Optional[str]) -> None + self._timeout = new_val + + +class StatusCheck(CrdObject): + _properties = [ + ('mirror', 'mirror', 'Mirror', False, True) + ] + + def __init__(self, + mirror=_omit, # type: Optional[Mirror] + ): + super(StatusCheck, self).__init__( + mirror=mirror, + ) + + @property + def mirror(self): + # type: () -> Optional[Mirror] + return self._property_impl('mirror') + + @mirror.setter + def mirror(self, new_val): + # type: (Optional[Mirror]) -> None + self._mirror = new_val + + +class DataPool(CrdObject): + _properties = [ + ('compressionMode', 'compressionMode', str, False, True), + ('crushRoot', 'crushRoot', str, False, True), + ('deviceClass', 'deviceClass', str, False, True), + ('enableRBDStats', 'enableRBDStats', bool, False, False), + ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False), + ('failureDomain', 'failureDomain', str, False, False), + ('mirroring', 'mirroring', 'Mirroring', False, False), + ('parameters', 'parameters', object, False, True), + ('quotas', 'quotas', 'Quotas', False, True), + ('replicated', 'replicated', 'Replicated', False, False), + ('statusCheck', 'statusCheck', 'StatusCheck', False, False) + ] + + def __init__(self, + compressionMode=_omit, # type: Optional[str] + crushRoot=_omit, # type: Optional[str] + deviceClass=_omit, # type: Optional[str] + enableRBDStats=_omit, # type: Optional[bool] + erasureCoded=_omit, # type: Optional[ErasureCoded] + failureDomain=_omit, # type: Optional[str] + mirroring=_omit, # type: Optional[Mirroring] + parameters=_omit, # type: Optional[Any] + quotas=_omit, # type: Optional[Quotas] + replicated=_omit, # type: Optional[Replicated] + statusCheck=_omit, # type: Optional[StatusCheck] + ): + super(DataPool, self).__init__( + compressionMode=compressionMode, + crushRoot=crushRoot, + deviceClass=deviceClass, + enableRBDStats=enableRBDStats, + erasureCoded=erasureCoded, + failureDomain=failureDomain, + mirroring=mirroring, + parameters=parameters, + quotas=quotas, + replicated=replicated, + statusCheck=statusCheck, + ) + + @property + def compressionMode(self): + # type: () -> Optional[str] + return self._property_impl('compressionMode') + + @compressionMode.setter + def compressionMode(self, new_val): + # type: (Optional[str]) -> None + self._compressionMode = new_val + + @property + def crushRoot(self): + # type: () -> Optional[str] + return self._property_impl('crushRoot') + + @crushRoot.setter + def crushRoot(self, new_val): + # type: (Optional[str]) -> None + self._crushRoot = new_val + + @property + def deviceClass(self): + # type: () -> Optional[str] + return self._property_impl('deviceClass') + + @deviceClass.setter + def deviceClass(self, new_val): + # type: (Optional[str]) -> None + self._deviceClass = new_val + + @property + def enableRBDStats(self): + # type: () -> bool + return self._property_impl('enableRBDStats') + + @enableRBDStats.setter + def enableRBDStats(self, new_val): + # type: (Optional[bool]) -> None + self._enableRBDStats = new_val + + @property + def erasureCoded(self): + # type: () -> ErasureCoded + return self._property_impl('erasureCoded') + + @erasureCoded.setter + def erasureCoded(self, new_val): + # type: (Optional[ErasureCoded]) -> None + self._erasureCoded = new_val + + @property + def failureDomain(self): + # type: () -> str + return self._property_impl('failureDomain') + + @failureDomain.setter + def failureDomain(self, new_val): + # type: (Optional[str]) -> None + self._failureDomain = new_val + + @property + def mirroring(self): + # type: () -> Mirroring + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def parameters(self): + # type: () -> Optional[Any] + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def quotas(self): + # type: () -> Optional[Quotas] + return self._property_impl('quotas') + + @quotas.setter + def quotas(self, new_val): + # type: (Optional[Quotas]) -> None + self._quotas = new_val + + @property + def replicated(self): + # type: () -> Replicated + return self._property_impl('replicated') + + @replicated.setter + def replicated(self, new_val): + # type: (Optional[Replicated]) -> None + self._replicated = new_val + + @property + def statusCheck(self): + # type: () -> StatusCheck + return self._property_impl('statusCheck') + + @statusCheck.setter + def statusCheck(self, new_val): + # type: (Optional[StatusCheck]) -> None + self._statusCheck = new_val + + +class MetadataPool(CrdObject): + _properties = [ + ('compressionMode', 'compressionMode', str, False, True), + ('crushRoot', 'crushRoot', str, False, True), + ('deviceClass', 'deviceClass', str, False, True), + ('enableRBDStats', 'enableRBDStats', bool, False, False), + ('erasureCoded', 'erasureCoded', 'ErasureCoded', False, False), + ('failureDomain', 'failureDomain', str, False, False), + ('mirroring', 'mirroring', 'Mirroring', False, False), + ('parameters', 'parameters', object, False, True), + ('quotas', 'quotas', 'Quotas', False, True), + ('replicated', 'replicated', 'Replicated', False, False), + ('statusCheck', 'statusCheck', 'StatusCheck', False, False) + ] + + def __init__(self, + compressionMode=_omit, # type: Optional[str] + crushRoot=_omit, # type: Optional[str] + deviceClass=_omit, # type: Optional[str] + enableRBDStats=_omit, # type: Optional[bool] + erasureCoded=_omit, # type: Optional[ErasureCoded] + failureDomain=_omit, # type: Optional[str] + mirroring=_omit, # type: Optional[Mirroring] + parameters=_omit, # type: Optional[Any] + quotas=_omit, # type: Optional[Quotas] + replicated=_omit, # type: Optional[Replicated] + statusCheck=_omit, # type: Optional[StatusCheck] + ): + super(MetadataPool, self).__init__( + compressionMode=compressionMode, + crushRoot=crushRoot, + deviceClass=deviceClass, + enableRBDStats=enableRBDStats, + erasureCoded=erasureCoded, + failureDomain=failureDomain, + mirroring=mirroring, + parameters=parameters, + quotas=quotas, + replicated=replicated, + statusCheck=statusCheck, + ) + + @property + def compressionMode(self): + # type: () -> Optional[str] + return self._property_impl('compressionMode') + + @compressionMode.setter + def compressionMode(self, new_val): + # type: (Optional[str]) -> None + self._compressionMode = new_val + + @property + def crushRoot(self): + # type: () -> Optional[str] + return self._property_impl('crushRoot') + + @crushRoot.setter + def crushRoot(self, new_val): + # type: (Optional[str]) -> None + self._crushRoot = new_val + + @property + def deviceClass(self): + # type: () -> Optional[str] + return self._property_impl('deviceClass') + + @deviceClass.setter + def deviceClass(self, new_val): + # type: (Optional[str]) -> None + self._deviceClass = new_val + + @property + def enableRBDStats(self): + # type: () -> bool + return self._property_impl('enableRBDStats') + + @enableRBDStats.setter + def enableRBDStats(self, new_val): + # type: (Optional[bool]) -> None + self._enableRBDStats = new_val + + @property + def erasureCoded(self): + # type: () -> ErasureCoded + return self._property_impl('erasureCoded') + + @erasureCoded.setter + def erasureCoded(self, new_val): + # type: (Optional[ErasureCoded]) -> None + self._erasureCoded = new_val + + @property + def failureDomain(self): + # type: () -> str + return self._property_impl('failureDomain') + + @failureDomain.setter + def failureDomain(self, new_val): + # type: (Optional[str]) -> None + self._failureDomain = new_val + + @property + def mirroring(self): + # type: () -> Mirroring + return self._property_impl('mirroring') + + @mirroring.setter + def mirroring(self, new_val): + # type: (Optional[Mirroring]) -> None + self._mirroring = new_val + + @property + def parameters(self): + # type: () -> Optional[Any] + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def quotas(self): + # type: () -> Optional[Quotas] + return self._property_impl('quotas') + + @quotas.setter + def quotas(self, new_val): + # type: (Optional[Quotas]) -> None + self._quotas = new_val + + @property + def replicated(self): + # type: () -> Replicated + return self._property_impl('replicated') + + @replicated.setter + def replicated(self, new_val): + # type: (Optional[Replicated]) -> None + self._replicated = new_val + + @property + def statusCheck(self): + # type: () -> StatusCheck + return self._property_impl('statusCheck') + + @statusCheck.setter + def statusCheck(self, new_val): + # type: (Optional[StatusCheck]) -> None + self._statusCheck = new_val + + +class Spec(CrdObject): + _properties = [ + ('dataPool', 'dataPool', 'DataPool', True, True), + ('metadataPool', 'metadataPool', 'MetadataPool', True, True), + ('zoneGroup', 'zoneGroup', str, True, False) + ] + + def __init__(self, + dataPool, # type: Optional[DataPool] + metadataPool, # type: Optional[MetadataPool] + zoneGroup, # type: str + ): + super(Spec, self).__init__( + dataPool=dataPool, + metadataPool=metadataPool, + zoneGroup=zoneGroup, + ) + + @property + def dataPool(self): + # type: () -> Optional[DataPool] + return self._property_impl('dataPool') + + @dataPool.setter + def dataPool(self, new_val): + # type: (Optional[DataPool]) -> None + self._dataPool = new_val + + @property + def metadataPool(self): + # type: () -> Optional[MetadataPool] + return self._property_impl('metadataPool') + + @metadataPool.setter + def metadataPool(self, new_val): + # type: (Optional[MetadataPool]) -> None + self._metadataPool = new_val + + @property + def zoneGroup(self): + # type: () -> str + return self._property_impl('zoneGroup') + + @zoneGroup.setter + def zoneGroup(self, new_val): + # type: (str) -> None + self._zoneGroup = new_val + + +class Status(CrdObject): + _properties = [ + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + phase=phase, + ) + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephObjectZone(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephObjectZone, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzonegroup.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzonegroup.py new file mode 100644 index 000000000..d535a1b7a --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephobjectzonegroup.py @@ -0,0 +1,131 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Spec(CrdObject): + _properties = [ + ('realm', 'realm', str, True, False) + ] + + def __init__(self, + realm, # type: str + ): + super(Spec, self).__init__( + realm=realm, + ) + + @property + def realm(self): + # type: () -> str + return self._property_impl('realm') + + @realm.setter + def realm(self, new_val): + # type: (str) -> None + self._realm = new_val + + +class Status(CrdObject): + _properties = [ + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + phase=phase, + ) + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephObjectZoneGroup(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephObjectZoneGroup, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephrbdmirror.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephrbdmirror.py new file mode 100644 index 000000000..4d121377f --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/cephrbdmirror.py @@ -0,0 +1,1066 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class SecretNamesList(CrdObjectList): + _items_type = str + + +class Peers(CrdObject): + _properties = [ + ('secretNames', 'secretNames', 'SecretNamesList', False, False) + ] + + def __init__(self, + secretNames=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(Peers, self).__init__( + secretNames=secretNames, + ) + + @property + def secretNames(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('secretNames') + + @secretNames.setter + def secretNames(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._secretNames = new_val + + +class ValuesList(CrdObjectList): + _items_type = str + + +class MatchExpressionsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchExpressionsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchExpressionsList(CrdObjectList): + _items_type = MatchExpressionsItem + + +class MatchFieldsItem(CrdObject): + _properties = [ + ('key', 'key', str, True, False), + ('operator', 'operator', str, True, False), + ('values', 'values', 'ValuesList', False, False) + ] + + def __init__(self, + key, # type: str + operator, # type: str + values=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(MatchFieldsItem, self).__init__( + key=key, + operator=operator, + values=values, + ) + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (str) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (str) -> None + self._operator = new_val + + @property + def values(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('values') + + @values.setter + def values(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._values = new_val + + +class MatchFieldsList(CrdObjectList): + _items_type = MatchFieldsItem + + +class Preference(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(Preference, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('podAffinityTerm', 'podAffinityTerm', 'PodAffinityTerm', False, False), + ('weight', 'weight', int, False, False), + ('preference', 'preference', 'Preference', False, False) + ] + + def __init__(self, + podAffinityTerm=_omit, # type: Optional[PodAffinityTerm] + weight=_omit, # type: Optional[int] + preference=_omit, # type: Optional[Preference] + ): + super(PreferredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + podAffinityTerm=podAffinityTerm, + weight=weight, + preference=preference, + ) + + @property + def podAffinityTerm(self): + # type: () -> PodAffinityTerm + return self._property_impl('podAffinityTerm') + + @podAffinityTerm.setter + def podAffinityTerm(self, new_val): + # type: (Optional[PodAffinityTerm]) -> None + self._podAffinityTerm = new_val + + @property + def weight(self): + # type: () -> int + return self._property_impl('weight') + + @weight.setter + def weight(self, new_val): + # type: (Optional[int]) -> None + self._weight = new_val + + @property + def preference(self): + # type: () -> Preference + return self._property_impl('preference') + + @preference.setter + def preference(self, new_val): + # type: (Optional[Preference]) -> None + self._preference = new_val + + +class PreferredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = PreferredDuringSchedulingIgnoredDuringExecutionItem + + +class NodeSelectorTermsItem(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchFields', 'matchFields', 'MatchFieldsList', False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchFields=_omit, # type: Optional[Union[List[MatchFieldsItem], CrdObjectList]] + ): + super(NodeSelectorTermsItem, self).__init__( + matchExpressions=matchExpressions, + matchFields=matchFields, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchFields(self): + # type: () -> Union[List[MatchFieldsItem], CrdObjectList] + return self._property_impl('matchFields') + + @matchFields.setter + def matchFields(self, new_val): + # type: (Optional[Union[List[MatchFieldsItem], CrdObjectList]]) -> None + self._matchFields = new_val + + +class NodeSelectorTermsList(CrdObjectList): + _items_type = NodeSelectorTermsItem + + +class RequiredDuringSchedulingIgnoredDuringExecution(CrdObject): + _properties = [ + ('nodeSelectorTerms', 'nodeSelectorTerms', 'NodeSelectorTermsList', True, False) + ] + + def __init__(self, + nodeSelectorTerms, # type: Union[List[NodeSelectorTermsItem], CrdObjectList] + ): + super(RequiredDuringSchedulingIgnoredDuringExecution, self).__init__( + nodeSelectorTerms=nodeSelectorTerms, + ) + + @property + def nodeSelectorTerms(self): + # type: () -> Union[List[NodeSelectorTermsItem], CrdObjectList] + return self._property_impl('nodeSelectorTerms') + + @nodeSelectorTerms.setter + def nodeSelectorTerms(self, new_val): + # type: (Union[List[NodeSelectorTermsItem], CrdObjectList]) -> None + self._nodeSelectorTerms = new_val + + +class NodeAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecution', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[RequiredDuringSchedulingIgnoredDuringExecution] + ): + super(NodeAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> RequiredDuringSchedulingIgnoredDuringExecution + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[RequiredDuringSchedulingIgnoredDuringExecution]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class LabelSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(LabelSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespaceSelector(CrdObject): + _properties = [ + ('matchExpressions', 'matchExpressions', 'MatchExpressionsList', False, False), + ('matchLabels', 'matchLabels', object, False, False) + ] + + def __init__(self, + matchExpressions=_omit, # type: Optional[Union[List[MatchExpressionsItem], CrdObjectList]] + matchLabels=_omit, # type: Optional[Any] + ): + super(NamespaceSelector, self).__init__( + matchExpressions=matchExpressions, + matchLabels=matchLabels, + ) + + @property + def matchExpressions(self): + # type: () -> Union[List[MatchExpressionsItem], CrdObjectList] + return self._property_impl('matchExpressions') + + @matchExpressions.setter + def matchExpressions(self, new_val): + # type: (Optional[Union[List[MatchExpressionsItem], CrdObjectList]]) -> None + self._matchExpressions = new_val + + @property + def matchLabels(self): + # type: () -> Any + return self._property_impl('matchLabels') + + @matchLabels.setter + def matchLabels(self, new_val): + # type: (Optional[Any]) -> None + self._matchLabels = new_val + + +class NamespacesList(CrdObjectList): + _items_type = str + + +class PodAffinityTerm(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(PodAffinityTerm, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('namespaceSelector', 'namespaceSelector', 'NamespaceSelector', False, False), + ('namespaces', 'namespaces', 'NamespacesList', False, False), + ('topologyKey', 'topologyKey', str, True, False) + ] + + def __init__(self, + topologyKey, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + namespaceSelector=_omit, # type: Optional[NamespaceSelector] + namespaces=_omit, # type: Optional[Union[List[str], CrdObjectList]] + ): + super(RequiredDuringSchedulingIgnoredDuringExecutionItem, self).__init__( + topologyKey=topologyKey, + labelSelector=labelSelector, + namespaceSelector=namespaceSelector, + namespaces=namespaces, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def namespaceSelector(self): + # type: () -> NamespaceSelector + return self._property_impl('namespaceSelector') + + @namespaceSelector.setter + def namespaceSelector(self, new_val): + # type: (Optional[NamespaceSelector]) -> None + self._namespaceSelector = new_val + + @property + def namespaces(self): + # type: () -> Union[List[str], CrdObjectList] + return self._property_impl('namespaces') + + @namespaces.setter + def namespaces(self, new_val): + # type: (Optional[Union[List[str], CrdObjectList]]) -> None + self._namespaces = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + +class RequiredDuringSchedulingIgnoredDuringExecutionList(CrdObjectList): + _items_type = RequiredDuringSchedulingIgnoredDuringExecutionItem + + +class PodAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class PodAntiAffinity(CrdObject): + _properties = [ + ('preferredDuringSchedulingIgnoredDuringExecution', 'preferredDuringSchedulingIgnoredDuringExecution', 'PreferredDuringSchedulingIgnoredDuringExecutionList', False, False), + ('requiredDuringSchedulingIgnoredDuringExecution', 'requiredDuringSchedulingIgnoredDuringExecution', 'RequiredDuringSchedulingIgnoredDuringExecutionList', False, False) + ] + + def __init__(self, + preferredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + requiredDuringSchedulingIgnoredDuringExecution=_omit, # type: Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]] + ): + super(PodAntiAffinity, self).__init__( + preferredDuringSchedulingIgnoredDuringExecution=preferredDuringSchedulingIgnoredDuringExecution, + requiredDuringSchedulingIgnoredDuringExecution=requiredDuringSchedulingIgnoredDuringExecution, + ) + + @property + def preferredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('preferredDuringSchedulingIgnoredDuringExecution') + + @preferredDuringSchedulingIgnoredDuringExecution.setter + def preferredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[PreferredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._preferredDuringSchedulingIgnoredDuringExecution = new_val + + @property + def requiredDuringSchedulingIgnoredDuringExecution(self): + # type: () -> Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList] + return self._property_impl('requiredDuringSchedulingIgnoredDuringExecution') + + @requiredDuringSchedulingIgnoredDuringExecution.setter + def requiredDuringSchedulingIgnoredDuringExecution(self, new_val): + # type: (Optional[Union[List[RequiredDuringSchedulingIgnoredDuringExecutionItem], CrdObjectList]]) -> None + self._requiredDuringSchedulingIgnoredDuringExecution = new_val + + +class TolerationsItem(CrdObject): + _properties = [ + ('effect', 'effect', str, False, False), + ('key', 'key', str, False, False), + ('operator', 'operator', str, False, False), + ('tolerationSeconds', 'tolerationSeconds', int, False, False), + ('value', 'value', str, False, False) + ] + + def __init__(self, + effect=_omit, # type: Optional[str] + key=_omit, # type: Optional[str] + operator=_omit, # type: Optional[str] + tolerationSeconds=_omit, # type: Optional[int] + value=_omit, # type: Optional[str] + ): + super(TolerationsItem, self).__init__( + effect=effect, + key=key, + operator=operator, + tolerationSeconds=tolerationSeconds, + value=value, + ) + + @property + def effect(self): + # type: () -> str + return self._property_impl('effect') + + @effect.setter + def effect(self, new_val): + # type: (Optional[str]) -> None + self._effect = new_val + + @property + def key(self): + # type: () -> str + return self._property_impl('key') + + @key.setter + def key(self, new_val): + # type: (Optional[str]) -> None + self._key = new_val + + @property + def operator(self): + # type: () -> str + return self._property_impl('operator') + + @operator.setter + def operator(self, new_val): + # type: (Optional[str]) -> None + self._operator = new_val + + @property + def tolerationSeconds(self): + # type: () -> int + return self._property_impl('tolerationSeconds') + + @tolerationSeconds.setter + def tolerationSeconds(self, new_val): + # type: (Optional[int]) -> None + self._tolerationSeconds = new_val + + @property + def value(self): + # type: () -> str + return self._property_impl('value') + + @value.setter + def value(self, new_val): + # type: (Optional[str]) -> None + self._value = new_val + + +class TolerationsList(CrdObjectList): + _items_type = TolerationsItem + + +class TopologySpreadConstraintsItem(CrdObject): + _properties = [ + ('labelSelector', 'labelSelector', 'LabelSelector', False, False), + ('maxSkew', 'maxSkew', int, True, False), + ('topologyKey', 'topologyKey', str, True, False), + ('whenUnsatisfiable', 'whenUnsatisfiable', str, True, False) + ] + + def __init__(self, + maxSkew, # type: int + topologyKey, # type: str + whenUnsatisfiable, # type: str + labelSelector=_omit, # type: Optional[LabelSelector] + ): + super(TopologySpreadConstraintsItem, self).__init__( + maxSkew=maxSkew, + topologyKey=topologyKey, + whenUnsatisfiable=whenUnsatisfiable, + labelSelector=labelSelector, + ) + + @property + def labelSelector(self): + # type: () -> LabelSelector + return self._property_impl('labelSelector') + + @labelSelector.setter + def labelSelector(self, new_val): + # type: (Optional[LabelSelector]) -> None + self._labelSelector = new_val + + @property + def maxSkew(self): + # type: () -> int + return self._property_impl('maxSkew') + + @maxSkew.setter + def maxSkew(self, new_val): + # type: (int) -> None + self._maxSkew = new_val + + @property + def topologyKey(self): + # type: () -> str + return self._property_impl('topologyKey') + + @topologyKey.setter + def topologyKey(self, new_val): + # type: (str) -> None + self._topologyKey = new_val + + @property + def whenUnsatisfiable(self): + # type: () -> str + return self._property_impl('whenUnsatisfiable') + + @whenUnsatisfiable.setter + def whenUnsatisfiable(self, new_val): + # type: (str) -> None + self._whenUnsatisfiable = new_val + + +class TopologySpreadConstraintsList(CrdObjectList): + _items_type = TopologySpreadConstraintsItem + + +class Placement(CrdObject): + _properties = [ + ('nodeAffinity', 'nodeAffinity', 'NodeAffinity', False, False), + ('podAffinity', 'podAffinity', 'PodAffinity', False, False), + ('podAntiAffinity', 'podAntiAffinity', 'PodAntiAffinity', False, False), + ('tolerations', 'tolerations', 'TolerationsList', False, False), + ('topologySpreadConstraints', 'topologySpreadConstraints', 'TopologySpreadConstraintsList', False, False) + ] + + def __init__(self, + nodeAffinity=_omit, # type: Optional[NodeAffinity] + podAffinity=_omit, # type: Optional[PodAffinity] + podAntiAffinity=_omit, # type: Optional[PodAntiAffinity] + tolerations=_omit, # type: Optional[Union[List[TolerationsItem], CrdObjectList]] + topologySpreadConstraints=_omit, # type: Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]] + ): + super(Placement, self).__init__( + nodeAffinity=nodeAffinity, + podAffinity=podAffinity, + podAntiAffinity=podAntiAffinity, + tolerations=tolerations, + topologySpreadConstraints=topologySpreadConstraints, + ) + + @property + def nodeAffinity(self): + # type: () -> NodeAffinity + return self._property_impl('nodeAffinity') + + @nodeAffinity.setter + def nodeAffinity(self, new_val): + # type: (Optional[NodeAffinity]) -> None + self._nodeAffinity = new_val + + @property + def podAffinity(self): + # type: () -> PodAffinity + return self._property_impl('podAffinity') + + @podAffinity.setter + def podAffinity(self, new_val): + # type: (Optional[PodAffinity]) -> None + self._podAffinity = new_val + + @property + def podAntiAffinity(self): + # type: () -> PodAntiAffinity + return self._property_impl('podAntiAffinity') + + @podAntiAffinity.setter + def podAntiAffinity(self, new_val): + # type: (Optional[PodAntiAffinity]) -> None + self._podAntiAffinity = new_val + + @property + def tolerations(self): + # type: () -> Union[List[TolerationsItem], CrdObjectList] + return self._property_impl('tolerations') + + @tolerations.setter + def tolerations(self, new_val): + # type: (Optional[Union[List[TolerationsItem], CrdObjectList]]) -> None + self._tolerations = new_val + + @property + def topologySpreadConstraints(self): + # type: () -> Union[List[TopologySpreadConstraintsItem], CrdObjectList] + return self._property_impl('topologySpreadConstraints') + + @topologySpreadConstraints.setter + def topologySpreadConstraints(self, new_val): + # type: (Optional[Union[List[TopologySpreadConstraintsItem], CrdObjectList]]) -> None + self._topologySpreadConstraints = new_val + + +class Resources(CrdObject): + _properties = [ + ('limits', 'limits', object, False, False), + ('requests', 'requests', object, False, False) + ] + + def __init__(self, + limits=_omit, # type: Optional[Any] + requests=_omit, # type: Optional[Any] + ): + super(Resources, self).__init__( + limits=limits, + requests=requests, + ) + + @property + def limits(self): + # type: () -> Any + return self._property_impl('limits') + + @limits.setter + def limits(self, new_val): + # type: (Optional[Any]) -> None + self._limits = new_val + + @property + def requests(self): + # type: () -> Any + return self._property_impl('requests') + + @requests.setter + def requests(self, new_val): + # type: (Optional[Any]) -> None + self._requests = new_val + + +class Spec(CrdObject): + _properties = [ + ('annotations', 'annotations', object, False, True), + ('count', 'count', int, True, False), + ('labels', 'labels', object, False, True), + ('peers', 'peers', 'Peers', False, True), + ('placement', 'placement', 'Placement', False, True), + ('priorityClassName', 'priorityClassName', str, False, False), + ('resources', 'resources', 'Resources', False, True) + ] + + def __init__(self, + count, # type: int + annotations=_omit, # type: Optional[Any] + labels=_omit, # type: Optional[Any] + peers=_omit, # type: Optional[Peers] + placement=_omit, # type: Optional[Placement] + priorityClassName=_omit, # type: Optional[str] + resources=_omit, # type: Optional[Resources] + ): + super(Spec, self).__init__( + count=count, + annotations=annotations, + labels=labels, + peers=peers, + placement=placement, + priorityClassName=priorityClassName, + resources=resources, + ) + + @property + def annotations(self): + # type: () -> Optional[Any] + return self._property_impl('annotations') + + @annotations.setter + def annotations(self, new_val): + # type: (Optional[Any]) -> None + self._annotations = new_val + + @property + def count(self): + # type: () -> int + return self._property_impl('count') + + @count.setter + def count(self, new_val): + # type: (int) -> None + self._count = new_val + + @property + def labels(self): + # type: () -> Optional[Any] + return self._property_impl('labels') + + @labels.setter + def labels(self, new_val): + # type: (Optional[Any]) -> None + self._labels = new_val + + @property + def peers(self): + # type: () -> Optional[Peers] + return self._property_impl('peers') + + @peers.setter + def peers(self, new_val): + # type: (Optional[Peers]) -> None + self._peers = new_val + + @property + def placement(self): + # type: () -> Optional[Placement] + return self._property_impl('placement') + + @placement.setter + def placement(self, new_val): + # type: (Optional[Placement]) -> None + self._placement = new_val + + @property + def priorityClassName(self): + # type: () -> str + return self._property_impl('priorityClassName') + + @priorityClassName.setter + def priorityClassName(self, new_val): + # type: (Optional[str]) -> None + self._priorityClassName = new_val + + @property + def resources(self): + # type: () -> Optional[Resources] + return self._property_impl('resources') + + @resources.setter + def resources(self, new_val): + # type: (Optional[Resources]) -> None + self._resources = new_val + + +class Status(CrdObject): + _properties = [ + ('phase', 'phase', str, False, False) + ] + + def __init__(self, + phase=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + phase=phase, + ) + + @property + def phase(self): + # type: () -> str + return self._property_impl('phase') + + @phase.setter + def phase(self, new_val): + # type: (Optional[str]) -> None + self._phase = new_val + + +class CephRBDMirror(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(CephRBDMirror, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucket.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucket.py new file mode 100644 index 000000000..7d4158a47 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucket.py @@ -0,0 +1,252 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Endpoint(CrdObject): + _properties = [ + ('bucketHost', 'bucketHost', str, False, False), + ('bucketPort', 'bucketPort', int, False, False), + ('bucketName', 'bucketName', str, False, False), + ('region', 'region', str, False, False), + ('subRegion', 'subRegion', str, False, False), + ('additionalConfig', 'additionalConfig', object, False, True) + ] + + def __init__(self, + bucketHost=_omit, # type: Optional[str] + bucketPort=_omit, # type: Optional[int] + bucketName=_omit, # type: Optional[str] + region=_omit, # type: Optional[str] + subRegion=_omit, # type: Optional[str] + additionalConfig=_omit, # type: Optional[Any] + ): + super(Endpoint, self).__init__( + bucketHost=bucketHost, + bucketPort=bucketPort, + bucketName=bucketName, + region=region, + subRegion=subRegion, + additionalConfig=additionalConfig, + ) + + @property + def bucketHost(self): + # type: () -> str + return self._property_impl('bucketHost') + + @bucketHost.setter + def bucketHost(self, new_val): + # type: (Optional[str]) -> None + self._bucketHost = new_val + + @property + def bucketPort(self): + # type: () -> int + return self._property_impl('bucketPort') + + @bucketPort.setter + def bucketPort(self, new_val): + # type: (Optional[int]) -> None + self._bucketPort = new_val + + @property + def bucketName(self): + # type: () -> str + return self._property_impl('bucketName') + + @bucketName.setter + def bucketName(self, new_val): + # type: (Optional[str]) -> None + self._bucketName = new_val + + @property + def region(self): + # type: () -> str + return self._property_impl('region') + + @region.setter + def region(self, new_val): + # type: (Optional[str]) -> None + self._region = new_val + + @property + def subRegion(self): + # type: () -> str + return self._property_impl('subRegion') + + @subRegion.setter + def subRegion(self, new_val): + # type: (Optional[str]) -> None + self._subRegion = new_val + + @property + def additionalConfig(self): + # type: () -> Optional[Any] + return self._property_impl('additionalConfig') + + @additionalConfig.setter + def additionalConfig(self, new_val): + # type: (Optional[Any]) -> None + self._additionalConfig = new_val + + +class AuthenticationList(CrdObjectList): + _items_type = None + + +class Spec(CrdObject): + _properties = [ + ('storageClassName', 'storageClassName', str, False, False), + ('endpoint', 'endpoint', 'Endpoint', False, True), + ('authentication', 'authentication', 'AuthenticationList', False, True), + ('additionalState', 'additionalState', object, False, True), + ('reclaimPolicy', 'reclaimPolicy', str, False, False), + ('claimRef', 'claimRef', object, False, True) + ] + + def __init__(self, + storageClassName=_omit, # type: Optional[str] + endpoint=_omit, # type: Optional[Endpoint] + authentication=_omit, # type: Optional[Union[List[Any], CrdObjectList]] + additionalState=_omit, # type: Optional[Any] + reclaimPolicy=_omit, # type: Optional[str] + claimRef=_omit, # type: Optional[Any] + ): + super(Spec, self).__init__( + storageClassName=storageClassName, + endpoint=endpoint, + authentication=authentication, + additionalState=additionalState, + reclaimPolicy=reclaimPolicy, + claimRef=claimRef, + ) + + @property + def storageClassName(self): + # type: () -> str + return self._property_impl('storageClassName') + + @storageClassName.setter + def storageClassName(self, new_val): + # type: (Optional[str]) -> None + self._storageClassName = new_val + + @property + def endpoint(self): + # type: () -> Optional[Endpoint] + return self._property_impl('endpoint') + + @endpoint.setter + def endpoint(self, new_val): + # type: (Optional[Endpoint]) -> None + self._endpoint = new_val + + @property + def authentication(self): + # type: () -> Optional[Union[List[Any], CrdObjectList]] + return self._property_impl('authentication') + + @authentication.setter + def authentication(self, new_val): + # type: (Optional[Union[List[Any], CrdObjectList]]) -> None + self._authentication = new_val + + @property + def additionalState(self): + # type: () -> Optional[Any] + return self._property_impl('additionalState') + + @additionalState.setter + def additionalState(self, new_val): + # type: (Optional[Any]) -> None + self._additionalState = new_val + + @property + def reclaimPolicy(self): + # type: () -> str + return self._property_impl('reclaimPolicy') + + @reclaimPolicy.setter + def reclaimPolicy(self, new_val): + # type: (Optional[str]) -> None + self._reclaimPolicy = new_val + + @property + def claimRef(self): + # type: () -> Optional[Any] + return self._property_impl('claimRef') + + @claimRef.setter + def claimRef(self, new_val): + # type: (Optional[Any]) -> None + self._claimRef = new_val + + +class ObjectBucket(CrdClass): + _properties = [ + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', object, False, False), + ('apiVersion', 'apiVersion', str, True, False), + ('metadata', 'metadata', object, True, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion, # type: str + metadata, # type: Any + status=_omit, # type: Optional[Any] + ): + super(ObjectBucket, self).__init__( + spec=spec, + apiVersion=apiVersion, + metadata=metadata, + status=status, + ) + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Any + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Any]) -> None + self._status = new_val + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (str) -> None + self._apiVersion = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Any) -> None + self._metadata = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucketclaim.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucketclaim.py new file mode 100644 index 000000000..3a976a167 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/objectbucketclaim.py @@ -0,0 +1,147 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Spec(CrdObject): + _properties = [ + ('storageClassName', 'storageClassName', str, False, False), + ('bucketName', 'bucketName', str, False, False), + ('generateBucketName', 'generateBucketName', str, False, False), + ('additionalConfig', 'additionalConfig', object, False, True), + ('objectBucketName', 'objectBucketName', str, False, False) + ] + + def __init__(self, + storageClassName=_omit, # type: Optional[str] + bucketName=_omit, # type: Optional[str] + generateBucketName=_omit, # type: Optional[str] + additionalConfig=_omit, # type: Optional[Any] + objectBucketName=_omit, # type: Optional[str] + ): + super(Spec, self).__init__( + storageClassName=storageClassName, + bucketName=bucketName, + generateBucketName=generateBucketName, + additionalConfig=additionalConfig, + objectBucketName=objectBucketName, + ) + + @property + def storageClassName(self): + # type: () -> str + return self._property_impl('storageClassName') + + @storageClassName.setter + def storageClassName(self, new_val): + # type: (Optional[str]) -> None + self._storageClassName = new_val + + @property + def bucketName(self): + # type: () -> str + return self._property_impl('bucketName') + + @bucketName.setter + def bucketName(self, new_val): + # type: (Optional[str]) -> None + self._bucketName = new_val + + @property + def generateBucketName(self): + # type: () -> str + return self._property_impl('generateBucketName') + + @generateBucketName.setter + def generateBucketName(self, new_val): + # type: (Optional[str]) -> None + self._generateBucketName = new_val + + @property + def additionalConfig(self): + # type: () -> Optional[Any] + return self._property_impl('additionalConfig') + + @additionalConfig.setter + def additionalConfig(self, new_val): + # type: (Optional[Any]) -> None + self._additionalConfig = new_val + + @property + def objectBucketName(self): + # type: () -> str + return self._property_impl('objectBucketName') + + @objectBucketName.setter + def objectBucketName(self, new_val): + # type: (Optional[str]) -> None + self._objectBucketName = new_val + + +class ObjectBucketClaim(CrdClass): + _properties = [ + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', object, False, False), + ('apiVersion', 'apiVersion', str, True, False), + ('metadata', 'metadata', object, True, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion, # type: str + metadata, # type: Any + status=_omit, # type: Optional[Any] + ): + super(ObjectBucketClaim, self).__init__( + spec=spec, + apiVersion=apiVersion, + metadata=metadata, + status=status, + ) + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Any + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Any]) -> None + self._status = new_val + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (str) -> None + self._apiVersion = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Any) -> None + self._metadata = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volume.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volume.py new file mode 100644 index 000000000..8b7c2703c --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volume.py @@ -0,0 +1,177 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class AttachmentsItem(CrdObject): + _properties = [ + ('clusterName', 'clusterName', str, True, False), + ('mountDir', 'mountDir', str, True, False), + ('node', 'node', str, True, False), + ('podName', 'podName', str, True, False), + ('podNamespace', 'podNamespace', str, True, False), + ('readOnly', 'readOnly', bool, True, False) + ] + + def __init__(self, + clusterName, # type: str + mountDir, # type: str + node, # type: str + podName, # type: str + podNamespace, # type: str + readOnly, # type: bool + ): + super(AttachmentsItem, self).__init__( + clusterName=clusterName, + mountDir=mountDir, + node=node, + podName=podName, + podNamespace=podNamespace, + readOnly=readOnly, + ) + + @property + def clusterName(self): + # type: () -> str + return self._property_impl('clusterName') + + @clusterName.setter + def clusterName(self, new_val): + # type: (str) -> None + self._clusterName = new_val + + @property + def mountDir(self): + # type: () -> str + return self._property_impl('mountDir') + + @mountDir.setter + def mountDir(self, new_val): + # type: (str) -> None + self._mountDir = new_val + + @property + def node(self): + # type: () -> str + return self._property_impl('node') + + @node.setter + def node(self, new_val): + # type: (str) -> None + self._node = new_val + + @property + def podName(self): + # type: () -> str + return self._property_impl('podName') + + @podName.setter + def podName(self, new_val): + # type: (str) -> None + self._podName = new_val + + @property + def podNamespace(self): + # type: () -> str + return self._property_impl('podNamespace') + + @podNamespace.setter + def podNamespace(self, new_val): + # type: (str) -> None + self._podNamespace = new_val + + @property + def readOnly(self): + # type: () -> bool + return self._property_impl('readOnly') + + @readOnly.setter + def readOnly(self, new_val): + # type: (bool) -> None + self._readOnly = new_val + + +class AttachmentsList(CrdObjectList): + _items_type = AttachmentsItem + + +class Volume(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('attachments', 'attachments', 'AttachmentsList', False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('status', 'status', object, False, False) + ] + + def __init__(self, + apiVersion=_omit, # type: Optional[str] + attachments=_omit, # type: Optional[Union[List[AttachmentsItem], CrdObjectList]] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Any] + ): + super(Volume, self).__init__( + apiVersion=apiVersion, + attachments=attachments, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def attachments(self): + # type: () -> Union[List[AttachmentsItem], CrdObjectList] + return self._property_impl('attachments') + + @attachments.setter + def attachments(self, new_val): + # type: (Optional[Union[List[AttachmentsItem], CrdObjectList]]) -> None + self._attachments = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def status(self): + # type: () -> Any + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Any]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplication.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplication.py new file mode 100644 index 000000000..1b9252729 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplication.py @@ -0,0 +1,363 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class DataSource(CrdObject): + _properties = [ + ('apiGroup', 'apiGroup', str, False, False), + ('kind', 'kind', str, True, False), + ('name', 'name', str, True, False) + ] + + def __init__(self, + kind, # type: str + name, # type: str + apiGroup=_omit, # type: Optional[str] + ): + super(DataSource, self).__init__( + kind=kind, + name=name, + apiGroup=apiGroup, + ) + + @property + def apiGroup(self): + # type: () -> str + return self._property_impl('apiGroup') + + @apiGroup.setter + def apiGroup(self, new_val): + # type: (Optional[str]) -> None + self._apiGroup = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (str) -> None + self._kind = new_val + + @property + def name(self): + # type: () -> str + return self._property_impl('name') + + @name.setter + def name(self, new_val): + # type: (str) -> None + self._name = new_val + + +class Spec(CrdObject): + _properties = [ + ('dataSource', 'dataSource', 'DataSource', True, False), + ('replicationState', 'replicationState', str, True, False), + ('volumeReplicationClass', 'volumeReplicationClass', str, True, False) + ] + + def __init__(self, + dataSource, # type: DataSource + replicationState, # type: str + volumeReplicationClass, # type: str + ): + super(Spec, self).__init__( + dataSource=dataSource, + replicationState=replicationState, + volumeReplicationClass=volumeReplicationClass, + ) + + @property + def dataSource(self): + # type: () -> DataSource + return self._property_impl('dataSource') + + @dataSource.setter + def dataSource(self, new_val): + # type: (DataSource) -> None + self._dataSource = new_val + + @property + def replicationState(self): + # type: () -> str + return self._property_impl('replicationState') + + @replicationState.setter + def replicationState(self, new_val): + # type: (str) -> None + self._replicationState = new_val + + @property + def volumeReplicationClass(self): + # type: () -> str + return self._property_impl('volumeReplicationClass') + + @volumeReplicationClass.setter + def volumeReplicationClass(self, new_val): + # type: (str) -> None + self._volumeReplicationClass = new_val + + +class ConditionsItem(CrdObject): + _properties = [ + ('lastTransitionTime', 'lastTransitionTime', str, True, False), + ('message', 'message', str, True, False), + ('observedGeneration', 'observedGeneration', int, False, False), + ('reason', 'reason', str, True, False), + ('status', 'status', str, True, False), + ('type', 'type', str, True, False) + ] + + def __init__(self, + lastTransitionTime, # type: str + message, # type: str + reason, # type: str + status, # type: str + type, # type: str + observedGeneration=_omit, # type: Optional[int] + ): + super(ConditionsItem, self).__init__( + lastTransitionTime=lastTransitionTime, + message=message, + reason=reason, + status=status, + type=type, + observedGeneration=observedGeneration, + ) + + @property + def lastTransitionTime(self): + # type: () -> str + return self._property_impl('lastTransitionTime') + + @lastTransitionTime.setter + def lastTransitionTime(self, new_val): + # type: (str) -> None + self._lastTransitionTime = new_val + + @property + def message(self): + # type: () -> str + return self._property_impl('message') + + @message.setter + def message(self, new_val): + # type: (str) -> None + self._message = new_val + + @property + def observedGeneration(self): + # type: () -> int + return self._property_impl('observedGeneration') + + @observedGeneration.setter + def observedGeneration(self, new_val): + # type: (Optional[int]) -> None + self._observedGeneration = new_val + + @property + def reason(self): + # type: () -> str + return self._property_impl('reason') + + @reason.setter + def reason(self, new_val): + # type: (str) -> None + self._reason = new_val + + @property + def status(self): + # type: () -> str + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (str) -> None + self._status = new_val + + @property + def type(self): + # type: () -> str + return self._property_impl('type') + + @type.setter + def type(self, new_val): + # type: (str) -> None + self._type = new_val + + +class ConditionsList(CrdObjectList): + _items_type = ConditionsItem + + +class Status(CrdObject): + _properties = [ + ('conditions', 'conditions', 'ConditionsList', False, False), + ('lastCompletionTime', 'lastCompletionTime', str, False, False), + ('lastStartTime', 'lastStartTime', str, False, False), + ('message', 'message', str, False, False), + ('observedGeneration', 'observedGeneration', int, False, False), + ('state', 'state', str, False, False) + ] + + def __init__(self, + conditions=_omit, # type: Optional[Union[List[ConditionsItem], CrdObjectList]] + lastCompletionTime=_omit, # type: Optional[str] + lastStartTime=_omit, # type: Optional[str] + message=_omit, # type: Optional[str] + observedGeneration=_omit, # type: Optional[int] + state=_omit, # type: Optional[str] + ): + super(Status, self).__init__( + conditions=conditions, + lastCompletionTime=lastCompletionTime, + lastStartTime=lastStartTime, + message=message, + observedGeneration=observedGeneration, + state=state, + ) + + @property + def conditions(self): + # type: () -> Union[List[ConditionsItem], CrdObjectList] + return self._property_impl('conditions') + + @conditions.setter + def conditions(self, new_val): + # type: (Optional[Union[List[ConditionsItem], CrdObjectList]]) -> None + self._conditions = new_val + + @property + def lastCompletionTime(self): + # type: () -> str + return self._property_impl('lastCompletionTime') + + @lastCompletionTime.setter + def lastCompletionTime(self, new_val): + # type: (Optional[str]) -> None + self._lastCompletionTime = new_val + + @property + def lastStartTime(self): + # type: () -> str + return self._property_impl('lastStartTime') + + @lastStartTime.setter + def lastStartTime(self, new_val): + # type: (Optional[str]) -> None + self._lastStartTime = new_val + + @property + def message(self): + # type: () -> str + return self._property_impl('message') + + @message.setter + def message(self, new_val): + # type: (Optional[str]) -> None + self._message = new_val + + @property + def observedGeneration(self): + # type: () -> int + return self._property_impl('observedGeneration') + + @observedGeneration.setter + def observedGeneration(self, new_val): + # type: (Optional[int]) -> None + self._observedGeneration = new_val + + @property + def state(self): + # type: () -> str + return self._property_impl('state') + + @state.setter + def state(self, new_val): + # type: (Optional[str]) -> None + self._state = new_val + + +class VolumeReplication(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', 'Status', False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Status] + ): + super(VolumeReplication, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Status + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Status]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplicationclass.py b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplicationclass.py new file mode 100644 index 000000000..842a131e1 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/volumereplicationclass.py @@ -0,0 +1,121 @@ +""" +This file is automatically generated. +Do not modify. +""" + +try: + from typing import Any, Optional, Union, List +except ImportError: + pass + +from .._helper import _omit, CrdObject, CrdObjectList, CrdClass + +class Spec(CrdObject): + _properties = [ + ('parameters', 'parameters', object, False, False), + ('provisioner', 'provisioner', str, True, False) + ] + + def __init__(self, + provisioner, # type: str + parameters=_omit, # type: Optional[Any] + ): + super(Spec, self).__init__( + provisioner=provisioner, + parameters=parameters, + ) + + @property + def parameters(self): + # type: () -> Any + return self._property_impl('parameters') + + @parameters.setter + def parameters(self, new_val): + # type: (Optional[Any]) -> None + self._parameters = new_val + + @property + def provisioner(self): + # type: () -> str + return self._property_impl('provisioner') + + @provisioner.setter + def provisioner(self, new_val): + # type: (str) -> None + self._provisioner = new_val + + +class VolumeReplicationClass(CrdClass): + _properties = [ + ('apiVersion', 'apiVersion', str, False, False), + ('kind', 'kind', str, False, False), + ('metadata', 'metadata', object, False, False), + ('spec', 'spec', 'Spec', True, False), + ('status', 'status', object, False, False) + ] + + def __init__(self, + spec, # type: Spec + apiVersion=_omit, # type: Optional[str] + kind=_omit, # type: Optional[str] + metadata=_omit, # type: Optional[Any] + status=_omit, # type: Optional[Any] + ): + super(VolumeReplicationClass, self).__init__( + spec=spec, + apiVersion=apiVersion, + kind=kind, + metadata=metadata, + status=status, + ) + + @property + def apiVersion(self): + # type: () -> str + return self._property_impl('apiVersion') + + @apiVersion.setter + def apiVersion(self, new_val): + # type: (Optional[str]) -> None + self._apiVersion = new_val + + @property + def kind(self): + # type: () -> str + return self._property_impl('kind') + + @kind.setter + def kind(self, new_val): + # type: (Optional[str]) -> None + self._kind = new_val + + @property + def metadata(self): + # type: () -> Any + return self._property_impl('metadata') + + @metadata.setter + def metadata(self, new_val): + # type: (Optional[Any]) -> None + self._metadata = new_val + + @property + def spec(self): + # type: () -> Spec + return self._property_impl('spec') + + @spec.setter + def spec(self, new_val): + # type: (Spec) -> None + self._spec = new_val + + @property + def status(self): + # type: () -> Any + return self._property_impl('status') + + @status.setter + def status(self, new_val): + # type: (Optional[Any]) -> None + self._status = new_val diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/py.typed b/src/pybind/mgr/rook/rook-client-python/rook_client/py.typed new file mode 100644 index 000000000..80dd90bf1 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/py.typed @@ -0,0 +1 @@ +# Marker file for PEP 561. This package uses inline types. diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/__init__.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_README.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_README.py new file mode 100644 index 000000000..50d6c41b4 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_README.py @@ -0,0 +1,28 @@ +def objectstore(api_name, name, namespace, instances): + from rook_client.ceph import cephobjectstore as cos + rook_os = cos.CephObjectStore( + apiVersion=api_name, + metadata=dict( + name=name, + namespace=namespace + ), + spec=cos.Spec( + metadataPool=cos.MetadataPool( + failureDomain='host', + replicated=cos.Replicated( + size=1 + ) + ), + dataPool=cos.DataPool( + failureDomain='osd', + replicated=cos.Replicated( + size=1 + ) + ), + gateway=cos.Gateway( + port=80, + instances=instances + ) + ) + ) + return rook_os.to_json() diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_examples.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_examples.py new file mode 100644 index 000000000..5367844ec --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_examples.py @@ -0,0 +1,52 @@ +from os.path import expanduser, dirname, realpath + +import yaml +import pytest + +import rook_client +from rook_client.cassandra.cluster import Cluster as CassandraCluster +from rook_client.ceph.cephcluster import CephCluster +from rook_client.ceph.cephfilesystem import CephFilesystem +from rook_client.ceph.cephnfs import CephNFS +from rook_client.ceph.cephobjectstore import CephObjectStore +from rook_client.ceph.cephblockpool import CephBlockPool + + +def _load_example(crd_base, what): + with open(expanduser('{crd_base}/{what}').format(crd_base=crd_base, what=what)) as f: + return f.read() + + +@pytest.mark.parametrize( + "strict,cls,filename", + [ + (True, CephCluster, "ceph/cluster-external.yaml"), + (True, CephCluster, "ceph/cluster-on-pvc.yaml"), + (True, CephCluster, "ceph/cluster.yaml"), + (True, CephFilesystem, "ceph/filesystem-ec.yaml"), + (True, CephFilesystem, "ceph/filesystem-test.yaml"), + (True, CephFilesystem, "ceph/filesystem.yaml"), + (True, CephObjectStore, "ceph/object-ec.yaml"), + (True, CephObjectStore, "ceph/object-openshift.yaml"), + (True, CephObjectStore, "ceph/object-test.yaml"), + (True, CephObjectStore, "ceph/object.yaml"), + (True, CephNFS, "ceph/nfs.yaml"), + (True, CephBlockPool, "ceph/pool.yaml"), + (True, CephBlockPool, "ceph/pool-ec.yaml"), + (True, CephBlockPool, "ceph/pool-test.yaml"), + + # schema invalid: + # (False, CassandraCluster, "cassandra/cluster.yaml"), + ], +) +def test_exact_match(strict, cls, filename, crd_base): + crds = yaml.safe_load_all(_load_example(crd_base, filename)) + rook_client.STRICT = strict + [crd] = [e for e in crds if e.get('kind', '') == cls.__name__] + + c = cls.from_json(crd) + assert crd == c.to_json() + + + + diff --git a/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_properties.py b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_properties.py new file mode 100644 index 000000000..0d580e43f --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/test_properties.py @@ -0,0 +1,13 @@ +from copy import deepcopy + +import pytest + +from rook_client.ceph import cephcluster as cc + + +def test_omit(): + cv = cc.CephVersion() + with pytest.raises(AttributeError): + cv.allowUnsupported + + assert not hasattr(cv, 'allowUnsupported') diff --git a/src/pybind/mgr/rook/rook-client-python/setup.py b/src/pybind/mgr/rook/rook-client-python/setup.py new file mode 100644 index 000000000..86601fd6a --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/setup.py @@ -0,0 +1,20 @@ +from setuptools import setup, find_packages + +with open("README.md", "r") as fh: + long_description = fh.read() + +setup( + name='rook-client', + version='1.0.0', + packages=find_packages(), + package_data = { + 'rook_client': ['py.typed'], + }, + url='', + license='Apache License v2', + author='Sebastian Wagner', + author_email='swagner@suse.com', + description='Client model classes for the CRDs exposed by Rook', + long_description=long_description, + long_description_content_type="text/markdown", +) diff --git a/src/pybind/mgr/rook/rook-client-python/tox.ini b/src/pybind/mgr/rook/rook-client-python/tox.ini new file mode 100644 index 000000000..b619fabf1 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/tox.ini @@ -0,0 +1,24 @@ +[tox] +envlist = py2,py36,py37,py38,mypy +skipsdist = true + + +[testenv] +deps = -rrequirements.txt +commands = pytest {posargs} + + +[testenv:mypy] +basepython = python3 +deps = + -rrequirements.txt + mypy + types-PyYAML +commands = + mkcodes --github --output rook_client/tests/test_\{name\}.py README.md + mypy --config-file=mypy.ini \ + rook_client \ + conftest.py \ + generate_model_classes.py \ + setup.py + diff --git a/src/pybind/mgr/rook/rook_client/__init__.py b/src/pybind/mgr/rook/rook_client/__init__.py new file mode 100644 index 000000000..3fa2272dd --- /dev/null +++ b/src/pybind/mgr/rook/rook_client/__init__.py @@ -0,0 +1 @@ +from ._helper import STRICT \ No newline at end of file diff --git a/src/pybind/mgr/rook/rook_client/_helper.py b/src/pybind/mgr/rook/rook_client/_helper.py new file mode 100644 index 000000000..382d04c27 --- /dev/null +++ b/src/pybind/mgr/rook/rook_client/_helper.py @@ -0,0 +1,128 @@ +import logging +import sys +try: + from typing import List, Dict, Any, Optional +except ImportError: + pass + +logger = logging.getLogger(__name__) + +# Tricking mypy to think `_omit`'s type is NoneType +# To make us not add things like `Union[Optional[str], OmitType]` +NoneType = type(None) +_omit = None # type: NoneType +_omit = object() # type: ignore + + +# Don't add any additionalProperties to objects. Useful for completeness testing +STRICT = False + +def _str_to_class(cls, typ_str): + if isinstance(typ_str, str): + return getattr(sys.modules[cls.__module__], typ_str) + return typ_str + + +def _property_from_json(cls, data, breadcrumb, name, py_name, typ_str, required, nullable): + if not required and name not in data: + return _omit + try: + obj = data[name] + except KeyError as e: + raise ValueError('KeyError in {}: {}'.format(breadcrumb, e)) + if nullable and obj is None: + return obj + typ = _str_to_class(cls, typ_str) + if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList): + return typ.from_json(obj, breadcrumb + '.' + name) + return obj + + +class CrdObject(object): + _properties = [] # type: List + + def __init__(self, **kwargs): + for prop in self._properties: + setattr(self, prop[1], kwargs.pop(prop[1])) + if kwargs: + raise TypeError( + '{} got unexpected arguments {}'.format(self.__class__.__name__, kwargs.keys())) + self._additionalProperties = {} # type: Dict[str, Any] + + def _property_impl(self, name): + obj = getattr(self, '_' + name) + if obj is _omit: + raise AttributeError(name + ' not found') + return obj + + def _property_to_json(self, name, py_name, typ_str, required, nullable): + obj = getattr(self, '_' + py_name) + typ = _str_to_class(self.__class__, typ_str) + if issubclass(typ, CrdObject) or issubclass(typ, CrdObjectList): + if nullable and obj is None: + return obj + if not required and obj is _omit: + return obj + return obj.to_json() + else: + return obj + + def to_json(self): + # type: () -> Dict[str, Any] + res = {p[0]: self._property_to_json(*p) for p in self._properties} + res.update(self._additionalProperties) + return {k: v for k, v in res.items() if v is not _omit} + + @classmethod + def from_json(cls, data, breadcrumb=''): + try: + sanitized = { + p[1]: _property_from_json(cls, data, breadcrumb, *p) for p in cls._properties + } + extra = {k:v for k,v in data.items() if k not in sanitized} + ret = cls(**sanitized) + ret._additionalProperties = {} if STRICT else extra + return ret + except (TypeError, AttributeError, KeyError): + logger.exception(breadcrumb) + raise + + +class CrdClass(CrdObject): + @classmethod + def from_json(cls, data, breadcrumb=''): + kind = data['kind'] + if kind != cls.__name__: + raise ValueError("kind mismatch: {} != {}".format(kind, cls.__name__)) + return super(CrdClass, cls).from_json(data, breadcrumb) + + def to_json(self): + ret = super(CrdClass, self).to_json() + ret['kind'] = self.__class__.__name__ + return ret + + +class CrdObjectList(list): + # Py3: Replace `Any` with `TypeVar('T_CrdObject', bound='CrdObject')` + _items_type = None # type: Optional[Any] + + def to_json(self): + # type: () -> List + if self._items_type is None: + return self + if issubclass(self._items_type, CrdObject) or issubclass(self._items_type, CrdObjectList): + return [e.to_json() for e in self] + return list(self) + + + @classmethod + def from_json(cls, data, breadcrumb=''): + if cls._items_type is None: + return cls(data) + if issubclass(cls._items_type, CrdObject) or issubclass(cls._items_type, CrdObjectList): + return cls(cls._items_type.from_json(e, breadcrumb + '[{}]'.format(i)) for i, e in enumerate(data)) + return cls(data) + + def __repr__(self): + return '{}({})'.format(self.__class__.__name__, repr(list(self))) + diff --git a/src/pybind/mgr/rook/rook_cluster.py b/src/pybind/mgr/rook/rook_cluster.py new file mode 100644 index 000000000..5c7c9fc04 --- /dev/null +++ b/src/pybind/mgr/rook/rook_cluster.py @@ -0,0 +1,1591 @@ +""" +This module wrap's Rook + Kubernetes APIs to expose the calls +needed to implement an orchestrator module. While the orchestrator +module exposes an async API, this module simply exposes blocking API +call methods. + +This module is runnable outside of ceph-mgr, useful for testing. +""" +import datetime +import threading +import logging +from contextlib import contextmanager +from time import sleep +import re +from orchestrator import OrchResult + +import jsonpatch +from urllib.parse import urljoin +import json + +# Optional kubernetes imports to enable MgrModule.can_run +# to behave cleanly. +from urllib3.exceptions import ProtocolError + +from ceph.deployment.inventory import Device +from ceph.deployment.drive_group import DriveGroupSpec +from ceph.deployment.service_spec import ServiceSpec, NFSServiceSpec, RGWSpec, PlacementSpec, HostPlacementSpec +from ceph.utils import datetime_now +from ceph.deployment.drive_selection.matchers import SizeMatcher +from nfs.cluster import create_ganesha_pool +from nfs.module import Module +from nfs.export import NFSRados +from mgr_module import NFS_POOL_NAME +from mgr_util import merge_dicts + +from typing import Optional, Tuple, TypeVar, List, Callable, Any, cast, Generic, \ + Iterable, Dict, Iterator, Type + +try: + from kubernetes import client, watch + from kubernetes.client.rest import ApiException +except ImportError: + class ApiException(Exception): # type: ignore + status = 0 + +from .rook_client.ceph import cephfilesystem as cfs +from .rook_client.ceph import cephnfs as cnfs +from .rook_client.ceph import cephobjectstore as cos +from .rook_client.ceph import cephcluster as ccl +from .rook_client.ceph import cephrbdmirror as crbdm +from .rook_client._helper import CrdClass + +import orchestrator + +try: + from rook.module import RookEnv, RookOrchestrator +except ImportError: + pass # just used for type checking. + + +T = TypeVar('T') +FuncT = TypeVar('FuncT', bound=Callable) + +CrdClassT = TypeVar('CrdClassT', bound=CrdClass) + + +log = logging.getLogger(__name__) + + +def __urllib3_supports_read_chunked() -> bool: + # There is a bug in CentOS 7 as it ships a urllib3 which is lower + # than required by kubernetes-client + try: + from urllib3.response import HTTPResponse + return hasattr(HTTPResponse, 'read_chunked') + except ImportError: + return False + + +_urllib3_supports_read_chunked = __urllib3_supports_read_chunked() + +class ApplyException(orchestrator.OrchestratorError): + """ + For failures to update the Rook CRDs, usually indicating + some kind of interference between our attempted update + and other conflicting activity. + """ + + +def threaded(f: Callable[..., None]) -> Callable[..., threading.Thread]: + def wrapper(*args: Any, **kwargs: Any) -> threading.Thread: + t = threading.Thread(target=f, args=args, kwargs=kwargs) + t.start() + return t + + return cast(Callable[..., threading.Thread], wrapper) + + +class DefaultFetcher(): + def __init__(self, storage_class_name: str, coreV1_api: 'client.CoreV1Api', rook_env: 'RookEnv'): + self.storage_class_name = storage_class_name + self.coreV1_api = coreV1_api + self.rook_env = rook_env + self.pvs_in_sc: List[client.V1PersistentVolumeList] = [] + + def fetch(self) -> None: + self.inventory: KubernetesResource[client.V1PersistentVolumeList] = KubernetesResource(self.coreV1_api.list_persistent_volume) + self.pvs_in_sc = [i for i in self.inventory.items if i.spec.storage_class_name == self.storage_class_name] + + def convert_size(self, size_str: str) -> int: + units = ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "", "K", "M", "G", "T", "P", "E") + coeff_and_unit = re.search('(\d+)(\D+)', size_str) + assert coeff_and_unit is not None + coeff = int(coeff_and_unit[1]) + unit = coeff_and_unit[2] + try: + factor = units.index(unit) % 7 + except ValueError: + log.error("PV size format invalid") + raise + size = coeff * (2 ** (10 * factor)) + return size + + def devices(self) -> Dict[str, List[Device]]: + nodename_to_devices: Dict[str, List[Device]] = {} + for i in self.pvs_in_sc: + node, device = self.device(i) + if node not in nodename_to_devices: + nodename_to_devices[node] = [] + nodename_to_devices[node].append(device) + return nodename_to_devices + + def device(self, i: 'client.V1PersistentVolume') -> Tuple[str, Device]: + node = 'N/A' + if i.spec.node_affinity: + terms = i.spec.node_affinity.required.node_selector_terms + if len(terms) == 1 and len(terms[0].match_expressions) == 1 and terms[0].match_expressions[0].key == 'kubernetes.io/hostname' and len(terms[0].match_expressions[0].values) == 1: + node = terms[0].match_expressions[0].values[0] + size = self.convert_size(i.spec.capacity['storage']) + path = i.spec.host_path.path if i.spec.host_path else i.spec.local.path if i.spec.local else ('/dev/' + i.metadata.annotations['storage.openshift.com/device-name']) if i.metadata.annotations and 'storage.openshift.com/device-name' in i.metadata.annotations else '' + state = i.spec.volume_mode == 'Block' and i.status.phase == 'Available' + pv_name = i.metadata.name + device = Device( + path = path, + sys_api = dict( + size = size, + node = node, + pv_name = pv_name + ), + available = state, + ) + return (node, device) + + +class LSOFetcher(DefaultFetcher): + def __init__(self, storage_class: 'str', coreV1_api: 'client.CoreV1Api', rook_env: 'RookEnv', customObjects_api: 'client.CustomObjectsApi', nodenames: 'Optional[List[str]]' = None): + super().__init__(storage_class, coreV1_api, rook_env) + self.customObjects_api = customObjects_api + self.nodenames = nodenames + + def fetch(self) -> None: + super().fetch() + self.discovery: KubernetesCustomResource = KubernetesCustomResource(self.customObjects_api.list_cluster_custom_object, + group="local.storage.openshift.io", + version="v1alpha1", + plural="localvolumediscoveryresults") + + def predicate(self, item: 'client.V1ConfigMapList') -> bool: + if self.nodenames is not None: + return item['spec']['nodeName'] in self.nodenames + else: + return True + + def devices(self) -> Dict[str, List[Device]]: + try: + lso_discovery_results = [i for i in self.discovery.items if self.predicate(i)] + except ApiException as dummy_e: + log.error("Failed to fetch device metadata") + raise + self.lso_devices = {} + for i in lso_discovery_results: + drives = i['status']['discoveredDevices'] + for drive in drives: + self.lso_devices[drive['deviceID'].split('/')[-1]] = drive + nodename_to_devices: Dict[str, List[Device]] = {} + for i in self.pvs_in_sc: + node, device = (None, None) + if (not i.metadata.annotations) or ('storage.openshift.com/device-id' not in i.metadata.annotations) or (i.metadata.annotations['storage.openshift.com/device-id'] not in self.lso_devices): + node, device = super().device(i) + else: + node, device = self.device(i) + if node not in nodename_to_devices: + nodename_to_devices[node] = [] + nodename_to_devices[node].append(device) + return nodename_to_devices + + def device(self, i: Any) -> Tuple[str, Device]: + node = i.metadata.labels['kubernetes.io/hostname'] + device_discovery = self.lso_devices[i.metadata.annotations['storage.openshift.com/device-id']] + pv_name = i.metadata.name + vendor: str = device_discovery['model'].split()[0] if len(device_discovery['model'].split()) >= 1 else '' + model: str = ' '.join(device_discovery['model'].split()[1:]) if len(device_discovery['model'].split()) > 1 else '' + device = Device( + path = device_discovery['path'], + sys_api = dict( + size = device_discovery['size'], + rotational = '1' if device_discovery['property']=='Rotational' else '0', + node = node, + pv_name = pv_name, + model = model, + vendor = vendor + ), + available = device_discovery['status']['state']=='Available', + device_id = device_discovery['deviceID'].split('/')[-1], + lsm_data = dict( + serialNum = device_discovery['serial'] + ) + ) + return (node, device) + + +class PDFetcher(DefaultFetcher): + """ Physical Devices Fetcher""" + def __init__(self, coreV1_api: 'client.CoreV1Api', rook_env: 'RookEnv'): + super().__init__('', coreV1_api, rook_env) + + def fetch(self) -> None: + """ Collect the devices information from k8s configmaps""" + self.dev_cms: KubernetesResource = KubernetesResource(self.coreV1_api.list_namespaced_config_map, + namespace=self.rook_env.operator_namespace, + label_selector='app=rook-discover') + + def devices(self) -> Dict[str, List[Device]]: + """ Return the list of devices found""" + node_devices: Dict[str, List[Device]] = {} + for i in self.dev_cms.items: + devices_list: List[Device] = [] + for d in json.loads(i.data['devices']): + devices_list.append(self.device(d)[1]) + node_devices[i.metadata.labels['rook.io/node']] = devices_list + + return node_devices + + def device(self, devData: Dict[str,str]) -> Tuple[str, Device]: + """ Build an orchestrator device """ + if 'cephVolumeData' in devData and devData['cephVolumeData']: + return "", Device.from_json(json.loads(devData['cephVolumeData'])) + else: + return "", Device( + path='/dev/' + devData['name'], + sys_api=dict( + rotational='1' if devData['rotational'] else '0', + size=devData['size'] + ), + available=False, + rejected_reasons=['device data coming from ceph-volume not provided'], + ) + + +class KubernetesResource(Generic[T]): + def __init__(self, api_func: Callable, **kwargs: Any) -> None: + """ + Generic kubernetes Resource parent class + + The api fetch and watch methods should be common across resource types, + + Exceptions in the runner thread are propagated to the caller. + + :param api_func: kubernetes client api function that is passed to the watcher + :param filter_func: signature: ``(Item) -> bool``. + """ + self.kwargs = kwargs + self.api_func = api_func + + # ``_items`` is accessed by different threads. I assume assignment is atomic. + self._items: Dict[str, T] = dict() + self.thread = None # type: Optional[threading.Thread] + self.exception: Optional[Exception] = None + if not _urllib3_supports_read_chunked: + logging.info('urllib3 is too old. Fallback to full fetches') + + def _fetch(self) -> str: + """ Execute the requested api method as a one-off fetch""" + response = self.api_func(**self.kwargs) + metadata = response.metadata + self._items = {item.metadata.name: item for item in response.items} + log.info('Full fetch of {}. result: {}'.format(self.api_func, len(self._items))) + return metadata.resource_version + + @property + def items(self) -> Iterable[T]: + """ + Returns the items of the request. + Creates the watcher as a side effect. + :return: + """ + if self.exception: + e = self.exception + self.exception = None + raise e # Propagate the exception to the user. + if not self.thread or not self.thread.is_alive(): + resource_version = self._fetch() + if _urllib3_supports_read_chunked: + # Start a thread which will use the kubernetes watch client against a resource + log.debug("Attaching resource watcher for k8s {}".format(self.api_func)) + self.thread = self._watch(resource_version) + + return self._items.values() + + def get_item_name(self, item: Any) -> Any: + try: + return item.metadata.name + except AttributeError: + raise AttributeError( + "{} doesn't contain a metadata.name. Unable to track changes".format( + self.api_func)) + @threaded + def _watch(self, res_ver: Optional[str]) -> None: + """ worker thread that runs the kubernetes watch """ + + self.exception = None + + w = watch.Watch() + + try: + # execute generator to continually watch resource for changes + for event in w.stream(self.api_func, resource_version=res_ver, watch=True, + **self.kwargs): + self.health = '' + item = event['object'] + name = self.get_item_name(item) + + log.info('{} event: {}'.format(event['type'], name)) + + if event['type'] in ('ADDED', 'MODIFIED'): + self._items = merge_dicts(self._items, {name: item}) + elif event['type'] == 'DELETED': + self._items = {k:v for k,v in self._items.items() if k != name} + elif event['type'] == 'BOOKMARK': + pass + elif event['type'] == 'ERROR': + raise ApiException(str(event)) + else: + raise KeyError('Unknown watch event {}'.format(event['type'])) + except ProtocolError as e: + if 'Connection broken' in str(e): + log.info('Connection reset.') + return + raise + except ApiException as e: + log.exception('K8s API failed. {}'.format(self.api_func)) + self.exception = e + raise + except Exception as e: + log.exception("Watcher failed. ({})".format(self.api_func)) + self.exception = e + raise + +class KubernetesCustomResource(KubernetesResource): + def _fetch(self) -> str: + response = self.api_func(**self.kwargs) + metadata = response['metadata'] + self._items = {item['metadata']['name']: item for item in response['items']} + log.info('Full fetch of {}. result: {}'.format(self.api_func, len(self._items))) + return metadata['resourceVersion'] + + def get_item_name(self, item: Any) -> Any: + try: + return item['metadata']['name'] + except AttributeError: + raise AttributeError( + "{} doesn't contain a metadata.name. Unable to track changes".format( + self.api_func)) + +class DefaultCreator(): + def __init__(self, inventory: 'Dict[str, List[Device]]', coreV1_api: 'client.CoreV1Api', storage_class_name: 'str'): + self.coreV1_api = coreV1_api + self.storage_class_name = storage_class_name + self.inventory = inventory + + def device_to_device_set(self, drive_group: DriveGroupSpec, d: Device) -> ccl.StorageClassDeviceSetsItem: + device_set = ccl.StorageClassDeviceSetsItem( + name=d.sys_api['pv_name'], + volumeClaimTemplates= ccl.VolumeClaimTemplatesList(), + count=1, + encrypted=drive_group.encrypted, + portable=False + ) + device_set.volumeClaimTemplates.append( + ccl.VolumeClaimTemplatesItem( + metadata=ccl.Metadata( + name="data" + ), + spec=ccl.Spec( + storageClassName=self.storage_class_name, + volumeMode="Block", + accessModes=ccl.CrdObjectList(["ReadWriteOnce"]), + resources={ + "requests":{ + "storage": 1 + } + }, + volumeName=d.sys_api['pv_name'] + ) + ) + ) + return device_set + + def filter_devices(self, rook_pods: KubernetesResource, drive_group: DriveGroupSpec, matching_hosts: List[str]) -> List[Device]: + device_list = [] + assert drive_group.data_devices is not None + sizematcher: Optional[SizeMatcher] = None + if drive_group.data_devices.size: + sizematcher = SizeMatcher('size', drive_group.data_devices.size) + limit = getattr(drive_group.data_devices, 'limit', None) + count = 0 + all = getattr(drive_group.data_devices, 'all', None) + paths = [device.path for device in drive_group.data_devices.paths] + osd_list = [] + for pod in rook_pods.items: + if ( + hasattr(pod, 'metadata') + and hasattr(pod.metadata, 'labels') + and 'osd' in pod.metadata.labels + and 'ceph.rook.io/DeviceSet' in pod.metadata.labels + ): + osd_list.append(pod.metadata.labels['ceph.rook.io/DeviceSet']) + for _, node in self.inventory.items(): + for device in node: + if device.sys_api['pv_name'] in osd_list: + count += 1 + for _, node in self.inventory.items(): + for device in node: + if not limit or (count < limit): + if device.available: + if ( + all + or ( + device.sys_api['node'] in matching_hosts + and ((sizematcher != None) or sizematcher.compare(device)) + and ( + not drive_group.data_devices.paths + or (device.path in paths) + ) + ) + ): + device_list.append(device) + count += 1 + + return device_list + + def add_osds(self, rook_pods: KubernetesResource, drive_group: DriveGroupSpec, matching_hosts: List[str]) -> Any: + to_create = self.filter_devices(rook_pods, drive_group,matching_hosts) + assert drive_group.data_devices is not None + def _add_osds(current_cluster, new_cluster): + # type: (ccl.CephCluster, ccl.CephCluster) -> ccl.CephCluster + if not hasattr(new_cluster.spec, 'storage') or not new_cluster.spec.storage: + new_cluster.spec.storage = ccl.Storage() + + if not hasattr(new_cluster.spec.storage, 'storageClassDeviceSets') or not new_cluster.spec.storage.storageClassDeviceSets: + new_cluster.spec.storage.storageClassDeviceSets = ccl.StorageClassDeviceSetsList() + + existing_scds = [ + scds.name for scds in new_cluster.spec.storage.storageClassDeviceSets + ] + for device in to_create: + new_scds = self.device_to_device_set(drive_group, device) + if new_scds.name not in existing_scds: + new_cluster.spec.storage.storageClassDeviceSets.append(new_scds) + return new_cluster + return _add_osds + +class LSOCreator(DefaultCreator): + def filter_devices(self, rook_pods: KubernetesResource, drive_group: DriveGroupSpec, matching_hosts: List[str]) -> List[Device]: + device_list = [] + assert drive_group.data_devices is not None + sizematcher = None + if drive_group.data_devices.size: + sizematcher = SizeMatcher('size', drive_group.data_devices.size) + limit = getattr(drive_group.data_devices, 'limit', None) + all = getattr(drive_group.data_devices, 'all', None) + paths = [device.path for device in drive_group.data_devices.paths] + vendor = getattr(drive_group.data_devices, 'vendor', None) + model = getattr(drive_group.data_devices, 'model', None) + count = 0 + osd_list = [] + for pod in rook_pods.items: + if ( + hasattr(pod, 'metadata') + and hasattr(pod.metadata, 'labels') + and 'osd' in pod.metadata.labels + and 'ceph.rook.io/DeviceSet' in pod.metadata.labels + ): + osd_list.append(pod.metadata.labels['ceph.rook.io/DeviceSet']) + for _, node in self.inventory.items(): + for device in node: + if device.sys_api['pv_name'] in osd_list: + count += 1 + for _, node in self.inventory.items(): + for device in node: + if not limit or (count < limit): + if device.available: + if ( + all + or ( + device.sys_api['node'] in matching_hosts + and ((sizematcher != None) or sizematcher.compare(device)) + and ( + not drive_group.data_devices.paths + or device.path in paths + ) + and ( + not vendor + or device.sys_api['vendor'] == vendor + ) + and ( + not model + or device.sys_api['model'].startsWith(model) + ) + ) + ): + device_list.append(device) + count += 1 + return device_list + +class DefaultRemover(): + def __init__( + self, + coreV1_api: 'client.CoreV1Api', + batchV1_api: 'client.BatchV1Api', + appsV1_api: 'client.AppsV1Api', + osd_ids: List[str], + replace_flag: bool, + force_flag: bool, + mon_command: Callable, + patch: Callable, + rook_env: 'RookEnv', + inventory: Dict[str, List[Device]] + ): + self.batchV1_api = batchV1_api + self.appsV1_api = appsV1_api + self.coreV1_api = coreV1_api + + self.osd_ids = osd_ids + self.replace_flag = replace_flag + self.force_flag = force_flag + + self.mon_command = mon_command + + self.patch = patch + self.rook_env = rook_env + + self.inventory = inventory + self.osd_pods: KubernetesResource = KubernetesResource(self.coreV1_api.list_namespaced_pod, + namespace=self.rook_env.namespace, + label_selector='app=rook-ceph-osd') + self.jobs: KubernetesResource = KubernetesResource(self.batchV1_api.list_namespaced_job, + namespace=self.rook_env.namespace, + label_selector='app=rook-ceph-osd-prepare') + self.pvcs: KubernetesResource = KubernetesResource(self.coreV1_api.list_namespaced_persistent_volume_claim, + namespace=self.rook_env.namespace) + + + def remove_device_sets(self) -> str: + self.to_remove: Dict[str, int] = {} + self.pvc_to_remove: List[str] = [] + for pod in self.osd_pods.items: + if ( + hasattr(pod, 'metadata') + and hasattr(pod.metadata, 'labels') + and 'osd' in pod.metadata.labels + and pod.metadata.labels['osd'] in self.osd_ids + ): + if pod.metadata.labels['ceph.rook.io/DeviceSet'] in self.to_remove: + self.to_remove[pod.metadata.labels['ceph.rook.io/DeviceSet']] = self.to_remove[pod.metadata.labels['ceph.rook.io/DeviceSet']] + 1 + else: + self.to_remove[pod.metadata.labels['ceph.rook.io/DeviceSet']] = 1 + self.pvc_to_remove.append(pod.metadata.labels['ceph.rook.io/pvc']) + def _remove_osds(current_cluster, new_cluster): + # type: (ccl.CephCluster, ccl.CephCluster) -> ccl.CephCluster + assert new_cluster.spec.storage is not None and new_cluster.spec.storage.storageClassDeviceSets is not None + for _set in new_cluster.spec.storage.storageClassDeviceSets: + if _set.name in self.to_remove: + if _set.count == self.to_remove[_set.name]: + new_cluster.spec.storage.storageClassDeviceSets.remove(_set) + else: + _set.count = _set.count - self.to_remove[_set.name] + return new_cluster + return self.patch(ccl.CephCluster, 'cephclusters', self.rook_env.cluster_name, _remove_osds) + + def check_force(self) -> None: + if not self.force_flag: + safe_args = {'prefix': 'osd safe-to-destroy', + 'ids': [str(x) for x in self.osd_ids]} + ret, out, err = self.mon_command(safe_args) + if ret != 0: + raise RuntimeError(err) + + def set_osds_down(self) -> None: + down_flag_args = { + 'prefix': 'osd down', + 'ids': [str(x) for x in self.osd_ids] + } + ret, out, err = self.mon_command(down_flag_args) + if ret != 0: + raise RuntimeError(err) + + def scale_deployments(self) -> None: + for osd_id in self.osd_ids: + self.appsV1_api.patch_namespaced_deployment_scale(namespace=self.rook_env.namespace, + name='rook-ceph-osd-{}'.format(osd_id), + body=client.V1Scale(spec=client.V1ScaleSpec(replicas=0))) + + def set_osds_out(self) -> None: + out_flag_args = { + 'prefix': 'osd out', + 'ids': [str(x) for x in self.osd_ids] + } + ret, out, err = self.mon_command(out_flag_args) + if ret != 0: + raise RuntimeError(err) + + def delete_deployments(self) -> None: + for osd_id in self.osd_ids: + self.appsV1_api.delete_namespaced_deployment(namespace=self.rook_env.namespace, + name='rook-ceph-osd-{}'.format(osd_id), + propagation_policy='Foreground') + + def clean_up_prepare_jobs_and_pvc(self) -> None: + for job in self.jobs.items: + if job.metadata.labels['ceph.rook.io/pvc'] in self.pvc_to_remove: + self.batchV1_api.delete_namespaced_job(name=job.metadata.name, namespace=self.rook_env.namespace, + propagation_policy='Foreground') + self.coreV1_api.delete_namespaced_persistent_volume_claim(name=job.metadata.labels['ceph.rook.io/pvc'], + namespace=self.rook_env.namespace, + propagation_policy='Foreground') + + def purge_osds(self) -> None: + for id in self.osd_ids: + purge_args = { + 'prefix': 'osd purge-actual', + 'id': int(id), + 'yes_i_really_mean_it': True + } + ret, out, err = self.mon_command(purge_args) + if ret != 0: + raise RuntimeError(err) + + def destroy_osds(self) -> None: + for id in self.osd_ids: + destroy_args = { + 'prefix': 'osd destroy-actual', + 'id': int(id), + 'yes_i_really_mean_it': True + } + ret, out, err = self.mon_command(destroy_args) + if ret != 0: + raise RuntimeError(err) + + def remove(self) -> str: + try: + self.check_force() + except Exception as e: + log.exception("Error checking if OSDs are safe to destroy") + return f"OSDs not safe to destroy or unable to check if they are safe to destroy: {e}" + try: + remove_result = self.remove_device_sets() + except Exception as e: + log.exception("Error patching ceph cluster CRD") + return f"Not possible to modify Ceph cluster CRD: {e}" + try: + self.scale_deployments() + self.delete_deployments() + self.clean_up_prepare_jobs_and_pvc() + except Exception as e: + log.exception("Ceph cluster CRD patched, but error cleaning environment") + return f"Error cleaning environment after removing OSDs from Ceph cluster CRD: {e}" + try: + self.set_osds_down() + self.set_osds_out() + if self.replace_flag: + self.destroy_osds() + else: + self.purge_osds() + except Exception as e: + log.exception("OSDs removed from environment, but not able to remove OSDs from Ceph cluster") + return f"Error removing OSDs from Ceph cluster: {e}" + + return remove_result + + + +class RookCluster(object): + # import of client.CoreV1Api must be optional at import time. + # Instead allow mgr/rook to be imported anyway. + def __init__( + self, + coreV1_api: 'client.CoreV1Api', + batchV1_api: 'client.BatchV1Api', + customObjects_api: 'client.CustomObjectsApi', + storageV1_api: 'client.StorageV1Api', + appsV1_api: 'client.AppsV1Api', + rook_env: 'RookEnv', + storage_class_name: 'str' + ): + self.rook_env = rook_env # type: RookEnv + self.coreV1_api = coreV1_api # client.CoreV1Api + self.batchV1_api = batchV1_api + self.customObjects_api = customObjects_api + self.storageV1_api = storageV1_api # client.StorageV1Api + self.appsV1_api = appsV1_api # client.AppsV1Api + self.storage_class_name = storage_class_name # type: str + + # TODO: replace direct k8s calls with Rook API calls + self.available_storage_classes : KubernetesResource = KubernetesResource(self.storageV1_api.list_storage_class) + self.configured_storage_classes = self.list_storage_classes() + + self.rook_pods: KubernetesResource[client.V1Pod] = KubernetesResource(self.coreV1_api.list_namespaced_pod, + namespace=self.rook_env.namespace, + label_selector="rook_cluster={0}".format( + self.rook_env.namespace)) + self.nodes: KubernetesResource[client.V1Node] = KubernetesResource(self.coreV1_api.list_node) + + def rook_url(self, path: str) -> str: + prefix = "/apis/ceph.rook.io/%s/namespaces/%s/" % ( + self.rook_env.crd_version, self.rook_env.namespace) + return urljoin(prefix, path) + + def rook_api_call(self, verb: str, path: str, **kwargs: Any) -> Any: + full_path = self.rook_url(path) + log.debug("[%s] %s" % (verb, full_path)) + + return self.coreV1_api.api_client.call_api( + full_path, + verb, + auth_settings=['BearerToken'], + response_type="object", + _return_http_data_only=True, + _preload_content=True, + **kwargs) + + def rook_api_get(self, path: str, **kwargs: Any) -> Any: + return self.rook_api_call("GET", path, **kwargs) + + def rook_api_delete(self, path: str) -> Any: + return self.rook_api_call("DELETE", path) + + def rook_api_patch(self, path: str, **kwargs: Any) -> Any: + return self.rook_api_call("PATCH", path, + header_params={"Content-Type": "application/json-patch+json"}, + **kwargs) + + def rook_api_post(self, path: str, **kwargs: Any) -> Any: + return self.rook_api_call("POST", path, **kwargs) + + def list_storage_classes(self) -> List[str]: + try: + crd = self.customObjects_api.get_namespaced_custom_object( + group="ceph.rook.io", + version="v1", + namespace=self.rook_env.namespace, + plural="cephclusters", + name=self.rook_env.cluster_name) + + sc_devicesets = crd['spec']['storage']['storageClassDeviceSets'] + sc_names = [vct['spec']['storageClassName'] for sc in sc_devicesets for vct in sc['volumeClaimTemplates']] + log.info(f"the cluster has the following configured sc: {sc_names}") + return sc_names + except Exception as e: + log.error(f"unable to list storage classes: {e}") + return [] + + # TODO: remove all the calls to code that uses rook_cluster.storage_class_name + def get_storage_class(self) -> 'client.V1StorageClass': + matching_sc = [i for i in self.available_storage_classes.items if self.storage_class_name == i.metadata.name] + if len(matching_sc) == 0: + log.error(f"No storage class exists matching configured Rook orchestrator storage class which currently is <{self.storage_class_name}>. This storage class can be set in ceph config (mgr/rook/storage_class)") + raise Exception('No storage class exists matching name provided in ceph config at mgr/rook/storage_class') + return matching_sc[0] + + def get_discovered_devices(self, nodenames: Optional[List[str]] = None) -> Dict[str, List[Device]]: + discovered_devices: Dict[str, List[Device]] = {} + op_settings = self.coreV1_api.read_namespaced_config_map(name="rook-ceph-operator-config", namespace=self.rook_env.operator_namespace).data + fetcher: Optional[DefaultFetcher] = None + if op_settings.get('ROOK_ENABLE_DISCOVERY_DAEMON', 'false').lower() == 'true': + fetcher = PDFetcher(self.coreV1_api, self.rook_env) + fetcher.fetch() + discovered_devices = fetcher.devices() + else: + active_storage_classes = [sc for sc in self.available_storage_classes.items if sc.metadata.name in self.configured_storage_classes] + for sc in active_storage_classes: + if sc.metadata.labels and ('local.storage.openshift.io/owner-name' in sc.metadata.labels): + fetcher = LSOFetcher(sc.metadata.name, self.coreV1_api, self.customObjects_api, nodenames) + else: + fetcher = DefaultFetcher(sc.metadata.name, self.coreV1_api, self.rook_env) + fetcher.fetch() + discovered_devices.update(fetcher.devices()) + + return discovered_devices + + def get_osds(self) -> List: + osd_pods: KubernetesResource = KubernetesResource(self.coreV1_api.list_namespaced_pod, + namespace=self.rook_env.namespace, + label_selector='app=rook-ceph-osd') + return list(osd_pods.items) + + def get_nfs_conf_url(self, nfs_cluster: str, instance: str) -> Optional[str]: + # + # Fetch cephnfs object for "nfs_cluster" and then return a rados:// + # URL for the instance within that cluster. If the fetch fails, just + # return None. + # + try: + ceph_nfs = self.rook_api_get("cephnfses/{0}".format(nfs_cluster)) + except ApiException as e: + log.info("Unable to fetch cephnfs object: {}".format(e.status)) + return None + + pool = ceph_nfs['spec']['rados']['pool'] + namespace = ceph_nfs['spec']['rados'].get('namespace', None) + + if namespace == None: + url = "rados://{0}/conf-{1}.{2}".format(pool, nfs_cluster, instance) + else: + url = "rados://{0}/{1}/conf-{2}.{3}".format(pool, namespace, nfs_cluster, instance) + return url + + def describe_pods(self, + service_type: Optional[str], + service_id: Optional[str], + nodename: Optional[str]) -> List[Dict[str, Any]]: + """ + Go query the k8s API about deployment, containers related to this + filesystem + + Example Rook Pod labels for a mgr daemon: + Labels: app=rook-ceph-mgr + pod-template-hash=2171958073 + rook_cluster=rook + And MDS containers additionally have `rook_filesystem` label + + Label filter is rook_cluster= + rook_file_system= + """ + def predicate(item): + # type: (client.V1Pod) -> bool + metadata = item.metadata + if service_type is not None: + if metadata.labels['app'] != "rook-ceph-{0}".format(service_type): + return False + + if service_id is not None: + try: + k, v = { + "mds": ("rook_file_system", service_id), + "osd": ("ceph-osd-id", service_id), + "mon": ("mon", service_id), + "mgr": ("mgr", service_id), + "nfs": ("nfs", service_id), + "rgw": ("ceph_rgw", service_id), + }[service_type] + except KeyError: + raise orchestrator.OrchestratorValidationError( + '{} not supported'.format(service_type)) + if metadata.labels[k] != v: + return False + + if nodename is not None: + if item.spec.node_name != nodename: + return False + return True + + refreshed = datetime_now() + pods = [i for i in self.rook_pods.items if predicate(i)] + + pods_summary = [] + prefix = 'sha256:' + + for p in pods: + d = p.to_dict() + + image_name = None + for c in d['spec']['containers']: + # look at the first listed container in the pod... + image_name = c['image'] + break + + ls = d['status'].get('container_statuses') + if not ls: + # ignore pods with no containers + continue + image_id = ls[0]['image_id'] + image_id = image_id.split(prefix)[1] if prefix in image_id else image_id + + s = { + "name": d['metadata']['name'], + "hostname": d['spec']['node_name'], + "labels": d['metadata']['labels'], + 'phase': d['status']['phase'], + 'container_image_name': image_name, + 'container_image_id': image_id, + 'refreshed': refreshed, + # these may get set below... + 'started': None, + 'created': None, + } + + # note: we want UTC + if d['metadata'].get('creation_timestamp', None): + s['created'] = d['metadata']['creation_timestamp'].astimezone( + tz=datetime.timezone.utc) + if d['status'].get('start_time', None): + s['started'] = d['status']['start_time'].astimezone( + tz=datetime.timezone.utc) + + pods_summary.append(s) + + return pods_summary + + def remove_pods(self, names: List[str]) -> List[str]: + pods = [i for i in self.rook_pods.items] + for p in pods: + d = p.to_dict() + daemon_type = d['metadata']['labels']['app'].replace('rook-ceph-','') + daemon_id = d['metadata']['labels']['ceph_daemon_id'] + name = daemon_type + '.' + daemon_id + if name in names: + self.coreV1_api.delete_namespaced_pod( + d['metadata']['name'], + self.rook_env.namespace, + body=client.V1DeleteOptions() + ) + return [f'Removed Pod {n}' for n in names] + + def get_node_names(self) -> List[str]: + return [i.metadata.name for i in self.nodes.items] + + @contextmanager + def ignore_409(self, what: str) -> Iterator[None]: + try: + yield + except ApiException as e: + if e.status == 409: + # Idempotent, succeed. + log.info("{} already exists".format(what)) + else: + raise + + def apply_filesystem(self, spec: ServiceSpec, num_replicas: int, + leaf_type: str) -> str: + # TODO use spec.placement + # TODO warn if spec.extended has entries we don't kow how + # to action. + all_hosts = self.get_hosts() + def _update_fs(new: cfs.CephFilesystem) -> cfs.CephFilesystem: + new.spec.metadataServer.activeCount = spec.placement.count or 1 + new.spec.metadataServer.placement = cfs.Placement( + nodeAffinity=cfs.NodeAffinity( + requiredDuringSchedulingIgnoredDuringExecution=cfs.RequiredDuringSchedulingIgnoredDuringExecution( + nodeSelectorTerms=cfs.NodeSelectorTermsList( + [placement_spec_to_node_selector(spec.placement, all_hosts)] + ) + ) + ) + ) + return new + def _create_fs() -> cfs.CephFilesystem: + fs = cfs.CephFilesystem( + apiVersion=self.rook_env.api_name, + metadata=dict( + name=spec.service_id, + namespace=self.rook_env.namespace, + ), + spec=cfs.Spec( + dataPools=cfs.DataPoolsList( + { + cfs.DataPoolsItem( + failureDomain=leaf_type, + replicated=cfs.Replicated( + size=num_replicas + ) + ) + } + ), + metadataPool=cfs.MetadataPool( + failureDomain=leaf_type, + replicated=cfs.Replicated( + size=num_replicas + ) + ), + metadataServer=cfs.MetadataServer( + activeCount=spec.placement.count or 1, + activeStandby=True, + placement= + cfs.Placement( + nodeAffinity=cfs.NodeAffinity( + requiredDuringSchedulingIgnoredDuringExecution=cfs.RequiredDuringSchedulingIgnoredDuringExecution( + nodeSelectorTerms=cfs.NodeSelectorTermsList( + [placement_spec_to_node_selector(spec.placement, all_hosts)] + ) + ) + ) + ) + ) + ) + ) + return fs + assert spec.service_id is not None + return self._create_or_patch( + cfs.CephFilesystem, 'cephfilesystems', spec.service_id, + _update_fs, _create_fs) + + def get_matching_node(self, host: str) -> Any: + matching_node = None + for node in self.nodes.items: + if node.metadata.labels['kubernetes.io/hostname'] == host: + matching_node = node + return matching_node + + def add_host_label(self, host: str, label: str) -> OrchResult[str]: + matching_node = self.get_matching_node(host) + if matching_node == None: + return OrchResult(None, RuntimeError(f"Cannot add {label} label to {host}: host not found in cluster")) + matching_node.metadata.labels['ceph-label/'+ label] = "" + self.coreV1_api.patch_node(host, matching_node) + return OrchResult(f'Added {label} label to {host}') + + def remove_host_label(self, host: str, label: str) -> OrchResult[str]: + matching_node = self.get_matching_node(host) + if matching_node == None: + return OrchResult(None, RuntimeError(f"Cannot remove {label} label from {host}: host not found in cluster")) + matching_node.metadata.labels.pop('ceph-label/' + label, None) + self.coreV1_api.patch_node(host, matching_node) + return OrchResult(f'Removed {label} label from {host}') + + def apply_objectstore(self, spec: RGWSpec, num_replicas: int, leaf_type: str) -> str: + assert spec.service_id is not None + + name = spec.service_id + + if '.' in spec.service_id: + # rook does not like . in the name. this is could + # there because it is a legacy rgw spec that was named + # like $realm.$zone, except that I doubt there were any + # users of this code. Instead, focus on future users and + # translate . to - (fingers crossed!) instead. + name = spec.service_id.replace('.', '-') + + all_hosts = self.get_hosts() + def _create_zone() -> cos.CephObjectStore: + port = None + secure_port = None + if spec.ssl: + secure_port = spec.get_port() + else: + port = spec.get_port() + object_store = cos.CephObjectStore( + apiVersion=self.rook_env.api_name, + metadata=dict( + name=name, + namespace=self.rook_env.namespace + ), + spec=cos.Spec( + gateway=cos.Gateway( + port=port, + securePort=secure_port, + instances=spec.placement.count or 1, + placement=cos.Placement( + cos.NodeAffinity( + requiredDuringSchedulingIgnoredDuringExecution=cos.RequiredDuringSchedulingIgnoredDuringExecution( + nodeSelectorTerms=cos.NodeSelectorTermsList( + [ + placement_spec_to_node_selector(spec.placement, all_hosts) + ] + ) + ) + ) + ) + ), + dataPool=cos.DataPool( + failureDomain=leaf_type, + replicated=cos.Replicated( + size=num_replicas + ) + ), + metadataPool=cos.MetadataPool( + failureDomain=leaf_type, + replicated=cos.Replicated( + size=num_replicas + ) + ) + ) + ) + if spec.rgw_zone: + object_store.spec.zone=cos.Zone( + name=spec.rgw_zone + ) + return object_store + + + def _update_zone(new: cos.CephObjectStore) -> cos.CephObjectStore: + if new.spec.gateway: + new.spec.gateway.instances = spec.placement.count or 1 + else: + new.spec.gateway=cos.Gateway( + instances=spec.placement.count or 1 + ) + return new + return self._create_or_patch( + cos.CephObjectStore, 'cephobjectstores', name, + _update_zone, _create_zone) + + def apply_nfsgw(self, spec: NFSServiceSpec, mgr: 'RookOrchestrator') -> str: + # TODO use spec.placement + # TODO warn if spec.extended has entries we don't kow how + # to action. + # TODO Number of pods should be based on the list of hosts in the + # PlacementSpec. + assert spec.service_id, "service id in NFS service spec cannot be an empty string or None " # for mypy typing + service_id = spec.service_id + mgr_module = cast(Module, mgr) + count = spec.placement.count or 1 + def _update_nfs(new: cnfs.CephNFS) -> cnfs.CephNFS: + new.spec.server.active = count + return new + + def _create_nfs() -> cnfs.CephNFS: + rook_nfsgw = cnfs.CephNFS( + apiVersion=self.rook_env.api_name, + metadata=dict( + name=spec.service_id, + namespace=self.rook_env.namespace, + ), + spec=cnfs.Spec( + rados=cnfs.Rados( + namespace=service_id, + pool=NFS_POOL_NAME, + ), + server=cnfs.Server( + active=count + ) + ) + ) + + + return rook_nfsgw + + create_ganesha_pool(mgr) + NFSRados(mgr_module.rados, service_id).write_obj('', f'conf-nfs.{spec.service_id}') + return self._create_or_patch(cnfs.CephNFS, 'cephnfses', service_id, + _update_nfs, _create_nfs) + + def rm_service(self, rooktype: str, service_id: str) -> str: + self.customObjects_api.delete_namespaced_custom_object(group="ceph.rook.io", version="v1", + namespace=self.rook_env.namespace, + plural=rooktype, name=service_id) + objpath = "{0}/{1}".format(rooktype, service_id) + return f'Removed {objpath}' + + def get_resource(self, resource_type: str) -> Iterable: + custom_objects: KubernetesCustomResource = KubernetesCustomResource(self.customObjects_api.list_namespaced_custom_object, + group="ceph.rook.io", + version="v1", + namespace=self.rook_env.namespace, + plural=resource_type) + return custom_objects.items + + def can_create_osd(self) -> bool: + current_cluster = self.rook_api_get( + "cephclusters/{0}".format(self.rook_env.cluster_name)) + use_all_nodes = current_cluster['spec'].get('useAllNodes', False) + + # If useAllNodes is set, then Rook will not be paying attention + # to anything we put in 'nodes', so can't do OSD creation. + return not use_all_nodes + + def node_exists(self, node_name: str) -> bool: + return node_name in self.get_node_names() + + def update_mon_count(self, newcount: Optional[int]) -> str: + def _update_mon_count(current, new): + # type: (ccl.CephCluster, ccl.CephCluster) -> ccl.CephCluster + if newcount is None: + raise orchestrator.OrchestratorError('unable to set mon count to None') + if not new.spec.mon: + raise orchestrator.OrchestratorError("mon attribute not specified in new spec") + new.spec.mon.count = newcount + return new + return self._patch(ccl.CephCluster, 'cephclusters', self.rook_env.cluster_name, _update_mon_count) + + def add_osds(self, drive_group, matching_hosts): + # type: (DriveGroupSpec, List[str]) -> str + assert drive_group.objectstore in ("bluestore", "filestore") + assert drive_group.service_id + storage_class = self.get_storage_class() + inventory = self.get_discovered_devices() + creator: Optional[DefaultCreator] = None + if ( + storage_class.metadata.labels + and 'local.storage.openshift.io/owner-name' in storage_class.metadata.labels + ): + creator = LSOCreator(inventory, self.coreV1_api, self.storage_class_name) + else: + creator = DefaultCreator(inventory, self.coreV1_api, self.storage_class_name) + return self._patch( + ccl.CephCluster, + 'cephclusters', + self.rook_env.cluster_name, + creator.add_osds(self.rook_pods, drive_group, matching_hosts) + ) + + def remove_osds(self, osd_ids: List[str], replace: bool, force: bool, mon_command: Callable) -> str: + inventory = self.get_discovered_devices() + self.remover = DefaultRemover( + self.coreV1_api, + self.batchV1_api, + self.appsV1_api, + osd_ids, + replace, + force, + mon_command, + self._patch, + self.rook_env, + inventory + ) + return self.remover.remove() + + def get_hosts(self) -> List[orchestrator.HostSpec]: + ret = [] + for node in self.nodes.items: + spec = orchestrator.HostSpec( + node.metadata.name, + addr='/'.join([addr.address for addr in node.status.addresses]), + labels=[label.split('/')[1] for label in node.metadata.labels if label.startswith('ceph-label')], + ) + ret.append(spec) + return ret + + def create_zap_job(self, host: str, path: str) -> None: + body = client.V1Job( + api_version="batch/v1", + metadata=client.V1ObjectMeta( + name="rook-ceph-device-zap", + namespace=self.rook_env.namespace + ), + spec=client.V1JobSpec( + template=client.V1PodTemplateSpec( + spec=client.V1PodSpec( + containers=[ + client.V1Container( + name="device-zap", + image="rook/ceph:master", + command=["bash"], + args=["-c", f"ceph-volume raw list {path} && dd if=/dev/zero of=\"{path}\" bs=1M count=1 oflag=direct,dsync || ceph-volume lvm zap --destroy {path}"], + env=[ + client.V1EnvVar( + name="ROOK_CEPH_USERNAME", + value_from=client.V1EnvVarSource( + secret_key_ref=client.V1SecretKeySelector( + key="ceph-username", + name="rook-ceph-mon" + ) + ) + ), + client.V1EnvVar( + name="ROOK_CEPH_SECRET", + value_from=client.V1EnvVarSource( + secret_key_ref=client.V1SecretKeySelector( + key="ceph-secret", + name="rook-ceph-mon" + ) + ) + ) + ], + security_context=client.V1SecurityContext( + run_as_user=0, + privileged=True + ), + volume_mounts=[ + client.V1VolumeMount( + mount_path="/etc/ceph", + name="ceph-conf-emptydir" + ), + client.V1VolumeMount( + mount_path="/etc/rook", + name="rook-config" + ), + client.V1VolumeMount( + mount_path="/dev", + name="devices" + ) + ] + ) + ], + volumes=[ + client.V1Volume( + name="ceph-conf-emptydir", + empty_dir=client.V1EmptyDirVolumeSource() + ), + client.V1Volume( + name="rook-config", + empty_dir=client.V1EmptyDirVolumeSource() + ), + client.V1Volume( + name="devices", + host_path=client.V1HostPathVolumeSource( + path="/dev" + ) + ), + ], + node_selector={ + "kubernetes.io/hostname": host + }, + restart_policy="Never" + ) + ) + ) + ) + self.batchV1_api.create_namespaced_job(self.rook_env.namespace, body) + + def rbd_mirror(self, spec: ServiceSpec) -> None: + service_id = spec.service_id or "default-rbd-mirror" + all_hosts = self.get_hosts() + def _create_rbd_mirror() -> crbdm.CephRBDMirror: + return crbdm.CephRBDMirror( + apiVersion=self.rook_env.api_name, + metadata=dict( + name=service_id, + namespace=self.rook_env.namespace, + ), + spec=crbdm.Spec( + count=spec.placement.count or 1, + placement=crbdm.Placement( + nodeAffinity=crbdm.NodeAffinity( + requiredDuringSchedulingIgnoredDuringExecution=crbdm.RequiredDuringSchedulingIgnoredDuringExecution( + nodeSelectorTerms=crbdm.NodeSelectorTermsList( + [ + placement_spec_to_node_selector(spec.placement, all_hosts) + ] + ) + ) + ) + ) + ) + ) + def _update_rbd_mirror(new: crbdm.CephRBDMirror) -> crbdm.CephRBDMirror: + new.spec.count = spec.placement.count or 1 + new.spec.placement = crbdm.Placement( + nodeAffinity=crbdm.NodeAffinity( + requiredDuringSchedulingIgnoredDuringExecution=crbdm.RequiredDuringSchedulingIgnoredDuringExecution( + nodeSelectorTerms=crbdm.NodeSelectorTermsList( + [ + placement_spec_to_node_selector(spec.placement, all_hosts) + ] + ) + ) + ) + ) + return new + self._create_or_patch(crbdm.CephRBDMirror, 'cephrbdmirrors', service_id, _update_rbd_mirror, _create_rbd_mirror) + def _patch(self, crd: Type, crd_name: str, cr_name: str, func: Callable[[CrdClassT, CrdClassT], CrdClassT]) -> str: + current_json = self.rook_api_get( + "{}/{}".format(crd_name, cr_name) + ) + + current = crd.from_json(current_json) + new = crd.from_json(current_json) # no deepcopy. + + new = func(current, new) + + patch = list(jsonpatch.make_patch(current_json, new.to_json())) + + log.info('patch for {}/{}: \n{}'.format(crd_name, cr_name, patch)) + + if len(patch) == 0: + return "No change" + + try: + self.rook_api_patch( + "{}/{}".format(crd_name, cr_name), + body=patch) + except ApiException as e: + log.exception("API exception: {0}".format(e)) + raise ApplyException( + "Failed to update {}/{}: {}".format(crd_name, cr_name, e)) + + return "Success" + + def _create_or_patch(self, + crd: Type, + crd_name: str, + cr_name: str, + update_func: Callable[[CrdClassT], CrdClassT], + create_func: Callable[[], CrdClassT]) -> str: + try: + current_json = self.rook_api_get( + "{}/{}".format(crd_name, cr_name) + ) + except ApiException as e: + if e.status == 404: + current_json = None + else: + raise + + if current_json: + new = crd.from_json(current_json) # no deepcopy. + + new = update_func(new) + + patch = list(jsonpatch.make_patch(current_json, new.to_json())) + + log.info('patch for {}/{}: \n{}'.format(crd_name, cr_name, patch)) + + if len(patch) == 0: + return "No change" + + try: + self.rook_api_patch( + "{}/{}".format(crd_name, cr_name), + body=patch) + except ApiException as e: + log.exception("API exception: {0}".format(e)) + raise ApplyException( + "Failed to update {}/{}: {}".format(crd_name, cr_name, e)) + return "Updated" + else: + new = create_func() + with self.ignore_409("{} {} already exists".format(crd_name, + cr_name)): + self.rook_api_post("{}/".format(crd_name), + body=new.to_json()) + return "Created" + def get_ceph_image(self) -> str: + try: + api_response = self.coreV1_api.list_namespaced_pod(self.rook_env.namespace, + label_selector="app=rook-ceph-mon", + timeout_seconds=10) + if api_response.items: + return api_response.items[-1].spec.containers[0].image + else: + raise orchestrator.OrchestratorError( + "Error getting ceph image. Cluster without monitors") + except ApiException as e: + raise orchestrator.OrchestratorError("Error getting ceph image: {}".format(e)) + + + def _execute_blight_job(self, ident_fault: str, on: bool, loc: orchestrator.DeviceLightLoc) -> str: + operation_id = str(hash(loc)) + message = "" + + # job definition + job_metadata = client.V1ObjectMeta(name=operation_id, + namespace= self.rook_env.namespace, + labels={"ident": operation_id}) + pod_metadata = client.V1ObjectMeta(labels={"ident": operation_id}) + pod_container = client.V1Container(name="ceph-lsmcli-command", + security_context=client.V1SecurityContext(privileged=True), + image=self.get_ceph_image(), + command=["lsmcli",], + args=['local-disk-%s-led-%s' % (ident_fault,'on' if on else 'off'), + '--path', loc.path or loc.dev,], + volume_mounts=[client.V1VolumeMount(name="devices", mount_path="/dev"), + client.V1VolumeMount(name="run-udev", mount_path="/run/udev")]) + pod_spec = client.V1PodSpec(containers=[pod_container], + active_deadline_seconds=30, # Max time to terminate pod + restart_policy="Never", + node_selector= {"kubernetes.io/hostname": loc.host}, + volumes=[client.V1Volume(name="devices", + host_path=client.V1HostPathVolumeSource(path="/dev")), + client.V1Volume(name="run-udev", + host_path=client.V1HostPathVolumeSource(path="/run/udev"))]) + pod_template = client.V1PodTemplateSpec(metadata=pod_metadata, + spec=pod_spec) + job_spec = client.V1JobSpec(active_deadline_seconds=60, # Max time to terminate job + ttl_seconds_after_finished=10, # Alfa. Lifetime after finishing (either Complete or Failed) + backoff_limit=0, + template=pod_template) + job = client.V1Job(api_version="batch/v1", + kind="Job", + metadata=job_metadata, + spec=job_spec) + + # delete previous job if it exists + try: + try: + api_response = self.batchV1_api.delete_namespaced_job(operation_id, + self.rook_env.namespace, + propagation_policy="Background") + except ApiException as e: + if e.status != 404: # No problem if the job does not exist + raise + + # wait until the job is not present + deleted = False + retries = 0 + while not deleted and retries < 10: + api_response = self.batchV1_api.list_namespaced_job(self.rook_env.namespace, + label_selector="ident=%s" % operation_id, + timeout_seconds=10) + deleted = not api_response.items + if retries > 5: + sleep(0.1) + retries += 1 + if retries == 10 and not deleted: + raise orchestrator.OrchestratorError( + "Light <{}> in <{}:{}> cannot be executed. Cannot delete previous job <{}>".format( + on, loc.host, loc.path or loc.dev, operation_id)) + + # create the job + api_response = self.batchV1_api.create_namespaced_job(self.rook_env.namespace, job) + + # get the result + finished = False + while not finished: + api_response = self.batchV1_api.read_namespaced_job(operation_id, + self.rook_env.namespace) + finished = api_response.status.succeeded or api_response.status.failed + if finished: + message = api_response.status.conditions[-1].message + + # get the result of the lsmcli command + api_response=self.coreV1_api.list_namespaced_pod(self.rook_env.namespace, + label_selector="ident=%s" % operation_id, + timeout_seconds=10) + if api_response.items: + pod_name = api_response.items[-1].metadata.name + message = self.coreV1_api.read_namespaced_pod_log(pod_name, + self.rook_env.namespace) + + except ApiException as e: + log.exception('K8s API failed. {}'.format(e)) + raise + + # Finally, delete the job. + # The job uses . This makes that the TTL controller delete automatically the job. + # This feature is in Alpha state, so extra explicit delete operations trying to delete the Job has been used strategically + try: + api_response = self.batchV1_api.delete_namespaced_job(operation_id, + self.rook_env.namespace, + propagation_policy="Background") + except ApiException as e: + if e.status != 404: # No problem if the job does not exist + raise + + return message + + def blink_light(self, ident_fault, on, locs): + # type: (str, bool, List[orchestrator.DeviceLightLoc]) -> List[str] + return [self._execute_blight_job(ident_fault, on, loc) for loc in locs] + +def placement_spec_to_node_selector(spec: PlacementSpec, all_hosts: List) -> ccl.NodeSelectorTermsItem: + all_hostnames = [hs.hostname for hs in all_hosts] + res = ccl.NodeSelectorTermsItem(matchExpressions=ccl.MatchExpressionsList()) + if spec.host_pattern and spec.host_pattern != "*": + raise RuntimeError("The Rook orchestrator only supports a host_pattern of * for placements") + if spec.label: + res.matchExpressions.append( + ccl.MatchExpressionsItem( + key="ceph-label/" + spec.label, + operator="Exists" + ) + ) + if spec.hosts: + host_list = [h.hostname for h in spec.hosts if h.hostname in all_hostnames] + res.matchExpressions.append( + ccl.MatchExpressionsItem( + key="kubernetes.io/hostname", + operator="In", + values=ccl.CrdObjectList(host_list) + ) + ) + if spec.host_pattern == "*" or (not spec.label and not spec.hosts and not spec.host_pattern): + res.matchExpressions.append( + ccl.MatchExpressionsItem( + key="kubernetes.io/hostname", + operator="Exists", + ) + ) + return res + +def node_selector_to_placement_spec(node_selector: ccl.NodeSelectorTermsItem) -> PlacementSpec: + res = PlacementSpec() + for expression in node_selector.matchExpressions: + if expression.key.startswith("ceph-label/"): + res.label = expression.key.split('/')[1] + elif expression.key == "kubernetes.io/hostname": + if expression.operator == "Exists": + res.host_pattern = "*" + elif expression.operator == "In": + res.hosts = [HostPlacementSpec(hostname=value, network='', name='')for value in expression.values] + return res diff --git a/src/pybind/mgr/rook/tests/__init__.py b/src/pybind/mgr/rook/tests/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/src/pybind/mgr/rook/tests/fixtures.py b/src/pybind/mgr/rook/tests/fixtures.py new file mode 100644 index 000000000..65a519743 --- /dev/null +++ b/src/pybind/mgr/rook/tests/fixtures.py @@ -0,0 +1,11 @@ +from rook.module import RookOrchestrator +from orchestrator import raise_if_exception, OrchResult + +try: + from typing import Any +except ImportError: + pass + + +def wait(m: RookOrchestrator, c: OrchResult) -> Any: + return raise_if_exception(c) diff --git a/src/pybind/mgr/rook/tests/test_placement.py b/src/pybind/mgr/rook/tests/test_placement.py new file mode 100644 index 000000000..eeaf191e2 --- /dev/null +++ b/src/pybind/mgr/rook/tests/test_placement.py @@ -0,0 +1,100 @@ +# flake8: noqa + +from rook.rook_cluster import placement_spec_to_node_selector, node_selector_to_placement_spec +from rook.rook_client.ceph.cephcluster import MatchExpressionsItem, MatchExpressionsList, NodeSelectorTermsItem +import pytest +from orchestrator import HostSpec +from ceph.deployment.service_spec import PlacementSpec + +@pytest.mark.parametrize("hosts", + [ # noqa: E128 + [ + HostSpec( + hostname="node1", + labels=["label1"] + ), + HostSpec( + hostname="node2", + labels=[] + ), + HostSpec( + hostname="node3", + labels=["label1"] + ) + ] + ]) +@pytest.mark.parametrize("expected_placement_spec, expected_node_selector", + [ # noqa: E128 + ( + PlacementSpec( + label="label1" + ), + NodeSelectorTermsItem( + matchExpressions=MatchExpressionsList( + [ + MatchExpressionsItem( + key="ceph-label/label1", + operator="Exists" + ) + ] + ) + ) + ), + ( + PlacementSpec( + label="label1", + host_pattern="*" + ), + NodeSelectorTermsItem( + matchExpressions=MatchExpressionsList( + [ + MatchExpressionsItem( + key="ceph-label/label1", + operator="Exists" + ), + MatchExpressionsItem( + key="kubernetes.io/hostname", + operator="Exists", + ) + ] + ) + ) + ), + ( + PlacementSpec( + host_pattern="*" + ), + NodeSelectorTermsItem( + matchExpressions=MatchExpressionsList( + [ + MatchExpressionsItem( + key="kubernetes.io/hostname", + operator="Exists", + ) + ] + ) + ) + ), + ( + PlacementSpec( + hosts=["node1", "node2", "node3"] + ), + NodeSelectorTermsItem( + matchExpressions=MatchExpressionsList( + [ + MatchExpressionsItem( + key="kubernetes.io/hostname", + operator="In", + values=["node1", "node2", "node3"] + ) + ] + ) + ) + ), + ]) +def test_placement_spec_translate(hosts, expected_placement_spec, expected_node_selector): + node_selector = placement_spec_to_node_selector(expected_placement_spec, hosts) + assert [(getattr(expression, 'key', None), getattr(expression, 'operator', None), getattr(expression, 'values', None)) for expression in node_selector.matchExpressions] == [(getattr(expression, 'key', None), getattr(expression, 'operator', None), getattr(expression, 'values', None)) for expression in expected_node_selector.matchExpressions] + placement_spec = node_selector_to_placement_spec(expected_node_selector) + assert placement_spec == expected_placement_spec + assert (getattr(placement_spec, 'label', None), getattr(placement_spec, 'hosts', None), getattr(placement_spec, 'host_pattern', None)) == (getattr(expected_placement_spec, 'label', None), getattr(expected_placement_spec, 'hosts', None), getattr(expected_placement_spec, 'host_pattern', None)) diff --git a/src/pybind/mgr/rook/tests/test_rook.py b/src/pybind/mgr/rook/tests/test_rook.py new file mode 100644 index 000000000..08028ba85 --- /dev/null +++ b/src/pybind/mgr/rook/tests/test_rook.py @@ -0,0 +1,120 @@ +import orchestrator +from .fixtures import wait +import pytest +from unittest.mock import patch, PropertyMock + +from rook.module import RookOrchestrator +from rook.rook_cluster import RookCluster + + +# we use this intermediate class as .rook_cluster property +# is read only in the paretn class RookCluster +class FakeRookCluster(RookCluster): + def __init__(self): + pass + + +class TestRook(object): + + @pytest.mark.parametrize("pods, expected_daemon_types", [ + ( + [ + { + 'name': 'ceph-rook-exporter', + 'hostname': 'host1', + "labels": {'app': 'rook-ceph-exporter', + 'ceph_daemon_id': 'exporter'}, + 'phase': 'Pending', + 'container_image_name': 'quay.io/ceph/ceph:v18', + 'container_image_id': 'docker-pullable://quay.io/ceph/ceph@sha256:f239715e1c7756e32a202a572e2763a4ce15248e09fc6e8990985f8a09ffa784', + 'refreshed': 'pod1_ts', + 'started': 'pod1_ts', + 'created': 'pod1_1ts', + }, + { + 'name': 'rook-ceph-mgr-a-68c7b9b6d8-vjjhl', + 'hostname': 'host1', + "labels": {'app': 'rook-ceph-mgr', + 'ceph_daemon_type': 'mgr', + 'ceph_daemon_id': 'a'}, + 'phase': 'Failed', + 'container_image_name': 'quay.io/ceph/ceph:v18', + 'container_image_id': '', + 'refreshed': 'pod2_ts', + 'started': 'pod2_ts', + 'created': 'pod2_1ts', + }, + { + 'name': 'rook-ceph-mon-a-65fb8694b4-mmtl5', + 'hostname': 'host1', + "labels": {'app': 'rook-ceph-mon', + 'ceph_daemon_type': 'mon', + 'ceph_daemon_id': 'b'}, + 'phase': 'Running', + 'container_image_name': 'quay.io/ceph/ceph:v18', + 'container_image_id': '', + 'refreshed': 'pod3_ts', + 'started': 'pod3_ts', + 'created': 'pod3_1ts', + }, + { + 'name': 'rook-ceph-osd-0-58cbd7b65c-6cjnr', + 'hostname': 'host1', + "labels": {'app': 'rook-ceph-osd', + 'ceph-osd-id': '0', + 'ceph_daemon_type': 'osd', + 'ceph_daemon_id': '0'}, + 'phase': 'Succeeded', + 'container_image_name': 'quay.io/ceph/ceph:v18', + 'container_image_id': '', + 'refreshed': 'pod4_ts', + 'started': 'pod4_ts', + 'created': 'pod4_1ts', + }, + # unknown pod: has no labels are provided, it shouldn't + # be part of the output + { + 'name': 'unknown-pod', + 'hostname': '', + "labels": {'app': 'unkwon'}, + 'phase': 'Pending', + 'container_image_name': 'quay.io/ceph/ceph:v18', + 'container_image_id': '', + 'refreshed': '', + 'started': '', + 'created': '', + } + ], + ['ceph-exporter', 'mgr', 'mon', 'osd'] + ) + ]) + def test_list_daemons(self, pods, expected_daemon_types): + + status = { + 'Pending': orchestrator.DaemonDescriptionStatus.starting, + 'Running': orchestrator.DaemonDescriptionStatus.running, + 'Succeeded': orchestrator.DaemonDescriptionStatus.stopped, + 'Failed': orchestrator.DaemonDescriptionStatus.error, + 'Unknown': orchestrator.DaemonDescriptionStatus.unknown, + } + + fake_rook_cluster = FakeRookCluster() + ro = RookOrchestrator('rook', None, self) + with patch('rook.RookOrchestrator.rook_cluster', + new_callable=PropertyMock, + return_value=fake_rook_cluster): + with patch.object(fake_rook_cluster, 'describe_pods') as mock_describe_pods: + mock_describe_pods.return_value = pods + dds = wait(ro, ro.list_daemons()) + assert len(dds) == len(expected_daemon_types) + for i in range(0, len(dds)): + assert dds[i].daemon_type == expected_daemon_types[i] + assert dds[i].hostname == pods[i]['hostname'] + assert dds[i].status == status[pods[i]['phase']] + assert dds[i].container_image_name == pods[i]['container_image_name'] + assert dds[i].container_image_id == pods[i]['container_image_id'] + assert dds[i].created == pods[i]['created'] + assert dds[i].last_configured == pods[i]['created'] + assert dds[i].last_deployed == pods[i]['created'] + assert dds[i].started == pods[i]['started'] + assert dds[i].last_refresh == pods[i]['refreshed'] -- cgit v1.2.3