def get_ovn_conn(viewer):
_nb_idl = OvnIdl(constants.OVN_NB_CONNECTION, 'OVN_Northbound', viewer)
_nb_conn = connection.Connection(
_nb_idl, timeout=constants.OVSDB_CONNECTION_TIMEOUT)
ovn_nb = nb_impl_idl.OvnNbApiIdlImpl(_nb_conn, start=True)
_sb_idl = OvnIdl(constants.OVN_SB_CONNECTION, 'OVN_Southbound', viewer)
_sb_conn = connection.Connection(
_sb_idl, timeout=constants.OVSDB_CONNECTION_TIMEOUT)
ovn_sb = nb_impl_idl.OvnNbApiIdlImpl(_sb_conn, start=True)
return ovn_nb, ovn_sb
def api_factory(context):
global _connection
if _connection is None:
try:
_connection = connection.Connection(
idl=n_connection.idl_factory(),
timeout=cfg.CONF.ovs_vsctl_timeout)
except TypeError:
#pylint: disable=unexpected-keyword-arg,no-value-for-parameter
_connection = connection.Connection(
idl_factory=n_connection.idl_factory, # noqa
timeout=cfg.CONF.ovs_vsctl_timeout)
return NeutronOvsdbIdl(_connection)
def __init__(self, db_connection, timeout, db_change_callback):
#连接到ovsdb
idl = df_idl_from_server(db_connection, 'Open_vSwitch',
db_change_callback)
type(self).ovsdb_connection = None
ovsdb_connection = connection.Connection(idl, timeout)
super(DFOvsdbApi, self).__init__(ovsdb_connection)
def _ovsdb_conn(self, conn, schema):
if schema in OVSDB_SCHEMA:
if OVSDB_SCHEMA[schema]['conn']:
return OVSDB_SCHEMA[schema]['conn']
# The python-ovs Idl class (Open vSwitch Database Interface Definition Language).
# Take it from server's database
try:
# The ovsdbapp Connection object
i = connection.OvsdbIdl.from_server(conn, schema)
except Exception as e:
self.logger.exception(
'Could not retrieve schema {} from {}'.format(
schema, conn))
return None
try:
# The ovsdbapp Connection object
conn = connection.Connection(idl=i, timeout=3)
except Exception as e:
self.logger.exception('Cannot initiate OVSDB connection: {}',
format(e))
return None
# The OVN_Northbound API implementation object
api = OVSDB_SCHEMA[schema]['Idl'](conn)
OVSDB_SCHEMA[schema]['conn'] = api
return api
else:
self.logger.exception('Incorrect OVSDB schema: {}', format(schema))
return None
def test_do_get_schema_helper_retry(self, mock_get_schema_helper,
mock_enable_conn, mock_idl,
mock_wait_for_change, mock_threading):
mock_helper = mock.Mock()
# raise until 3rd retry attempt
mock_get_schema_helper.side_effect = [
Exception(), Exception(), mock_helper
]
try:
conn = connection.Connection(idl_factory=native_conn.idl_factory,
timeout=mock.Mock())
except TypeError:
conn = connection.Connection(idl=native_conn.idl_factory(),
timeout=mock.Mock())
conn.start()
self.assertEqual(3, len(mock_get_schema_helper.mock_calls))
mock_helper.register_all.assert_called_once_with()
def api_factory():
global _connection
global _idl_monitor
if _connection is None:
_idl_monitor = n_connection.OvsIdlMonitor()
_connection = connection.Connection(idl=_idl_monitor,
timeout=cfg.CONF.OVS.ovsdb_timeout)
return NeutronOvsdbIdl(_connection, _idl_monitor)
def get_ovsdb_connection(connection_string, schema, timeout, tables=None):
helper = idlutils.get_schema_helper(connection_string, schema)
if tables:
for table in tables:
helper.register_table(table)
else:
helper.register_all()
return connection.Connection(idl.Idl(connection_string, helper), timeout)
def from_worker(cls, worker_class, driver=None):
args = (cfg.get_ovn_sb_connection(), 'OVN_Southbound')
if worker_class == worker.MaintenanceWorker:
idl_ = ovsdb_monitor.BaseOvnSbIdl.from_server(*args)
else:
idl_ = ovsdb_monitor.OvnSbIdl.from_server(*args, driver=driver)
conn = connection.Connection(idl_, timeout=cfg.get_ovn_ovsdb_timeout())
return cls(conn)
def from_worker(cls, worker_class, driver=None):
args = (cls.connection_string, cls.schema_helper)
if worker_class == worker.MaintenanceWorker:
idl_ = ovsdb_monitor.BaseOvnSbIdl.from_server(*args)
else:
idl_ = ovsdb_monitor.OvnSbIdl.from_server(*args, driver=driver)
conn = connection.Connection(idl_, timeout=cfg.get_ovn_ovsdb_timeout())
return cls(conn)
def test_ovsdb_monitor_lock(self):
"""Test case to test the ovsdb monitor lock used by OvnConnection.
This test case created another IDL connection to the NB DB using
the ovsdb_monitor.OvnConnection.
With this we will have 2 'ovsdb_monitor.OvnConnection's. At the
start the lock should be with the IDL connection created by the
'TestOVNFunctionalBase' setup() function.
The port up/down events should be handled by the first IDL connection.
Then we will restart the first IDL connection so that the 2nd IDL
connection created in this test case gets the lock and it should
handle the port up/down events.
Please note that the "self.monitor_nb_idl_con" created by the base
class is created using 'connection.Connection' and hence it will not
contend for any lock.
"""
fake_driver = mock.MagicMock()
_idl = ovsdb_monitor.OvnNbIdl.from_server(
self.ovsdb_server_mgr.get_ovsdb_connection_path(),
'OVN_Northbound', fake_driver)
tst_ovn_idl_conn = connection.Connection(_idl, timeout=10)
tst_ovn_idl_conn.start()
self.mech_driver.set_port_status_up = mock.Mock()
self.mech_driver.set_port_status_down = mock.Mock()
with self.port(name='port') as p:
p = p['port']
with self.nb_idl_transaction(self.fake_api,
check_error=True) as txn:
txn.add(
cmd.SetLSwitchPortCommand(self.fake_api,
p['id'],
True,
up=False))
self._test_port_up_down_helper(p, self.mech_driver)
fake_driver.set_port_status_up.assert_not_called()
fake_driver.set_port_status_down.assert_not_called()
# Now restart the mech_driver's IDL connection.
self.mech_driver._nb_ovn.idl.force_reconnect()
# Wait till the test_ovn_idl_conn has acquired the lock.
n_utils.wait_until_true(lambda: tst_ovn_idl_conn.idl.has_lock)
self.mech_driver.set_port_status_up.reset_mock()
self.mech_driver.set_port_status_down.reset_mock()
fake_driver.set_port_status_up.reset_mock()
fake_driver.set_port_status_down.reset_mock()
self._test_port_up_down_helper(p, fake_driver)
self.assertFalse(self.mech_driver.set_port_status_up.called)
self.assertFalse(self.mech_driver.set_port_status_down.called)
def start(self):
connection_string = config.cfg.CONF.ovs.ovsdb_connection
helper = idlutils.get_schema_helper(connection_string, 'Open_vSwitch')
tables = ('Open_vSwitch', 'Bridge', 'Port', 'Interface')
for table in tables:
helper.register_table(table)
ovs_idl = idl.Idl(connection_string, helper)
conn = connection.Connection(
ovs_idl, timeout=config.cfg.CONF.ovs.ovsdb_connection_timeout)
return idl_ovs.OvsdbIdl(conn)
def start(self, connection_string):
helper = idlutils.get_schema_helper(connection_string,
'Open_vSwitch')
tables = ('Open_vSwitch', 'Bridge', 'Port', 'Interface')
for table in tables:
helper.register_table(table)
ovs_idl = idl.Idl(connection_string, helper)
ovs_idl._session.reconnect.set_probe_interval(60000)
conn = connection.Connection(
ovs_idl, timeout=180)
self.idl_ovs = idl_ovs.OvsdbIdl(conn)
def _test_connection_start(self, mock_wfc, mock_gsh, idl_class, schema):
mock_gsh.return_value = ovs_idl.SchemaHelper(
location=schema_files[schema])
_idl = idl_class.from_server('punix:/tmp/fake', schema, mock.Mock())
self.ovn_connection = connection.Connection(_idl, mock.Mock())
with mock.patch.object(poller, 'Poller'), \
mock.patch('threading.Thread'):
self.ovn_connection.start()
# A second start attempt shouldn't re-register.
self.ovn_connection.start()
self.ovn_connection.thread.start.assert_called_once_with()
def get_idl_singleton():
global _idl
conn = cfg.CONF.net_ansible_openvswitch.ovsdb_connection
schema = "Open_vSwitch"
if _idl is None:
_connection = connection.Connection(idl=idl_factory(conn, schema),
timeout=10)
_idl = impl_idl.OvsdbIdl(_connection)
return _idl
def short_living_ovsdb_api(api_class, idl):
"""Context manager for short living connections to the database.
:param api_class: Class implementing the database calls
(e.g. from the impl_idl module)
:param idl: An instance of IDL class (e.g. instance of OvnNbIdl)
"""
conn = connection.Connection(idl, timeout=ovn_conf.get_ovn_ovsdb_timeout())
api = api_class(conn)
try:
yield api
finally:
api.ovsdb_connection.stop()
def test_ssl_connection(self, mock_cfg, mock_os, mock_get_schema_helper,
mock_idl, mock_threading, mock_stream):
mock_os.path.isfile.return_value = True
mock_cfg.CONF.OVS.ovsdb_connection = 'ssl:127.0.0.1:6640'
mock_cfg.CONF.OVS.ssl_key_file = SSL_KEY_FILE
mock_cfg.CONF.OVS.ssl_cert_file = SSL_CERT_FILE
mock_cfg.CONF.OVS.ssl_ca_cert_file = SSL_CA_FILE
conn = connection.Connection(idl=native_conn.idl_factory(), timeout=1)
conn.start()
mock_stream.ssl_set_private_key_file.assert_called_once_with(
SSL_KEY_FILE)
mock_stream.ssl_set_certificate_file.assert_called_once_with(
SSL_CERT_FILE)
mock_stream.ssl_set_ca_cert_file.assert_called_once_with(SSL_CA_FILE)
def test_ssl_connection(self):
self.mock_os.path.isfile.return_value = True
self.mock_cfg.CONF.OVS.ovsdb_connection = 'ssl:127.0.0.1:6640'
self.mock_cfg.CONF.OVS.ssl_key_file = SSL_KEY_FILE
self.mock_cfg.CONF.OVS.ssl_cert_file = SSL_CERT_FILE
self.mock_cfg.CONF.OVS.ssl_ca_cert_file = SSL_CA_FILE
ovs_idl_monitor = self._get_ovs_idl_monitor()
conn = connection.Connection(idl=ovs_idl_monitor, timeout=1)
conn.start()
self.mock_stream.ssl_set_private_key_file.assert_called_once_with(
SSL_KEY_FILE)
self.mock_stream.ssl_set_certificate_file.assert_called_once_with(
SSL_CERT_FILE)
self.mock_stream.ssl_set_ca_cert_file.assert_called_once_with(
SSL_CA_FILE)
def get_connection(db_class, trigger=None, driver=None):
# The trigger is the start() method of the worker class
if db_class == OvsdbNbOvnIdl:
args = (cfg.get_ovn_nb_connection(), 'OVN_Northbound')
cls = ovsdb_monitor.OvnNbIdl
elif db_class == OvsdbSbOvnIdl:
args = (cfg.get_ovn_sb_connection(), 'OVN_Southbound')
cls = ovsdb_monitor.OvnSbIdl
if trigger and utils.get_method_class(trigger) == ovsdb_monitor.OvnWorker:
idl_ = cls.from_server(*args, driver=driver)
else:
if db_class == OvsdbSbOvnIdl:
idl_ = ovsdb_monitor.BaseOvnSbIdl.from_server(*args)
else:
idl_ = ovsdb_monitor.BaseOvnIdl.from_server(*args)
return connection.Connection(idl_, timeout=cfg.get_ovn_ovsdb_timeout())
def get_connection(db_class, trigger=None, driver=None, binding_events=False):
if db_class == OvsdbNbOvnIdl:
args = (cfg.get_ovn_nb_connection(), 'OVN_Northbound')
elif db_class == OvsdbSbOvnIdl:
args = (cfg.get_ovn_sb_connection(), 'OVN_Southbound')
if binding_events:
if db_class == OvsdbNbOvnIdl:
idl_ = ovsdb_monitor.OvnNbIdl.from_server(*args, driver=driver)
else:
idl_ = ovsdb_monitor.OvnSbIdl.from_server(*args, driver=driver)
else:
if db_class == OvsdbNbOvnIdl:
idl_ = ovsdb_monitor.BaseOvnIdl.from_server(*args)
else:
idl_ = ovsdb_monitor.BaseOvnSbIdl.from_server(*args)
return connection.Connection(idl_, timeout=cfg.get_ovn_ovsdb_timeout())
def _get_ovsdb_client(self, module):
try:
from ovsdbapp.backend.ovs_idl import command
from ovsdbapp.backend.ovs_idl import connection
from ovsdbapp.backend.ovs_idl import idlutils
from ovsdbapp.schema.open_vswitch import impl_idl
except ImportError as e:
self.module.log(msg=str(e))
self.module.fail_json(msg="ovsdbapp module is required")
class GetIfaceCommand(command.ReadOnlyCommand):
def __init__(self, api, iface):
super(GetIfaceCommand, self).__init__(api)
self.iface = iface
def run_idl(self, txn):
iface = idlutils.row_by_value(self.api.idl, 'Interface',
'name', self.iface)
self.result = iface
class TcOvsdbIdl(impl_idl.OvsdbIdl):
def __init__(self, connection):
super(TcOvsdbIdl, self).__init__(connection)
def get_iface(self, iface):
return GetIfaceCommand(self, iface)
endpoint = ("tcp:%(host)s:%(port)s" % module.params)
client = None
try:
idl = connection.OvsdbIdl.from_server(endpoint, 'Open_vSwitch')
connection = connection.Connection(idl=idl, timeout=3)
client = TcOvsdbIdl(connection)
except Exception as e:
self.module.fail_json(msg=("could not connect to openvswitch. "
"error: %s") % str(e))
return client
def __init__(self, nb_api, db_connection, timeout):
if DFOvsdbApi.ovsdb_connection is None:
idl = df_idl_from_server(nb_api, db_connection, 'Open_vSwitch')
DFOvsdbApi.ovsdb_connection = connection.Connection(idl, timeout)
super(DFOvsdbApi, self).__init__(DFOvsdbApi.ovsdb_connection)
def create_connection(cls, schema):
idl = connection.OvsdbIdl.from_server(cls.schema_map[schema], schema)
return connection.Connection(idl, constants.DEFAULT_TIMEOUT)
def start(self):
ovsdb_monitor._check_and_set_ssl_files(self.SCHEMA)
conn = connection.Connection(self,
timeout=config.get_ovn_ovsdb_timeout())
return idl_ovn.OvsdbSbOvnIdl(conn)
def create_connection(cls, schema):
idl = connection.OvsdbIdl.from_server(cls.schema_map[schema], schema)
return connection.Connection(idl, 0)
def start(self):
conn = connection.Connection(self, timeout=180)
ovsdbSbConn = OvsdbSbOvnIdl(conn)
if self._events:
self.notify_handler.watch_events(self._events)
return ovsdbSbConn
def start(self):
conn = connection.Connection(self,
timeout=config.get_ovn_ovsdb_timeout())
return idl_ovn.OvsdbSbOvnIdl(conn)
def set_connection(cls):
idl = TestingOvsIdl.from_server(cls.schema_map, cls.default_tables)
cls._connection = connection.Connection(idl, constants.DEFAULT_TIMEOUT)
def __init__(self, idl=None, constr=None, schema=None, timeout=60):
self.idl = idl or ovsdb_monitor.BaseOvnIdl.from_server(constr, schema)
self.connection = connection.Connection(idl=self.idl, timeout=timeout)
def start(self):
LOG.info('Getting OvsdbSbOvnIdl for MetadataAgent with retry')
conn = connection.Connection(self,
timeout=config.get_ovn_ovsdb_timeout())
return impl_idl_ovn.OvsdbSbOvnIdl(conn)
def api_factory(context):
global _connection
if _connection is None:
_connection = connection.Connection(idl=n_connection.idl_factory(),
timeout=cfg.CONF.OVS.ovsdb_timeout)
return NeutronOvsdbIdl(_connection)