def to_python(self, value):
if not value:
return set()
if isinstance(value, basestring):
return set(ranges_to_list(value))
else:
return value
def clean(self, value):
if isinstance(value, six.string_types) and not value.strip():
return ""
vp = VLANIDParameter()
try:
return list_to_ranges([vp.clean(v) for v in ranges_to_list(value)])
except SyntaxError:
self.raise_error(value)
def on_interface_tagged(self, tokens):
vlans = tokens[0].strip()
if vlans.startswith("add"):
vlans = vlans.split(" ", 1)[1].strip()
si = self.get_current_subinterface()
if vlans != "none":
for v in ranges_to_list(vlans):
si.tagged_vlans += [int(v)]
si.add_afi("BRIDGE")
def execute(self):
interfaces = []
v = self.cli("show lldp local config")
for port in self.rx_port.finditer(v):
port_no = port.group("port")
c = self.cli("show interface port-list %s switchport" % port_no)
match = self.rx_vlan.search(c)
iface = {
"name": "P%s" % port_no,
"type": "physical"
}
sub = {
"name": "P%s" % port_no,
"enabled_afi": ["BRIDGE"],
}
if match.group("op_mode") in ["trunk", "hybrid"]:
sub["untagged_vlan"] = int(match.group("trunk_native_vlan"))
sub["tagged_vlans"] = ranges_to_list(match.group("op_vlans"))
else:
sub["untagged_vlan"] = int(match.group("access_vlan"))
iface["subinterfaces"] = [sub]
interfaces += [iface]
mac = self.scripts.get_chassis_id()[0]["first_chassis_mac"]
v = self.cli("show interface ip")
for match in self.rx_ip_iface.finditer(v):
ifname = match.group("iface")
i = {
"name": "ip%s" % ifname,
"type": "SVI",
"mac": mac,
"enabled_protocols": [],
"subinterfaces": [{
"name": "ip%s" % ifname,
"mac": mac,
"enabled_afi": ['IPv4']
}]
}
addr = match.group("ip")
mask = match.group("mask")
ip_address = "%s/%s" % (addr, IPv4.netmask_to_len(mask))
i['subinterfaces'][0]["ipv4_addresses"] = [ip_address]
interfaces += [i]
v = self.cli("show interface ip vlan")
for match in self.rx_vlans_ip.finditer(v):
vlan_id = match.group("vlan_id")
if vlan_id == "none":
continue
ifname = "ip%s" % match.group("iface")
for i in interfaces:
if i["name"] == ifname:
i["subinterfaces"][0]["vlan_ids"] = vlan_id
break
return [{"interfaces": interfaces}]
def on_vlan(self, tokens):
"""
if - vlan range
database -
:param tokens:
:return:
"""
if "-" not in tokens[-1] and "database" not in tokens:
self.get_vlan_fact(int(tokens[-1].strip()))
elif "-" in tokens[-1]:
for v in ranges_to_list(tokens[-1].strip()):
self.get_vlan_fact(int(v))
def clean(self, value):
"""
>>> VLANIDMapParameter().clean("1,2,5-10")
'1-2,5-10'
>>> VLANIDMapParameter().clean("")
''
"""
if isinstance(value, basestring) and not value.strip():
return ""
vp = VLANIDParameter()
try:
return list_to_ranges([vp.clean(v) for v in ranges_to_list(value)])
except SyntaxError:
self.raise_error(value)
def on_interface_tagged(self, tokens):
"""
undo port trunk allow-pass vlan 1
port trunk allow-pass vlan 118 718
port trunk allow-pass vlan 2 to 4094
port trunk allow-pass vlan 76 90 118 123 126 165 to 169 175 to 179 621 2852 to 2854
port hybrid tagged vlan 51 90 to 91 110 118 319 333 402 419 433 524 to 527
"""
si = self.get_current_subinterface()
vlans = " ".join(tokens[4:])
if vlans != "none":
for v in ranges_to_list(vlans, splitter=" "):
si.tagged_vlans += [int(v)]
si.add_afi("BRIDGE")
def execute_cli(self):
if self.is_iscom2624g:
return self.execute_iscom2624g()
lldp_ifaces = []
v = self.cli("show lldp local config")
match = self.rx_lldp.search(v)
if match:
lldp_ifaces = self.expand_rangelist(match.group("ports"))
ifaces = []
v = self.cli("show interface port description")
for line in v.splitlines()[2:-1]:
i = {
"name": int(line[:8]),
"type": "physical",
"snmp_ifindex": int(line[:8]),
"subinterfaces": [],
}
if str(line[8:]) != "-":
i["description"] = str(line[8:])
if i["name"] in lldp_ifaces:
i["enabled_protocols"] = ["LLDP"]
ifaces.append(i)
statuses = []
v = self.cli("show interface port")
for line in v.splitlines()[5:]:
i = {
"name": int(line[:6]),
"admin_status": "enable" in line[7:14],
"oper_status": "up" in line[14:29],
}
statuses.append(i)
vlans = []
v = self.cli("show interface port switchport")
for section in v.split("Port"):
if not section:
continue
vlans.append(self.parse_vlans(section))
d = defaultdict(dict)
for l in (statuses, ifaces):
for elem in l:
d[elem["name"]].update(elem)
l3 = list(six.itervalues(d))
for port in l3:
name = port["name"]
port["subinterfaces"] = [{
"name":
str(name),
"enabled_afi": ["BRIDGE"],
"admin_status":
port["admin_status"],
"oper_status":
port["oper_status"],
"tagged_vlans": [],
"untagged_vlan": [
int(vlan["untagged_vlan"]) for vlan in vlans
if int(vlan["name"]) == name
][0],
}]
if "description" in port:
port["subinterfaces"][0]["description"] = port["description"]
tvl = [
vlan["op_trunk_allowed_vlan"] for vlan in vlans
if int(vlan["name"]) == name
][0]
if "n/a" not in tvl:
port["subinterfaces"][0]["tagged_vlans"] = ranges_to_list(tvl)
if_descr = []
v = self.cli("show interface ip description")
for line in v.splitlines()[2:-1]:
i = {"name": int(line[:9]), "description": str(line[9:])}
if_descr.append(i)
if not l3:
v = self.cli("show interface description")
for match in self.rx_descr.finditer(v):
i = {
"name":
match.group("port"),
"type":
"physical",
"description":
match.group("descr").strip(),
"enabled_protocols": [],
"subinterfaces": [{
"name":
match.group("port"),
"description":
match.group("descr").strip()
}],
}
l3 += [i]
v = self.cli("show vlan detail")
for match in self.rx_vlan2.finditer(v):
vlan_id = int(match.group("vlan_id"))
ports = ranges_to_list(match.group("ports"))
if match.group("untagged"):
untagged = ranges_to_list(match.group("untagged"))
else:
untagged = []
for i in l3:
for p in ports:
if i["name"] == "port%s" % p:
if p not in untagged:
if "tagged_vlans" in i["subinterfaces"][0]:
i["subinterfaces"][0]["tagged_vlans"] += [
vlan_id
]
else:
i["subinterfaces"][0]["tagged_vlans"] = [
vlan_id
]
else:
i["subinterfaces"][0][
"untagged_vlan"] = vlan_id
v = self.profile.get_version(self)
mac = v["mac"]
# XXX: This is a dirty hack !!!
# I do not know, how get ip interface MAC address
try:
v = self.cli("show interface ip")
except self.CLISyntaxError:
v = self.cli("show interface ip 0")
for match in self.rx_iface.finditer(v):
ifname = match.group("iface")
i = {
"name":
"ip%s" % ifname,
"type":
"SVI",
"oper_status":
match.group("oper_status") == "active",
"admin_status":
match.group("oper_status") == "active",
"mac":
mac,
"enabled_protocols": [],
"subinterfaces": [{
"name":
"ip%s" % ifname,
"oper_status":
match.group("oper_status") == "active",
"admin_status":
match.group("oper_status") == "active",
"mac":
mac,
"vlan_ids": [int(match.group("vid"))],
"enabled_afi": ["IPv4"],
}],
}
addr = match.group("ip")
mask = match.group("mask")
ip_address = "%s/%s" % (addr, IPv4.netmask_to_len(mask))
i["subinterfaces"][0]["ipv4_addresses"] = [ip_address]
for q in if_descr:
if str(q["name"]).strip() == ifname:
i["description"] = q["description"]
i["subinterfaces"][0]["description"] = q["description"]
l3 += [i]
try:
v = self.cli("show ip interface brief")
except self.CLISyntaxError:
return [{"interfaces": l3}]
for match in self.rx_iface2.finditer(v):
ifname = match.group("iface")
i = {
"name":
"ip%s" % ifname,
"type":
"SVI",
"mac":
mac,
"enabled_protocols": [],
"subinterfaces": [{
"name": "ip%s" % ifname,
"mac": mac,
"enabled_afi": ["IPv4"]
}],
}
addr = match.group("ip")
mask = match.group("mask")
ip_address = "%s/%s" % (addr, IPv4.netmask_to_len(mask))
i["subinterfaces"][0]["ipv4_addresses"] = [ip_address]
l3 += [i]
v = self.cli("show interface ip vlan")
for match in self.rx_vlans_ip.finditer(v):
vlan_id = match.group("vlan_id")
if vlan_id == "none":
continue
ifname = "ip%s" % match.group("iface")
for i in l3:
if i["name"] == ifname:
i["subinterfaces"][0]["vlan_ids"] = vlan_id
break
return [{"interfaces": l3}]
def execute_cli(self):
interfaces = []
v = self.cli("show interface port")
for match in self.rx_port.finditer(v):
i = {
"name":
match.group("port"),
"type":
"physical",
"admin_status":
match.group("admin_status") == "enable",
"oper_status":
match.group("admin_status") == "up",
"snmp_ifindex":
int(match.group("port")),
"subinterfaces": [{
"name":
match.group("port"),
"admin_status":
match.group("admin_status") == "enable",
"oper_status":
match.group("admin_status") == "up",
"enabled_afi": ['BRIDGE']
}]
}
interfaces += [i]
v = self.cli("show interface port switchport")
for match in self.rx_vlan.finditer(v):
port = match.group("port")
for iface in interfaces:
if iface["name"] == port:
sub = iface["subinterfaces"][0]
if match.group("op_mode") in ["trunk", "hybrid"]:
sub["untagged_vlan"] = int(
match.group("trunk_native_vlan"))
sub["tagged_vlans"] = ranges_to_list(
match.group("op_vlans"))
else:
sub["untagged_vlan"] = int(match.group("access_vlan"))
break
v = self.cli("show interface port description")
for match in self.rx_descr.finditer(v):
port = match.group("port")
descr = match.group("descr").strip()
if not descr:
continue
for iface in interfaces:
if iface["name"] == port:
iface["description"] = descr
iface["subinterfaces"][0]["description"] = descr
break
mac = self.scripts.get_chassis_id()[0]["first_chassis_mac"]
v = self.cli("show interface ip")
for match in self.rx_ip_iface.finditer(v):
ifname = str(int(match.group("iface")) - 1)
addr = match.group("ip")
mask = match.group("mask")
ip_address = "%s/%s" % (addr, IPv4.netmask_to_len(mask))
i = {
"name":
"IP%s" % ifname,
"type":
"SVI",
"mac":
mac,
"enabled_protocols": [],
"subinterfaces": [{
"name": "ip%s" % ifname,
"mac": mac,
"enabled_afi": ['IPv4'],
"ipv4_addresses": [ip_address],
"vlan_ids": [match.group("vlan_id")]
}]
}
interfaces += [i]
return [{"interfaces": interfaces}]
def on_vlan_range(self, tokens):
for v in ranges_to_list(tokens[0].strip()):
self.get_vlan_fact(v)
def get_data_from_confdb(self):
# Get interfaces and parse result
interfaces = {
d["if_name"]: d
for d in self.confdb.query(self.IF_QUERY)
}
vrfs = {(d["vr"], d["instance"]): d
for d in self.confdb.query(self.VRF_QUERY)}
instances = defaultdict(dict)
for d in self.confdb.query(self.UNIT_QUERY):
r = instances[d["vr"], d["instance"]]
if not r:
r["virtual_router"] = d["vr"]
r["forwarding_instance"] = d["instance"]
if vrfs and (d["vr"], d["instance"]) in vrfs:
try:
vrf = vrfs[d["vr"], d["instance"]]
r["vpn_id"] = get_vpn_id({
"name":
vrf["instance"],
"rd":
vrf.get("rd"),
"rt_export":
vrf.get("rt_export", []),
"type":
vrf["type"].upper()
if vrf["type"] in ["vrf", "vpls"] else vrf["type"],
})
except ValueError:
pass
if "interfaces" not in r:
r["interfaces"] = {}
if_name = d["if_name"]
p_iface = interfaces.get(if_name)
iface = r["interfaces"].get(if_name)
if iface is None:
iface = {
"name": if_name,
"type":
p_iface.get("type", "unknown") if p_iface else "unknown",
"admin_status": False,
"subinterfaces": {},
}
r["interfaces"][if_name] = iface
if p_iface:
if "description" in p_iface:
iface["description"] = p_iface["description"]
if "admin_status" in p_iface:
iface["admin_status"] = p_iface["admin_status"] == "on"
unit = iface["subinterfaces"].get(d["unit"])
if unit is None:
unit = {"name": d["unit"], "enabled_afi": []}
iface["subinterfaces"][d["unit"]] = unit
unit = iface["subinterfaces"][d["unit"]]
description = d.get("description")
if description:
unit["description"] = description
elif p_iface and p_iface.get("description"):
unit["description"] = p_iface["description"]
if "ipv4_addresses" in d:
unit["enabled_afi"] += ["IPv4"]
unit["ipv4_addresses"] = d["ipv4_addresses"]
if "ipv6_addresses" in d:
unit["enabled_afi"] += ["IPv6"]
unit["ipv6_addresses"] = d["ipv4_addresses"]
if "tagged" in d or "untagged" in d:
unit["enabled_afi"] += ["BRIDGE"]
if "untagged" in d:
unit["untagged_vlan"] = int(d["untagged"])
if "tagged" in d:
unit["tagged_vlans"] = ranges_to_list(d["tagged"])
# Flatten units
r = list(six.itervalues(instances))
for fi in r:
# Flatten interfaces
fi["interfaces"] = list(six.itervalues(fi["interfaces"]))
# Flatten units
for i in fi["interfaces"]:
i["subinterfaces"] = list(six.itervalues(i["subinterfaces"]))
return IGetInterfaces().clean_result(r)
def normalize_vlan_id_batch(self, tokens):
for vlan in ranges_to_list(tokens[3]):
yield self.make_vlan_id(vlan_id=vlan)
def normalize_switchport_tagged(self, tokens):
if_name = self.interface_name(tokens[1])
yield self.make_switchport_tagged(interface=if_name,
unit=if_name,
vlan_filter=ranges_to_list(
tokens[7]))
def normalize_vlan_id(self, tokens):
for vlan_id in ranges_to_list(tokens[3]):
yield self.make_vlan_id(vlan_id=str(vlan_id))
