本文整理汇总了Python中exabgp.logger.FakeLogger.network方法的典型用法代码示例。如果您正苦于以下问题:Python FakeLogger.network方法的具体用法?Python FakeLogger.network怎么用?Python FakeLogger.network使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类exabgp.logger.FakeLogger
的用法示例。
在下文中一共展示了FakeLogger.network方法的10个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: Connection
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Connection (object):
direction = 'undefined'
identifier = 0
def __init__ (self,afi,peer,local):
# peer and local are strings of the IP
# If the OS tells us we have data on the socket, we should never have to wait more than read_timeout to be able to read it.
# However real life says that on some OS we do ... So let the user control this value
try:
self.read_timeout = environment.settings().tcp.timeout
self.defensive = environment.settings().debug.defensive
self.logger = Logger()
except RuntimeError:
self.read_timeout = 1
self.defensive = True
self.logger = FakeLogger()
self.afi = afi
self.peer = peer
self.local = local
self._reading = None
self._writing = None
self._buffer = ''
self.io = None
self.established = False
self.identifier += 1
self.id = self.identifier
# Just in case ..
def __del__ (self):
if self.io:
self.logger.network("%s connection to %s closed" % (self.name(),self.peer),'info')
self.close()
def name (self):
return "session %d %s" % (self.id,self.direction)
def close (self):
try:
self.logger.wire("%s, closing connection from %s to %s" % (self.name(),self.local,self.peer))
if self.io:
self.io.close()
self.io = None
except KeyboardInterrupt,e:
raise e
except:
示例2: Connection
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Connection (object):
direction = 'undefined'
identifier = 0
def __init__ (self, afi, peer, local):
# peer and local are strings of the IP
try:
self.defensive = environment.settings().debug.defensive
self.logger = Logger()
except RuntimeError:
self.defensive = True
self.logger = FakeLogger()
self.afi = afi
self.peer = peer
self.local = local
self._buffer = ''
self.io = None
self.established = False
self.identifier += 1
self.id = self.identifier
# Just in case ..
def __del__ (self):
if self.io:
self.logger.network("%s connection to %s closed" % (self.name(),self.peer),'info')
self.close()
def name (self):
return "session %d %s" % (self.id,self.direction)
def close (self):
try:
self.logger.wire("%s, closing connection from %s to %s" % (self.name(),self.local,self.peer))
if self.io:
self.io.close()
self.io = None
except KeyboardInterrupt,exc:
raise exc
except:
示例3: Protocol
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Protocol (object):
decode = True
def __init__ (self,peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
port = os.environ.get('exabgp.tcp.port','') or os.environ.get('exabgp_tcp_port','')
self.port = int(port) if port.isdigit() else 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN-Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = environment.settings().log.routes
# XXX: we use self.peer.neighbor.peer_address when we could use self.neighbor.peer_address
def __del__ (self):
self.close('automatic protocol cleanup')
def me (self,message):
return "Peer %15s ASN %-7s %s" % (self.peer.neighbor.peer_address,self.peer.neighbor.peer_as,message)
def accept (self,incoming):
self.connection = incoming
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer)
# very important - as we use this function on __init__
return self
def connect (self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if not self.connection:
peer = self.neighbor.peer_address
local = self.neighbor.local_address
md5 = self.neighbor.md5
ttl = self.neighbor.ttl
self.connection = Outgoing(peer.afi,peer.ip,local.ip,self.port,md5,ttl)
try:
generator = self.connection.establish()
while True:
connected = generator.next()
if not connected:
yield False
continue
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer)
yield True
return
except StopIteration:
# close called by the caller
# self.close('could not connect to remote end')
yield False
return
def close (self,reason='protocol closed, reason unspecified'):
if self.connection:
self.logger.network(self.me(reason))
# must be first otherwise we could have a loop caused by the raise in the below
self.connection.close()
self.connection = None
try:
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.down(self.peer,reason)
except ProcessError:
self.logger.message(self.me('could not send notification of neighbor close to API'))
def write (self,message):
if self.neighbor.api['send-packets'] and not self.neighbor.api['consolidate']:
self.peer.reactor.processes.send(self.peer,ord(message[18]),message[:19],message[19:])
for boolean in self.connection.writer(message):
yield boolean
# Read from network .......................................................
def read_message (self):
for length,msg,header,body,notify in self.connection.reader():
if notify:
if self.neighbor.api['receive-packets']:
self.peer.reactor.processes.receive(self.peer,msg,header,body)
if self.neighbor.api[Message.ID.NOTIFICATION]:
self.peer.reactor.processes.notification(self.peer,notify.code,notify.subcode,str(notify))
# XXX: is notify not already Notify class ?
raise Notify(notify.code,notify.subcode,str(notify))
if not length:
yield _NOP
#.........这里部分代码省略.........
示例4: Protocol
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Protocol (object):
decode = True
def __init__ (self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port','').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port','').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN-Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = environment.settings().log.routes
# XXX: we use self.peer.neighbor.peer_address when we could use self.neighbor.peer_address
def __del__ (self):
self.close('automatic protocol cleanup')
def me (self, message):
return "Peer %15s ASN %-7s %s" % (self.peer.neighbor.peer_address,self.peer.neighbor.peer_as,message)
def accept (self, incoming):
self.connection = incoming
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
# very important - as we use this function on __init__
return self
def connect (self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if not self.connection:
local = self.neighbor.md5_ip
peer = self.neighbor.peer_address
md5 = self.neighbor.md5_password
ttl_out = self.neighbor.ttl_out
self.connection = Outgoing(peer.afi,peer.top(),local.top(),self.port,md5,ttl_out)
try:
generator = self.connection.establish()
while True:
connected = generator.next()
if not connected:
yield False
continue
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
yield True
return
except StopIteration:
# close called by the caller
# self.close('could not connect to remote end')
yield False
return
def close (self, reason='protocol closed, reason unspecified'):
if self.connection:
self.logger.network(self.me(reason))
# must be first otherwise we could have a loop caused by the raise in the below
self.connection.close()
self.connection = None
try:
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.down(self.peer.neighbor,reason)
except ProcessError:
self.logger.message(self.me('could not send notification of neighbor close to API'))
def _to_api (self,direction,message,raw):
packets = self.neighbor.api['%s-packets' % direction]
parsed = self.neighbor.api['%s-parsed' % direction]
consolidate = self.neighbor.api['%s-consolidate' % direction]
if consolidate:
if packets:
self.peer.reactor.processes.message(self.peer.neighbor,direction,message,raw[:19],raw[19:])
else:
self.peer.reactor.processes.message(self.peer.neighbor,direction,message,'','')
else:
if packets:
self.peer.reactor.processes.packets(self.peer.neighbor,direction,int(message.ID),raw[:19],raw[19:])
if parsed:
#.........这里部分代码省略.........
示例5: Peer
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
#.........这里部分代码省略.........
def send_new (self,changes=None,update=None):
if changes:
self.neighbor.rib.outgoing.replace(changes)
self._have_routes = self.neighbor.flush if update is None else update
def restart (self,restart_neighbor=None):
# we want to tear down the session and re-establish it
self._teardown = 3
self._restart = True
self._restarted = True
self._resend_routes = SEND.normal
self._neighbor = restart_neighbor
self._reset_skip()
def teardown (self,code,restart=True):
self._restart = restart
self._teardown = code
self._reset_skip()
# sockets we must monitor
def sockets (self):
ios = []
for direction in ['in','out']:
proto = self._[direction]['proto']
if proto and proto.connection and proto.connection.io:
ios.append(proto.connection.io)
return ios
def incoming (self,connection):
# if the other side fails, we go back to idle
if self._['in']['proto'] not in (True,False,None):
self.logger.network('we already have a peer at this address')
return False
self._['in']['proto'] = Protocol(self).accept(connection)
# Let's make sure we do some work with this connection
self._['in']['generator'] = None
self._['in']['state'] = STATE.connect
return True
def established (self):
return self._['in']['state'] == STATE.established or self._['out']['state'] == STATE.established
def _accept (self):
# we can do this as Protocol is a mutable object
proto = self._['in']['proto']
# send OPEN
for message in proto.new_open(self._restarted):
if ord(message.TYPE) == Message.Type.NOP:
yield ACTION.immediate
proto.negotiated.sent(message)
self._['in']['state'] = STATE.opensent
# Read OPEN
wait = environment.settings().bgp.openwait
opentimer = Timer(self._log('in'),wait,1,1,'waited for open too long, we do not like stuck in active')
# Only yield if we have not the open, otherwise the reactor can run the other connection
# which would be bad as we need to do the collission check without going to the other peer
for message in proto.read_open(self.neighbor.peer_address.ip):
opentimer.tick(message)
if ord(message.TYPE) == Message.Type.NOP:
示例6: Protocol
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Protocol (object):
decode = True
def __init__ (self,peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
port = os.environ.get('exabgp.tcp.port','') or os.environ.get('exabgp_tcp_port','')
self.port = int(port) if port.isdigit() else 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN-Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = environment.settings().log.routes
# XXX: we use self.peer.neighbor.peer_address when we could use self.neighbor.peer_address
def __del__ (self):
self.close('automatic protocol cleanup')
def me (self,message):
return "Peer %15s ASN %-7s %s" % (self.peer.neighbor.peer_address,self.peer.neighbor.peer_as,message)
def accept (self,incoming):
self.connection = incoming
self.peer.reactor.processes.reset(self.peer)
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.connected(self.peer)
# very important - as we use this function on __init__
return self
def connect (self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if not self.connection:
peer = self.neighbor.peer_address
local = self.neighbor.local_address
md5 = self.neighbor.md5
ttl = self.neighbor.ttl
self.connection = Outgoing(peer.afi,peer.ip,local.ip,self.port,md5,ttl)
connected = False
try:
generator = self.connection.establish()
while True:
connected = generator.next()
if not connected:
yield False
continue
self.peer.reactor.processes.reset(self.peer)
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.connected(self.peer)
yield True
return
except StopIteration:
# close called by the caller
# self.close('could not connect to remote end')
yield False
return
def close (self,reason='protocol closed, reason unspecified'):
if self.connection:
self.logger.network(self.me(reason))
# must be first otherwise we could have a loop caused by the raise in the below
self.connection.close()
self.connection = None
try:
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.down(self.peer,reason)
except ProcessError:
self.logger.message(self.me('could not send notification of neighbor close to API'))
def write (self,message):
if self.neighbor.api.send_packets:
self.peer.reactor.processes.send(self.peer,ord(message[18]),message[:19],message[19:])
for boolean in self.connection.writer(message):
yield boolean
# Read from network .......................................................
def read_message (self,comment=''):
self.peer.reactor.processes.increase(self.peer)
for length,msg,header,body,notify in self.connection.reader():
if notify:
if self.neighbor.api.receive_packets:
self.peer.reactor.processes.receive(self.peer,msg,header,body)
if self.neighbor.api.receive_notifications:
self.peer.reactor.processes.notification(self.peer,notify.code,notify.subcode,str(notify))
#.........这里部分代码省略.........
示例7: Peer
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
#.........这里部分代码省略.........
def reestablish (self, restart_neighbor=None):
# we want to tear down the session and re-establish it
self._teardown = 3
self._restart = True
self._restarted = True
self._resend_routes = SEND.NORMAL
self._neighbor = restart_neighbor
self._delay.reset()
def reconfigure (self, restart_neighbor=None):
# we want to update the route which were in the configuration file
self._reconfigure = True
self._neighbor = restart_neighbor
self._resend_routes = SEND.NORMAL
self._neighbor = restart_neighbor
def teardown (self, code, restart=True):
self._restart = restart
self._teardown = code
self._delay.reset()
# sockets we must monitor
def sockets (self):
ios = []
for proto in (self._incoming.proto,self._outgoing.proto):
if proto and proto.connection and proto.connection.io:
ios.append(proto.connection.io)
return ios
def incoming (self, connection):
# if the other side fails, we go back to idle
if self._incoming.proto not in (True,False,None):
self.logger.network('we already have a peer at this address')
return False
# self._incoming.fsm.change(FSM.ACTIVE)
self._incoming.proto = Protocol(self).accept(connection)
# Let's make sure we do some work with this connection
self._incoming.generator = None
return True
def established (self):
return self._incoming.fsm == FSM.ESTABLISHED or self._outgoing.fsm == FSM.ESTABLISHED
def _accept (self):
self._incoming.fsm.change(FSM.CONNECT)
# we can do this as Protocol is a mutable object
proto = self._incoming.proto
# send OPEN
message = Message.CODE.NOP
for message in proto.new_open(self._restarted):
if ord(message.TYPE) == Message.CODE.NOP:
yield ACTION.NOW
proto.negotiated.sent(message)
self._incoming.fsm.change(FSM.OPENSENT)
# Read OPEN
wait = environment.settings().bgp.openwait
opentimer = ReceiveTimer(self.me,wait,1,1,'waited for open too long, we do not like stuck in active')
# Only yield if we have not the open, otherwise the reactor can run the other connection
示例8: Protocol
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Protocol (object):
decode = True
def __init__ (self,peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
port = os.environ.get('exabgp.tcp.port','')
self.port = int(port) if port.isdigit() else 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN-Message.HEADER_LEN
# XXX: we use self.peer.neighbor.peer_address when we could use self.neighbor.peer_address
def __del__ (self):
self.close('automatic protocol cleanup')
def me (self,message):
return "Peer %15s ASN %-7s %s" % (self.peer.neighbor.peer_address,self.peer.neighbor.peer_as,message)
def accept (self,incoming):
self.connection = incoming
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.connected(self.peer.neighbor.peer_address)
# very important - as we use this function on __init__
return self
def connect (self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if not self.connection:
peer = self.neighbor.peer_address
local = self.neighbor.local_address
md5 = self.neighbor.md5
ttl = self.neighbor.ttl
self.connection = Outgoing(peer.afi,peer.ip,local.ip,self.port,md5,ttl)
connected = False
try:
generator = self.connection.establish()
while True:
connected = generator.next()
if not connected:
yield False
continue
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.connected(self.peer.neighbor.peer_address)
yield True
return
except StopIteration:
# close called by the caller
# self.close('could not connect to remote end')
yield False
return
def close (self,reason='protocol closed, reason unspecified'):
if self.connection:
self.logger.network(self.me(reason))
# must be first otherwise we could have a loop caused by the raise in the below
self.connection.close()
self.connection = None
try:
if self.peer.neighbor.api.neighbor_changes:
self.peer.reactor.processes.down(self.peer.neighbor.peer_address,reason)
except ProcessError:
self.logger.message(self.me('could not send notification of neighbor close to API'))
def write (self,message):
if self.neighbor.api.send_packets:
self.peer.reactor.processes.send(self.peer.neighbor.peer_address,ord(message[18]),message[:19],message[19:])
for boolean in self.connection.writer(message):
yield boolean
# Read from network .......................................................
def read_message (self,comment=''):
try:
for length,msg,header,body in self.connection.reader():
if not length:
yield _NOP
except NotifyError,n:
raise Notify(n.code,n.subcode,str(n))
if self.neighbor.api.receive_packets:
self.peer.reactor.processes.receive(self.peer.neighbor.peer_address,msg,header,body)
if msg == Message.Type.UPDATE:
self.logger.message(self.me('<< UPDATE'))
#.........这里部分代码省略.........
示例9: Connection
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Connection (object):
direction = 'undefined'
identifier = 0
def __init__ (self, afi, peer, local):
# peer and local are strings of the IP
try:
self.defensive = environment.settings().debug.defensive
self.logger = Logger()
except RuntimeError:
self.defensive = True
self.logger = FakeLogger()
self.afi = afi
self.peer = peer
self.local = local
self._buffer = ''
self.io = None
self.established = False
self.identifier += 1
self.id = self.identifier
# Just in case ..
def __del__ (self):
if self.io:
self.logger.network("%s connection to %s closed" % (self.name(),self.peer),'info')
self.close()
def name (self):
return "session %d %s" % (self.id,self.direction)
def close (self):
try:
self.logger.wire("%s, closing connection from %s to %s" % (self.name(),self.local,self.peer))
if self.io:
self.io.close()
self.io = None
except KeyboardInterrupt as exc:
raise exc
except:
pass
def reading (self):
while True:
try:
r,_,_ = select.select([self.io,],[],[],0)
except select.error as exc:
if exc.args[0] not in error.block:
self.close()
self.logger.wire("%s %s errno %s on socket" % (self.name(),self.peer,errno.errorcode[exc.args[0]]))
raise NetworkError('errno %s on socket' % errno.errorcode[exc.args[0]])
return False
return r != []
def writing (self):
while True:
try:
_,w,_ = select.select([],[self.io,],[],0)
except select.error as exc:
if exc.args[0] not in error.block:
self.close()
self.logger.wire("%s %s errno %s on socket" % (self.name(),self.peer,errno.errorcode[exc.args[0]]))
raise NetworkError('errno %s on socket' % errno.errorcode[exc.args[0]])
return False
return w != []
def _reader (self, number):
# The function must not be called if it does not return with no data with a smaller size as parameter
if not self.io:
self.close()
raise NotConnected('Trying to read on a closed TCP connection')
if number == 0:
yield ''
return
while not self.reading():
yield ''
data = ''
reported = ''
while True:
try:
while True:
if self.defensive and random.randint(0,2):
raise socket.error(errno.EAGAIN,'raising network error on purpose')
read = self.io.recv(number)
if not read:
self.close()
self.logger.wire("%s %s lost TCP session with peer" % (self.name(),self.peer))
raise LostConnection('the TCP connection was closed by the remote end')
data += read
number -= len(read)
if not number:
self.logger.wire(
LazyFormat(
"%s %-32s RECEIVED " % (
self.name(),
#.........这里部分代码省略.........
示例10: Protocol
# 需要导入模块: from exabgp.logger import FakeLogger [as 别名]
# 或者: from exabgp.logger.FakeLogger import network [as 别名]
class Protocol (object):
decode = True
def __init__ (self, peer):
try:
self.logger = Logger()
except RuntimeError:
self.logger = FakeLogger()
self.peer = peer
self.neighbor = peer.neighbor
self.negotiated = Negotiated(self.neighbor)
self.connection = None
if self.neighbor.connect:
self.port = self.neighbor.connect
elif os.environ.get('exabgp.tcp.port','').isdigit():
self.port = int(os.environ.get('exabgp.tcp.port'))
elif os.environ.get('exabgp_tcp_port','').isdigit():
self.port = int(os.environ.get('exabgp_tcp_port'))
else:
self.port = 179
# XXX: FIXME: check the the -19 is correct (but it is harmless)
# The message size is the whole BGP message _without_ headers
self.message_size = Message.MAX_LEN-Message.HEADER_LEN
from exabgp.configuration.environment import environment
self.log_routes = environment.settings().log.routes
# XXX: we use self.peer.neighbor.peer_address when we could use self.neighbor.peer_address
def me (self, message):
return "Peer %15s ASN %-7s %s" % (self.peer.neighbor.peer_address,self.peer.neighbor.peer_as,message)
def accept (self, incoming):
self.connection = incoming
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
# very important - as we use this function on __init__
return self
def connect (self):
# allows to test the protocol code using modified StringIO with a extra 'pending' function
if not self.connection:
local = self.neighbor.md5_ip
peer = self.neighbor.peer_address
md5 = self.neighbor.md5_password
ttl_out = self.neighbor.ttl_out
self.connection = Outgoing(peer.afi,peer.top(),local.top(),self.port,md5,ttl_out)
try:
generator = self.connection.establish()
while True:
connected = six.next(generator)
if not connected:
yield False
continue
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.connected(self.peer.neighbor)
yield True
return
except StopIteration:
# close called by the caller
# self.close('could not connect to remote end')
yield False
return
def close (self, reason='protocol closed, reason unspecified'):
if self.connection:
self.logger.network(self.me(reason))
# must be first otherwise we could have a loop caused by the raise in the below
self.connection.close()
self.connection = None
try:
if self.peer.neighbor.api['neighbor-changes']:
self.peer.reactor.processes.down(self.peer.neighbor,reason)
except ProcessError:
self.logger.message(self.me('could not send notification of neighbor close to API'))
def _to_api (self,direction,message,raw):
packets = self.neighbor.api['%s-packets' % direction]
parsed = self.neighbor.api['%s-parsed' % direction]
consolidate = self.neighbor.api['%s-consolidate' % direction]
if consolidate:
if packets:
self.peer.reactor.processes.message(self.peer.neighbor,direction,message,raw[:19],raw[19:])
else:
self.peer.reactor.processes.message(self.peer.neighbor,direction,message,'','')
else:
if packets:
self.peer.reactor.processes.packets(self.peer.neighbor,direction,int(message.ID),raw[:19],raw[19:])
if parsed:
self.peer.reactor.processes.message(message.ID,self.peer.neighbor,direction,message,'','')
def write (self, message, negotiated=None):
#.........这里部分代码省略.........