def router(self):
protocol = self.expect(Keyword)
protocol_tag = taglib.tag("routing protocol", protocol.upper())
protocol_tag.implied_by(taglib.env_tags.device, self.lineNum)
if protocol == "bgp":
local_as = self.expect(Literal)
local_as_tag = taglib.as_number_tag(local_as, "local AS")
local_as_lineNum = self.lineNum
local_as_tag.implies(taglib.as_number_tag(local_as), local_as_lineNum)
self.skipTo(EndOfCommand)
while True:
if self.accept(Token.EndOfMode) is not None:
return
if self.accept(Whitespace) is not None:
continue
if self.accept(Comment) is not None:
self.skipTo(EndOfCommand)
continue
try:
op = self.accept(Operator)
if op:
pass
cmd = self.expect(Keyword)
if False:
pass
elif cmd == "neighbor-group":
self.bgp_neighbor_group(self.expect(Literal))
elif cmd == "neighbor":
peer = self.expect(Literal)
peer_tag = taglib.ip_address_tag(peer, kind="%s peer" % protocol.upper())
peer_lineNum = self.lineNum
address_tag = taglib.ip_address_tag(peer)
peer_tag.implies(address_tag, self.lineNum)
self.expect(EndOfCommand)
self.bgp_neighbor(protocol_tag, peer, peer_tag, peer_lineNum, local_as, local_as_tag, local_as_lineNum)
elif cmd == "vrf":
self.expect(Literal)
self.expect(EndOfCommand)
else:
self.skipTo(EndOfCommand)
except UnexpectedToken:
self.skipTo(EndOfCommand)
elif protocol == "static":
self.static()
else:
self.skipToEndOfMode()
def test_as_number_tag(self):
t = taglib.as_number_tag("1212")
eq_(t.kind, "AS number")
eq_(t.name, "1212")
eq_(t.sort_name, "0000001212")
t = taglib.as_number_tag("1212.4124")
eq_(t.kind, "AS number")
eq_(t.name, "1212.4124")
eq_(t.sort_name, "0079433756")
t = taglib.as_number_tag("1212.4124")
eq_(t.kind, "AS number")
eq_(t.name, "1212.4124")
eq_(t.sort_name, "0079433756")
def test_as_number_tag(self):
t = taglib.as_number_tag("1212")
eq_(t.kind, "AS number")
eq_(t.name, "1212")
eq_(t.sort_name, "0000001212")
t = taglib.as_number_tag("1212.4124")
eq_(t.kind, "AS number")
eq_(t.name, "1212.4124")
eq_(t.sort_name, "0079433756")
t = taglib.as_number_tag("1212.4124")
eq_(t.kind, "AS number")
eq_(t.name, "1212.4124")
eq_(t.sort_name, "0079433756")
def bgp_neighbor(self, protocol_tag, peer, peer_tag, peer_lineNum,
top_local_as, top_local_as_tag, top_local_as_lineNum):
local_as = top_local_as
local_as_tag = top_local_as_tag
local_as_lineNum = top_local_as_lineNum
while True:
if self.accept(Token.EndOfMode) is not None:
if peer_as == local_as:
peering_relationship = "iBGP"
else:
peering_relationship = "eBGP"
peering_tag = taglib.tag("%s peering" % peering_relationship,
"%s %s" % (device_tag.name, peer),
sort_name="%s %s" %
(device_tag.name, peer_tag.sort_name))
peering_tag.implies(protocol_tag, peer_lineNum)
peering_tag.implied_by(device_tag, peer_lineNum)
local_as_tag.implied_by(peering_tag, peer_lineNum)
peer_as_tag.implied_by(peering_tag, peer_lineNum)
remote_peer_tag = taglib.ip_address_tag(peer,
kind="remote %s peer" %
protocol_tag.name)
remote_peer_tag.implied_by(peering_tag, peer_lineNum)
remote_peer_tag.implies(peer_tag, peer_lineNum)
return
if self.accept(Whitespace) is not None:
continue
if self.accept(Comment) is not None:
self.skipTo(EndOfCommand)
continue
try:
op = self.accept(Operator)
if op:
pass
cmd = self.expect(Keyword)
if False:
pass
elif cmd == "local-as":
local_as = self.expect(Literal)
local_as_lineNum = self.lineNum
local_as_tag = taglib.as_number_tag(local_as, "local AS")
local_as_tag.implies(taglib.as_number_tag(local_as),
local_as_lineNum)
self.expect(EndOfCommand)
elif cmd == "remote-as":
peer_as = self.expect(Literal)
peer_as_lineNum = self.lineNum
peer_as_tag = taglib.as_number_tag(peer_as, "remote AS")
peer_as_tag.implies(taglib.as_number_tag(peer_as),
peer_as_lineNum)
self.expect(EndOfCommand)
elif cmd == "use":
subcmd = self.expect(Keyword)
if subcmd == "neighbor-group":
group = self.expect(Literal)
group_local_as = bgp_group_local_as.get(group, None)
if group_local_as is not None:
local_as = group_local_as
local_as_lineNum = bgp_group_local_as_lineNum.get(
group, None)
local_as_tag = taglib.as_number_tag(
local_as, "local AS")
local_as_tag.implies(
taglib.as_number_tag(local_as),
local_as_lineNum)
group_peer_as = bgp_group_remote_as.get(group, None)
if group_peer_as is not None:
peer_as = group_peer_as
peer_as_lineNum = bgp_group_remote_as_lineNum.get(
group, None)
peer_as_tag = taglib.as_number_tag(
peer_as, "remote AS")
peer_as_tag.implies(taglib.as_number_tag(peer_as),
peer_as_lineNum)
self.skipTo(EndOfCommand)
elif cmd == "address-family":
self.bgp_neighbor_address_family()
else:
self.skipTo(EndOfCommand)
except UnexpectedToken:
self.skipTo(EndOfCommand)
def router(self):
protocol = self.expect(Keyword)
protocol_tag = taglib.tag("routing protocol", protocol.upper())
protocol_tag.implied_by(taglib.env_tags.device, self.lineNum)
if protocol == "bgp":
local_as = self.expect(Literal)
local_as_tag = taglib.as_number_tag(local_as, "local AS")
local_as_lineNum = self.lineNum
local_as_tag.implies(taglib.as_number_tag(local_as),
local_as_lineNum)
self.skipTo(EndOfCommand)
while True:
if self.accept(Token.EndOfMode) is not None:
return
if self.accept(Whitespace) is not None:
continue
if self.accept(Comment) is not None:
self.skipTo(EndOfCommand)
continue
try:
op = self.accept(Operator)
if op:
pass
cmd = self.expect(Keyword)
if False:
pass
elif cmd == "neighbor-group":
self.bgp_neighbor_group(self.expect(Literal))
elif cmd == "neighbor":
peer = self.expect(Literal)
peer_tag = taglib.ip_address_tag(peer,
kind="%s peer" %
protocol.upper())
peer_lineNum = self.lineNum
address_tag = taglib.ip_address_tag(peer)
peer_tag.implies(address_tag, self.lineNum)
self.expect(EndOfCommand)
self.bgp_neighbor(protocol_tag, peer, peer_tag,
peer_lineNum, local_as, local_as_tag,
local_as_lineNum)
elif cmd == "vrf":
self.expect(Literal)
self.expect(EndOfCommand)
else:
self.skipTo(EndOfCommand)
except UnexpectedToken:
self.skipTo(EndOfCommand)
elif protocol == "static":
self.static()
else:
self.skipToEndOfMode()
def router(self):
protocol = self.expect(Keyword)
protocol_tag = taglib.tag("routing protocol", protocol.upper())
protocol_tag.implied_by(taglib.env_tags.device, self.lineNum)
if protocol == "bgp":
bgp_router_id = None
bgp_router_id_lineNum = None
local_as = self.expect(Literal)
local_as_tag = taglib.as_number_tag(local_as, "local AS")
local_as_lineNum = self.lineNum
local_as_tag.implies(taglib.as_number_tag(local_as), local_as_lineNum)
self.skipTo(EndOfCommand)
while True:
disable = False
if self.accept(Whitespace) is None:
for peer, peerdict in peer_dicts.items():
bgp_local_addr = None
bgp_local_addr_lineNum = None
peer_lineNum = peerdict.get("peer_lineNum", None)
peer_group = peerdict.get("peer_group", None)
if peer_group:
peer_group_dict = peer_groups.get(peer_group, None)
else:
peer_group_dict = None
peer_as = peerdict.get("peer_as", None)
if peer_as is not None:
peer_as_lineNum = peerdict.get("peer_as_lineNum", None)
elif peer_group_dict:
peer_as = peer_group_dict.get("peer_as", None);
peer_as_lineNum = peer_group_dict.get("peer_as_lineNum", None)
if peer_as is None:
continue
update_source = peerdict.get("update_source", None)
update_source_lineNum = peerdict.get("update_source_lineNum", None)
if update_source is None and peer_group_dict is not None:
update_source = peer_group_dict.get("update_source", None)
update_source_lineNum = peer_group_dict.get("update_source_lineNum", None)
peer_ip = IPy.IP(peer)
if update_source is None:
if peer_ip.version() == 4 and bgp_router_id:
bgp_local_addr = bgp_router_id
bgp_local_addr_lineNum = bgp_router_id_lineNum
else:
update_source = 'Loopback0'
update_source_lineNum = 0
if update_source is not None:
bgp_local_addr_lineNum = update_source_lineNum
if peer_ip.version() == 4:
bgp_local_addr = if_addrs4.get(update_source)
elif peer_ip.version() == 6:
bgp_local_addr = if_addrs6.get(update_source)
peer_tag = taglib.ip_address_tag(peer, kind="%s peer" % protocol.upper())
address_tag = taglib.ip_address_tag(peer)
peer_tag.implies(address_tag, peer_lineNum)
peer_as_tag = taglib.as_number_tag(peer_as, "remote AS")
peer_as_tag.implies(taglib.as_number_tag(peer_as), peer_as_lineNum)
if peer_as == local_as:
peering_relationship = "iBGP"
else:
peering_relationship = "eBGP"
peering_tag = taglib.tag("%s peering" % peering_relationship,
"%s %s" % (device_tag.name, peer),
sort_name="%s %s" % (device_tag.name, peer_tag.sort_name))
peering_tag.implies(protocol_tag, peer_lineNum)
peering_tag.implied_by(device_tag, peer_lineNum)
local_as_tag.implied_by(peering_tag, peer_lineNum)
peer_as_tag.implied_by(peering_tag, peer_lineNum)
if bgp_local_addr is not None:
peer2_tag = taglib.ip_address_tag(bgp_local_addr, kind="%s peer" % protocol.upper())
address2_tag = taglib.ip_address_tag(bgp_local_addr)
peer2_tag.implies(address2_tag, bgp_local_addr_lineNum)
local_peer_tag = taglib.ip_address_tag(bgp_local_addr, kind="local %s peer" % protocol.upper())
local_peer_tag.implied_by(peering_tag, bgp_local_addr_lineNum)
local_peer_tag.implies(peer2_tag, bgp_local_addr_lineNum)
remote_peer_tag = taglib.ip_address_tag(peer, kind="remote %s peer" % protocol.upper())
remote_peer_tag.implied_by(peering_tag, peer_lineNum)
remote_peer_tag.implies(peer_tag, peer_lineNum)
return
if self.accept(Comment) is not None:
self.skipTo(EndOfCommand)
continue
try:
op = self.accept(Operator)
if op and op == "no":
disable = True
cmd = self.expect(Keyword)
if cmd == "neighbor":
peer_group = None
peer = self.accept(Number)
if peer is None:
# if no address, then its probably a peer group
peer_group = self.expect(String)
peerdict = peer_groups.get(peer_group, None)
if peerdict is None:
peerdict = {}
peer_groups[peer_group] = peerdict
else:
peerdict = peer_dicts.get(peer, None)
if peerdict is None:
peerdict = {}
peerdict["peer"] = peer
peerdict["peer_lineNum"] = self.lineNum
peerdict["disable"] = disable
peer_dicts[peer] = peerdict
subcmd = self.expect(Keyword)
if subcmd == "remote-as":
peerdict["peer_as"] = self.expect(Literal)
peerdict["peer_as_lineNum"] = self.lineNum
elif subcmd == "peer-group":
if peer is not None:
peerdict["peer_group"] = self.accept(Literal)
elif subcmd == "update-source":
peerdict["update_source"] = self.expect(Literal)
peerdict["update_source_lineNum"] = self.lineNum
elif cmd == "bgp":
subcmd = self.expect(Keyword)
if subcmd == "router-id":
bgp_router_id = self.accept(Literal)
bgp_router_id_lineNum = self.lineNum
else:
self.skipTo(EndOfCommand)
elif cmd == "router-id":
bgp_router_id = self.accept(Literal)
bgp_router_id_lineNum = self.lineNum
self.skipTo(EndOfCommand)
except UnexpectedToken:
self.skipTo(EndOfCommand)
self.skipTo(EndOfCommand)
def tag_protocols(top):
protocol = "BGP"
routing_options_local_as_list = top.xpath("routing-options/autonomous-system/as-number")
routing_options_router_id_list = top.xpath("routing-options/router-id")
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for group_elem in protocol_elem.xpath("group"):
name_elem = group_elem.xpath("name")[0]
group_tag = taglib.tag("%s group" % protocol,
"%s %s" % (device_tag.name, name_elem.text))
group_tag.implied_by(device_tag, name_elem.sourceline)
for peer_name_elem in group_elem.xpath("neighbor/name"):
local_address_elem_list = peer_name_elem.xpath("ancestor::*/local-address")
if local_address_elem_list:
local_address_elem = local_address_elem_list[0]
elif routing_options_router_id_list:
local_address_elem = routing_options_router_id_list[0]
local_elem_list = peer_name_elem.xpath("ancestor::*/local-as/as-number")
if local_elem_list:
local_elem = local_elem_list[0]
elif routing_options_local_as_list:
local_elem = routing_options_local_as_list[0]
if local_elem is not None:
localasn_tag = taglib.as_number_tag(local_elem.text, "local AS")
localasn_tag.implies(taglib.as_number_tag(local_elem.text),
local_elem.sourceline)
asn_elem_list = peer_name_elem.xpath("ancestor::*/peer-as")
if asn_elem_list:
asn_elem = asn_elem_list[0]
else:
asn_elem = local_elem
asn_tag = taglib.as_number_tag(asn_elem.text, kind="remote AS")
asn_tag.implies(taglib.as_number_tag(asn_elem.text),
asn_elem.sourceline)
if asn_elem.text == local_elem.text:
peering_relationship = "iBGP"
else:
peering_relationship = "eBGP"
address_tag = taglib.ip_address_tag(peer_name_elem.text)
peering_tag = taglib.tag("%s peering" % peering_relationship,
"%s %s" % (device_tag.name, peer_name_elem.text),
sort_name="%s %s" % (device_tag.name, address_tag.sort_name))
peering_tag.implies(protocol_tag, peer_name_elem.sourceline)
peering_tag.implied_by(device_tag, peer_name_elem.sourceline)
peering_tag.implied_by(group_tag, peer_name_elem.sourceline)
asn_tag.implied_by(peering_tag, asn_elem.sourceline)
localasn_tag.implied_by(peering_tag, local_elem.sourceline)
peer_tag = taglib.ip_address_tag(peer_name_elem.text, kind="%s peer" % protocol)
peer_tag.implies(address_tag, peer_name_elem.sourceline)
if local_address_elem is not None:
peer2_tag = taglib.ip_address_tag(local_address_elem.text, kind="%s peer" % protocol.upper())
address2_tag = taglib.ip_address_tag(local_address_elem.text)
peer2_tag.implies(address2_tag, local_address_elem.sourceline)
local_peer_tag = taglib.ip_address_tag(local_address_elem.text,
kind="local %s peer" % protocol)
local_peer_tag.implied_by(peering_tag, local_address_elem.sourceline)
local_peer_tag.implies(peer2_tag, peer_name_elem.sourceline)
remote_peer_tag = taglib.ip_address_tag(peer_name_elem.text,
kind="remote %s peer" % protocol)
remote_peer_tag.implied_by(peering_tag, peer_name_elem.sourceline)
remote_peer_tag.implies(peer_tag, peer_name_elem.sourceline)
protocol = "MSDP"
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for group_elem in protocol_elem.xpath("group"):
name_elem = group_elem.xpath("name")[0]
group_tag = taglib.tag("%s group" % protocol,
"%s %s" % (device_tag.name, name_elem.text))
group_tag.implied_by(device_tag, name_elem.sourceline)
for peer_name_elem in group_elem.xpath("peer/name"):
peer_tag = taglib.tag("%s peer" % protocol, peer_name_elem.text)
address_tag = taglib.ip_address_tag(peer_name_elem.text)
peer_tag.implies(address_tag, peer_name_elem.sourceline)
peer_tag.implied_by(group_tag, peer_name_elem.sourceline)
peer_tag.implies(protocol_tag, peer_name_elem.sourceline)
ospf_version_dict = {'ospf':'OSPF', 'ospf3':'OSPFv3'}
for protocol_key, protocol in ospf_version_dict.items():
protocol_elem_list = top.xpath("protocols/%s" % protocol_key)
if not protocol_elem_list:
continue
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for area_elem in protocol_elem.xpath("area"):
name_elem = area_elem.xpath("name")[0]
area_tag = taglib.tag("%s area" % protocol, name_elem.text)
area_tag.implies(protocol_tag, name_elem.sourceline)
for interface_name_elem in area_elem.xpath("interface/name"):
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag("interface",
"%s %s" % (device_tag.name,
interface_name_elem.text))]
for t in interface_tags:
t.implies(area_tag, interface_name_elem.sourceline)
protocol = "PIM"
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for interface_name_elem in protocol_elem.xpath("interface/name"):
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag("interface",
"%s %s" % (device_tag.name,
interface_name_elem.text))]
for t in interface_tags:
t.implies(protocol_tag, interface_name_elem.sourceline)
for protocol in ("RIP", "RIPng"):
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if not protocol_elem_list:
continue
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for group_elem in protocol_elem.xpath("group"):
name_elem = group_elem.xpath("name")[0]
group_tag = taglib.tag("%s group" % protocol,name_elem.text)
group_tag.implies(protocol_tag, name_elem.sourceline)
for interface_name_elem in group_elem.xpath("neighbor/name"):
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag("interface",
"%s %s" % (device_tag.name,
interface_name_elem.text))]
for t in interface_tags:
t.implies(group_tag, interface_name_elem.sourceline)
protocol = "router-advertisement"
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for interface_elem in protocol_elem.xpath("interface"):
interface_name_elem = interface_elem.xpath("name")[0]
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag("interface",
"%s %s" % (device_tag.name,
interface_name_elem.text))]
for t in interface_tags:
ratag = taglib.tag("ND router advertisement server",
"%s %s" % (device_tag.name, interface_name_elem.text))
ratag.implied_by(t, interface_name_elem.sourceline);
for prefix_name_elem in interface_elem.xpath("prefix/name"):
ratag.implies(taglib.ip_subnet_tag(prefix_name_elem.text),
prefix_name_elem.sourceline)
def tag_protocols(top):
protocol = "BGP"
routing_options_local_as_list = top.xpath(
"routing-options/autonomous-system/as-number")
routing_options_router_id_list = top.xpath("routing-options/router-id")
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for group_elem in protocol_elem.xpath("group"):
name_elem = group_elem.xpath("name")[0]
group_tag = taglib.tag("%s group" % protocol,
"%s %s" % (device_tag.name, name_elem.text))
group_tag.implied_by(device_tag, name_elem.sourceline)
for peer_name_elem in group_elem.xpath("neighbor/name"):
local_address_elem_list = peer_name_elem.xpath(
"ancestor::*/local-address")
if local_address_elem_list:
local_address_elem = local_address_elem_list[0]
elif routing_options_router_id_list:
local_address_elem = routing_options_router_id_list[0]
local_elem_list = peer_name_elem.xpath(
"ancestor::*/local-as/as-number")
if local_elem_list:
local_elem = local_elem_list[0]
elif routing_options_local_as_list:
local_elem = routing_options_local_as_list[0]
if local_elem is not None:
localasn_tag = taglib.as_number_tag(
local_elem.text, "local AS")
localasn_tag.implies(taglib.as_number_tag(local_elem.text),
local_elem.sourceline)
asn_elem_list = peer_name_elem.xpath("ancestor::*/peer-as")
if asn_elem_list:
asn_elem = asn_elem_list[0]
else:
asn_elem = local_elem
asn_tag = taglib.as_number_tag(asn_elem.text, kind="remote AS")
asn_tag.implies(taglib.as_number_tag(asn_elem.text),
asn_elem.sourceline)
if asn_elem.text == local_elem.text:
peering_relationship = "iBGP"
else:
peering_relationship = "eBGP"
address_tag = taglib.ip_address_tag(peer_name_elem.text)
peering_tag = taglib.tag(
"%s peering" % peering_relationship,
"%s %s" % (device_tag.name, peer_name_elem.text),
sort_name="%s %s" %
(device_tag.name, address_tag.sort_name))
peering_tag.implies(protocol_tag, peer_name_elem.sourceline)
peering_tag.implied_by(device_tag, peer_name_elem.sourceline)
peering_tag.implied_by(group_tag, peer_name_elem.sourceline)
asn_tag.implied_by(peering_tag, asn_elem.sourceline)
localasn_tag.implied_by(peering_tag, local_elem.sourceline)
peer_tag = taglib.ip_address_tag(peer_name_elem.text,
kind="%s peer" % protocol)
peer_tag.implies(address_tag, peer_name_elem.sourceline)
if local_address_elem is not None:
peer2_tag = taglib.ip_address_tag(local_address_elem.text,
kind="%s peer" %
protocol.upper())
address2_tag = taglib.ip_address_tag(
local_address_elem.text)
peer2_tag.implies(address2_tag,
local_address_elem.sourceline)
local_peer_tag = taglib.ip_address_tag(
local_address_elem.text,
kind="local %s peer" % protocol)
local_peer_tag.implied_by(peering_tag,
local_address_elem.sourceline)
local_peer_tag.implies(peer2_tag,
peer_name_elem.sourceline)
remote_peer_tag = taglib.ip_address_tag(peer_name_elem.text,
kind="remote %s peer" %
protocol)
remote_peer_tag.implied_by(peering_tag,
peer_name_elem.sourceline)
remote_peer_tag.implies(peer_tag, peer_name_elem.sourceline)
protocol = "MSDP"
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for group_elem in protocol_elem.xpath("group"):
name_elem = group_elem.xpath("name")[0]
group_tag = taglib.tag("%s group" % protocol,
"%s %s" % (device_tag.name, name_elem.text))
group_tag.implied_by(device_tag, name_elem.sourceline)
for peer_name_elem in group_elem.xpath("peer/name"):
peer_tag = taglib.tag("%s peer" % protocol,
peer_name_elem.text)
address_tag = taglib.ip_address_tag(peer_name_elem.text)
peer_tag.implies(address_tag, peer_name_elem.sourceline)
peer_tag.implied_by(group_tag, peer_name_elem.sourceline)
peer_tag.implies(protocol_tag, peer_name_elem.sourceline)
ospf_version_dict = {'ospf': 'OSPF', 'ospf3': 'OSPFv3'}
for protocol_key, protocol in ospf_version_dict.items():
protocol_elem_list = top.xpath("protocols/%s" % protocol_key)
if not protocol_elem_list:
continue
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for area_elem in protocol_elem.xpath("area"):
name_elem = area_elem.xpath("name")[0]
area_tag = taglib.tag("%s area" % protocol, name_elem.text)
area_tag.implies(protocol_tag, name_elem.sourceline)
for interface_name_elem in area_elem.xpath("interface/name"):
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag(
"interface", "%s %s" %
(device_tag.name, interface_name_elem.text))
]
for t in interface_tags:
t.implies(area_tag, interface_name_elem.sourceline)
protocol = "PIM"
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for interface_name_elem in protocol_elem.xpath("interface/name"):
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag(
"interface",
"%s %s" % (device_tag.name, interface_name_elem.text))
]
for t in interface_tags:
t.implies(protocol_tag, interface_name_elem.sourceline)
for protocol in ("RIP", "RIPng"):
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if not protocol_elem_list:
continue
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for group_elem in protocol_elem.xpath("group"):
name_elem = group_elem.xpath("name")[0]
group_tag = taglib.tag("%s group" % protocol, name_elem.text)
group_tag.implies(protocol_tag, name_elem.sourceline)
for interface_name_elem in group_elem.xpath("neighbor/name"):
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag(
"interface", "%s %s" %
(device_tag.name, interface_name_elem.text))
]
for t in interface_tags:
t.implies(group_tag, interface_name_elem.sourceline)
protocol = "router-advertisement"
protocol_elem_list = top.xpath("protocols/%s" % protocol.lower())
if protocol_elem_list:
protocol_elem = protocol_elem_list[0]
protocol_tag = taglib.tag("routing protocol", protocol)
protocol_tag.used(protocol_elem.sourceline)
for interface_elem in protocol_elem.xpath("interface"):
interface_name_elem = interface_elem.xpath("name")[0]
if interface_name_elem.text == "all":
interface_tags = all_interface_tags
else:
interface_tags = [
taglib.tag(
"interface",
"%s %s" % (device_tag.name, interface_name_elem.text))
]
for t in interface_tags:
ratag = taglib.tag(
"ND router advertisement server",
"%s %s" % (device_tag.name, interface_name_elem.text))
ratag.implied_by(t, interface_name_elem.sourceline)
for prefix_name_elem in interface_elem.xpath("prefix/name"):
ratag.implies(taglib.ip_subnet_tag(prefix_name_elem.text),
prefix_name_elem.sourceline)
def bgp_neighbor(self, protocol_tag, peer, peer_tag, peer_lineNum, top_local_as, top_local_as_tag, top_local_as_lineNum):
local_as = top_local_as
local_as_tag = top_local_as_tag
local_as_lineNum = top_local_as_lineNum
while True:
if self.accept(Token.EndOfMode) is not None:
if peer_as == local_as:
peering_relationship = "iBGP"
else:
peering_relationship = "eBGP"
peering_tag = taglib.tag("%s peering" % peering_relationship,
"%s %s" % (device_tag.name, peer),
sort_name="%s %s" % (device_tag.name, peer_tag.sort_name))
peering_tag.implies(protocol_tag, peer_lineNum)
peering_tag.implied_by(device_tag, peer_lineNum)
local_as_tag.implied_by(peering_tag, peer_lineNum)
peer_as_tag.implied_by(peering_tag, peer_lineNum)
remote_peer_tag = taglib.ip_address_tag(peer, kind="remote %s peer" % protocol_tag.name)
remote_peer_tag.implied_by(peering_tag, peer_lineNum)
remote_peer_tag.implies(peer_tag, peer_lineNum)
return
if self.accept(Whitespace) is not None:
continue
if self.accept(Comment) is not None:
self.skipTo(EndOfCommand)
continue
try:
op = self.accept(Operator)
if op:
pass
cmd = self.expect(Keyword)
if False:
pass
elif cmd == "local-as":
local_as = self.expect(Literal)
local_as_lineNum = self.lineNum
local_as_tag = taglib.as_number_tag(local_as, "local AS")
local_as_tag.implies(taglib.as_number_tag(local_as), local_as_lineNum)
self.expect(EndOfCommand)
elif cmd == "remote-as":
peer_as = self.expect(Literal)
peer_as_lineNum = self.lineNum
peer_as_tag = taglib.as_number_tag(peer_as, "remote AS")
peer_as_tag.implies(taglib.as_number_tag(peer_as), peer_as_lineNum)
self.expect(EndOfCommand)
elif cmd == "use":
subcmd = self.expect(Keyword)
if subcmd == "neighbor-group":
group = self.expect(Literal)
group_local_as = bgp_group_local_as.get(group, None)
if group_local_as is not None:
local_as = group_local_as
local_as_lineNum = bgp_group_local_as_lineNum.get(group, None)
local_as_tag = taglib.as_number_tag(local_as, "local AS")
local_as_tag.implies(taglib.as_number_tag(local_as), local_as_lineNum)
group_peer_as = bgp_group_remote_as.get(group, None)
if group_peer_as is not None:
peer_as = group_peer_as
peer_as_lineNum = bgp_group_remote_as_lineNum.get(group, None)
peer_as_tag = taglib.as_number_tag(peer_as, "remote AS")
peer_as_tag.implies(taglib.as_number_tag(peer_as), peer_as_lineNum)
self.skipTo(EndOfCommand)
elif cmd == "address-family":
self.bgp_neighbor_address_family()
else:
self.skipTo(EndOfCommand)
except UnexpectedToken:
self.skipTo(EndOfCommand)
