task #722 ability to turn promiscuous mode on off

integration/integration_commands/integration_test_connect.py

@@ -46,7 +46,7 @@ def integration_test_connect_A(self):
         vm = py_vmomi_service.find_vm_by_name(si, 'QualiSB/Raz', '2')
 
         # Act
-        connector.connect_by_mapping(si, vm, [mapping], None, [])
+        connector.connect_by_mapping(si, vm, [mapping], None, [], Mock(), 'True')
 
         pass
 
@@ -77,7 +77,7 @@ def integration_test_connect_B(self):
 
         command = VirtualSwitchConnectCommand(py_vmomi_service, connector, name_gen, vlan_spec, range_fac, Mock())
 
-        command.connect_to_networks(si, vm_uuid, [mapping], 'QualiSB/anetwork', [])
+        command.connect_to_networks(si, vm_uuid, [mapping], 'QualiSB/anetwork', [], 'True')
 
     def test_integration(self):
         self.integration_test_connect_A()

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

@@ -22,7 +22,7 @@ def __init__(self,
         self.vlan_id_range_parser = vlan_id_range_parser
 
     def connect_to_networks(self, si, logger, vm_uuid, vm_network_mappings, default_network_name,
-                            reserved_networks, dv_switch_name):
+                            reserved_networks, dv_switch_name, promiscuous_mode):
         """
         Connect VM to Network
         :param si: VmWare Service Instance - defined connection to vCenter
@@ -32,6 +32,7 @@ def connect_to_networks(self, si, logger, vm_uuid, vm_network_mappings, default_
         :param default_network_name: <str> Full Network name - likes 'DataCenterName/NetworkName'
         :param reserved_networks:
         :param dv_switch_name: <str> Default dvSwitch name
+        :param promiscuous_mode <str> 'True' or 'False' turn on/off promiscuous mode for the port group
         :return: None
         """
         vm = self.pv_service.find_by_uuid(si, vm_uuid)
@@ -47,7 +48,7 @@ def connect_to_networks(self, si, logger, vm_uuid, vm_network_mappings, default_
         mappings = self._prepare_mappings(dv_switch_name=dv_switch_name, vm_network_mappings=vm_network_mappings)
 
         updated_mappings = self.virtual_switch_to_machine_connector.connect_by_mapping(
-            si, vm, mappings, default_network_instance, reserved_networks, logger)
+            si, vm, mappings, default_network_instance, reserved_networks, logger, promiscuous_mode)
 
         connection_results = []
         for updated_mapping in updated_mappings:

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

@@ -210,13 +210,15 @@ def _set_vlan(self, action_mappings, si, vm_uuid, logger):
             self.logger.debug('connecting vm({0}) with the mappings'.format(vm_uuid,
                                                                             jsonpickle.encode(action_mappings,
                                                                                               unpicklable=False)))
-            connection_results = self.connector.connect_to_networks(si=si,
-                                                                    logger=logger,
-                                                                    vm_uuid=vm_uuid,
-                                                                    vm_network_mappings=action_mappings.set_mapping,
-                                                                    default_network_name=self.default_network,
-                                                                    reserved_networks=self.reserved_networks,
-                                                                    dv_switch_name=self.dv_switch_name)
+            connection_results = self.connector.connect_to_networks(
+                si=si,
+                logger=logger,
+                vm_uuid=vm_uuid,
+                vm_network_mappings=action_mappings.set_mapping,
+                default_network_name=self.default_network,
+                reserved_networks=self.reserved_networks,
+                dv_switch_name=self.dv_switch_name,
+                promiscuous_mode=self.vcenter_data_model.promiscuous_mode)
 
             connection_res_map = self._prepare_connection_results_for_extraction(connection_results)
             act_by_mode_by_vlan = self._group_action_by_vlan_id(set_vlan_actions)

package/cloudshell/cp/vcenter/models/VMwarevCenterResourceModel.py

@@ -13,3 +13,4 @@ def __init__(self):
         self.execution_server_selector = '' 
         self.reserved_networks = ''
         self.default_datacenter = ''
+        self.promiscuous_mode = ''

package/cloudshell/cp/vcenter/network/dvswitch/creator.py

@@ -24,7 +24,8 @@ def get_or_create_network(self,
                               dv_switch_path,
                               vlan_id,
                               vlan_spec,
-                              logger):
+                              logger,
+                              promiscuous_mode):
         network = None
         error = None
         self._lock.acquire()
