added some setup script samples with no params restrictions

Author: katzy687

automation_api_scripts/export_families_to_xml.py

@@ -0,0 +1,11 @@
+from cloudshell.api.cloudshell_api import CloudShellAPISession
+import xml.etree.ElementTree as ET
+
+user = "admin"
+password = "admin"
+server = "localhost"
+domain = "Global"
+
+api = CloudShellAPISession(host=server, username=user, password=password, domain=domain)
+model_data_str = api.ExportFamiliesAndModels().Configuration
+xml_data = ET.fromstring(model_data_str)

generic-orchestration-samples/setup_with_class_based_func/__init__.py

@@ -0,0 +1,11 @@
+from extended_models import CustomSandbox, CustomSetupWorkflow
+from blueprint_commands import BlueprintCommands
+
+sandbox = CustomSandbox()
+
+bp_commands = BlueprintCommands(sandbox)
+
+CustomSetupWorkflow(sandbox).register()
+sandbox.workflow.on_configuration_ended(bp_commands.command_one)
+sandbox.workflow.on_configuration_ended(bp_commands.command_two)
+sandbox.execute_setup()

generic-orchestration-samples/setup_with_class_based_func/__main__.py

@@ -0,0 +1,17 @@
+from extended_models import CustomSandbox
+
+
+class BlueprintCommands(object):
+    def __init__(self, sandbox):
+        """
+        :param CustomSandbox sandbox:
+        """
+        self.sandbox = sandbox
+
+    def command_one(self):
+        api = self.sandbox.automation_api
+        api.WriteMessageToReservationOutput(self.sandbox.id, "hello from command one")
+
+    def command_two(self):
+        api = self.sandbox.automation_api
+        api.WriteMessageToReservationOutput(self.sandbox.id, "hello from command two")

generic-orchestration-samples/setup_with_class_based_func/blueprint_commands.py

