def convert_link(cls, kb_entry, link, text=None): """ Convert extracted link to URL Following link types are supported: KB<n> - Link to Knowledge Base article <n> TT<n> - Link to Trouble Ticket <n> attach:<name> - Link to attachment <name> :param kb_entry: :param link: :param text: :return: """ if text is None: text = link if link.startswith("KB") and is_int(link[2:]): return "<a href='%s/%s/'>%s</a>" % (BASE_PATH, link[2:], text) elif link.startswith("TT"): return link[2:] elif link.startswith("attach:"): if text == link: text = link[7:] link = link[7:] return "<a href='%s/%d/attachment/%s/'>%s</a>" % (BASE_PATH, kb_entry.id, link, text) elif link.startswith("attachment:"): if text == link: text = link[11:] link = link[11:] return "<a href='/kb/kbentry/%d/attachment/%s/'>%s</a>" % (kb_entry.id, link, text) else: try: le = kb_entry.__class__.objects.get(subject=link) return "<a href='%s/%s/'>%s</a>" % (BASE_PATH, le.id, text) except kb_entry.__class__.DoesNotExist: return "<a href='%s'>%s</a>" % (link, text)
def is_static(svc): if ":" not in svc: return False p = svc.split(":") if len(p) != 2: return False return is_ipv4(p[0]) and is_int(p[1])
def execute_cli(self): r = [] try: v = self.cli("show lldp remote-device | begin LocalPort") except self.CLISyntaxError: raise self.NotSupportedError() if v: for match in self.rx_lldp.finditer(v): local_port = match.group("local_port") remote_chassis_id = match.group("remote_id") remote_chassis_id_subtype = 4 remote_port = match.group("remote_port") rn = match.group("remote_n") remote_port_subtype = 5 if self.rx_mac.match(remote_port): remote_port = MACAddressParameter().clean(remote_port) remote_port_subtype = 3 elif is_ipv4(remote_port): remote_port_subtype = 4 elif is_int(remote_port): remote_port_subtype = 7 if self.rx_mac.match(remote_chassis_id): remote_chassis_id = remote_chassis_id.replace(" ", "-") remote_chassis_id = MACAddressParameter().clean(remote_chassis_id) remote_chassis_id_subtype = 3 n = { "remote_port": remote_port, "remote_port_subtype": remote_port_subtype, "remote_chassis_id": remote_chassis_id, "remote_chassis_id_subtype": remote_chassis_id_subtype, "remote_system_name": rn, } i = {"local_interface": local_port, "neighbors": [n]} r += [i] return r
def execute(self): r = [] for v in parse_table(self.cli("show vlan", cached=True), max_width=80): if not is_int(v[0]): continue r += [{"vlan_id": v[0], "name": v[1]}] return r
def get_interface_by_local(self, port, object): """ Try to guess remote port from free-form description :param object: :param port: :return: """ self.logger.debug("Searching port by local: %s:%s", object.name, port) # Try ifindex if is_int(port): i = self.get_interface_by_ifindex(port, object) if i: return i # Try interface name try: n_port = object.get_profile().convert_interface_name(port) i = Interface.objects.filter(managed_object=object.id, name=n_port).first() if i: return i for p in object.get_profile().get_interface_names(n_port): i = Interface.objects.filter(managed_object=object.id, name=p).first() if i: return i except InterfaceTypeError: pass # Unable to decode self.logger.info("Unable to decode local subtype port id %s at %s", port, object) return None
def get_psu(self): r = defaultdict(list) k_map = {"state": "state", "partinfo": "partinfo"} try: v = self.cli("show power detail") except self.CLISyntaxError: return {} slot = 1 number = None for block in self.rx_power_split.split(v): if is_int(block): if int(block.strip()) < number: slot += 1 number = int(block.strip()) continue d = parse_kv(k_map, block) if d.get("state") in ["Empty", "Powered Off", None ] or "partinfo" not in d: continue partinfo = d["partinfo"].split() r[slot] += [{ "type": "PSU", "number": number, "description": "".join(partinfo[:-2]), "vendor": "EXTREME", "part_no": partinfo[-1], "serial": partinfo[-2], }] return r
def convert_interface_name(self, s): """ >>> Profile().convert_interface_name("19") 'vlan 19' """ if is_int(s): return "vlan %s" % s return s
def get_interface_names(self, name): r = [] if name.startswith("1:"): r += [name[2:]] else: if is_int(name): r += ["1:%s" % name] return r
def execute_cli(self, **kwargs): res = [] ports = [] try: v = self.cli("show fiber-ports optical-transceiver") for i in parse_table(v, footer=r"Temp\s+- Internally measured transceiver temperature"): if i[1] in ["OK", "N/S"] or is_int(i[1]): ports += [i[0]] except self.CLISyntaxError: pass if self.has_capability("Stack | Members"): has_unit_command = True for unit in self.capabilities["Stack | Member Ids"].split(" | "): try: plat = self.cli("show system unit %s" % unit, cached=True) except self.CLISyntaxError: # Found on MES1124M SW version 1.1.46 # Left for compatibility with other models if unit == "1": plat = self.cli("show system", cached=True) has_unit_command = False else: raise self.NotSupportedError() if not self.is_has_image: if has_unit_command: ver = self.cli("show version unit %s" % unit, cached=True) else: ver = self.cli("show version", cached=True) else: ver = "" if has_unit_command: ser = self.cli("show system id unit %s" % unit, cached=True) else: ser = self.cli("show system", cached=True) r = self.get_chassis(plat, ver, ser) platform = r["part_no"][0] res += [r] for match in self.rx_pwr.finditer(plat): res += [self.get_pwr(match.group("type"), match.group("pwr_type"), platform)] for p in ports: if p.startswith("gi") or p.startswith("te"): if unit == p[2]: res += [self.get_trans(p)] else: plat = self.cli("show system", cached=True) ver = self.cli("show version", cached=True) ser = self.cli("show system id", cached=True) r = self.get_chassis(plat, ver, ser) platform = r["part_no"][0] res = [r] for match in self.rx_pwr.finditer(plat): res += [self.get_pwr(match.group("type"), match.group("pwr_type"), platform)] for p in ports: res += [self.get_trans(p)] return res
def get_type(self, name): name = name.upper() n = name.split() if is_int(n[-1]): number = n[-1] name = " ".join(n[:-1]) else: number = None return self.TYPE_MAP.get(name), number
def execute(self): interfaces = [] lldp = self.get_lldp() ctp = self.get_ctp() for i in parse_table(self.cli("show interface switchport")): iface = { "name": i[0], "type": "physical", "enabled_protocols": [], "subinterfaces": [{ "name": i[0], "enabled_afi": ["BRIDGE"], "untagged_vlan": i[1] }], } if i[0] in lldp: iface["enabled_protocols"] += ["LLDP"] if i[0] in ctp: iface["enabled_protocols"] += ["CTP"] interfaces += [iface] for v in parse_table(self.cli("show vlan"), max_width=80): if not is_int(v[0]): continue vlan_id = v[0] ports = self.expand_rangelist(v[2]) for i in interfaces: if i["subinterfaces"][0]["untagged_vlan"] == vlan_id: continue if int(i["name"]) in ports: if "tagged_vlans" in i["subinterfaces"][0]: i["subinterfaces"][0]["tagged_vlans"] += [vlan_id] else: i["subinterfaces"][0]["tagged_vlans"] = [vlan_id] mac = self.scripts.get_chassis_id()[0]["first_chassis_mac"] match = self.rx_ipif.search(self.cli("show ip interface")) ip = match.group("ip") mask = match.group("mask") ip_address = "%s/%s" % (ip, IPv4.netmask_to_len(mask)) iface = { "name": "mgmt", "type": "SVI", "mac": mac, "subinterfaces": [{ "name": "mgmt", "vlan_ids": match.group("vlan_id"), "ipv4_addresses": [ip_address], "enabled_afi": ["IPv4"], "mac": mac, }], } interfaces += [iface] return [{"interfaces": interfaces}]
def has_bfd_snmp(self): """ Check box has bfd enabled """ # bfdAdminStatus bfd = self.snmp.get("1.3.6.1.4.1.2636.5.3.1.1.1.1.0") if is_int(bfd) and int(bfd) == 1: # enabled(1) return True return False
def execute_platform_snmp(self, caps): np = 0 # jnxRpmResSumSent for v, r in self.snmp.getnext("1.3.6.1.4.1.2636.3.50.1.2.1.2", bulk=False): tests = v.split(".") if tests[-1] == "1": # currentTest(1) np += 1 if np > 0: caps["Juniper | RPM | Probes"] = np # jnxPPPoEMajorInterfaceCount pppoe = self.snmp.get("1.3.6.1.4.1.2636.3.67.1.1.3.1.0") if is_int(pppoe) and int(pppoe) > 0: caps["BRAS | PPPoE"] = True # jnxL2tpStatsTotalTunnels l2tp = self.snmp.get("1.3.6.1.4.1.2636.3.49.1.1.1.1.1.0") if is_int(l2tp) and int(l2tp) > 0: caps["BRAS | L2TP"] = True
def parse_create_vlan(self, tokens): """ create vlan 306 tag 306 create vlan tag tag 306 """ tag = self.next_item(tokens, "tag") if tag and is_int(tag): name = self.next_item(tokens, "vlan") vid = int(tag) self.get_vlan_fact(vid).name = name self.vlan_ids[tag] = vid self.vlan_ids[name] = vid else: if len(tokens) == 5 and tokens[3] == "tag" and is_int(tokens[4]): name = self.next_item(tokens, "vlan") vid = int(tokens[4]) self.get_vlan_fact(vid).name = name self.vlan_ids[tag] = vid self.vlan_ids[name] = vid
def table_search_Q(cls, table, query): q = [] for f in CustomField.objects.filter(is_active=True, table=table, is_searchable=True): if f.type == "str": q += [{"%s__icontains" % f.name: query}] elif f.type == "int": if is_int(query): q += [{f.name: int(query)}] if q: return reduce(lambda x, y: x | models.Q(**y), q, models.Q(**q[0])) else: return None
def inner_model(qs): if value and not is_int(value): raise HTTPException( status_code=HTTPStatus.UNPROCESSABLE_ENTITY, detail=f"'{value}' is not a Integer", ) vv = self.model.get_by_id(int(value)) if value else None if value and not vv: raise HTTPException( status_code=HTTPStatus.NOT_FOUND, detail=f"NotFond {str(self.model)}: {value}") return qs.filter(**{self.name: vv})
def get_current_input(self, metrics): for metric in metrics: if self.is_lite: value = self.snmp.get("1.3.6.1.4.1.27514.103.0.28.0") else: value = self.snmp.get("1.3.6.1.4.1.27514.102.0.21") if is_float(value) or is_int(value): self.set_metric( id=("Environment | Electric Current", metric.labels), value=value, scale=scale(0.01), )
def is_ignored_interface(self, i): if i.lower() in self.ignored_interfaces: return True if i.startswith("flood to vlan"): return True if i.startswith("VPLS"): return True if i.startswith("seq_no:"): return True if is_int(i): # 10.27.0.80, 1204773146 return True return False
def convert_interface_name(self, s): """ >>> Profile().convert_interface_name("1") 'load' >>> Profile().convert_interface_name("0/1") 'load' """ match = self.rx_discrete_name.findall(s) if match: return "%s %s" % (self.SENSOR_NAME.get(int(s.split("/")[0])), s.split("/")[1]) elif is_int(s): return self.SENSOR_NAME.get(int(s)) return s
def execute_cli(self): ifaces = [] v = self.cli("show interface") for match in self.rx_int.finditer(v): ifname = self.profile.convert_interface_name(match.group("ifname")) typ = match.group("type") iftype = self.types[typ] i = { "name": ifname, "type": iftype, "admin_status": "up" in match.group("admin_status"), "oper_status": "up" in match.group("oper_status"), "snmp_ifindex": match.group("snmp_ifindex"), "mac": match.group("mac"), } sub = { "name": ifname, "admin_status": "up" in match.group("admin_status"), "oper_status": "up" in match.group("oper_status"), "mac": match.group("mac"), "mtu": match.group("mtu"), } if match.group("descr") and match.group("descr").strip(): i["description"] = match.group("descr").strip() sub["description"] = match.group("descr").strip() if match.group("ip"): sub["enabled_afi"] = ["IPv4"] sub["ipv4_addresses"] = [match.group("ip")] if i["type"] == "physical": sub["enabled_afi"] = ["BRIDGE"] c = self.cli("show vlan interface %s" % match.group("ifname")) for r in parse_table(c, allow_wrap=True): if is_int(r[2]): untagged = int(r[2]) sub["untagged_vlan"] = untagged tagged = self.expand_rangelist(r[3]) tagged = [item for item in tagged if int(item) != untagged] if tagged: sub["tagged_vlans"] = tagged if ifname.startswith("GigaEthernet"): cmd1 = "show lldp interface %s" % ifname cmd2 = self.cli(cmd1) for match1 in self.rx_lldp.finditer(cmd2): if ( match1.group("lldp_rx") == "enabled" or match1.groups("lldp_tx") == "enabled" ): i["enabled_protocols"] = ["LLDP"] i["subinterfaces"] = [sub] ifaces += [i] return [{"interfaces": ifaces}]
def get_current_input(self, metrics): for metric in metrics: if self.is_lite: value = self.snmp.get("1.3.6.1.4.1.27514.103.0.28.0") else: value = self.snmp.get("1.3.6.1.4.1.27514.102.0.21") port = metric.labels[0].rsplit("::", 1)[-1] if is_float(value) or is_int(value): self.set_metric( id=("Environment | Electric Current", metric.labels), labels=[f"noc::sensor::{port}"], value=value, scale=scale(0.01), )
def execute_cli(self, interface=None): # @todo without stack slot (Members | Ids) # show ports transceiver information r = [] if interface is not None: ifaces = [interface.split(":")] elif self.has_capability("Stack | Member Ids"): ifaces = [(s_id, None) for s_id in self.capabilities["Stack | Member Ids"].split(" | ")] else: ifaces = [(None, None)] for slot, port in ifaces: cmd = "debug hal show optic-info ddmi " if port is not None: cmd += "slot %s, port %s" % (slot, port) elif slot is not None: cmd += "slot %s" % slot try: v = self.cli(cmd) except self.CLISyntaxError: return [] for block in self.rx_trans_split.split(v): if is_int(block): port = block.strip() continue if self.rx_no_trans.match(block) or not port: continue d = parse_kv(self.k_map, block) if slot is not None: port = "%s:%s" % (slot, port) if not d: continue r += [{ "interface": port, "temp_c": self.normalize_output(d.get("temp_c")), "voltage_v": self.normalize_output(d.get("voltage_v")), "current_ma": self.normalize_output(d.get("current_ma")), "optical_rx_dbm": self.normalize_output(d.get("optical_rx_dbm")), "optical_tx_dbm": self.normalize_output(d.get("optical_tx_dbm")), }] return r
def convert_interface_name(self, s): """ >>> Profile().convert_interface_name_cisco("gi1/0/1") 'Gi 1/0/1' >>> Profile().convert_interface_name_cisco("gi1/0/1?") 'Gi 1/0/1' """ match = self.rx_eltex_interface_name.match(str(s)) if is_int(s): return "Vl %s" % s elif s in ["oob", "stack-port"]: return s elif match: return "%s %s" % (match.group("type").capitalize(), match.group("number")) else: raise InterfaceTypeError("Invalid interface '%s'" % s)
def get_object(self, object_name): """ Resolve object by name or by id """ from noc.sa.models.managedobject import ManagedObject from django.db.models import Q connect() if object_name.endswith(".json") and os.path.isfile(object_name): return JSONObject(object_name) q = Q(name=object_name) if is_int(object_name): q = Q(id=int(object_name)) | q try: return ManagedObject.objects.get(q) except ManagedObject.DoesNotExist: self.die("Object is not found: %s" % object_name)
def __iter__(self): g = super(RouterOSTokenizer, self).__iter__() context = None context_fed = False n_item = 0 for tokens in g: if tokens[0].startswith("/"): # New context if context and not context_fed: yield context context = tokens context_fed = False n_item = 0 continue if tokens[0] == "set" and len(tokens) > 1: # Process set instruction if ( tokens[1] == "[" and len(tokens) > 4 and tokens[2] == "find" and tokens[4] == "]" ): # set [ find key=value ] ... item = tokens[3].split("=", 1)[1] for ct in self.iter_context(context + (item,), tokens[5:]): yield ct elif is_int(tokens[1]): # set 0 ... for ct in self.iter_context(context + (tokens[1],), tokens[2:]): yield ct else: # set XXX for ct in self.iter_context(context, tokens[1:]): yield ct context_fed = True if tokens[0] == "add" and len(tokens) > 1: # Process add instruction for ct in self.iter_context(context + (str(n_item),), tokens[1:]): yield ct context_fed = True n_item += 1 # Yield last context if not already yielded if context and not context_fed: yield context
def execute(self, interface=None, vlan=None, mac=None): cmd = self.cli("show mac-address-table") # if mac is not None: # cmd += " address %s" % mac if interface is not None: cmd += " port %s" % interface if vlan is not None: cmd += " vlan %s" % vlan r = [] t = parse_table(cmd, footer="^show mac-address-table") for i in t: if is_int(i[0]): r += [{ "vlan_id": i[0], "mac": i[1], "interfaces": [self.profile.convert_interface_name(i[4])], "type": "D" if i[2] == "learned" else "S", }] return r
def get_objects_from_expression(cls, s): """ Get list of Managed Object matching selector expression Expression must be string or list. Elements must be one of: * string starting with @ - treated as selector name * string containing numbers - treated as object's id * string - managed object name. * string - IPv4 or IPv6 address - management address Raises ManagedObject.DoesNotExists if object is not found. Raises ManagedObjectSelector.DoesNotExists if selector is not found :param cls: :param s: :return: """ from .managedobject import ManagedObject if isinstance(s, int) or isinstance(s, str): s = [s] if not isinstance(s, list): raise ValueError("list required") objects = set() for so in s: if not isinstance(so, str): so = str(so) if so.startswith("@"): # Selector expression: @<selector name> o = ManagedObjectSelector.objects.get(name=so[1:]) objects |= set(o.managed_objects) else: # Search by name q = Q(name=so) if is_int(so): # Search by id q |= Q(id=int(so)) if is_ipv4(so) or is_ipv6(so): q |= Q(address=so) o = ManagedObject.objects.get(q) objects.add(o) return list(objects)
def convert_interface_name(self, s): """ >>> Profile().convert_interface_name_cisco("gi1/0/1") 'Gi 1/0/1' >>> Profile().convert_interface_name_cisco("gi1/0/1?") 'Gi 1/0/1' """ if s.startswith("Slot"): # @todo InterfaceType check needed s = s.replace("Slot", "gigabitethernet") match = self.rx_eltex_interface_name.match(str(s)) if is_int(s): return "Vl %s" % s elif s in ["oob", "stack-port"]: return s elif match: return "%s %s" % (match.group("type").capitalize(), match.group("number")) else: raise InterfaceTypeError("Invalid interface '%s'" % s)
def get_managed_object(self, o_id): """ Get ManagedObject by id or name :param o_id: Object's id or name :return: ManagedObject :rtype: ManagedObject """ from noc.sa.models.managedobject import ManagedObject # Try to get object by id if is_int(o_id): try: return ManagedObject.objects.get(id=int(o_id)) except ManagedObject.DoesNotExist: pass # Try to get object by name try: return ManagedObject.objects.get(name=o_id) except ManagedObject.DoesNotExist: return None
def get_user(self, u_id): """ Get User by id or name :param u_id: Object's id or name :return: ManagedObject :rtype: ManagedObject """ from noc.aaa.models.user import User # Try to get object by id if is_int(u_id): try: return User.objects.get(id=int(u_id)) except User.DoesNotExist: pass # Try to get object by name try: return User.objects.get(username=u_id) except User.DoesNotExist: return None