@@ -50,7 +51,8 @@ def get_or_create_network(self,
                                            si,
                                            vlan_spec,
                                            vlan_id,
-                                           logger)
+                                           logger,
+                                           promiscuous_mode)
                 network = self.pyvmomi_service.find_network_by_name(si, dv_switch_path, dv_port_name)
 
             if not network:
@@ -63,20 +65,21 @@ def get_or_create_network(self,
                 raise error
             return network
 
-    def _create_dv_port_group(self, dv_port_name, dv_switch_name, dv_switch_path, si, spec, vlan_id, logger):
+    def _create_dv_port_group(self, dv_port_name, dv_switch_name, dv_switch_path, si, spec, vlan_id,
+                              logger, promiscuous_mode):
         dv_switch = self.pyvmomi_service.get_folder(si, '{0}/{1}'.format(dv_switch_path, dv_switch_name))
         if not dv_switch:
             raise ValueError('DV Switch {0} not found in path {1}'.format(dv_switch_name, dv_switch_path))
 
         task = DvPortGroupCreator.dv_port_group_create_task(dv_port_name, dv_switch, spec, vlan_id,
-                                                            logger=logger)
+                                                            logger, promiscuous_mode)
         self.synchronous_task_waiter.wait_for_task(task=task,
                                                    logger=logger,
                                                    action_name='Create dv port group',
                                                    hide_result=False)
 
     @staticmethod
-    def dv_port_group_create_task(dv_port_name, dv_switch, spec, vlan_id, logger, num_ports=32):
+    def dv_port_group_create_task(dv_port_name, dv_switch, spec, vlan_id, logger, promiscuous_mode, num_ports=32):
         """
         Create ' Distributed Virtual Portgroup' Task
         :param dv_port_name: <str>  Distributed Virtual Portgroup Name
@@ -85,6 +88,7 @@ def dv_port_group_create_task(dv_port_name, dv_switch, spec, vlan_id, logger, nu
         :param vlan_id: <int>
         :param logger:
         :param num_ports: <int> number of ports in this Group
+        :param promiscuous_mode <str> 'True' or 'False' turn on/off promiscuous mode for the port group
         :return: <vim.Task> Task which really provides update
         """
 
