Merge pull request #894 from QualiSystems/develop

Merging dev to master for 1.10.0 release

Author: alexazarh

.gitignore

@@ -81,3 +81,4 @@ develop.cmd
 *.zip
 debug.xml
 debug_info.txt
+

cloudshell_shell_core_install.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 if [ "${CLOUD_SHELL_SHELL_CORE}" -eq 1 ]
 then
-    pip install "cloudshell-shell-core>=3.0.0,<3.1.0" --extra-index-url https://testpypi.python.org/simple
+    pip install "cloudshell-shell-core>=3.1.0,<3.2.0" --extra-index-url https://testpypi.python.org/simple
 else
     pip install "cloudshell-shell-core>=2.3.0,<2.4.0" --extra-index-url https://testpypi.python.org/simple
 fi

kill_python.bat

@@ -0,0 +1,4 @@
+@echo off
+::taskkill /im python.exe /f
+wmic Path win32_process Where "CommandLine Like '%%\\ExecutionServer\\%%python.exe%%'" Call Terminate
+wmic Path win32_process Where "CommandLine Like '%%\\ProgramData\\QualiSystems\\%%python.exe%%'" Call Terminate

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

@@ -3,6 +3,7 @@
 import jsonpickle
 
 from cloudshell.cp.vcenter.models.DeployFromImageDetails import DeployFromImageDetails
+from cloudshell.shell.core.context import ResourceRemoteCommandContext
 from cloudshell.cp.vcenter.models.OrchestrationSaveResult import OrchestrationSaveResult
 from cloudshell.cp.vcenter.models.OrchestrationSavedArtifactsInfo import OrchestrationSavedArtifactsInfo
 from cloudshell.cp.vcenter.models.OrchestrationSavedArtifact import OrchestrationSavedArtifact
@@ -19,12 +20,10 @@
 from cloudshell.cp.vcenter.commands.restore_snapshot import SnapshotRestoreCommand
 from cloudshell.cp.vcenter.commands.save_snapshot import SaveSnapshotCommand
 from cloudshell.cp.vcenter.commands.retrieve_snapshots import RetrieveSnapshotsCommand
-from cloudshell.cp.vcenter.common.cloud_shell.driver_helper import CloudshellDriverHelper
 from cloudshell.cp.vcenter.common.cloud_shell.resource_remover import CloudshellResourceRemover
 from cloudshell.cp.vcenter.common.model_factory import ResourceModelParser
 from cloudshell.cp.vcenter.common.utilites.command_result import set_command_result, get_result_from_command_output
 from cloudshell.cp.vcenter.common.utilites.common_name import generate_unique_name
-from cloudshell.cp.vcenter.common.utilites.common_utils import back_slash_to_front_converter
 from cloudshell.cp.vcenter.common.utilites.context_based_logger_factory import ContextBasedLoggerFactory
 from cloudshell.cp.vcenter.common.vcenter.ovf_service import OvfImageDeployerService
 from cloudshell.cp.vcenter.common.vcenter.task_waiter import SynchronousTaskWaiter
@@ -50,16 +49,13 @@
 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):
         """
         Initialize the driver session, this function is called everytime a new instance of the driver is created
         in here the driver is going to be bootstrapped
 
-        :param context: models.QualiDriverModels.InitCommandContext
         """
-        self.cs_helper = CloudshellDriverHelper()
         synchronous_task_waiter = SynchronousTaskWaiter()
         pv_service = pyVmomiService(connect=SmartConnect, disconnect=Disconnect, task_waiter=synchronous_task_waiter)
         self.resource_model_parser = ResourceModelParser()
@@ -74,7 +70,6 @@ def __init__(self):
         vm_deployer = VirtualMachineDeployer(pv_service=pv_service,
                                              name_generator=generate_unique_name,
                                              ovf_service=ovf_service,
-                                             cs_helper=self.cs_helper,
                                              resource_model_parser=ResourceModelParser())
 
         dv_port_group_creator = DvPortGroupCreator(pyvmomi_service=pv_service,
@@ -89,7 +84,6 @@ def __init__(self):
                                                                               virtual_machine_port_group_configurer)
         # Command Wrapper
         self.command_wrapper = CommandWrapper(pv_service=pv_service,
-                                              cloud_shell_helper=self.cs_helper,
                                               resource_model_parser=self.resource_model_parser,
                                               context_based_logger_factory=ContextBasedLoggerFactory())
         # Deploy Command
