Merge pull request #909 from QualiSystems/igor_cancellation_added

Cancellation added for the all deployment options

Author: igor-olikh

package/cloudshell/cp/vcenter/commands/command_orchestrator.py

@@ -52,6 +52,7 @@
 from cloudshell.cp.vcenter.vm.vnic_to_network_mapper import VnicToNetworkMapper
 from cloudshell.cp.vcenter.models.DeployFromTemplateDetails import DeployFromTemplateDetails
 
+
 class CommandOrchestrator(object):
     def __init__(self):
         """
@@ -159,10 +160,11 @@ def connect_bulk(self, context, request):
         driver_response_root.driverResponse = driver_response
         return set_command_result(result=driver_response_root, unpicklable=False)
 
-    def deploy_from_template(self, context, request):
+    def deploy_from_template(self, context, request, cancellation_context):
         """
         Deploy From Template Command, will deploy vm from template
 
+        :param cancellation_context:
         :param models.QualiDriverModels.ResourceCommandContext context: the context of the command
         :param str request: represent a json string '{ "DeploymentServiceName": "..", "AppName": "..", "Attributes": {"Key1": "Value1", ..} }'
         :return str deploy results
@@ -171,21 +173,24 @@ def deploy_from_template(self, context, request):
         # get command parameters from the environment
         data = jsonpickle.decode(request)
         data['Attributes']['vCenter Name'] = context.resource.name
-        clone_from_vm_model = ResourceModelParser().convert_to_resource_model(data['Attributes'], vCenterVMFromTemplateResourceModel)
+        clone_from_vm_model = ResourceModelParser().convert_to_resource_model(data['Attributes'],
+                                                                              vCenterVMFromTemplateResourceModel)
         data_holder = DeployFromTemplateDetails(clone_from_vm_model, data['UserRequestedAppName'] or data['AppName'])
 
         # execute command
         result = self.command_wrapper.execute_command_with_connection(
             context,
             self.deploy_command.execute_deploy_from_template,
-            data_holder)
+            data_holder,
+            cancellation_context)
 
         return set_command_result(result=result, unpicklable=False)
 
-    def deploy_clone_from_vm(self, context, request):
+    def deploy_clone_from_vm(self, context, request, cancellation_context):
         """
         Deploy Cloned VM From VM Command, will deploy vm from template
 
+        :param cancellation_context:
         :param models.QualiDriverModels.ResourceCommandContext context: the context of the command
         :param str request: represent a json string '{ "DeploymentServiceName": "..", "AppName": "..", "Attributes": {"Key1": "Value1", ..} }'
         :return str deploy results
@@ -194,22 +199,25 @@ def deploy_clone_from_vm(self, context, request):
         # get command parameters from the environment
         data = jsonpickle.decode(request)
         data['Attributes']['vCenter Name'] = context.resource.name
-        clone_from_vm_model = ResourceModelParser().convert_to_resource_model(data['Attributes'], vCenterCloneVMFromVMResourceModel)
+        clone_from_vm_model = ResourceModelParser().convert_to_resource_model(data['Attributes'],
+                                                                              vCenterCloneVMFromVMResourceModel)
         data_holder = DeployFromTemplateDetails(clone_from_vm_model, data['UserRequestedAppName'] or data['AppName'])
 
         # execute command
         result = self.command_wrapper.execute_command_with_connection(
             context,
             self.deploy_command.execute_deploy_clone_from_vm,
-            data_holder)
+            data_holder,
+            cancellation_context)
 
         res = set_command_result(result=result, unpicklable=False)
         return res
 
-    def deploy_from_linked_clone(self, context, request):
+    def deploy_from_linked_clone(self, context, request, cancellation_context):
         """
         Deploy Cloned VM From VM Command, will deploy vm from template
 
+        :param cancellation_context:
         :param models.QualiDriverModels.ResourceCommandContext context: the context of the command
         :param str request: represent a json string '{ "DeploymentServiceName": "..", "AppName": "..", "Attributes": {"Key1": "Value1", ..} }'
         :return str deploy results
@@ -218,25 +226,29 @@ def deploy_from_linked_clone(self, context, request):
         # get command parameters from the environment
         data = jsonpickle.decode(request)
         data['Attributes']['vCenter Name'] = context.resource.name
-        linked_clone_from_vm_model = self.resource_model_parser.convert_to_resource_model(data['Attributes'], VCenterDeployVMFromLinkedCloneResourceModel)
+        linked_clone_from_vm_model = self.resource_model_parser.convert_to_resource_model(data['Attributes'],
+                                                                                          VCenterDeployVMFromLinkedCloneResourceModel)
 
         if not linked_clone_from_vm_model.vcenter_vm_snapshot:
             raise ValueError('Please insert snapshot to deploy from')
 
-        data_holder = DeployFromTemplateDetails(linked_clone_from_vm_model, data['UserRequestedAppName'] or data['AppName'])
+        data_holder = DeployFromTemplateDetails(linked_clone_from_vm_model,
+                                                data['UserRequestedAppName'] or data['AppName'])
 
         # execute command
         result = self.command_wrapper.execute_command_with_connection(
             context,
             self.deploy_command.execute_deploy_from_linked_clone,
-            data_holder)
+            data_holder,
+            cancellation_context)
 
         return set_command_result(result=result, unpicklable=False)
 
