def reset_bgp(self):
# TODO: port status changes should cause us to withdraw a route.
# TODO: configurable behavior - withdraw routes if peer goes down.
for dp_id, valve in self.valves.iteritems():
if dp_id not in self.dp_bgp_speakers:
self.dp_bgp_speakers[dp_id] = {}
bgp_speakers = self.dp_bgp_speakers[dp_id]
for bgp_speaker in bgp_speakers.itervalues():
bgp_speaker.shutdown()
for vlan in valve.dp.vlans.itervalues():
if vlan.bgp_as:
handler = lambda x: self.bgp_route_handler(x, vlan)
bgp_speaker = BGPSpeaker(
as_number=vlan.bgp_as,
router_id=vlan.bgp_routerid,
bgp_server_port=vlan.bgp_port,
best_path_change_handler=handler)
for controller_ip in vlan.controller_ips:
prefix = ipaddr.IPNetwork(
'/'.join(
(str(controller_ip.ip),
str(controller_ip.prefixlen))))
bgp_speaker.prefix_add(
prefix=str(prefix),
next_hop=controller_ip.ip)
for route_table in (vlan.ipv4_routes, vlan.ipv6_routes):
for ip_dst, ip_gw in route_table.iteritems():
bgp_speaker.prefix_add(
prefix=str(ip_dst),
next_hop=str(ip_gw))
bgp_speaker.neighbor_add(
address=vlan.bgp_neighbor_address,
remote_as=vlan.bgp_neighbor_as)
bgp_speakers[vlan] = bgp_speaker
def _create_bgp_speaker_for_vlan(self, vlan, dp_id, vlan_vid):
"""Set up BGP speaker for an individual VLAN if required.
Args:
vlan (valve VLAN): VLAN for BGP speaker.
dp_id (int): Datapath ID for BGP speaker.
vlan_vid (vlan_vid): VLAN VID for BGP speaker.
Returns:
ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker: BGP speaker.
"""
handler = lambda x: self._bgp_route_handler(x, dp_id, vlan_vid)
bgp_speaker = BGPSpeaker(
as_number=vlan.bgp_as,
router_id=vlan.bgp_routerid,
bgp_server_port=vlan.bgp_port,
bgp_server_hosts=vlan.bgp_server_addresses,
best_path_change_handler=handler,
peer_up_handler=self._bgp_up_handler,
peer_down_handler=self._bgp_down_handler)
for ip_dst, ip_gw in self._vlan_prefixes(vlan):
bgp_speaker.prefix_add(prefix=ip_dst, next_hop=ip_gw)
for bgp_neighbor_address in vlan.bgp_neighbor_addresses:
bgp_speaker.neighbor_add(
connect_mode=vlan.bgp_connect_mode,
address=bgp_neighbor_address,
remote_as=vlan.bgp_neighbor_as,
local_address=vlan.bgp_local_address,
enable_ipv4=True,
enable_ipv6=True)
return bgp_speaker
def _create_bgp_speaker_for_vlan(self, vlan):
"""Set up BGP speaker for an individual VLAN if required.
Args:
vlan (vlan): VLAN associated with this speaker.
Returns:
ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker: BGP speaker.
"""
handler = lambda x: self._bgp_route_handler(x, vlan)
bgp_speaker = BGPSpeaker(as_number=vlan.bgp_as,
router_id=vlan.bgp_routerid,
bgp_server_port=vlan.bgp_port,
best_path_change_handler=handler)
for faucet_vip in vlan.faucet_vips:
prefix = ipaddr.IPNetwork(faucet_vip.exploded)
bgp_speaker.prefix_add(prefix=str(prefix),
next_hop=str(faucet_vip.ip))
for route_table in (vlan.ipv4_routes, vlan.ipv6_routes):
for ip_dst, ip_gw in route_table.iteritems():
bgp_speaker.prefix_add(prefix=str(ip_dst), next_hop=str(ip_gw))
for bgp_neighbor_address in vlan.bgp_neighbor_addresses:
bgp_speaker.neighbor_add(address=bgp_neighbor_address,
remote_as=vlan.bgp_neighbor_as,
local_address=vlan.bgp_local_address,
enable_ipv4=True,
enable_ipv6=True)
return bgp_speaker
def ryu(routerid, asn, peerip, peerport, peeras):
import eventlet
from ryu.services.protocols.bgp.bgpspeaker import BGPSpeaker
eventlet.monkey_patch() # BGPSpeaker needs sockets patched
def dump_remote_best_path_change(event):
print('the best path changed:', event.remote_as, event.prefix,
event.nexthop, event.is_withdraw)
def detect_peer_down(remote_ip, remote_as):
print('Peer down:', remote_ip, remote_as)
speaker = BGPSpeaker(
as_number=int(args.asn),
router_id=args.router_id,
best_path_change_handler=dump_remote_best_path_change,
peer_down_handler=detect_peer_down)
# XXX need to fix port arg
speaker.neighbor_add(peerip, peeras, peerport)
# uncomment the below line if the speaker needs to talk with a bmp server.
# speaker.bmp_server_add('192.168.177.2', 11019)
# count = 1
while True:
eventlet.sleep(30)
def __init__(self, *args, **kwargs):
super(SDNIP, self).__init__(*args, **kwargs)
self.fwd = kwargs['fwd']
self.hop_db = kwargs['hop_db']
self.cfg_mgr = SDNIPConfigManager()
self.waiters = {}
self.bgp_speaker =\
BGPSpeaker(self.cfg_mgr.as_number,
str(self.cfg_mgr.router_id),
bgp_server_port=self.cfg_mgr.listen_port,
best_path_change_handler=self.best_path_change_handler,
peer_down_handler=self.peer_down_handler,
peer_up_handler=self.peer_up_handler)
speaker_ids = self.cfg_mgr.get_all_speaker_id()
for speaker_id in speaker_ids:
self.bgp_speaker.neighbor_add(speaker_id,
self.cfg_mgr.as_number,
is_next_hop_self=True)
hub.spawn(self.prefix_check_loop)
if with_dk:
dk_plugin.DynamicLoader.register_custom_cmd(
'sdn-ip:info', self.cmd_self_info)
dk_plugin.DynamicLoader.register_custom_cmd(
'sdn-ip:routes', self.cmd_list_routes)
dk_plugin.DynamicLoader.register_custom_cmd(
'sdn-ip:flows', self.cmd_get_flows)
def start_bgpspeaker(self, asNum, routerId, label_start, label_end):
self.myRouterId = routerId
self.labelRange = tuple([label_start, label_end])
self.speaker = BGPSpeaker(as_number=asNum, router_id=routerId,
best_path_change_handler=self.dump_remote_best_path_change,
peer_down_handler=self.detect_peer_down,
peer_up_handler=self.detect_peer_up,
label_range=self.labelRange)
def main():
reset_flows()
sw=discover_switches()
resolve_nhops()
print "start BGP peering"
speaker = BGPSpeaker(**self)
speaker.neighbor_add(**neighbor)
while True:
eventlet.sleep(10)
def _start_speaker(self, settings):
"""
Starts BGPSpeaker using the given settings.
"""
# Settings for starting BGPSpeaker
bgp_settings = {}
# Get required settings.
try:
bgp_settings['as_number'] = settings.get(LOCAL_AS)
bgp_settings['router_id'] = settings.get(ROUTER_ID)
except KeyError as e:
raise ApplicationException(
desc='Required BGP configuration missing: %s' % e)
# Set event notify handlers if no corresponding handler specified.
bgp_settings['best_path_change_handler'] = settings.get(
'best_path_change_handler', self._notify_best_path_changed_event)
bgp_settings['peer_down_handler'] = settings.get(
'peer_down_handler', self._notify_peer_down_event)
bgp_settings['peer_up_handler'] = settings.get(
'peer_up_handler', self._notify_peer_up_event)
# Get optional settings.
bgp_settings[BGP_SERVER_PORT] = settings.get(
BGP_SERVER_PORT, DEFAULT_BGP_SERVER_PORT)
bgp_settings[REFRESH_STALEPATH_TIME] = settings.get(
REFRESH_STALEPATH_TIME, DEFAULT_REFRESH_STALEPATH_TIME)
bgp_settings[REFRESH_MAX_EOR_TIME] = settings.get(
REFRESH_MAX_EOR_TIME, DEFAULT_REFRESH_MAX_EOR_TIME)
bgp_settings[LABEL_RANGE] = settings.get(
LABEL_RANGE, DEFAULT_LABEL_RANGE)
bgp_settings['allow_local_as_in_count'] = settings.get(
'allow_local_as_in_count', 0)
bgp_settings[LOCAL_PREF] = settings.get(
LOCAL_PREF, DEFAULT_LOCAL_PREF)
# Create BGPSpeaker instance.
LOG.debug('Starting BGPSpeaker...')
self.speaker = BGPSpeaker(**bgp_settings)
# Add neighbors.
LOG.debug('Adding neighbors...')
self._add_neighbors(settings.get('neighbors', []))
# Add VRFs.
LOG.debug('Adding VRFs...')
self._add_vrfs(settings.get('vrfs', []))
# Add Networks
LOG.debug('Adding routes...')
self._add_routes(settings.get('routes', []))
def _start_speaker(self, settings):
"""
Starts BGPSpeaker using the given settings.
"""
# Check required settings.
_required_settings = (
LOCAL_AS,
ROUTER_ID,
)
for required in _required_settings:
if required not in settings:
raise ApplicationException(
desc='Required BGP configuration missing: %s' % required)
# Set event notify handlers if no corresponding handler specified.
settings.setdefault(
'best_path_change_handler', self._notify_best_path_changed_event)
settings.setdefault(
'adj_rib_in_change_handler', self._notify_adj_rib_in_changed_event)
settings.setdefault(
'peer_down_handler', self._notify_peer_down_event)
settings.setdefault(
'peer_up_handler', self._notify_peer_up_event)
# Pop settings other than creating BGPSpeaker instance.
neighbors_settings = settings.pop('neighbors', [])
vrfs_settings = settings.pop('vrfs', [])
routes_settings = settings.pop('routes', [])
# Create BGPSpeaker instance.
LOG.debug('Starting BGPSpeaker...')
settings.setdefault('as_number', settings.pop(LOCAL_AS))
self.speaker = BGPSpeaker(**settings)
# Add neighbors.
LOG.debug('Adding neighbors...')
self._add_neighbors(neighbors_settings)
# Add VRFs.
LOG.debug('Adding VRFs...')
self._add_vrfs(vrfs_settings)
# Add routes
LOG.debug('Adding routes...')
self._add_routes(routes_settings)
def bgp_sender(self):
def dump_remote_best_path_change(event):
print 'the best path changed:', event.remote_as, event.prefix, \
event.nexthop, event.is_withdraw
def detect_peer_down(remote_ip, remote_as):
print 'Peer down:', remote_ip, remote_as
def detect_peer_up(remote_ip, remote_as, uri_enabled, peer):
print 'Peer up', remote_ip, remote_as
if uri_enabled:
self.uri_enabled_capability = True
self.peer[remote_ip] = (
peer, self.uri_enabled_capability
) #Create peer dictionary with key ip and value a tuple of peer and uri_enabled capability
self.uri_enabled_capability = False
else:
self.peer[remote_ip] = (peer, False)
self.speaker = BGPSpeaker(
as_number=1000,
router_id='147.102.13.198',
best_path_change_handler=dump_remote_best_path_change,
peer_down_handler=detect_peer_down,
peer_up_handler=detect_peer_up)
#self.speaker = BGPSpeaker(as_number=1000, router_id='2.1.1.1',
# best_path_change_handler=dump_remote_best_path_change,
# peer_down_handler=detect_peer_down,peer_up_handler=detect_peer_up)
self.speaker.neighbor_add('147.102.13.156', 1000, next_hop='192.0.2.1')
#self.speaker.neighbor_add('192.168.1.2', 1001,enable_uri=True)
#self.speaker.neighbor_add('2.1.1.2', 1000, next_hop='192.0.2.1')
#alla = PrefixFilter('0.0.0.0/0',policy=PrefixFilter.POLICY_DENY)
#self.speaker.out_filter_set('192.168.1.2',[alla])
#self.speaker.out_filter_set('2.1.1.2',[alla])
#self.drop_to_router(AC(1000).create())
#self.speaker.
#eventlet.sleep(20)
#self.drop_to_router(['147.102.13.199/32'])
ofs = Switch()
eventlet.sleep(40)
ofs.add_flow("147.102.13.199")
"""
def __init__(self, *args, **kwargs):
super(SDNIP, self).__init__(*args, **kwargs)
self.fwd_util = kwargs['fwd']
self.hop_db = kwargs['hop_db']
self.cfg_mgr = SDNIPConfigManager() #获取SDN－IP配置信息
# 在Ryu上运行一个iBGPSpeaker
self.bgp_speaker =\
BGPSpeaker(self.cfg_mgr.as_number, #AS号
str(self.cfg_mgr.router_id), #iBGP的router id
bgp_server_port=self.cfg_mgr.listen_port, #监听BGP协议的端口号
best_path_change_handler=self.best_path_change_handler, #当路由信息变化时调用此方法
peer_down_handler=self.peer_down_handler, #BGP对等体下线
peer_up_handler=self.peer_up_handler) #BGP对等体上线
speaker_ids = self.cfg_mgr.get_all_speaker_id()
# 建立iBGPSpeaker与SDN域内的BGPSpeaker的连接
for speaker_id in speaker_ids:
self.bgp_speaker.neighbor_add(speaker_id,
self.cfg_mgr.as_number,
is_next_hop_self=True)
def __init__(self, *args, **kwargs):
super(SDNIP, self).__init__(*args, **kwargs)
self.fwd = kwargs['fwd']
self.hop_db = kwargs['hop_db']
self.cfg_mgr = SDNIPConfigManager('config.json')
self.bgp_speaker =\
BGPSpeaker(self.cfg_mgr.as_number,
self.cfg_mgr.router_id,
bgp_server_port=self.cfg_mgr.listen_port,
best_path_change_handler=self.best_path_change_handler,
peer_down_handler=self.peer_down_handler,
peer_up_handler=self.peer_up_handler)
speaker_ids = self.cfg_mgr.get_all_speaker_id()
for speaker_id in speaker_ids:
self.bgp_speaker.neighbor_add(speaker_id,
self.cfg_mgr.as_number,
is_next_hop_self=True)
hub.spawn(self.prefix_check_loop)
def bgp_create(self, as_number, router_id):
# MUDAR AQUI - INICIO
try:
self.bgp_speaker = BGPSpeaker(
as_number=as_number,
router_id=router_id,
best_path_change_handler=self.best_path_change_handler,
adj_rib_in_change_handler=self.adj_rib_in_change_handler,
peer_down_handler=self.peer_down_handler,
peer_up_handler=self.peer_up_handler)
except Exception as e:
print "Error creating bgp speaker: %s" % (e)
return (False, 'Failed to create BGP speaker')
# MUDAR AQUI - FIM
self.bgp_config['as_number'] = as_number
self.bgp_config['router_id'] = router_id
self.bgp_config['neighbors'] = []
self.bgp_config['adv_prefixes'] = []
self.persist_config()
return (True, 'Success')
def _start_speaker(self, settings):
"""
Starts BGPSpeaker using the given settings.
"""
# Settings for starting BGPSpeaker
bgp_settings = {}
# Get required settings.
try:
bgp_settings['as_number'] = settings.get(LOCAL_AS)
bgp_settings['router_id'] = settings.get(ROUTER_ID)
except KeyError as e:
raise ApplicationException(
desc='Required BGP configuration missing: %s' % e)
# Get optional settings.
bgp_settings[BGP_SERVER_PORT] = settings.get(BGP_SERVER_PORT,
DEFAULT_BGP_SERVER_PORT)
bgp_settings[REFRESH_STALEPATH_TIME] = settings.get(
REFRESH_STALEPATH_TIME, DEFAULT_REFRESH_STALEPATH_TIME)
bgp_settings[REFRESH_MAX_EOR_TIME] = settings.get(
REFRESH_MAX_EOR_TIME, DEFAULT_REFRESH_MAX_EOR_TIME)
bgp_settings[LABEL_RANGE] = settings.get(LABEL_RANGE,
DEFAULT_LABEL_RANGE)
# Create BGPSpeaker instance.
LOG.debug('Starting BGPSpeaker...')
self.speaker = BGPSpeaker(**bgp_settings)
# Add neighbors.
LOG.debug('Adding neighbors...')
self._add_neighbors(settings.get('neighbors', []))
# Add VRFs.
LOG.debug('Adding VRFs...')
self._add_vrfs(settings.get('vrfs', []))
# Add Networks
LOG.debug('Adding routes...')
self._add_routes(settings.get('routes', []))
def _create_bgp_speaker_for_vlan(self, vlan):
"""Set up BGP speaker for an individual VLAN if required.
Args:
vlan (vlan): VLAN associated with this speaker.
Returns:
ryu.services.protocols.bgp.bgpspeaker.BGPSpeaker: BGP speaker.
"""
handler = lambda x: self._bgp_route_handler(x, vlan)
bgp_speaker = BGPSpeaker(as_number=vlan.bgp_as,
router_id=vlan.bgp_routerid,
bgp_server_port=vlan.bgp_port,
best_path_change_handler=handler)
for controller_ip in vlan.controller_ips:
prefix = ipaddr.IPNetwork('/'.join(
(str(controller_ip.ip), str(controller_ip.prefixlen))))
bgp_speaker.prefix_add(prefix=str(prefix),
next_hop=controller_ip.ip)
for route_table in (vlan.ipv4_routes, vlan.ipv6_routes):
for ip_dst, ip_gw in route_table.iteritems():
bgp_speaker.prefix_add(prefix=str(ip_dst), next_hop=str(ip_gw))
bgp_speaker.neighbor_add(address=vlan.bgp_neighbor_address,
remote_as=vlan.bgp_neighbor_as)
return bgp_speaker
__author__ = 'hyq'
import eventlet
import json
eventlet.monkey_patch()
import logging
import sys
log = logging.getLogger()
log.addHandler(logging.StreamHandler(sys.stderr))
log.setLevel(logging.DEBUG)
from ryu.services.protocols.bgp.bgpspeaker import BGPSpeaker
if __name__ == "__main__":
speaker = BGPSpeaker(as_number=64512, router_id='10.0.0.1',
ssh_console=True)
while True:
eventlet.sleep(5)
from ryu.services.protocols.bgp.bgpspeaker import BGPSpeaker
'''
sudo /usr/bin/python2.7 "/home/walber/Dropbox/SDN - Controllers/ryu/ryu/app/COOL/topology_management/bgp_tester.py"
'''
def dump_remote_best_path_change(event):
print 'the best path changed:', event.remote_as, event.prefix,\
event.nexthop, event.is_withdraw
def detect_peer_down(remote_ip, remote_as):
print 'Peer down:', remote_ip, remote_as
if __name__ == "__main__":
speaker = BGPSpeaker(as_number=65001, router_id='192.168.25.7',
best_path_change_handler=dump_remote_best_path_change,
peer_down_handler=detect_peer_down)
speaker.neighbor_add('192.168.25.2', 65002)
# uncomment the below line if the speaker needs to talk with a bmp server.
# speaker.bmp_server_add('192.168.177.2', 11019)
count = 1
while True:
print "Oi"
eventlet.sleep(30)
prefix = '10.20.' + str(count) + '.0/24'
print "add a new prefix", prefix
speaker.prefix_add(prefix)
count += 1
if count == 4:
speaker.shutdown()
def __init__(self, hosts=None, networks=None, *args, **kwargs):
super(BGP_Speaker, self).__init__(*args, **kwargs)
self.networks = networks
self.hosts = hosts
# Configuring AS 65501:
self.as_number = 65001
#self.remote_as = 65501
self.router_id = '192.168.25.7'
self.router_next_hop = "10.0.254.254" # The source IP of the BGP
self.listen_port = 179
self.bgp_speaker = \
BGPSpeaker(self.as_number,
self.router_id,
bgp_server_port=self.listen_port,
best_path_change_handler=self.best_path_change_handler,
peer_down_handler=self.peer_down_handler,
peer_up_handler=self.peer_up_handler)
# print "<<<<<<<<<",self.bgp_speaker
# speaker = BGPSpeaker(as_number=65001, router_id='192.168.25.7',
# best_path_change_handler=dump_remote_best_path_change,
# peer_down_handler=detect_peer_down)
self.neighbor1 = Neighbor(ip="192.168.25.2",
asn=65002,
next_hop="10.0.1.254",
border_switch=2,
sw_port=1,
controller_ip="10.0.1.254")
#self.neighbor2 = Neighbor(ip="10.0.2.2", asn=65002,next_hop="10.0.1.254", border_switch=2, sw_port=2, controller_ip="10.0.1.254")
# self.neighbor = {"10.0.1.1": {'asn': 65001,'switch':2, 'port': 1,'controller_ip':"10.0.1.254"},
# "10.0.2.2": {'asn': 65002,'switch':2, 'port': 2,'controller_ip':"10.0.2.254"},
# }
self.neighbors = [self.neighbor1] #,self.neighbor2]
#self.local_networks = {"192.168.2.0/24":{'controller_ip':"192.168.2.254"}}
self.prefix_add(prefix="192.168.2.0/24", next_hop="192.168.2.254")
# Adding neighbors:
#TODO: Verify the option of next_hop
for neighbor in self.neighbors:
# self.bgp_speaker.neighbor_add(address=neighbor, remote_as=self.neighbor[neighbor]['asn'],
# next_hop=self.router_next_hop,
# is_next_hop_self=True)
self.neighbors_add(neighbor)
# for network in self.local_networks:
# # Adding prefixes:
# self.bgp_speaker.prefix_add(network, self.neighbor[neighbor]['controller_ip']) # next_hop (how to reach the network)
# #self.bgp_speaker.prefix_add("192.168.2.0/24", "10.0.2.254") # next_hop (how to reach the network)
# # self.bgp_speaker.prefix_add("10.0.0.0/24", "10.0.1.1")
# "10.0.3.1": 'fe:00:00:00:00:03'}
# self.arp_controller = '00:00:00:00:00:fe'
# self.monitor_thread = hub.spawn(self._monitor)
# self.best_paths ={}
self.prefix_learned = {} # "198.51.100.0/24",'10.0.1.0/24'}
self.is_load_balancer_active = False
self.load_balancer = {}
#self.monitor_thread = hub.spawn(self.stand_alone)
print "BGP Speaker started! ;)"
self.stand_alone()
null = ''
true = 'True'
false = 'False'
Flag = False
status_bgp = speaker.neighbor_state_get()
status = json.loads(status_bgp)
for key in status.keys():
if status[key]['info']['bgp_state'] != 'Established':
logging.info('neighbor is abornamal .please check peer {}'.format(key))
Flag = True
return Flag
if __name__ == "__main__":
speaker = BGPSpeaker(as_number=100, router_id='10.0.0.82',
best_path_change_handler=dump_remote_best_path_change,
peer_down_handler=detect_peer_down)
speaker.neighbor_add('10.0.0.81', 100)
# uncomment the below line if the speaker needs to talk with a bmp server.
# speaker.bmp_server_add('192.168.177.2', 11019)
time.sleep(5)
while True:
print(datetime.datetime.now())
if (get_bgp_status()):
logging.warning("~~~~~~~~~~~~~~~~~~~~~")
db_from_bgp.clear()
else:
compare_db()
eventlet.sleep(6)
event.nexthop, event.is_withdraw
def detect_peer_down(remote_ip, remote_as):
print 'Peer down:', remote_ip, remote_as
SSH = {
'ssh_port': 4990,
'ssh_host': 'localhost',
'ssh_host_key': '/etc/ssh_host_rsa_key',
'ssh_username': '******',
'ssh_password': '******',
}
if __name__ == "__main__":
speaker = BGPSpeaker(as_number=65005, router_id='172.16.1.174',
best_path_change_handler=dump_remote_best_path_change,
peer_down_handler=detect_peer_down)
speaker.neighbor_add('172.16.1.175', 65003)
count = 0
while True:
eventlet.sleep(5)
prefix = '192.168.' + str(count) + '.0/24'
print "add a new prefix", prefix
speaker.prefix_add(prefix)
count += 1
print("Neighbors: ", speaker.neighbors_get())
print("Routes: ", speaker.rib_get())
