コード例 #1
0
    def _initialize_agent(self):
        cfg.CONF.set_override('epg_mapping_dir', self.ep_dir, 'OPFLEX')
        cfg.CONF.set_override(
            'bridge_manager',
            'opflexagent.utils.bridge_managers.vpp_manager.VppManager',
            'OPFLEX')
        cfg.CONF.set_override("vhostuser_socket_dir", VHU_DIR, group="VPP")
        kwargs = gbp_agent.create_agent_config_map(cfg.CONF)

        class MockFixedIntervalLoopingCall(object):
            def __init__(self, f):
                self.f = f

            def start(self, interval=0):
                self.f()

        resources = [
            mock.patch('oslo_service.loopingcall.FixedIntervalLoopingCall',
                       new=MockFixedIntervalLoopingCall),
            mock.patch('opflexagent.gbp_agent.GBPOpflexAgent.'
                       '_report_state')
        ]

        with utils.nested_context_manager(*resources):
            agent = gbp_agent.GBPOpflexAgent(**kwargs)
            # set back to true because initial report state will succeed due
            # to mocked out RPC calls
            agent.use_call = True
            agent.tun_br = mock.Mock()
            agent.host = 'host1'
        agent.sg_agent = mock.Mock()
        return agent
コード例 #2
0
    def test_dvs_agent_no_binding_mode(self):
        mock_dvs_instance = mock.MagicMock()
        import_mock = mock.patch('importlib.import_module',
                                 return_value=mock_dvs_instance)
        import_patch = import_mock.start()
        cfg.CONF.set_override('agent_mode', 'dvs_no_binding', 'OPFLEX')

        resources = [mock.patch('os.path.basename'), mock.patch('sys.argv')]

        with utils.nested_context_manager(*resources):
            gbp_agent.main()
            self.assertEqual(1, import_patch.call_count)
            self.assertEqual(
                1, mock_dvs_instance.create_agent_config_map.call_count)
        import_mock.stop()
コード例 #3
0
    def test_opflex_agent_mode(self):
        opflex_agent = mock.patch('opflexagent.gbp_agent.GBPOpflexAgent')
        opflex_patch = opflex_agent.start()
        metadata_mgr = mock.patch(
            'opflexagent.as_metadata_manager.AsMetadataManager')
        metadata_patch = metadata_mgr.start()
        cfg.CONF.set_override('agent_mode', 'opflex', 'OPFLEX')

        resources = [mock.patch('os.path.basename'), mock.patch('sys.argv')]

        with utils.nested_context_manager(*resources):
            gbp_agent.main()
            self.assertEqual(1, opflex_patch.call_count)
            self.assertEqual(1, metadata_patch.call_count)
        opflex_agent.stop()
        metadata_mgr.stop()
コード例 #4
0
    def test_dvs_agent_mode_no_package(self):
        import_mock = mock.patch('importlib.import_module',
                                 side_effect=ValueError)
        import_patch = import_mock.start()
        cfg.CONF.set_override('agent_mode', 'dvs', 'OPFLEX')

        resources = [
            mock.patch('os.path.basename'),
            mock.patch('sys.argv'),
        ]

        with utils.nested_context_manager(*resources):
            with mock.patch('sys.exit') as sys_patch:
                try:
                    gbp_agent.main()
                except AttributeError:
                    self.assertEqual(1, sys_patch.call_count)
                self.assertEqual(1, import_patch.call_count)
        import_mock.stop()
