added custom sample to find sandbox id from launched job

Author: katzy687

generic-orchestration-samples/setup/setup_update_public_ips/DEBUG.py

@@ -0,0 +1,16 @@
+from cloudshell.workflow.orchestration.sandbox import Sandbox
+from cloudshell.helpers.scripts.cloudshell_dev_helpers import attach_to_cloudshell_as
+import credentials
+from config_ginger import configure_ginger_agents
+
+LIVE_SANDBOX_ID = "bda46630-f777-401c-a27e-c055f6e6732b"
+
+attach_to_cloudshell_as(user=credentials.USER,
+                        password=credentials.PASSWORD,
+                        domain=credentials.DOMAIN,
+                        reservation_id=LIVE_SANDBOX_ID,
+                        server_address=credentials.SERVER)
+
+sandbox = Sandbox()
+configure_ginger_agents(sandbox)
+pass

generic-orchestration-samples/setup/setup_update_public_ips/README.md

@@ -0,0 +1,18 @@
+# Setup eDTM
+Setup will provision and register Ginger Execution agents to the Agent Handler URL. 
+
+## Setup Flow
+1. Provision one Linux VM per Execution Agent
+2. Run config script to Install Docker
+3. Read IP of agent handler from sandbox and pass into config script to run container and register with handler
+
+## NOTES
+Run container config script param:
+- EXECUTION_HANDLER_URL
+
+Docker install script:
+https://raw.githubusercontent.com/docker/docker-install/master/rootless-install.sh
+
+Ginger install script:
+https://raw.githubusercontent.com/QualiSystemsLab/App-Configuration-Demo-Scripts/master/ginger/register_ginger.sh
+

generic-orchestration-samples/setup/setup_update_public_ips/__main__.py

@@ -0,0 +1,9 @@
+from cloudshell.workflow.orchestration.setup.default_setup_orchestrator import DefaultSetupWorkflow
+from cloudshell.workflow.orchestration.sandbox import Sandbox
+from set_public_ips import set_public_ip_flow
+
+sandbox = Sandbox()
+
+DefaultSetupWorkflow().register(sandbox)
+sandbox.workflow.on_connectivity_ended(set_public_ip_flow)
+sandbox.execute_setup()

generic-orchestration-samples/setup/setup_update_public_ips/requirements.txt

@@ -0,0 +1,2 @@
+cloudshell-orch-core
+cloudshell-sandbox-reporter

generic-orchestration-samples/setup/setup_update_public_ips/set_public_ips.py

@@ -0,0 +1,30 @@
+from cloudshell.workflow.orchestration.sandbox import Sandbox
+from cloudshell.helpers.sandbox_reporter.reporter import SandboxReporter
+
+
+PUBLIC_IP_ATTR = "Public IP"
+
+
+def set_public_ip_flow(sandbox, components=None):
+    """
+    run all other playbooks on apps besides the router ones
+    :param Sandbox sandbox:
+    """
+    api = sandbox.automation_api
+    res_id = sandbox.id
+    logger = sandbox.logger
+    reporter = SandboxReporter(api, res_id, logger)
+    resources = api.GetReservationDetails(res_id, True).ReservationDescription.Resources
+
+    for resource in resources:
+        res_details = api.GetResourceDetails(resource.Name)
+        attrs = res_details.ResourceAttributes
+        attrs_dict = {x.Name: x.Value for x in attrs}
+        public_ip = attrs_dict.get(PUBLIC_IP_ATTR)
+        if public_ip:
+            reporter.warning(f"Updating address to public IP on {resource.Name}")
+            api.UpdateResourceAddress(resourceFullPath=resource.Name, resourceAddress=public_ip)
+
+    reporter.info("set public IP flow done", console_print=False)
+
+

generic-orchestration-samples/setup/setup_update_public_ips/update_script.py

