def create_config(self):
# Currently, supports only single peer
c = CmdBuffer('\n')
c << '[DEFAULT]'
c << 'log_dir = {0}'.format(self.SHARED_VOLUME)
c << 'use_stderr = False'
c << '[message]'
c << 'write_disk = True'
c << 'write_dir = {0}/data/bgp/'.format(self.SHARED_VOLUME)
c << 'format = json'
if self.peers:
info = next(iter(list(self.peers.values())))
remote_as = info['remote_as']
neigh_addr = info['neigh_addr'].split('/')[0]
local_as = info['local_as'] or self.asn
local_addr = info['local_addr'].split('/')[0]
c << '[bgp]'
c << 'afi_safi = ipv4, ipv6, vpnv4, vpnv6, flowspec, evpn'
c << 'remote_as = {0}'.format(remote_as)
c << 'remote_addr = {0}'.format(neigh_addr)
c << 'local_as = {0}'.format(local_as)
c << 'local_addr = {0}'.format(local_addr)
with open('{0}/yabgp.ini'.format(self.config_dir), 'w') as f:
print(yellow('[{0}\'s new yabgp.ini]'.format(self.name)))
print(yellow(indent(str(c))))
f.writelines(str(c))
def create_config(self):
c = CmdBuffer()
c << 'router id {0};'.format(self.router_id)
for peer, info in self.peers.items():
c << 'protocol bgp {'
c << ' local as {0};'.format(self.asn)
n_addr = info['neigh_addr'].split('/')[0]
c << ' neighbor {0} as {1};'.format(n_addr, peer.asn)
c << ' multihop;'
c << '}'
with open('{0}/bird.conf'.format(self.config_dir), 'w') as f:
print(yellow('[{0}\'s new bird.conf]'.format(self.name)))
print(yellow(indent(str(c))))
f.writelines(str(c))
def _create_config_ospfd(self):
c = CmdBuffer()
c << 'hostname ospfd'
c << 'password zebra'
c << 'router ospf'
for redistribute in self.ospfd_config.get('redistributes', []):
c << ' redistribute {0}'.format(redistribute)
for network, area in list(self.ospfd_config.get('networks', {}).items()):
c << ' network {0} area {1}'.format(network, area)
c << 'log file {0}/ospfd.log'.format(self.QUAGGA_VOLUME)
c << ''
with open('{0}/ospfd.conf'.format(self.quagga_config_dir), 'w') as f:
print(yellow('[{0}\'s new ospfd.conf]'.format(self.name)))
print(yellow(indent(str(c))))
f.writelines(str(c))
def _create_config_zebra(self):
c = CmdBuffer()
c << 'hostname zebra'
c << 'password zebra'
c << 'log file {0}/zebra.log'.format(self.QUAGGA_VOLUME)
c << 'debug zebra packet'
c << 'debug zebra kernel'
c << 'debug zebra rib'
c << 'ipv6 forwarding'
c << ''
with open('{0}/zebra.conf'.format(self.quagga_config_dir), 'w') as f:
print(yellow('[{0}\'s new zebra.conf]'.format(self.name)))
c = str(c).strip()
print(yellow(indent(c)))
f.writelines(c)
def _create_config_zebra(self):
c = CmdBuffer()
c << 'hostname zebra'
c << 'password zebra'
for name, settings in list(
self.zebra_config.get('interfaces', {}).items()):
c << 'interface {0}'.format(name)
for setting in settings:
c << str(setting)
for route in self.zebra_config.get('routes', []):
c << str(route)
c << 'log file {0}/zebra.log'.format(self.SHARED_VOLUME)
c << 'debug zebra packet'
c << 'debug zebra kernel'
c << 'debug zebra rib'
c << 'ipv6 forwarding'
c << ''
with open('{0}/zebra.conf'.format(self.config_dir), 'w') as f:
print(yellow('[{0}\'s new zebra.conf]'.format(self.name)))
c = str(c).strip()
print(yellow(indent(c)))
f.writelines(c)
def create_config(self):
with open('{0}/gobgpd.conf'.format(self.config_dir), 'w') as f:
print(yellow('[{0}\'s new gobgpd.conf]'.format(self.name)))
print(yellow(indent(self.config)))
f.write(self.config)
def _create_config_bgp(self):
config = {
'global': {
'config': {
'as': self.asn,
'router-id': self.router_id,
},
'route-selection-options': {
'config': {
'external-compare-router-id': True,
},
},
},
'neighbors': [],
}
self._merge_dict(config, self.bgp_config)
if self.zebra and self.zapi_version == 2:
config['global']['use-multiple-paths'] = {'config': {'enabled': True}}
for peer, info in self.peers.items():
afi_safi_list = []
if info['interface'] != '':
afi_safi_list.append({'config': {'afi-safi-name': 'ipv4-unicast'}})
afi_safi_list.append({'config': {'afi-safi-name': 'ipv6-unicast'}})
else:
version = netaddr.IPNetwork(info['neigh_addr']).version
if version == 4:
afi_safi_list.append({'config': {'afi-safi-name': 'ipv4-unicast'}})
elif version == 6:
afi_safi_list.append({'config': {'afi-safi-name': 'ipv6-unicast'}})
else:
Exception('invalid ip address version. {0}'.format(version))
if info['vpn']:
afi_safi_list.append({'config': {'afi-safi-name': 'l3vpn-ipv4-unicast'}})
afi_safi_list.append({'config': {'afi-safi-name': 'l3vpn-ipv6-unicast'}})
afi_safi_list.append({'config': {'afi-safi-name': 'l2vpn-evpn'}})
afi_safi_list.append({'config': {'afi-safi-name': 'rtc'}, 'route-target-membership': {'config': {'deferral-time': 10}}})
if info['flowspec']:
afi_safi_list.append({'config': {'afi-safi-name': 'ipv4-flowspec'}})
afi_safi_list.append({'config': {'afi-safi-name': 'l3vpn-ipv4-flowspec'}})
afi_safi_list.append({'config': {'afi-safi-name': 'ipv6-flowspec'}})
afi_safi_list.append({'config': {'afi-safi-name': 'l3vpn-ipv6-flowspec'}})
neigh_addr = None
interface = None
peer_as = None
if info['interface'] == '':
neigh_addr = info['neigh_addr'].split('/')[0]
peer_as = info['remote_as']
else:
interface = info['interface']
n = {
'config': {
'neighbor-address': neigh_addr,
'neighbor-interface': interface,
'peer-as': peer_as,
'auth-password': info['passwd'],
'vrf': info['vrf'],
'remove-private-as': info['remove_private_as'],
},
'afi-safis': afi_safi_list,
'timers': {
'config': {
'connect-retry': 10,
},
},
'transport': {
'config': {},
},
}
n['as-path-options'] = {'config': {}}
if info['allow_as_in'] > 0:
n['as-path-options']['config']['allow-own-as'] = info['allow_as_in']
if info['replace_peer_as']:
n['as-path-options']['config']['replace-peer-as'] = info['replace_peer_as']
if ':' in info['local_addr']:
n['transport']['config']['local-address'] = info['local_addr'].split('/')[0]
if info['passive']:
n['transport']['config']['passive-mode'] = True
if info['is_rs_client']:
n['route-server'] = {'config': {'route-server-client': True}}
if info['local_as']:
n['config']['local-as'] = info['local_as']
if info['prefix_limit']:
for v in afi_safi_list:
v['prefix-limit'] = {'config': {'max-prefixes': info['prefix_limit'], 'shutdown-threshold-pct': 80}}
if info['graceful_restart'] is not None:
n['graceful-restart'] = {'config': {'enabled': True, 'restart-time': GRACEFUL_RESTART_TIME}}
for afi_safi in afi_safi_list:
afi_safi['mp-graceful-restart'] = {'config': {'enabled': True}}
if info['llgr'] is not None:
n['graceful-restart']['config']['restart-time'] = 1
n['graceful-restart']['config']['long-lived-enabled'] = True
for afi_safi in afi_safi_list:
afi_safi['long-lived-graceful-restart'] = {'config': {'enabled': True, 'restart-time': LONG_LIVED_GRACEFUL_RESTART_TIME}}
if info['is_rr_client']:
cluster_id = self.router_id
if 'cluster_id' in info and info['cluster_id'] is not None:
cluster_id = info['cluster_id']
n['route-reflector'] = {'config': {'route-reflector-client': True,
'route-reflector-cluster-id': cluster_id}}
if info['addpath']:
n['add-paths'] = {'config': {'receive': True,
'send-max': 16}}
if len(info.get('default-policy', [])) + len(info.get('policies', [])) > 0:
n['apply-policy'] = {'config': {}}
for typ, p in info.get('policies', {}).items():
n['apply-policy']['config']['{0}-policy-list'.format(typ)] = [p['name']]
def _f(v):
if v == 'reject':
return 'reject-route'
elif v == 'accept':
return 'accept-route'
raise Exception('invalid default policy type {0}'.format(v))
for typ, d in info.get('default-policy', {}).items():
n['apply-policy']['config']['default-{0}-policy'.format(typ)] = _f(d)
if info['treat_as_withdraw']:
n['error-handling'] = {'config': {'treat-as-withdraw': True}}
config['neighbors'].append(n)
config['defined-sets'] = {}
if self.prefix_set:
config['defined-sets']['prefix-sets'] = self.prefix_set
if self.neighbor_set:
config['defined-sets']['neighbor-sets'] = self.neighbor_set
if self.bgp_set:
config['defined-sets']['bgp-defined-sets'] = self.bgp_set
policy_list = []
for p in self.policies.values():
policy = {'name': p['name']}
if 'statements' in p:
policy['statements'] = p['statements']
policy_list.append(policy)
if len(policy_list) > 0:
config['policy-definitions'] = policy_list
if self.zebra:
config['zebra'] = {'config': {'enabled': True,
'redistribute-route-type-list': ['connect'],
'version': self.zapi_version}}
with open('{0}/gobgpd.conf'.format(self.config_dir), 'w') as f:
print(yellow('[{0}\'s new gobgpd.conf]'.format(self.name)))
if self.config_format is 'toml':
raw = toml.dumps(config)
elif self.config_format is 'yaml':
raw = yaml.dump(config)
elif self.config_format is 'json':
raw = json.dumps(config)
else:
raise Exception('invalid config_format {0}'.format(self.config_format))
raw = raw.strip()
print(yellow(indent(raw)))
f.write(raw)
def _create_config_bgp(self):
c = CmdBuffer()
c << 'hostname bgpd'
c << 'password zebra'
c << 'router bgp {0}'.format(self.asn)
c << 'bgp router-id {0}'.format(self.router_id)
if any(info['graceful_restart'] for info in self.peers.values()):
c << 'bgp graceful-restart'
if 'global' in self.bgpd_config:
if 'confederation' in self.bgpd_config['global']:
conf = self.bgpd_config['global']['confederation']['config']
c << 'bgp confederation identifier {0}'.format(
conf['identifier'])
c << 'bgp confederation peers {0}'.format(' '.join(
[str(i) for i in conf['member-as-list']]))
version = 4
for peer, info in self.peers.items():
version = netaddr.IPNetwork(info['neigh_addr']).version
n_addr = info['neigh_addr'].split('/')[0]
if version == 6:
c << 'no bgp default ipv4-unicast'
c << 'neighbor {0} remote-as {1}'.format(n_addr, info['remote_as'])
# For rapid convergence
c << 'neighbor {0} advertisement-interval 1'.format(n_addr)
if info['is_rs_client']:
c << 'neighbor {0} route-server-client'.format(n_addr)
for typ, p in info['policies'].items():
c << 'neighbor {0} route-map {1} {2}'.format(
n_addr, p['name'], typ)
if info['passwd']:
c << 'neighbor {0} password {1}'.format(n_addr, info['passwd'])
if info['passive']:
c << 'neighbor {0} passive'.format(n_addr)
if version == 6:
c << 'address-family ipv6 unicast'
c << 'neighbor {0} activate'.format(n_addr)
c << 'exit-address-family'
if self.zebra:
if version == 6:
c << 'address-family ipv6 unicast'
c << 'redistribute connected'
c << 'exit-address-family'
else:
c << 'redistribute connected'
for name, policy in self.policies.items():
c << 'access-list {0} {1} {2}'.format(name, policy['type'],
policy['match'])
c << 'route-map {0} permit 10'.format(name)
c << 'match ip address {0}'.format(name)
c << 'set metric {0}'.format(policy['med'])
c << 'debug bgp as4'
c << 'debug bgp fsm'
c << 'debug bgp updates'
c << 'debug bgp events'
c << 'log file {0}/bgpd.log'.format(self.SHARED_VOLUME)
with open('{0}/bgpd.conf'.format(self.config_dir), 'w') as f:
print(yellow('[{0}\'s new bgpd.conf]'.format(self.name)))
print(yellow(indent(str(c))))
f.writelines(str(c))