@@ -0,0 +1,144 @@
+from cloudshell.workflow.orchestration.sandbox import Sandbox
+from cloudshell.workflow.orchestration.setup.default_setup_logic import DefaultSetupLogic
+from cloudshell.workflow.orchestration.workflow import Workflow
+
+
+class CustomWorkflow(Workflow):
+    def __init__(self, sandbox):
+        super(CustomWorkflow, self).__init__(sandbox)
+
+    def _validate_function(self, func):
+        self.sandbox.logger.info('Custom Sandbox Object being used. No validation done on Workflow functions')
+        pass
+
+
+class CustomSandbox(Sandbox):
+    def __init__(self):
+        super(CustomSandbox, self).__init__()
+        self.workflow = CustomWorkflow(self)
+
+    def _execute_workflow_process(self, func, components):
+        self.logger.info("Executing method: {0}. ".format(func.__name__))
+        execution_failed = 0
+        try:
+            self.logger.info("Executing workflow function with no parameters passed")
+            func()
+
+        except Exception as exc:
+            self.logger.info("except Exception as exc")
+            execution_failed = 1
+            if not hasattr(exc, 'message'):  # python 3
+                error = str(exc)
+                self.logger.info("type of exc is {}".format(str(type(exc))))
+            else:
+                error = exc.message
+            self._exception = exc
+            if not error or not isinstance(error, str):
+                try:
+                    error = str(exc)
+                except Exception:
+                    pass
+
+            if self.suppress_exceptions:
+                print (error)
+            self.logger.exception("Error was thrown during orchestration execution: ")
+
+        return execution_failed
+
+
+class CustomSetupWorkflow(object):
+    def __init__(self, sandbox):
+        """
+        :param Sandbox sandbox:
+        """
+        self.sandbox = sandbox
+        self._deploy_result = None
+        self._resource_details_cache = {}
+
+    def register(self, enable_provisioning=True, enable_connectivity=True, enable_configuration=True):
+        """
+        :param bool enable_provisioning:
+        :param bool enable_connectivity:
+        :param bool enable_configuration:
+        :return:
+        """
+        self.sandbox.logger.info("Adding default setup orchestration")
+        if enable_provisioning:
+            self.sandbox.logger.debug("Default provisioning is added to sandbox orchestration")
+            self.sandbox.workflow.add_to_provisioning(self.default_provisioning, None)
+        if enable_connectivity:
+            self.sandbox.logger.debug("Default connectivity is added to sandbox orchestration")
+            self.sandbox.workflow.add_to_connectivity(self.default_connectivity, None)
+        if enable_configuration:
+            self.sandbox.logger.debug("Default configuration is added to sandbox orchestration")
+            self.sandbox.workflow.add_to_configuration(self.default_configuration, None)
+
+    def default_provisioning(self):
+        """
+        :return:
+        """
+        api = self.sandbox.automation_api
+
+        self.sandbox.logger.info("Executing default provisioning")
+
+        reservation_details = api.GetReservationDetails(reservationId=self.sandbox.id, disableCache=True)
+        self._deploy_result = DefaultSetupLogic.deploy_apps_in_reservation(api=api,
+                                                                           reservation_details=reservation_details,
+                                                                           reservation_id=self.sandbox.id,
+                                                                           logger=self.sandbox.logger)
+
+        DefaultSetupLogic.validate_all_apps_deployed(deploy_results=self._deploy_result,
+                                                     logger=self.sandbox.logger)
+
+        self.sandbox.components.refresh_components(sandbox=self.sandbox)
+
+        DefaultSetupLogic.try_exeucte_autoload(api=api,
+                                               deploy_result=self._deploy_result,
+                                               resource_details_cache=self._resource_details_cache,
+                                               reservation_id=self.sandbox.id,
+                                               logger=self.sandbox.logger, components=self.sandbox.components)
+
+    def default_connectivity(self):
+        """
+        :return:
+        """
+        api = self.sandbox.automation_api
+
+        self.sandbox.logger.info("Executing default connectivity")
+
+        reservation_details = api.GetReservationDetails(reservationId=self.sandbox.id, disableCache=True)
+
+        connect_results = DefaultSetupLogic.connect_all_routes_in_reservation(api=api,
+                                                                              reservation_details=reservation_details,
+                                                                              reservation_id=self.sandbox.id,
+                                                                              resource_details_cache=self._resource_details_cache,
+                                                                              logger=self.sandbox.logger)
+
+        DefaultSetupLogic.activate_routes(api=api,
+                                          reservation_details=reservation_details,
+                                          reservation_id=self.sandbox.id,
+                                          logger=self.sandbox.logger)
+
+        DefaultSetupLogic.run_async_power_on_refresh_ip(api=api,
+                                                        reservation_details=reservation_details,
+                                                        deploy_results=self._deploy_result,
+                                                        resource_details_cache=self._resource_details_cache,
+                                                        reservation_id=self.sandbox.id,
+                                                        logger=self.sandbox.logger,
+                                                        components=self.sandbox.components)
+
+        DefaultSetupLogic.refresh_vm_details(api=api,
+                                             reservation_details=reservation_details,
+                                             connect_results=connect_results,
+                                             resource_details_cache=self._resource_details_cache,
+                                             logger=self.sandbox.logger,
+                                             components=self.sandbox.components)
+
+    def default_configuration(self):
+        """
+        :return:
+        """
+        self.sandbox.logger.info("Executing default configuration")
+        DefaultSetupLogic.configure_apps(api=self.sandbox.automation_api,
+                                         reservation_id=self.sandbox.id,
+                                         logger=self.sandbox.logger)

generic-orchestration-samples/setup_with_class_based_func/extended_models.py

@@ -0,0 +1 @@
+cloudshell-orch-core<3.2.0.0,>=3.1.0.0

generic-orchestration-samples/setup_with_class_based_func/requirements.txt

@@ -0,0 +1,20 @@
+from cloudshell.workflow.orchestration.setup.default_setup_orchestrator import DefaultSetupWorkflow
+from extended_models import CustomSandbox
+from blueprint_commands import BlueprintCommands, command_with_sandbox_param, command_with_sandbox_and_components_params
+
+# instantiate custom sandbox object
+sandbox = CustomSandbox()
+
+# instantiate class based commands container
+bp_commands = BlueprintCommands(sandbox)
+
+# register sandbox with default workflow class
+DefaultSetupWorkflow().register(sandbox)
+
+# pass in both custom class based and function based commands
+sandbox.workflow.on_configuration_ended(bp_commands.command_one)
+sandbox.workflow.on_configuration_ended(bp_commands.command_two)
+sandbox.workflow.on_configuration_ended(command_with_sandbox_param)
+sandbox.workflow.on_configuration_ended(command_with_sandbox_and_components_params)
+
+sandbox.execute_setup()

