sc-napalm 1.0.0__py3-none-any.whl

custom_napalm/nos/nos.py

@@ -0,0 +1,230 @@
+from typing import Dict, List
+
+from ncclient import manager
+from ncclient.xml_ import to_ele
+from lxml import etree
+
+from napalm.base import NetworkDriver
+from napalm.base.exceptions import ConnectionException
+from napalm.base import models as napalm_models
+
+
+import logging
+
+from ..base import SCBaseNetconfDriver
+from .. import models as sc_models
+from . import constants as C
+from .constants import NS
+
+logger = logging.getLogger(__name__)
+
+
+class SCNOSDriver(NetworkDriver, SCBaseNetconfDriver):
+    """
+    Drivenets class is heavily based on Napalm IOSXR, which is
+    also a netconf/yang device.
+    """
+
+    netmiko_host_type = "linux"
+
+    def __init__(self, hostname, username, password, timeout=60, optional_args=None):
+        self.hostname = hostname
+        self.username = username
+        self.password = password
+        self.timeout = timeout
+        self.pending_changes = False
+        self.replace = False
+        self.locked = False
+        self.optional_args = optional_args if optional_args else {}
+        self.port = self.optional_args.pop("port", 830)
+        self.key_file = self.optional_args.pop("key_file", None)
+        if "ssh_config_file" in self.optional_args:
+            #    self.optional_args["ssh_config"] = self.optional_args["ssh_config_file"]
+            del self.optional_args["ssh_config_file"]
+
+        self.optional_args["hostkey_verify"] = False
+        self.device = None
+        self.NS = NS
+
+    def open(self):
+        """Open the connection with the device."""
+        try:
+            self.device = manager.connect(
+                host=self.hostname,
+                port=self.port,
+                username=self.username,
+                password=self.password,
+                key_filename=self.key_file,
+                timeout=self.timeout,
+                **self.optional_args,
+            )
+
+        except Exception as conn_err:
+            logger.error(conn_err.args[0])
+            raise ConnectionException(conn_err.args[0])
+
+    def close(self):
+        """Close the connection."""
+        logger.debug("Closed connection with device %s" % (self.hostname))
+        self.device.close_session()
+
+    def get_config(
+        self, retrieve="all", full=False, sanitized=False, format="text"
+    ) -> napalm_models.ConfigDict:
+        """
+        Get config adapted from iosxr_netconf driver. Note that there doesn't appear to
+        be a way to get a non-xml version of the config via netconf, so we're doing
+        in a separate SSH CLI session.
+        """
+
+        if sanitized:
+            raise NotImplementedError("Sanitized nos config not supported")
+        if format not in ["text", "xml"]:
+            raise NotImplementedError("Only XML and text config formats supported")
+
+        config = {"startup": "", "running": "", "candidate": ""}
+
+        # for text format we're going to SSH into the device and do 'show config'
+        # in this scenario 'candidate' isn't really relevant.
+        if format == "text":
+            with self.ssh_conn() as ssh_device:
+                config["running"] = ssh_device.send_command("show config")
+
+        # otherwise we're just doing netconf 'get-config'
+        else:
+            if retrieve.lower() in ["running", "all"]:
+                config["running"] = str(self.device.get_config(source="running").xml)
+            if retrieve.lower() in ["candidate", "all"]:
+                config["candidate"] = str(
+                    self.device.get_config(source="candidate").xml
+                )
+
+            for datastore in config:
+                if not config[datastore]:
+                    continue
+
+                config[datastore] = etree.tostring(
+                    etree.fromstring(config[datastore][0]),
+                    pretty_print=True,
+                    encoding="unicode",
+                )
+
+        return config
+
+    def get_facts(self) -> napalm_models.FactsDict:
+        """napalm get_facts"""
+        rpc_reply = self.device.dispatch(to_ele(C.FACTS_RPC_REQ)).xml
+        facts_xml = etree.fromstring(rpc_reply)
+
+        return {
+            "vendor": "Drivenets",
+            "os_version": self._text(facts_xml, "//dn-sys:system-version", default=""),
+            "hostname": self._text(facts_xml, "//dn-sys:name", default=""),
+            "uptime": self._text(facts_xml, "//dn-sys:system-uptime", default=-1.0),
+            "serial_number": self._text(
+                facts_xml, "//dn-platform:serial-number", default=""
+            ),
+            "fqdn": self._text(facts_xml, "//dn-sys-dns:domain-name", default=""),
+            "model": self._text(facts_xml, "//dn-sys:system-type", default=""),
+            "interface_list": [i.text for i in self._xpath(facts_xml, "//dn-if:name")],
+        }
+
+    def get_optics(self) -> Dict[str, napalm_models.OpticsDict]:
+        """napalm get_optics"""
+        rpc_reply = self.device.dispatch(to_ele(C.OPTICS_RPC_REQ)).xml
+        optics_xml = etree.fromstring(rpc_reply)
+
+        # print(etree.tostring(optics_xml, pretty_print=True, encoding="unicode"))
+
+        output = {}
+        for i in self._xpath(optics_xml, "//dn-if:interface"):
+            if not self._text(i, ".//dn-trans:transceiver-voltage"):
+                continue
+            i_name = self._text(i, "dn-if:name")
+            output[i_name] = {"physical_channels": {"channels": {}}}
+
+            i_channels = output[i_name]["physical_channels"]["channels"]
+            for c in self._xpath(i, ".//dn-trans:channel"):
+                if self._text(c, ".//dn-trans:receive-power"):
+                    i_channels[self._text(c, ".//dn-trans:lane")] = {
+                        "input_power": self._text(c, ".//dn-trans:receive-power"),
+                        "output_power": self._text(c, ".//dn-trans:transmit-power"),
+                        "laser_bias_current": self._text(
+                            c, ".//dn-trans:laser-bias-current"
+                        ),
+                    }
+
+        return output
+
+    def get_lldp_neighbors(self) -> Dict[str, List[napalm_models.LLDPNeighborDict]]:
+        """napalm get lldp neighbors"""
+        rpc_reply = self.device.dispatch(to_ele(C.LLDP_NEIGH_RPC_REQ)).xml
+        lldp_xml = etree.fromstring(rpc_reply)
+
+        # print(etree.tostring(lldp_xml, pretty_print=True, encoding="unicode"))
+
+        output = {}
+        for i in self._xpath(lldp_xml, "//dn-lldp:interface"):
+            if not self._xpath(i, ".//dn-lldp:system-name"):
+                continue
+            i_name = self._text(i, ".//dn-lldp:name")
+            output[i_name] = []
+
+            for n in self._xpath(i, ".//dn-lldp:neighbor"):
+                output[i_name].append(
+                    {
+                        "hostname": self._text(n, ".//dn-lldp:system-name"),
+                        "port": self._text(n, ".//dn-lldp:port-id"),
+                    }
+                )
+
+        return output
+
+    def get_inventory(self) -> List[sc_models.InventoryDict]:
+        """
+        sc-napalm get inventory
+        """
+        rpc_reply = self.device.dispatch(to_ele(C.INVENTORY_RPC_REQ)).xml
+        inv_xml = etree.fromstring(rpc_reply)
+        # print(etree.tostring(inv_xml, pretty_print=True, encoding="unicode"))
+
+        output = []
+        for i in self._xpath(inv_xml, "//dn-if:interface"):
+            if not self._xpath(i, ".//dn-trans:ethernet-pmd"):
+                continue
+
+            i_name = self._text(i, "//dn-if:name")
+            output.append(
+                {
+                    "type": "optic",
+                    "subtype": self._get_optic_subtype(i),
+                    "name": i_name,
+                    "part_number": self._text(i, ".//dn-trans:vendor-part").strip(),
+                    "serial_number": self._text(i, ".//dn-trans:serial-no").strip(),
+                }
+            )
+
+        return output
+
+    def _get_optic_subtype(self, i):
+        """
+        Optic subtypes are a bit tricky and sometimes have to be
+        inferred
+        """
+        # the ethernet-pmd attribute gives us an official
+        # 'transport type' which matches the data we want here
+        eth_pmd = self._text(i, ".//dn-trans:ethernet-pmd")
+        eth_pmd = eth_pmd.replace("dn-transport-types:", "")
+
+        # terrible assumptions - right now on the one nos switch I only
+        # see 'undefined' for 400G and 100G, wavelengths are all "1311"
+        if eth_pmd == "ETH_UNDEFINED":
+            speed = int(self._text(i, ".//dn-if:interface-speed")) / 1000
+            if self._text(i, ".//dn-trans:wavelength") == "1311":
+                return f"ETH_{int(speed)}GBASE-LR4"
+
+            raise ValueError(
+                f"ETH_UNDEFINED {i[0].text} speed {speed} WAVELENGTH {self._text(i, './/dn-trans:wavelength')}"
+            )
+
+        return eth_pmd

