nornir-collection 0.0.1__py3-none-any.whl

nornir_collection/cisco/configuration_management/netconf/ops_tasks.py

@@ -0,0 +1,307 @@
+#!/usr/bin/env python3
+"""
+This module contains the Nornir NETCONF operation RPC tasks lock, validate, discard, commit and unlock.
+NETCONF RPC tasks like get-config or edit-config are not part of this module. Please take a look to
+the module config_tasks for these tasks.
+
+The functions are ordered as followed:
+- Nornir NETCONF tasks
+- Nornir NETCONF tasks in regular function
+"""
+
+import traceback
+from typing import Literal
+from nornir.core import Nornir
+from nornir.core.task import Task, Result
+from nornir_collection.utils import print_result
+
+
+#### Nornir NETCONF Tasks ###################################################################################
+
+
+def nc_ops_rpc(  # pylint: disable=too-many-arguments,invalid-name,too-many-branches
+    task: Task,
+    rpc: Literal["lock", "validate", "discard", "commit", "unlock"],
+    datastore: Literal["candidate", "running"] = "candidate",
+    confirm: bool = False,
+    confirm_timeout: int = 300,
+    verbose: bool = False,
+) -> Result:
+    """
+    This function is a Nornir Task using Scrapli to run a NETCONF RPC operation. The `rpc` argument
+    specifies the NETCONF operation to perform. The `datastore` argument specifies the NETCONF datastore
+    to perform the operation on. The `confirm` argument specifies if the commit operation should be
+    confirm. The `confirm_timeout` argument sets the timeout period for the commit-confirm operation.
+    The `verbose` argument sets the verbosity level of the result output.
+    """
+    # Track if the overall task has failed
+    failed = False
+
+    # Verify that the rpc argument is valid
+    if rpc not in ("lock", "validate", "discard", "commit", "unlock"):
+        result = (
+            f"'{task.name}' -> NetconfResponse <Success: False>\n"
+            + f"-> ValueError: '{rpc}' is not a supported NETCONF RPC"
+        )
+        return Result(host=task.host, result=result, changed=False, failed=True)
+
+    # Get the Scrapli Netconf connection manually
+    scrapli_conn = task.host.get_connection("scrapli_netconf", task.nornir.config)
+    scrapli_conn.open()
+
+    try:
+        if rpc == "lock":
+            nc_result = scrapli_conn.lock(target=datastore)
+        elif rpc == "unlock":
+            nc_result = scrapli_conn.unlock(target=datastore)
+        elif rpc == "validate":
+            nc_result = scrapli_conn.validate(source=datastore)
+        elif rpc == "discard":
+            nc_result = scrapli_conn.discard()
+        elif rpc == "commit":
+            if confirm:
+                # Set a "bare" NETCONF commit-confirm string
+                filter_commit_confirm = (
+                    "<commit>\n"
+                    "  <confirmed/>\n"
+                    f"  <confirm-timeout>{confirm_timeout}</confirm-timeout>\n"
+                    "</commit>"
+                )
+                nc_result = scrapli_conn.rpc(filter_=filter_commit_confirm)
+
+            else:
+                nc_result = scrapli_conn.commit()
+
+    except Exception:  # pylint: disable=broad-exception-caught # nosec
+        result = (
+            f"'{task.name}' -> NetconfResponse <Success: False>\n"
+            + "-> Configuration attempt failed\n"
+            + f"\n{traceback.format_exc()}"
+        )
+        return Result(host=task.host, result=result, changed=False, failed=True)
+
+    # No Exception -> Continue to return the result
+    ########################################### WORKAROUND ##################################################
+    ### It seems that since 17.12.4 the NETCONF server implementation has a bug !                         ###
+    ### If the database is locked by 'yang_mgmt_infra' or 'system system', the NETCONF rpc reply failed   ###
+    ### The rpc reply contains one of the following errors:                                               ###
+    ### - the configuration database is locked by session 20 yang_mgmt_infra tcp (system from 127.0.0.1)  ###
+    ### - the configuration database is locked by session 238 system system (system from 0.0.0.0)         ###
+    ### -> So we don't set the task as failed if this error occurs, as the configuration is still applied ###
+    #########################################################################################################
+    # Exclude the 'yang_mgmt_infra' and 'system system' locked database error
+    if "database is locked by" in str(nc_result.result):
+        if any(x in str(nc_result.result) for x in ["yang_mgmt_infra", "system system"]):
+            pass
+        else:
+            failed = True
+    # Else if the result XML payload dont't contain '<ok/>', the NETCONF rpc reply failed
+    elif "<ok/>" not in str(nc_result.result):
+        failed = True
+
+    # Set the task result
+    result = f"'{task.name}' -> {str(nc_result)}"
+    # Add more details to the task result
+    if rpc == "commit" and confirm and not failed:
+        result += f"\n-> NETCONF commit-confirm timeout period is set to {confirm_timeout}s"
+    if failed or verbose:
+        if confirm:
+            result += f"\n\n{filter_commit_confirm}"
+        result += f"\n\n{nc_result.result}"
+
+    # Set changed for the Nornir print result
+    changed = not failed
+
+    return Result(host=task.host, result=result, changed=changed, failed=failed)
+
+
+#### Nornir NETCONF Tasks in regular Function ###############################################################
+
+
+def nc_lock(
+    nr: Nornir,
+    datastore: Literal["candidate", "running"] = "candidate",
+    cfg_status: bool = True,
+    verbose: bool = False,
+) -> bool:
+    """
+    This function uses Nornir to run a NETCONF lock operation on the specified datastore using Scrapli.
+    If the `cfg_status` argument is set to False, the function will immediately return False without
+    performing any operations, in order to skip the NETCONF lock operation.
+    """
+    # pylint: disable=invalid-name
+
+    # Return False if cfg_status argument is False
+    if not cfg_status:
+        return False
+
+    # Lock the NETCONF datastore with Scrapli netconf_lock
+    nc_result = nr.run(
+        name="NETCONF lock datastore",
+        task=nc_ops_rpc,
+        rpc="lock",
+        datastore=datastore,
+        verbose=verbose,
+        on_failed=True,
+    )
+
+    # Print the result
+    print_result(result=nc_result)
+
+    # If the task failed -> nc_result.failed is True. So return False if nc_result.failed is True
+    if nc_result.failed:
+        cfg_status = False
+
+    return cfg_status
+
+
+def nc_validate(
+    nr: Nornir,
+    datastore: Literal["candidate", "running"] = "candidate",
+    cfg_status: bool = True,
+    verbose: bool = False,
+) -> bool:
+    """
+    This function uses Nornir to run a NETCONF validate operation on the specified datastore using Scrapli.
+    If the `cfg_status` argument is set to False, the function will immediately return False without
+    performing any operations, in order to skip the NETCONF validate operation.
+    """
+    # pylint: disable=invalid-name
+
+    # Return False if cfg_status argument is False
+    if not cfg_status:
+        return False
+
+    # Lock the NETCONF datastore with Scrapli netconf_validate
+    nc_result = nr.run(
+        name="NETCONF validate datastore",
+        task=nc_ops_rpc,
+        rpc="validate",
+        datastore=datastore,
+        verbose=verbose,
+        on_failed=True,
+    )
+
+    # Print the result
+    print_result(result=nc_result)
+
+    # If the task failed -> nc_result.failed is True. So return False if nc_result.failed is True
+    if nc_result.failed:
+        cfg_status = False
+
+    return cfg_status
+
+
+def nc_commit(
+    nr: Nornir,
+    confirm: bool = False,
+    confirm_timeout: int = 300,
+    cfg_status: bool = True,
+    verbose: bool = False,
+) -> bool:
+    """
+    This function uses Nornir to run a NETCONF commit operation using Scrapli. Optionally, the function
+    can perform a commit-confirm operation by setting the `confirm` argument to True. The
+    `confirm_timeout` argument sets the timeout period for the commit-confirm operation. If the
+    `cfg_status` argument is set to False, the function will immediately return False without performing
+    any operations, in order to skip the NETCONF commit operation.
+    """
+    # pylint: disable=invalid-name
+
+    # Return False if cfg_status argument is False
+    if not cfg_status:
+        return False
+
+    # Set the task name
+    if confirm:
+        task_name = "NETCONF commit-confirm datastore"
+    else:
+        task_name = "NETCONF commit datastore"
+
+    # Lock the NETCONF datastore with Scrapli netconf_commit
+    nc_result = nr.run(
+        name=task_name,
+        task=nc_ops_rpc,
+        rpc="commit",
+        confirm=confirm,
+        confirm_timeout=confirm_timeout,
+        verbose=verbose,
+        on_failed=True,
+    )
+
+    # Print the result
+    print_result(result=nc_result)
+
+    # If the task failed -> nc_result.failed is True. So return False if nc_result.failed is True
+    if nc_result.failed:
+        cfg_status = False
+
+    return cfg_status
+
+
+def nc_unlock(
+    nr: Nornir,
+    datastore: Literal["candidate", "running"] = "candidate",
+    cfg_status: bool = True,
+    verbose: bool = False,
+) -> bool:
+    """
+    This function uses Nornir to run a NETCONF unlock operation on the specified datastore using Scrapli.
+    If the `cfg_status` argument is set to False, the function will immediately return False without
+    performing any operations, in order to skip the NETCONF unlock operation.
+    """
+    # pylint: disable=invalid-name
+
+    # Return False if cfg_status argument is False
+    if not cfg_status:
+        return False
+
+    # Lock the NETCONF datastore with Scrapli netconf_unlock
+    nc_result = nr.run(
+        name="NETCONF unlock datastore",
+        task=nc_ops_rpc,
+        rpc="unlock",
+        datastore=datastore,
+        verbose=verbose,
+        on_failed=True,
+    )
+
+    # Print the result
+    print_result(result=nc_result)
+
+    # If the task failed -> nc_result.failed is True. So return False if nc_result.failed is True
+    if nc_result.failed:
+        cfg_status = False
+
+    return cfg_status
+
+
+def nc_discard(nr: Nornir, cfg_status: bool = False, verbose: bool = False) -> bool:
+    """
+    This function uses Nornir to run a NETCONF discard operation using Scrapli. If the `cfg_status`
+    argument is set to True, the function will immediately return True without performing any operations,
+    as no NETCONF discard is needed.
+    """
+    # pylint: disable=invalid-name
+
+    # Return True if cfg_status argument is True
+    if cfg_status:
+        return True
+
+    # Lock the NETCONF datastore with Scrapli netconf_discard
+    nc_result = nr.run(
+        name="NETCONF discard datastore",
+        task=nc_ops_rpc,
+        rpc="discard",
+        verbose=verbose,
+        on_failed=True,
+    )
+
+    # Print the result
+    print_result(result=nc_result)
+
+    # If the task failed -> nc_result.failed is True. So return False if nc_result.failed is True
+    if nc_result.failed:
+        cfg_status = False
+
+    return cfg_status