コード例 #5
0
    def test_stale_endpoints(self):
        self.agent.ep_manager._write_file(
            'uuid1_AA', {}, self.agent.ep_manager.epg_mapping_file)
        self.agent.ep_manager._write_file(
            'uuid1_BB', {}, self.agent.ep_manager.epg_mapping_file)
        self.agent.ep_manager._write_file(
            'uuid1_CC', {}, self.agent.ep_manager.epg_mapping_file)
        self.agent.ep_manager._write_file(
            'uuid2_BB', {}, self.agent.ep_manager.epg_mapping_file)
        self.agent.ep_manager._write_file(
            'uuid2_BB', {}, self.agent.ep_manager.epg_mapping_file)

        resources = [
            mock.patch.object(snat_iptables_manager.SnatIptablesManager,
                              'cleanup_snat_all'),
            mock.patch.object(snat_iptables_manager.SnatIptablesManager,
                              'check_if_exists',
                              return_value=False),
            mock.patch.object(endpoint_file_manager.EndpointFileManager,
                              'undeclare_endpoint'),
            mock.patch.object(ovs.OVSPluginApi, 'update_device_down')
        ]

        with utils.nested_context_manager(*resources):
            port_stats = {
                'regular': {
                    'added': 0,
                    'updated': 0,
                    'removed': 0
                },
                'ancillary': {
                    'added': 0,
                    'removed': 0
                }
            }
            agent = self._initialize_agent()
            self._mock_agent(agent)
            agent.bridge_manager.get_vif_port_set = mock.Mock(
                return_value={'uuid1': 'someint'})
            agent._main_loop(set(), True, 1, port_stats, mock.Mock(), True)
            agent.ep_manager.undeclare_endpoint.assert_called_once_with(
                'uuid2')
コード例 #6
0
    def test_process_deleted_ports(self):
        self.agent.bridge_manager.delete_patch_ports = mock.Mock()

        resources = [
            mock.patch.object(snat_iptables_manager.SnatIptablesManager,
                              'cleanup_snat_all'),
            mock.patch.object(endpoint_file_manager.EndpointFileManager,
                              'undeclare_endpoint'),
            mock.patch.object(ovs.OVSPluginApi, 'update_device_down')
        ]

        with utils.nested_context_manager(*resources):
            agent = self._initialize_agent()
            self._mock_agent(agent)
            port_info = {
                'current': set(['1', '2']),
                'removed': set(['3', '5'])
            }
            agent.bridge_manager.scan_ports = mock.Mock(return_value=port_info)
            agent.bridge_manager.delete_patch_ports = mock.Mock()
            agent.deleted_ports.add('3')
            agent.deleted_ports.add('4')
            port_stats = {
                'regular': {
                    'added': 0,
                    'updated': 0,
                    'removed': 0
                },
                'ancillary': {
                    'added': 0,
                    'removed': 0
                }
            }
            agent._main_loop(set(), True, 1, port_stats, mock.Mock(), True)
            # 3, 4 and 5 are undeclared once
            expected = [mock.call('3'), mock.call('4'), mock.call('5')]
            self._check_call_list(
                expected, agent.ep_manager.undeclare_endpoint.call_args_list)
            expected = [mock.call(['3']), mock.call(['4']), mock.call(['5'])]
            self._check_call_list(
                expected,
                agent.bridge_manager.delete_patch_ports.call_args_list)
コード例 #7
0
    def _initialize_agent(self):
        cfg.CONF.set_override('epg_mapping_dir', self.ep_dir, 'OPFLEX')
        kwargs = gbp_agent.create_agent_config_map(cfg.CONF)

        class MockFixedIntervalLoopingCall(object):
            def __init__(self, f):
                self.f = f

            def start(self, interval=0):
                self.f()

        resources = [
            mock.patch(
                'opflexagent.utils.bridge_managers.ovs_manager.'
                'OvsManager.setup_integration_bridge',
                return_value=mock.Mock()),
            mock.patch('neutron.agent.common.ovs_lib.OVSBridge.'
                       'create'),
            mock.patch('neutron.agent.common.ovs_lib.OVSBridge.'
                       'set_secure_mode'),
            mock.patch(
                'neutron.agent.common.ovs_lib.OVSBridge.'
                'get_local_port_mac',
                return_value='00:00:00:00:00:01'),
            mock.patch('neutron.agent.common.ovs_lib.BaseOVS.get_bridges'),
            mock.patch('oslo_service.loopingcall.FixedIntervalLoopingCall',
                       new=MockFixedIntervalLoopingCall),
            mock.patch('opflexagent.gbp_agent.GBPOpflexAgent.'
                       '_report_state')
        ]

        with utils.nested_context_manager(*resources):
            agent = gbp_agent.GBPOpflexAgent(**kwargs)
            # set back to true because initial report state will succeed due
            # to mocked out RPC calls
            agent.use_call = True
            agent.tun_br = mock.Mock()
            agent.host = 'host1'
        agent.sg_agent = mock.Mock()
        return agent