update netconf refactor task class inheritance

Author: jtdub

netnir/__init__.py

@@ -3,4 +3,4 @@
 netnir will create the default config and folders.
 """
 
-__version__ = "0.0.14"
+__version__ = "0.0.15"

netnir/core/inventory.py

@@ -66,7 +66,9 @@ def nhosts(self):
                         "hostname": f"{host}.{domain}" if domain else host,
                         "username": host_vars.get("username", creds["username"]),
                         "password": host_vars.get("password", creds["password"]),
-                        "platform": host_vars.get("os"),
+                        "platform": device_mapper(
+                            os_type=host_vars["os"], proto="netconf"
+                        ),
                         "port": host_vars.get("port", 830),
                         "extras": {"hostkey_verify": False},
                     },

netnir/core/tasks/__init__.py

@@ -1,2 +1 @@
-"""built-in tasks initialization
-"""
+"""built-in tasks initialization"""

netnir/core/tasks/config_plan.py

@@ -1,9 +1,8 @@
-from netnir.constants import NR
+from netnir.helpers.scaffold.command import CommandScaffold
 from netnir.core.template import CompileTemplate
 from netnir.core.networking import Networking
 from netnir.helpers import output_writer, TextColor
 from netnir.plugins.hier import hier_host
-from netnir.helpers.common.args import filter_host
 from netnir.constants import OUTPUT_DIR
 from nornir.plugins.functions.text import print_result
 import logging
@@ -13,30 +12,21 @@
 """
 
 
-class ConfigPlan:
+class ConfigPlan(CommandScaffold):
     """
     config plan cli plugin to render configuration plans, either by
     compiling from template or using hier_config to create a remediation
     plan
-
-    :params args: type obj
     """
 
-    def __init__(self, args):
-        """
-        initialize the config plan class
-        """
-        self.args = args
-        self.nr = NR
-
     @staticmethod
     def parser(parser):
         """
         cli options parser
 
         :params parser: type obj
         """
