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()