components class added

Author: katzy687

cloudshell/__pycache__/__init__.cpython-37.pyc

@@ -0,0 +1,96 @@
+"""
+Helper functions to poll the state of sandbox setup or the execution status of a command.
+Using 'retrying' library to do polling:
+https://pypi.org/project/retrying/
+"""
+from typing import List, Callable
+from retrying import retry  # pip install retrying
+from cloudshell.sandbox_rest.sandbox_api import SandboxRestApiClient
+from enum import Enum
+
+
+class SandboxStates(Enum):
+    before_setup_state = "BeforeSetup"
+    running_setup_state = "Setup"
+    error_state = "Error"
+    ready_state = "Ready"
+    teardown_state = "Teardown"
+    ended_state = "Ended"
+
+
+class ExecutionStatuses(Enum):
+    running_status = "Running"
+    pending_status = "Pending"
+    completed_status = "Completed"
+    failed_status = "Failed"
+
+
+UNFINISHED_EXECUTION_STATUSES = [ExecutionStatuses.running_status.value,
+                                 ExecutionStatuses.pending_status.value]
+
+
+def _should_we_keep_polling_setup(sandbox_details: dict) -> bool:
+    """ if still in setup keep polling """
+    setup_states = [SandboxStates.before_setup_state.value, SandboxStates.running_setup_state.value]
+    if sandbox_details["state"] in setup_states:
+        return True
+    return False
+
+
+def _should_we_keep_polling_teardown(sandbox_details: dict) -> bool:
+    """ if in teardown keep polling """
+    if sandbox_details["state"] == SandboxStates.teardown_state.value:
+        return True
+    return False
+
+
+def _poll_sandbox_state(api: SandboxRestApiClient, reservation_id: str, polling_func: Callable,
+                        max_polling_minutes: int, polling_frequency_seconds: int) -> str:
+    """ Create blocking polling process """
+
+    # retry wait times are in milliseconds
+    @retry(retry_on_result=polling_func, wait_fixed=polling_frequency_seconds * 1000,
+           stop_max_delay=max_polling_minutes * 60000)
+    def get_sandbox_details():
+        return api.get_sandbox_details(reservation_id)
+
+    return get_sandbox_details()
+
+
+def poll_sandbox_setup(api: SandboxRestApiClient, reservation_id: str, max_polling_minutes=20,
+                       polling_frequency_seconds=30) -> dict:
+    """ poll until completion """
+    sandbox_details = _poll_sandbox_state(api, reservation_id, _should_we_keep_polling_setup, max_polling_minutes,
+                                          polling_frequency_seconds)
+    return sandbox_details
+
+
+def poll_sandbox_teardown(api: SandboxRestApiClient, reservation_id: str, max_polling_minutes=20,
+                          polling_frequency_seconds=30) -> dict:
+    """ poll until completion  """
+    sandbox_details = _poll_sandbox_state(api, reservation_id, _should_we_keep_polling_teardown, max_polling_minutes,
+                                          polling_frequency_seconds)
+    return sandbox_details
+
+
+def _should_we_keep_polling_execution(exc_data: dict) -> bool:
+    current_exc_status = exc_data["status"]
+    if current_exc_status in UNFINISHED_EXECUTION_STATUSES:
+        return True
+    return False
+
+
+def poll_execution_for_completion(sandbox_rest: SandboxRestApiClient, command_execution_id: str,
+                                  max_polling_in_minutes=20, polling_frequency_in_seconds=30) -> str:
+    """
+    poll execution for "Completed" status, then return the execution output
+    """
+    # retry wait times are in milliseconds
+    @retry(retry_on_result=_should_we_keep_polling_execution, wait_fixed=polling_frequency_in_seconds * 1000,
+           stop_max_delay=max_polling_in_minutes * 60000)
+    def get_execution_data():
+        exc_data = sandbox_rest.get_execution_details(command_execution_id)
+        return exc_data
+    return get_execution_data(sandbox_rest, command_execution_id)
+
+

cloudshell/sandbox_rest/__pycache__/exceptions.cpython-37.pyc

@@ -3,7 +3,21 @@
 from typing import List
 import requests
 from dataclasses import dataclass, asdict
-from cloudshell.sandbox_rest.exceptions import SandboxRestException, SandboxRestAuthException
+
+
+class SandboxRestException(Exception):
+    """ General exception to raise inside Rest client class """
+    pass
+
+
+class SandboxRestAuthException(Exception):
+    """ Failed auth actions """
+    pass
+
+
+class SandboxRestInitException(ValueError):
+    """ Failed auth actions """
+    pass
 
 
 @dataclass