custom_napalm/nxos/__init__.py

@@ -0,0 +1 @@
+from .nxos import SCNXOS

custom_napalm/nxos/nxos.py

@@ -0,0 +1,88 @@
+from typing import List
+import logging
+
+from napalm.nxos_ssh import NXOSSSHDriver
+from napalm.base.helpers import textfsm_extractor
+
+from ..base import SCBaseDriver
+from ..models import (
+    InventoryDict,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class SCNXOS(NXOSSSHDriver, SCBaseDriver):
+    """
+    NXOS Parser
+    """
+
+    # for nexus we're going to map the 'description' provided by
+    # show inventory to the type
+    INVENTORY_TO_TYPE = {
+        # note we're using the fact that this dict gets evaluated
+        # sequentially to catch the linecards, whose descriptions are varied
+        # but all end in 'Module'
+        r"Fabric Module": "fabric_module",
+        r"Fabric card": "fabric_module",  # N7K fabric modules in umd
+        r"Fabric Extender": None,  # FEXes in Dearborn
+        r"N2K-C2": "stack_member",  # FEXes in Dearborn
+        r"Eth\s?Mod": None,  # chassis for fixed config Nexus
+        r"Supervisor Module": "re",
+        r"Fan Module": "fan",
+        r"Module": "linecard",
+        r"System Controller": None,
+        r"Chassis": None,
+        r"Power Supply": "psu",
+    }
+
+    I_ABBRS = {
+        "Lo": "loopback",
+        "Po": "port-channel",
+        "Eth": "Ethernet",
+    }
+
+    def get_inventory(self) -> List[InventoryDict]:
+        """
+        Parses "show inventory" and "show interface transciever"
+        """
+
+        raw_inventory = self._send_command("show inventory")
+        inventory = textfsm_extractor(self, "sh_inventory", raw_inventory)
+
+        output = []
+        for entry in inventory:
+            inventory_type = self._get_inventory_type(entry["desc"])
+            if not inventory_type:
+                continue
+
+            output.append(
+                {
+                    "type": inventory_type,
+                    "name": entry["name"],
+                    "part_number": entry["pid"],
+                    "serial_number": entry["sn"],
+                }
+            )
+
+        raw_trans = self._send_command("show interface transceiver")
+        trans = textfsm_extractor(self, "sh_int_transceiver", raw_trans)
+        for entry in trans:
+            if "AOC" in entry["type"]:
+                db_type = "aoc"
+            elif "DAC" in entry["type"]:
+                db_type = "dac"
+            else:
+                db_type = "optic"
+
+            output.append(
+                {
+                    "type": db_type,
+                    "subtype": entry["type"],
+                    "name": entry["interface"],
+                    "part_number": entry["pn"],
+                    "serial_number": entry["sn"],
+                }
+            )
+
+        return output

custom_napalm/nxos/utils/textfsm_templates/sh_int_transceiver.tpl

@@ -0,0 +1,27 @@
+Value Required INTERFACE (\S+)
+Value TYPE (\S+)
+Value PN (\S+)
+Value Required SN (\w+)
+
+Start
+  ^\S+ -> Continue.Record
+  ^${INTERFACE}$$
+  ^\s+type is ${TYPE}
+  ^\s+part number is ${PN}
+  ^\s+serial number is ${SN}
+
+
+#Ethernet1/101
+#    transceiver is present
+#    type is QSFP-100G-SR4
+#    name is FS
+#    part number is QSFP28-SR4-100G
+#    revision is 04
+#    serial number is G2240392123
+#    nominal bitrate is 25500 MBit/sec
+#    Link length supported for 50/125um OM3 fiber is 70 m
+#    cisco id is 17
+#    cisco extended id number is 220
+#
+#Ethernet1/102
+#    transceiver is not present

custom_napalm/nxos/utils/textfsm_templates/sh_inventory.tpl

@@ -0,0 +1,8 @@
+Value NAME (.+)
+Value DESC (.+)
+Value PID (\S*)
+Value SN (\S+)
+
+Start
+  ^NAME: "${NAME}",\s+DESCR: "${DESC}"
+  ^PID: ${PID}\s*,\s+VID:.*,\s+SN: ${SN} -> Record

custom_napalm/srl/__init__.py

@@ -0,0 +1 @@
+from .srl import SCNokiaSRLDriver

custom_napalm/srl/srl.py

@@ -0,0 +1,160 @@
+from napalm_srl import NokiaSRLDriver
+from napalm_srl.srl import SRLAPI
+from napalm.base import models as napalm_models
+from ..base import SCBaseNetconfDriver
+
+from ipaddress import IPv6Address
+
+from pprint import pprint
+
+
+class SCSLRAPI(SRLAPI):
+    """
+    This override fixes an issue with IPv6 addresses embedded in URLs when talking
+    over GRPCs. Not sure if it's moot with the various TLS
+    """
+
+    def __init__(self, hostname, username, password, timeout=60, optional_args=None):
+        super().__init__(hostname, username, password, timeout, optional_args)
+
+        try:
+            IPv6Address(hostname)
+            self.target = f"[{hostname}]:{self.gnmi_port}"
+        except ValueError:
+            pass
+
+
+class SCNokiaSRLDriver(NokiaSRLDriver, SCBaseNetconfDriver):
+    def __init__(self, hostname, username, password, timeout=60, optional_args=None):
+        """
+        Forcing insecure connection for testing purposes
+        """
+        optional_args = optional_args if optional_args else {}
+        optional_args["insecure"] = True
+        optional_args["skip_verify"] = True
+
+        optional_args["encoding"] = "JSON_IETF"
+
+        super().__init__(
+            hostname, username, password, timeout=timeout, optional_args=optional_args
+        )
+
+        self.device = SCSLRAPI(
+            hostname, username, password, timeout=timeout, optional_args=optional_args
+        )
+
+    def get_config(
+        self, retrieve="all", full=False, sanitized=False, format="text"
+    ) -> napalm_models.ConfigDict:
+        """
+        pulling running config via ssh sow we can have it in 'display set' format.
+        """
+        if format != "text":
+            return super().get_config(
+                retrieve=retrieve, full=full, sanitized=sanitized, format=format
+            )
+
+        config = {"startup": "", "running": "", "candidate": ""}
+
+        with self.ssh_conn() as ssh_device:
+            if retrieve in ["all", "running"]:
+                config["running"] = ssh_device.send_command("info from running flat")
+            if retrieve in ["all", "startup"]:
+                config["startup"] = ssh_device.send_command("info from startup flat")
+            if retrieve in ["all", "candidate"]:
+                config["candidate"] = ssh_device.send_command(
+                    "info from candidate flat"
+                )
+
+        return config
+
+    def get_optics(self):
+        path = {"/interface"}
+        path_type = "STATE"
+        output = self.device._gnmiGet("", path, path_type)
+        interfaces = self._getObj(
+            output, *["srl_nokia-interfaces:interface"], default=[]
+        )
+        channel_data = {}
+
+        for i in interfaces:
+            if not self._getObj(i, *["transceiver", "channel"], default=False):
+                continue
+
+            name = self._getObj(i, *["name"])
+            channel = self._getObj(i, *["transceiver", "channel"], default={})[0]
+            channel_data.update(
+                {
+                    name: {
+                        "physical_channels": {
+                            "channel": [
+                                {
+                                    "index": self._getObj(
+                                        channel, *["index"], default=-1
+                                    ),
+                                    "state": {
+                                        "input_power": {
+                                            "instant": self._getObj(
+                                                channel,
+                                                *["input-power", "latest-value"],
+                                                default=-1.0,
+                                            ),
+                                            "avg": -1.0,
+                                            "min": -1.0,
+                                            "max": -1.0,
+                                        },
+                                        "output_power": {
+                                            "instant": self._getObj(
+                                                channel,
+                                                *["output-power", "latest-value"],
+                                                default=-1.0,
+                                            ),
+                                            "avg": -1.0,
+                                            "min": -1.0,
+                                            "max": -1.0,
+                                        },
+                                        "laser_bias_current": {
+                                            "instant": self._getObj(
+                                                channel,
+                                                *["laser-bias-current", "latest-value"],
+                                                default=-1.0,
+                                            ),
+                                            "avg": -1.0,
+                                            "min": -1.0,
+                                            "max": -1.0,
+                                        },
+                                    },
+                                }
+                            ]
+                        }
+                    }
+                }
+            )
+
+        return channel_data
+
+    def get_inventory(self):
+        path = {"/interface/transceiver"}
+        path_type = "STATE"
+        output = self.device._gnmiGet("", path, path_type)
+        transceivers = self._getObj(
+            output, *["srl_nokia-interfaces:interface"], default=[]
+        )
+        result = []
+        for t_if in transceivers:
+            trans = t_if["transceiver"]
+
+            if "serial-number" not in trans:
+                continue
+
+            result.append(
+                {
+                    "type": "optic",
+                    "subtype": trans["ethernet-pmd"],
+                    "name": t_if["name"],
+                    "part_number": trans["vendor-part-number"],
+                    "serial_number": trans["serial-number"],
+                }
+            )
+
+        return result

custom_napalm/srl_ssh/__init__.py

@@ -0,0 +1 @@
+from .srl_ssh import NokiaSRLSSHDriver

custom_napalm/srl_ssh/srl_ssh.py

@@ -0,0 +1,45 @@
+from typing import Optional, Dict
+from napalm.base import NetworkDriver
+
+
+class NokiaSRLSSHDriver(NetworkDriver):
+    """
+    Netmiko based Nokia SRL driver :(
+    """
+
+    def __init__(
+        self,
+        hostname: str,
+        username: str,
+        password: str,
+        timeout: int = 60,
+        optional_args: Optional[Dict] = None,
+    ) -> None:
+        if optional_args is None:
+            optional_args = {}
+        self.hostname = hostname
+        self.username = username
+        self.password = password
+        self.timeout = timeout
+
+    def open(self):
+        self.device = self._netmiko_open("nokia_srl")
+
+    def close(self):
+        self._netmiko_close()
+
+    def send_command(self, cmd: str) -> str:
+        """
+        Sends command with netmiko and returns the result
+        """
+        return self.device.send_command(cmd)
+
+    def get_config(self, retrieve="all", full=False, sanitized=False, format="text"):
+        result = {"startup": "", "candidate": "", "running": ""}
+        if retrieve in ["all", "running"]:
+            result["running"] = self.send_command("info from running flat")
+        if retrieve in ["all", "startup"]:
+            result["startup"] = self.send_command("info from startup flat")
+        if retrieve in ["all", "candidate"]:
+            result["candidate"] = self.send_command("info from candidate flat")
+        return result

custom_napalm/sros/__init__.py

@@ -0,0 +1 @@
+from .sros import SCNokiaSROSDriver

custom_napalm/sros/nc_filters.py

@@ -0,0 +1,18 @@
+GET_INVENTORY = {
+    "_": """
+    <filter xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+        <state xmlns="urn:nokia.com:sros:ns:yang:sr:state">
+            <port>
+                <port-id/>
+                <transceiver>
+                    <vendor-part-number/>
+                    <model-number/>
+                    <vendor-serial-number/>
+                    <connector-type/>
+                    <type/>
+                </transceiver>
+            </port>
+        </state>
+    </filter>
+    """
+}

custom_napalm/sros/sros.py

@@ -0,0 +1,59 @@
+from napalm_sros import NokiaSROSDriver
+from napalm.base import models as napalm_models
+
+from lxml import etree
+from ncclient.xml_ import to_ele, to_xml
+
+from ..base import SCBaseNetconfDriver, sc_models
+from .nc_filters import GET_INVENTORY
+
+
+class SCNokiaSROSDriver(NokiaSROSDriver, SCBaseNetconfDriver):
+    netmiko_host_type = "alcatel_sros"
+
+    NS = {
+        "state": "urn:nokia.com:sros:ns:yang:sr:state",
+    }
+
+    def get_config(
+        self, retrieve="all", full=False, sanitized=False, format="text"
+    ) -> napalm_models.ConfigDict:
+        if format != "text":
+            return super().get_config(
+                retrieve=retrieve, full=full, sanitized=sanitized, format=format
+            )
+
+        config = {"startup": "", "running": "", "candidate": ""}
+
+        with self.ssh_conn() as ssh_device:
+            config["running"] = ssh_device.send_command("admin show configuration flat")
+            config["running"] += ssh_device.send_command(
+                "admin show configuration bof flat"
+            )
+
+        return config
+
+    def get_inventory(self) -> list[sc_models.InventoryDict]:
+        inv_xml = to_ele(
+            self.conn.get(
+                filter=GET_INVENTORY["_"], with_defaults="report-all"
+            ).data_xml
+        )
+        # print(etree.tostring(result, pretty_print=True, encoding="unicode"))
+
+        results = []
+        for i in self._xpath(inv_xml, ".//state:port"):
+            if not self._xpath(i, ".//state:transceiver"):
+                continue
+
+            results.append(
+                {
+                    "type": "optic",
+                    "subtype": self._text(i, ".//state:vendor-part-number").strip(),
+                    "name": self._text(i, ".//state:port-id"),
+                    "part_number": self._text(i, ".//state:model-number").strip(),
+                    "serial_number": self._text(i, ".//state:vendor-serial-number"),
+                }
+            )
+
+        return results