Adding upstream version 8.4.4.upstream/8.4.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2491 insertions, 0 deletions

diff --git a/tests/topotests/lib/ospf.py b/tests/topotests/lib/ospf.py
new file mode 100644
index 0000000..e7ea7d3
--- /dev/null
+++ b/tests/topotests/lib/ospf.py
@@ -0,0 +1,2491 @@
+#
+# Copyright (c) 2020 by VMware, Inc. ("VMware")
+# Used Copyright (c) 2018 by Network Device Education Foundation, Inc.
+# ("NetDEF") in this file.
+#
+# Permission to use, copy, modify, and/or distribute this software
+# for any purpose with or without fee is hereby granted, provided
+# that the above copyright notice and this permission notice appear
+# in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND VMWARE DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL VMWARE BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+#
+
+import ipaddress
+import sys
+from copy import deepcopy
+
+# Import common_config to use commomnly used APIs
+from lib.common_config import (
+    create_common_configurations,
+    InvalidCLIError,
+    generate_ips,
+    retry,
+    run_frr_cmd,
+    validate_ip_address,
+)
+from lib.topolog import logger
+from lib.topotest import frr_unicode
+
+################################
+# Configure procs
+################################
+
+
+def create_router_ospf(tgen, topo=None, input_dict=None, build=False, load_config=True):
+    """
+    API to configure ospf on router.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : json file data
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `build` : Only for initial setup phase this is set as True.
+    * `load_config` : Loading the config to router this is set as True.
+
+    Usage
+    -----
+    input_dict = {
+        "r1": {
+            "ospf": {
+                "router_id": "22.22.22.22",
+                "area": [{ "id": "0.0.0.0", "type": "nssa"}]
+        }
+    }
+
+    result = create_router_ospf(tgen, topo, input_dict)
+
+    Returns
+    -------
+    True or False
+    """
+    logger.debug("Entering lib API: create_router_ospf()")
+    result = False
+
+    if topo is None:
+        topo = tgen.json_topo
+
+    if not input_dict:
+        input_dict = deepcopy(topo)
+    else:
+        topo = topo["routers"]
+        input_dict = deepcopy(input_dict)
+
+    for ospf in ["ospf", "ospf6"]:
+        config_data_dict = {}
+
+        for router in input_dict.keys():
+            if ospf not in input_dict[router]:
+                logger.debug("Router %s: %s not present in input_dict", router, ospf)
+                continue
+
+            config_data = __create_ospf_global(
+                tgen, input_dict, router, build, load_config, ospf
+            )
+            if config_data:
+                if router not in config_data_dict:
+                    config_data_dict[router] = config_data
+                else:
+                    config_data_dict[router].extend(config_data)
+        try:
+            result = create_common_configurations(
+                tgen, config_data_dict, ospf, build, load_config
+            )
+        except InvalidCLIError:
+            logger.error("create_router_ospf (ipv4)", exc_info=True)
+            result = False
+
+    logger.debug("Exiting lib API: create_router_ospf()")
+    return result
+
+
+def __create_ospf_global(tgen, input_dict, router, build, load_config, ospf):
+    """
+    Helper API to create ospf global configuration.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `router` : router to be configured.
+    * `build` : Only for initial setup phase this is set as True.
+    * `load_config` : Loading the config to router this is set as True.
+    * `ospf` : either 'ospf' or 'ospf6'
+
+    Usage
+    -----
+    input_dict = {
+    "routers": {
+        "r1": {
+            "links": {
+                "r3": {
+                    "ipv6": "2013:13::1/64",
+                    "ospf6": {
+                        "hello_interval": 1,
+                        "dead_interval": 4,
+                        "network": "point-to-point"
+                    }
+                }
+            },
+            "ospf6": {
+                "router_id": "1.1.1.1",
+                "neighbors": {
+                    "r3": {
+                        "area": "1.1.1.1"
+                    }
+                }
+            }
+        }
+    }
+
+    Returns
+    -------
+    list of configuration commands
+    """
+
+    config_data = []
+
+    if ospf not in input_dict[router]:
+        return config_data
+
+    logger.debug("Entering lib API: __create_ospf_global()")
+
+    ospf_data = input_dict[router][ospf]
+    del_ospf_action = ospf_data.setdefault("delete", False)
+    if del_ospf_action:
+        config_data = ["no router {}".format(ospf)]
+        return config_data
+
+    cmd = "router {}".format(ospf)
+
+    config_data.append(cmd)
+
+    # router id
+    router_id = ospf_data.setdefault("router_id", None)
+    del_router_id = ospf_data.setdefault("del_router_id", False)
+    if del_router_id:
+        config_data.append("no {} router-id".format(ospf))
+    if router_id:
+        config_data.append("{} router-id {}".format(ospf, router_id))
+
+    # log-adjacency-changes
+    log_adj_changes = ospf_data.setdefault("log_adj_changes", None)
+    del_log_adj_changes = ospf_data.setdefault("del_log_adj_changes", False)
+    if del_log_adj_changes:
+        config_data.append("no log-adjacency-changes detail")
+    if log_adj_changes:
+        config_data.append("log-adjacency-changes {}".format(log_adj_changes))
+
+    # aggregation timer
+    aggr_timer = ospf_data.setdefault("aggr_timer", None)
+    del_aggr_timer = ospf_data.setdefault("del_aggr_timer", False)
+    if del_aggr_timer:
+        config_data.append("no aggregation timer")
+    if aggr_timer:
+        config_data.append("aggregation timer {}".format(aggr_timer))
+
+    # maximum path information
+    ecmp_data = ospf_data.setdefault("maximum-paths", {})
+    if ecmp_data:
+        cmd = "maximum-paths {}".format(ecmp_data)
+        del_action = ospf_data.setdefault("del_max_path", False)
+        if del_action:
+            cmd = "no maximum-paths"
+        config_data.append(cmd)
+
+    # redistribute command
+    redistribute_data = ospf_data.setdefault("redistribute", {})
+    if redistribute_data:
+        for redistribute in redistribute_data:
+            if "redist_type" not in redistribute:
+                logger.debug(
+                    "Router %s: 'redist_type' not present in " "input_dict", router
+                )
+            else:
+                cmd = "redistribute {}".format(redistribute["redist_type"])
+                for red_type in redistribute_data:
+                    if "route_map" in red_type:
+                        cmd = cmd + " route-map {}".format(red_type["route_map"])
+                del_action = redistribute.setdefault("delete", False)
+                if del_action:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+    # area information
+    area_data = ospf_data.setdefault("area", {})
+    if area_data:
+        for area in area_data:
+            if "id" not in area:
+                logger.debug(
+                    "Router %s: 'area id' not present in " "input_dict", router
+                )
+            else:
+                cmd = "area {}".format(area["id"])
+
+                if "type" in area:
+                    cmd = cmd + " {}".format(area["type"])
+
+                del_action = area.setdefault("delete", False)
+                if del_action:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+    # def route information
+    def_rte_data = ospf_data.setdefault("default-information", {})
+    if def_rte_data:
+        if "originate" not in def_rte_data:
+            logger.debug(
+                "Router %s: 'originate key' not present in " "input_dict", router
+            )
+        else:
+            cmd = "default-information originate"
+
+            if "always" in def_rte_data:
+                cmd = cmd + " always"
+
+            if "metric" in def_rte_data:
+                cmd = cmd + " metric {}".format(def_rte_data["metric"])
+
+            if "metric-type" in def_rte_data:
+                cmd = cmd + " metric-type {}".format(def_rte_data["metric-type"])
+
+            if "route-map" in def_rte_data:
+                cmd = cmd + " route-map {}".format(def_rte_data["route-map"])
+
+            del_action = def_rte_data.setdefault("delete", False)
+            if del_action:
+                cmd = "no {}".format(cmd)
+            config_data.append(cmd)
+
+    # summary information
+    summary_data = ospf_data.setdefault("summary-address", {})
+    if summary_data:
+        for summary in summary_data:
+            if "prefix" not in summary:
+                logger.debug(
+                    "Router %s: 'summary-address' not present in " "input_dict",
+                    router,
+                )
+            else:
+                cmd = "summary {}/{}".format(summary["prefix"], summary["mask"])
+
+                _tag = summary.setdefault("tag", None)
+                if _tag:
+                    cmd = "{} tag {}".format(cmd, _tag)
+
+                _advertise = summary.setdefault("advertise", True)
+                if not _advertise:
+                    cmd = "{} no-advertise".format(cmd)
+
+                del_action = summary.setdefault("delete", False)
+                if del_action:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+    # ospf gr information
+    gr_data = ospf_data.setdefault("graceful-restart", {})
+    if gr_data:
+
+        if "opaque" in gr_data and gr_data["opaque"]:
+            cmd = "capability opaque"
+            if gr_data.setdefault("delete", False):
+                cmd = "no {}".format(cmd)
+            config_data.append(cmd)
+
+        if "helper enable" in gr_data and not gr_data["helper enable"]:
+            cmd = "graceful-restart helper enable"
+            if gr_data.setdefault("delete", False):
+                cmd = "no {}".format(cmd)
+            config_data.append(cmd)
+        elif "helper enable" in gr_data and type(gr_data["helper enable"]) is list:
+            for rtrs in gr_data["helper enable"]:
+                cmd = "graceful-restart helper enable {}".format(rtrs)
+                if gr_data.setdefault("delete", False):
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+        if "helper" in gr_data:
+            if type(gr_data["helper"]) is not list:
+                gr_data["helper"] = list(gr_data["helper"])
+            for helper_role in gr_data["helper"]:
+                cmd = "graceful-restart helper {}".format(helper_role)
+                if gr_data.setdefault("delete", False):
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+        if "supported-grace-time" in gr_data:
+            cmd = "graceful-restart helper supported-grace-time {}".format(
+                gr_data["supported-grace-time"]
+            )
+            if gr_data.setdefault("delete", False):
+                cmd = "no {}".format(cmd)
+            config_data.append(cmd)
+
+    logger.debug("Exiting lib API: create_ospf_global()")
+
+    return config_data
+
+
+def config_ospf_interface(
+    tgen, topo=None, input_dict=None, build=False, load_config=True
+):
+    """
+    API to configure ospf on router.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : json file data
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `build` : Only for initial setup phase this is set as True.
+    * `load_config` : Loading the config to router this is set as True.
+
+    Usage
+    -----
+    r1_ospf_auth = {
+                    "r1": {
+                        "links": {
+                            "r2": {
+                                "ospf": {
+                                    "authentication": "message-digest",
+                                    "authentication-key": "ospf",
+                                    "message-digest-key": "10"
+                                }
+                            }
+                        }
+                    }
+                }
+    result = config_ospf_interface(tgen, topo, r1_ospf_auth)
+
+    Returns
+    -------
+    True or False
+    """
+    logger.debug("Enter lib config_ospf_interface")
+    result = False
+
+    if topo is None:
+        topo = tgen.json_topo
+
+    if not input_dict:
+        input_dict = deepcopy(topo)
+    else:
+        input_dict = deepcopy(input_dict)
+
+    config_data_dict = {}
+
+    for router in input_dict.keys():
+        config_data = []
+        for lnk in input_dict[router]["links"].keys():
+            if "ospf" not in input_dict[router]["links"][lnk]:
+                logger.debug(
+                    "Router %s: ospf config is not present in" "input_dict", router
+                )
+                continue
+            ospf_data = input_dict[router]["links"][lnk]["ospf"]
+            data_ospf_area = ospf_data.setdefault("area", None)
+            data_ospf_auth = ospf_data.setdefault("authentication", None)
+            data_ospf_dr_priority = ospf_data.setdefault("priority", None)
+            data_ospf_cost = ospf_data.setdefault("cost", None)
+            data_ospf_mtu = ospf_data.setdefault("mtu_ignore", None)
+
+            try:
+                intf = topo["routers"][router]["links"][lnk]["interface"]
+            except KeyError:
+                intf = topo["switches"][router]["links"][lnk]["interface"]
+
+            # interface
+            cmd = "interface {}".format(intf)
+
+            config_data.append(cmd)
+            # interface area config
+            if data_ospf_area:
+                cmd = "ip ospf area {}".format(data_ospf_area)
+                config_data.append(cmd)
+
+            # interface ospf auth
+            if data_ospf_auth:
+                if data_ospf_auth == "null":
+                    cmd = "ip ospf authentication null"
+                elif data_ospf_auth == "message-digest":
+                    cmd = "ip ospf authentication message-digest"
+                else:
+                    cmd = "ip ospf authentication"
+
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+                if "message-digest-key" in ospf_data:
+                    cmd = "ip ospf message-digest-key {} md5 {}".format(
+                        ospf_data["message-digest-key"], ospf_data["authentication-key"]
+                    )
+                    if "del_action" in ospf_data:
+                        cmd = "no {}".format(cmd)
+                    config_data.append(cmd)
+
+                if (
+                    "authentication-key" in ospf_data
+                    and "message-digest-key" not in ospf_data
+                ):
+                    cmd = "ip ospf authentication-key {}".format(
+                        ospf_data["authentication-key"]
+                    )
+                    if "del_action" in ospf_data:
+                        cmd = "no {}".format(cmd)
+                    config_data.append(cmd)
+
+            # interface ospf dr priority
+            if data_ospf_dr_priority:
+                cmd = "ip ospf priority {}".format(ospf_data["priority"])
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+            # interface ospf cost
+            if data_ospf_cost:
+                cmd = "ip ospf cost {}".format(ospf_data["cost"])
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+            # interface ospf mtu
+            if data_ospf_mtu:
+                cmd = "ip ospf mtu-ignore"
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+            if build:
+                return config_data
+
+        if config_data:
+            config_data_dict[router] = config_data
+
+    result = create_common_configurations(
+        tgen, config_data_dict, "interface_config", build=build
+    )
+
+    logger.debug("Exiting lib API: config_ospf_interface()")
+    return result
+
+
+def clear_ospf(tgen, router, ospf=None):
+    """
+    This API is to clear ospf neighborship by running
+    clear ip ospf interface * command,
+
+    Parameters
+    ----------
+    * `tgen`: topogen object
+    * `router`: device under test
+
+    Usage
+    -----
+    clear_ospf(tgen, "r1")
+    """
+
+    logger.debug("Entering lib API: clear_ospf()")
+    if router not in tgen.routers():
+        return False
+
+    rnode = tgen.routers()[router]
+    # Clearing OSPF
+    if ospf:
+        version = "ipv6"
+    else:
+        version = "ip"
+
+    cmd = "clear {} ospf interface".format(version)
+    logger.info("Clearing ospf process on router %s.. using command '%s'", router, cmd)
+    run_frr_cmd(rnode, cmd)
+
+    logger.debug("Exiting lib API: clear_ospf()")
+
+
+def redistribute_ospf(tgen, topo, dut, route_type, **kwargs):
+    """
+    Redstribution of routes inside ospf.
+
+    Parameters
+    ----------
+    * `tgen`: Topogen object
+    * `topo` : json file data
+    * `dut`: device under test
+    * `route_type`: "static" or "connected" or ....
+    * `kwargs`: pass extra information (see below)
+
+    Usage
+    -----
+    redistribute_ospf(tgen, topo, "r0", "static", delete=True)
+    redistribute_ospf(tgen, topo, "r0", "static", route_map="rmap_ipv4")
+    """
+
+    ospf_red = {dut: {"ospf": {"redistribute": [{"redist_type": route_type}]}}}
+    for k, v in kwargs.items():
+        ospf_red[dut]["ospf"]["redistribute"][0][k] = v
+
+    result = create_router_ospf(tgen, topo, ospf_red)
+    assert result is True, "Testcase : Failed \n Error: {}".format(result)
+
+
+################################
+# Verification procs
+################################
+@retry(retry_timeout=80)
+def verify_ospf_neighbor(
+    tgen, topo=None, dut=None, input_dict=None, lan=False, expected=True
+):
+    """
+    This API is to verify ospf neighborship by running
+    show ip ospf neighbour command,
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : json file data
+    * `dut`: device under test
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `lan` : verify neighbors in lan topology
+    * `expected` : expected results from API, by-default True
+
+    Usage
+    -----
+    1. To check FULL neighbors.
+    verify_ospf_neighbor(tgen, topo, dut=dut)
+
+    2. To check neighbors with their roles.
+    input_dict = {
+        "r0": {
+            "ospf": {
+                "neighbors": {
+                    "r1": {
+                        "state": "Full",
+                        "role": "DR"
+                    },
+                    "r2": {
+                        "state": "Full",
+                        "role": "DROther"
+                    },
+                    "r3": {
+                        "state": "Full",
+                        "role": "DROther"
+                    }
+                }
+            }
+        }
+    }
+    result = verify_ospf_neighbor(tgen, topo, dut, input_dict, lan=True)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+    logger.debug("Entering lib API: verify_ospf_neighbor()")
+    result = False
+    if topo is None:
+        topo = tgen.json_topo
+
+    if input_dict:
+        for router, rnode in tgen.routers().items():
+            if "ospf" not in topo["routers"][router]:
+                continue
+
+            if dut is not None and dut != router:
+                continue
+
+            logger.info("Verifying OSPF neighborship on router %s:", router)
+            show_ospf_json = run_frr_cmd(
+                rnode, "show ip ospf neighbor all json", isjson=True
+            )
+
+            # Verifying output dictionary show_ospf_json is empty or not
+            if not bool(show_ospf_json):
+                errormsg = "OSPF is not running"
+                return errormsg
+
+            ospf_data_list = input_dict[router]["ospf"]
+            ospf_nbr_list = ospf_data_list["neighbors"]
+
+            for ospf_nbr, nbr_data in ospf_nbr_list.items():
+                data_ip = topo["routers"][ospf_nbr]["links"]
+                data_rid = topo["routers"][ospf_nbr]["ospf"]["router_id"]
+                if ospf_nbr in data_ip:
+                    nbr_details = nbr_data[ospf_nbr]
+                elif lan:
+                    for switch in topo["switches"]:
+                        if "ospf" in topo["switches"][switch]["links"][router]:
+                            neighbor_ip = data_ip[switch]["ipv4"].split("/")[0]
+                        else:
+                            continue
+                else:
+                    neighbor_ip = data_ip[router]["ipv4"].split("/")[0]
+
+                nh_state = None
+                neighbor_ip = neighbor_ip.lower()
+                nbr_rid = data_rid
+                try:
+                    nh_state = show_ospf_json[nbr_rid][0]["state"].split("/")[0]
+                    intf_state = show_ospf_json[nbr_rid][0]["state"].split("/")[1]
+                except KeyError:
+                    errormsg = "[DUT: {}] OSPF peer {} missing".format(router, nbr_rid)
+                    return errormsg
+
+                nbr_state = nbr_data.setdefault("state", None)
+                nbr_role = nbr_data.setdefault("role", None)
+
+                if nbr_state:
+                    if nbr_state == nh_state:
+                        logger.info(
+                            "[DUT: {}] OSPF Nbr is {}:{} State {}".format(
+                                router, ospf_nbr, nbr_rid, nh_state
+                            )
+                        )
+                        result = True
+                    else:
+                        errormsg = (
+                            "[DUT: {}] OSPF is not Converged, neighbor"
+                            " state is {}".format(router, nh_state)
+                        )
+                        return errormsg
+                if nbr_role:
+                    if nbr_role == intf_state:
+                        logger.info(
+                            "[DUT: {}] OSPF Nbr is {}: {} Role {}".format(
+                                router, ospf_nbr, nbr_rid, nbr_role
+                            )
+                        )
+                    else:
+                        errormsg = (
+                            "[DUT: {}] OSPF is not Converged with rid"
+                            "{}, role is {}".format(router, nbr_rid, intf_state)
+                        )
+                        return errormsg
+                continue
+    else:
+        for router, rnode in tgen.routers().items():
+            if "ospf" not in topo["routers"][router]:
+                continue
+
+            if dut is not None and dut != router:
+                continue
+
+            logger.info("Verifying OSPF neighborship on router %s:", router)
+            show_ospf_json = run_frr_cmd(
+                rnode, "show ip ospf neighbor  all json", isjson=True
+            )
+            # Verifying output dictionary show_ospf_json is empty or not
+            if not bool(show_ospf_json):
+                errormsg = "OSPF is not running"
+                return errormsg
+
+            ospf_data_list = topo["routers"][router]["ospf"]
+            ospf_neighbors = ospf_data_list["neighbors"]
+            total_peer = 0
+            total_peer = len(ospf_neighbors.keys())
+            no_of_ospf_nbr = 0
+            ospf_nbr_list = ospf_data_list["neighbors"]
+            no_of_peer = 0
+            for ospf_nbr, nbr_data in ospf_nbr_list.items():
+                if nbr_data:
+                    data_ip = topo["routers"][nbr_data["nbr"]]["links"]
+                    data_rid = topo["routers"][nbr_data["nbr"]]["ospf"]["router_id"]
+                else:
+                    data_ip = topo["routers"][ospf_nbr]["links"]
+                    data_rid = topo["routers"][ospf_nbr]["ospf"]["router_id"]
+                if ospf_nbr in data_ip:
+                    nbr_details = nbr_data[ospf_nbr]
+                elif lan:
+                    for switch in topo["switches"]:
+                        if "ospf" in topo["switches"][switch]["links"][router]:
+                            neighbor_ip = data_ip[switch]["ipv4"].split("/")[0]
+                        else:
+                            continue
+                else:
+                    neighbor_ip = data_ip[router]["ipv4"].split("/")[0]
+
+                nh_state = None
+                neighbor_ip = neighbor_ip.lower()
+                nbr_rid = data_rid
+                try:
+                    nh_state = show_ospf_json[nbr_rid][0]["state"].split("/")[0]
+                except KeyError:
+                    errormsg = "[DUT: {}] OSPF peer {} missing,from " "{} ".format(
+                        router, nbr_rid, ospf_nbr
+                    )
+                    return errormsg
+
+                if nh_state == "Full":
+                    no_of_peer += 1
+
+            if no_of_peer == total_peer:
+                logger.info("[DUT: {}] OSPF is Converged".format(router))
+                result = True
+            else:
+                errormsg = "[DUT: {}] OSPF is not Converged".format(router)
+                return errormsg
+
+    logger.debug("Exiting API: verify_ospf_neighbor()")
+    return result
+
+
+################################
+# Verification procs
+################################
+@retry(retry_timeout=50)
+def verify_ospf6_neighbor(tgen, topo=None, dut=None, input_dict=None, lan=False):
+    """
+    This API is to verify ospf neighborship by running
+    show ipv6 ospf neighbour command,
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : json file data
+    * `dut`: device under test
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `lan` : verify neighbors in lan topology
+
+    Usage
+    -----
+    1. To check FULL neighbors.
+    verify_ospf_neighbor(tgen, topo, dut=dut)
+
+    2. To check neighbors with their roles.
+    input_dict = {
+        "r0": {
+            "ospf6": {
+                "neighbors": {
+                    "r1": {
+                        "state": "Full",
+                        "role": "DR"
+                    },
+                    "r2": {
+                        "state": "Full",
+                        "role": "DROther"
+                    },
+                    "r3": {
+                        "state": "Full",
+                        "role": "DROther"
+                    }
+                }
+            }
+        }
+    }
+    result = verify_ospf6_neighbor(tgen, topo, dut, input_dict, lan=True)
+
+    3. To check there are no neighbors.
+    input_dict = {
+        "r0": {
+            "ospf6": {
+                "neighbors": []
+            }
+        }
+    }
+    result = verify_ospf6_neighbor(tgen, topo, dut, input_dict)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+    logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
+    result = False
+
+    if topo is None:
+        topo = tgen.json_topo
+
+    if input_dict:
+        for router, rnode in tgen.routers().items():
+            if "ospf6" not in topo["routers"][router]:
+                continue
+
+            if dut is not None and dut != router:
+                continue
+
+            logger.info("Verifying OSPF neighborship on router %s:", router)
+            show_ospf_json = run_frr_cmd(
+                rnode, "show ipv6 ospf neighbor json", isjson=True
+            )
+            # Verifying output dictionary show_ospf_json is empty or not
+            if not bool(show_ospf_json):
+                errormsg = "OSPF6 is not running"
+                return errormsg
+
+            ospf_data_list = input_dict[router]["ospf6"]
+            ospf_nbr_list = ospf_data_list["neighbors"]
+
+            # Check if looking for no neighbors
+            if ospf_nbr_list == []:
+                if show_ospf_json["neighbors"] == []:
+                    logger.info("[DUT: {}] OSPF6 no neighbors found".format(router))
+                    return True
+                else:
+                    errormsg = (
+                        "[DUT: {}] OSPF6 active neighbors found, expected None".format(
+                            router
+                        )
+                    )
+                    return errormsg
+
+            for ospf_nbr, nbr_data in ospf_nbr_list.items():
+
+                try:
+                    data_ip = data_rid = topo["routers"][ospf_nbr]["ospf6"]["router_id"]
+                except KeyError:
+                    data_ip = data_rid = topo["routers"][nbr_data["nbr"]]["ospf6"][
+                        "router_id"
+                    ]
+
+                if ospf_nbr in data_ip:
+                    nbr_details = nbr_data[ospf_nbr]
+                elif lan:
+                    for switch in topo["switches"]:
+                        if "ospf6" in topo["switches"][switch]["links"][router]:
+                            neighbor_ip = data_ip
+                        else:
+                            continue
+                else:
+                    neighbor_ip = data_ip[router]["ipv6"].split("/")[0]
+
+                nh_state = None
+                neighbor_ip = neighbor_ip.lower()
+                nbr_rid = data_rid
+                get_index_val = dict(
+                    (d["neighborId"], dict(d, index=index))
+                    for (index, d) in enumerate(show_ospf_json["neighbors"])
+                )
+                try:
+                    nh_state = get_index_val.get(neighbor_ip)["state"]
+                    intf_state = get_index_val.get(neighbor_ip)["ifState"]
+                except TypeError:
+                    errormsg = "[DUT: {}] OSPF peer {} missing,from " "{} ".format(
+                        router, nbr_rid, ospf_nbr
+                    )
+                    return errormsg
+
+                nbr_state = nbr_data.setdefault("state", None)
+                nbr_role = nbr_data.setdefault("role", None)
+
+                if nbr_state:
+                    if nbr_state == nh_state:
+                        logger.info(
+                            "[DUT: {}] OSPF6 Nbr is {}:{} State {}".format(
+                                router, ospf_nbr, nbr_rid, nh_state
+                            )
+                        )
+                        result = True
+                    else:
+                        errormsg = (
+                            "[DUT: {}] OSPF6 is not Converged, neighbor"
+                            " state is {} , Expected state is {}".format(
+                                router, nh_state, nbr_state
+                            )
+                        )
+                        return errormsg
+                if nbr_role:
+                    if nbr_role == intf_state:
+                        logger.info(
+                            "[DUT: {}] OSPF6 Nbr is {}: {} Role {}".format(
+                                router, ospf_nbr, nbr_rid, nbr_role
+                            )
+                        )
+                    else:
+                        errormsg = (
+                            "[DUT: {}] OSPF6 is not Converged with rid"
+                            "{}, role is {}, Expected role is {}".format(
+                                router, nbr_rid, intf_state, nbr_role
+                            )
+                        )
+                        return errormsg
+                continue
+    else:
+
+        for router, rnode in tgen.routers().items():
+            if "ospf6" not in topo["routers"][router]:
+                continue
+
+            if dut is not None and dut != router:
+                continue
+
+            logger.info("Verifying OSPF6 neighborship on router %s:", router)
+            show_ospf_json = run_frr_cmd(
+                rnode, "show ipv6 ospf neighbor json", isjson=True
+            )
+            # Verifying output dictionary show_ospf_json is empty or not
+            if not bool(show_ospf_json):
+                errormsg = "OSPF6 is not running"
+                return errormsg
+
+            ospf_data_list = topo["routers"][router]["ospf6"]
+            ospf_neighbors = ospf_data_list["neighbors"]
+            total_peer = 0
+            total_peer = len(ospf_neighbors.keys())
+            no_of_ospf_nbr = 0
+            ospf_nbr_list = ospf_data_list["neighbors"]
+            no_of_peer = 0
+            for ospf_nbr, nbr_data in ospf_nbr_list.items():
+                try:
+                    data_ip = data_rid = topo["routers"][ospf_nbr]["ospf6"]["router_id"]
+                except KeyError:
+                    data_ip = data_rid = topo["routers"][nbr_data["nbr"]]["ospf6"][
+                        "router_id"
+                    ]
+
+                if ospf_nbr in data_ip:
+                    nbr_details = nbr_data[ospf_nbr]
+                elif lan:
+                    for switch in topo["switches"]:
+                        if "ospf6" in topo["switches"][switch]["links"][router]:
+                            neighbor_ip = data_ip
+                        else:
+                            continue
+                else:
+                    neighbor_ip = data_ip
+
+                nh_state = None
+                neighbor_ip = neighbor_ip.lower()
+                nbr_rid = data_rid
+                get_index_val = dict(
+                    (d["neighborId"], dict(d, index=index))
+                    for (index, d) in enumerate(show_ospf_json["neighbors"])
+                )
+                try:
+                    nh_state = get_index_val.get(neighbor_ip)["state"]
+                    intf_state = get_index_val.get(neighbor_ip)["ifState"]
+                except TypeError:
+                    errormsg = "[DUT: {}] OSPF peer {} missing,from " "{} ".format(
+                        router, nbr_rid, ospf_nbr
+                    )
+                    return errormsg
+
+                if nh_state == "Full":
+                    no_of_peer += 1
+
+            if no_of_peer == total_peer:
+                logger.info("[DUT: {}] OSPF6 is Converged".format(router))
+                result = True
+            else:
+                errormsg = "[DUT: {}] OSPF6 is not Converged".format(router)
+                return errormsg
+
+    logger.debug("Exiting lib API: {}".format(sys._getframe().f_code.co_name))
+    return result
+
+
+@retry(retry_timeout=40)
+def verify_ospf_rib(
+    tgen, dut, input_dict, next_hop=None, tag=None, metric=None, fib=None, expected=True
+):
+    """
+    This API is to verify ospf routes by running
+    show ip ospf route command.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `dut`: device under test
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `next_hop` : next to be verified
+    * `tag` : tag to be verified
+    * `metric` : metric to be verified
+    * `fib` : True if the route is installed in FIB.
+    * `expected` : expected results from API, by-default True
+
+    Usage
+    -----
+    input_dict = {
+        "r1": {
+            "static_routes": [
+                {
+                    "network": ip_net,
+                    "no_of_ip": 1,
+                    "routeType": "N"
+                }
+            ]
+        }
+    }
+
+    result = verify_ospf_rib(tgen, dut, input_dict,next_hop=nh)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+
+    logger.info("Entering lib API: verify_ospf_rib()")
+    result = False
+    router_list = tgen.routers()
+    additional_nexthops_in_required_nhs = []
+    found_hops = []
+    for routerInput in input_dict.keys():
+        for router, rnode in router_list.items():
+            if router != dut:
+                continue
+
+            logger.info("Checking router %s RIB:", router)
+
+            # Verifying RIB routes
+            command = "show ip ospf route"
+
+            found_routes = []
+            missing_routes = []
+
+            if (
+                "static_routes" in input_dict[routerInput]
+                or "prefix" in input_dict[routerInput]
+            ):
+                if "prefix" in input_dict[routerInput]:
+                    static_routes = input_dict[routerInput]["prefix"]
+                else:
+                    static_routes = input_dict[routerInput]["static_routes"]
+
+                for static_route in static_routes:
+                    cmd = "{}".format(command)
+
+                    cmd = "{} json".format(cmd)
+
+                    ospf_rib_json = run_frr_cmd(rnode, cmd, isjson=True)
+
+                    # Verifying output dictionary ospf_rib_json is not empty
+                    if bool(ospf_rib_json) is False:
+                        errormsg = (
+                            "[DUT: {}] No routes found in OSPF route "
+                            "table".format(router)
+                        )
+                        return errormsg
+
+                    network = static_route["network"]
+                    no_of_ip = static_route.setdefault("no_of_ip", 1)
+                    _tag = static_route.setdefault("tag", None)
+                    _rtype = static_route.setdefault("routeType", None)
+
+                    # Generating IPs for verification
+                    ip_list = generate_ips(network, no_of_ip)
+                    st_found = False
+                    nh_found = False
+
+                    for st_rt in ip_list:
+                        st_rt = str(ipaddress.ip_network(frr_unicode(st_rt)))
+
+                        _addr_type = validate_ip_address(st_rt)
+                        if _addr_type != "ipv4":
+                            continue
+
+                        if st_rt in ospf_rib_json:
+                            st_found = True
+                            found_routes.append(st_rt)
+
+                            if fib and next_hop:
+                                if type(next_hop) is not list:
+                                    next_hop = [next_hop]
+
+                                for mnh in range(0, len(ospf_rib_json[st_rt])):
+                                    if (
+                                        "fib"
+                                        in ospf_rib_json[st_rt][mnh]["nexthops"][0]
+                                    ):
+                                        found_hops.append(
+                                            [
+                                                rib_r["ip"]
+                                                for rib_r in ospf_rib_json[st_rt][mnh][
+                                                    "nexthops"
+                                                ]
+                                            ]
+                                        )
+
+                                if found_hops[0]:
+                                    missing_list_of_nexthops = set(
+                                        found_hops[0]
+                                    ).difference(next_hop)
+                                    additional_nexthops_in_required_nhs = set(
+                                        next_hop
+                                    ).difference(found_hops[0])
+
+                                    if additional_nexthops_in_required_nhs:
+                                        logger.info(
+                                            "Nexthop "
+                                            "%s is not active for route %s in "
+                                            "RIB of router %s\n",
+                                            additional_nexthops_in_required_nhs,
+                                            st_rt,
+                                            dut,
+                                        )
+                                        errormsg = (
+                                            "Nexthop {} is not active"
+                                            " for route {} in RIB of router"
+                                            " {}\n".format(
+                                                additional_nexthops_in_required_nhs,
+                                                st_rt,
+                                                dut,
+                                            )
+                                        )
+                                        return errormsg
+                                    else:
+                                        nh_found = True
+
+                            elif next_hop and fib is None:
+                                if type(next_hop) is not list:
+                                    next_hop = [next_hop]
+                                found_hops = [
+                                    rib_r["ip"]
+                                    for rib_r in ospf_rib_json[st_rt]["nexthops"]
+                                ]
+
+                                if found_hops:
+                                    missing_list_of_nexthops = set(
+                                        found_hops
+                                    ).difference(next_hop)
+                                    additional_nexthops_in_required_nhs = set(
+                                        next_hop
+                                    ).difference(found_hops)
+
+                                    if additional_nexthops_in_required_nhs:
+                                        logger.info(
+                                            "Missing nexthop %s for route"
+                                            " %s in RIB of router %s\n",
+                                            additional_nexthops_in_required_nhs,
+                                            st_rt,
+                                            dut,
+                                        )
+                                        errormsg = (
+                                            "Nexthop {} is Missing for "
+                                            "route {} in RIB of router {}\n".format(
+                                                additional_nexthops_in_required_nhs,
+                                                st_rt,
+                                                dut,
+                                            )
+                                        )
+                                        return errormsg
+                                    else:
+                                        nh_found = True
+                            if _rtype:
+                                if "routeType" not in ospf_rib_json[st_rt]:
+                                    errormsg = (
+                                        "[DUT: {}]: routeType missing"
+                                        " for route {} in OSPF RIB \n".format(
+                                            dut, st_rt
+                                        )
+                                    )
+                                    return errormsg
+                                elif _rtype != ospf_rib_json[st_rt]["routeType"]:
+                                    errormsg = (
+                                        "[DUT: {}]: routeType mismatch"
+                                        " for route {} in OSPF RIB \n".format(
+                                            dut, st_rt
+                                        )
+                                    )
+                                    return errormsg
+                                else:
+                                    logger.info(
+                                        "[DUT: {}]: Found routeType {}"
+                                        " for route {}".format(dut, _rtype, st_rt)
+                                    )
+                            if tag:
+                                if "tag" not in ospf_rib_json[st_rt]:
+                                    errormsg = (
+                                        "[DUT: {}]: tag is not"
+                                        " present for"
+                                        " route {} in RIB \n".format(dut, st_rt)
+                                    )
+                                    return errormsg
+
+                                if _tag != ospf_rib_json[st_rt]["tag"]:
+                                    errormsg = (
+                                        "[DUT: {}]: tag value {}"
+                                        " is not matched for"
+                                        " route {} in RIB \n".format(
+                                            dut,
+                                            _tag,
+                                            st_rt,
+                                        )
+                                    )
+                                    return errormsg
+
+                            if metric is not None:
+                                if "type2cost" not in ospf_rib_json[st_rt]:
+                                    errormsg = (
+                                        "[DUT: {}]: metric is"
+                                        " not present for"
+                                        " route {} in RIB \n".format(dut, st_rt)
+                                    )
+                                    return errormsg
+
+                                if metric != ospf_rib_json[st_rt]["type2cost"]:
+                                    errormsg = (
+                                        "[DUT: {}]: metric value "
+                                        "{} is not matched for "
+                                        "route {} in RIB \n".format(
+                                            dut,
+                                            metric,
+                                            st_rt,
+                                        )
+                                    )
+                                    return errormsg
+
+                        else:
+                            missing_routes.append(st_rt)
+
+                if nh_found:
+                    logger.info(
+                        "[DUT: {}]: Found next_hop {} for all OSPF"
+                        " routes in RIB".format(router, next_hop)
+                    )
+
+                if len(missing_routes) > 0:
+                    errormsg = "[DUT: {}]: Missing route in RIB, " "routes: {}".format(
+                        dut, missing_routes
+                    )
+                    return errormsg
+
+                if found_routes:
+                    logger.info(
+                        "[DUT: %s]: Verified routes in RIB, found" " routes are: %s\n",
+                        dut,
+                        found_routes,
+                    )
+                    result = True
+
+    logger.info("Exiting lib API: verify_ospf_rib()")
+    return result
+
+
+@retry(retry_timeout=20)
+def verify_ospf_interface(
+    tgen, topo=None, dut=None, lan=False, input_dict=None, expected=True
+):
+    """
+    This API is to verify ospf routes by running
+    show ip ospf interface command.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : topology descriptions
+    * `dut`: device under test
+    * `lan`: if set to true this interface belongs to LAN.
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `expected` : expected results from API, by-default True
+
+    Usage
+    -----
+    input_dict= {
+        'r0': {
+            'links':{
+                's1': {
+                    'ospf':{
+                        'priority':98,
+                        'timerDeadSecs': 4,
+                        'area': '0.0.0.3',
+                        'mcastMemberOspfDesignatedRouters': True,
+                        'mcastMemberOspfAllRouters': True,
+                        'ospfEnabled': True,
+
+                    }
+                }
+            }
+        }
+    }
+    result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+
+    logger.debug("Entering lib API: verify_ospf_interface()")
+    result = False
+    if topo is None:
+        topo = tgen.json_topo
+
+    for router, rnode in tgen.routers().items():
+        if "ospf" not in topo["routers"][router]:
+            continue
+
+        if dut is not None and dut != router:
+            continue
+
+        logger.info("Verifying OSPF interface on router %s:", router)
+        show_ospf_json = run_frr_cmd(rnode, "show ip ospf interface json", isjson=True)
+
+        # Verifying output dictionary show_ospf_json is empty or not
+        if not bool(show_ospf_json):
+            errormsg = "OSPF is not running"
+            return errormsg
+
+        # To find neighbor ip type
+        ospf_intf_data = input_dict[router]["links"]
+        for ospf_intf, intf_data in ospf_intf_data.items():
+            intf = topo["routers"][router]["links"][ospf_intf]["interface"]
+            if intf in show_ospf_json["interfaces"]:
+                for intf_attribute in intf_data["ospf"]:
+                    if (
+                        intf_data["ospf"][intf_attribute]
+                        == show_ospf_json["interfaces"][intf][intf_attribute]
+                    ):
+                        logger.info(
+                            "[DUT: %s] OSPF interface %s: %s is %s",
+                            router,
+                            intf,
+                            intf_attribute,
+                            intf_data["ospf"][intf_attribute],
+                        )
+                    else:
+                        errormsg = "[DUT: {}] OSPF interface {}: {} is {}, \
+                        Expected is {}".format(
+                            router,
+                            intf,
+                            intf_attribute,
+                            intf_data["ospf"][intf_attribute],
+                            show_ospf_json["interfaces"][intf][intf_attribute],
+                        )
+                        return errormsg
+        result = True
+    logger.debug("Exiting API: verify_ospf_interface()")
+    return result
+
+
+@retry(retry_timeout=20)
+def verify_ospf_database(tgen, topo, dut, input_dict, expected=True):
+    """
+    This API is to verify ospf lsa's by running
+    show ip ospf database command.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `dut`: device under test
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `topo` : next to be verified
+    * `expected` : expected results from API, by-default True
+
+    Usage
+    -----
+    input_dict = {
+        "areas": {
+        "0.0.0.0": {
+            "Router Link States": {
+                "100.1.1.0-100.1.1.0": {
+                    "LSID": "100.1.1.0",
+                    "Advertised router": "100.1.1.0",
+                    "LSA Age": 130,
+                    "Sequence Number": "80000006",
+                    "Checksum": "a703",
+                    "Router links": 3
+                }
+            },
+            "Net Link States": {
+                "10.0.0.2-100.1.1.1": {
+                    "LSID": "10.0.0.2",
+                    "Advertised router": "100.1.1.1",
+                    "LSA Age": 137,
+                    "Sequence Number": "80000001",
+                    "Checksum": "9583"
+                }
+            },
+        },
+        }
+    }
+    result = verify_ospf_database(tgen, topo, dut, input_dict)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+
+    result = False
+    router = dut
+    logger.debug("Entering lib API: verify_ospf_database()")
+
+    if "ospf" not in topo["routers"][dut]:
+        errormsg = "[DUT: {}] OSPF is not configured on the router.".format(dut)
+        return errormsg
+
+    rnode = tgen.routers()[dut]
+
+    logger.info("Verifying OSPF interface on router %s:", dut)
+    show_ospf_json = run_frr_cmd(rnode, "show ip ospf database json", isjson=True)
+    # Verifying output dictionary show_ospf_json is empty or not
+    if not bool(show_ospf_json):
+        errormsg = "OSPF is not running"
+        return errormsg
+
+    # for inter and inter lsa's
+    ospf_db_data = input_dict.setdefault("areas", None)
+    ospf_external_lsa = input_dict.setdefault("AS External Link States", None)
+    if ospf_db_data:
+        for ospf_area, area_lsa in ospf_db_data.items():
+            if ospf_area in show_ospf_json["areas"]:
+                if "Router Link States" in area_lsa:
+                    for lsa in area_lsa["Router Link States"]:
+                        if (
+                            lsa
+                            in show_ospf_json["areas"][ospf_area]["Router Link States"]
+                        ):
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:Router " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            result = True
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " Router LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+                if "Net Link States" in area_lsa:
+                    for lsa in area_lsa["Net Link States"]:
+                        if lsa in show_ospf_json["areas"][ospf_area]["Net Link States"]:
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:Network " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            result = True
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " Network LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+                if "Summary Link States" in area_lsa:
+                    for lsa in area_lsa["Summary Link States"]:
+                        if (
+                            lsa
+                            in show_ospf_json["areas"][ospf_area]["Summary Link States"]
+                        ):
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:Summary " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            result = True
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " Summary LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+                if "ASBR-Summary Link States" in area_lsa:
+                    for lsa in area_lsa["ASBR-Summary Link States"]:
+                        if (
+                            lsa
+                            in show_ospf_json["areas"][ospf_area][
+                                "ASBR-Summary Link States"
+                            ]
+                        ):
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:ASBR Summary " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            result = True
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " ASBR Summary LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+    if ospf_external_lsa:
+        for ospf_ext_lsa, ext_lsa_data in ospf_external_lsa.items():
+            if ospf_ext_lsa in show_ospf_json["AS External Link States"]:
+                logger.info(
+                    "[DUT: %s]  OSPF LSDB:External LSA %s", router, ospf_ext_lsa
+                )
+                result = True
+            else:
+                errormsg = (
+                    "[DUT: {}]  OSPF LSDB : expected"
+                    " External LSA is {}".format(router, ospf_ext_lsa)
+                )
+                return errormsg
+
+    logger.debug("Exiting API: verify_ospf_database()")
+    return result
+
+
+@retry(retry_timeout=20)
+def verify_ospf_summary(tgen, topo, dut, input_dict, ospf=None, expected=True):
+    """
+    This API is to verify ospf routes by running
+    show ip ospf interface command.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : topology descriptions
+    * `dut`: device under test
+    * `input_dict` : Input dict data, required when configuring from testcase
+
+    Usage
+    -----
+    input_dict = {
+        "11.0.0.0/8": {
+            "Summary address": "11.0.0.0/8",
+            "Metric-type": "E2",
+            "Metric": 20,
+            "Tag": 0,
+            "External route count": 5
+        }
+    }
+    result = verify_ospf_summary(tgen, topo, dut, input_dict)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+
+    logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
+    result = False
+    router = dut
+
+    logger.info("Verifying OSPF summary on router %s:", router)
+
+    rnode = tgen.routers()[dut]
+
+    if ospf:
+        if "ospf6" not in topo["routers"][dut]:
+            errormsg = "[DUT: {}] OSPF6 is not configured on the router.".format(router)
+            return errormsg
+
+        show_ospf_json = run_frr_cmd(
+            rnode, "show ipv6 ospf summary detail json", isjson=True
+        )
+    else:
+        if "ospf" not in topo["routers"][dut]:
+            errormsg = "[DUT: {}] OSPF is not configured on the router.".format(router)
+            return errormsg
+
+        show_ospf_json = run_frr_cmd(
+            rnode, "show ip ospf summary detail json", isjson=True
+        )
+
+    # Verifying output dictionary show_ospf_json is empty or not
+    if not bool(show_ospf_json):
+        errormsg = "OSPF is not running"
+        return errormsg
+
+    # To find neighbor ip type
+    ospf_summary_data = input_dict
+
+    if ospf:
+        show_ospf_json = show_ospf_json["default"]
+
+    for ospf_summ, summ_data in ospf_summary_data.items():
+        if ospf_summ not in show_ospf_json:
+            continue
+        summary = ospf_summary_data[ospf_summ]["Summary address"]
+
+        if summary in show_ospf_json:
+            for summ in summ_data:
+                if summ_data[summ] == show_ospf_json[summary][summ]:
+                    logger.info(
+                        "[DUT: %s] OSPF summary %s:%s is %s",
+                        router,
+                        summary,
+                        summ,
+                        summ_data[summ],
+                    )
+                    result = True
+                else:
+                    errormsg = (
+                        "[DUT: {}] OSPF summary {} : {} is {}, "
+                        "Expected is {}".format(
+                            router,
+                            summary,
+                            summ,
+                            show_ospf_json[summary][summ],
+                            summ_data[summ],
+                        )
+                    )
+                    return errormsg
+
+    logger.debug("Exiting lib API: {}".format(sys._getframe().f_code.co_name))
+    return result
+
+
+@retry(retry_timeout=30)
+def verify_ospf6_rib(
+    tgen, dut, input_dict, next_hop=None, tag=None, metric=None, fib=None
+):
+    """
+    This API is to verify ospf routes by running
+    show ip ospf route command.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `dut`: device under test
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `next_hop` : next to be verified
+    * `tag` : tag to be verified
+    * `metric` : metric to be verified
+    * `fib` : True if the route is installed in FIB.
+
+    Usage
+    -----
+    input_dict = {
+        "r1": {
+            "static_routes": [
+                {
+                    "network": ip_net,
+                    "no_of_ip": 1,
+                    "routeType": "N"
+                }
+            ]
+        }
+    }
+
+    result = verify_ospf6_rib(tgen, dut, input_dict,next_hop=nh)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+
+    logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
+    result = False
+    router_list = tgen.routers()
+    additional_nexthops_in_required_nhs = []
+    found_hops = []
+    for routerInput in input_dict.keys():
+        for router, rnode in router_list.items():
+            if router != dut:
+                continue
+
+            logger.info("Checking router %s RIB:", router)
+
+            # Verifying RIB routes
+            command = "show ipv6 ospf route detail"
+
+            found_routes = []
+            missing_routes = []
+
+            if (
+                "static_routes" in input_dict[routerInput]
+                or "prefix" in input_dict[routerInput]
+            ):
+                if "prefix" in input_dict[routerInput]:
+                    static_routes = input_dict[routerInput]["prefix"]
+                else:
+                    static_routes = input_dict[routerInput]["static_routes"]
+
+                for static_route in static_routes:
+                    cmd = "{}".format(command)
+
+                    cmd = "{} json".format(cmd)
+
+                    ospf_rib_json = run_frr_cmd(rnode, cmd, isjson=True)
+
+                    # Fix for PR 2644182
+                    try:
+                        ospf_rib_json = ospf_rib_json["routes"]
+                    except KeyError:
+                        pass
+
+                    # Verifying output dictionary ospf_rib_json is not empty
+                    if bool(ospf_rib_json) is False:
+                        errormsg = (
+                            "[DUT: {}] No routes found in OSPF6 route "
+                            "table".format(router)
+                        )
+                        return errormsg
+
+                    network = static_route["network"]
+                    no_of_ip = static_route.setdefault("no_of_ip", 1)
+                    _tag = static_route.setdefault("tag", None)
+                    _rtype = static_route.setdefault("routeType", None)
+
+                    # Generating IPs for verification
+                    ip_list = generate_ips(network, no_of_ip)
+                    if len(ip_list) == 1:
+                        ip_list = [network]
+                    st_found = False
+                    nh_found = False
+                    for st_rt in ip_list:
+                        st_rt = str(ipaddress.ip_network(frr_unicode(st_rt)))
+
+                        _addr_type = validate_ip_address(st_rt)
+                        if _addr_type != "ipv6":
+                            continue
+
+                        if st_rt in ospf_rib_json:
+
+                            st_found = True
+                            found_routes.append(st_rt)
+
+                            if fib and next_hop:
+                                if type(next_hop) is not list:
+                                    next_hop = [next_hop]
+
+                                for mnh in range(0, len(ospf_rib_json[st_rt])):
+                                    if (
+                                        "fib"
+                                        in ospf_rib_json[st_rt][mnh]["nextHops"][0]
+                                    ):
+                                        found_hops.append(
+                                            [
+                                                rib_r["ip"]
+                                                for rib_r in ospf_rib_json[st_rt][mnh][
+                                                    "nextHops"
+                                                ]
+                                            ]
+                                        )
+
+                                if found_hops[0]:
+                                    missing_list_of_nexthops = set(
+                                        found_hops[0]
+                                    ).difference(next_hop)
+                                    additional_nexthops_in_required_nhs = set(
+                                        next_hop
+                                    ).difference(found_hops[0])
+
+                                    if additional_nexthops_in_required_nhs:
+                                        logger.info(
+                                            "Nexthop "
+                                            "%s is not active for route %s in "
+                                            "RIB of router %s\n",
+                                            additional_nexthops_in_required_nhs,
+                                            st_rt,
+                                            dut,
+                                        )
+                                        errormsg = (
+                                            "Nexthop {} is not active"
+                                            " for route {} in RIB of router"
+                                            " {}\n".format(
+                                                additional_nexthops_in_required_nhs,
+                                                st_rt,
+                                                dut,
+                                            )
+                                        )
+                                        return errormsg
+                                    else:
+                                        nh_found = True
+
+                            elif next_hop and fib is None:
+                                if type(next_hop) is not list:
+                                    next_hop = [next_hop]
+                                found_hops = [
+                                    rib_r["nextHop"]
+                                    for rib_r in ospf_rib_json[st_rt]["nextHops"]
+                                ]
+
+                                if found_hops:
+                                    missing_list_of_nexthops = set(
+                                        found_hops
+                                    ).difference(next_hop)
+                                    additional_nexthops_in_required_nhs = set(
+                                        next_hop
+                                    ).difference(found_hops)
+                                    if additional_nexthops_in_required_nhs:
+                                        logger.info(
+                                            "Missing nexthop %s for route"
+                                            " %s in RIB of router %s\n",
+                                            additional_nexthops_in_required_nhs,
+                                            st_rt,
+                                            dut,
+                                        )
+                                        errormsg = (
+                                            "Nexthop {} is Missing for "
+                                            "route {} in RIB of router {}\n".format(
+                                                additional_nexthops_in_required_nhs,
+                                                st_rt,
+                                                dut,
+                                            )
+                                        )
+                                        return errormsg
+                                    else:
+                                        nh_found = True
+                            if _rtype:
+                                if "destinationType" not in ospf_rib_json[st_rt]:
+                                    errormsg = (
+                                        "[DUT: {}]: destinationType missing"
+                                        "for route {} in OSPF RIB \n".format(dut, st_rt)
+                                    )
+                                    return errormsg
+                                elif _rtype != ospf_rib_json[st_rt]["destinationType"]:
+                                    errormsg = (
+                                        "[DUT: {}]: destinationType mismatch"
+                                        "for route {} in OSPF RIB \n".format(dut, st_rt)
+                                    )
+                                    return errormsg
+                                else:
+                                    logger.info(
+                                        "DUT: {}]: Found destinationType {}"
+                                        "for route {}".format(dut, _rtype, st_rt)
+                                    )
+                            if tag:
+                                if "tag" not in ospf_rib_json[st_rt]:
+                                    errormsg = (
+                                        "[DUT: {}]: tag is not"
+                                        " present for"
+                                        " route {} in RIB \n".format(dut, st_rt)
+                                    )
+                                    return errormsg
+
+                                if _tag != ospf_rib_json[st_rt]["tag"]:
+                                    errormsg = (
+                                        "[DUT: {}]: tag value {}"
+                                        " is not matched for"
+                                        " route {} in RIB \n".format(
+                                            dut,
+                                            _tag,
+                                            st_rt,
+                                        )
+                                    )
+                                    return errormsg
+
+                            if metric is not None:
+                                if "metricCostE2" not in ospf_rib_json[st_rt]:
+                                    errormsg = (
+                                        "[DUT: {}]: metric is"
+                                        " not present for"
+                                        " route {} in RIB \n".format(dut, st_rt)
+                                    )
+                                    return errormsg
+
+                                if metric != ospf_rib_json[st_rt]["metricCostE2"]:
+                                    errormsg = (
+                                        "[DUT: {}]: metric value "
+                                        "{} is not matched for "
+                                        "route {} in RIB \n".format(
+                                            dut,
+                                            metric,
+                                            st_rt,
+                                        )
+                                    )
+                                    return errormsg
+
+                        else:
+                            missing_routes.append(st_rt)
+
+                if nh_found:
+                    logger.info(
+                        "[DUT: {}]: Found next_hop {} for all OSPF"
+                        " routes in RIB".format(router, next_hop)
+                    )
+
+                if len(missing_routes) > 0:
+                    errormsg = "[DUT: {}]: Missing route in RIB, " "routes: {}".format(
+                        dut, missing_routes
+                    )
+                    return errormsg
+
+                if found_routes:
+                    logger.info(
+                        "[DUT: %s]: Verified routes in RIB, found" " routes are: %s\n",
+                        dut,
+                        found_routes,
+                    )
+                    result = True
+
+    logger.debug("Exiting lib API: {}".format(sys._getframe().f_code.co_name))
+    return result
+
+
+@retry(retry_timeout=6)
+def verify_ospf6_interface(tgen, topo=None, dut=None, lan=False, input_dict=None):
+    """
+    This API is to verify ospf routes by running
+    show ip ospf interface command.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : topology descriptions
+    * `dut`: device under test
+    * `lan`: if set to true this interface belongs to LAN.
+    * `input_dict` : Input dict data, required when configuring from testcase
+
+    Usage
+    -----
+    input_dict= {
+        'r0': {
+            'links':{
+                's1': {
+                    'ospf6':{
+                        'priority':98,
+                        'timerDeadSecs': 4,
+                        'area': '0.0.0.3',
+                        'mcastMemberOspfDesignatedRouters': True,
+                        'mcastMemberOspfAllRouters': True,
+                        'ospfEnabled': True,
+
+                    }
+                }
+            }
+        }
+    }
+    result = verify_ospf_interface(tgen, topo, dut=dut, input_dict=input_dict)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+
+    logger.debug("Entering lib API: verify_ospf6_interface")
+    result = False
+
+    if topo is None:
+        topo = tgen.json_topo
+
+    for router, rnode in tgen.routers().items():
+        if "ospf6" not in topo["routers"][router]:
+            continue
+
+        if dut is not None and dut != router:
+            continue
+
+        logger.info("Verifying OSPF interface on router %s:", router)
+        show_ospf_json = run_frr_cmd(
+            rnode, "show ipv6 ospf interface json", isjson=True
+        )
+
+        # Verifying output dictionary show_ospf_json is empty or not
+        if not bool(show_ospf_json):
+            errormsg = "OSPF6 is not running"
+            return errormsg
+
+        # To find neighbor ip type
+        ospf_intf_data = input_dict[router]["links"]
+        for ospf_intf, intf_data in ospf_intf_data.items():
+            intf = topo["routers"][router]["links"][ospf_intf]["interface"]
+            if intf in show_ospf_json:
+                for intf_attribute in intf_data["ospf6"]:
+                    if intf_data["ospf6"][intf_attribute] is not list:
+                        if (
+                            intf_data["ospf6"][intf_attribute]
+                            == show_ospf_json[intf][intf_attribute]
+                        ):
+                            logger.info(
+                                "[DUT: %s] OSPF6 interface %s: %s is %s",
+                                router,
+                                intf,
+                                intf_attribute,
+                                intf_data["ospf6"][intf_attribute],
+                            )
+                    elif intf_data["ospf6"][intf_attribute] is list:
+                        for addr_list in len(show_ospf_json[intf][intf_attribute]):
+                            if (
+                                show_ospf_json[intf][intf_attribute][addr_list][
+                                    "address"
+                                ].split("/")[0]
+                                == intf_data["ospf6"]["internetAddress"][0]["address"]
+                            ):
+                                break
+                            else:
+                                errormsg = "[DUT: {}] OSPF6 interface {}: {} is {}, \
+                                    Expected is {}".format(
+                                    router,
+                                    intf,
+                                    intf_attribute,
+                                    intf_data["ospf6"][intf_attribute],
+                                    intf_data["ospf6"][intf_attribute],
+                                )
+                                return errormsg
+                    else:
+                        errormsg = "[DUT: {}] OSPF6 interface {}: {} is {}, \
+                        Expected is {}".format(
+                            router,
+                            intf,
+                            intf_attribute,
+                            intf_data["ospf6"][intf_attribute],
+                            intf_data["ospf6"][intf_attribute],
+                        )
+                        return errormsg
+        result = True
+    logger.debug("Exiting lib API: {}".format(sys._getframe().f_code.co_name))
+    return result
+
+
+@retry(retry_timeout=20)
+def verify_ospf6_database(tgen, topo, dut, input_dict):
+    """
+    This API is to verify ospf lsa's by running
+    show ip ospf database command.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `dut`: device under test
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `topo` : next to be verified
+
+    Usage
+    -----
+    input_dict = {
+        "areas": {
+        "0.0.0.0": {
+            "routerLinkStates": {
+                "100.1.1.0-100.1.1.0": {
+                    "LSID": "100.1.1.0",
+                    "Advertised router": "100.1.1.0",
+                    "LSA Age": 130,
+                    "Sequence Number": "80000006",
+                    "Checksum": "a703",
+                    "Router links": 3
+                }
+            },
+            "networkLinkStates": {
+                "10.0.0.2-100.1.1.1": {
+                    "LSID": "10.0.0.2",
+                    "Advertised router": "100.1.1.1",
+                    "LSA Age": 137,
+                    "Sequence Number": "80000001",
+                    "Checksum": "9583"
+                }
+            },
+        },
+        }
+    }
+    result = verify_ospf_database(tgen, topo, dut, input_dict)
+
+    Returns
+    -------
+    True or False (Error Message)
+    """
+
+    result = False
+    router = dut
+    logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
+
+    if "ospf" not in topo["routers"][dut]:
+        errormsg = "[DUT: {}] OSPF is not configured on the router.".format(dut)
+        return errormsg
+
+    rnode = tgen.routers()[dut]
+
+    logger.info("Verifying OSPF interface on router %s:", dut)
+    show_ospf_json = run_frr_cmd(rnode, "show ip ospf database json", isjson=True)
+    # Verifying output dictionary show_ospf_json is empty or not
+    if not bool(show_ospf_json):
+        errormsg = "OSPF is not running"
+        return errormsg
+
+    # for inter and inter lsa's
+    ospf_db_data = input_dict.setdefault("areas", None)
+    ospf_external_lsa = input_dict.setdefault("asExternalLinkStates", None)
+
+    if ospf_db_data:
+        for ospf_area, area_lsa in ospf_db_data.items():
+            if ospf_area in show_ospf_json["areas"]:
+                if "routerLinkStates" in area_lsa:
+                    for lsa in area_lsa["routerLinkStates"]:
+                        for rtrlsa in show_ospf_json["areas"][ospf_area][
+                            "routerLinkStates"
+                        ]:
+                            if (
+                                lsa["lsaId"] == rtrlsa["lsaId"]
+                                and lsa["advertisedRouter"]
+                                == rtrlsa["advertisedRouter"]
+                            ):
+                                result = True
+                                break
+                        if result:
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:Router " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            break
+                    else:
+                        errormsg = (
+                            "[DUT: {}]  OSPF LSDB area {}: expected"
+                            " Router LSA is {}".format(router, ospf_area, lsa)
+                        )
+                        return errormsg
+
+                if "networkLinkStates" in area_lsa:
+                    for lsa in area_lsa["networkLinkStates"]:
+                        for netlsa in show_ospf_json["areas"][ospf_area][
+                            "networkLinkStates"
+                        ]:
+                            if (
+                                lsa
+                                in show_ospf_json["areas"][ospf_area][
+                                    "networkLinkStates"
+                                ]
+                            ):
+                                if (
+                                    lsa["lsaId"] == netlsa["lsaId"]
+                                    and lsa["advertisedRouter"]
+                                    == netlsa["advertisedRouter"]
+                                ):
+                                    result = True
+                                    break
+                        if result:
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:Network " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            break
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " Network LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+
+                if "summaryLinkStates" in area_lsa:
+                    for lsa in area_lsa["summaryLinkStates"]:
+                        for t3lsa in show_ospf_json["areas"][ospf_area][
+                            "summaryLinkStates"
+                        ]:
+                            if (
+                                lsa["lsaId"] == t3lsa["lsaId"]
+                                and lsa["advertisedRouter"] == t3lsa["advertisedRouter"]
+                            ):
+                                result = True
+                                break
+                        if result:
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:Summary " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            break
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " Summary LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+
+                if "nssaExternalLinkStates" in area_lsa:
+                    for lsa in area_lsa["nssaExternalLinkStates"]:
+                        for t7lsa in show_ospf_json["areas"][ospf_area][
+                            "nssaExternalLinkStates"
+                        ]:
+                            if (
+                                lsa["lsaId"] == t7lsa["lsaId"]
+                                and lsa["advertisedRouter"] == t7lsa["advertisedRouter"]
+                            ):
+                                result = True
+                                break
+                        if result:
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:Type7 " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            break
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " Type7 LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+
+                if "asbrSummaryLinkStates" in area_lsa:
+                    for lsa in area_lsa["asbrSummaryLinkStates"]:
+                        for t4lsa in show_ospf_json["areas"][ospf_area][
+                            "asbrSummaryLinkStates"
+                        ]:
+                            if (
+                                lsa["lsaId"] == t4lsa["lsaId"]
+                                and lsa["advertisedRouter"] == t4lsa["advertisedRouter"]
+                            ):
+                                result = True
+                                break
+                        if result:
+                            logger.info(
+                                "[DUT: %s]  OSPF LSDB area %s:ASBR Summary " "LSA %s",
+                                router,
+                                ospf_area,
+                                lsa,
+                            )
+                            result = True
+                        else:
+                            errormsg = (
+                                "[DUT: {}]  OSPF LSDB area {}: expected"
+                                " ASBR Summary LSA is {}".format(router, ospf_area, lsa)
+                            )
+                            return errormsg
+
+                if "linkLocalOpaqueLsa" in area_lsa:
+                    for lsa in area_lsa["linkLocalOpaqueLsa"]:
+                        try:
+                            for lnklsa in show_ospf_json["areas"][ospf_area][
+                                "linkLocalOpaqueLsa"
+                            ]:
+                                if (
+                                    lsa["lsaId"] in lnklsa["lsaId"]
+                                    and "linkLocalOpaqueLsa"
+                                    in show_ospf_json["areas"][ospf_area]
+                                ):
+                                    logger.info(
+                                        (
+                                            "[DUT: FRR]  OSPF LSDB area %s:Opaque-LSA"
+                                            "%s",
+                                            ospf_area,
+                                            lsa,
+                                        )
+                                    )
+                                    result = True
+                                else:
+                                    errormsg = (
+                                        "[DUT: FRR] OSPF LSDB area: {} "
+                                        "expected Opaque-LSA is {}, Found is {}".format(
+                                            ospf_area, lsa, show_ospf_json
+                                        )
+                                    )
+                                    raise ValueError(errormsg)
+                                    return errormsg
+                        except KeyError:
+                            errormsg = "[DUT: FRR] linkLocalOpaqueLsa Not " "present"
+                            return errormsg
+
+    if ospf_external_lsa:
+        for lsa in ospf_external_lsa:
+            try:
+                for t5lsa in show_ospf_json["asExternalLinkStates"]:
+                    if (
+                        lsa["lsaId"] == t5lsa["lsaId"]
+                        and lsa["advertisedRouter"] == t5lsa["advertisedRouter"]
+                    ):
+                        result = True
+                        break
+            except KeyError:
+                result = False
+            if result:
+                logger.info("[DUT: %s]  OSPF LSDB:External LSA %s", router, lsa)
+                result = True
+            else:
+                errormsg = (
+                    "[DUT: {}]  OSPF LSDB : expected"
+                    " External LSA is {}".format(router, lsa)
+                )
+                return errormsg
+
+    logger.debug("Exiting lib API: {}".format(sys._getframe().f_code.co_name))
+    return result
+
+
+def config_ospf6_interface(
+    tgen, topo=None, input_dict=None, build=False, load_config=True
+):
+    """
+    API to configure ospf on router.
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : json file data
+    * `input_dict` : Input dict data, required when configuring from testcase
+    * `build` : Only for initial setup phase this is set as True.
+    * `load_config` : Loading the config to router this is set as True.
+
+    Usage
+    -----
+    r1_ospf_auth = {
+                    "r1": {
+                        "links": {
+                            "r2": {
+                                "ospf": {
+                                    "authentication": 'message-digest',
+                                    "authentication-key": "ospf",
+                                    "message-digest-key": "10"
+                                }
+                            }
+                        }
+                    }
+                }
+    result = config_ospf6_interface(tgen, topo, r1_ospf_auth)
+
+    Returns
+    -------
+    True or False
+    """
+
+    logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
+    result = False
+    if topo is None:
+        topo = tgen.json_topo
+
+    if not input_dict:
+        input_dict = deepcopy(topo)
+    else:
+        input_dict = deepcopy(input_dict)
+
+    config_data_dict = {}
+
+    for router in input_dict.keys():
+        config_data = []
+        for lnk in input_dict[router]["links"].keys():
+            if "ospf6" not in input_dict[router]["links"][lnk]:
+                logger.debug(
+                    "Router %s: ospf6 config is not present in"
+                    "input_dict, passed input_dict %s",
+                    router,
+                    str(input_dict),
+                )
+                continue
+            ospf_data = input_dict[router]["links"][lnk]["ospf6"]
+            data_ospf_area = ospf_data.setdefault("area", None)
+            data_ospf_auth = ospf_data.setdefault("hash-algo", None)
+            data_ospf_keychain = ospf_data.setdefault("keychain", None)
+            data_ospf_dr_priority = ospf_data.setdefault("priority", None)
+            data_ospf_cost = ospf_data.setdefault("cost", None)
+            data_ospf_mtu = ospf_data.setdefault("mtu_ignore", None)
+
+            try:
+                intf = topo["routers"][router]["links"][lnk]["interface"]
+            except KeyError:
+                intf = topo["switches"][router]["links"][lnk]["interface"]
+
+            # interface
+            cmd = "interface {}".format(intf)
+
+            config_data.append(cmd)
+            # interface area config
+            if data_ospf_area:
+                cmd = "ipv6 ospf area {}".format(data_ospf_area)
+                config_data.append(cmd)
+
+            # interface ospf auth
+            if data_ospf_auth:
+                cmd = "ipv6 ospf6 authentication"
+
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+
+                if "hash-algo" in ospf_data:
+                    cmd = "{} key-id {} hash-algo {} key {}".format(
+                        cmd,
+                        ospf_data["key-id"],
+                        ospf_data["hash-algo"],
+                        ospf_data["key"],
+                    )
+                config_data.append(cmd)
+
+            # interface ospf auth with keychain
+            if data_ospf_keychain:
+                cmd = "ipv6 ospf6 authentication"
+
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+
+                if "keychain" in ospf_data:
+                    cmd = "{} keychain {}".format(cmd, ospf_data["keychain"])
+                config_data.append(cmd)
+
+            # interface ospf dr priority
+            if data_ospf_dr_priority:
+                cmd = "ipv6 ospf priority {}".format(ospf_data["priority"])
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+            # interface ospf cost
+            if data_ospf_cost:
+                cmd = "ipv6 ospf cost {}".format(ospf_data["cost"])
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+            # interface ospf mtu
+            if data_ospf_mtu:
+                cmd = "ipv6 ospf mtu-ignore"
+                if "del_action" in ospf_data:
+                    cmd = "no {}".format(cmd)
+                config_data.append(cmd)
+
+            if build:
+                return config_data
+
+            if config_data:
+                config_data_dict[router] = config_data
+
+        result = create_common_configurations(
+            tgen, config_data_dict, "interface_config", build=build
+        )
+
+    logger.debug("Exiting lib API: {}".format(sys._getframe().f_code.co_name))
+    return result
+
+
+@retry(retry_timeout=20)
+def verify_ospf_gr_helper(tgen, topo, dut, input_dict=None):
+    """
+    This API is used to vreify gr helper using command
+    show ip ospf graceful-restart helper
+
+    Parameters
+    ----------
+    * `tgen` : Topogen object
+    * `topo` : topology descriptions
+    * 'dut' : router
+    * 'input_dict' - values to be verified
+
+    Usage:
+    -------
+    input_dict = {
+                    "helperSupport":"Disabled",
+                    "strictLsaCheck":"Enabled",
+                    "restartSupoort":"Planned and Unplanned Restarts",
+                    "supportedGracePeriod":1800
+                }
+    result = verify_ospf_gr_helper(tgen, topo, dut, input_dict)
+
+    """
+    logger.debug("Entering lib API: {}".format(sys._getframe().f_code.co_name))
+    result = False
+
+    if "ospf" not in topo["routers"][dut]:
+        errormsg = "[DUT: {}] OSPF is not configured on the router.".format(dut)
+        return errormsg
+
+    rnode = tgen.routers()[dut]
+    logger.info("Verifying OSPF GR details on router %s:", dut)
+    show_ospf_json = run_frr_cmd(
+        rnode, "show ip ospf graceful-restart helper json", isjson=True
+    )
+
+    # Verifying output dictionary show_ospf_json is empty or not
+    if not bool(show_ospf_json):
+        errormsg = "OSPF is not running"
+        raise ValueError(errormsg)
+        return errormsg
+
+    for ospf_gr, gr_data in input_dict.items():
+        try:
+            if input_dict[ospf_gr] == show_ospf_json[ospf_gr]:
+                logger.info(
+                    "[DUT: FRR] OSPF GR Helper: %s is %s",
+                    ospf_gr,
+                    show_ospf_json[ospf_gr],
+                )
+                result = True
+            else:
+                errormsg = (
+                    "[DUT: FRR] OSPF GR Helper: {} expected is {}, Found "
+                    "is {}".format(
+                        ospf_gr, input_dict[ospf_gr], show_ospf_json[ospf_gr]
+                    )
+                )
+                raise ValueError(errormsg)
+                return errormsg
+
+        except KeyError:
+            errormsg = "[DUT: FRR] OSPF GR Helper: {}".format(ospf_gr)
+            return errormsg
+
+    logger.debug("Exiting lib API: {}".format(sys._getframe().f_code.co_name))
+    return result