Merge pull request #111 from QualiSystems/feature/borismod_40_save_vnic

Feature/borismod 40 save vnic

Author: borismod

common/vcenter/vmomi_service.py

@@ -191,10 +191,7 @@ def find_obj_by_path(self, si, path, name, type_name):
 
         search_index = si.content.searchIndex
         '#searches for the specific vm in the folder'
-        res = search_index.FindChild(look_in, name)
-        if res:
-            return res
-        raise KeyError('vmomi managed object not found at: {0}'.format(path))
+        return search_index.FindChild(look_in, name)
 
     def get_folder(self, si, path):
         """

integration/integration_commands/integration_test_connect.py

@@ -56,7 +56,7 @@ def integration_test_connect_B(self):
         vm_uuid = py_vmomi_service.find_vm_by_name(si, 'QualiSB/Boris', 'Boris2-win7').config.uuid
 
         mapping = VmNetworkMapping()
-        mapping.vlan_id = 65
+        mapping.vlan_id = '114'
         # mapping.dv_port_name = 65
         mapping.dv_switch_name = 'dvSwitch'
         mapping.dv_switch_path = 'QualiSB'

integration/integration_commands/integration_test_refresh_ip.py

@@ -34,3 +34,29 @@ def integrationtest_refresh_ip(self):
         refresh_ip_command.refresh_ip(uuid, '')
 
         pass
+
+    def integrationtest_refresh_ip(self):
+        resource_context = Mock()
+        resource_context.attributes = {"vCenter Template": "vCenter/Boris/Boris2-win7"}
+        qualipy_helpers = Mock()
+        qualipy_helpers.get_resource_context_details = Mock(return_value=resource_context)
+
+        credentials = TestCredentials()
+        py_vmomi_service = pyVmomiService(SmartConnect, Disconnect)
+        cloudshell_data_retriever_service = Mock()
+        cloudshell_data_retriever_service.getVCenterConnectionDetails = Mock(
+                return_value=VCenterConnectionDetails(credentials.host, credentials.username, credentials.password))
+
+        vm_resource = Mock()
+        vm_resource.default_network = 'default'
+
+        resource_model_parser = Mock()
+        resource_model_parser.convert_to_resource_model = Mock(return_value=vm_resource)
+
+        refresh_ip_command = RefreshIpCommand(py_vmomi_service, cloudshell_data_retriever_service, qualipy_helpers,
+                                              resource_model_parser)
+
+        uuid = helpers.get_uuid('Boris2-win7')
+        refresh_ip_command.refresh_ip(uuid, '')
+
+        pass

tests/test_network/vlan/test_range_parser.py

@@ -6,18 +6,24 @@
 class TestVLanIdRangeParser(TestCase):
     def test_one_numer(self):
         v_lan_id_range_parser = VLanIdRangeParser()
-        vlan_id = v_lan_id_range_parser.parse_vlan_id('11')
+        vlan_id = v_lan_id_range_parser.parse_vlan_id('Trunk', '11')
 
         self.assertEqual(vlan_id[0].start, 11)
         self.assertEqual(vlan_id[0].end, 11)
 
     def test_two_numbers_with_dash(self):
         v_lan_id_range_parser = VLanIdRangeParser()
-        vlan_id = v_lan_id_range_parser.parse_vlan_id('11-100')
+        vlan_id = v_lan_id_range_parser.parse_vlan_id('Trunk', '11-100')
 
         self.assertEqual(vlan_id[0].start, 11)
         self.assertEqual(vlan_id[0].end, 100)
 
+    def test_two_numbers_with_dash(self):
+        v_lan_id_range_parser = VLanIdRangeParser()
+        vlan_id = v_lan_id_range_parser.parse_vlan_id('Access', '100')
+
+        self.assertEqual(vlan_id, 100)
+
     def test_parse_vlan_id(self):
         v_lan_id_range_parser = VLanIdRangeParser()
-        self.assertRaises(Exception, v_lan_id_range_parser.parse_vlan_id, None)
+        self.assertRaises(Exception, v_lan_id_range_parser.parse_vlan_id, '', None)

vCenterShell/bootstrap.py

@@ -6,7 +6,6 @@
 from common.cloudshell.resource_remover import CloudshellResourceRemover
 from common.logger import getLogger
 from common.model_factory import ResourceModelParser
-from common.utilites.common_name import generate_unique_name
 from common.vcenter.data_model_retriever import VCenterDataModelRetriever
 from common.vcenter.task_waiter import SynchronousTaskWaiter
 from common.vcenter.vmomi_service import pyVmomiService
@@ -39,7 +38,7 @@ def __init__(self):
                                                                                    cloudshell_data_retriever_service)
         resource_remover = CloudshellResourceRemover(helpers)
         command_wrapper = CommandWrapper(getLogger, py_vmomi_service)
-        name_generator = generate_unique_name
+        name_generator = DvPortGroupNameGenerator()
         template_deployer = VirtualMachineDeployer(py_vmomi_service, name_generator)
 
         deploy_from_template_command = DeployFromTemplateCommand(template_deployer)

vCenterShell/command_executer.py

@@ -44,6 +44,7 @@ def connect(self):
         dv_switch_path = self.vcenter_resource_model.default_dvswitch_path
         dv_switch_name = self.vcenter_resource_model.default_dvswitch_name
         port_group_path = self.vcenter_resource_model.default_port_group_path
+        default_network = self.vcenter_resource_model.default_network
 
         vnic_to_network = VmNetworkMapping()
         vnic_to_network.dv_switch_path = dv_switch_path
@@ -60,7 +61,8 @@ def connect(self):
                 connection_details,
                 self.virtual_switch_connect_command.connect_to_networks,
                 uuid,
-                [vnic_to_network])
+                [vnic_to_network],
+                default_network)
 
     def disconnect_all(self):
         vcener_name = self.qualipy_helpers.get_user_param('VCENTER_NAME')

vCenterShell/commands/connect_dvswitch.py

@@ -37,12 +37,15 @@ def connect_to_networks(self, si, vm_uuid, vm_network_mappings, default_network_
         mappings = []
         # create mapping
         for vm_network_mapping in vm_network_mappings:
-            vm_network_mapping.vlan_id_range = \
-                self.vlan_id_range_parser.parse_vlan_id(vm_network_mapping.vlan_id)
             vm_network_mapping.dv_port_name = \
                 self.dv_port_group_name_generator.generate_port_group_name(vm_network_mapping.vlan_id)
+
+            vm_network_mapping.vlan_id = \
+                self.vlan_id_range_parser.parse_vlan_id(vm_network_mapping.vlan_spec, vm_network_mapping.vlan_id)
+
             vm_network_mapping.vlan_spec = \
                 self.vlan_spec_factory.get_vlan_spec(vm_network_mapping.vlan_spec)
+
             mappings.append(vm_network_mapping)
 
         return self.virtual_switch_to_machine_connector.connect_by_mapping(

vCenterShell/network/dvswitch/creator.py

@@ -79,7 +79,10 @@ def get_or_create_network(self,
         # if we didn't found the network on the vm
         if network is None:
             # try to get it from the vcenter
-            network = self.pyvmomi_service.find_network_by_name(si, port_group_path, dv_port_name)
+            try:
+                network = self.pyvmomi_service.find_network_by_name(si, port_group_path, dv_port_name)
+            except KeyError:
+                network = None
 
         # if we still couldn't get the network ---> create it(can't find it, play god!)
         if network is None:

vCenterShell/network/vlan/range_parser.py

@@ -1,20 +1,28 @@
 from pyVmomi import vim
 
+from common.utilites.common_utils import represents_int
+
 
 class VLanIdRangeParser(object):
     def __init__(self):
         pass
 
-    def parse_vlan_id(self, vlan_id):
-
-        if not vlan_id:
-            raise Exception('VLAN should be a number or range in format 1-100')
-        vlan_parts = str(vlan_id).split("-")
-        if len(vlan_parts) > 2:
-            raise Exception('VLAN should be a number or range in format 1-100')
-        if len(vlan_parts) == 1:
-            return [vim.NumericRange(start=int(vlan_parts[0]), end=int(vlan_parts[0]))]
-        if len(vlan_parts) == 2:
-            start_port = int(vlan_parts[0])
-            end_port = int(vlan_parts[1])
-            return [vim.NumericRange(start=start_port, end=end_port)]
+    @staticmethod
+    def parse_vlan_id(vlan_type, vlan_id):
+        if vlan_type == 'Access':
+            if represents_int(vlan_id):
+                return int(vlan_id)
+            raise KeyError('Access supports only int vlan id')
+        elif vlan_type == 'Trunk':
+            if not vlan_id:
+                raise Exception('VLAN should be a number or range in format 1-100')
+            vlan_parts = str(vlan_id).split("-")
+            if len(vlan_parts) > 2:
+                raise Exception('VLAN should be a number or range in format 1-100')
+            if len(vlan_parts) == 1:
+                return [vim.NumericRange(start=int(vlan_parts[0]), end=int(vlan_parts[0]))]
+            if len(vlan_parts) == 2:
+                start_port = int(vlan_parts[0])
+                end_port = int(vlan_parts[1])
+                return [vim.NumericRange(start=start_port, end=end_port)]
+        raise KeyError('vlan type: {0} is not supported'.format(vlan_type))

vCenterShell/vm/vnic_to_network_mapper.py

@@ -28,7 +28,7 @@ def map_request_to_vnics(self, requests, vnics, existing_network, default_networ
 
     def _find_available_vnic(self, vnics_to_network_mapping, default_network):
         for vnic_name, network_name in vnics_to_network_mapping.items():
-            if network_name == default_network:
+            if network_name == default_network.name:
                 return vnic_name
         raise Exception('no vnic available')
 
@@ -39,12 +39,12 @@ def _map_vnic_to_network(self, vnics, existing_network, default_network):
             if hasattr(vnic, 'backing'):
                 if hasattr(vnic.backing, 'network') and hasattr(vnic.backing.network, 'name'):
                     network_to_map = vnic.backing.network.name
-                elif hasattr(vnic.backing, 'port') and hasattr(vnic.backing.port, 'key'):
-                    network_to_map = self._get_network_name_from_key(vnic.backing.port.key,
+                elif hasattr(vnic.backing, 'port') and hasattr(vnic.backing.port, 'portgroupKey'):
+                    network_to_map = self._get_network_name_from_key(vnic.backing.port.portgroupKey,
                                                                      existing_network, default_network)
 
             if not self.quali_name_generator.is_generated_name(network_to_map):
-                network_to_map = default_network
+                network_to_map = default_network.name
             mapping[vnic_name] = network_to_map
 
         if mapping:
@@ -54,6 +54,6 @@ def _map_vnic_to_network(self, vnics, existing_network, default_network):
     @staticmethod
     def _get_network_name_from_key(key, existing_network, default_network):
         for network in existing_network:
-            if hasattr(network, 'name') and hasattr(network, 'portgroupKey') and network.portgroupKey == key:
+            if hasattr(network, 'name') and hasattr(network, 'key') and network.key == key:
                 return network.name
         return default_network