generic-orchestration-samples/setup_with_class_based_func_backwards_compatible/__init__.py

@@ -0,0 +1,33 @@
+from extended_models import CustomSandbox
+from cloudshell.workflow.orchestration.components import Components
+
+
+class BlueprintCommands(object):
+    def __init__(self, sandbox):
+        """
+        :param CustomSandbox sandbox:
+        """
+        self.sandbox = sandbox
+
+    def command_one(self):
+        api = self.sandbox.automation_api
+        api.WriteMessageToReservationOutput(self.sandbox.id, "hello from bound method no param")
+
+
+def command_with_sandbox_param(sandbox):
+    """
+    :param CustomSandbox sandbox:
+    :return:
+    """
+    api = sandbox.automation_api
+    api.WriteMessageToReservationOutput(sandbox.id, "hello from function with sandbox param only")
+
+
+def command_with_sandbox_and_components_params(sandbox, components=None):
+    """
+    :param CustomSandbox sandbox:
+    :param Components components:
+    :return:
+    """
+    api = sandbox.automation_api
+    api.WriteMessageToReservationOutput(sandbox.id, "hello from function with sandbox and component params")

generic-orchestration-samples/setup_with_class_based_func_backwards_compatible/__main__.py

@@ -0,0 +1,92 @@
+from cloudshell.workflow.orchestration.sandbox import Sandbox
+from cloudshell.workflow.orchestration.workflow import Workflow
+import inspect
+
+
+def _is_bound_method(method):
+    """
+    check if the method or function is bound (will pass self as first arg)
+    :param method:
+    :return:
+    """
+    return hasattr(method, '__self__')
+
+
+class CustomWorkflow(Workflow):
+    def __init__(self, sandbox):
+        super(CustomWorkflow, self).__init__(sandbox)
+
+    def _validate_function(self, func):
+        """
+        changing validation from a requirement of two parameters, to restricting to max of 2 optional parameters
+        bound class methods will receive an extra 'self' param
+        :param function func: the user function that is passed to orchestration
+        :return:
+        """
+        args = inspect.getargspec(func).args
+        is_bound_method = _is_bound_method(func)
+
+        if is_bound_method:
+            if len(args) > 3:
+                raise Exception("Orchestration methods can not have more than 2 parameters. (Sandbox, Components)")
+        else:
+            if len(args) > 2:
+                raise Exception("Orchestration functions can not have more than 2 parameters. (Sandbox, Components)")
+
+
+class CustomSandbox(Sandbox):
+    def __init__(self):
+        super(CustomSandbox, self).__init__()
+        self.workflow = CustomWorkflow(self)
+
+    def _execute_workflow_process(self, func, components):
+        self.logger.info("Executing method: {0}. ".format(func.__name__))
+        execution_failed = 0
+
+        args = inspect.getargspec(func).args
+        is_bound_method = _is_bound_method(func)
+
+        try:
+            if is_bound_method:
+                if len(args) == 1:
+                    self.logger.info("Executing workflow bound method with no additional parameters passed")
+                    func()
+                elif len(args) == 2:
+                    self.logger.info("Executing workflow bound method with 1 parameter passed (Sandbox)")
+                    func(self)
+                else:
+                    self.logger.info("Executing workflow bound method with 2 parameters passed (Sandbox, Components)")
+                    func(self, components)
+            else:
+                if not len(args):
+                    self.logger.info("Executing workflow function with no parameters passed")
+                    func()
+                elif len(args) == 1:
+                    self.logger.info("Executing workflow function with 1 parameter passed (Sandbox)")
+                    func(self)
+                else:
+                    self.logger.info("Executing workflow function with 2 parameters passed (Sandbox, Components)")
+                    func(self, components)
+
+        except Exception as exc:
+            self.logger.info("except Exception as exc")
+            execution_failed = 1
+            if not hasattr(exc, 'message'):  # python 3
+                error = str(exc)
+                self.logger.info("type of exc is {}".format(str(type(exc))))
+            else:
+                error = exc.message
+            self._exception = exc
+            if not error or not isinstance(error, str):
+                try:
+                    error = str(exc)
+                except Exception:
+                    pass
+
+            if self.suppress_exceptions:
+                print (error)
+            self.logger.exception("Error was thrown during orchestration execution: ")
+
+        return execution_failed
+
+