本文整理汇总了Python中ryu.ofproto.ofproto_parser.header函数的典型用法代码示例。如果您正苦于以下问题：Python header函数的具体用法？Python header怎么用？Python header使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了header函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: _test_msg
def _test_msg(self, name, wire_msg, json_str):
json_dict = json.loads(json_str)
# on-wire -> OFPxxx -> json
(version, msg_type, msg_len, xid) = ofproto_parser.header(wire_msg)
try:
has_parser, has_serializer = implemented[version][msg_type]
except KeyError:
has_parser = True
has_serializer = True
dp = DummyDatapath(*self._ofp_versions[version])
if has_parser:
msg = ofproto_parser.msg(dp, version, msg_type, msg_len, xid,
wire_msg)
json_dict2 = self._msg_to_jsondict(msg)
# XXXdebug code
open(('/tmp/%s.json' % name), 'wb').write(json.dumps(json_dict2))
eq_(json_dict, json_dict2)
# json -> OFPxxx -> json
msg2 = self._jsondict_to_msg(dp, json_dict)
if has_serializer:
msg2.serialize()
eq_(self._msg_to_jsondict(msg2), json_dict)
eq_(wire_msg, msg2.buf)示例2: _on_header
def _on_header(self, data):
assert len(data) == ofproto_common.OFP_HEADER_SIZE
self._msg_header = data
(version, msg_type, msg_len, xid) = ofproto_parser.header(data)
assert msg_len >= ofproto_common.OFP_HEADER_SIZE
if not self.stream.closed():
self.stream.read_bytes(msg_len-ofproto_common.OFP_HEADER_SIZE, stack_context.wrap(self._on_message))示例3: SBP_handler
def SBP_handler(self, ev):
# Parser the msg and raise an event.
# Handle event in service or app.
msg = ev.msg
domain = msg.domain
data = msg.data
if domain.sbp_proto_type == oxproto_v1_0.OXPS_OPENFLOW:
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
if len(data) == 0:
return
buf += data
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
self.logger.debug('ofp msg %s cls %s', msg, msg.__class__)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(self.fake_datapath,
version, msg_type, msg_len, xid, buf)
if msg:
ev = oxp_event.sbp_to_oxp_msg_to_ev(msg)
ev.domain = domain
self.send_event_to_observers(ev, MAIN_DISPATCHER)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE示例4: blocking_read_sdn_message
def blocking_read_sdn_message(self,block_read_written=False):
'''
@returns an SDN message
'''
reader_method = self._sdn_socket.blocking_read
if block_read_written:
reader_method = self._sdn_socket.blocking_read_written
# first read openflow header
msg_buffer = reader_method(OFP_HEADER_SIZE)
while len(msg_buffer) != OFP_HEADER_SIZE:
diff = OFP_HEADER_SIZE - len(msg_buffer)
msg_buffer.extend(reader_method(diff))
# based on size of openflow header, decide how much more to
# read
(version, msg_type, msg_len, xid) = ofproto_parser.header(msg_buffer)
while len(msg_buffer) != msg_len:
diff = msg_len - len(msg_buffer)
msg_buffer.extend(reader_method(diff))
msg = ofproto_parser.msg(
_OF_1_0_DATAPATH, version, msg_type, msg_len,
xid, str(msg_buffer))
msg.original_buffer = msg_buffer
return msg示例5: error_msg_handler
def error_msg_handler(self, ev):
msg = ev.msg
ofp = msg.datapath.ofproto
self.logger.debug(
"EventOFPErrorMsg received.\n"
"version=%s, msg_type=%s, msg_len=%s, xid=%s\n"
" `-- msg_type: %s\n"
"OFPErrorMsg(type=%s, code=%s, data=b'%s')\n"
" |-- type: %s\n"
" |-- code: %s",
hex(msg.version), hex(msg.msg_type), hex(msg.msg_len),
hex(msg.xid), ofp.ofp_msg_type_to_str(msg.msg_type),
hex(msg.type), hex(msg.code), utils.binary_str(msg.data),
ofp.ofp_error_type_to_str(msg.type),
ofp.ofp_error_code_to_str(msg.type, msg.code))
if len(msg.data) >= ofp.OFP_HEADER_SIZE:
(version, msg_type, msg_len, xid) = ofproto_parser.header(msg.data)
self.logger.debug(
" `-- data: version=%s, msg_type=%s, msg_len=%s, xid=%s\n"
" `-- msg_type: %s",
hex(version), hex(msg_type), hex(msg_len), hex(xid),
ofp.ofp_msg_type_to_str(msg_type))
else:
self.logger.warning(
"The data field sent from the switch is too short: "
"len(msg.data) < OFP_HEADER_SIZE\n"
"The OpenFlow Spec says that the data field should contain "
"at least 64 bytes of the failed request.\n"
"Please check the settings or implementation of your switch.")示例6: handle
def handle(self):
desc = ofproto_protocol.ProtocolDesc()
residue = b''
while True:
if residue:
data = residue
residue = b''
else:
data = self.request.recv(1024)
if data == b'':
break
if self.verbose:
print(data)
h = ofproto_parser.header(data)
if self.verbose:
print(h)
version, msg_type, msg_len, xid = h
residue = data[msg_len:]
desc.set_version(version=version)
if msg_type == desc.ofproto.OFPT_HELLO:
hello = desc.ofproto_parser.OFPHello(desc)
hello.serialize()
self.request.send(hello.buf)
elif msg_type == desc.ofproto.OFPT_FLOW_MOD:
buf.append(data[:msg_len])
elif msg_type == desc.ofproto.OFPT_BARRIER_REQUEST:
brep = desc.ofproto_parser.OFPBarrierReply(desc)
brep.xid = xid
brep.serialize()
self.request.send(brep.buf)
break示例7: _recv_loop
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while self.is_active:
ret = self.socket.recv(required_len)
if len(ret) == 0:
self.is_active = False
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(self,
version, msg_type, msg_len, xid, buf)
# LOG.debug('queue msg %s cls %s', msg, msg.__class__)
if msg:
self.principal_connection.receive_principal_message(msg)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)示例8: handle_event
def handle_event(self, header, msg):
#required_len = self.ofp.OFP_HEADER_SIZE
ret = bytearray(msg)
(version, msg_type, msg_len, xid) = ofproto_parser.header(ret)
self.netide_xid = header[NetIDEOps.NetIDE_header['XID']]
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid, ret)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
event_observers = self.ofp_brick.get_observers(ev,self.state)
module_id = header[NetIDEOps.NetIDE_header['MOD_ID']]
for key, value in self.channel.running_modules.iteritems():
if value == module_id and key in event_observers:
module_brick = ryu.base.app_manager.lookup_service_brick(key)
module_brick_handlers = module_brick.get_handlers(ev)
for handler in module_brick_handlers:
handler(ev)
break
# Sending the FENCE message to the Core only if self.netide_xid is not 0
if self.netide_xid is not 0:
msg_to_send = NetIDEOps.netIDE_encode('NETIDE_FENCE', self.netide_xid, module_id, 0, "")
self.channel.socket.send(msg_to_send)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [handler for handler in
self.ofp_brick.get_handlers(ev) if
self.state in dispatchers(handler)]
for handler in handlers:
handler(ev)
# Resetting netide_xid to zero
self.netide_xid = 0示例9: SBP_handler
def SBP_handler(self, ev):
# parser the msg and handle the SBP message.
# raise the event.
# finish it in service or app.
msg = ev.msg
domain = msg.domain
data = msg.data
if CONF.sbp_proto_type == oxproto_v1_0.OXPS_OPENFLOW:
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
if len(data) == 0:
return
buf += data
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(self.network_aware.fake_datapath,
version, msg_type, msg_len, xid, buf)
if msg:
ev = oxp_event.sbp_to_oxp_msg_to_ev(msg)
ev.domain = domain
self.send_event_to_observers(ev, MAIN_DISPATCHER)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE示例10: _on_message
def _on_message(self, data):
(version, msg_type, msg_len, xid) = ofproto_parser.header(self._msg_header)
assert len(data) == msg_len - ofproto_common.OFP_HEADER_SIZE
msg = ofproto_parser.msg(self, version, msg_type, msg_len, xid, self._msg_header+data)
logging.getLogger("openflow").debug("RECV %s %s" % (self.address, msg))
self.dispatch(msg)
if not self.stream.closed():
self.stream.read_bytes(ofproto_common.OFP_HEADER_SIZE, stack_context.wrap(self._on_header))示例11: testHello
def testHello(self):
(version,
msg_type,
msg_len,
xid) = ofproto_parser.header(self.bufHello)
eq_(version, 1)
eq_(msg_type, 0)
eq_(msg_len, 8)
eq_(xid, 1)示例12: _recv_loop
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while self.state != DEAD_DISPATCHER:
ret = ""
try:
ret = self.socket.recv(required_len)
except SocketTimeout:
continue
except ssl.SSLError:
# eventlet throws SSLError (which is a subclass of IOError)
# on SSL socket read timeout; re-try the loop in this case.
continue
except (EOFError, IOError):
break
if len(ret) == 0:
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(
self, version, msg_type, msg_len, xid, buf[:msg_len])
# LOG.debug('queue msg %s cls %s', msg, msg.__class__)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [handler for handler in
self.ofp_brick.get_handlers(ev) if
self.state in dispatchers(handler)]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)示例13: _recv_loop
def _recv_loop(self):
buf = bytearray()
required_len = ofproto_common.OFP_HEADER_SIZE
count = 0
while True:
ret = ""
try:
ret = self.socket.recv(required_len)
except:
# Hit socket timeout; decide what to do.
if self.close_requested:
pass
else:
continue
if (len(ret) == 0) or (self.close_requested):
self.socket.close()
break
buf += ret
while len(buf) >= required_len:
(version, msg_type, msg_len, xid) = ofproto_parser.header(buf)
required_len = msg_len
if len(buf) < required_len:
break
msg = ofproto_parser.msg(
self, version, msg_type, msg_len, xid, buf[:msg_len])
# LOG.debug('queue msg %s cls %s', msg, msg.__class__)
if msg:
ev = ofp_event.ofp_msg_to_ev(msg)
self.ofp_brick.send_event_to_observers(ev, self.state)
dispatchers = lambda x: x.callers[ev.__class__].dispatchers
handlers = [handler for handler in
self.ofp_brick.get_handlers(ev) if
self.state in dispatchers(handler)]
for handler in handlers:
handler(ev)
buf = buf[required_len:]
required_len = ofproto_common.OFP_HEADER_SIZE
# We need to schedule other greenlets. Otherwise, ryu
# can't accept new switches or handle the existing
# switches. The limit is arbitrary. We need the better
# approach in the future.
count += 1
if count > 2048:
count = 0
hub.sleep(0)示例14: test_check_msg_parser
def test_check_msg_parser(self):
(version,
msg_type,
msg_len,
xid) = ofproto_parser.header(self.bufPacketIn)
version = 0xff
ofproto_parser.msg(self,
version,
msg_type,
msg_len,
xid,
self.bufPacketIn)示例15: error_msg_handler
def error_msg_handler(self, ev):
err_msg = ev.msg
#self.logger.info('OFPErrorMsg received: type=0x%02x code=0x%02x message=%s', msg.type, msg.code, utils.hex_array(msg.data))
if err_msg.type == ofproto_v1_3.OFPET_FLOW_MOD_FAILED and err_msg.code == ofproto_v1_3.OFPFMFC_TABLE_FULL:
print 'caputred full table error message'
self.rand_remove(err_msg.datapath)
#parser = err_msg.datapath.ofproto_parser
(version,msg_type,msg_len,xid)= ofproto_parser.header(err_msg.data)
print 'version %s, msg_type %s, msg_len %s, xid %s, len %s' % (version, msg_type, msg_len, xid, len(err_msg.data))
msg = ofproto_parser.msg(err_msg.datapath, version,msg_type,msg_len,xid,err_msg.data)
#controller will assign a new xid
msg.xid=None
error_msg.datapath.send_msg(msg)