Merge pull request #737 from QualiSystems/hotfix/release_1.1_3

Hotfix/release 1.1 3

Author: razaba

deployment_drivers/deploy_clone_from_vm/drivermetadata.xml

@@ -1,4 +1,4 @@
-<Driver Description="Deploy App From VM" MainClass="driver.DeployCloneFromVMDriver" Name="Deploy Clone From VM Driver" Version="1.0.0">
+<Driver Description="Deploy App From VM" MainClass="driver.DeployCloneFromVMDriver" Name="Deploy Clone From VM Driver" Version="1.1.0">
     <Layout>
         <Category Name="App Management">
             <Command Description="" DisplayName="Deploy" Name="Deploy" Tags="allow_shared" />

deployment_drivers/deploy_from_image/drivermetadata.xml

@@ -1,4 +1,4 @@
-<Driver Description="Deploy App From Image" MainClass="driver.DeployFromImage" Name="VM Deployment From Image" Version="1.0.0">
+<Driver Description="Deploy App From Image" MainClass="driver.DeployFromImage" Name="VM Deployment From Image" Version="1.1.0">
     <Layout>
         <Category Name="App Management">
             <Command Description="" DisplayName="Deploy" Name="Deploy" Tags="allow_shared" />

deployment_drivers/deploy_from_linked_clone/drivermetadata.xml

@@ -1,4 +1,4 @@
-<Driver Description="Deploy App From VM" MainClass="driver.DeployCloneFromVMDriver" Name="Deploy Clone From VM Driver" Version="1.0.0">
+<Driver Description="Deploy App From VM" MainClass="driver.DeployCloneFromVMDriver" Name="Deploy Clone From VM Driver" Version="1.1.0">
     <Layout>
         <Category Name="App Management">
             <Command Description="" DisplayName="Deploy" Name="Deploy" Tags="allow_shared" />

deployment_drivers/deploy_from_template/drivermetadata.xml

@@ -1,4 +1,4 @@
-<Driver Description="Deploy App From Template" MainClass="driver.DeployFromTemplateDriver" Name="VM Deployment From Template" Version="1.0.0">
+<Driver Description="Deploy App From Template" MainClass="driver.DeployFromTemplateDriver" Name="VM Deployment From Template" Version="1.1.0">
     <Layout>
         <Category Name="App Management">
             <Command Description="" DisplayName="Deploy" Name="Deploy" Tags="allow_shared" />

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

@@ -5,6 +5,7 @@
 from cloudshell.cp.vcenter.commands.deploy_vm import DeployCommand
 from cloudshell.cp.vcenter.commands.destroy_vm import DestroyVirtualMachineCommand
 from cloudshell.cp.vcenter.commands.disconnect_dvswitch import VirtualSwitchToMachineDisconnectCommand
+from cloudshell.cp.vcenter.commands.load_vm import VMLoader
 from cloudshell.cp.vcenter.commands.power_manager_vm import VirtualMachinePowerManagementCommand
 from cloudshell.cp.vcenter.commands.refresh_ip import RefreshIpCommand
 from cloudshell.cp.vcenter.common.cloud_shell.driver_helper import CloudshellDriverHelper
@@ -27,6 +28,7 @@
 from cloudshell.cp.vcenter.network.vnic.vnic_service import VNicService
 from cloudshell.cp.vcenter.vm.deploy import VirtualMachineDeployer
 from cloudshell.cp.vcenter.vm.dvswitch_connector import VirtualSwitchToMachineConnector
+from cloudshell.cp.vcenter.vm.ip_manager import VMIPManager
 from cloudshell.cp.vcenter.vm.portgroup_configurer import VirtualMachinePortGroupConfigurer
 from cloudshell.cp.vcenter.vm.vnic_to_network_mapper import VnicToNetworkMapper
 from pyVim.connect import SmartConnect, Disconnect
@@ -51,6 +53,9 @@ def __init__(self):
         resource_remover = CloudshellResourceRemover()
         ovf_service = OvfImageDeployerService(self.resource_model_parser)
 