@@ -98,7 +102,9 @@ def dv_port_group_create_task(dv_port_name, dv_switch, spec, vlan_id, logger, nu
 
         dv_pg_spec.defaultPortConfig.vlan = spec
         dv_pg_spec.defaultPortConfig.vlan.vlanId = vlan_id
-        dv_pg_spec.defaultPortConfig.securityPolicy.allowPromiscuous = vim.BoolPolicy(value=True)
+
+        promiscuous_mode = promiscuous_mode.lower() == 'true'
+        dv_pg_spec.defaultPortConfig.securityPolicy.allowPromiscuous = vim.BoolPolicy(value=promiscuous_mode)
         dv_pg_spec.defaultPortConfig.securityPolicy.forgedTransmits = vim.BoolPolicy(value=True)
 
         dv_pg_spec.defaultPortConfig.vlan.inherited = False

package/cloudshell/cp/vcenter/vm/dvswitch_connector.py

@@ -39,7 +39,7 @@ def __init__(self,
         self.dv_port_group_creator = dv_port_group_creator
         self.virtual_machine_port_group_configurer = virtual_machine_port_group_configurer
 
-    def connect_by_mapping(self, si, vm, mapping, default_network, reserved_networks, logger):
+    def connect_by_mapping(self, si, vm, mapping, default_network, reserved_networks, logger, promiscuous_mode):
         """
         gets the mapping to the vnics and connects it to the vm
         :param default_network:
@@ -48,6 +48,7 @@ def connect_by_mapping(self, si, vm, mapping, default_network, reserved_networks
         :param mapping: [VmNetworkMapping]
         :param reserved_networks:
         :param logger:
+        :param promiscuous_mode <str> 'True' or 'False' turn on/off promiscuous mode for the port group
         """
         request_mapping = []
 
@@ -62,7 +63,8 @@ def connect_by_mapping(self, si, vm, mapping, default_network, reserved_networks
                                                                        network_map.dv_switch_path,
                                                                        network_map.vlan_id,
                                                                        network_map.vlan_spec,
-                                                                       logger=logger)
+                                                                       logger,
+                                                                       promiscuous_mode)
 
             request_mapping.append(ConnectRequest(network_map.vnic_name, network))
 

package/cloudshell/tests/test_commands/test_connect_orchestrator.py

@@ -22,6 +22,7 @@ def setUp(self):
         self.vc_data_model.default_network = 'Anetwork'
         self.vc_data_model.default_datacenter = 'datacenter'
         self.vc_data_model.holding_network = 'Holding Network'
+        self.vc_data_model.promiscuous_mode = 'True'
 
         self.si = Mock()
 
@@ -39,6 +40,7 @@ def test_connect_bulk_dvswitch_is_None(self):
         vc_data_model.default_network = 'Anetwork'
         vc_data_model.default_datacenter = 'datacenter'
         vc_data_model.holding_network = 'Holding Network'
+        self.vc_data_model.promiscuous_mode = 'True'
 
         request, expected = self._get_missing_dv_switch_params()
         results = self.ConnectionCommandOrchestrator.connect_bulk(si=self.si,

package/cloudshell/tests/test_commands/test_connect_vm.py

@@ -49,20 +49,22 @@ def test_connect_vnic_to_network(self):
         mapping.vlan_spec = 'trunc'
         mapping.dv_port_name = 'port_name'
         mapping.network = Mock()
+        logger = Mock()
 
         # act
         connect_results = connect_command.connect_to_networks(si=self.si,
-                                                              logger=Mock(),
+                                                              logger=logger,
                                                               vm_uuid=self.vm_uuid,
                                                               vm_network_mappings=[mapping],
                                                               default_network_name='default_network',
                                                               reserved_networks=[],
-                                                              dv_switch_name='')
+                                                              dv_switch_name='',
+                                                              promiscuous_mode='True')
 
         # assert
         self.assertTrue(self.vlan_id_range_parser.parse_vlan_id.called_with(self.vlan_id))
         self.assertTrue(
             self.dv_port_name_gen.generate_port_group_name.called_with(self.vlan_id, self.vlan_spec_factory))
         self.assertTrue(self.vlan_spec_factory.get_vlan_spec.called_with(self.spec_type))
-        self.assertTrue(self.dv_connector.connect_by_mapping.called_with(self.si, self.vm, [mapping]))
+        self.assertTrue(self.dv_connector.connect_by_mapping.called_with(self.si, self.vm, [mapping], logger, 'True'))
         self.assertEqual(connect_results[0].mac_address, 'AA-BB')

package/cloudshell/tests/test_common/test_vcenter/test_vcenter_data_model_retriever.py

@@ -28,7 +28,8 @@ def test_get_vcenter_data_model(self):
                                    'ovf_tool_path': '',
                                    'execution_server_selector': '',
                                    'reserved_networks': '',
-                                   'default_datacenter': ''}
+                                   'default_datacenter': '',
+                                   'promiscuous_mode': ''}
 
         api.GetResourceDetails = Mock(return_value=vcenter_resource)
 
@@ -57,7 +58,8 @@ def test_get_vcenter_data_model_empty_vcenter_name(self):
                                    'ovf_tool_path': '',
                                    'execution_server_selector': '',
                                    'reserved_networks': '',
-                                   'default_datacenter': ''}
+                                   'default_datacenter': '',
+                                   'promiscuous_mode': ''}
 
         api.GetResourceDetails = Mock(return_value=vcenter_resource)
 

package/cloudshell/tests/test_network/test_dvswitch/test_connector.py

@@ -85,12 +85,12 @@ def test_map_vnc(self):
         self.connector.virtual_machine_port_group_configurer.connect_by_mapping = Mock(return_value="OK")
         self.connector.connect_and_get_vm = Mock(return_value=(1, 1,))
 
-        res = self.connector.connect_by_mapping(self.si, self.vm, [], 'default_network', [], logger=Mock())
+        res = self.connector.connect_by_mapping(self.si, self.vm, [], 'default_network', [], Mock(), 'True')
         self.assertEqual(res, 'OK')
-        res = self.connector.connect_by_mapping(self.si, self.vm, [], None, [], logger=Mock())
+        res = self.connector.connect_by_mapping(self.si, self.vm, [], None, [], Mock(), 'True')
         self.assertEqual(res, 'OK')
 
