added components module

Author: katzy687

src/cloudshell/sandbox_rest/api.py

@@ -13,11 +13,9 @@
 from tenacity import RetryError, retry, retry_if_result, stop_after_delay, wait_fixed
 
 from cloudshell.sandbox_rest import exceptions, model
-from cloudshell.sandbox_rest.default_logger import set_up_default_logger
 from pydantic.main import ValidationError
 
 
-
 @dataclass
 class CommandInputParam:
     """
@@ -50,7 +48,7 @@ def __init__(
             show_insecure_warning=False
     ):
         """ Login to api and store headers for future requests """
-        self.logger = logger or set_up_default_logger()
+        self.logger = logger
         super().__init__(host, username, password, token, logger, port, use_https, ssl_verify, proxies, show_insecure_warning)
         self.domain = domain
         self._base_uri = "/api"
@@ -243,7 +241,7 @@ def run_sandbox_command(
             max_polling_minutes: int = 20,
             polling_frequency_seconds: int = 10,
             polling_log_level: int = logging.DEBUG
-    ) -> model.EnvironmentCommandExecutionDetails:
+    ) -> model.SandboxCommandExecutionDetails:
         """Run a sandbox level command"""
         self._validate_auth_header()
         uri = f"{self._v2_base_uri}/sandboxes/{sandbox_id}/commands/{command_name}/start"
@@ -253,7 +251,7 @@ def run_sandbox_command(
         response_dict = self.rest_service.request_post(uri, data).json()
         start_response = model.CommandStartResponse.dict_to_model(response_dict)
         model_wrapped_command_params = [model.CommandParameterNameValue(x.name, x.value) for x in params] if params else []
-        command_context = model.CommandContextDetails(sandbox_id=sandbox_id,
+        command_context = model.SandboxCommandContext(sandbox_id=sandbox_id,
                                                       command_name=command_name,
                                                       command_params=model_wrapped_command_params)
         if polling_execution:
@@ -264,13 +262,13 @@ def run_sandbox_command(
         else:
             execution_details = self.get_execution_details(start_response.executionId)
 
-        return model.EnvironmentCommandExecutionDetails(id=start_response.executionId,
-                                                        status=execution_details.status,
-                                                        supports_cancellation=execution_details.supports_cancellation,
-                                                        started=execution_details.started,
-                                                        ended=execution_details.ended,
-                                                        output=execution_details.output,
-                                                        command_context=command_context)
+        return model.SandboxCommandExecutionDetails(id=start_response.executionId,
+                                                    status=execution_details.status,
+                                                    supports_cancellation=execution_details.supports_cancellation,
+                                                    started=execution_details.started,
+                                                    ended=execution_details.ended,
+                                                    output=execution_details.output,
+                                                    command_context=command_context)
 
     def run_component_command(
             self,
@@ -294,11 +292,11 @@ def run_component_command(
         start_response = model.CommandStartResponse.dict_to_model(response_dict)
         component_details = self.get_sandbox_component_details(sandbox_id, component_id)
         model_wrapped_command_params = [model.CommandParameterNameValue(x.name, x.value) for x in params] if params else []
-        command_context = model.ComponentCommandContextDetails(sandbox_id=sandbox_id,
-                                                               command_name=command_name,
-                                                               command_params=model_wrapped_command_params,
-                                                               component_name=component_details.name,
-                                                               component_id=component_details.id)
+        command_context = model.ComponentCommandContext(sandbox_id=sandbox_id,
+                                                        command_name=command_name,
+                                                        command_params=model_wrapped_command_params,
+                                                        component_name=component_details.name,
+                                                        component_id=component_details.id)
         if polling_execution:
             execution_details = self.poll_command_execution(execution_id=start_response.executionId,
                                                             max_polling_minutes=max_polling_minutes,
@@ -575,8 +573,8 @@ def poll_sandbox_teardown(
 
     def poll_command_execution(self,
                                execution_id: str,
-                               max_polling_minutes: int,
-                               polling_frequency_seconds: int,
+                               max_polling_minutes=10,
+                               polling_frequency_seconds=30,
                                log_level=logging.DEBUG,
                                ) -> model.CommandExecutionDetails:
         """ Create blocking polling process """

src/cloudshell/sandbox_rest/components.py

@@ -1,7 +1,84 @@
 """
 Component helpers for filtering and sorting the sandbox components
 """
+from enum import Enum
+from typing import List
+
+from cloudshell.sandbox_rest import model
+from cloudshell.sandbox_rest.api import SandboxRestApiSession
+
+
+class ComponentTypes(str, Enum):
+    app_type = "Application"
+    resource_type = "Resource"
+    service_type = "Service"
+
+
+class AppLifeCycleTypes(str, Enum):
+    deployed = "Deployed"
+    un_deployed = "Undeployed"
+
+
+class AttributeTypes(str, Enum):
+    boolean = "boolean"
+    password = "password"
+    string = "string"
+    numeric = "numeric"
 
 
 class SandboxComponents:
-    pass
+    def __init__(self, components: List[model.SandboxComponentFull] = None):
+        self.all_components = components or []
+
+    def refresh_components(self, api: SandboxRestApiSession, sandbox_id: str) -> None:
+        self.all_components = api.get_sandbox_components(sandbox_id)
+
+    def _filter_components_by_type(self, component_type: ComponentTypes) -> List[model.SandboxComponentFull]:
+        """ accepts both short info components and full info """
+        return [component for component in self.all_components if component.component_type == component_type]
+
+    def _filter_app_by_lifecycle(self, lifecycle_type: AppLifeCycleTypes) -> List[model.SandboxComponentFull]:
+        return [component for component in self.all_components if component.component_type == ComponentTypes.app_type
+                and component.app_lifecycle == lifecycle_type]
+
+    @property
+    def resources(self):
+        return self._filter_components_by_type(ComponentTypes.service_type)
+
+    @property
+    def services(self):
+        return self._filter_components_by_type(ComponentTypes.service_type)
+
+    @property
+    def deployed_apps(self):
+        return self._filter_app_by_lifecycle(AppLifeCycleTypes.deployed)
+
+    @property
+    def un_deployed_apps(self):
+        return self._filter_app_by_lifecycle(AppLifeCycleTypes.un_deployed)
+
+    def filter_by_model(self, component_model: str) -> List[dict]:
+        """
+        Component Model / Shell Template
+        ex: 'Juniper JunOS Switch Shell 2G'
+        """
+        return [component for component in self.all_components if component.component_type == component_model]
+
+    def filter_by_attr(self, attr_name: str, attr_val: str) -> List[model.SandboxComponentFull]:
+        """ attr name is shell agnostic, no namespacing """
+        components = []
+        for component in self.all_components:
+            for attr in component.attributes:
+                if attr.name.endswith(attr_name) and attr.value == attr_val:
+                    components.append(component)
+        return components
+
+    def filter_by_boolean_attr(self, attr_name: str) -> List[dict]:
+        """ attr name is shell agnostic, no namespacing """
+        components = []
+        for component in self.all_components:
+            for attr in component.attributes:
+                if attr.type == AttributeTypes.boolean and attr.name.endswith(attr_name) and attr.value == "True":
+                    components.append(component)
+        return components
+

src/cloudshell/sandbox_rest/model.py

@@ -214,8 +214,8 @@ class CommandParameterDetails(SandboxApiBaseModel):
 
 @_basemodel_decorator
 class CommandParameterNameValue(SandboxApiBaseModel):
-    name: Optional[str]
-    value: Optional[str]
+    name: str
+    value: str
 
 
 @_basemodel_decorator
@@ -314,23 +314,23 @@ class StopSandboxResponse(SandboxApiBaseModel):
 
 
 @_basemodel_decorator
-class CommandContextDetails(SandboxApiBaseModel):
+class SandboxCommandContext(SandboxApiBaseModel):
     sandbox_id: Optional[str]
     command_name: Optional[str]
     command_params: Optional[List[CommandParameterNameValue]]
 
 
 @_basemodel_decorator
-class ComponentCommandContextDetails(CommandContextDetails):
+class ComponentCommandContext(SandboxCommandContext):
     component_name: Optional[str]
     component_id: Optional[str]
 
 
 @_basemodel_decorator
-class EnvironmentCommandExecutionDetails(CommandExecutionDetails):
-    command_context: Optional[CommandContextDetails]
+class SandboxCommandExecutionDetails(CommandExecutionDetails):
+    command_context: Optional[SandboxCommandContext]
 
 
 @_basemodel_decorator
 class ComponentCommandExecutionDetails(CommandExecutionDetails):
-    command_context: Optional[ComponentCommandContextDetails]
+    command_context: Optional[ComponentCommandContext]

src/cloudshell/sandbox_rest/sandbox_context.py

@@ -1,15 +1,34 @@
 """
 Sandbox controller context manager to manage the lifecyle of setup and teardown