-    def deploy_from_image(self, context, request):
+    def deploy_from_image(self, context, request, cancellation_context):
         """
         Deploy From Image Command, will deploy vm from ovf image
 
+        :param cancellation_context:
         :param models.QualiDriverModels.ResourceCommandContext context: the context of the command
         :param str request: represent a json string '{ "DeploymentServiceName": "..", "AppName": "..", "Attributes": {"Key1": "Value1", ..} }'
         :return str deploy results
@@ -245,15 +257,17 @@ def deploy_from_image(self, context, request):
         # get command parameters from the environment
         data = jsonpickle.decode(request)
         data['Attributes']['vCenter Name'] = context.resource.name
-        deploy_from_image_model = self.resource_model_parser.convert_to_resource_model(data['Attributes'], vCenterVMFromImageResourceModel)
+        deploy_from_image_model = self.resource_model_parser.convert_to_resource_model(data['Attributes'],
+                                                                                       vCenterVMFromImageResourceModel)
         data_holder = DeployFromImageDetails(deploy_from_image_model, data['UserRequestedAppName'] or data['AppName'])
 
         # execute command
         result = self.command_wrapper.execute_command_with_connection(
             context,
             self.deploy_command.execute_deploy_from_image,
             data_holder,
-            context.resource)
+            context.resource,
+            cancellation_context)
 
         return set_command_result(result=result, unpicklable=False)
 
@@ -325,7 +339,8 @@ def refresh_ip(self, context, cancellation_context, ports):
                                                                    self.refresh_ip_command.refresh_ip,
                                                                    resource_details,
                                                                    cancellation_context,
-                                                                   context.remote_endpoints[0].app_context.app_request_json)
+                                                                   context.remote_endpoints[
+                                                                       0].app_context.app_request_json)
         return set_command_result(result=res, unpicklable=False)
 
     # remote command
@@ -402,7 +417,7 @@ def get_vm_uuid_by_name(self, context, vm_name):
                                                                    vm_name)
         return set_command_result(result=res, unpicklable=False)
 
-    def get_vm_details(self, context,cancellation_context, requests_json):
+    def get_vm_details(self, context, cancellation_context, requests_json):
         requests = DeployDataHolder(jsonpickle.decode(requests_json)).items
         res = self.command_wrapper.execute_command_with_connection(context,
                                                                    self.vm_details.get_vm_details,

package/cloudshell/cp/vcenter/commands/deploy_vm.py

@@ -11,9 +11,10 @@ def __init__(self, deployer):
         """
         self.deployer = deployer
 
-    def execute_deploy_from_linked_clone(self, si, logger, vcenter_data_model, reservation_id, deployment_params):
+    def execute_deploy_from_linked_clone(self, si, logger, vcenter_data_model, reservation_id, deployment_params, cancellation_context):
         """
         Calls the deployer to deploy vm from snapshot
+        :param cancellation_context:
         :param str reservation_id:
         :param si:
         :param logger:
@@ -22,12 +23,13 @@ def execute_deploy_from_linked_clone(self, si, logger, vcenter_data_model, reser
         :return:
         """
         deploy_result = self.deployer.deploy_from_linked_clone(si, logger, deployment_params, vcenter_data_model,
-                                                               reservation_id)
+                                                               reservation_id, cancellation_context)
         return deploy_result
 
-    def execute_deploy_clone_from_vm(self, si, logger, vcenter_data_model, reservation_id, deployment_params):
+    def execute_deploy_clone_from_vm(self, si, logger, vcenter_data_model, reservation_id, deployment_params, cancellation_context):
         """
         Calls the deployer to deploy vm from another vm
+        :param cancellation_context:
         :param str reservation_id:
         :param si:
         :param logger:
@@ -36,10 +38,10 @@ def execute_deploy_clone_from_vm(self, si, logger, vcenter_data_model, reservati
         :return:
         """
         deploy_result = self.deployer.deploy_clone_from_vm(si, logger, deployment_params, vcenter_data_model,
-                                                           reservation_id)
+                                                           reservation_id, cancellation_context)
         return deploy_result
 