-        filter_host(parser)
+        CommandScaffold.parser(parser)
         parser.add_argument(
             "--compile",
             nargs="?",
@@ -65,26 +55,16 @@ def run(self, template_file="main.conf.j2"):
 
         :returns: result string
         """
-        if self.args.host:
-            self.nr = self.nr.filter(name=self.args.host)
+        self.nr = self._inventory()
 
+        for host in self.nr.inventory.hosts:
             compiled_template = CompileTemplate(
-                nr=self.nr, host=self.args.host, template=template_file
+                nr=self.nr, host=host, template=template_file
             )
             output_writer(
-                nornir_results=compiled_template.render(), output_file="compiled.conf"
+                nornir_results=compiled_template.render(), output_file="compiled.conf",
             )
             print_result(compiled_template.render())
-        else:
-            for host in self.nr.inventory.hosts:
-                compiled_template = CompileTemplate(
-                    nr=self.nr, host=host, template=template_file
-                )
-                output_writer(
-                    nornir_results=compiled_template.render(),
-                    output_file="compiled.conf",
-                )
-                print_result(compiled_template.render())
 
         if self.args.compile:
             if self.args.host:

netnir/core/tasks/fetch/config.py

@@ -1,38 +1,24 @@
-from netnir.helpers.common.args import (
-    filter_host,
-    filter_group,
-    filter_hosts,
-    num_workers,
-)
-from netnir.helpers import filter_type, inventory_filter, output_writer
+from netnir.helpers.scaffold.command import CommandScaffold
+from netnir.helpers.common.args import num_workers
+from netnir.helpers import output_writer
 from netnir.core.networking import Networking
-from netnir.constants import NR
 from nornir.plugins.functions.text import print_result
 
-"""fetch remove device configs
-"""
+"""fetch remove device configs"""
 
 
-class FetchConfig:
+class FetchConfig(CommandScaffold):
     """
     cli command to fetch remote device configs via nornir's netmiko_show_command plugin
     """
 
-    def __init__(self, args):
-        """initialize the class
-        """
-        self.args = args
-        self.nr = NR
-
     @staticmethod
     def parser(parser):
         """cli command parser
 
         :param parser: type obj
         """
-        filter_host(parser)
-        filter_group(parser)
-        filter_hosts(parser)
+        CommandScaffold.parser(parser)
         num_workers(parser)
 
     def run(self):
@@ -41,12 +27,7 @@ def run(self):
         :return: nornir results
         """
 
-        device_filter = filter_type(
-            host=self.args.host, filter=self.args.filter, group=self.args.group
-        )
-        self.nr = inventory_filter(
-            nr=self.nr, device_filter=device_filter["data"], type=device_filter["type"]
-        )
+        self.nr = self._inventory()
         networking = Networking(nr=self.nr, num_workers=self.args.workers)
         results = networking.fetch(commands="show running")
         output_writer(nornir_results=results, output_file="running.conf")

netnir/core/tasks/netconf.py

@@ -1,19 +1,51 @@
 from netnir.helpers.scaffold.command import CommandScaffold
+from netnir.helpers.common.args import (
+    netconf_config,
+    netconf_filter,
+    netconf_source,
+    netconf_target,
+    config,
+)
 
 
 class NetConf(CommandScaffold):
     """netconf commands"""
 
+    @staticmethod
+    def parser(parser):
+        CommandScaffold.parser(parser)
+        netconf_config(parser)
+        netconf_filter(parser)
+        netconf_source(parser)
+        netconf_target(parser)
+        config(parser)
+
     def run(self):
         """execute netconf commands
 
         :returns: nornir Result object
         """
-        from netnir.plugins.netconf import netconf_get
+        from netnir.plugins.netconf import netconf_get_config, netconf_edit_config
         from nornir.plugins.functions.text import print_result
 
         self.nr = self._inventory()
-        results = self.nr.run(task=netconf_get, name="NETCONF GET CONFIG AND STATE")
+
+        if self.args.config:
+            results = self.nr.run(
+                task=netconf_edit_config,
+                name="NETCONF EDIT CONFIG",
+                target=self.args.target,
+                nc_config=self.args.nc_config,
+            )
+        else:
+            results = self.nr.run(
+                task=netconf_get_config,
+                source=self.args.source,
+                name="NETCONF GET FILTERED CONFIG",
+                nc_filter_type=self.args.nc_filter,
+                nc_filter=self.args.nc_config,
+            )
+
         print_result(results)
 
         return results

netnir/core/tasks/ssh.py

@@ -1,72 +1,41 @@
-from netnir.constants import NR
+from netnir.helpers.scaffold.command import CommandScaffold
 from netnir.core.networking import Networking
-from netnir.helpers import output_writer, filter_type, inventory_filter
+from netnir.helpers import output_writer
 from netnir.helpers.common.args import (
-    filter_host,
-    filter_hosts,
-    filter_group,
     output,
     num_workers,
+    commands,
+    config,
 )
 from nornir.plugins.functions.text import print_result
 import sys
 
-"""ssh cli commands
-"""
+"""ssh cli commands"""
 
 
-class Ssh:
+class Ssh(CommandScaffold):
     """
     cli command to execute show and config commands via SSH
-
-    :params args: type obj
     """
 
-    def __init__(self, args):
-        """
-        initialize the ssh class
-        """
-        self.args = args
-        self.nr = NR
-
     @staticmethod
     def parser(parser):
         """
         cli command parser
         """
-        filter_host(parser)
-        filter_group(parser)
-        filter_hosts(parser)
+        CommandScaffold.parser(parser)
         output(parser)
         num_workers(parser)
-
-        parser.add_argument(
-            "--commands",
-            "-c",
-            help="commands to execute",
-            action="append",
-            required=False,
-        )
-        parser.add_argument(
-            "--config",
-            help="execute commands in config mode",
-            required=False,
-            nargs="?",
-            const=True,
-        )
+        commands(parser)
+        config(parser)
 
     def run(self):
         """
         cli command execution
         """
 
-        device_filter = filter_type(
-            host=self.args.host, filter=self.args.filter, group=self.args.group
-        )
-        hosts = inventory_filter(
-            self.nr, device_filter=device_filter["data"], type=device_filter["type"]
-        )
-        networking = Networking(nr=hosts, num_workers=self.args.workers,)
+        self.nr = self._inventory()
+        networking = Networking(nr=self.nr, num_workers=self.args.workers,)
 
         if self.args.config:
             results = networking.config(self.args.commands)

netnir/helpers/__init__.py

@@ -9,23 +9,43 @@
 """
 
 
-def device_mapper(os_type: str):
+def device_mapper(os_type: str, proto: str = "netmiko"):
     """
     map an os type to a netmiko device_type
 
-    :param os_type: type str
+    :params os_type: type str
+    :params proto: type str, default "netmiko"
 
-    :return: device_type string
+    :returns: device_type string
     """
-    device_types = {
-        "ios": "cisco_ios",
-        "iosxr": "cisco_xr",
-        "iosxe": "cisco_xe",
-        "nxos": "cisco_nxos",
-        "eos": "arista_eos",
-    }
-
-    return device_types[os_type]
+    if proto == "netmiko":
+        device_types = {
+            "ios": "cisco_ios",
+            "iosxr": "cisco_xr",
+            "iosxe": "cisco_xe",
+            "nxos": "cisco_nxos",
+            "eos": "arista_eos",
+        }
+        try:
+            result = device_types[os_type]
+        except KeyError:
+            return os_type
+    elif proto == "netconf":
+        device_types = {
+            "csr": "csr",
+            "iosxr": "iosxr",
+            "iosxe": "iosxe",
+            "nxos": "nexus",
+            "junos": "junos",
+        }
+        try:
+            result = device_types[os_type]
+        except KeyError:
+            return "default"
+    else:
+        result = os_type
+
+    return result
 
 
 def render_filter(pattern: list):