sc-napalm 1.0.0__py3-none-any.whl

custom_napalm/__init__.py

@@ -0,0 +1,30 @@
+from .iosxr import SCIOSXR
+from .junos import SCJunOS
+from .nxos import SCNXOS
+from .sros import SCNokiaSROSDriver
+from .srl_ssh import NokiaSRLSSHDriver
+from .srl import SCNokiaSRLDriver
+from .eos import SCEOSDriver
+from .nos import SCNOSDriver
+
+PLATFORM_MAP = {
+    "iosxr": SCIOSXR,
+    "nxos": SCNXOS,
+    "junos": SCJunOS,
+    "sros": SCNokiaSROSDriver,
+    "srl_ssh": NokiaSRLSSHDriver,
+    "srl": SCNokiaSRLDriver,
+    "eos": SCEOSDriver,
+    "nos": SCNOSDriver,
+}
+
+
+def get_network_driver(platform: str):
+    """
+    Returns network driver based on platform string.
+    """
+    for valid_platform, driver in PLATFORM_MAP.items():
+        if valid_platform == platform:
+            return driver
+
+    raise NotImplementedError(f"Unsupported platform {platform}")

custom_napalm/base.py

@@ -0,0 +1,113 @@
+from typing import Dict, List
+import re
+from napalm.base import models as napalm_models
+from netmiko import ConnectHandler
+
+from . import models as sc_models
+
+
+class SCBaseDriver:
+    """
+    Base class that all children should inherit
+    """
+
+    # populate in child classes
+    INVENTORY_TO_TYPE = {}
+
+    def _get_inventory_type(self, name: str) -> str:
+        """
+        Maps the name of the inventory item to its type
+        """
+        for pattern, inv_type in self.INVENTORY_TO_TYPE.items():
+            if inv_type and inv_type not in sc_models.VALID_INVENTORY_TYPES.__args__:
+                raise TypeError(f"Invalid Inventory type {inv_type}")
+            if re.search(pattern, name):
+                return inv_type
+
+        raise ValueError(f"Unknown inventory item {name}")
+
+    def get_config(self) -> napalm_models.ConfigDict:
+        """napalm get config"""
+        raise NotImplementedError
+
+    def get_facts(self) -> napalm_models.FactsDict:
+        """napalm get facts"""
+        raise NotImplementedError
+
+    def get_optics(self) -> Dict[str, napalm_models.OpticsDict]:
+        """napalm get optics"""
+        raise NotImplementedError
+
+    def get_lldp_neighbors(self) -> Dict[str, List[napalm_models.LLDPNeighborDict]]:
+        """napalm get lldp neighbors"""
+        raise NotImplementedError
+
+    def get_inventory(self) -> List[sc_models.InventoryDict]:
+        """sc get inventory"""
+        raise NotImplementedError
+
+
+class SCBaseNetconfDriver(SCBaseDriver):
+    """
+    Inclues some helper xml functions
+    """
+
+    netmiko_host_type = "linux"
+
+    def ssh_conn(self) -> ConnectHandler:
+        """
+        Ugly workaround for getting stuff via the cli over ssh.
+        Starts a netmiko ssh connection handler and returns it,
+        allowing you to interact with the CLI of the device.
+        """
+        optional_args = {}
+        if getattr(self, "optional_args", False):
+            optional_args = self.optional_args if self.optional_args else {}
+
+        args = {
+            "device_type": self.netmiko_host_type,
+            "host": self.hostname,
+            "username": self.username,
+            "password": self.password,
+            "ssh_config_file": optional_args.get("ssh_config", None),
+        }
+        return ConnectHandler(**args)
+
+    def _find_txt(self, xml_tree, path, default=None, namespaces=None):
+        """
+        Stolen from the napalm iosxr driver
+        Extract the text value from a leaf in an XML tree using XPath.
+
+        Will return a default value if leaf path not matched.
+        :param xml_tree:the XML Tree object. <type'lxml.etree._Element'>.
+        :param path: XPath to be applied in order to extract the desired data.
+        :param default:  Value to be returned in case of a no match.
+        :param namespaces: namespace dictionary.
+        :return: a str value or None if leaf path not matched.
+        """
+        value = None
+        xpath_applied = xml_tree.xpath(path, namespaces=namespaces)
+
+        if xpath_applied:
+            if not len(xpath_applied[0]):
+                if xpath_applied[0].text is not None:
+                    value = xpath_applied[0].text.strip()
+                else:
+                    value = ""
+        else:
+            value = default
+
+        return value
+
+    # Helper xml methods that always pass in our namespaces by default
+    def _text(self, xml_tree, path, default=None):
+        return self._find_txt(xml_tree, path, default, namespaces=self.NS)
+
+    def _xpath(self, xml_tree, path):
+        return getattr(xml_tree, "xpath")(path, namespaces=self.NS)
+
+    def _find(self, xml_tree, element):
+        return getattr(xml_tree, "find")(element, namespaces=self.NS)
+
+    def _iterfind(self, xml_tree, element):
+        return getattr(xml_tree, "iterfind")(element, namespaces=self.NS)

