def ocm_cli_install(self): """Installs ocm cli if not installed""" if not self._is_ocmcli_installed(): log.info("Installing ocm cli...") cmd = "sudo curl -Lo /bin/ocm {}".format(self.ocm_cli_binary_url) ret = execute_command(cmd) if ret is None: log.info("Failed to download ocm cli binary") sys.exit(1) cmd = "sudo chmod +x /bin/ocm" ret = execute_command(cmd) if ret is None: log.info("Failed to give execute permission to ocm cli binary") sys.exit(1)
def get_prometheus_token(project): """ Get prometheus token for the cluster. """ cmd = "oc sa get-token prometheus -n {}".format(project) prometheus_token = execute_command(cmd) return prometheus_token.strip("\n")
def create_group(self, group_name): """Creates new group""" cmd = "oc adm groups new {}".format(group_name) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to add group " "{}".format(group_name))
def create_idp(self): """Creates Identity Provider""" if self.idp_type == "htpasswd": cmd = ("ocm create idp -c {} -t {} -n {} --username {} " "--password {}".format(self.cluster_name, self.idp_type, self.idp_name, self.htpasswd_cluster_admin, self.htpasswd_cluster_password)) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to add identity provider of " "type {}".format(self.idp_type)) self.add_user_to_group() elif (self.idp_type == "ldap"): ldap_yaml_file = (os.path.abspath(os.path.dirname(__file__)) + "/../../../configs/templates/ldap/ldap.yaml") cmd = "oc apply -f {}".format(ldap_yaml_file) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to deploy openldap application") sys.exit(1) replace_vars = { "LDAP_URL": self.ldap_url, "LDAP_BIND_DN": self.ldap_bind_dn, "LDAP_BIND_PASSWORD": self.ldap_bind_password } template_file = "create_ldap_idp.jinja" output_file = "create_ldap_idp.json" self._render_template(template_file, output_file, replace_vars) cluster_id = self.get_osd_cluster_id() cmd = ("ocm post /api/clusters_mgmt/v1/" "clusters/{}/identity_providers " "--body={}".format(cluster_id, output_file)) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to add ldap identity provider") self.add_users_to_rhods_group() time.sleep(300)
def _is_ocmcli_installed(self): """Checks if ocm cli is installed""" cmd = "ocm version" ret = execute_command(cmd) if ret is None: log.info("ocm cli not installed.") return False log.info("ocm cli already installed...") return True
def get_prometheus_url(project): """ Get prometheus url for the cluster. """ host_jsonpath = "{.spec.host}" cmd = "oc get route prometheus -n {} -o jsonpath='{}'".format( project, host_jsonpath) prometheus_url = execute_command(cmd) return "https://" + prometheus_url.strip("\n")
def delete_idp(self): """Deletes Identity Provider""" cmd = ("ocm delete idp -c {} {}".format(self.cluster_name, self.idp_name)) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to delete identity provider of " "type {}".format(self.idp_name))
def upload_result(self): """Uploads test results to report portal""" cmd = ("rp_preproc -c {} -d {} " "--service {} -l {}".format(self.config_file, self.payload_dir, self.service_url, self.log_path)) log.info("CMD: {}".format(cmd)) rp_output = execute_command(cmd) rp_output_json = json.loads(rp_output) self.write_output_file(json.dumps(rp_output_json))
def ocm_describe(self, filter=""): """Describes cluster and returns cluster info""" cmd = "ocm describe cluster {}".format(self.cluster_name) if filter != "": cmd += " " + filter ret = execute_command(cmd) if ret is None: log.info("ocm describe for cluster " "{} failed".format(self.cluster_name)) return None return ret
def list_idps(self): """Lists IDPs for the cluster""" cmd = ("ocm list idps --cluster {} --columns name".format( self.cluster_name)) ret = execute_command(cmd) if ret is None: return [] if ret != []: ret = ret.split('\n')[1:-1] return ret
def delete_cluster(self): """ Delete OSD Cluster""" cluster_id = self.get_osd_cluster_id() cmd = "ocm delete cluster {}".format(cluster_id) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to delete osd cluster {}".format( self.cluster_name)) sys.exit(1) self.wait_for_osd_cluster_to_get_deleted()
def add_users_to_rhods_group(self): """Add users to rhods group""" self.create_group("rhods-admins") # Adds user ldap-admin1..ldap-adminN for i in range(1, int(self.num_users_to_create_per_group) + 1): self.add_user_to_group(user="******" + str(i), group="rhods-admins") self.create_group("rhods-users") # Adds user ldap-user1..ldap-userN for i in range(1, int(self.num_users_to_create_per_group) + 1): self.add_user_to_group(user="******" + str(i), group="rhods-users") # Adds special users # "(", ")", "|", "<", ">" not working in OSD # "+" and ";" disabled for now for char in [".", "^", "$", "*", "?", "[", "]", "{", "}", "@"]: self.add_user_to_group(user="******" + char, group="rhods-users") self.create_group("rhods-noaccess") # Adds user ldap-noaccess1..ldap-noaccessN for i in range(1, int(self.num_users_to_create_per_group) + 1): self.add_user_to_group(user="******" + str(i), group="rhods-noaccess") # Logging users/groups details after adding # given user to group cmd = "oc get users" log.info("CMD: {}".format(cmd)) users_list = execute_command(cmd) log.info("Users present in cluster: {}".format(users_list)) cmd = "oc get groups" log.info("CMD: {}".format(cmd)) groups_list = execute_command(cmd) log.info("Groups present in cluster: {}".format(groups_list))
def uninstall_addon(self, addon_name="managed-odh"): """Uninstalls addon""" addon_state = self.get_addon_state(addon_name) if addon_state != "not installed": cluster_id = self.get_osd_cluster_id() cmd = ("ocm delete /api/clusters_mgmt/v1/clusters/{}/addons/" "{}".format(cluster_id, addon_name)) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to uninstall {} addon on cluster " "{}".format(addon_name, self.cluster_name)) sys.exit(1)
def get_addon_state(self, addon_name="managed-odh"): """Gets given addon's state""" cmd = ("ocm list addons --cluster {} --columns id,state | grep " "{} ".format(self.cluster_name, addon_name)) ret = execute_command(cmd) if ret is None: log.info("Failed to get {} addon state for cluster " "{}".format(addon_name, self.cluster_name)) return None match = re.search(addon_name + '\s*(.*)', ret) if match is None: log.info("regex failed in get_addon_state") return None return match.group(1).strip()
def ocm_login(self): """ Login to OCM using ocm cli""" cmd = "ocm login --token=\"{}\" ".format(self.token) if self.testing_platform == "stage": cmd += "--url=staging" cmd = "OCM_CONFIG=ocm.json." + self.testing_platform + " " + cmd log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to login to aws openshift platform using token") sys.exit(1) os.environ["OCM_CONFIG"] = "ocm.json." + self.testing_platform
def add_user_to_group(self, user="", group="cluster-admins"): """Adds user to given group""" if user == "": user = self.htpasswd_cluster_admin if ((group == "rhods-admins") or (group == "rhods-users") or (group == "rhods-noaccess")): cmd = "oc adm groups add-users {} {}".format(group, user) else: cmd = ("ocm create user {} --cluster {} " "--group={}".format(user, self.cluster_name, group)) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to add user {} to group " "{}".format(user, group))
def do_encrypt(self, args): """ Encrypt an epub file using the *local* lcpencrypt command line """ print("Let's encrypt {}".format(self.epub_path)) # Generate a random content id content_id = str(uuid.uuid4()) # Generate a target file path output_filename = "{}-{}.crypt.epub".format(self.epub_filename, content_id) output_file_path = os.path.join(self.config.encrypted_file_path, output_filename) # Execute the encryption using the lcpencrypt utility return_code, stdout, stderr = util.execute_command([ self.config.encrypt_cmd_path, '-input', self.epub_path, '-contentid', content_id, '-output', output_file_path ]) if return_code != 0: print("Encryption failed, err {}".format(return_code)) print(stderr) return # Parse the resulting json message result = json.loads(stdout.decode("utf-8")) self.encrypted_content_id = result["content-id"] self.encrypted_content_encryption_key = result[ "content-encryption-key"] self.encrypted_content_filename = result[ "protected-content-disposition"] self.encrypted_content_location = result["protected-content-location"] self.encrypted_content_length = result["protected-content-length"] self.encrypted_content_sha256 = result["protected-content-sha256"] print("Content id {}".format(self.encrypted_content_id)) print("Encrypted Content filename {}".format( self.encrypted_content_filename)) print("Encrypted Content location {}".format( self.encrypted_content_location)) print("Encrypted Content length {}".format( self.encrypted_content_length))
def install_addon(self, addon_name="managed-odh"): """Installs addon""" replace_vars = { "CLUSTER_ID": self.cluster_name, "ADDON_NAME": addon_name } template_file = "install_addon.jinja" output_file = "install_operator.json" self._render_template(template_file, output_file, replace_vars) cluster_id = self.get_osd_cluster_id() cmd = ("ocm post /api/clusters_mgmt/v1/clusters/{}/addons " "--body={}".format(cluster_id, output_file)) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to install {} addon on cluster " "{}".format(addon_name, self.cluster_name)) sys.exit(1)
def osd_cluster_create(self): """Creates OSD cluster""" if ((self.channel_group == "candidate") and (self.testing_platform == "prod")): log.error( "Channel group 'candidate' is available only for stage environment." ) sys.exit(1) version = "" if self.openshift_version != "": version_match = re.match(r'(\d+\.\d+)\-latest', self.openshift_version) if version_match is not None: version = version_match.group(1) chan_grp = "" if (self.channel_group == "candidate"): chan_grp = "--channel-group {}".format(self.channel_group) version_cmd = "ocm list versions {} | grep -w \"".format( chan_grp) + re.escape(version) + "*\"" log.info("CMD: {}".format(version_cmd)) versions = execute_command(version_cmd) if versions is not None: version = [ver for ver in versions.split("\n") if ver][-1] self.openshift_version = version else: log.info("Using the osd version given by user as it is...") version = "--version {} ".format(self.openshift_version) else: log.info("Using the latest osd version available in AWS...") channel_grp = "" if (self.channel_group != ""): if ((self.channel_group == "stable") or (self.channel_group == "candidate")): if version == "": log.error(( "Please enter openshift version as argument." "Channel group option is used along with openshift version." )) sys.exit(1) else: channel_grp = "--channel-group {} ".format( self.channel_group) else: log.error( "Invalid channel group. Values can be 'stable' or 'candidate'." ) cmd = ("ocm create cluster --aws-account-id {} " "--aws-access-key-id {} --aws-secret-access-key {} " "--ccs --region {} --compute-nodes {} " "--compute-machine-type {} {} {}" "{}".format(self.aws_account_id, self.aws_access_key_id, self.aws_secret_access_key, self.aws_region, self.num_compute_nodes, self.aws_instance_type, version, channel_grp, self.cluster_name)) log.info("CMD: {}".format(cmd)) ret = execute_command(cmd) if ret is None: log.info("Failed to create osd cluster {}".format( self.cluster_name)) sys.exit(1)