nornir_collection/cisco/configuration_management/processor.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+This module contains functions regarding Nornir run with Processor.
+
+The functions are ordered as followed:
+- Nornir Processor Task in Functions
+- Nornir Processor Print Functions
+"""
+
+from colorama import Style, init
+from beautifultable import BeautifulTable
+from nornir.core import Nornir
+from nornir.core.task import AggregatedResult
+from nornir_salt.plugins.processors import TestsProcessor
+from nornir_salt.plugins.tasks import scrapli_send_commands
+from nornir_collection.utils import (
+    print_task_name,
+    task_host,
+    task_info,
+    task_result,
+    list_flatten,
+    load_multiple_yaml_files_to_string,
+    nr_filter_by_role_and_tag,
+    print_result,
+)
+
+init(autoreset=True, strip=False)
+
+
+#### Nornir Processor Task in Functions #####################################################################
+
+
+def nr_testsprocessor(nr: Nornir, name: str, inv_key: str, role: str = None, tags: list[str] = None) -> bool:
+    """
+    This function filters the Nornir object by the string of the argument filter_tag and searches all values
+    of the Nornir inventory which starts with the string of the argument inv_key. These values can be a
+    string or a list of strings which are the TestProcessor test suite yaml files.
+    As Nornir with processors works on the nr object level and not on the task level, it have to be ensured
+    that all filtered hosts have access to all files or the TestsProcessor task will fail.
+    The test suite yaml file supports all NornirSalt TestsProcessor values including Jinja2 host templating.
+    """
+    # pylint: disable=invalid-name
+
+    task_text = f"NORNIR prepare TestsProcessor '{name}'"
+    print_task_name(task_text)
+
+    # If filter_tag is True, filter the inventory based on the string from the argument filter_tag
+    # If the filteres object have no hosts, exit with a error message
+    if role or tags:
+        nr = nr_filter_by_role_and_tag(nr=nr, role=role, tags=tags, silent=False)
+
+    # Create a list with the values of all inventory keys starting with a specific string
+    file_list = []
+    for host in nr.inventory.hosts.values():
+        file_list += [value for key, value in host.items() if key.startswith(inv_key)]
+
+    # Flatten the file_list if it contains lists of lists
+    file_list = list_flatten(file_list)
+    # Create a union of the files in the file_list -> no duplicate items
+    file_list = list(set().union(file_list))
+
+    # Load the test suite yaml files from file_list as one string to render jinja2 host inventory data
+    yaml_string = load_multiple_yaml_files_to_string(file_list=file_list, silent=False)
+    # Return False if the yaml_string is empty
+    if not yaml_string:
+        return False
+
+    task_text = f"NORNIR run TestsProcessor '{name}'"
+    print_task_name(task_text)
+
+    # Add the nornir salt TestsProcessor processor
+    # TestsProcessor expects a list, therefor each yaml string needs to be packed into a list
+    # TestsProcessor templates the yaml string with Jinja2 and loads the yaml string into a dict
+    nr_with_testsprocessor = nr.with_processors(
+        [TestsProcessor(tests=[yaml_string], build_per_host_tests=True)]
+    )
+
+    # Collect output from the devices using scrapli send_commands task plugin
+    try:
+        results = nr_with_testsprocessor.run(task=scrapli_send_commands, on_failed=True)
+    except ValueError:  # pylint: disable=broad-except
+        print(task_info(text=task_text, changed=False))
+        print(f"'{task_text}' -> NornirResponse <Success: True>")
+        print("-> Test files have no tests or are empty")
+        return True
+
+    # Print the TestsProcessor results
+    cfg_status = print_testsprocessor_results(nr_result=results, name=name)
+
+    return cfg_status
+
+
+#### Print Functions ########################################################################################
+
+
+def print_testsprocessor_results(nr_result: AggregatedResult, name: str) -> None:
+    """
+    This function prints a NornirSalt TestsProcessor result in a nice table with the library rich
+    """
+    # Track if the overall task has failed
+    cfg_status = True
+
+    # Print for each host a table with the Nornir testsprocessor result
+    for host, multiresult in nr_result.items():
+        # Print the host
+        print(task_host(host=str(host), changed=False))
+        # Print the overal TestsProcessor task result as INFO is all tests are successful, else ERROR
+        level_name = "INFO" if all("PASS" in result.result for result in multiresult) else "ERROR"
+        print(task_result(text=f"NORNIR run TestsProcessor '{name}'", changed=False, level_name=level_name))
+        # Update the overall task status if the level name if ERROR
+        if level_name == "ERROR":
+            cfg_status = False
+
+        try:
+            # Create a table with the Python library beautifultable
+            table = BeautifulTable()
+            table.set_style(BeautifulTable.STYLE_NONE)
+            table.columns.width = [50, 25, 10]
+            table.columns.header = [
+                f"{Style.BRIGHT}Name / Task",
+                f"{Style.BRIGHT}Criteria / Test",
+                f"{Style.BRIGHT}Result",
+            ]
+            # Create a custom table styling
+            table.columns.header.separator = "-"
+            table.columns.separator = "|"
+            table.rows.separator = "-"
+            table.columns.alignment = BeautifulTable.ALIGN_LEFT
+            # Add a row for each test result
+            for result in multiresult:
+                # Expression test using evan have an empty criteria in the Nornir result
+                if result.criteria:
+                    criteria = f"{Style.DIM}\x1b[3m({result.test})\n{result.criteria}"
+                else:
+                    criteria = f"{Style.DIM}\x1b[3mCritera not available\n"
+                    criteria += f"{Style.DIM}\x1b[3mfor this test"
+                table.rows.append(
+                    [
+                        f"{Style.DIM}\x1b[3m({result.task})\n{result.name}",
+                        f"{criteria}",
+                        f"{result.result} ✅" if result.result == "PASS" else f"{result.result} ❌",
+                    ]
+                )
+            # Print the TestProcessor result as beautifultable
+            print(f"\n{table}")
+        except:  # pylint: disable=bare-except
+            # Print the Nornir result to stdout
+            print_result(multiresult)
+
+    # Return a config status boolian True if all tests were successful or False if not
+    return cfg_status

nornir_collection/cisco/configuration_management/pyats.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""
+This module contains Nornir pyATS functions and tasks.
+
+The functions are ordered as followed:
+- Nornir pyATS tasks in regular functions
+"""
+
+import subprocess  # nosec
+import sys
+from typing import Union
+import yaml
+from colorama import Fore, Style, init
+from nornir.core import Nornir
+from nornir_collection.utils import (
+    print_task_title,
+    print_task_name,
+    task_host,
+    task_info,
+    task_error,
+)
+from nornir_collection.cisco.configuration_management.cli.show_tasks import write_commands_to_file
+from nornir_collection.cisco.configuration_management.restconf.cisco_rpc import (
+    rc_cisco_rpc_copy_file,
+    rc_cisco_rpc_is_syncing,
+)
+
+init(autoreset=True, strip=False)
+
+
+#### Nornir pyATS Functions ##################################################################################
+
+
+def pyats_create_testbed(nr: Nornir, pyats_testbed_file: str) -> None:
+    """
+    This function create a pyATS testbed from a nornir inventory. The nornir object can be the whole inventory
+    or a filtered subset.
+    """
+    # pylint: disable=invalid-name
+
+    # Create a empty dictionary to populate with every nornir host details
+    pyats_testbed = {}
+    pyats_testbed["devices"] = {}
+
+    try:
+        # Add each nornir host details to the dictionary
+        for host in nr.inventory.hosts:
+            # Create a nornir host object
+            host_obj = nr.inventory.hosts[host]
+            # Add a dictionary key for the nornir host
+            pyats_testbed["devices"][str(host_obj)] = {}
+            # Add dictionary keys and values from nornir inventory
+            pyats_testbed["devices"][str(host_obj)].update(
+                {
+                    "type": host_obj["pyats"]["type"],
+                    "os": host_obj["pyats"]["os"],
+                    "platform": host_obj["pyats"]["platform"],
+                    "credentials": {
+                        "default": {
+                            "username": nr.inventory.defaults.username,
+                            "password": nr.inventory.defaults.password,
+                        }
+                    },
+                    "connections": {
+                        "cli": {
+                            "protocol": host_obj["pyats"]["protocol"],
+                            "ip": host_obj.hostname,
+                        }
+                    },
+                }
+            )
+
+    except KeyError as error:
+        # KeyError exception handles not existing host inventory data keys
+        print(task_host(host=host, changed=False))
+        print(task_error(text="PyATS create testbed failed", changed=False))
+        print(f"Nornir inventory host key ['data']['pyats'][{error}] don't exist\n")
+        sys.exit(1)
+
+    # Write the pyATS testbed to a file encoded in yaml
+    with open(pyats_testbed_file, "w", encoding="utf-8") as stream:
+        stream.writelines(["---\n"])
+        yaml.dump(pyats_testbed, stream, default_flow_style=False)
+
+
+def pyats_update_golden_config(pyats_testbed_file: str) -> None:
+    """
+    This function creates or updates the pyATS golden config and prints a Nornir output to std-out
+    """
+    try:
+        golden_config = "network_state/golden-config-cli"
+
+        # fmt: off
+        subprocess.run( # nosec
+            ["pyats", "learn", "config", "--testbed-file",pyats_testbed_file, "--output", golden_config,],
+            check=True, capture_output=True,
+        )
+        # fmt: on
+
+        task_info_text = "PyATS update golden config"
+        print(task_info(text=task_info_text, changed=False))
+        print(f"'Update {golden_config}' -> PyATSResponse <Success: True>")
+
+    except subprocess.CalledProcessError as error:
+        # Exception is raised if subprocess exits with a non 0 status code
+        task_error_text = "PyATS update golden config"
+        print(task_error(text=task_error_text, changed=False))
+        print(f"'Update {golden_config}' -> PyATSResponse <Success: False>\n")
+        print(f"{error}")
+
+
+def pyats_artifacts_cleanup(artifacts_list: list) -> None:
+    """
+    This function deletes a list of pyATS artifact files and prints a Nornir output to std-out
+    """
+    # Define a empty string to return at the end of the function
+    task_info_result = ""
+    task_error_result = ""
+
+    # Delete each artifact in the artifacts_list
+    for artifact in artifacts_list:
+        try:
+            # Delete all pyATS artifacts
+            # fmt: off
+            subprocess.run(["rm", "-r", artifact,],check=True, capture_output=True,) # nosec
+            # fmt: on
+
+            task_info_result += f"'Delete {artifact}' -> SubprocessResponse <Success:True>\n"
+
+        except subprocess.CalledProcessError as error:
+            # Exception is raised if subprocess exits with a non 0 status code
+            task_error_result += f"{error}\n"
+
+    task_text = "PyATS clean-up of artifact"
+
+    # Return if all subprocess failed
+    if not task_info_result:
+        # Return error result only
+        print(f"{task_error(text=task_text, changed=False)}\n" + f"{task_error_result.rstrip()}")
+    # Return if all subprocess were successful
+    elif not task_error_result:
+        # Return info result only
+        print(f"{task_info(text=task_text, changed=True)}\n" + f"{task_info_result.rstrip()}")
+    # Return if it's a mix of failed and successfull subprocess
+    else:
+        # Return info and error result
+        print(
+            f"{task_info(text=task_text, changed=True)}\n"
+            + f"{task_info_result.rstrip()}\n"
+            + f"{task_error(text=task_text, changed=False)}\n"
+            + f"{task_error_result.rstrip()}"
+        )
+
+
+def pyats_update_golden_cleanup(
+    nr: Nornir, cfg_status: bool, task_text: str, pyats: dict, verbose: bool = False
+) -> Union[str, None]:
+    """
+    This function is used to verify if a new golden config can be created based on the cfg_status boolian.
+    If veriy_status is True a new golden config will be created and the list of artifact files can be deleted.
+    """
+    # pylint: disable=invalid-name
+
+    # Verify status of the config results
+    print_task_title("Verify network from code config status")
+    print_task_name(text="Verify config results")
+
+    if cfg_status:
+        # If the config is successful -> update the golden config
+        print(task_info(text="Verify config results", changed=True))
+        print(task_text[0])
+
+        # Save the running-config as text-file to local disk
+        print_task_title("Backup config file to local disk")
+
+        write_commands_to_file(
+            nr=nr,
+            name="Backup config file to local disk",
+            commands=["show running-config"],
+            path="config_backup",
+            filename_suffix="_config.txt",
+            backup_config=True,
+            verbose=verbose,
+        )
+
+        # Update golden config and clean-up artifacts
+        print_task_title("Update golden config and clean-up artifacts")
+
+        if pyats["generate_testbed"]:
+            text = "PyATS generate testbed from Nornir inventory"
+            print_task_name(text=text)
+            # Create a pyATS testbed from the filtered Nornir inventory
+            # Exceptions are handled inside the function
+            pyats_create_testbed(nr=nr, pyats_testbed_file=pyats["testbed"])
+            print(task_info(text=text, changed=True))
+            print(f"'Generate {pyats['testbed']}' -> PyATSResponse <Success: True>")
+
+        print_task_name(text="PyATS update golden config")
+        pyats_update_golden_config(pyats_testbed_file=pyats["testbed"])
+
+        # Checks to see if sync from the network element to the running datastore is
+        # in progress and wait until the configuration datastore if unlocked again
+        rc_cisco_rpc_is_syncing(nr=nr, verbose=verbose)
+
+        rc_cisco_rpc_copy_file(
+            nr=nr,
+            name="RESTCONF save golden config",
+            source="running-config",
+            destination="flash:golden-config",
+            verbose=verbose,
+        )
+
+        print_task_name(text="PyATS clean-up artifacts")
+        pyats_artifacts_cleanup(artifacts_list=pyats["artifacts_list"])
+
+        # No configuration error message to be returned
+        error_msg = None
+
+    else:
+        # If one or more of the network from code config tasks failed
+        task_error_text = "Config from code failed"
+        print(task_error(text=task_error_text, changed=True))
+        print(task_text[1])
+
+        if pyats["cleanup_else"]:
+            print_task_name(text="PyATS clean-up artifacts")
+            pyats_artifacts_cleanup(artifacts_list=pyats["artifacts_list"])
+
+        error_msg = (
+            f"\n{Style.BRIGHT}{Fore.RED}-> Analyse the Nornir output for failed config tasks\n"
+            "-> May apply Nornir inventory changes and run the script again\n\n"
+            f"The golden config has not been updated yet!{Fore.RESET}{Style.RESET_ALL}\n"
+        )
+
+    # Return error_msg if exists or return None
+    return error_msg if error_msg else None