custom_napalm/eos/__init__.py

@@ -0,0 +1 @@
+from .eos import SCEOSDriver

custom_napalm/eos/eos.py

@@ -0,0 +1,93 @@
+from typing import List
+from napalm.eos import EOSDriver
+from ..base import SCBaseDriver
+from ..models import InventoryDict
+
+
+class SCEOSDriver(EOSDriver, SCBaseDriver):
+    ("fabric_module",)
+    ("fan",)
+    ("linecard",)
+    ("optic",)
+    ("psu",)
+    ("re",)
+    ("stack_cable",)
+    ("stack_member",)
+    ("uplink_module",)
+    ("aoc",)
+    ("dac",)
+
+    INVENTORY_TO_TYPE = {
+        r"Fabric": "fabric_module",
+        r"Linecard": "linecard",
+        r"Supervisor": "re",
+    }
+
+    def __init__(self, hostname, username, password, timeout=60, optional_args=None):
+        """
+        Forcing ssh transport since we don't enable the web interface
+        """
+        optional_args = optional_args if optional_args else {}
+        optional_args["transport"] = "ssh"
+
+        super().__init__(
+            hostname, username, password, timeout=timeout, optional_args=optional_args
+        )
+
+    def get_inventory(self) -> List[InventoryDict]:
+        inventory = self._run_commands(["show inventory"], encoding="json")
+
+        results = []
+
+        ### optics
+        for slot, optic in inventory[0]["xcvrSlots"].items():
+            if optic.get("modelName"):
+                results.append(
+                    {
+                        "type": "optic",
+                        "subtype": optic["modelName"],
+                        "name": f"Ethernet{slot}",
+                        "part_number": optic["modelName"],
+                        "serial_number": optic["serialNum"],
+                    },
+                )
+
+        ### line cards
+        for slot, card in inventory[0]["cardSlots"].items():
+            if card.get("serialNum"):
+                results.append(
+                    {
+                        "type": self._get_inventory_type(slot),
+                        "subtype": card["modelName"],
+                        "name": f"Ethernet{slot}",
+                        "part_number": card["modelName"],
+                        "serial_number": card["serialNum"],
+                    },
+                )
+
+        ### PSUs
+        for slot, psu in inventory[0]["powerSupplySlots"].items():
+            if psu.get("serialNum"):
+                results.append(
+                    {
+                        "type": "psu",
+                        "subtype": None,
+                        "name": f"PSU {slot}",
+                        "part_number": psu["name"],
+                        "serial_number": psu["serialNum"],
+                    },
+                )
+
+        ### FANs
+        for slot, fan in inventory[0]["fanTraySlots"].items():
+            if fan.get("serialNum"):
+                results.append(
+                    {
+                        "type": "fan",
+                        "subtype": None,
+                        "name": f"FAN {slot}",
+                        "part_number": fan["name"],
+                        "serial_number": fan["serialNum"],
+                    },
+                )
+        return results

custom_napalm/get.py