+
+        self.vm_loader = VMLoader(pv_service)
+
         vm_deployer = VirtualMachineDeployer(pv_service=pv_service,
                                              name_generator=generate_unique_name,
                                              ovf_service=ovf_service,
@@ -104,9 +109,13 @@ def __init__(self):
         self.vm_power_management_command = \
             VirtualMachinePowerManagementCommand(pyvmomi_service=pv_service,
                                                  synchronous_task_waiter=synchronous_task_waiter)
+
+        ip_manager = VMIPManager()
+
         # Refresh IP command
         self.refresh_ip_command = RefreshIpCommand(pyvmomi_service=pv_service,
-                                                   resource_model_parser=ResourceModelParser())
+                                                   resource_model_parser=ResourceModelParser(),
+                                                   ip_manager=ip_manager)
 
     def connect_bulk(self, context, request):
         results = self.command_wrapper.execute_command_with_connection(
@@ -387,3 +396,9 @@ def power_on_not_roemote(self, context, vm_uuid, resource_fullname):
                                                                    vm_uuid,
                                                                    resource_fullname)
         return set_command_result(result=res, unpicklable=False)
+
+    def get_vm_uuid_by_name(self, context, vm_name):
+        res = self.command_wrapper.execute_command_with_connection(context,
+                                                                   self.vm_loader.load_vm_uuid_by_name,
+                                                                   vm_name)
+        return set_command_result(result=res, unpicklable=False)

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

@@ -143,25 +143,34 @@ def _get_remove_mappings(self, req_to_modes, vm):
         if ACTION_TYPE_REMOVE_VLAN in req_to_modes:
             for mode, actions in req_to_modes[ACTION_TYPE_REMOVE_VLAN].items():
                 for action in actions:
-                    interface_attributes = \
-                        [attr.attributeValue for attr in action.connectorAttributes
-                         if attr.attributeName == INTERFACE]
-                    for interface_attribute in interface_attributes:
+                    macs = self._get_macs_from_action(action)
+                    for mac in macs:
                         vm_network_remove_mapping = VmNetworkRemoveMapping()
-                        vm_network_remove_mapping.mac_address = interface_attribute
+                        vm_network_remove_mapping.mac_address = mac
                         vm_network_remove_mapping.vm_uuid = vm
                         remove_mappings.append(vm_network_remove_mapping)
         return remove_mappings
 
+    def _get_macs_from_action(self, action):
+        interface_attributes = \
+            [attr.attributeValue for attr in action.connectorAttributes
+             if attr.attributeName == INTERFACE]
+        macs = []
+        for interface_attribute in interface_attributes:
+            macs += self._split_names(interface_attribute)
+        return macs
+
     def _get_set_mappings(self, req_to_modes):
         set_mappings = []
         if ACTION_TYPE_SET_VLAN in req_to_modes:
             set_requests = req_to_modes[ACTION_TYPE_SET_VLAN]
             for mode, actions in set_requests.items():
                 for action in actions:
                     vnic_name = self._get_vnic_name(action)
-                    vnic_to_network = self._create_map(action.connectionParams.vlanId, mode, vnic_name)
-                    set_mappings.append(vnic_to_network)
+                    vnic_names = self._split_names(vnic_name)
+                    for name in vnic_names:
+                        vnic_to_network = self._create_map(action.connectionParams.vlanId, mode, name)
+                        set_mappings.append(vnic_to_network)
 
         # this line makes sure that the vNICS with names are first
         return sorted(set_mappings, key=lambda x: x.vnic_name, reverse=True)
@@ -220,7 +229,7 @@ def _set_vlan(self, action_mappings, si, vm_uuid, logger):
                 for action in actions:
                     error_result = self._create_error_action_res(action, e)
                     results.append(error_result)
-
+            results = self._consolidate_duplicate_results(results)
         return results
 
     def _prepare_connection_results_for_extraction(self, connection_results):
