update the log error messages and execute of cmd and output (#1234)

1. when we exit with sys.exit(1) the line before should be log.error
instead of log.info
2. format with f-string which is more readable
3. in the method execute_command(cmd) log the cmd and the output instead
of doing that multiple times in the code

I faced these issues as part of jira ticket: RHOAIENG-2683

ods_ci/libs/Helpers.py

@@ -63,7 +63,7 @@ def get_cluster_name(self, cluster_identifier):
         ocm_client = OpenshiftClusterManager()
         # to manipulate ocm_describe on line 45
         ocm_client.cluster_name = cluster_identifier
-        cluster_name = ocm_client.ocm_describe(filter="--json | jq -r '.name'")
+        cluster_name = ocm_client.ocm_describe(jq_filter="--json | jq -r '.name'")
         cluster_name = cluster_name.strip("\n")
         return cluster_name
 

ods_ci/utils/scripts/awsOps.py

@@ -1,42 +1,23 @@
-from logging import log
 from time import sleep
 
+from logger import log
 from util import execute_command
 
 
-def aws_configure(aws_access_key_id, aws_secret_access_key, aws_region):
-    """
-    Runs aws configure and set the configuration required
-    for OpenShift/ROSA Installation
-    """
-    cmd_aws_configure_key_id = [
-        "aws",
-        "configure",
-        "set",
-        "default.aws_access_key_id",
-        aws_access_key_id,
-    ]
-    ret = execute_command(" ".join(cmd_aws_configure_key_id))
+def aws_configure_execute_cmd(aws_key, aws_value, aws_profile):
+    aws_configure_cmd = ["aws", "configure", "set", aws_key, aws_value, "--profile", aws_profile]
+    ret = execute_command(" ".join(aws_configure_cmd))
     if ret is None:
-        print("Failed  to configure aws_access_key_id")
+        log.error(f"Failed to configure {aws_key}")
         return ret
     sleep(1)
 
-    cmd_aws_configure_access_id = [
-        "aws",
-        "configure",
-        "set",
-        "default.aws_secret_access_key",
-        aws_secret_access_key,
-    ]
-    ret = execute_command(" ".join(cmd_aws_configure_access_id))
-    if ret is None:
-        print("Failed  to configure aws_secret_access_key")
-        return ret
-    sleep(1)
 
-    cmd_aws_configure_region = ["aws", "configure", "set", "default.region", aws_region]
-    ret = execute_command(" ".join(cmd_aws_configure_region))
-    if ret is None:
-        print("Failed  to configure region")
-        return ret
+def aws_configure(aws_access_key_id, aws_secret_access_key, aws_region, aws_profile="default"):
+    """
+    Runs aws configure and set the configuration required
+    for OpenShift/ROSA Installation
+    """
+    aws_configure_execute_cmd(aws_key="aws_access_key_id", aws_value=aws_access_key_id, aws_profile=aws_profile)
+    aws_configure_execute_cmd(aws_key="aws_secret_access_key", aws_value=aws_secret_access_key, aws_profile=aws_profile)
+    aws_configure_execute_cmd(aws_key="region", aws_value=aws_region, aws_profile=aws_profile)

ods_ci/utils/scripts/openshift/openshift.py

@@ -34,15 +34,13 @@ def _generate_ssh_key(self):
         """
         Generates ssh key required for OpenShift Installation
         """
-        cmd = "ssh-keygen -t rsa -b 4096 -N '' -f {}/id_rsa".format(self.work_dir)
-        log.info("CMD: {}".format(cmd))
+        cmd = f"ssh-keygen -t rsa -b 4096 -N '' -f {self.work_dir}/id_rsa"
         ret = execute_command(cmd)
         if ret is None:
             log.error("Failed to generate ssh key")
             return None
 
-        cmd = 'eval "$(ssh-agent -s)";' + "ssh-add {}/id_rsa".format(self.work_dir)
-        log.info("CMD: {}".format(cmd))
+        cmd = f'eval "$(ssh-agent -s)"; ssh-add {self.work_dir}/id_rsa'
         ret = execute_command(cmd)
         if ret is None:
             log.error("Failed to eval ssh-agent and to add ssh rsa key")
@@ -162,7 +160,7 @@ def openshift_install(self, config_file="cluster_config.yaml"):
             log.error("Unexpected console logs in openshift-install create cluster output")
             sys.exit(1)
 
-        log.info("OpenShift Cluster {} created successfully !".format(self.cluster_name))
+        log.info(f"OpenShift Cluster {self.cluster_name} created successfully !")
 
         cluster_info = {}
         cluster_info["CLUSTER_NAME"] = self.cluster_name
@@ -187,7 +185,6 @@ def openshift_destroy(self):
             sys.exit(1)
 
         cmd = "openshift-install destroy cluster"
-        log.info("CMD: {}".format(cmd))
         ret = execute_command(cmd)
         if ret is None:
             log.error("Failed to destroy openshift cluster")

ods_ci/utils/scripts/reportportal/rp_uploader.py

@@ -46,7 +46,6 @@ def upload_result(self):
         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.dumps(rp_output)
         self.write_output_file(json.dumps(rp_output_json))

ods_ci/utils/scripts/rosa/rosa.py

@@ -6,31 +6,33 @@
 sys.path.append(dir_path + "/../")
 from awsOps import aws_configure
 from logger import log
-from rosaOps import create_account_roles, rosa_create_cluster, wait_for_osd_cluster_to_be_ready
+from rosaOps import create_account_roles, rosa_create_cluster, rosa_whoami, wait_for_osd_cluster_to_be_ready
 
 
 class RosaClusterManager:
     def __init__(self, args={}):
         self.aws_access_key_id = args.get("aws_access_key_id")
         self.aws_secret_access_key = args.get("aws_secret_access_key")
         self.aws_region = args.get("aws_region")
-        self.profile = args.get("profile")
+        self.aws_profile = args.get("aws_profile")
         self.cluster_name = args.get("cluster_name")
         self.compute_nodes = args.get("compute_nodes")
         self.compute_machine_type = args.get("compute_machine_type")
         self.rosa_version = args.get("rosa_version")
         self.channel_name = args.get("channel_name")
 
     def create_rosa_cluster(self):
-        print(
-            self.cluster_name,
-            self.aws_region,
-            self.channel_name,
-            self.compute_nodes,
-            self.compute_machine_type,
-            self.rosa_version,
+        log.info(
+            "Creating ROSA cluster with the following details:\n"
+            f"Name: {self.cluster_name}\n"
+            f"Region: {self.aws_region}\n"
+            f"Channel: {self.channel_name}\n"
+            f"Compute Nodes: {self.compute_nodes}\n"
+            f"Compute machine type: {self.compute_machine_type}\n"
+            f"Rosa version: {self.rosa_version}\n"
         )
-        aws_configure(self.aws_access_key_id, self.aws_secret_access_key, self.aws_region)
+        aws_configure(self.aws_access_key_id, self.aws_secret_access_key, self.aws_region, self.aws_profile)
+        rosa_whoami()
         create_account_roles()
         rosa_create_cluster(
             self.cluster_name,
@@ -51,67 +53,76 @@ def main():
 
     # Argument parsers for create_cluster
     subparsers = parser.add_subparsers(title="Available sub commands", help="sub-command help")
-    rosaClusterCreate_parser = subparsers.add_parser(
+    rosa_cluster_create_parser = subparsers.add_parser(
         "create_rosa_cluster",
-        help=("create ROSA clusters using openshift installer"),
+        help="create ROSA clusters using openshift installer",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
     )
-    rosaClusterCreate_parser.add_argument(
+
+    rosa_cluster_create_parser.add_argument(
         "--aws-access-key-id",
         required=True,
         action="store",
         dest="aws_access_key_id",
         help="AWS access key ID",
     )
 
-    rosaClusterCreate_parser.add_argument(
+    rosa_cluster_create_parser.add_argument(
         "--aws-secret-access-key",
         required=True,
         action="store",
         dest="aws_secret_access_key",
         help="AWS secret access key",
     )
 
-    rosaClusterCreate_parser.add_argument(
+    rosa_cluster_create_parser.add_argument(
         "--aws_region",
         required=True,
         action="store",
         dest="aws_region",
         help="AWS aws_region",
     )
 
-    rosaClusterCreate_parser.add_argument(
+    rosa_cluster_create_parser.add_argument(
+        "--aws_profile",
+        required=False,
+        action="store",
+        dest="aws_profile",
+        help="AWS aws_profile",
+    )
+
+    rosa_cluster_create_parser.add_argument(
         "--cluster-name",
         required=True,
         action="store",
         dest="cluster_name",
         help="ROSA cluster name",
     )
 
-    rosaClusterCreate_parser.add_argument(
+    rosa_cluster_create_parser.add_argument(
         "--compute_nodes",
         required=True,
         action="store",
         dest="compute_nodes",
         help="Number of compute nodes",
     )
 
-    rosaClusterCreate_parser.add_argument(
+    rosa_cluster_create_parser.add_argument(
         "--compute-machine-type",
         required=True,
         action="store",
         dest="compute_machine_type",
         help="Compute machine type",
     )
 
-    rosaClusterCreate_parser.add_argument(
+    rosa_cluster_create_parser.add_argument(
         "--osd-version",
         required=True,
         action="store",
         dest="rosa_version",
         help="ROSA version",
     )
-    rosaClusterCreate_parser.add_argument(
+    rosa_cluster_create_parser.add_argument(
         "--channel-name",
         required=True,
         action="store",
@@ -120,7 +131,7 @@ def main():
     )
     rosa_cluster_manager = RosaClusterManager()
 
-    rosaClusterCreate_parser.set_defaults(func=rosa_cluster_manager.create_rosa_cluster)
+    rosa_cluster_create_parser.set_defaults(func=rosa_cluster_manager.create_rosa_cluster)
     args = parser.parse_args(namespace=rosa_cluster_manager)
     if hasattr(args, "func"):
         args.func()