@@ -261,6 +255,7 @@ def disconnect_all(self, context, ports):
         :param models.QualiDriverModels.ResourceRemoteCommandContext context: the context the command runs on
         :param list[string] ports: the ports of the connection between the remote resource and the local resource, NOT IN USE!!!
         """
+
         resource_details = self._parse_remote_model(context)
         # execute command
         res = self.command_wrapper.execute_command_with_connection(
@@ -309,16 +304,15 @@ def destroy_vm_only(self, context, ports):
     def refresh_ip(self, context, cancellation_context, ports):
         """
         Refresh IP Command, will refresh the ip of the vm and will update it on the resource
-        :param models.QualiDriverModels.ResourceRemoteCommandContext context: the context the command runs on
+        :param ResourceRemoteCommandContext context: the context the command runs on
         :param cancellation_context:
         :param list[string] ports: the ports of the connection between the remote resource and the local resource, NOT IN USE!!!
         """
         resource_details = self._parse_remote_model(context)
         # execute command
         res = self.command_wrapper.execute_command_with_connection(context,
                                                                    self.refresh_ip_command.refresh_ip,
-                                                                   resource_details.vm_uuid,
-                                                                   resource_details.fullname,
+                                                                   resource_details,
                                                                    cancellation_context,
                                                                    context.remote_endpoints[0].app_context.app_request_json)
         return set_command_result(result=res, unpicklable=False)
@@ -379,6 +373,8 @@ def _parse_remote_model(self, context):
         app_resource_detail.vm_uuid = holder.vmdetails.uid
         app_resource_detail.cloud_provider = context.resource.fullname
         app_resource_detail.fullname = resource.fullname
+        if hasattr(holder.vmdetails, 'vmCustomParams'):
+            app_resource_detail.vm_custom_params = holder.vmdetails.vmCustomParams
         return app_resource_detail
 
     def power_on_not_roemote(self, context, vm_uuid, resource_fullname):

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

@@ -1,9 +1,12 @@
 import re
 import time
 
+from retrying import retry
+
 from cloudshell.cp.vcenter.commands.ip_result import IpResult, IpReason
 
 from cloudshell.cp.vcenter.common.vcenter.vm_location import VMLocation
+from cloudshell.cp.vcenter.models.GenericDeployedAppResourceModel import GenericDeployedAppResourceModel
 
 
 class RefreshIpCommand(object):
@@ -19,15 +22,15 @@ def _do_not_run_on_static_vm(self, app_request_json):
         if app_request_json == '' or app_request_json is None:
             raise ValueError('This command cannot be executed on a Static VM.')
 
-    def refresh_ip(self, si, logger, session, vcenter_data_model, vm_uuid, resource_name, cancellation_context,app_request_json):
+    def refresh_ip(self, si, logger, session, vcenter_data_model, resource_model, cancellation_context,
+                   app_request_json):
         """
         Refreshes IP address of virtual machine and updates Address property on the resource
 
         :param vim.ServiceInstance si: py_vmomi service instance
         :param logger:
         :param vCenterShell.driver.SecureCloudShellApiSession session: cloudshell session
