def packets (self, neighbor, direction, category, header, body):
return self._header(self._neighbor(neighbor,direction,self._kv({
'message': '{ %s } ' % self._kv({
'category': category,
'header': hexstring(header),
'body': hexstring(body),
})
})),'','',neighbor,message_type=Message.string(category))
def read_message (self):
# This will always be defined by the loop but scope leaking upset scrutinizer/pylint
msg_id = None
packets = self.neighbor.api['receive-packets']
consolidate = self.neighbor.api['receive-consolidate']
parsed = self.neighbor.api['receive-parsed']
body,header = '','' # just because pylint/pylama are getting more clever
for length,msg_id,header,body,notify in self.connection.reader():
if notify:
if self.neighbor.api['receive-%d' % Message.CODE.NOTIFICATION]:
if packets and not consolidate:
self.peer.reactor.processes.packets(self.peer.neighbor,'receive',msg_id,header,body)
if not packets or consolidate:
header = ''
body = ''
self.peer.reactor.processes.notification(self.peer.neighbor,'receive',notify.code,notify.subcode,str(notify),header,body)
# XXX: is notify not already Notify class ?
raise Notify(notify.code,notify.subcode,str(notify))
if not length:
yield _NOP
if packets and not consolidate:
self.peer.reactor.processes.packets(self.peer.neighbor,'receive',msg_id,header,body)
if msg_id == Message.CODE.UPDATE:
if not parsed and not self.log_routes:
yield _UPDATE
return
self.logger.message(self.me('<< %s' % Message.CODE.name(msg_id)))
try:
message = Message.unpack(msg_id,body,self.negotiated)
except (KeyboardInterrupt,SystemExit,Notify):
raise
except Exception,exc:
self.logger.message(self.me('Could not decode message "%d"' % msg_id))
self.logger.message(self.me('%s' % str(exc)))
self.logger.message(traceback.format_exc())
raise Notify(1,0,'can not decode update message of type "%d"' % msg_id)
def __init__(self, afi, safi, action=None):
Message.__init__(self)
self.nlris = [
EOR.NLRI(afi, safi, action),
]
self.attributes = Attributes()
def _message (self, data):
return Message._message(self,concat_bytes(
self.what.pack(),
pack('!H',len(data)),
data
))
def __init__ (self, what): Message.__init__(self) self.what = Type(what)
def _message(self, data):
return Message._message(
self, concat_bytes(self.what.pack(), pack('!H', len(data)), data))
def __init__(self, what):
Message.__init__(self)
self.what = Type(what)
def _from_json (self, string):
try:
parsed = json.loads(string)
except ValueError:
print >> sys.stderr, 'invalid JSON message'
sys.exit(1)
if parsed.get('exabgp','0.0.0') != json_version:
print >> sys.stderr, 'invalid json version', string
sys.exit(1)
content = parsed.get('type','')
if not content:
print >> sys.stderr, 'invalid json content', string
sys.exit(1)
neighbor = _FakeNeighbor(
parsed['neighbor']['address']['local'],
parsed['neighbor']['address']['peer'],
parsed['neighbor']['asn']['local'],
parsed['neighbor']['asn']['peer'],
)
if content == 'state':
self._state()
return string
direction = parsed['neighbor']['direction']
category = parsed['neighbor']['message']['category']
header = parsed['neighbor']['message']['header']
body = parsed['neighbor']['message']['body']
raw = ''.join(chr(int(body[_:_+2],16)) for _ in range(0,len(body),2))
if content == 'open':
message = Open.unpack_message(raw)
self._open(direction,message)
return self.encoder.open(neighbor,direction,message,header,body)
if content == 'keapalive':
return self.encoder.keepalive(neighbor,direction,header,body)
if content == 'notification':
return self.encoder.notification(neighbor,direction,ord(message[0]),ord(message[1]),message[2:],header,body)
if not self.negotiated:
print >> sys.stderr, 'invalid message sequence, open not exchange not complete', string
sys.exit(1)
message = Message.unpack(category,raw,self.negotiated)
if content == 'update':
return self.encoder.update(neighbor, direction, message, header,body)
if content == 'eor': # XXX: Should not be required
return self.encoder.update(neighbor, direction, message, header,body)
if content == 'refresh':
return self.json.refresh(neighbor, direction, message, header,body)
if content == 'operational':
return self.json.refresh(neighbor, direction, message, header,body)
raise RuntimeError('the programer is a monkey and forgot a JSON message type')
def __init__ (self, afi, safi, action=None): Message.__init__(self) self.nlris = [EOR.NLRI(afi,safi,action),] self.attributes = Attributes()
def _message(self, data):
return Message._message(
self, "%s%s%s" % (self.what.pack(), pack('!H', len(data)), data))
def _message(self, data):
return Message._message(self, self.what.pack() + pack('!H', len(data)) + data)
def _message (self, data):
return Message._message(self,"%s%s%s" % (
self.what.pack(),
pack('!H',len(data)),
data
))
class TestData (unittest.TestCase):
def test_1_open (self):
check_capa = {
1: [(AFI.ipv4, SAFI.unicast), (AFI.ipv6, SAFI.unicast)],
2: RouteRefresh(),
65: 65534L,
128: RouteRefresh(),
}
message_id = 1
body = ''.join([chr(c) for c in [0x4, 0xff, 0xfe, 0x0, 0xb4, 0x0, 0x0, 0x0, 0x0, 0x20, 0x2, 0x6, 0x1, 0x4, 0x0, 0x1, 0x0, 0x1, 0x2, 0x6, 0x1, 0x4, 0x0, 0x2, 0x0, 0x1, 0x2, 0x2, 0x80, 0x0, 0x2, 0x2, 0x2, 0x0, 0x2, 0x6, 0x41, 0x4, 0x0, 0x0, 0xff, 0xfe]])
negotiated = {'invalid':'test'}
o = Message.unpack(message_id,body,negotiated)
self.assertEqual(o.version,4)
self.assertEqual(o.asn,65534)
self.assertEqual(o.router_id,RouterID('0.0.0.0'))
self.assertEqual(o.hold_time,180)
for k,v in o.capabilities.items():
self.assertEqual(v,check_capa[k])
def test_2_open (self):
capabilities = Capabilities()
o = Open(4,65500,'127.0.0.1',capabilities,180)
self.assertEqual(o.version,4)
self.assertEqual(o.asn,65500)
self.assertEqual(o.router_id,RouterID('127.0.0.1'))
self.assertEqual(o.hold_time,180)
ANNOUNCE = 0x01 WITHDRAW = 0x02 class IN (object): ANNOUNCED = 0x01 WITHDRAWN = 0x02 # ================================================================ Registration # from exabgp.bgp.message.message import Message from exabgp.bgp.message.open import Open from exabgp.bgp.message.update import Update from exabgp.bgp.message.keepalive import KeepAlive from exabgp.bgp.message.notification import Notification from exabgp.bgp.message.refresh import RouteRefresh from exabgp.bgp.message.operational import Operational Message.register_message(Open) Message.register_message(Update) Message.register_message(KeepAlive) Message.register_message(Notification) Message.register_message(RouteRefresh) Message.register_message(Operational) from exabgp.bgp.message.notification import Notify Message.klass_notify = Notify
