def setUp(self):
cfg.CONF.set_override('apps_list', self.apps_list, group='df')
super(DFAppTestBase, self).setUp()
mock.patch('ryu.base.app_manager.AppManager.get_instance').start()
self.controller = df_local_controller.DfLocalController('fake_host')
self.nb_api = self.controller.nb_api = mock.MagicMock()
self.vswitch_api = self.controller.vswitch_api = mock.MagicMock()
kwargs = dict(nb_api=self.controller.nb_api,
vswitch_api=self.controller.vswitch_api,
db_store=self.controller.db_store)
self.controller.open_flow_app = ryu_base_app.RyuDFAdapter(**kwargs)
self.open_flow_app = self.controller.open_flow_app
self.datapath = self.open_flow_app._datapath = mock.Mock()
self.open_flow_app.load(self.controller.open_flow_app, **kwargs)
self.controller.topology = topology.Topology(self.controller, False)
# Add basic network topology
self.controller.logical_switch_updated(fake_logic_switch1)
self.controller.logical_switch_updated(fake_external_switch1)
self.controller.router_updated(fake_logic_router1)
self.arp_responder = mock.patch(
'dragonflow.controller.common.arp_responder.ArpResponder').start()
mock.patch(
'dragonflow.controller.df_base_app.DFlowApp.mod_flow').start()
mock.patch('dragonflow.controller.df_base_app.DFlowApp.'
'add_flow_go_to_table').start()
def run(self):
self.vswitch_api.initialize(self.nb_api)
self.nb_api.register_notification_callback(self._handle_update)
if cfg.CONF.df.enable_neutron_notifier:
self.neutron_notifier.initialize(nb_api=self.nb_api,
is_neutron_server=False)
self.topology = topology.Topology(self,
self.enable_selective_topo_dist)
self._sync_pulse.start(
interval=cfg.CONF.df.db_sync_time,
initial_delay=cfg.CONF.df.db_sync_time,
)
# both set_controller and del_controller will delete flows.
# for reliability, here we should check if controller is set for OVS,
# if yes, don't set controller and don't delete controller.
# if no, set controller
targets = ('tcp:' + cfg.CONF.df_ryu.of_listen_address + ':' +
str(cfg.CONF.df_ryu.of_listen_port))
is_controller_set = self.vswitch_api.check_controller(targets)
integration_bridge = cfg.CONF.df.integration_bridge
if not is_controller_set:
self.vswitch_api.set_controller(integration_bridge, [targets])
is_fail_mode_set = self.vswitch_api.check_controller_fail_mode(
'secure')
if not is_fail_mode_set:
self.vswitch_api.set_controller_fail_mode(integration_bridge,
'secure')
self.open_flow_service.start()
self.open_flow_app.start()
self._register_models()
self.register_chassis()
self.sync()
self.nb_api.process_changes()
def run(self):
self.vswitch_api.initialize(self.nb_api)
if cfg.CONF.df.enable_neutron_notifier:
self.neutron_notifier.initialize(nb_api=self.nb_api,
is_neutron_server=False)
self.topology = topology.Topology(self,
self.enable_selective_topo_dist)
if self.enable_db_consistency:
self.db_consistency_manager = \
db_consistent.DBConsistencyManager(self)
self.nb_api.set_db_consistency_manager(self.db_consistency_manager)
self.db_consistency_manager.daemonize()
# both set_controller and del_controller will delete flows.
# for reliability, here we should check if controller is set for OVS,
# if yes, don't set controller and don't delete controller.
# if no, set controller
targets = ('tcp:' + cfg.CONF.df_ryu.of_listen_address + ':' +
str(cfg.CONF.df_ryu.of_listen_port))
is_controller_set = self.vswitch_api.check_controller(targets)
integration_bridge = cfg.CONF.df.integration_bridge
if not is_controller_set:
self.vswitch_api.set_controller(integration_bridge, [targets])
is_fail_mode_set = self.vswitch_api.check_controller_fail_mode(
'secure')
if not is_fail_mode_set:
self.vswitch_api.set_controller_fail_mode(integration_bridge,
'secure')
self.open_flow_app.start()
self.create_tunnels()
self._register_models()
self.db_sync_loop()
def run(self):
self.nb_api.initialize(db_ip=cfg.CONF.df.remote_db_ip,
db_port=cfg.CONF.df.remote_db_port)
self.vswitch_api.initialize(self.nb_api)
if cfg.CONF.df.enable_port_status_notifier:
self.port_status_notifier.initialize(mech_driver=None,
nb_api=self.nb_api,
pub=self.nb_api.publisher,
sub=None,
is_neutron_server=False)
self.topology = topology.Topology(self,
self.enable_selective_topo_dist)
# both set_controller and del_controller will delete flows.
# for reliability, here we should check if controller is set for OVS,
# if yes, don't set controller and don't delete controller.
# if no, set controller
targets = ('tcp:' + cfg.CONF.df_ryu.of_listen_address + ':' +
str(cfg.CONF.df_ryu.of_listen_port))
is_controller_set = self.vswitch_api.check_controller(targets)
if not is_controller_set:
self.vswitch_api.set_controller(self.integration_bridge, [targets])
is_fail_mode_set = self.vswitch_api.check_controller_fail_mode(
'secure')
if not is_fail_mode_set:
self.vswitch_api.set_controller_fail_mode(self.integration_bridge,
'secure')
self.open_flow_app.start()
self.db_sync_loop()
def setUp(self, enable_selective_topo_dist=False):
extra_apps = ['portbinding']
cfg.CONF.set_override(
'apps_list',
self.apps_list + extra_apps,
group='df',
)
cfg.CONF.set_override('host', fake_chassis1.id)
super(DFAppTestBase, self).setUp()
self.useFixture(log_fixture.SetLogLevel([None], logging.DEBUG))
mock_app = mock.patch(
'ryu.base.app_manager.AppManager.get_instance').start()
self.addCleanup(mock_app.stop)
mock_nb = mock.patch('dragonflow.db.api_nb.NbApi.get_instance')
mock_nb.start()
self.addCleanup(mock_nb.stop)
mod_flow = mock.patch(
'dragonflow.controller.df_base_app.DFlowApp.mod_flow')
mod_flow_mock = mod_flow.start()
self.addCleanup(mod_flow.stop)
add_flow_go_to_table_mock_patch = mock.patch(
'dragonflow.controller.df_base_app.DFlowApp.add_flow_go_to_table')
add_flow_go_to_table = add_flow_go_to_table_mock_patch
add_flow_go_to_table_mock = add_flow_go_to_table.start()
self.addCleanup(add_flow_go_to_table_mock_patch.stop)
execute = mock.patch('neutron.agent.common.utils.execute')
execute_mock = execute.start()
self.addCleanup(execute.stop)
# CLear old objects from cache
db_store.get_instance().clear()
self.nb_api = api_nb.NbApi.get_instance(False)
self.controller = df_local_controller.DfLocalController(
fake_chassis1.id, self.nb_api)
self.vswitch_api = self.controller.vswitch_api = mock.MagicMock()
kwargs = dict(
nb_api=self.controller.nb_api,
vswitch_api=self.controller.vswitch_api,
)
self.controller.open_flow_app = ryu_base_app.RyuDFAdapter(**kwargs)
self.open_flow_app = self.controller.open_flow_app
self.datapath = self.open_flow_app._datapath = mock.Mock()
self.open_flow_app.load(self.controller.open_flow_app, **kwargs)
self.topology = self.controller.topology = topology.Topology(
self.controller, enable_selective_topo_dist)
# Add basic network topology
self.controller.update(fake_logic_switch1)
self.controller.update(fake_lswitch_default_subnets[0])
self.controller.update(fake_external_switch1)
self.controller.update(fake_logic_router1)
self.controller.db_store.update(fake_chassis1)
self.controller.db_store.update(fake_chassis2)
mod_flow_mock.reset_mock()
add_flow_go_to_table_mock.reset_mock()
execute_mock.reset_mock()
def run(self):
self.nb_api.register_notification_callback(self._handle_update)
if self.neutron_notifier:
self.neutron_notifier.initialize(nb_api=self.nb_api)
self.topology = topology.Topology(self,
self.enable_selective_topo_dist)
self._sync_pulse.start(
interval=cfg.CONF.df.db_sync_time,
initial_delay=cfg.CONF.df.db_sync_time,
)
self.switch_backend.start()
self._register_models()
self.register_chassis()
self.sync()
self.process_changes()
def setUp(self, enable_selective_topo_dist=False):
cfg.CONF.set_override('apps_list', self.apps_list, group='df')
super(DFAppTestBase, self).setUp()
mock.patch('ryu.base.app_manager.AppManager.get_instance').start()
mock.patch('dragonflow.db.api_nb.NbApi.get_instance').start()
mod_flow = mock.patch(
'dragonflow.controller.df_base_app.DFlowApp.mod_flow').start()
add_flow_go_to_table_mock_patch = mock.patch(
'dragonflow.controller.df_base_app.DFlowApp.add_flow_go_to_table')
add_flow_go_to_table = add_flow_go_to_table_mock_patch.start()
execute = mock.patch('neutron.agent.common.utils.execute').start()
# CLear old objects from cache
db_store._instance = None
nb_api = api_nb.NbApi.get_instance(False)
self.controller = df_local_controller.DfLocalController(
'fake_host', nb_api)
self.nb_api = self.controller.nb_api = mock.MagicMock()
self.vswitch_api = self.controller.vswitch_api = mock.MagicMock()
kwargs = dict(
nb_api=self.controller.nb_api,
vswitch_api=self.controller.vswitch_api,
)
self.controller.open_flow_app = ryu_base_app.RyuDFAdapter(**kwargs)
self.open_flow_app = self.controller.open_flow_app
self.datapath = self.open_flow_app._datapath = mock.Mock()
self.open_flow_app.load(self.controller.open_flow_app, **kwargs)
self.topology = self.controller.topology = topology.Topology(
self.controller, enable_selective_topo_dist)
# Add basic network topology
self.controller.update(fake_logic_switch1)
self.controller.update(fake_external_switch1)
self.controller.update(fake_logic_router1)
self.controller.db_store.update(fake_chassis1)
self.controller.db_store.update(fake_chassis2)
mod_flow.reset_mock()
add_flow_go_to_table.reset_mock()
execute.reset_mock()
def run(self):
#注册nb_api的通知回调（完成self._queue中event update的处理，见process_changes)
self.nb_api.register_notification_callback(self._handle_update)
if self.neutron_notifier:
self.neutron_notifier.initialize(nb_api=self.nb_api)
#????
self.topology = topology.Topology(self,
self.enable_selective_topo_dist)
#开启定时器，周期性触发controller sync事件
self._sync_pulse.start(
interval=cfg.CONF.df.db_sync_time,
initial_delay=cfg.CONF.df.db_sync_time,
)
self.switch_backend.start()
self._register_models()
# 更新自身
self.register_chassis()
self.sync()
# 自队列中取出更新event传入cb处理
self.process_changes()
def run(self):
#self.vswitch_api.initialize(self.nb_api)
self.nb_api.register_notification_callback(self._handle_update)
if cfg.CONF.df.enable_neutron_notifier:
self.neutron_notifier.initialize(nb_api=self.nb_api,
is_neutron_server=False)
self.topology = topology.Topology(self,
self.enable_selective_topo_dist)
self._sync_pulse.start(
interval=cfg.CONF.df.db_sync_time,
initial_delay=cfg.CONF.df.db_sync_time,
)
# both set_controller and del_controller will delete flows.
# for reliability, here we should check if controller is set for OVS,
# if yes, don't set controller and don't delete controller.
# if no, set controller
# targets = ('tcp:' + cfg.CONF.df_ryu.of_listen_address + ':' +
# str(cfg.CONF.df_ryu.of_listen_port))
# is_controller_set = self.vswitch_api.check_controller(targets)
# integration_bridge = cfg.CONF.df.integration_bridge
# if not is_controller_set:
# self.vswitch_api.set_controller(integration_bridge, [targets])
# is_fail_mode_set = self.vswitch_api.check_controller_fail_mode(
# 'secure')
# if not is_fail_mode_set:
# self.vswitch_api.set_controller_fail_mode(
# integration_bridge, 'secure')
self.open_flow_service.start()
self.open_flow_app.start()
import gc
from ryu.controller.ofp_handler import OpenFlowController
objs = gc.get_objects()
for obj in objs:
if type(obj) is OpenFlowController:
obj.__call__()