-        res = self.connector.connect_by_mapping(self.si, self.vm, mapp, 'default_network', [], logger=Mock())
+        res = self.connector.connect_by_mapping(self.si, self.vm, mapp, 'default_network', [], Mock(), 'True')
         self.assertEqual(res, 'OK')
-        res = self.connector.connect_by_mapping(self.si, self.vm, mapp, None, [], logger=Mock())
+        res = self.connector.connect_by_mapping(self.si, self.vm, mapp, None, [], Mock(), 'True')
         self.assertEqual(res, 'OK')

package/cloudshell/tests/test_network/test_dvswitch/test_creator.py

@@ -38,7 +38,8 @@ def test_create_dv_port_group(self):
                                                     create_autospec(spec=vim.ServiceInstance),
                                                     spec=None,
                                                     vlan_id=1001,
-                                                    logger=Mock())
+                                                    logger=Mock(),
+                                                    promiscuous_mode="True")
 
         # Assert
         self.assertTrue(dv_port_group_creator.dv_port_group_create_task.called)
@@ -59,6 +60,7 @@ def test_dv_port_group_create_task(self):
                                                         spec=spec,
                                                         vlan_id=1001,
                                                         logger=Mock(),
+                                                        promiscuous_mode="True",
                                                         num_ports=32)
 
         # assert

package/cloudshell/tests/test_vm/test_dvswitch_connector.py

@@ -43,7 +43,8 @@ def test_connect(self):
                                                                mapping=[network_map],
                                                                default_network=Mock(spec=vim.Network),
                                                                reserved_networks=[],
-                                                               logger=Mock())
+                                                               logger=Mock(),
+                                                               promiscuous_mode='True')
 
     def integrationtest(self):
         resource_connection_details_retriever = Mock()

vCenterShellPackage/Configuration/shellconfig.xml

@@ -23,6 +23,7 @@ xmlns="http://schemas.qualisystems.com/ResourceManagement/ShellsConfigurationSch
 			<Attribute Name="OVF Tool Path" Value="C:\Program Files (x86)\VMware\VMware Workstation\OVFTool\ovftool.exe" />
 			<Attribute Name="Execution Server Selector" Value="" />
 			<Attribute Name="Reserved Networks" Value="" />
+			<Attribute Name="Promiscuous Mode" Value="True" />
         </Attributes>
     </ResourceTemplate>
 </ResourceTemplates>

vCenterShellPackage/DataModel/datamodel.xml

@@ -170,6 +170,12 @@
         <ns0:Rule Name="Setting" />
       </ns0:Rules>
     </ns0:AttributeInfo>
+    <ns0:AttributeInfo DefaultValue="true" Description="If enabled the port groups on the virtual switch will be configured to allow promiscuous mode." IsReadOnly="false" Name="Promiscuous Mode" Type="Boolean">
+      <ns0:Rules>
+        <ns0:Rule Name="Configuration" />
+        <ns0:Rule Name="Setting" />
+      </ns0:Rules>
+    </ns0:AttributeInfo>
   </ns0:Attributes>
   <ns0:ResourceFamilies>
     <ns0:ResourceFamily Description="" IsAdminOnly="true" IsSearchable="true" Name="Cloud Provider">
@@ -220,6 +226,9 @@
             <ns0:AttachedAttribute IsLocal="true" IsOverridable="true" Name="Reserved Networks">
               <ns0:AllowedValues />
             </ns0:AttachedAttribute>
+            <ns0:AttachedAttribute IsLocal="true" IsOverridable="true" Name="Promiscuous Mode">
+              <ns0:AllowedValues />
+            </ns0:AttachedAttribute>
           </ns0:AttachedAttributes>
           <ns0:AttributeValues>
             <ns0:AttributeValue Name="Reserved Networks" Value="" />
@@ -234,6 +243,7 @@
             <ns0:AttributeValue Name="Shutdown Method" Value="hard" />
             <ns0:AttributeValue Name="OVF Tool Path" Value="C:\Program Files (x86)\VMware\VMware Workstation\OVFTool\ovftool.exe" />
             <ns0:AttributeValue Name="Execution Server Selector" Value="" />
+            <ns0:AttributeValue Name="Promiscuous Mode" Value="true" />
           </ns0:AttributeValues>
           <ns0:ParentModels />
           <ns0:Drivers>