@@ -16,7 +30,7 @@ class InputParam:
     value: str
 
 
-class SandboxRestApiClient:
+class SandboxRestApiSession:
     """
     Python wrapper for CloudShell Sandbox API
     View http://<API_SERVER>/api/v2/explore to see schemas of return json values
@@ -207,7 +221,6 @@ def stop_sandbox(self, sandbox_id: str):
         response = requests.post(f'{self._versioned_url}/sandboxes/{sandbox_id}/stop', headers=self._auth_headers)
         if not response.ok:
             raise SandboxRestException(self._format_err(response, f"Failed to stop sandbox '{sandbox_id}'"))
-        return response.json()
 
     # SANDBOX GET REQUESTS
     def get_sandboxes(self, show_historic=False):
@@ -405,15 +418,17 @@ def delete_execution(self, execution_id: str):
     ADMIN_USER = "admin"
     ADMIN_PASS = "admin"
 
-    admin_api = SandboxRestApiClient(host=API_SERVER, username=ADMIN_USER, password=ADMIN_PASS)
+    admin_api = SandboxRestApiSession(host=API_SERVER, username=ADMIN_USER, password=ADMIN_PASS)
     with admin_api:
         # sample api call with admin user session to get all sandboxes
-        all_sandboxes = admin_api.get_sandboxes()
-        print("== List of sandboxes pulled by Admin ===")
-        print(json.dumps(all_sandboxes, indent=4))
+        # all_sandboxes = admin_api.get_sandboxes()
+        # print("== List of sandboxes pulled by Admin ===")
+        # print(json.dumps(all_sandboxes, indent=4))
+
+        sb_res = admin_api.start_sandbox(blueprint_id="rest test", sandbox_name="rest test")
+        print(sb_res["state"])
+        time.sleep(4)
+
 
-    admin_api.refresh_auth()
-    all_sandboxes = admin_api.get_sandboxes()
-    pass
 
 

cloudshell/sandbox_rest/__pycache__/sandbox_api.cpython-37.pyc

@@ -0,0 +1,98 @@
+import json
+from typing import List
+from enum import Enum
+
+
+class ComponentTypes(Enum):
+    app_type = "Application"
+    resource_type = "Resource"
+    service_type = "Service"
+
+
+class AppLifeCycleTypes(Enum):
+    deployed = "Deployed"
+    un_deployed = "Undeployed"
+
+
+class AttributeTypes(Enum):
+    boolean_type = "boolean"
+    password_type = "password"
+    string_type = "string"
+    numeric_type = "numeric"
+
+
+class SandboxRestComponents:
+    def __init__(self, components: List[dict] = None):
+        """
+        if instantiated with components then populate lists
+        if not, then call "refresh_components" after getting data from sandbox
+         """
+        self.all_components = components if components else []
+        self.services = []
+        self.resources = []
+        self.deployed_apps = []
+        self.un_deployed_apps = []
+        if self.all_components:
+            self._sort_components()
+
+    def _filter_components_by_type(self, component_type: str) -> List[dict]:
+        """ accepts both short info components and full info """
+        return [component for component in self.all_components if component["type"] == component_type]
+
+    def _filter_app_by_lifecycle(self, lifecycle_type):
+        return [component for component in self.all_components
+                if component["type"] == ComponentTypes.app_type.value
+                and component["app_lifecyle"] == lifecycle_type]
+
+    def _sort_components(self) -> None:
+        """ sort stored components into separate lists """
+        self.resources = self._filter_components_by_type(ComponentTypes.resource_type.value)
+        self.services = self._filter_components_by_type(ComponentTypes.service_type.value)
+        self.deployed_apps = self._filter_app_by_lifecycle(AppLifeCycleTypes.deployed.value)
+        self.un_deployed_apps = self._filter_app_by_lifecycle(AppLifeCycleTypes.un_deployed.value)
+
+    def refresh_components(self, components: List[dict]) -> None:
+        self.all_components = components
+        self._sort_components()
+
+    def find_component_by_name(self, component_name: str) -> dict:
+        for component in self.all_components:
+            if component["name"] == component_name:
+                return component
+
+    @staticmethod
+    def filter_by_model(components: List[dict], model: str) -> List[dict]:
+        """
+        Can pass in all components or sub list
+        Both Resources and Applications can use same shell / model
+        """
+        return [component for component in components if component["component_type"] == model]
+
+    def filter_by_attr_value(self, components: List[dict], attribute_name: str, attribute_value: str) -> List[dict]:
+        """ attribute name does not have to include model / family namespace """
+        self._validate_components_for_attributes(components)
+        result = []
+        for component in components:
+            for attr in component["attributes"]:
+                if attr["name"].endswith(attribute_name) and attr["value"] == attribute_value:
+                    result.append(component)
+        return result
+
+    def filter_by_boolean_attr_true(self, components: List[dict], attribute_name: str) -> List[dict]:
+        """ attribute name does not have to include model / family namespace """
+        self._validate_components_for_attributes(components)
+        result = []
+        for component in components:
+            for attr in component["attributes"]:
+                if attr["name"].endswith(attribute_name) and attr["value"].lower() == "true":
+                    result.append(component)
+        return result
+
+    @staticmethod
+    def _validate_components_for_attributes(components: List[dict]):
+        if not components:
+            return
+        attrs = components[0].get("attributes")
+        if not attrs:
+            raise Exception("'attributes' member not found. Must pass in Full info components.\n"
+                            f"components data passed:\n{json.dumps(components, indent=4)}")

cloudshell/sandbox_rest/exceptions.py

@@ -0,0 +1,89 @@
+import json
+import logging
+from typing import List
+
+from cloudshell.sandbox_rest.sandbox_api import SandboxRestApiSession, InputParam
+from cloudshell.sandbox_rest.helpers import polling_helpers as poll_help
+
+
+class SandboxSetupError(Exception):
+    """ When sandbox has error during setup """
+    pass
+
+
+class SandboxTeardownError(Exception):
+    """ When sandbox has error during setup """
+    pass
+
+
+class CommandFailedException(Exception):
+    pass
+
+
+# TODO:
+# add context manager methods
+# review design of class
+# add logger
+# publish env vars
+
+
+class SandboxRestController:
+    def __init__(self, api: SandboxRestApiSession, sandbox_id="", log_file_handler=False):
+        self.api = api
+        self.sandbox_id = sandbox_id
+        self.logger = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def start_sandbox_and_poll(self, blueprint_id: str, sandbox_name="", duration="PT1H30M",
+                               bp_params: List[InputParam] = None, permitted_users: List[str] = None,
+                               max_polling_minutes=30) -> dict:
+        """ Start sandbox, poll for result, get back sandbox info """
+        start_response = self.api.start_sandbox(blueprint_id, sandbox_name, duration, bp_params, permitted_users)
+        sb_id = start_response["id"]
+        sandbox_details = poll_help.poll_sandbox_setup(self.api, sb_id, max_polling_minutes,
+                                                       polling_frequency_seconds=30)
+
+        sandbox_state = sandbox_details["state"]
+        stage = sandbox_details["setup_stage"]
+        name = sandbox_details["name"]
+
+        if "error" in sandbox_state.lower():
+            activity_errors = self._get_all_activity_errors(sb_id)
+
+            # TODO: print this? log it? or dump into exception message?
+            if activity_errors:
+                print(f"=== Activity Feed Errors ===\n{json.dumps(activity_errors, indent=4)}")
+
+            err_msg = (f"Sandbox '{name}' Error during SETUP.\n"
+                       f"Stage: '{stage}'. State '{sandbox_state}'. Sandbox ID: '{sb_id}'")
+            raise SandboxSetupError(err_msg)
+        return sandbox_details
+
+    def stop_sandbox_and_poll(self, sandbox_id: str, max_polling_minutes=30) -> dict:
+        self.api.stop_sandbox(sandbox_id)
+        sandbox_details = poll_help.poll_sandbox_teardown(self.api, sandbox_id, max_polling_minutes,
+                                                          polling_frequency_seconds=30)
+        sandbox_state = sandbox_details["state"]
+        stage = sandbox_details["setup_stage"]
+        name = sandbox_details["name"]
+
+        if "error" in sandbox_state.lower():
+            tail_error_count = 5
+            tailed_errors = self.api.get_sandbox_activity(sandbox_id, error_only=True, tail=tail_error_count)["events"]
+            print(f"=== Last {tail_error_count} Errors ===\n{json.dumps(tailed_errors, indent=4)}")
+            err_msg = (f"Sandbox '{name}' Error during SETUP.\n"
+                       f"Stage: '{stage}'. State '{sandbox_state}'. Sandbox ID: '{sandbox_id}'")
+            raise SandboxTeardownError(err_msg)
+        return sandbox_details
+
+    def _get_all_activity_errors(self, sandbox_id):
+        activity_results = self.api.get_sandbox_activity(sandbox_id, error_only=True)
+        return activity_results["events"]
+
+    def publish_sandbox_id_to_env_vars(self):
+        pass