本文整理汇总了Python中vlcp.event.runnable.RoutineContainer.waitForSend方法的典型用法代码示例。如果您正苦于以下问题:Python RoutineContainer.waitForSend方法的具体用法?Python RoutineContainer.waitForSend怎么用?Python RoutineContainer.waitForSend使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类vlcp.event.runnable.RoutineContainer
的用法示例。
在下文中一共展示了RoutineContainer.waitForSend方法的5个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: OpenflowPortManager
# 需要导入模块: from vlcp.event.runnable import RoutineContainer [as 别名]
# 或者: from vlcp.event.runnable.RoutineContainer import waitForSend [as 别名]
class OpenflowPortManager(Module):
'''
Manage Ports from Openflow Protocol
'''
service = True
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._manage_ports
self.routines.append(self.apiroutine)
self.managed_ports = {}
self.createAPI(api(self.getports, self.apiroutine),
api(self.getallports, self.apiroutine),
api(self.getportbyno, self.apiroutine),
api(self.waitportbyno, self.apiroutine),
api(self.getportbyname, self.apiroutine),
api(self.waitportbyname, self.apiroutine),
api(self.resync, self.apiroutine)
)
self._synchronized = False
def _get_ports(self, connection, protocol, onup = False, update = True):
ofdef = connection.openflowdef
dpid = connection.openflow_datapathid
vhost = connection.protocol.vhost
add = []
try:
if hasattr(ofdef, 'ofp_multipart_request'):
# Openflow 1.3, use ofp_multipart_request to get ports
for m in protocol.querymultipart(ofdef.ofp_multipart_request(type=ofdef.OFPMP_PORT_DESC), connection, self.apiroutine):
yield m
ports = self.managed_ports.setdefault((vhost, dpid), {})
for msg in self.apiroutine.openflow_reply:
for p in msg.ports:
add.append(p)
ports[p.port_no] = p
else:
# Openflow 1.0, use features_request
if onup:
# Use the features_reply on connection setup
reply = connection.openflow_featuresreply
else:
request = ofdef.ofp_msg()
request.header.type = ofdef.OFPT_FEATURES_REQUEST
for m in protocol.querywithreply(request):
yield m
reply = self.apiroutine.retvalue
ports = self.managed_ports.setdefault((vhost, dpid), {})
for p in reply.ports:
add.append(p)
ports[p.port_no] = p
if update:
for m in self.apiroutine.waitForSend(OpenflowPortSynchronized(connection)):
yield m
for m in self.apiroutine.waitForSend(ModuleNotification(self.getServiceName(), 'update',
datapathid = connection.openflow_datapathid,
connection = connection,
vhost = protocol.vhost,
add = add, remove = [],
reason = 'connected')):
yield m
except ConnectionResetException:
pass
except OpenflowProtocolException:
pass
def _get_existing_ports(self):
for m in callAPI(self.apiroutine, 'openflowmanager', 'getallconnections', {'vhost':None}):
yield m
with closing(self.apiroutine.executeAll([self._get_ports(c, c.protocol, False, False) for c in self.apiroutine.retvalue if c.openflow_auxiliaryid == 0])) as g:
for m in g:
yield m
self._synchronized = True
for m in self.apiroutine.waitForSend(ModuleNotification(self.getServiceName(), 'synchronized')):
yield m
def _wait_for_sync(self):
if not self._synchronized:
yield (ModuleNotification.createMatcher(self.getServiceName(), 'synchronized'),)
def _manage_ports(self):
try:
self.apiroutine.subroutine(self._get_existing_ports())
conn_update = ModuleNotification.createMatcher('openflowmanager', 'update')
port_status = OpenflowAsyncMessageEvent.createMatcher(of13.OFPT_PORT_STATUS, None, 0)
while True:
yield (conn_update, port_status)
if self.apiroutine.matcher is port_status:
e = self.apiroutine.event
m = e.message
c = e.connection
if (c.protocol.vhost, c.openflow_datapathid) in self.managed_ports:
if m.reason == c.openflowdef.OFPPR_ADD:
# A new port is added
self.managed_ports[(c.protocol.vhost, c.openflow_datapathid)][m.desc.port_no] = m.desc
self.scheduler.emergesend(ModuleNotification(self.getServiceName(), 'update',
datapathid = c.openflow_datapathid,
connection = c,
vhost = c.protocol.vhost,
add = [m.desc], remove = [],
reason = 'add'))
elif m.reason == c.openflowdef.OFPPR_DELETE:
try:
del self.managed_ports[(c.protocol.vhost, c.openflow_datapathid)][m.desc.port_no]
#.........这里部分代码省略.........
示例2: OpenflowManager
# 需要导入模块: from vlcp.event.runnable import RoutineContainer [as 别名]
# 或者: from vlcp.event.runnable.RoutineContainer import waitForSend [as 别名]
class OpenflowManager(Module):
'''
Manage Openflow Connections
'''
service = True
_default_vhostbind = None
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._manage_conns
self.routines.append(self.apiroutine)
self.managed_conns = {}
self.endpoint_conns = {}
self.table_modules = set()
self._acquiring = False
self._acquire_updated = False
self._lastacquire = None
self._synchronized = False
self.createAPI(api(self.getconnections, self.apiroutine),
api(self.getconnection, self.apiroutine),
api(self.waitconnection, self.apiroutine),
api(self.getdatapathids, self.apiroutine),
api(self.getalldatapathids, self.apiroutine),
api(self.getallconnections, self.apiroutine),
api(self.getconnectionsbyendpoint, self.apiroutine),
api(self.getconnectionsbyendpointname, self.apiroutine),
api(self.getendpoints, self.apiroutine),
api(self.getallendpoints, self.apiroutine),
api(self.acquiretable, self.apiroutine),
api(self.unacquiretable, self.apiroutine),
api(self.lastacquiredtables)
)
def _add_connection(self, conn):
vhost = conn.protocol.vhost
conns = self.managed_conns.setdefault((vhost, conn.openflow_datapathid), [])
remove = []
for i in range(0, len(conns)):
if conns[i].openflow_auxiliaryid == conn.openflow_auxiliaryid:
ci = conns[i]
remove = [ci]
ep = _get_endpoint(ci)
econns = self.endpoint_conns.get((vhost, ep))
if econns is not None:
try:
econns.remove(ci)
except ValueError:
pass
if not econns:
del self.endpoint_conns[(vhost, ep)]
del conns[i]
break
conns.append(conn)
ep = _get_endpoint(conn)
econns = self.endpoint_conns.setdefault((vhost, ep), [])
econns.append(conn)
if self._lastacquire and conn.openflow_auxiliaryid == 0:
self.apiroutine.subroutine(self._initialize_connection(conn))
return remove
def _initialize_connection(self, conn):
ofdef = conn.openflowdef
flow_mod = ofdef.ofp_flow_mod(buffer_id = ofdef.OFP_NO_BUFFER,
out_port = ofdef.OFPP_ANY,
command = ofdef.OFPFC_DELETE
)
if hasattr(ofdef, 'OFPG_ANY'):
flow_mod.out_group = ofdef.OFPG_ANY
if hasattr(ofdef, 'OFPTT_ALL'):
flow_mod.table_id = ofdef.OFPTT_ALL
if hasattr(ofdef, 'ofp_match_oxm'):
flow_mod.match = ofdef.ofp_match_oxm()
cmds = [flow_mod]
if hasattr(ofdef, 'ofp_group_mod'):
group_mod = ofdef.ofp_group_mod(command = ofdef.OFPGC_DELETE,
group_id = ofdef.OFPG_ALL
)
cmds.append(group_mod)
for m in conn.protocol.batch(cmds, conn, self.apiroutine):
yield m
if hasattr(ofdef, 'ofp_instruction_goto_table'):
# Create default flows
vhost = conn.protocol.vhost
if self._lastacquire and vhost in self._lastacquire:
_, pathtable = self._lastacquire[vhost]
cmds = [ofdef.ofp_flow_mod(table_id = t[i][1],
command = ofdef.OFPFC_ADD,
priority = 0,
buffer_id = ofdef.OFP_NO_BUFFER,
out_port = ofdef.OFPP_ANY,
out_group = ofdef.OFPG_ANY,
match = ofdef.ofp_match_oxm(),
instructions = [ofdef.ofp_instruction_goto_table(table_id = t[i+1][1])]
)
for _,t in pathtable.items()
for i in range(0, len(t) - 1)]
if cmds:
for m in conn.protocol.batch(cmds, conn, self.apiroutine):
yield m
for m in self.apiroutine.waitForSend(FlowInitialize(conn, conn.openflow_datapathid, conn.protocol.vhost)):
yield m
def _acquire_tables(self):
#.........这里部分代码省略.........
示例3: OVSDBManager
# 需要导入模块: from vlcp.event.runnable import RoutineContainer [as 别名]
# 或者: from vlcp.event.runnable.RoutineContainer import waitForSend [as 别名]
class OVSDBManager(Module):
'''
Manage Openflow Connections
'''
service = True
_default_vhostbind = None
_default_bridgenames = None
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._manage_conns
self.routines.append(self.apiroutine)
self.managed_conns = {}
self.managed_systemids = {}
self.managed_bridges = {}
self.managed_routines = []
self.endpoint_conns = {}
self.createAPI(api(self.getconnection, self.apiroutine),
api(self.waitconnection, self.apiroutine),
api(self.getdatapathids, self.apiroutine),
api(self.getalldatapathids, self.apiroutine),
api(self.getallconnections, self.apiroutine),
api(self.getbridges, self.apiroutine),
api(self.getbridge, self.apiroutine),
api(self.getbridgebyuuid, self.apiroutine),
api(self.waitbridge, self.apiroutine),
api(self.waitbridgebyuuid, self.apiroutine),
api(self.getsystemids, self.apiroutine),
api(self.getallsystemids, self.apiroutine),
api(self.getconnectionbysystemid, self.apiroutine),
api(self.waitconnectionbysystemid, self.apiroutine),
api(self.getconnectionsbyendpoint, self.apiroutine),
api(self.getconnectionsbyendpointname, self.apiroutine),
api(self.getendpoints, self.apiroutine),
api(self.getallendpoints, self.apiroutine),
api(self.getallbridges, self.apiroutine),
api(self.getbridgeinfo, self.apiroutine),
api(self.waitbridgeinfo, self.apiroutine)
)
self._synchronized = False
def _update_bridge(self, connection, protocol, bridge_uuid, vhost):
try:
method, params = ovsdb.transact('Open_vSwitch',
ovsdb.wait('Bridge', [["_uuid", "==", ovsdb.uuid(bridge_uuid)]],
["datapath_id"], [{"datapath_id": ovsdb.oset()}], False, 5000),
ovsdb.select('Bridge', [["_uuid", "==", ovsdb.uuid(bridge_uuid)]],
["datapath_id","name"]))
for m in protocol.querywithreply(method, params, connection, self.apiroutine):
yield m
r = self.apiroutine.jsonrpc_result[0]
if 'error' in r:
raise JsonRPCErrorResultException('Error while acquiring datapath-id: ' + repr(r['error']))
r = self.apiroutine.jsonrpc_result[1]
if 'error' in r:
raise JsonRPCErrorResultException('Error while acquiring datapath-id: ' + repr(r['error']))
if r['rows']:
r0 = r['rows'][0]
name = r0['name']
dpid = int(r0['datapath_id'], 16)
if self.bridgenames is None or name in self.bridgenames:
self.managed_bridges[connection].append((vhost, dpid, name, bridge_uuid))
self.managed_conns[(vhost, dpid)] = connection
for m in self.apiroutine.waitForSend(OVSDBBridgeSetup(OVSDBBridgeSetup.UP,
dpid,
connection.ovsdb_systemid,
name,
connection,
connection.connmark,
vhost,
bridge_uuid)):
yield m
except JsonRPCProtocolException:
pass
def _get_bridges(self, connection, protocol):
try:
try:
vhost = protocol.vhost
if not hasattr(connection, 'ovsdb_systemid'):
method, params = ovsdb.transact('Open_vSwitch', ovsdb.select('Open_vSwitch', [], ['external_ids']))
for m in protocol.querywithreply(method, params, connection, self.apiroutine):
yield m
result = self.apiroutine.jsonrpc_result[0]
system_id = ovsdb.omap_getvalue(result['rows'][0]['external_ids'], 'system-id')
connection.ovsdb_systemid = system_id
else:
system_id = connection.ovsdb_systemid
if (vhost, system_id) in self.managed_systemids:
oc = self.managed_systemids[(vhost, system_id)]
ep = _get_endpoint(oc)
econns = self.endpoint_conns.get((vhost, ep))
if econns:
try:
econns.remove(oc)
except ValueError:
pass
del self.managed_systemids[(vhost, system_id)]
self.managed_systemids[(vhost, system_id)] = connection
self.managed_bridges[connection] = []
ep = _get_endpoint(connection)
self.endpoint_conns.setdefault((vhost, ep), []).append(connection)
#.........这里部分代码省略.........
示例4: ObjectDB
# 需要导入模块: from vlcp.event.runnable import RoutineContainer [as 别名]
# 或者: from vlcp.event.runnable.RoutineContainer import waitForSend [as 别名]
#.........这里部分代码省略.........
# key => [(walker_func, original_keys, rid), ...]
walkers = {}
self._loopCount = 0
# A request-id -> retrieve set dictionary to store the saved keys
savelist = {}
def updateloop():
while (retrieve_list or self._updatekeys or self._requests):
watch_keys = set()
# Updated keys
update_list = set()
if self._loopCount >= 10 and not retrieve_list:
if not self._updatekeys:
break
elif self._loopCount >= 100:
# Too many updates, we must stop to respond
self._logger.warning("There are still database updates after 100 loops of mget, respond with potential inconsistent values")
break
if self._updatekeys:
update_list.update(self._updatekeys)
self._updatekeys.clear()
if self._requests:
# Processing requests
for r in self._requests:
if r[2] == 'unwatch':
try:
for k in r[0]:
s = self._watches.get(k)
if s:
s.discard(r[3])
if not s:
del self._watches[k]
# Do not need to wait
except Exception as exc:
for m in self.apiroutine.waitForSend(RetrieveReply(r[1], exception = exc)):
yield m
else:
for m in self.apiroutine.waitForSend(RetrieveReply(r[1], result = None)):
yield m
elif r[2] == 'watch':
retrieve_list.update(r[0])
orig_retrieve_list.update(r[0])
for k in r[0]:
self._watches.setdefault(k, set()).add(r[3])
processing_requests.append(r)
elif r[2] == 'get':
retrieve_list.update(r[0])
orig_retrieve_list.update(r[0])
processing_requests.append(r)
elif r[2] == 'walk':
retrieve_list.update(r[0])
processing_requests.append(r)
for k,v in r[3].items():
walkers.setdefault(k, []).append((v, (r[0], r[1])))
else:
retrieveonce_list.update(r[0])
orig_retrieveonce_list.update(r[0])
processing_requests.append(r)
del self._requests[:]
if retrieve_list:
watch_keys.update(retrieve_list)
# Add watch_keys to notification
watch_keys.difference_update(self._watchedkeys)
if watch_keys:
for k in watch_keys:
if k in update_result:
self._update_version[k] = getversion(update_result[k])
示例5: OVSDBPortManager
# 需要导入模块: from vlcp.event.runnable import RoutineContainer [as 别名]
# 或者: from vlcp.event.runnable.RoutineContainer import waitForSend [as 别名]
class OVSDBPortManager(Module):
'''
Manage Ports from OVSDB Protocol
'''
service = True
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._manage_ports
self.routines.append(self.apiroutine)
self.managed_ports = {}
self.managed_ids = {}
self.monitor_routines = set()
self.ports_uuids = {}
self.wait_portnos = {}
self.wait_names = {}
self.wait_ids = {}
self.bridge_datapathid = {}
self.createAPI(api(self.getports, self.apiroutine),
api(self.getallports, self.apiroutine),
api(self.getportbyid, self.apiroutine),
api(self.waitportbyid, self.apiroutine),
api(self.getportbyname, self.apiroutine),
api(self.waitportbyname, self.apiroutine),
api(self.getportbyno, self.apiroutine),
api(self.waitportbyno, self.apiroutine),
api(self.resync, self.apiroutine)
)
self._synchronized = False
def _get_interface_info(self, connection, protocol, buuid, interface_uuid, port_uuid):
try:
method, params = ovsdb.transact('Open_vSwitch',
ovsdb.wait('Interface', [["_uuid", "==", ovsdb.uuid(interface_uuid)]],
["ofport"], [{"ofport":ovsdb.oset()}], False, 5000),
ovsdb.wait('Interface', [["_uuid", "==", ovsdb.uuid(interface_uuid)]],
["ifindex"], [{"ifindex":ovsdb.oset()}], False, 5000),
ovsdb.select('Interface', [["_uuid", "==", ovsdb.uuid(interface_uuid)]],
["_uuid", "name", "ifindex", "ofport", "type", "external_ids"]))
for m in protocol.querywithreply(method, params, connection, self.apiroutine):
yield m
r = self.apiroutine.jsonrpc_result[0]
if 'error' in r:
raise JsonRPCErrorResultException('Error while acquiring interface: ' + repr(r['error']))
r = self.apiroutine.jsonrpc_result[1]
if 'error' in r:
raise JsonRPCErrorResultException('Error while acquiring interface: ' + repr(r['error']))
r = self.apiroutine.jsonrpc_result[2]
if 'error' in r:
raise JsonRPCErrorResultException('Error while acquiring interface: ' + repr(r['error']))
if not r['rows']:
self.apiroutine.retvalue = []
return
r0 = r['rows'][0]
if r0['ofport'] < 0:
# Ignore this port because it is in an error state
self.apiroutine.retvalue = []
return
r0['_uuid'] = r0['_uuid'][1]
r0['ifindex'] = ovsdb.getoptional(r0['ifindex'])
r0['external_ids'] = ovsdb.getdict(r0['external_ids'])
if buuid not in self.bridge_datapathid:
self.apiroutine.retvalue = []
return
else:
datapath_id = self.bridge_datapathid[buuid]
if 'iface-id' in r0['external_ids']:
eid = r0['external_ids']['iface-id']
r0['id'] = eid
id_ports = self.managed_ids.setdefault((protocol.vhost, eid), [])
id_ports.append((datapath_id, r0))
else:
r0['id'] = None
self.managed_ports.setdefault((protocol.vhost, datapath_id),[]).append((port_uuid, r0))
notify = False
if (protocol.vhost, datapath_id, r0['ofport']) in self.wait_portnos:
notify = True
del self.wait_portnos[(protocol.vhost, datapath_id, r0['ofport'])]
if (protocol.vhost, datapath_id, r0['name']) in self.wait_names:
notify = True
del self.wait_names[(protocol.vhost, datapath_id, r0['name'])]
if (protocol.vhost, r0['id']) in self.wait_ids:
notify = True
del self.wait_ids[(protocol.vhost, r0['id'])]
if notify:
for m in self.apiroutine.waitForSend(OVSDBPortUpNotification(connection, r0['name'],
r0['ofport'], r0['id'],
protocol.vhost, datapath_id,
port = r0)):
yield m
self.apiroutine.retvalue = [r0]
except JsonRPCProtocolException:
self.apiroutine.retvalue = []
def _remove_interface_id(self, connection, protocol, datapath_id, port):
eid = port['id']
eid_list = self.managed_ids.get((protocol.vhost, eid))
for i in range(0, len(eid_list)):
if eid_list[i][1]['_uuid'] == port['_uuid']:
del eid_list[i]
break
def _remove_interface(self, connection, protocol, datapath_id, interface_uuid, port_uuid):
#.........这里部分代码省略.........