-        :param str vm_uuid: UUID of Virtual Machine
-        :param str resource_name: Logical resource name to update address property on
+        :param GenericDeployedAppResourceModel resource_model: UUID of Virtual Machine
         :param VMwarevCenterResourceModel vcenter_data_model: the vcenter data model attributes
         :param cancellation_context:
         """
@@ -36,29 +39,34 @@ def refresh_ip(self, si, logger, session, vcenter_data_model, vm_uuid, resource_
         default_network = VMLocation.combine(
             [vcenter_data_model.default_datacenter, vcenter_data_model.holding_network])
 
-        resource = session.GetResourceDetails(resource_name)
-
-        match_function = self.ip_manager.get_ip_match_function(self._get_ip_refresh_ip_regex(resource))
+        match_function = self.ip_manager.get_ip_match_function(
+            self._get_ip_refresh_ip_regex(resource_model.vm_custom_params))
 
-        timeout = self._get_ip_refresh_timeout(resource)
+        timeout = self._get_ip_refresh_timeout(resource_model.vm_custom_params)
 
-        vm = self.pyvmomi_service.find_by_uuid(si, vm_uuid)
+        vm = self.pyvmomi_service.find_by_uuid(si, resource_model.vm_uuid)
 
         ip_res = self.ip_manager.get_ip(vm, default_network, match_function, cancellation_context, timeout, logger)
 
         if ip_res.reason == IpReason.Timeout:
             raise ValueError('IP address of VM \'{0}\' could not be obtained during {1} seconds'
-                             .format(resource_name, timeout))
+                             .format(resource_model.fullname, timeout))
 
         if ip_res.reason == IpReason.Success:
-            session.UpdateResourceAddress(resource_name, ip_res.ip_address)
+            self._update_resource_address_with_retry(session=session,
+                                                     resource_name=resource_model.fullname,
+                                                     ip_address=ip_res.ip_address)
 
             return ip_res.ip_address
 
+    @retry(stop_max_attempt_number=5, wait_fixed=1000)
+    def _update_resource_address_with_retry(self, session, resource_name, ip_address):
+        session.UpdateResourceAddress(resource_name, ip_address)
+
     @staticmethod
-    def _get_ip_refresh_timeout(resource):
+    def _get_ip_refresh_timeout(custom_params):
         timeout = RefreshIpCommand._get_custom_param(
-            resource=resource,
+            custom_params=custom_params,
             custom_param_name='refresh_ip_timeout')
 
         if not timeout:
@@ -67,21 +75,18 @@ def _get_ip_refresh_timeout(resource):
         return float(timeout)
 
     @staticmethod
-    def _get_ip_refresh_ip_regex(resource):
+    def _get_ip_refresh_ip_regex(custom_params):
         return RefreshIpCommand._get_custom_param(
-            resource=resource,
+            custom_params=custom_params,
             custom_param_name='ip_regex')
 
     @staticmethod
-    def _get_custom_param(resource, custom_param_name):
-        custom_param_values = []
-        vm_details = resource.VmDetails
-        if vm_details and hasattr(vm_details, 'VmCustomParams') and vm_details.VmCustomParams:
-            custom_params = vm_details.VmCustomParams
-            params = custom_params if isinstance(custom_params, list) else [custom_params]
-            custom_param_values = [custom_param.Value for custom_param
-                                   in params
-                                   if custom_param.Name == custom_param_name]
+    def _get_custom_param(custom_params, custom_param_name):
+        if not custom_params:
+            return None
+
+        custom_param_values = [custom_param.value for custom_param in custom_params
+                               if custom_param.name == custom_param_name]
 
         if custom_param_values:
             return custom_param_values[0]

package/cloudshell/cp/vcenter/common/cloud_shell/conn_details_retriever.py

@@ -2,28 +2,24 @@
 
 
 class ResourceConnectionDetailsRetriever:
-    def __init__(self, qualipy_helpers):
-        """
-        :param qualipy.scripts.cloudshell_scripts_helpers qualipy_helpers:
-        :param cs_retriever_service:
-        :return:
-        """
-        self.qualipy_helpers = qualipy_helpers
 
-    def connection_details(self):
-        """ Retrieves connection details to vCenter from specified resource
+    @staticmethod
+    def get_connection_details(session, vcenter_resource_model, resource_context):
+        """
+        Methods retrieves the connection details from the vcenter resource model attributes.
 
-        :param resource_name: Resource name to get connection details from
-        :rtype VCenterConnectionDetails:
+        :param CloudShellAPISession session:
+        :param VMwarevCenterResourceModel vcenter_resource_model: Instance of VMwarevCenterResourceModel
+        :param ResourceContextDetails resource_context: the context of the command
         """
-        # gets the vcenter resource context to connect. We assume this will only run on a cloud prodvider resource
-        session = self.qualipy_helpers.get_api_session()
-        resource_context = self.qualipy_helpers.get_resource_context_details()
+
+        session = session
+        resource_context = resource_context
 
         # get vCenter connection details from vCenter resource
