예제 #1
0
    def test_create_dv_port_group(self):
        # Arrange
        dv_switch = create_autospec(spec=vim.DistributedVirtualSwitch)
        dv_switch.portgroup = Mock()
        pyvmomy_service = Mock()
        pyvmomy_service.find_network_by_name = Mock(return_value=dv_switch)
        synchronous_task_waiter = Mock()
        dv_port_group_creator = DvPortGroupCreator(pyvmomy_service,
                                                   synchronous_task_waiter)
        dv_port_group_create_task_prev = DvPortGroupCreator.__dict__[
            'dv_port_group_create_task']
        DvPortGroupCreator.dv_port_group_create_task = Mock()

        # Act
        dv_port_group_creator._create_dv_port_group(
            'port_name',
            'switch_name',
            'switch_path',
            create_autospec(spec=vim.ServiceInstance),
            spec=None,
            vlan_id=1001,
            logger=Mock(),
            promiscuous_mode="True")

        # Assert
        self.assertTrue(dv_port_group_creator.dv_port_group_create_task.called)
        setattr(DvPortGroupCreator, 'dv_port_group_create_task',
                dv_port_group_create_task_prev)
    def integration_test_connect_B(self):
        py_vmomi_service = pyVmomiService(SmartConnect, Disconnect)
        cred = TestCredentials()
        si = py_vmomi_service.connect(cred.host, cred.username, cred.password,
                                      cred.port)
        vm_uuid = py_vmomi_service.find_vm_by_name(si, 'QualiSB/Boris',
                                                   'Boris2-win7').config.uuid

        mapping = VmNetworkMapping()
        mapping.vlan_id = '114'
        # mapping.dv_port_name = 65
        mapping.dv_switch_name = 'dvSwitch'
        mapping.dv_switch_path = 'QualiSB'
        mapping.vlan_spec = 'Trunk'

        vlan_spec = VlanSpecFactory()
        range_fac = VLanIdRangeParser()
        synchronous_task_waiter = SynchronousTaskWaiter()
        name_gen = DvPortGroupNameGenerator()
        mapper = VnicToNetworkMapper(name_gen)
        dv_port_group_creator = DvPortGroupCreator(py_vmomi_service,
                                                   synchronous_task_waiter)
        virtual_machine_port_group_configurer = VirtualMachinePortGroupConfigurer(
            py_vmomi_service, synchronous_task_waiter, mapper, VNicService())
        connector = VirtualSwitchToMachineConnector(
            dv_port_group_creator, virtual_machine_port_group_configurer)

        command = VirtualSwitchConnectCommand(py_vmomi_service, connector,
                                              name_gen, vlan_spec, range_fac,
                                              Mock())

        command.connect_to_networks(si, vm_uuid, [mapping], 'QualiSB/anetwork',
                                    [])
    def integration_test_connect_A(self):
        py_vmomi_service = pyVmomiService(SmartConnect, Disconnect)
        cred = TestCredentials()
        si = py_vmomi_service.connect(cred.host, cred.username, cred.password,
                                      cred.port)
        synchronous_task_waiter = SynchronousTaskWaiter()
        mapper = VnicToNetworkMapper(DvPortGroupNameGenerator())
        dv_port_group_creator = DvPortGroupCreator(py_vmomi_service,
                                                   synchronous_task_waiter)
        port_group_name_generator = DvPortGroupNameGenerator()
        virtual_machine_port_group_configurer = VirtualMachinePortGroupConfigurer(
            py_vmomi_service, synchronous_task_waiter, mapper, VNicService(),
            port_group_name_generator)

        mapping = VmNetworkMapping()
        mapping.vlan_id = [vim.NumericRange(start=65, end=65)]
        mapping.dv_port_name = DvPortGroupNameGenerator(
        ).generate_port_group_name(65, 'Trunk')
        mapping.dv_switch_name = 'dvSwitch'
        mapping.dv_switch_path = 'QualiSB'
        mapping.vlan_spec = vim.dvs.VmwareDistributedVirtualSwitch.TrunkVlanSpec(
        )
        connector = VirtualSwitchToMachineConnector(
            dv_port_group_creator, virtual_machine_port_group_configurer)

        vm = py_vmomi_service.find_vm_by_name(si, 'QualiSB/Raz', '2')

        # Act
        connector.connect_by_mapping(si, vm, [mapping], None, [])

        pass
예제 #4
0
    def test_dv_port_group_create_task(self):
        # arrange
        pyvmomy_service = Mock()
        synchronous_task_waiter = Mock()
        dv_port_group_creator = DvPortGroupCreator(pyvmomy_service, synchronous_task_waiter)
        dv_switch = create_autospec(spec=vim.DistributedVirtualSwitch)
        dv_switch.AddDVPortgroup_Task = Mock()
        spec = create_autospec(spec=vim.dvs.VmwareDistributedVirtualSwitch.VlanSpec)

        # act
        dv_port_group_creator.dv_port_group_create_task(dv_port_name='dv_port_name',
                                                        dv_switch=dv_switch,
                                                        spec=spec,
                                                        vlan_id=1001,
                                                        logger=Mock(),
                                                        num_ports=32)

        # assert
        self.assertTrue(dv_switch.AddDVPortgroup_Task.called)