@@ -256,7 +265,20 @@ def _get_set_vlan_result_suc(self, act_by_mode_by_vlan_by_nic, connection_res_ma
                         result.type = ACTION_TYPE_SET_VLAN
                         result.updatedInterface = res.mac_address
                         results.append(result)
-        return results
+        final_res = self._consolidate_duplicate_results(results)
+        return final_res
+
+    def _consolidate_duplicate_results(self, results):
+        mapping = dict()
+        final_res = []
+        for result in results:
+            self._add_safely_to_dict(value=result, dictionary=mapping, key=result.actionId)
+        for action_id, actions in mapping.items():
+            final_act = actions[0]
+            for action in actions[1:]:
+                final_act.updatedInterface = '{0},{1}'.format(final_act.updatedInterface, action.updatedInterface)
+            final_res.append(final_act)
+        return final_res
 
     def _group_actions_by_vlan_by_vnic(self, set_actions_grouped_by_vlan_id):
         set_act_group_by_mode_by_vlan_by_requsted_vnic = dict()
@@ -266,12 +288,21 @@ def _group_actions_by_vlan_by_vnic(self, set_actions_grouped_by_vlan_id):
                 set_act_group_by_mode_by_vlan_by_requsted_vnic[mode][vlan_id] = dict()
                 for action in actions:
                     name = self._get_vnic_name(action)
-                    self._add_safely_to_dict(
-                        dictionary=set_act_group_by_mode_by_vlan_by_requsted_vnic[mode][vlan_id],
-                        key=name,
-                        value=action)
+                    names = self._split_names(name)
+                    for v_name in names:
+                        self._add_safely_to_dict(
+                            dictionary=set_act_group_by_mode_by_vlan_by_requsted_vnic[mode][vlan_id],
+                            key=v_name,
+                            value=action)
         return set_act_group_by_mode_by_vlan_by_requsted_vnic
 
+    @staticmethod
+    def _split_names(name):
+        if not name:
+            return [name]
+
+        return [v_name for v_name in name.strip().split(',') if v_name]
+
     def _group_action_by_vlan_id(self, set_vlan_actions):
         set_actions_grouped_by_vlan_id = dict()
         for mode, actions in set_vlan_actions.items():
@@ -282,8 +313,7 @@ def _group_action_by_vlan_id(self, set_vlan_actions):
         return set_actions_grouped_by_vlan_id
 
     def _remove_vlan(self, action_mappings, si, vm_uuid, logger):
-
-        results = []
+        final_res = []
         mode_to_actions = action_mappings.action_tree[ACTION_TYPE_REMOVE_VLAN]
         try:
             self.logger.info('disconnecting vm({0})'.format(vm_uuid))
@@ -299,9 +329,10 @@ def _remove_vlan(self, action_mappings, si, vm_uuid, logger):
             interface_to_action = dict()
             for mode, actions in mode_to_actions.items():
                 for action in actions:
-                    name = self._get_mac(action)
-                    interface_to_action[name] = action
-
+                    names = self._get_macs_from_action(action)
+                    for name in names:
+                        interface_to_action[name] = action
+            results = []
             for res in connection_results:
                 action = interface_to_action[res.vnic_mac]
                 action_result = ActionResult()
@@ -312,13 +343,15 @@ def _remove_vlan(self, action_mappings, si, vm_uuid, logger):
                 action_result.errorMessage = None
                 action_result.updatedInterface = res.vnic_mac
                 results.append(action_result)
+            final_res = self._consolidate_duplicate_results(results)
         except Exception as e:
             self.logger.error('Exception raised while disconnecting vm({0}) with exception: {1}'.format(vm_uuid, e))
             for mode, actions in mode_to_actions.items():
                 for action in actions:
                     error_result = self._create_error_action_res(action, e)
-                    results.append(error_result)
-        return results
+                    final_res.append(error_result)
+            final_res = self._consolidate_duplicate_results(final_res)
+        return final_res
 
     @staticmethod
     def _create_error_action_res(action, e):

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

@@ -4,9 +4,10 @@
 class IpReason(Enum):
     Success = 0,
     Timeout = 1,
-    Cancelled = 2
-    
-    
+    Cancelled = 2,
+    NotFound = 3
+
+
 class IpResult(object):
     def __init__(self, ip_address, reason):
         self.ip_address = ip_address

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

@@ -0,0 +1,31 @@
+from cloudshell.cp.vcenter.common.vcenter.vm_location import VMLocation
+from pyVmomi import vim
+
+
+class VMLoader(object):
+    def __init__(self, pv_service):
+        """
+        :type pv_service: cloudshell.cp.vcenter.common.vcenter.vmomi_service.pyVmomiService
+        """
+        self.pv_service = pv_service
+
+    def load_vm_uuid_by_name(self, si, vcenter_data_model, vm_name):
+        """
+        Returns the vm uuid
+        :param si: Service instance to the vcenter
+        :param vcenter_data_model: vcenter data model
+        :param vm_name: the vm name
+        :return: str uuid
+        """
+        path = VMLocation.combine([vcenter_data_model.default_datacenter, vm_name])
+        paths = path.split('/')
+        name = paths[len(paths) - 1]
+        path = VMLocation.combine(paths[:len(paths) - 1])
+        vm = self.pv_service.find_vm_by_name(si, path, name)
+        if not vm:
+            raise ValueError('Could not find the vm in the given path: {0}/{1}'.format(path, name))
+
+        if isinstance(vm, vim.VirtualMachine):
+            return vm.config.uuid
+
+        raise ValueError('The given object is not a vm: {0}/{1}'.format(path, name))

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

@@ -10,9 +10,10 @@ class RefreshIpCommand(object):
     INTERVAL = 5
     IP_V4_PATTERN = re.compile('^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$')
 
-    def __init__(self, pyvmomi_service, resource_model_parser):
+    def __init__(self, pyvmomi_service, resource_model_parser, ip_manager):
         self.pyvmomi_service = pyvmomi_service
         self.resource_model_parser = resource_model_parser
+        self.ip_manager = ip_manager
 
     def refresh_ip(self, si, logger, session, vcenter_data_model, vm_uuid, resource_name, cancellation_context):
         """
@@ -30,36 +31,22 @@ def refresh_ip(self, si, logger, session, vcenter_data_model, vm_uuid, resource_
 
         resource = session.GetResourceDetails(resource_name)
 
-        match_function = self._get_ip_match_function(resource)
+        match_function = self.ip_manager.get_ip_match_function(self._get_ip_refresh_ip_regex(resource))
 
         timeout = self._get_ip_refresh_timeout(resource)
 
         vm = self.pyvmomi_service.find_by_uuid(si, vm_uuid)
 
-        if vm.guest.toolsStatus == 'toolsNotInstalled':
-            logger.warning('VMWare Tools status on virtual machine \'{0}\' are not installed'.format(resource_name))
-            return None
+        ip_res = self.ip_manager.get_ip(vm, default_network, match_function, cancellation_context, timeout, logger)
 
-        ip_result = self._obtain_ip(vm, default_network, match_function, cancellation_context, timeout, logger)
-
-        if ip_result.reason == IpReason.Timeout:
+        if ip_res.reason == IpReason.Timeout:
             raise ValueError('IP address of VM \'{0}\' could not be obtained during {1} seconds'
                              .format(resource_name, timeout))
 
-        if ip_result.reason == IpReason.Success:
-            session.UpdateResourceAddress(resource_name, ip_result.ip_address)
-
-            return ip_result.ip_address
-
-    @staticmethod
-    def _get_ip_match_function(resource):
-        ip_regex = RefreshIpCommand._get_custom_param(
-            resource=resource,
-            custom_param_name='ip_regex')
-
-        ip_regex = ip_regex or '.*'
+        if ip_res.reason == IpReason.Success:
+            session.UpdateResourceAddress(resource_name, ip_res.ip_address)
 
-        return re.compile(ip_regex).match
+            return ip_res.ip_address
 
     @staticmethod
     def _get_ip_refresh_timeout(resource):
@@ -72,6 +59,12 @@ def _get_ip_refresh_timeout(resource):
 
         return float(timeout)
 
+    @staticmethod
+    def _get_ip_refresh_ip_regex(resource):
+        return RefreshIpCommand._get_custom_param(
+            resource=resource,
+            custom_param_name='ip_regex')
+
     @staticmethod
     def _get_custom_param(resource, custom_param_name):
         custom_param_values = []
@@ -87,40 +80,4 @@ def _get_custom_param(resource, custom_param_name):
             return custom_param_values[0]
         return None
 
-    def _obtain_ip(self, vm, default_network, match_function, cancellation_context, timeout, logger):
-        time_elapsed = 0
-        ip = None
-        interval = self.INTERVAL
-        while time_elapsed < timeout and ip is None:
-            if cancellation_context.is_cancelled:
-                return IpResult(ip, IpReason.Cancelled)
-            ips = RefreshIpCommand._get_ip_addresses(vm, default_network)
-            if ips:
-                logger.debug('Filtering IP adresses to limit to IP V4 \'{0}\''.format(','.join(ips)))
-                ips = RefreshIpCommand._select_ip_by_match(ips, RefreshIpCommand.IP_V4_PATTERN.match)
-            if ips:
-                logger.debug('Filtering IP adresses by custom IP Regex'.format(','.join(ips)))
-                ips = RefreshIpCommand._select_ip_by_match(ips, match_function)
-            if ips:
-                ip = ips[0]
-                if ip:
-                    return IpResult(ip, IpReason.Success)
-            time_elapsed += interval
-            time.sleep(interval)
-        return IpResult(ip, IpReason.Timeout)
 
-    @staticmethod
-    def _get_ip_addresses(vm, default_network):
-        ips = []
-        if vm.guest.ipAddress:
-            ips.append(vm.guest.ipAddress)
-        for nic in vm.guest.net:
-            if nic.network != default_network:
-                for addr in nic.ipAddress:
-                    if addr:
-                        ips.append(addr)
-        return ips
-
-    @staticmethod
-    def _select_ip_by_match(ips, match_function):
-        return [ip for ip in ips if match_function(ip)]