@@ -0,0 +1,83 @@
+import argparse
+from pprint import pprint
+
+from napalm import get_network_driver
+
+from custom_napalm import PLATFORM_MAP
+from custom_napalm.base import SCBaseDriver
+from custom_napalm.utils import configure_logging, LOG_LEVELS, get_from_args_or_env
+
+# list of getters to run
+GETTERS = [attr for attr in SCBaseDriver.__dict__ if attr.startswith("get")]
+
+cred_args = {"sc_username": True, "sc_password": True}
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="""
+Run a specific sc_napalm "getter" against a device.
+"""
+    )
+    parser.add_argument("device", help="device hostname or IP address")
+    parser.add_argument(
+        "sc_napalm_platform",
+        choices=PLATFORM_MAP,
+        help="The platform of this device",
+    )
+    parser.add_argument(
+        "cmd",
+        choices=GETTERS,
+        help="The getter command to run against this device",
+    )
+    parser.add_argument("--ssh-cfg", help="Use SSH config file to connect", type=str)
+    log_args = parser.add_mutually_exclusive_group()
+    log_args.add_argument(
+        "-l", "--log-level", help="Set log level for sc_napalm only", choices=LOG_LEVELS
+    )
+    log_args.add_argument(
+        "-L", "--LOG-LEVEL", help="set global log level", choices=LOG_LEVELS
+    )
+    parser.add_argument(
+        "--logfile",
+        type=str,
+        help="Save logging to a file (specified by name) instead of to stdout",
+    )
+
+    for cred_arg in cred_args:
+        parser.add_argument(f"--{cred_arg}", help="Specify credentials")
+    args = parser.parse_args()
+
+    log_level = args.log_level if args.log_level else args.LOG_LEVEL
+    if log_level:
+        configure_logging(
+            log_level,
+            log_globally=bool(args.LOG_LEVEL),
+            log_file=args.logfile,
+            log_to_console=not (bool(args.logfile)),
+        )
+
+    creds = {
+        cred: get_from_args_or_env(cred, args, required=reqd)
+        for cred, reqd in cred_args.items()
+    }
+    Driver = get_network_driver(args.sc_napalm_platform)
+
+    # setting up connection details
+    optional_args = {"look_for_keys": False}
+    if args.ssh_cfg:
+        optional_args = {"ssh_config_file": args.ssh_cfg}
+
+    with Driver(
+        args.device,
+        creds["sc_username"],
+        creds["sc_password"],
+        timeout=60,
+        optional_args=optional_args,
+    ) as conn:
+        result = getattr(conn, args.cmd)()
+        pprint(result)
+
+
+if __name__ == "__main__":
+    main()

custom_napalm/iosxr/__init__.py

@@ -0,0 +1 @@
+from .iosxr import SCIOSXR

custom_napalm/iosxr/constants.py