-        user = resource_context.attributes["User"]
-        encrypted_pass = resource_context.attributes["Password"]
+        user = vcenter_resource_model.user
         vcenter_url = resource_context.address
-        password = session.DecryptPassword(encrypted_pass).Value
+        password = session.DecryptPassword(vcenter_resource_model.password).Value
 
         return VCenterConnectionDetails(vcenter_url, user, password)
+

package/cloudshell/cp/vcenter/common/cloud_shell/driver_helper.py

@@ -7,11 +7,12 @@
 from cloudshell.cp.vcenter.models.QualiDriverModels import AutoLoadDetails, AutoLoadAttribute
 from cloudshell.cp.vcenter.models.VCenterConnectionDetails import VCenterConnectionDetails
 
-from cloudshell.cp.vcenter.common.cloud_shell.driver_helper import CloudshellDriverHelper
+
 from cloudshell.cp.vcenter.common.model_factory import ResourceModelParser
 from cloudshell.cp.vcenter.common.vcenter.vmomi_service import pyVmomiService
 
 from cloudshell.cp.vcenter.common.vcenter.task_waiter import SynchronousTaskWaiter
+from cloudshell.shell.core.session.cloudshell_session import CloudShellSessionContext
 
 DOMAIN = 'Global'
 ADDRESS = 'address'
@@ -34,7 +35,6 @@ class VCenterAutoModelDiscovery(object):
     def __init__(self):
         self.parser = ResourceModelParser()
         self.pv_service = pyVmomiService(SmartConnect, Disconnect, SynchronousTaskWaiter())
-        self.cs_helper = CloudshellDriverHelper()
         self.context_based_logger_factory = ContextBasedLoggerFactory()
 
     def _get_logger(self, context):
@@ -51,15 +51,15 @@ def validate_and_discover(self, context):
         """
         logger = self._get_logger(context)
         logger.info('Autodiscovery started')
+        si = None
+        resource = None
 
-        session = self.cs_helper.get_session(context.connectivity.server_address,
-                                             context.connectivity.admin_auth_token,
-                                             DOMAIN)
-        self._check_if_attribute_not_empty(context.resource, ADDRESS)
-        resource = context.resource
-        auto_attr = []
-        si = self._check_if_vcenter_user_pass_valid(context, session, resource.attributes)
+        with CloudShellSessionContext(context) as cloudshell_session:
+            self._check_if_attribute_not_empty(context.resource, ADDRESS)
+            resource = context.resource
+            si = self._check_if_vcenter_user_pass_valid(context, cloudshell_session, resource.attributes)
 
+        auto_attr = []
         if not si:
             error_message = 'Could not connect to the vCenter: {0}, with given credentials'\
                 .format(context.resource.address)
@@ -69,6 +69,7 @@ def validate_and_discover(self, context):
         try:
             all_dc = self.pv_service.get_all_items_in_vcenter(si, vim.Datacenter)
             dc = self._validate_datacenter(si, all_dc, auto_attr, resource.attributes)
+
             all_items_in_dc = self.pv_service.get_all_items_in_vcenter(si, None, dc)
             dc_name = dc.name
 
@@ -111,6 +112,21 @@ def _validate_datacenter(self, si, all_item_in_vc, auto_att, attributes):
         auto_att.append(AutoLoadAttribute('', DEFAULT_DATACENTER, dc.name))
         return dc
 
+    def _validate_default_dvswitch(self, si, all_items_in_vc, auto_att, dc_name, attributes, key):
+
+        dvs_path = attributes[key]
+
+        # optional pararm
+        if(not attributes[key]):
+            return
+
+        path = "{}/{}".format(dc_name, dvs_path)
+        dv = self.pv_service.find_dvs_by_path(si, path)
+
+        auto_att.append(AutoLoadAttribute('', DEFAULT_DVSWITCH, dvs_path))
+
+        return dv
+
     def _validate_attribute(self, si, attributes, vim_type, name, prefix=''):
         if name in attributes and attributes[name]:
             att_value = attributes[name]