+- start sandbox on context enter, end sandbox on context exit
+- cache setup / teardown duration and errors
+- components object member
+- async commands executor member
 """
-
+import logging
 
 from cloudshell.sandbox_rest.api import SandboxRestApiSession
+from cloudshell.sandbox_rest.async_commands import AsyncCommandExecutor
+from cloudshell.sandbox_rest.components import SandboxComponents
+
+
+class SandboxStartRequest:
+    pass
 
 
 class SandboxControllerContext:
-    def __init__(self, api: SandboxRestApiSession, sandbox_id: str = None):
+    def __init__(self, api: SandboxRestApiSession, sandbox_request: SandboxStartRequest = None, sandbox_id: str = None,
+                 logger: logging.Logger = None):
         self.api = api
+        self.sandbox_request = sandbox_request
         self.sandbox_id = sandbox_id
+        self.logger = logger
+        self.components = SandboxComponents()
+        self.async_executor = AsyncCommandExecutor()
+        self.setup_duration_seconds: int = None
+        self.teardown_duration_seconds: int = None
+        self.setup_errors = None
+        self.teardown_errors = None
 
     def __enter__(self):
         """ start sandbox """
@@ -18,3 +37,10 @@ def __enter__(self):
     def __exit__(self, exc_type, exc_val, exc_tb):
         """ end sandbox """
         return self
+
+    def refresh_components(self):
+        self.components.refresh_components(self.api, self.sandbox_id)
+
+
+if __name__ == "__main__":
+    controller = SandboxControllerContext()