-    def execute_deploy_from_template(self, si, logger, vcenter_data_model, reservation_id, deployment_params):
+    def execute_deploy_from_template(self, si, logger, vcenter_data_model, reservation_id, deployment_params, cancellation_context):
         """
 
         :param str reservation_id:
@@ -50,13 +52,14 @@ def execute_deploy_from_template(self, si, logger, vcenter_data_model, reservati
         :return:
         """
         deploy_result = self.deployer.deploy_from_template(si, logger, deployment_params, vcenter_data_model,
-                                                           reservation_id)
+                                                           reservation_id, cancellation_context)
         return deploy_result
 
     def execute_deploy_from_image(self, si, logger, session, vcenter_data_model, reservation_id, deployment_params,
-                                  resource_context):
+                                  resource_context, cancellation_context):
         """
 
+        :param cancellation_context:
         :param str reservation_id:
         :param si:
         :param logger:
@@ -72,5 +75,6 @@ def execute_deploy_from_image(self, si, logger, session, vcenter_data_model, res
                                                         vcenter_data_model=vcenter_data_model,
                                                         data_holder=deployment_params,
                                                         resource_context=resource_context,
-                                                        reservation_id=reservation_id)
+                                                        reservation_id=reservation_id,
+                                                        cancellation_context=cancellation_context)
         return deploy_result

package/cloudshell/cp/vcenter/common/vcenter/task_waiter.py

@@ -10,9 +10,10 @@ def __init__(self):
         pass
 
     # noinspection PyMethodMayBeStatic
-    def wait_for_task(self, task, logger, action_name='job', hide_result=False):
+    def wait_for_task(self, task, logger, action_name='job', hide_result=False, cancellation_context=None):
         """
         Waits and provides updates on a vSphere task
+        :param cancellation_context: package.cloudshell.cp.vcenter.models.QualiDriverModels.CancellationContext
         :param task:
         :param action_name:
         :param hide_result:
@@ -21,6 +22,13 @@ def wait_for_task(self, task, logger, action_name='job', hide_result=False):
 
         while task.info.state in [vim.TaskInfo.State.running, vim.TaskInfo.State.queued]:
             time.sleep(2)
+            if cancellation_context is not None and task.info.cancelable and cancellation_context.is_cancelled and not task.info.cancelled:
+                # some times the cancel operation doesn't really cancel the task
+                # so consider an additional handling of the canceling
+                task.CancelTask()
+                logger.info("SynchronousTaskWaiter: task.CancelTask() " + str(task.info.name.info.name))
+                logger.info("SynchronousTaskWaiter: task.info.cancelled " + str(task.info.cancelled))
+                logger.info("SynchronousTaskWaiter: task.info.state " + str(task.info.state))
 
         if task.info.state == vim.TaskInfo.State.success:
             if task.info.result is not None and not hide_result:

package/cloudshell/cp/vcenter/common/vcenter/vmomi_service.py

@@ -405,10 +405,11 @@ def __init__(self, vm=None, error=None):
             self.vm = vm
             self.error = error
 
-    def clone_vm(self, clone_params, logger):
+    def clone_vm(self, clone_params, logger, cancellation_context):
         """
         Clone a VM from a template/VM and return the vm oject or throws argument is not valid
 
+        :param cancellation_context:
         :param clone_params: CloneVmParameters =
         :param logger:
         """
@@ -470,7 +471,8 @@ def clone_vm(self, clone_params, logger):
         logger.info("cloning VM...")
         try:
             task = template.Clone(folder=dest_folder, name=clone_params.vm_name, spec=clone_spec)
-            vm = self.task_waiter.wait_for_task(task=task, logger=logger, action_name='Clone VM')
+            vm = self.task_waiter.wait_for_task(task=task, logger=logger, action_name='Clone VM',
+                                                cancellation_context=cancellation_context)
         except TaskFaultException:
             raise
         except vim.fault.NoPermission as error:

package/cloudshell/cp/vcenter/common/wrappers/command_wrapper.py

@@ -59,8 +59,8 @@ def execute_command_with_connection(self, context, command, *args):
         """
 
         logger = self.context_based_logger_factory.create_logger_for_context(
-                logger_name='vCenterShell',
-                context=context)
+            logger_name='vCenterShell',
+            context=context)
 
         if not command:
             logger.error(COMMAND_CANNOT_BE_NONE)
@@ -82,15 +82,15 @@ def execute_command_with_connection(self, context, command, *args):
 
                 vcenter_data_model = self.resource_model_parser.convert_to_vcenter_model(context.resource)
                 connection_details = ResourceConnectionDetailsRetriever.get_connection_details(session=session,
-                                                                           vcenter_resource_model=vcenter_data_model,
-                                                                           resource_context=context.resource)
+                                                                                               vcenter_resource_model=vcenter_data_model,
+                                                                                               resource_context=context.resource)
 
             if connection_details:
                 logger.info(INFO_CONNECTING_TO_VCENTER.format(connection_details.host))
                 logger.debug(
-                        DEBUG_CONNECTION_INFO.format(connection_details.host,
-                                                     connection_details.username,
-                                                     connection_details.port))
+                    DEBUG_CONNECTION_INFO.format(connection_details.host,
+                                                 connection_details.username,
+                                                 connection_details.port))
 
                 si = self.get_py_service_connection(connection_details, logger)
             if si:
@@ -127,7 +127,7 @@ def execute_command_with_connection(self, context, command, *args):
             return results
         except Exception as ex:
             logger.exception(COMMAND_ERROR.format(command_name))
-            logger.exception(str(type(ex)) + ': '+ str(ex))
+            logger.exception(str(type(ex)) + ': ' + str(ex))
             raise
         finally:
             logger.info(LOG_FORMAT.format(END, command_name))