@@ -0,0 +1,144 @@
+NS = {
+    "int": "http://cisco.com/ns/yang/Cisco-IOS-XR-pfi-im-cmd-oper",
+    "int4": "http://cisco.com/ns/yang/Cisco-IOS-XR-ipv4-io-oper",
+    "int6": "http://cisco.com/ns/yang/Cisco-IOS-XR-ipv6-ma-oper",
+    "rib4": "http://cisco.com/ns/yang/Cisco-IOS-XR-ip-rib-ipv4-oper",
+    "rib6": "http://cisco.com/ns/yang/Cisco-IOS-XR-ip-rib-ipv6-oper",
+    "inv": "http://cisco.com/ns/yang/Cisco-IOS-XR-invmgr-oper",
+}
+
+
+IP_INT_RPC_REQ = """
+<get xmlns="urn:ietf:params:xml:ns:netconf:base:1.1">
+  <filter>
+    <interfaces xmlns="http://cisco.com/ns/yang/Cisco-IOS-XR-pfi-im-cmd-oper">
+      <interfaces>
+        <interface/>
+      </interfaces>
+    </interfaces>
+    <ipv4-network xmlns="http://cisco.com/ns/yang/Cisco-IOS-XR-ipv4-io-oper">
+      <nodes>
+        <node>
+          <interface-data>
+            <vrfs>
+              <vrf>
+                <details>
+                  <detail/>
+                </details>
+              </vrf>
+            </vrfs>
+          </interface-data>
+        </node>
+      </nodes>
+    </ipv4-network>
+    <ipv6-network xmlns="http://cisco.com/ns/yang/Cisco-IOS-XR-ipv6-ma-oper">
+      <nodes>
+        <node>
+          <interface-data>
+            <vrfs>
+              <vrf>
+                <global-details>
+                  <global-detail/>
+                </global-details>
+              </vrf>
+            </vrfs>
+          </interface-data>
+        </node>
+      </nodes>
+    </ipv6-network>
+  </filter>
+</get>"""
+
+IP_ROUTE_RPC_REQ = """
+<get xmlns="urn:ietf:params:xml:ns:netconf:base:1.1">
+  <filter>
+    <rib xmlns="http://cisco.com/ns/yang/Cisco-IOS-XR-ip-rib-ipv4-oper">
+      <vrfs>
+        <vrf>
+          <afs>
+            <af>
+              <af-name>IPv4</af-name>
+              <safs>
+                <saf>
+                  <saf-name>Unicast</saf-name>
+                  <ip-rib-route-table-names>
+                    <ip-rib-route-table-name>
+                      <route-table-name>default</route-table-name>
+                      <routes>
+                        <route>
+                          <prefix-length/>
+                          <protocol-name/>
+                          <route-age/>
+                          <route-path>
+                            <active>true</active>
+                          </route-path>
+                        </route>
+                      </routes>
+                    </ip-rib-route-table-name>
+                  </ip-rib-route-table-names>
+                </saf>
+              </safs>
+            </af>
+          </afs>
+        </vrf>
+      </vrfs>
+    </rib>
+  
+    <ipv6-rib xmlns="http://cisco.com/ns/yang/Cisco-IOS-XR-ip-rib-ipv6-oper">
+      <vrfs>
+        <vrf>
+          <afs>
+            <af>
+              <af-name>IPv6</af-name>
+              <safs>
+                <saf>
+                  <saf-name>Unicast</saf-name>
+                  <ip-rib-route-table-names>
+                    <ip-rib-route-table-name>
+                      <route-table-name>default</route-table-name>
+                      <routes>
+                        <route>
+                          <prefix-length/>
+                          <protocol-name/>
+                          <route-age/>
+                          <route-path>
+                            <active>true</active>
+                          </route-path>
+                        </route>
+                      </routes>
+                    </ip-rib-route-table-name>
+                  </ip-rib-route-table-names>
+                </saf>
+              </safs>
+            </af>
+          </afs>
+        </vrf>
+      </vrfs>
+    </ipv6-rib>
+
+  </filter>
+</get>
+"""
+
+INV_RPC_REQ = """
+<get xmlns="urn:ietf:params:xml:ns:netconf:base:1.1">
+  <filter>
+    <inventory xmlns="http://cisco.com/ns/yang/Cisco-IOS-XR-invmgr-oper">
+      <entities>
+        <entity>
+          <attributes>
+            <inv-basic-bag>
+              <description/>
+              <name/>
+              <serial-number/>
+              <manufacturer-name/>
+              <model-name/>
+              <is-field-replaceable-unit>true</is-field-replaceable-unit>
+            </inv-basic-bag>
+          </attributes>
+        </entity>
+      </entities>
+    </inventory>
+  </filter>
+</get>
+"""

custom_napalm/iosxr/iosxr.py

@@ -0,0 +1,55 @@
+from typing import List
+import logging
+
+from lxml import etree
+
+from napalm.iosxr_netconf import IOSXRNETCONFDriver
+from ncclient.xml_ import to_ele
+
+from ..base import SCBaseNetconfDriver
+from ..models import InventoryDict
+
+from .constants import INV_RPC_REQ
+
+logger = logging.getLogger(__name__)
+
+
+class SCIOSXR(IOSXRNETCONFDriver, SCBaseNetconfDriver):
+    """
+    IOSXR Class
+    """
+
+    INVENTORY_TO_TYPE = {
+        r"PM\d+$": "psu",
+        r"FT\d+$": "fan",
+        r"FC\d+$": "fabric_module",
+        r"RP\d$": "re",
+        r"SC\d": None,  # don't care about system controller
+        r"Rack 0": None,  # this is the chassis, don't care about it
+        r"^(FourHundred|Hundred|Forty)GigE": "optic",
+        r"\d/\d": "linecard",
+    }
+
+    def get_inventory(self) -> List[InventoryDict]:
+        """
+        Gets inventory data
+        """
+        rpc_reply = self.device.dispatch(to_ele(INV_RPC_REQ)).xml
+        xml_result = etree.fromstring(rpc_reply)
+
+        output = []
+        for item in self._xpath(xml_result, "//inv:inv-basic-bag"):
+            name = self._text(item, "inv:name")
+            item_type = self._get_inventory_type(name)
+            if item_type:
+                output.append(
+                    {
+                        "type": item_type,
+                        "name": name,
+                        "part_number": self._text(item, "inv:model-name"),
+                        "serial_number": self._text(item, "inv:serial-number"),
+                        "parent": None,
+                    }
+                )
+
+        return output

custom_napalm/junos/__init__.py

@@ -0,0 +1 @@
+from .junos import SCJunOS