def get_schema_helper(connection, schema_name):
"""Create a schema helper object by querying an ovsdb-server
:param connection: The ovsdb-server connection string
:type connection: string
:param schema_name: The schema on the server to pull
:type schema_name: string
"""
err, strm = stream.Stream.open_block(stream.Stream.open(connection))
if err:
#有错误，扔异常
raise Exception("Could not connect to %s" % connection)
#创建jsonrpc连接，请求命令'get_schema'
rpc = jsonrpc.Connection(strm)
req = jsonrpc.Message.create_request('get_schema', [schema_name])
#等待响应
err, resp = rpc.transact_block(req)
rpc.close()
if err:
raise Exception("Could not retrieve schema from %(conn)s: "
"%(err)s" % {
'conn': connection,
'err': os.strerror(err)
})
elif resp.error:
raise Exception(resp.error)
#封装返回的库描述信息（例如含哪些表，表结构是什么）
return idl.SchemaHelper(None, resp.result)
def __init__(self, session, schema):
if not isinstance(schema, idl.SchemaHelper):
schema = idl.SchemaHelper(schema_json=schema)
schema.register_all()
schema = schema.get_idl_schema()
# NOTE(jkoelker) event buffer
self._events = []
self.tables = schema.tables
self.readonly = schema.readonly
self._db = schema
self._session = session
self._monitor_request_id = None
self._last_seqno = None
self.change_seqno = 0
# Database locking.
self.lock_name = None # Name of lock we need, None if none.
self.has_lock = False # Has db server said we have the lock?
self.is_lock_contended = False # Has db server said we can't get lock?
self._lock_request_id = None # JSON-RPC ID of in-flight lock request.
# Transaction support.
self.txn = None
self._outstanding_txns = {}
for table in schema.tables.values():
for column in table.columns.values():
if not hasattr(column, 'alert'):
column.alert = True
table.need_table = False
table.rows = {}
table.idl = self
def _get_ovs_idl_monitor(self):
with mock.patch.object(ovsdb_event, 'RowEventHandler'), \
mock.patch.object(
native_conn.OvsIdl, '_get_ovsdb_helper',
return_value=idl.SchemaHelper(None, SCHEMA)), \
mock.patch.object(jsonrpc.Session, 'open'), \
mock.patch.object(connection.OvsdbIdl, '__init__'):
return native_conn.OvsIdlMonitor()
def setUp(self):
super(TestOvnNbIdlNotifyHandler, self).setUp()
helper = ovs_idl.SchemaHelper(schema_json=OVN_NB_SCHEMA)
helper.register_all()
self.idl = ovsdb_monitor.OvnNbIdl(self.driver, "remote", helper)
self.lp_table = self.idl.tables.get('Logical_Switch_Port')
self.driver.set_port_status_up = mock.Mock()
self.driver.set_port_status_down = mock.Mock()
def create_schema_helper(schema):
"""Create a schema helper object based on the provided schema.
:param schema: The description of the schema
:type schema: dict or string
"""
if isinstance(schema, str):
schema = json.loads(schema)
return idl.SchemaHelper(None, schema)
def setUp(self):
super(TestOvnSbIdlNotifyHandler, self).setUp()
sb_helper = ovs_idl.SchemaHelper(schema_json=OVN_SB_SCHEMA)
sb_helper.register_table('Chassis')
self.sb_idl = ovsdb_monitor.OvnSbIdl(self.plugin, "remote", sb_helper)
self.sb_idl.lock_name = self.sb_idl.event_lock_name
self.sb_idl.has_lock = True
self.sb_idl.post_initialize(self.plugin)
self.chassis_table = self.sb_idl.tables.get('Chassis')
def setUp(self):
super(TestOvnIdlNotifyHandler, self).setUp()
helper = ovs_idl.SchemaHelper(schema_json=OVN_NB_SCHEMA)
helper.register_all()
self.idl = ovsdb_monitor.OvnIdl(self.plugin, "remote", helper)
self.idl.lock_name = self.idl.event_lock_name
self.idl.has_lock = True
self.lp_table = self.idl.tables.get('Logical_Port')
self.plugin.set_port_status_up = mock.Mock()
self.plugin.set_port_status_down = mock.Mock()
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_schema_helper(connection, schema_name):
err, strm = stream.Stream.open_block(stream.Stream.open(connection))
if err:
raise Exception("Could not connect to %s" % (connection, ))
rpc = jsonrpc.Connection(strm)
req = jsonrpc.Message.create_request('get_schema', [schema_name])
err, resp = rpc.transact_block(req)
rpc.close()
if err:
raise Exception("Could not retrieve schema from %s: %s" %
(connection, os.strerror(err)))
elif resp.error:
raise Exception(resp.error)
return idl.SchemaHelper(None, resp.result)
def setUp(self):
super().setUp()
ovn_config.register_opts()
# TODO(haleyb) - figure out why every test in this class generates
# this warning, think it's in relation to reading this schema file:
# sys:1: ResourceWarning: unclosed file <_io.FileIO name=1 mode='wb'
# closefd=True> ResourceWarning: Enable tracemalloc to get the object
# allocation traceback
self.mock_gsh = mock.patch.object(
idlutils,
'get_schema_helper',
side_effect=lambda x, y: ovs_idl.SchemaHelper(
location=schema_files['OVN_Northbound'])).start()
self.idl = impl_idl_ovn.OvnNbIdlForLb()
def setUp(self):
super(TestOvnSbIdlNotifyHandler, self).setUp()
sb_helper = ovs_idl.SchemaHelper(schema_json=OVN_SB_SCHEMA)
sb_helper.register_table('Chassis')
self.sb_idl = ovsdb_monitor.OvnSbIdl(self.driver, "remote", sb_helper)
self.sb_idl.post_connect()
self.chassis_table = self.sb_idl.tables.get('Chassis')
self.driver.update_segment_host_mapping = mock.Mock()
self.l3_plugin = directory.get_plugin(n_const.L3)
self.l3_plugin.schedule_unhosted_gateways = mock.Mock()
self.row_json = {
"name": "fake-name",
"hostname": "fake-hostname",
"external_ids": ['map', [["ovn-bridge-mappings",
"fake-phynet1:fake-br1"]]]
}
def setUp(self):
super(TestOvnIdlDistributedLock, self).setUp()
self.node_uuid = uuidutils.generate_uuid()
self.fake_driver = mock.Mock()
self.fake_driver.node_uuid = self.node_uuid
self.fake_event = 'fake-event'
self.fake_row = fakes.FakeOvsdbRow.create_one_ovsdb_row(
attrs={'_table': mock.Mock(name='FakeTable')})
helper = ovs_idl.SchemaHelper(schema_json=OVN_NB_SCHEMA)
helper.register_all()
with mock.patch.object(ovsdb_monitor, 'OvnDbNotifyHandler'):
self.idl = ovsdb_monitor.OvnIdlDistributedLock(
self.fake_driver, 'punix:/tmp/fake', helper)
self.mock_get_node = mock.patch.object(
hash_ring_manager.HashRingManager,
'get_node', return_value=self.node_uuid).start()
def get_schema_helper(connection, schema_name):
err, strm = stream.Stream.open_block(
stream.Stream.open(connection))
if err:
print "Failure 1"
raise Exception(_("Could not connect to %s") % connection)
rpc = jsonrpc.Connection(strm)
req = jsonrpc.Message.create_request('get_schema', [schema_name])
err, resp = rpc.transact_block(req)
rpc.close()
if err:
print "Failure 2"
raise Exception(_("Could not retrieve schema from %(conn)s: "
"%(err)s") % {'conn': connection,
'err': os.strerror(err)})
elif resp.error:
print "Failure 3"
print resp.error
raise Exception(resp.error)
return idl.SchemaHelper(None, resp.result)
def get_schema_helper(connection, schema_name):
"""Create a schema helper object by querying an ovsdb-server
:param connection: The ovsdb-server connection string
:type connection: string
:param schema_name: The schema on the server to pull
:type schema_name: string
"""
parsed_connections = parse_connection(connection)
for c in parsed_connections:
err, strm = stream.Stream.open_block(stream.Stream.open(c))
if err:
LOG.error(
"Unable to open stream to %(conn)s to retrieve schema: "
"%(err)s", {
'conn': c,
'err': os.strerror(err)
})
continue
rpc = jsonrpc.Connection(strm)
req = jsonrpc.Message.create_request('get_schema', [schema_name])
err, resp = rpc.transact_block(req)
rpc.close()
if err:
LOG.info("Could not retrieve schema from %(conn)s: "
"%(err)s", {
'conn': c,
'err': os.strerror(err)
})
continue
elif resp.error:
LOG.error(
"TRXN error, failed to retrieve schema from %(conn)s: "
"%(err)s", {
'conn': c,
'err': resp.error
})
continue
return idl.SchemaHelper(None, resp.result)
raise Exception("Could not retrieve schema from %s" % connection)
def setUp(self):
super(TestOvnSbIdlNotifyHandler, self).setUp()
sb_helper = ovs_idl.SchemaHelper(schema_json=OVN_SB_SCHEMA)
sb_helper.register_table('Chassis')
self.sb_idl = ovsdb_monitor.OvnSbIdl(self.driver, "remote", sb_helper)
self.sb_idl.lock_name = self.sb_idl.event_lock_name
self.sb_idl.has_lock = True
self.sb_idl.post_initialize(self.driver)
self.chassis_table = self.sb_idl.tables.get('Chassis')
self.driver.update_segment_host_mapping = mock.Mock()
mgr = manager.NeutronManager.get_instance()
self.l3_plugin = mgr.get_service_plugins().get(
service_constants.L3_ROUTER_NAT)
if ovn_config.is_ovn_l3():
self.l3_plugin.schedule_unhosted_routers = mock.Mock()
self.row_json = {
"name": "fake-name",
"hostname": "fake-hostname",
"external_ids": ['map', [["ovn-bridge-mappings",
"fake-phynet1:fake-br1"]]]
}
def get_schema_helper_for_vtep():
current_dir = os.path.dirname(os.path.realpath(__file__))
return idl.SchemaHelper(current_dir + '/../vtep/vtep.ovsschema')
except eventlet.queue.Empty:
print("EMPTY")
pass
except Exception as ex:
print("NOOOOOO!", ex)
raise
def client(_idl, q, ev):
print("waiting")
ev.wait()
print("GO!")
for n in range(1000):
q.put(Command(_idl, n))
#remote = 'tcp:127.0.0.1:6640'
remote = 'unix:/usr/local/var/run/openvswitch/db.sock'
schema_helper = idl.SchemaHelper(
location="/usr/local/share/openvswitch/vswitch.ovsschema")
schema_helper.register_all()
i = MyIdl(remote, schema_helper)
q = MyQueue()
e = eventlet.Event()
pool = eventlet.GreenPool()
gt1 = pool.spawn(run, i, q, e)
gt2 = pool.spawn(client, i, q, e)
pool.waitall()