예제 #5
0
    def test_create_dv_port_group(self):
        # Arrange
        dv_switch = create_autospec(spec=vim.DistributedVirtualSwitch)
        dv_switch.portgroup = Mock()
        pyvmomy_service = Mock()
        pyvmomy_service.find_network_by_name = Mock(return_value=dv_switch)
        synchronous_task_waiter = Mock()
        dv_port_group_creator = DvPortGroupCreator(pyvmomy_service, synchronous_task_waiter)
        dv_port_group_create_task_prev = DvPortGroupCreator.__dict__['dv_port_group_create_task']
        DvPortGroupCreator.dv_port_group_create_task = Mock()

        # Act
        dv_port_group_creator._create_dv_port_group('port_name', 'switch_name', 'switch_path',
                                                    create_autospec(spec=vim.ServiceInstance),
                                                    spec=None,
                                                    vlan_id=1001,
                                                    logger=Mock())

        # Assert
        self.assertTrue(dv_port_group_creator.dv_port_group_create_task.called)
        setattr(DvPortGroupCreator, 'dv_port_group_create_task', dv_port_group_create_task_prev)
예제 #6
0
    def test_create_dv_port_group_exception(self):
        # Arrange
        pyvmomy_service = Mock()
        pyvmomy_service.find_network_by_name = Mock(return_value=None)
        synchronous_task_waiter = Mock()

        # Act
        dv_port_group_creator = DvPortGroupCreator(pyvmomy_service, synchronous_task_waiter)

        # Assert
        self.assertRaises(Exception,
                          dv_port_group_creator._create_dv_port_group, 'port_name', 'switch_name', 'switch_path',
                          Mock(),
                          None, None, Mock())
 def destroy_port_group_task(network):
     if network_is_portgroup(network):
         task = DvPortGroupCreator.dv_port_group_destroy_task(network)
         return task
     return None
예제 #8
0
    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()
        port_group_name_generator = DvPortGroupNameGenerator()

        vnic_to_network_mapper = VnicToNetworkMapper(
            quali_name_generator=port_group_name_generator)
        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,
            cs_helper=self.cs_helper,
            resource_model_parser=ResourceModelParser())

        dv_port_group_creator = DvPortGroupCreator(
            pyvmomi_service=pv_service,
            synchronous_task_waiter=synchronous_task_waiter)
        virtual_machine_port_group_configurer = \
            VirtualMachinePortGroupConfigurer(pyvmomi_service=pv_service,
                                              synchronous_task_waiter=synchronous_task_waiter,
                                              vnic_to_network_mapper=vnic_to_network_mapper,
                                              vnic_service=VNicService(),
                                              name_gen=port_group_name_generator)
        virtual_switch_to_machine_connector = VirtualSwitchToMachineConnector(
            dv_port_group_creator, 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
        self.deploy_command = DeployCommand(deployer=vm_deployer)

        # Virtual Switch Revoke
        self.virtual_switch_disconnect_command = \
            VirtualSwitchToMachineDisconnectCommand(
                pyvmomi_service=pv_service,
                port_group_configurer=virtual_machine_port_group_configurer,
                resource_model_parser=self.resource_model_parser)

        # Virtual Switch Connect
        virtual_switch_connect_command = \
            VirtualSwitchConnectCommand(
                pv_service=pv_service,
                virtual_switch_to_machine_connector=virtual_switch_to_machine_connector,
                dv_port_group_name_generator=DvPortGroupNameGenerator(),
                vlan_spec_factory=VlanSpecFactory(),
                vlan_id_range_parser=VLanIdRangeParser())
        self.connection_orchestrator = ConnectionCommandOrchestrator(
            connector=virtual_switch_connect_command,
            disconnector=self.virtual_switch_disconnect_command,
            resource_model_parser=self.resource_model_parser)

        # Destroy VM Command
        self.destroy_virtual_machine_command = \
            DestroyVirtualMachineCommand(pv_service=pv_service,
                                         resource_remover=resource_remover,
                                         disconnector=self.virtual_switch_disconnect_command)
        # Power Command
        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(),
            ip_manager=ip_manager)

        # Save Snapshot
        self.snapshot_saver = SaveSnapshotCommand(
            pyvmomi_service=pv_service, task_waiter=synchronous_task_waiter)

        # Snapshot Restorer
        self.snapshot_restorer = SnapshotRestoreCommand(
            pyvmomi_service=pv_service, task_waiter=synchronous_task_waiter)

        self.snapshots_retriever = RetrieveSnapshotsCommand(
            pyvmomi_service=pv_service)
예제 #9
0
 def destroy_port_group_task(network):
     if network_is_portgroup(network):
         task = DvPortGroupCreator.dv_port_group_destroy_task(network)
         return task
     return None