def create_quay_registry(self): """ Creates Quay registry """ if not helpers.get_default_storage_class(): patch = ' \'{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}\' ' run_cmd(f"oc patch storageclass {self.sc_name} " f"-p {patch} " f"--request-timeout=120s") self.sc_default = True self.quay_registry_secret_name = create_unique_resource_name( "quay-user", "secret") logger.info( f"Creating Quay registry config for super-user access: {self.quay_registry_secret_name}" ) self.quay_registry_secret = self.ocp_obj.exec_oc_cmd( command= f"create secret generic --from-file config.yaml={constants.QUAY_SUPER_USER} " f"{self.quay_registry_secret_name}") quay_registry_data = templating.load_yaml(file=constants.QUAY_REGISTRY) self.quay_registry_name = quay_registry_data["metadata"]["name"] quay_registry_data["spec"][ "configBundleSecret"] = self.quay_registry_secret_name self.quay_registry = OCS(**quay_registry_data) logger.info(f"Creating Quay registry: {self.quay_registry.name}") self.quay_registry.create() logger.info("Waiting for 15s for registry to get initialized") sleep(15) self.wait_for_quay_endpoint()
def teardown(self): """ Delete objects created in roughly reverse order of how they were created. """ self.cb_examples.delete() self.cb_worker.delete() self.cb_deploy.delete() self.pod_obj.exec_oc_cmd( command="delete rolebinding couchbase-operator-rolebinding") self.pod_obj.exec_oc_cmd( command="delete serviceaccount couchbase-operator") self.operator_role.delete() self.couchbase_obj.delete() switch_to_project('default') self.pod_obj.delete_project(constants.COUCHBASE_OPERATOR) for adm_yaml in self.admission_parts: adm_data = templating.load_yaml(adm_yaml) adm_obj = OCS(**adm_data) adm_obj.delete() # Before the code below was added, the teardown task would sometimes # fail with the leftover objects because it would still see one of the # couchbase pods. for admin_pod in TimeoutSampler(self.WAIT_FOR_TIME, 3, get_pod_name_by_pattern, 'couchbase', 'default'): if admin_pod: continue else: break PillowFight.cleanup(self) switch_to_default_rook_cluster_project()
def test_verify_all_fields_in_sc_yaml_with_oc_describe(self, interface): """ Test function to create RBD and CephFS SC, and match with oc describe sc output """ log.info(f"Creating a {interface} storage class") self.sc_data = templating.load_yaml( getattr(constants, f"CSI_{interface}_STORAGECLASS_YAML")) self.sc_data['metadata']['name'] = ( helpers.create_unique_resource_name('test', f'csi-{interface.lower()}')) global SC_OBJ SC_OBJ = OCS(**self.sc_data) assert SC_OBJ.create() log.info( f"{interface}Storage class: {SC_OBJ.name} created successfully") log.info(self.sc_data) # Get oc describe sc output describe_out = SC_OBJ.get("sc") log.info(describe_out) # Confirm that sc yaml details matches oc describe sc output value = { k: describe_out[k] for k in set(describe_out) - set(self.sc_data) } assert len(value) == 1 and value['volumeBindingMode'] == 'Immediate', ( "OC describe sc output didn't match storage class yaml") log.info("OC describe sc output matches storage class yaml") # Delete Storage Class log.info(f"Deleting Storageclass: {SC_OBJ.name}") assert SC_OBJ.delete() log.info(f"Storage Class: {SC_OBJ.name} deleted successfully") del SC_OBJ
def invalid_storageclass(request): """ Creates a CephFS or RBD StorageClass with invalid parameters. Storageclass is removed at the end of test. Returns: str: Name of created StorageClass """ logger.info(f"SETUP - creating storageclass " f"{request.param['values']['storageclass_name']}") yaml_path = os.path.join(request.param['template_dir'], "storageclass.yaml") with open(yaml_path, 'r') as fd: yaml_data = yaml.safe_load(fd) yaml_data.update(request.param['values']) storageclass = OCS(**yaml_data) sc_data = storageclass.create() logger.debug('Check that storageclass has assigned creationTimestamp') assert sc_data['metadata']['creationTimestamp'] yield sc_data logger.info(f"TEARDOWN - removing storageclass " f"{request.param['values']['storageclass_name']}") storageclass.delete()
def test_ceph_rgw_metrics_after_metrics_exporter_respin(rgw_deployments): """ RGW metrics should be provided via OCP Prometheus even after ocs-metrics-exporter pod is respinned. """ logger.info("Respin ocs-metrics-exporter pod") pod_obj = ocp.OCP(kind=constants.POD, namespace=defaults.ROOK_CLUSTER_NAMESPACE) metrics_pods = pod_obj.get( selector="app.kubernetes.io/name=ocs-metrics-exporter")["items"] assert len(metrics_pods) == 1 metrics_pod_data = metrics_pods[0] metrics_pod = OCS(**metrics_pod_data) metrics_pod.delete(force=True) logger.info("Wait for ocs-metrics-exporter pod to come up") assert pod_obj.wait_for_resource( condition="Running", selector="app.kubernetes.io/name=ocs-metrics-exporter", resource_count=1, timeout=600, ) logger.info("Collect RGW metrics") prometheus = PrometheusAPI() list_of_metrics_without_results = metrics.get_missing_metrics( prometheus, metrics.ceph_rgw_metrics) msg = ( "OCS Monitoring should provide some value(s) for tested rgw metrics, " "so that the list of metrics without results is empty.") assert list_of_metrics_without_results == [], msg
def setup_ceph_toolbox(): """ Setup ceph-toolbox - also checks if toolbox exists, if it exists it behaves as noop. """ namespace = ocsci_config.ENV_DATA['cluster_namespace'] ceph_toolbox = get_pod_name_by_pattern('rook-ceph-tools', namespace) if len(ceph_toolbox) == 1: log.info("Ceph toolbox already exists, skipping") return if ocsci_config.ENV_DATA.get("ocs_version") == '4.2': rook_operator = get_pod_name_by_pattern('rook-ceph-operator', namespace) out = run_cmd( f'oc -n {namespace} get pods {rook_operator[0]} -o yaml', ) version = yaml.safe_load(out) rook_version = version['spec']['containers'][0]['image'] tool_box_data = templating.load_yaml(constants.TOOL_POD_YAML) tool_box_data['spec']['template']['spec']['containers'][0][ 'image'] = rook_version rook_toolbox = OCS(**tool_box_data) rook_toolbox.create() else: # for OCS >= 4.3 there is new toolbox pod deployment done here: # https://github.com/openshift/ocs-operator/pull/207/ log.info("starting ceph toolbox pod") run_cmd( 'oc patch ocsinitialization ocsinit -n openshift-storage --type ' 'json --patch \'[{ "op": "replace", "path": ' '"/spec/enableCephTools", "value": true }]\'')
def create_cephfilesystem(): """ Function for deploying CephFileSystem (MDS) Returns: bool: True if CephFileSystem creates successful """ fs_data = templating.load_yaml_to_dict(constants.CEPHFILESYSTEM_YAML) fs_data['metadata']['name'] = create_unique_resource_name( 'test', 'cephfs' ) fs_data['metadata']['namespace'] = config.ENV_DATA['cluster_namespace'] global CEPHFS_OBJ CEPHFS_OBJ = OCS(**fs_data) CEPHFS_OBJ.create() POD = pod.get_all_pods( namespace=defaults.ROOK_CLUSTER_NAMESPACE ) for pod_names in POD: if 'rook-ceph-mds' in pod_names.labels.values(): assert pod_names.ocp.wait_for_resource( condition=constants.STATUS_RUNNING, selector='app=rook-ceph-mds' ) assert validate_cephfilesystem(fs_name=fs_data['metadata']['name']) return True
def deploy_and_wait_for_wl_to_start(self, timeout=300, sleep=20): """ Deploy the workload and wait until it start working Args: timeout (int): time in second to wait until the benchmark start sleep (int): Sleep interval seconds """ log.debug(f"The {self.benchmark_name} CR file is {self.crd_data}") self.benchmark_obj = OCS(**self.crd_data) self.benchmark_obj.create() # This time is only for reporting - when the benchmark started. self.start_time = time.strftime("%Y-%m-%dT%H:%M:%SGMT", time.gmtime()) # Wait for benchmark client pod to be created log.info(f"Waiting for {self.client_pod_name} to Start") for bm_pod in TimeoutSampler( timeout, sleep, get_pod_name_by_pattern, self.client_pod_name, constants.RIPSAW_NAMESPACE, ): try: if bm_pod[0] is not None: self.client_pod = bm_pod[0] break except IndexError: log.info("Bench pod is not ready yet") # Sleeping for 15 sec for the client pod to be fully accessible time.sleep(15) log.info(f"The benchmark pod {self.client_pod_name} is Running")
def create_kafka_topic(self, name="my-topic", partitions=1, replicas=1): """ Creates kafka topic Args: name (str): Name of the kafka topic partitions (int): Number of partitions replicas (int): Number of replicas Return: kafka_topic object """ try: kafka_topic = templating.load_yaml( os.path.join(self.dir, self.kafka_topic_yaml) ) kafka_topic["metadata"]["name"] = name kafka_topic["spec"]["partitions"] = partitions kafka_topic["spec"]["replicas"] = replicas self.kafka_topic = OCS(**kafka_topic) self.kafka_topic.create() except (CommandFailed, CalledProcessError) as cf: if f'kafkatopics.kafka.strimzi.io "{name}" already exists' not in str(cf): log.error("Failed during creating of Kafka topic") raise cf # Making sure kafka topic created if self.kafka_topic_obj.get(resource_name=name): return self.kafka_topic else: raise ResourceWrongStatusException("kafka topic is not created")
def create_ocs_jenkins_template(self): """ Create OCS Jenkins Template """ log.info("Create Jenkins Template, jenkins-persistent-ocs") ocp_obj = OCP(namespace='openshift', kind='template') tmp_dict = ocp_obj.get( resource_name='jenkins-persistent', out_yaml_format=True ) tmp_dict['labels']['app'] = 'jenkins-persistent-ocs' tmp_dict['labels']['template'] = 'jenkins-persistent-ocs-template' tmp_dict['metadata']['name'] = 'jenkins-persistent-ocs' tmp_dict['objects'][1]['metadata']['annotations'] = { 'volume.beta.kubernetes.io/storage-class': 'ocs-storagecluster-ceph-rbd' } tmp_dict['objects'][2]['spec']['template']['spec']['containers'][0]['env'].append( {'name': 'JAVA_OPTS', 'value': '${JAVA_OPTS}'}) tmp_dict['parameters'][4]['value'] = '10Gi' tmp_dict['parameters'].append({ 'description': "Override jenkins options to speed up slave spawning", 'displayName': 'Override jenkins options to speed up slave spawning', 'name': 'JAVA_OPTS', 'value': "-Dhudson.slaves.NodeProvisioner.initialDelay=0 " "-Dhudson.slaves.NodeProvisioner.MARGIN=50 -Dhudson." "slaves.NodeProvisioner.MARGIN0=0.85" }) ocs_jenkins_template_obj = OCS(**tmp_dict) ocs_jenkins_template_obj.create()
def create_ocs_jenkins_template(self): """ Create OCS Jenkins Template """ log.info("Create Jenkins Template, jenkins-persistent-ocs") ocp_obj = OCP(namespace="openshift", kind="template") tmp_dict = ocp_obj.get(resource_name="jenkins-persistent", out_yaml_format=True) tmp_dict["labels"]["app"] = "jenkins-persistent-ocs" tmp_dict["labels"]["template"] = "jenkins-persistent-ocs-template" tmp_dict["metadata"]["name"] = "jenkins-persistent-ocs" # Find Kind: 'PersistentVolumeClaim' position in the objects list, differs in OCP 4.5 and OCP 4.6. for i in range(len(tmp_dict["objects"])): if tmp_dict["objects"][i]["kind"] == constants.PVC: tmp_dict["objects"][i]["metadata"]["annotations"] = { "volume.beta.kubernetes.io/storage-class": "ocs-storagecluster-ceph-rbd" } tmp_dict["parameters"][4]["value"] = "10Gi" tmp_dict["parameters"].append({ "description": "Override jenkins options to speed up slave spawning", "displayName": "Override jenkins options to speed up slave spawning", "name": "JAVA_OPTS", "value": "-Dhudson.slaves.NodeProvisioner.initialDelay=0 " "-Dhudson.slaves.NodeProvisioner.MARGIN=50 -Dhudson." "slaves.NodeProvisioner.MARGIN0=0.85", }) ocs_jenkins_template_obj = OCS(**tmp_dict) ocs_jenkins_template_obj.create()
def create_kafka_user(self, name="my-user"): """ Creates kafka user Args: name (str): Name of the kafka user Return: kafka_user object """ try: kafka_user = templating.load_yaml( os.path.join(self.dir, self.kafka_user_yaml) ) kafka_user["metadata"]["name"] = name self.kafka_user = OCS(**kafka_user) self.kafka_user.create() except (CommandFailed, CalledProcessError) as cf: log.error("Failed during creating of Kafka user") raise cf # Making sure kafka user created if self.kafka_user_obj.get(resource_name=name): return self.kafka_user else: raise ResourceWrongStatusException("kafka user is not created")
def create_storageclass(sc_name, expect_fail=False): """ Function to create a storage class and check for duplicate storage class name Args: sc_name (str): name of the storageclass to be created expect_fail (bool): To catch the incorrect scenario if two SCs are indeed created with same name Returns: None """ # Create a storage class sc_data = templating.load_yaml(constants.CSI_RBD_STORAGECLASS_YAML) sc_data["metadata"]["name"] = sc_name sc_data["parameters"]["clusterID"] = defaults.ROOK_CLUSTER_NAMESPACE global SC_OBJ SC_OBJ = OCS(**sc_data) # Check for expected failure with duplicate SC name try: SC_OBJ.create() assert not expect_fail, "SC creation with same name passed. Expected to fail !" log.info(f"Storage class: {SC_OBJ.name} created successfully !") log.debug(sc_data) except CommandFailed as ecf: assert "AlreadyExists" in str(ecf) log.info(f"Cannot create two StorageClasses with same name !" f" Error message: \n" f"{ecf}")
def get_machineset_objs(machineset_names=None): """ Get machineset objects by machineset names Args: machineset_names (list): The machineset names to get their objects If None, will return all cluster machines Returns: list: Cluster machineset OCS objects """ machinesets_obj = OCP( kind=constants.MACHINESETS, namespace=constants.OPENSHIFT_MACHINE_API_NAMESPACE ) machineset_dicts = machinesets_obj.get()["items"] if not machineset_names: return [OCS(**obj) for obj in machineset_dicts] else: return [ OCS(**obj) for obj in machineset_dicts if (obj.get("metadata").get("name") in machineset_names) ]
def create_pvc_snapshot(pvc_name, snap_yaml, snap_name, sc_name=None, wait=False): """ Create snapshot of a PVC Args: pvc_name (str): Name of the PVC snap_yaml (str): The path of snapshot yaml snap_name (str): The name of the snapshot to be created sc_name (str): The name of the snapshot class wait (bool): True to wait for snapshot to be ready, False otherwise Returns: OCS object """ snapshot_data = templating.load_yaml(snap_yaml) snapshot_data['metadata']['name'] = snap_name if sc_name: snapshot_data['spec']['volumeSnapshotClassName'] = sc_name snapshot_data['spec']['source']['persistentVolumeClaimName'] = pvc_name ocs_obj = OCS(**snapshot_data) created_snap = ocs_obj.create(do_reload=True) assert created_snap, f"Failed to create snapshot {snap_name}" if wait: ocs_obj.ocp.wait_for_resource(condition='true', resource_name=ocs_obj.name, column=constants.STATUS_READYTOUSE, timeout=60) return ocs_obj
def create_consumer_pod(self, num_of_pods=1, value="10000"): """ Creates producer pods Args: num_of_pods (int): Number of consumer pods to be created value (str): Number of messages to be received Returns: consumer pod object """ try: consumer_pod = templating.load_yaml(constants.HELLO_WORLD_CONSUMER_YAML) consumer_pod["spec"]["replicas"] = num_of_pods consumer_pod["spec"]["template"]["spec"]["containers"][0]["env"][4][ "value" ] = value self.consumer_pod = OCS(**consumer_pod) self.consumer_pod.create() except (CommandFailed, CalledProcessError) as cf: log.error("Failed during creation of consumer pod") raise cf # Making sure the producer pod is running if self.is_amq_pod_running( pod_pattern="hello-world-consumer", expected_pods=num_of_pods ): return self.consumer_pod else: raise ResourceWrongStatusException( "consumer pod is not getting to running state" )
def increase_pods_per_worker_node_count(pods_per_node=500, pods_per_core=10): """ Function to increase pods per node count, default OCP supports 250 pods per node, from OCP 4.6 limit is going to be 500, but using this function can override this param to create more pods per worker nodes. more detail: https://docs.openshift.com/container-platform/4.5/nodes/nodes/nodes-nodes-managing-max-pods.html Example: The default value for podsPerCore is 10 and the default value for maxPods is 250. This means that unless the node has 25 cores or more, by default, podsPerCore will be the limiting factor. WARN: This function will perform Unscheduling of workers and reboot so Please aware if there is any non-dc pods then expected to be terminated. Args: pods_per_node (int): Pods per node limit count pods_per_core (int): Pods per core limit count Raise: UnexpectedBehaviour if machineconfigpool not in Updating state within 40secs. """ max_pods_template = templating.load_yaml( constants.PODS_PER_NODE_COUNT_YAML) max_pods_template["spec"]["kubeletConfig"]["podsPerCore"] = pods_per_core max_pods_template["spec"]["kubeletConfig"]["maxPods"] = pods_per_node # Create new max-pods label max_pods_obj = OCS(**max_pods_template) assert max_pods_obj.create() # Apply the changes in the workers label_cmd = "label machineconfigpool worker custom-kubelet=small-pods" ocp = OCP() assert ocp.exec_oc_cmd(command=label_cmd) # First wait for Updating status to become True, default it will be False & # machine_count and ready_machine_count will be equal get_cmd = "get machineconfigpools -o yaml" timout_counter = 0 while True: output = ocp.exec_oc_cmd(command=get_cmd) update_status = (output.get("items")[1].get("status").get("conditions") [4].get("status")) if update_status == "True": break elif timout_counter >= 8: raise UnexpectedBehaviour( "After 40sec machineconfigpool not in Updating state") else: logging.info("Sleep 5secs for updating status change") timout_counter += 1 time.sleep(5) # Validate either change is successful output = ocp.exec_oc_cmd(command=get_cmd) machine_count = output.get("items")[1].get("status").get("machineCount") # During manual execution observed each node took 240+ sec for update timeout = machine_count * 300 utils.wait_for_machineconfigpool_status(node_type=constants.WORKER_MACHINE, timeout=timeout)
def deploy_and_wait_for_wl_to_start(self): """ Deploy the workload and wait until it start working Returns: obj : the FIO client pod object """ log.info(f"The FIO CR file is {self.fio_cr}") self.fio_cr_obj = OCS(**self.fio_cr) self.fio_cr_obj.create() # Wait for fio client pod to be created for fio_pod in TimeoutSampler(900, 20, get_pod_name_by_pattern, "fio-client", constants.RIPSAW_NAMESPACE): try: if fio_pod[0] is not None: fio_client_pod = fio_pod[0] break except IndexError: log.info("Bench pod not ready yet") # Getting the start time of the test self.start_time = time.strftime("%Y-%m-%dT%H:%M:%SGMT", time.gmtime()) return fio_client_pod
def setup_amq_kafka_connect(self): """ The function is to setup amq-kafka-connect, the yaml file is pulling from github it will make kind: KafkaConnect and will make sure the status is running Returns: kafka_connect object """ try: kafka_connect = templating.load_yaml( os.path.join(self.dir, self.amq_kafka_connect_yaml) ) self.kafka_connect = OCS(**kafka_connect) self.kafka_connect.create() except (CommandFailed, CalledProcessError) as cf: log.error("Failed during setup of AMQ KafkaConnect") raise cf if self.is_amq_pod_running( pod_pattern="my-connect-cluster-connect", expected_pods=1 ): return self.kafka_connect else: raise ResourceWrongStatusException( "my-connect-cluster-connect pod is not getting to running state" )
def create_resource(desired_status=constants.STATUS_AVAILABLE, wait=True, **kwargs): """ Create a resource Args: desired_status (str): The status of the resource to wait for wait (bool): True for waiting for the resource to reach the desired status, False otherwise kwargs (dict): Dictionary of the OCS resource Returns: OCS: An OCS instance Raises: AssertionError: In case of any failure """ ocs_obj = OCS(**kwargs) resource_name = kwargs.get('metadata').get('name') created_resource = ocs_obj.create(do_reload=wait) assert created_resource, (f"Failed to create resource {resource_name}") if wait: assert wait_for_resource_state(resource=resource_name, state=desired_status) return ocs_obj
def create_pgbench_benchmark(self, replicas, clients=None, threads=None, transactions=None, scaling_factor=None, timeout=None): """ Create pgbench benchmark pods Args: replicas (int): Number of pgbench pods to be deployed clients (int): Number of clients threads (int): Number of threads transactions (int): Number of transactions scaling_factor (int): scaling factor timeout (int): Time in seconds to wait Returns: List: pgbench pod objects list """ pg_obj_list = [] for i in range(replicas): log.info("Create resource file for pgbench workload") pg_data = templating.load_yaml(constants.PGSQL_BENCHMARK_YAML) pg_data['metadata']['name'] = 'pgbench-benchmark' + f"{i}" pg_data['spec']['workload']['args']['databases'][0][ 'host'] = "postgres-" + f"{i}" + ".postgres" if clients is not None: pg_data['spec']['workload']['args']['clients'][0] = clients if threads is not None: pg_data['spec']['workload']['args']['threads'] = threads if transactions is not None: pg_data['spec']['workload']['args'][ 'transactions'] = transactions if scaling_factor is not None: pg_data['spec']['workload']['args'][ 'scaling_factor'] = scaling_factor pg_obj = OCS(**pg_data) pg_obj_list.append(pg_obj) pg_obj.create() # Confirm that expected pgbench pods are spinned log.info("Checking if Getting pgbench pods name") timeout = timeout if timeout else 300 for pgbench_pods in TimeoutSampler(timeout, replicas, get_pod_name_by_pattern, 'pgbench-1-dbs-client', RIPSAW_NAMESPACE): try: if len(pgbench_pods) == replicas: log.info(f"Expected number of pgbench pods are " f"found: {replicas}") break except IndexError: log.info(f'Expected number of pgbench pods are {replicas} ' f'but only found {len(pgbench_pods)}') return pg_obj_list
def create_couchbase_worker(self, replicas=1, sc_name=None): """ Deploy a Couchbase server and pillowfight workload using operator The couchbase workers do not come up unless there is an admission controller running. The admission controller is started from the default project prior to bringing up the operator. Secrets, rolebindings and serviceaccounts need to also be generated. Once the couchbase operator is running, we need to wait for the three worker pods to also be up. Then a pillowfight task is started. After the pillowfight task has finished, the log is collected and analyzed. Raises: Exception: If pillowfight results indicate that a minimum performance level is not reached (1 second response time, less than 1000 ops per second) """ logging.info("Creating pods..") cb_example = templating.load_yaml(constants.COUCHBASE_WORKER_EXAMPLE) if storagecluster_independent_check(): cb_example["spec"]["volumeClaimTemplates"][0]["spec"][ "storageClassName" ] = constants.DEFAULT_EXTERNAL_MODE_STORAGECLASS_RBD cb_example["spec"]["servers"][0]["size"] = replicas if sc_name: cb_example["spec"]["volumeClaimTemplates"][0]["spec"][ "storageClassName" ] = sc_name self.cb_examples = OCS(**cb_example) self.cb_examples.create() # Wait for last of three workers to be running. logging.info("Waiting for the pods to Running") for cb_wrk_pods in TimeoutSampler( self.WAIT_FOR_TIME, 3, get_pod_name_by_pattern, "cb-example", constants.COUCHBASE_OPERATOR, ): try: if len(cb_wrk_pods) == replicas: counter = 0 for cb_pod in cb_wrk_pods: if self.is_up_and_running(cb_pod, self.up_check): counter += 1 logging.info(f"Couchbase worker {cb_pod} is up") if counter == replicas: break except IndexError: logging.info( f"Expected number of couchbase pods are {replicas} " f"but only found {len(cb_wrk_pods)}" )
def setup_amq_cluster_operator(self, namespace=constants.AMQ_NAMESPACE): """ Function to setup amq-cluster_operator, the file is pulling from github it will make sure cluster-operator pod is running Args: namespace (str): Namespace for AMQ pods """ # Namespace for amq try: self.create_namespace(namespace) except CommandFailed as ef: if f'project.project.openshift.io "{namespace}" already exists' not in str( ef ): raise ef # Create strimzi-cluster-operator pod run( f"for i in `(ls strimzi-kafka-operator/packaging/install/cluster-operator/)`;" f"do sed 's/{namespace}/myproject/g' " f"strimzi-kafka-operator/packaging/install/cluster-operator/$i;done", shell=True, check=True, cwd=self.dir, ) self.strimzi_kafka_operator = os.path.join(self.dir, self.amq_dir) pf_files = os.listdir(self.strimzi_kafka_operator) crds = [] for crd in pf_files: crds.append(crd) self.crd_objects = [] for adm_yaml in crds: try: adm_data = templating.load_yaml(self.strimzi_kafka_operator + adm_yaml) adm_obj = OCS(**adm_data) adm_obj.create() self.crd_objects.append(adm_obj) except (CommandFailed, CalledProcessError) as cfe: if "Error is Error from server (AlreadyExists):" in str(cfe): log.warn( "Some amq leftovers are present, please cleanup the cluster" ) pytest.skip( "AMQ leftovers are present needs to cleanup the cluster" ) time.sleep(30) # Check strimzi-cluster-operator pod created if self.is_amq_pod_running(pod_pattern="cluster-operator", expected_pods=1): log.info("strimzi-cluster-operator pod is in running state") else: raise ResourceWrongStatusException( "strimzi-cluster-operator pod is not getting to running state" )
def couchbase_operatorgroup(self): """ Creates an operator group for Couchbase """ operatorgroup_yaml = templating.load_yaml( constants.COUCHBASE_OPERATOR_GROUP_YAML) self.operatorgroup_yaml = OCS(**operatorgroup_yaml) self.operatorgroup_yaml.create()
def create_cb_secrets(self): """ " Create secrets for running Couchbase workers """ cb_secrets = templating.load_yaml(constants.COUCHBASE_WORKER_SECRET) self.cb_secrets = OCS(**cb_secrets) self.cb_secrets.create() log.info("Successfully created secrets for Couchbase") self.cb_create_cb_secret = True
def create_data_buckets(self): """ Create data buckets """ cb_bucket = templating.load_yaml(constants.COUCHBASE_DATA_BUCKET) self.cb_bucket = OCS(**cb_bucket) self.cb_bucket.create() log.info("Successfully created data buckets") self.cb_create_bucket = True
def setup_ceph_toolbox(): """ Setup ceph-toolbox based """ namespace = ocsci_config.ENV_DATA['cluster_namespace'] rook_operator = get_pod_name_by_pattern('rook-ceph-operator', namespace) out = run_cmd(f'oc -n {namespace} get pods {rook_operator[0]} -o yaml', ) version = yaml.safe_load(out) rook_version = version['spec']['containers'][0]['image'] tool_box_data = templating.load_yaml(constants.TOOL_POD_YAML) tool_box_data['spec']['template']['spec']['containers'][0][ 'image'] = rook_version rook_toolbox = OCS(**tool_box_data) rook_toolbox.create()
def default_storageclasses(request, teardown_factory_session): """ Returns dictionary with storageclasses. Keys represent reclaim policy of storageclass. There are two storageclasses for each key. First is RBD based and the second one is CephFS based. Storageclasses with Retain Reclaim Policy are created from default storageclasses. """ scs = { constants.RECLAIM_POLICY_DELETE: [], constants.RECLAIM_POLICY_RETAIN: [] } # TODO(fbalak): Use proper constants after # https://github.com/red-hat-storage/ocs-ci/issues/1056 # is resolved for sc_name in ('ocs-storagecluster-ceph-rbd', 'ocs-storagecluster-cephfs'): sc = OCS(kind=constants.STORAGECLASS, metadata={'name': sc_name}) sc.reload() scs[constants.RECLAIM_POLICY_DELETE].append(sc) sc.data['reclaimPolicy'] = constants.RECLAIM_POLICY_RETAIN sc.data['metadata']['name'] += '-retain' sc._name = sc.data['metadata']['name'] sc.create() teardown_factory_session(sc) scs[constants.RECLAIM_POLICY_RETAIN].append(sc) return scs
def setup(self): """ Setting up the environment for the test """ # Create a storage class log.info("Creating a Storage Class") self.sc_data = templating.load_yaml(constants.CSI_RBD_STORAGECLASS_YAML) self.sc_data['metadata']['name'] = helpers.create_unique_resource_name( 'test', 'csi-rbd') global SC_OBJ SC_OBJ = OCS(**self.sc_data) assert SC_OBJ.create() log.info(f"Storage class: {SC_OBJ.name} created successfully") log.debug(self.sc_data)
def setup_ceph_toolbox(force_setup=False): """ Setup ceph-toolbox - also checks if toolbox exists, if it exists it behaves as noop. Args: force_setup (bool): force setup toolbox pod """ namespace = ocsci_config.ENV_DATA["cluster_namespace"] ceph_toolbox = get_pod_name_by_pattern("rook-ceph-tools", namespace) # setup toolbox for external mode # Refer bz: 1856982 - invalid admin secret if len(ceph_toolbox) == 1: log.info("Ceph toolbox already exists, skipping") if force_setup: log.info("Running force setup for Ceph toolbox!") else: return external_mode = ocsci_config.DEPLOYMENT.get("external_mode") if ocsci_config.ENV_DATA.get("ocs_version") == "4.2": rook_operator = get_pod_name_by_pattern("rook-ceph-operator", namespace) out = run_cmd( f"oc -n {namespace} get pods {rook_operator[0]} -o yaml", ) version = yaml.safe_load(out) rook_version = version["spec"]["containers"][0]["image"] tool_box_data = templating.load_yaml(constants.TOOL_POD_YAML) tool_box_data["spec"]["template"]["spec"]["containers"][0][ "image"] = rook_version rook_toolbox = OCS(**tool_box_data) rook_toolbox.create() else: if external_mode: toolbox = templating.load_yaml(constants.TOOL_POD_YAML) toolbox["metadata"]["name"] += "-external" keyring_dict = ocsci_config.EXTERNAL_MODE.get("admin_keyring") env = [{"name": "ROOK_ADMIN_SECRET", "value": keyring_dict["key"]}] toolbox["spec"]["template"]["spec"]["containers"][0]["env"] = env # add ceph volumeMounts ceph_volume_mount_path = { "mountPath": "/etc/ceph", "name": "ceph-config" } ceph_volume = {"name": "ceph-config", "emptyDir": {}} toolbox["spec"]["template"]["spec"]["containers"][0][ "volumeMounts"].append(ceph_volume_mount_path) toolbox["spec"]["template"]["spec"]["volumes"].append(ceph_volume) rook_toolbox = OCS(**toolbox) rook_toolbox.create() return # for OCS >= 4.3 there is new toolbox pod deployment done here: # https://github.com/openshift/ocs-operator/pull/207/ log.info("starting ceph toolbox pod") run_cmd( "oc patch ocsinitialization ocsinit -n openshift-storage --type " 'json --patch \'[{ "op": "replace", "path": ' '"/spec/enableCephTools", "value": true }]\'')