diff options
Diffstat (limited to '')
40 files changed, 16694 insertions, 0 deletions
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 <crds.yaml> <output-folder> +``` + +## 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 + + + +## 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 <crds.yaml> <output-folder> + python setup.py develop + +Usage: + generate_model_classes.py <crds.yaml> <output-folder> +""" +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["<crds.yaml>"] == '-' else args["<crds.yaml>"] + main(yaml_filename, args["<output-folder>"])
\ 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 Binary files differnew file mode 100644 index 000000000..0a9139a13 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook-python-client-demo.gif 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 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/cassandra/__init__.py 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 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/ceph/__init__.py 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 --- /dev/null +++ b/src/pybind/mgr/rook/rook-client-python/rook_client/tests/__init__.py 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 + |