@@ -0,0 +1,107 @@
+"""
+NOTE: - This script is only for updating EXISTING scripts.
+      - Scripts MUST be uploaded manually first time. (this tool can still be used to do zipping)
+"""
+from cloudshell.api.cloudshell_api import CloudShellAPISession
+import os
+import credentials  # may need to create this module and set the constants for the api session
+
+# ===== Optional Variables to set =======
+
+# To name zip package something other than the default directory name
+CUSTOM_SCRIPT_NAME = ''
+
+
+# =======================================
+
+
+def get_api_session():
+    return CloudShellAPISession(host=credentials.SERVER,
+                                username=credentials.USER,
+                                password=credentials.PASSWORD,
+                                domain=credentials.DOMAIN)
+
+
+def error_red(err_str):
+    """
+    for printing errors in red in pycharm.
+    :param err_str:
+    :return:
+    """
+    CRED = '\033[91m'
+    CEND = '\033[0m'
+    return CRED + err_str + CEND
+
+
+def get_zip_details():
+    parent_dir_path = os.path.abspath('.')
+    parent_dir_name = os.path.basename(parent_dir_path)
+    script_name = CUSTOM_SCRIPT_NAME or parent_dir_name
+    zip_file_name = script_name + '.zip'
+
+    return {"parent_dir_path": parent_dir_path,
+            "parent_dir_name": parent_dir_name,
+            "script_name": script_name,
+            "zip_file_name": zip_file_name}
+
+
+def is_whitelisted(f, file_path, files_to_exclude):
+    is_regular_file = os.path.isfile(file_path)
+    is_not_excluded = f not in files_to_exclude
+    is_not_pyc = not f.endswith('.pyc')
+    return is_regular_file and is_not_excluded and is_not_pyc
+
+
+def make_zipfile(output_filename, source_dir, files_to_exclude, dirs_to_exclude):
+    import zipfile
+    with zipfile.ZipFile(output_filename, "w", zipfile.ZIP_DEFLATED) as z:
+        for root, dirs, files in os.walk(source_dir):
+            dirs[:] = [d for d in dirs if d not in dirs_to_exclude]
+            for f in files:
+                file_path = os.path.join(root, f)
+                if is_whitelisted(f, file_path, files_to_exclude):
+                    arcname = os.path.join(os.path.relpath(root, source_dir), f)
+                    z.write(file_path, arcname)
+
+
+def zip_files():
+    zip_details = get_zip_details()
+    zip_file_name = zip_details["zip_file_name"]
+    dirs_to_exclude = [".git"]
+    files_to_exclude = [zip_file_name, "venv", ".idea", "credentials.py"]
+    try:
+        make_zipfile(output_filename=zip_file_name,
+                     source_dir=zip_details["parent_dir_path"],
+                     files_to_exclude=files_to_exclude,
+                     dirs_to_exclude=dirs_to_exclude)
+    except Exception as e:
+        print(error_red("[-] error zipping up file: " + str(e)))
+        exit(1)
+    else:
+        if zip_file_name in os.listdir("."):
+            print("[+] ZIPPED UP: '{zip_name}'".format(zip_name=zip_file_name))
+        else:
+            print("[-] ZIP FILE NOT PRESENT")
+
+
+def update_script_api_wrapper(cs_ses, script_name, zip_address):
+    try:
+        cs_ses.UpdateScript(script_name, zip_address)
+    except Exception as e:
+        print(error_red("[-] ERROR UPDATING SCRIPT IN PORTAL\n" + str(e)) + "\n"
+                                                                            "PLEASE LOAD SCRIPT MANUALLY THE FIRST TIME")
+        exit(1)
+    else:
+        print("[+] '{script}' updated on CloudShell Successfully".format(script=script_name))
+
+
+def update_script_on_server():
+    zip_files()
+    cs_ses = get_api_session()
+    zip_details = get_zip_details()
+    update_script_api_wrapper(cs_ses=cs_ses,
+                              script_name=zip_details["script_name"],
+                              zip_address=zip_details["zip_file_name"])
+
+
+update_script_on_server()

quali_api/start-suite-get-sandbox-id/enqueue_suite_get_sandbox_id.py

@@ -0,0 +1,64 @@
+"""
+This script is a method to obtain sandbox id of newly formed job.
+Methodology is to pass in a UUID as global input, then to query sandbox id for sandbox with matching input value
+NOTE: Sandbox Api server may not be hosted on quali server, it is typically hosted together with Portal server
+https://help.quali.com/Online%20Help/0.0/Portal/Content/IG/Overview/cs-reqd-ports.htm?Highlight=ports
+"""
+import time
+
+from quali_api_wrapper import QualiAPISession
+from sandbox_rest_api import SandboxRest
+import json
+from timeit import default_timer
+
+
+def get_sandbox_id_from_job(quali_api: QualiAPISession, sandbox_api: SandboxRest,
+                            suite_data: dict, global_input_name: str, global_input_value: str):
+    print(f"starting new job, passing '{global_input_value}' as custom UUID")
+
+    # pass in custom global value - assuming only 1 job per suite
+    global_inputs = suite_data["JobsDetails"][0]["Topology"]["GlobalInputs"]
+    target_input = [x for x in global_inputs if x["Name"] == global_input_name][0]
+    target_input["Value"] = global_input_value
+
+    # start new suite with quali pai
+    suite_id = quali_api.enqueue_suite(suite_data=suite_data)
+    print(f"suite started: {suite_id}")
+
+    # give DB a few seconds to propagate new sandbox
+    time.sleep(3)
+
+    # query sandbox api for matching sandbox
+    print("searching for job's sandbox...")
+    start = default_timer()
+    all_sandboxes = sandbox_api.get_sandboxes()
+    for sandbox in all_sandboxes:
+        sandbox_details = sandbox_api.get_sandbox_data(sandbox_id=sandbox["id"])
+        global_inputs = sandbox_details["parameters"]
+        target_global = [x for x in global_inputs if x["Name"] == global_input_name]
+        if not target_global:
+            continue
+        target_value = target_global[0]["Value"]
+        if target_value == global_input_value:
+            print(f"sandbox id found after '{default_timer() - start}' seconds")
+            return sandbox["id"]
+
+
+if __name__ == "__main__":
+    SUITE_JSON_PATH = 'suite_data.json'
+    TARGET_GLOBAL_PARAM_NAME = "my_uuid"
+    TARGET_GLOBAL_PARAM_VALUE = "123456789"
+
+    quali_api = QualiAPISession(host="localhost", username="admin", password="admin", domain="Global")
+    sandbox_api = SandboxRest(server="localhost", username="admin", password="admin", domain="Global")
+
+    # read in suite json
+    with open(SUITE_JSON_PATH) as handle:
+        suite_data_dict = json.loads(handle.read())
+
+    sandbox_id = get_sandbox_id_from_job(quali_api=quali_api,
+                                         sandbox_api=sandbox_api,
+                                         suite_data=suite_data_dict,
+                                         global_input_name=TARGET_GLOBAL_PARAM_NAME,
+                                         global_input_value=TARGET_GLOBAL_PARAM_VALUE)
+    print(f"sandbox id: {sandbox_id}")