コード例 #1
0
ファイル: topotest.py プロジェクト: ton31337/frr
 def restartRouter(self):
     # Starts actual daemons without init (ie restart)
     # cd to per node directory
     self.cmd('cd {}/{}'.format(self.logdir, self.name))
     self.cmd('umask 000')
     #Re-enable to allow for report per run
     self.reportCores = True
     if self.version == None:
         self.version = self.cmd(os.path.join(self.daemondir, 'bgpd')+' -v').split()[2]
         logger.info('{}: running version: {}'.format(self.name,self.version))
     # Start Zebra first
     if self.daemons['zebra'] == 1:
         zebra_path = os.path.join(self.daemondir, 'zebra')
         zebra_option = self.daemons_options['zebra']
         self.cmd('{0} {1} > zebra.out 2> zebra.err &'.format(
              zebra_path, zebra_option, self.logdir, self.name
         ))
         self.waitOutput()
         logger.debug('{}: {} zebra started'.format(self, self.routertype))
         sleep(1, '{}: waiting for zebra to start'.format(self.name))
     # Start staticd next if required
     if self.daemons['staticd'] == 1:
         staticd_path = os.path.join(self.daemondir, 'staticd')
         staticd_option = self.daemons_options['staticd']
         self.cmd('{0} {1} > staticd.out 2> staticd.err &'.format(
              staticd_path, staticd_option, self.logdir, self.name
         ))
         self.waitOutput()
         logger.debug('{}: {} staticd started'.format(self, self.routertype))
    # Fix Link-Local Addresses
     # Somehow (on Mininet only), Zebra removes the IPv6 Link-Local addresses on start. Fix this
     self.cmd('for i in `ls /sys/class/net/` ; do mac=`cat /sys/class/net/$i/address`; IFS=\':\'; set $mac; unset IFS; ip address add dev $i scope link fe80::$(printf %02x $((0x$1 ^ 2)))$2:${3}ff:fe$4:$5$6/64; done')
     # Now start all the other daemons
     for daemon in self.daemons:
         # Skip disabled daemons and zebra
         if self.daemons[daemon] == 0 or daemon == 'zebra' or daemon == 'staticd':
             continue
         daemon_path = os.path.join(self.daemondir, daemon)
         self.cmd('{0} {1} > {2}.out 2> {2}.err &'.format(
             daemon_path, self.daemons_options.get(daemon, ''), daemon
         ))
         self.waitOutput()
         logger.debug('{}: {} {} started'.format(self, self.routertype, daemon))
コード例 #2
0
ファイル: conftest.py プロジェクト: patrasar/frr
def pytest_runtest_makereport(item, call):
    "Log all assert messages to default logger with error level"

    # Nothing happened
    if call.when == "call":
        pause = topotest_extra_config["pause"]
    else:
        pause = False

    title = "unset"

    if call.excinfo is None:
        error = False
    else:
        parent = item.parent
        modname = parent.module.__name__

        # Treat skips as non errors, don't pause after
        if call.excinfo.typename == "Skipped":
            pause = False
            error = False
            logger.info('test skipped at "{}/{}": {}'.format(
                modname, item.name, call.excinfo.value))
        else:
            error = True
            # Handle assert failures
            parent._previousfailed = item  # pylint: disable=W0212
            logger.error('test failed at "{}/{}": {}'.format(
                modname, item.name, call.excinfo.value))
            title = "{}/{}".format(modname, item.name)

            # We want to pause, if requested, on any error not just test cases
            # (e.g., call.when == "setup")
            if not pause:
                pause = (topotest_extra_config["pause_on_error"]
                         or topotest_extra_config["pause"])

            # (topogen) Set topology error to avoid advancing in the test.
            tgen = get_topogen()
            if tgen is not None:
                # This will cause topogen to report error on `routers_have_failure`.
                tgen.set_error("{}/{}".format(modname, item.name))

    commander = Commander("pytest")
    isatty = sys.stdout.isatty()
    error_cmd = None

    if error and topotest_extra_config["vtysh_on_error"]:
        error_cmd = commander.get_exec_path(["vtysh"])
    elif error and topotest_extra_config["shell_on_error"]:
        error_cmd = os.getenv("SHELL", commander.get_exec_path(["bash"]))

    if error_cmd:
        is_tmux = bool(os.getenv("TMUX", ""))
        is_screen = not is_tmux and bool(os.getenv("STY", ""))
        is_xterm = not is_tmux and not is_screen and bool(
            os.getenv("DISPLAY", ""))

        channel = None
        win_info = None
        wait_for_channels = []
        wait_for_procs = []
        # Really would like something better than using this global here.
        # Not all tests use topogen though so get_topogen() won't work.
        for node in Mininet.g_mnet_inst.hosts.values():
            pause = True

            if is_tmux:
                channel = ("{}-{}".format(os.getpid(), Commander.tmux_wait_gen)
                           if not isatty else None)
                Commander.tmux_wait_gen += 1
                wait_for_channels.append(channel)

            pane_info = node.run_in_window(
                error_cmd,
                new_window=win_info is None,
                background=True,
                title="{} ({})".format(title, node.name),
                name=title,
                tmux_target=win_info,
                wait_for=channel,
            )
            if is_tmux:
                if win_info is None:
                    win_info = pane_info
            elif is_xterm:
                assert isinstance(pane_info, subprocess.Popen)
                wait_for_procs.append(pane_info)

        # Now wait on any channels
        for channel in wait_for_channels:
            logger.debug("Waiting on TMUX channel %s", channel)
            commander.cmd_raises(
                [commander.get_exec_path("tmux"), "wait", channel])
        for p in wait_for_procs:
            logger.debug("Waiting on TMUX xterm process %s", p)
            o, e = p.communicate()
            if p.wait():
                logger.warning("xterm proc failed: %s:", proc_error(p, o, e))

    if error and topotest_extra_config["cli_on_error"]:
        # Really would like something better than using this global here.
        # Not all tests use topogen though so get_topogen() won't work.
        if Mininet.g_mnet_inst:
            cli(Mininet.g_mnet_inst, title=title, background=False)
        else:
            logger.error("Could not launch CLI b/c no mininet exists yet")

    while pause and isatty:
        try:
            user = raw_input(
                'PAUSED, "cli" for CLI, "pdb" to debug, "Enter" to continue: ')
        except NameError:
            user = input(
                'PAUSED, "cli" for CLI, "pdb" to debug, "Enter" to continue: ')
        user = user.strip()

        if user == "cli":
            cli(Mininet.g_mnet_inst)
        elif user == "pdb":
            pdb.set_trace()
        elif user:
            print('Unrecognized input: "%s"' % user)
        else:
            break
コード例 #3
0
ファイル: common_config.py プロジェクト: Me0w1ng/frr-orange
def create_route_maps(tgen, input_dict, build=False):
    """
    Create route-map on the devices as per the arguments passed

    Parameters
    ----------
    * `tgen` : Topogen object
    * `input_dict` : Input dict data, required when configuring from testcase
    * `build` : Only for initial setup phase this is set as True.

    Usage
    -----
    # route_maps: key, value pair for route-map name and its attribute
    # rmap_match_prefix_list_1: user given name for route-map
    # action: PERMIT/DENY
    # match: key,value pair for match criteria. prefix_list, community-list,
             large-community-list or tag. Only one option at a time.
    # prefix_list: name of prefix list
    # large-community-list: name of large community list
    # community-ist: name of community list
    # tag: tag id for static routes
    # set: key, value pair for modifying route attributes
    # localpref: preference value for the network
    # med: metric value advertised for AS
    # aspath: set AS path value
    # weight: weight for the route
    # community: standard community value to be attached
    # large_community: large community value to be attached
    # community_additive: if set to "additive", adds community/large-community
                          value to the existing values of the network prefix

    Example:
    --------
    input_dict = {
        "r1": {
            "route_maps": {
                "rmap_match_prefix_list_1": [
                    {
                        "action": "PERMIT",
                        "match": {
                            "ipv4": {
                                "prefix_list": "pf_list_1"
                            }
                            "ipv6": {
                                "prefix_list": "pf_list_1"
                            }

                            "large-community-list": "{
                                "id": "community_1",
                                "exact_match": True
                            }
                            "community": {
                                "id": "community_2",
                                "exact_match": True
                            }
                            "tag": "tag_id"
                        },
                        "set": {
                            "localpref": 150,
                            "med": 30,
                            "aspath": {
                                "num": 20000,
                                "action": "prepend",
                            },
                            "weight": 500,
                            "community": {
                                "num": "1:2 2:3",
                                "action": additive
                            }
                            "large_community": {
                                "num": "1:2:3 4:5;6",
                                "action": additive
                            },
                        }
                    }
                ]
            }
        }
    }

    Returns
    -------
    errormsg(str) or True
    """

    result = False
    logger.debug("Entering lib API: create_route_maps()")

    try:
        for router in input_dict.keys():
            if "route_maps" not in input_dict[router]:
                errormsg = "route_maps not present in input_dict"
                logger.info(errormsg)
                continue
            rmap_data = []
            for rmap_name, rmap_value in \
                    input_dict[router]["route_maps"].iteritems():

                for rmap_dict in rmap_value:
                    del_action = rmap_dict.setdefault("delete", False)

                    if del_action:
                        rmap_data.append("no route-map {}".format(rmap_name))
                        continue

                    if "action" not in rmap_dict:
                        errormsg = "action not present in input_dict"
                        logger.error(errormsg)
                        return False

                    rmap_action = rmap_dict.setdefault("action", "deny")

                    seq_id = rmap_dict.setdefault("seq_id", None)
                    if seq_id is None:
                        seq_id = get_seq_id("route_maps", router, rmap_name)
                    else:
                        set_seq_id("route_maps", router, seq_id, rmap_name)

                    rmap_data.append("route-map {} {} {}".format(
                        rmap_name, rmap_action, seq_id))

                    # Verifying if SET criteria is defined
                    if "set" in rmap_dict:
                        set_data = rmap_dict["set"]

                        local_preference = set_data.setdefault(
                            "localpref", None)
                        metric = set_data.setdefault("med", None)
                        as_path = set_data.setdefault("aspath", {})
                        weight = set_data.setdefault("weight", None)
                        community = set_data.setdefault("community", {})
                        large_community = set_data.setdefault(
                            "large_community", {})
                        set_action = set_data.setdefault("set_action", None)

                        # Local Preference
                        if local_preference:
                            rmap_data.append("set local-preference {}".format(
                                local_preference))

                        # Metric
                        if metric:
                            rmap_data.append("set metric {} \n".format(metric))

                        # AS Path Prepend
                        if as_path:
                            as_num = as_path.setdefault("as_num", None)
                            as_action = as_path.setdefault("as_action", None)
                            if as_action and as_num:
                                rmap_data.append("set as-path {} {}".format(
                                    as_action, as_num))

                        # Community
                        if community:
                            num = community.setdefault("num", None)
                            comm_action = community.setdefault("action", None)
                            if num:
                                cmd = "set community {}".format(num)
                                if comm_action:
                                    cmd = "{} {}".format(cmd, comm_action)
                                rmap_data.append(cmd)
                            else:
                                logger.error("In community, AS Num not"
                                             " provided")
                                return False

                        if large_community:
                            num = large_community.setdefault("num", None)
                            comm_action = large_community.setdefault(
                                "action", None)
                            if num:
                                cmd = "set large-community {}".format(num)
                                if comm_action:
                                    cmd = "{} {}".format(cmd, comm_action)

                                rmap_data.append(cmd)
                            else:
                                logger.errror("In large_community, AS Num not"
                                              " provided")
                                return False

                        # Weight
                        if weight:
                            rmap_data.append("set weight {} \n".format(weight))

                    # Adding MATCH and SET sequence to RMAP if defined
                    if "match" in rmap_dict:
                        match_data = rmap_dict["match"]
                        ipv4_data = match_data.setdefault("ipv4", {})
                        ipv6_data = match_data.setdefault("ipv6", {})
                        community = match_data.setdefault("community-list", {})
                        large_community = match_data.setdefault(
                            "large-community-list", {})
                        tag = match_data.setdefault("tag", None)

                        if ipv4_data:
                            prefix_name = ipv4_data.setdefault(
                                "prefix_lists", None)
                            if prefix_name:
                                rmap_data.append("match ip address prefix-list"
                                                 " {}".format(prefix_name))
                        if ipv6_data:
                            prefix_name = ipv6_data.setdefault(
                                "prefix_lists", None)
                            if prefix_name:
                                rmap_data.append(
                                    "match ipv6 address "
                                    "prefix-list {}".format(prefix_name))
                        if tag:
                            rmap_data.append("match tag {}".format(tag))

                        if community:
                            if "id" not in community:
                                logger.error("'id' is mandatory for "
                                             "community-list in match"
                                             " criteria")
                                return False
                            cmd = "match community {}".format(community["id"])
                            exact_match = community.setdefault(
                                "exact_match", False)
                            if exact_match:
                                cmd = "{} exact-match".format(cmd)

                            rmap_data.append(cmd)

                        if large_community:
                            if "id" not in large_community:
                                logger.error("'num' is mandatory for "
                                             "large-community-list in match "
                                             "criteria")
                                return False
                            cmd = "match large-community {}".format(
                                large_community["id"])
                            exact_match = large_community.setdefault(
                                "exact_match", False)
                            if exact_match:
                                cmd = "{} exact-match".format(cmd)

                            rmap_data.append(cmd)

            result = create_common_configuration(tgen,
                                                 router,
                                                 rmap_data,
                                                 "route_maps",
                                                 build=build)

    except InvalidCLIError:
        # Traceback
        errormsg = traceback.format_exc()
        logger.error(errormsg)
        return errormsg

    logger.debug("Exiting lib API: create_prefix_lists()")
    return result
コード例 #4
0
ファイル: common_config.py プロジェクト: Me0w1ng/frr-orange
def create_prefix_lists(tgen, input_dict, build=False):
    """
    Create ip prefix lists as per the config provided in input
    JSON or input_dict

    Parameters
    ----------
    * `tgen` : Topogen object
    * `input_dict` : Input dict data, required when configuring from testcase
    * `build` : Only for initial setup phase this is set as True.

    Usage
    -----
    # pf_lists_1: name of prefix-list, user defined
    # seqid: prefix-list seqid, auto-generated if not given by user
    # network: criteria for applying prefix-list
    # action: permit/deny
    # le: less than or equal number of bits
    # ge: greater than or equal number of bits

    Example
    -------
    input_dict = {
        "r1": {
            "prefix_lists":{
                "ipv4": {
                    "pf_list_1": [
                        {
                            "seqid": 10,
                            "network": "any",
                            "action": "permit",
                            "le": "32",
                            "ge": "30",
                            "delete": True
                        }
                    ]
                }
            }
        }
    }

    Returns
    -------
    errormsg or True
    """

    logger.debug("Entering lib API: create_prefix_lists()")
    result = False
    try:
        for router in input_dict.keys():
            if "prefix_lists" not in input_dict[router]:
                errormsg = "prefix_lists not present in input_dict"
                logger.info(errormsg)
                continue

            config_data = []
            prefix_lists = input_dict[router]["prefix_lists"]
            for addr_type, prefix_data in prefix_lists.iteritems():
                if not check_address_types(addr_type):
                    continue

                for prefix_name, prefix_list in prefix_data.iteritems():
                    for prefix_dict in prefix_list:
                        if "action" not in prefix_dict or \
                                "network" not in prefix_dict:
                            errormsg = "'action' or network' missing in" \
                                       " input_dict"
                            return errormsg

                        network_addr = prefix_dict["network"]
                        action = prefix_dict["action"]
                        le = prefix_dict.setdefault("le", None)
                        ge = prefix_dict.setdefault("ge", None)
                        seqid = prefix_dict.setdefault("seqid", None)
                        del_action = prefix_dict.setdefault("delete", False)
                        if seqid is None:
                            seqid = get_seq_id("prefix_lists", router,
                                               prefix_name)
                        else:
                            set_seq_id("prefix_lists", router, seqid,
                                       prefix_name)

                        if addr_type == "ipv4":
                            protocol = "ip"
                        else:
                            protocol = "ipv6"

                        cmd = "{} prefix-list {} seq {} {} {}".format(
                            protocol, prefix_name, seqid, action, network_addr)
                        if le:
                            cmd = "{} le {}".format(cmd, le)
                        if ge:
                            cmd = "{} ge {}".format(cmd, ge)

                        if del_action:
                            cmd = "no {}".format(cmd)

                        config_data.append(cmd)
            result = create_common_configuration(tgen,
                                                 router,
                                                 config_data,
                                                 "prefix_list",
                                                 build=build)

    except InvalidCLIError:
        # Traceback
        errormsg = traceback.format_exc()
        logger.error(errormsg)
        return errormsg

    logger.debug("Exiting lib API: create_prefix_lists()")
    return result
コード例 #5
0
ファイル: common_config.py プロジェクト: Me0w1ng/frr-orange
def create_static_routes(tgen, input_dict, build=False):
    """
    Create static routes for given router as defined in input_dict

    Parameters
    ----------
    * `tgen` : Topogen object
    * `input_dict` : Input dict data, required when configuring from testcase
    * `build` : Only for initial setup phase this is set as True.

    Usage
    -----
    input_dict should be in the format below:
    # static_routes: list of all routes
    # network: network address
    # no_of_ip: number of next-hop address that will be configured
    # admin_distance: admin distance for route/routes.
    # next_hop: starting next-hop address
    # tag: tag id for static routes
    # delete: True if config to be removed. Default False.

    Example:
    "routers": {
        "r1": {
            "static_routes": [
                {
                    "network": "100.0.20.1/32",
                    "no_of_ip": 9,
                    "admin_distance": 100,
                    "next_hop": "10.0.0.1",
                    "tag": 4001
                    "delete": true
                }
            ]
        }
    }

    Returns
    -------
    errormsg(str) or True
    """
    result = False
    logger.debug("Entering lib API: create_static_routes()")
    try:
        for router in input_dict.keys():
            if "static_routes" not in input_dict[router]:
                errormsg = "static_routes not present in input_dict"
                logger.info(errormsg)
                continue

            static_routes_list = []

            static_routes = input_dict[router]["static_routes"]
            for static_route in static_routes:
                del_action = static_route.setdefault("delete", False)
                # No of IPs
                no_of_ip = static_route.setdefault("no_of_ip", 1)
                admin_distance = static_route.setdefault(
                    "admin_distance", None)
                tag = static_route.setdefault("tag", None)
                if "next_hop" not in static_route or \
                        "network" not in static_route:
                    errormsg = "'next_hop' or 'network' missing in" \
                               " input_dict"
                    return errormsg

                next_hop = static_route["next_hop"]
                network = static_route["network"]
                ip_list = generate_ips([network], no_of_ip)
                for ip in ip_list:
                    addr_type = validate_ip_address(ip)
                    if addr_type == "ipv4":
                        cmd = "ip route {} {}".format(ip, next_hop)
                    else:
                        cmd = "ipv6 route {} {}".format(ip, next_hop)

                    if tag:
                        cmd = "{} {}".format(cmd, str(tag))
                    if admin_distance:
                        cmd = "{} {}".format(cmd, admin_distance)

                    if del_action:
                        cmd = "no {}".format(cmd)

                    static_routes_list.append(cmd)

            result = create_common_configuration(tgen,
                                                 router,
                                                 static_routes_list,
                                                 "static_route",
                                                 build=build)

    except InvalidCLIError:
        # Traceback
        errormsg = traceback.format_exc()
        logger.error(errormsg)
        return errormsg

    logger.debug("Exiting lib API: create_static_routes()")
    return result
コード例 #6
0
ファイル: common_config.py プロジェクト: Me0w1ng/frr-orange
def reset_config_on_routers(tgen, routerName=None):
    """
    Resets configuration on routers to the snapshot created using input JSON
    file. It replaces existing router configuration with FRRCFG_BKUP_FILE

    Parameters
    ----------
    * `tgen` : Topogen object
    * `routerName` : router config is to be reset
    """

    logger.debug("Entering API: reset_config_on_routers")

    router_list = tgen.routers()
    for rname, router in router_list.iteritems():
        if routerName and routerName != rname:
            continue

        cfg = router.run("vtysh -c 'show running'")
        fname = "{}/{}/frr.sav".format(TMPDIR, rname)
        dname = "{}/{}/delta.conf".format(TMPDIR, rname)
        f = open(fname, "w")
        for line in cfg.split("\n"):
            line = line.strip()

            if (line == "Building configuration..."
                    or line == "Current configuration:" or not line):
                continue
            f.write(line)
            f.write("\n")

        f.close()

        command = "/usr/lib/frr/frr-reload.py  --input {}/{}/frr.sav" \
                  " --test {}/{}/frr_json_initial.conf > {}". \
            format(TMPDIR, rname, TMPDIR, rname, dname)
        result = call(command, shell=True, stderr=SUB_STDOUT)

        # Assert if command fail
        if result > 0:
            errormsg = ("Command:{} is failed due to non-zero exit"
                        " code".format(command))
            return errormsg

        f = open(dname, "r")
        delta = StringIO.StringIO()
        delta.write("configure terminal\n")
        t_delta = f.read()
        for line in t_delta.split("\n"):
            line = line.strip()
            if (line == "Lines To Delete" or line == "==============="
                    or line == "Lines To Add" or line == "============"
                    or not line):
                continue
            delta.write(line)
            delta.write("\n")

        delta.write("end\n")
        output = router.vtysh_multicmd(delta.getvalue(), pretty_output=False)
        logger.info("New configuration for router {}:".format(rname))
        delta.close()
        delta = StringIO.StringIO()
        cfg = router.run("vtysh -c 'show running'")
        for line in cfg.split("\n"):
            line = line.strip()
            delta.write(line)
            delta.write("\n")

        # Router current configuration to log file or console if
        # "show_router_config" is defined in "pytest.ini"
        if show_router_config:
            logger.info(delta.getvalue())
        delta.close()

    logger.debug("Exting API: reset_config_on_routers")
    return True
コード例 #7
0
ファイル: ospf.py プロジェクト: vishaldhingra/frr
def verify_ospf_neighbor(tgen, topo, dut=None, input_dict=None, lan=False):
    """
    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

    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 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
コード例 #8
0
ファイル: ospf.py プロジェクト: zpericic/frr
def __create_ospf_global(tgen,
                         input_dict,
                         router,
                         build=False,
                         load_config=True):
    """
    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.

    Returns
    -------
    True or False
    """

    result = False
    logger.debug("Entering lib API: __create_ospf_global()")
    try:

        ospf_data = input_dict[router]["ospf"]
        del_ospf_action = ospf_data.setdefault("delete", False)
        if del_ospf_action:
            config_data = ["no router ospf"]
            result = create_common_configuration(tgen, router, config_data,
                                                 "ospf", build, load_config)
            return result

        config_data = []
        cmd = "router 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 ospf router-id")
        if router_id:
            config_data.append("ospf router-id {}".format(router_id))

        # 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)
        result = create_common_configuration(tgen, router, config_data, "ospf",
                                             build, load_config)

        # 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)
        result = create_common_configuration(tgen, router, config_data, "ospf",
                                             build, load_config)

    except InvalidCLIError:
        # Traceback
        errormsg = traceback.format_exc()
        logger.error(errormsg)
        return errormsg

    logger.debug("Exiting lib API: create_ospf_global()")
    return result
コード例 #9
0
ファイル: ospf.py プロジェクト: vishaldhingra/frr
def verify_ospf_summary(tgen, topo, dut, input_dict):
    """
    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: verify_ospf_summary()")
    result = False
    router = dut

    logger.info("Verifying OSPF summary on router %s:", router)

    if "ospf" not in topo["routers"][dut]:
        errormsg = "[DUT: {}] OSPF is not configured on the router.".format(
            router)
        return errormsg

    rnode = tgen.routers()[dut]
    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
    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 %s, "
                                "Expected is {}".format(
                                    router, summary, summ,
                                    show_ospf_json[summary][summ]))
                    return errormsg

    logger.debug("Exiting API: verify_ospf_summary()")
    return result
コード例 #10
0
ファイル: ospf.py プロジェクト: vishaldhingra/frr
def verify_ospf_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": {
            "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
コード例 #11
0
ファイル: ospf.py プロジェクト: vishaldhingra/frr
def verify_ospf_interface(tgen, topo, 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': {
                    '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
    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
コード例 #12
0
ファイル: ospf.py プロジェクト: vishaldhingra/frr
def __create_ospf_global(tgen,
                         input_dict,
                         router,
                         build=False,
                         load_config=True,
                         ospf="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
    -------
    True or False
    """

    result = False
    logger.debug("Entering lib API: __create_ospf_global()")
    try:

        ospf_data = input_dict[router][ospf]
        del_ospf_action = ospf_data.setdefault("delete", False)
        if del_ospf_action:
            config_data = ["no router {}".format(ospf)]
            result = create_common_configuration(tgen, router, config_data,
                                                 ospf, build, load_config)
            return result

        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))

        # 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)

        # area interface information for ospf6d only
        if ospf == "ospf6":
            area_iface = ospf_data.setdefault("neighbors", {})
            if area_iface:
                for neighbor in area_iface:
                    if "area" in area_iface[neighbor]:
                        iface = input_dict[router]["links"][neighbor][
                            "interface"]
                        cmd = "interface {} area {}".format(
                            iface, area_iface[neighbor]["area"])
                        if area_iface[neighbor].setdefault("delete", False):
                            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)

        result = create_common_configuration(tgen, router, config_data, ospf,
                                             build, load_config)

    except InvalidCLIError:
        # Traceback
        errormsg = traceback.format_exc()
        logger.error(errormsg)
        return errormsg

    logger.debug("Exiting lib API: create_ospf_global()")
    return result
コード例 #13
0
ファイル: topojson.py プロジェクト: zxybupt/FRRouting
def build_topo_from_json(tgen, topo):
    """
    Reads configuration from JSON file. Adds routers, creates interface
    names dynamically and link routers as defined in JSON to create
    topology. Assigns IPs dynamically to all interfaces of each router.

    * `tgen`: Topogen object
    * `topo`: json file data
    """

    ROUTER_LIST = sorted(topo['routers'].keys(),
                         key=lambda x: int(re_search('\d+', x).group(0)))

    listRouters = ROUTER_LIST[:]
    for routerN in ROUTER_LIST:
        logger.info('Topo: Add router {}'.format(routerN))
        tgen.add_router(routerN)
        listRouters.append(routerN)

    if 'ipv4base' in topo:
        ipv4Next = ipaddr.IPv4Address(topo['link_ip_start']['ipv4'])
        ipv4Step = 2**(32 - topo['link_ip_start']['v4mask'])
        if topo['link_ip_start']['v4mask'] < 32:
            ipv4Next += 1
    if 'ipv6base' in topo:
        ipv6Next = ipaddr.IPv6Address(topo['link_ip_start']['ipv6'])
        ipv6Step = 2**(128 - topo['link_ip_start']['v6mask'])
        if topo['link_ip_start']['v6mask'] < 127:
            ipv6Next += 1
    for router in listRouters:
        topo['routers'][router]['nextIfname'] = 0

    while listRouters != []:
        curRouter = listRouters.pop(0)
        # Physical Interfaces
        if 'links' in topo['routers'][curRouter]:

            def link_sort(x):
                if x == 'lo':
                    return 0
                elif 'link' in x:
                    return int(x.split('-link')[1])
                else:
                    return int(re_search('\d+', x).group(0))
            for destRouterLink, data in sorted(topo['routers'][curRouter]['links']. \
                                               iteritems(),
                                               key=lambda x: link_sort(x[0])):
                currRouter_lo_json = \
                    topo['routers'][curRouter]['links'][destRouterLink]
                # Loopback interfaces
                if 'type' in data and data['type'] == 'loopback':
                    if 'ipv4' in currRouter_lo_json and \
                            currRouter_lo_json['ipv4'] == 'auto':
                        currRouter_lo_json['ipv4'] = '{}{}.{}/{}'. \
                            format(topo['lo_prefix']['ipv4'], number_to_row(curRouter), \
                                   number_to_column(curRouter), topo['lo_prefix']['v4mask'])
                    if 'ipv6' in currRouter_lo_json and \
                            currRouter_lo_json['ipv6'] == 'auto':
                        currRouter_lo_json['ipv6'] = '{}{}:{}/{}'. \
                            format(topo['lo_prefix']['ipv6'], number_to_row(curRouter), \
                                   number_to_column(curRouter), topo['lo_prefix']['v6mask'])

                if "-" in destRouterLink:
                    # Spliting and storing destRouterLink data in tempList
                    tempList = destRouterLink.split("-")

                    # destRouter
                    destRouter = tempList.pop(0)

                    # Current Router Link
                    tempList.insert(0, curRouter)
                    curRouterLink = "-".join(tempList)
                else:
                    destRouter = destRouterLink
                    curRouterLink = curRouter

                if destRouter in listRouters:
                    currRouter_link_json = \
                        topo['routers'][curRouter]['links'][destRouterLink]
                    destRouter_link_json = \
                        topo['routers'][destRouter]['links'][curRouterLink]

                    # Assigning name to interfaces
                    currRouter_link_json['interface'] = \
                        '{}-{}-eth{}'.format(curRouter, destRouter, topo['routers'] \
                            [curRouter]['nextIfname'])
                    destRouter_link_json['interface'] = \
                        '{}-{}-eth{}'.format(destRouter, curRouter, topo['routers'] \
                            [destRouter]['nextIfname'])

                    topo['routers'][curRouter]['nextIfname'] += 1
                    topo['routers'][destRouter]['nextIfname'] += 1

                    # Linking routers to each other as defined in JSON file
                    tgen.gears[curRouter].add_link(tgen.gears[destRouter],
                        topo['routers'][curRouter]['links'][destRouterLink] \
                        ['interface'], topo['routers'][destRouter]['links'] \
                        [curRouterLink]['interface'])

                    # IPv4
                    if 'ipv4' in currRouter_link_json:
                        if currRouter_link_json['ipv4'] == 'auto':
                            currRouter_link_json['ipv4'] = \
                                '{}/{}'.format(ipv4Next, topo['link_ip_start'][ \
                                    'v4mask'])
                            destRouter_link_json['ipv4'] = \
                                '{}/{}'.format(ipv4Next + 1, topo['link_ip_start'][ \
                                    'v4mask'])
                            ipv4Next += ipv4Step
                    # IPv6
                    if 'ipv6' in currRouter_link_json:
                        if currRouter_link_json['ipv6'] == 'auto':
                            currRouter_link_json['ipv6'] = \
                                '{}/{}'.format(ipv6Next, topo['link_ip_start'][ \
                                    'v6mask'])
                            destRouter_link_json['ipv6'] = \
                                '{}/{}'.format(ipv6Next + 1, topo['link_ip_start'][ \
                                    'v6mask'])
                            ipv6Next = ipaddr.IPv6Address(
                                int(ipv6Next) + ipv6Step)

            logger.debug(
                "Generated link data for router: %s\n%s", curRouter,
                json_dumps(topo["routers"][curRouter]["links"],
                           indent=4,
                           sort_keys=True))
コード例 #14
0
def build_topo_from_json(tgen, topo=None):
    """
    Reads configuration from JSON file. Adds routers, creates interface
    names dynamically and link routers as defined in JSON to create
    topology. Assigns IPs dynamically to all interfaces of each router.
    * `tgen`: Topogen object
    * `topo`: json file data, or use tgen.json_topo if None
    """
    if topo is None:
        topo = tgen.json_topo

    router_list = sorted(topo["routers"].keys(),
                         key=lambda x: int(re_search(r"\d+", x).group(0)))

    switch_list = []
    if "switches" in topo:
        switch_list = sorted(topo["switches"].keys(),
                             key=lambda x: int(re_search(r"\d+", x).group(0)))

    listRouters = sorted(router_list[:])
    listSwitches = sorted(switch_list[:])
    listAllRouters = deepcopy(listRouters)
    dictSwitches = {}

    for routerN in router_list:
        logger.info("Topo: Add router {}".format(routerN))
        tgen.add_router(routerN)

    for switchN in switch_list:
        logger.info("Topo: Add switch {}".format(switchN))
        dictSwitches[switchN] = tgen.add_switch(switchN)

    if "ipv4base" in topo:
        ipv4Next = ipaddress.IPv4Address(topo["link_ip_start"]["ipv4"])
        ipv4Step = 2**(32 - topo["link_ip_start"]["v4mask"])
        if topo["link_ip_start"]["v4mask"] < 32:
            ipv4Next += 1
    if "ipv6base" in topo:
        ipv6Next = ipaddress.IPv6Address(topo["link_ip_start"]["ipv6"])
        ipv6Step = 2**(128 - topo["link_ip_start"]["v6mask"])
        if topo["link_ip_start"]["v6mask"] < 127:
            ipv6Next += 1
    for router in listRouters:
        topo["routers"][router]["nextIfname"] = 0

    router_count = 0
    while listRouters != []:
        curRouter = listRouters.pop(0)
        # Physical Interfaces
        if "links" in topo["routers"][curRouter]:
            for destRouterLink, data in sorted(
                    topo["routers"][curRouter]["links"].items()):
                currRouter_lo_json = topo["routers"][curRouter]["links"][
                    destRouterLink]
                # Loopback interfaces
                if "type" in data and data["type"] == "loopback":
                    router_count += 1
                    if ("ipv4" in currRouter_lo_json
                            and currRouter_lo_json["ipv4"] == "auto"):
                        currRouter_lo_json["ipv4"] = "{}{}.{}/{}".format(
                            topo["lo_prefix"]["ipv4"],
                            router_count,
                            number_to_column(curRouter),
                            topo["lo_prefix"]["v4mask"],
                        )
                    if ("ipv6" in currRouter_lo_json
                            and currRouter_lo_json["ipv6"] == "auto"):
                        currRouter_lo_json["ipv6"] = "{}{}:{}/{}".format(
                            topo["lo_prefix"]["ipv6"],
                            router_count,
                            number_to_column(curRouter),
                            topo["lo_prefix"]["v6mask"],
                        )

                if "-" in destRouterLink:
                    # Spliting and storing destRouterLink data in tempList
                    tempList = destRouterLink.split("-")

                    # destRouter
                    destRouter = tempList.pop(0)

                    # Current Router Link
                    tempList.insert(0, curRouter)
                    curRouterLink = "-".join(tempList)
                else:
                    destRouter = destRouterLink
                    curRouterLink = curRouter

                if destRouter in listRouters:
                    currRouter_link_json = topo["routers"][curRouter]["links"][
                        destRouterLink]
                    destRouter_link_json = topo["routers"][destRouter][
                        "links"][curRouterLink]

                    # Assigning name to interfaces
                    currRouter_link_json["interface"] = "{}-{}-eth{}".format(
                        curRouter, destRouter,
                        topo["routers"][curRouter]["nextIfname"])
                    destRouter_link_json["interface"] = "{}-{}-eth{}".format(
                        destRouter, curRouter,
                        topo["routers"][destRouter]["nextIfname"])

                    # add link interface
                    destRouter_link_json[
                        "peer-interface"] = "{}-{}-eth{}".format(
                            curRouter, destRouter,
                            topo["routers"][curRouter]["nextIfname"])
                    currRouter_link_json[
                        "peer-interface"] = "{}-{}-eth{}".format(
                            destRouter, curRouter,
                            topo["routers"][destRouter]["nextIfname"])

                    topo["routers"][curRouter]["nextIfname"] += 1
                    topo["routers"][destRouter]["nextIfname"] += 1

                    # Linking routers to each other as defined in JSON file
                    tgen.gears[curRouter].add_link(
                        tgen.gears[destRouter],
                        topo["routers"][curRouter]["links"][destRouterLink]
                        ["interface"],
                        topo["routers"][destRouter]["links"][curRouterLink]
                        ["interface"],
                    )

                    # IPv4
                    if "ipv4" in currRouter_link_json:
                        if currRouter_link_json["ipv4"] == "auto":
                            currRouter_link_json["ipv4"] = "{}/{}".format(
                                ipv4Next, topo["link_ip_start"]["v4mask"])
                            destRouter_link_json["ipv4"] = "{}/{}".format(
                                ipv4Next + 1, topo["link_ip_start"]["v4mask"])
                            ipv4Next += ipv4Step
                    # IPv6
                    if "ipv6" in currRouter_link_json:
                        if currRouter_link_json["ipv6"] == "auto":
                            currRouter_link_json["ipv6"] = "{}/{}".format(
                                ipv6Next, topo["link_ip_start"]["v6mask"])
                            destRouter_link_json["ipv6"] = "{}/{}".format(
                                ipv6Next + 1, topo["link_ip_start"]["v6mask"])
                            ipv6Next = ipaddress.IPv6Address(
                                int(ipv6Next) + ipv6Step)

            logger.debug(
                "Generated link data for router: %s\n%s",
                curRouter,
                json.dumps(topo["routers"][curRouter]["links"],
                           indent=4,
                           sort_keys=True),
            )

    switch_count = 0
    add_switch_to_topo = []
    while listSwitches != []:
        curSwitch = listSwitches.pop(0)
        # Physical Interfaces
        if "links" in topo["switches"][curSwitch]:
            for destRouterLink, data in sorted(
                    topo["switches"][curSwitch]["links"].items()):

                # Loopback interfaces
                if "dst_node" in data:
                    destRouter = data["dst_node"]

                elif "-" in destRouterLink:
                    # Spliting and storing destRouterLink data in tempList
                    tempList = destRouterLink.split("-")
                    # destRouter
                    destRouter = tempList.pop(0)
                else:
                    destRouter = destRouterLink

                if destRouter in listAllRouters:

                    topo["routers"][destRouter]["links"][curSwitch] = deepcopy(
                        topo["switches"][curSwitch]["links"][destRouterLink])

                    # Assigning name to interfaces
                    topo["routers"][destRouter]["links"][curSwitch][
                        "interface"] = "{}-{}-eth{}".format(
                            destRouter, curSwitch,
                            topo["routers"][destRouter]["nextIfname"])

                    topo["switches"][curSwitch]["links"][destRouter][
                        "interface"] = "{}-{}-eth{}".format(
                            curSwitch, destRouter,
                            topo["routers"][destRouter]["nextIfname"])

                    topo["routers"][destRouter]["nextIfname"] += 1

                    # Add links
                    dictSwitches[curSwitch].add_link(
                        tgen.gears[destRouter],
                        topo["switches"][curSwitch]["links"][destRouter]
                        ["interface"],
                        topo["routers"][destRouter]["links"][curSwitch]
                        ["interface"],
                    )

                    # IPv4
                    if "ipv4" in topo["routers"][destRouter]["links"][
                            curSwitch]:
                        if (topo["routers"][destRouter]["links"][curSwitch]
                            ["ipv4"] == "auto"):
                            topo["routers"][destRouter]["links"][curSwitch][
                                "ipv4"] = "{}/{}".format(
                                    ipv4Next, topo["link_ip_start"]["v4mask"])
                            ipv4Next += 1
                    # IPv6
                    if "ipv6" in topo["routers"][destRouter]["links"][
                            curSwitch]:
                        if (topo["routers"][destRouter]["links"][curSwitch]
                            ["ipv6"] == "auto"):
                            topo["routers"][destRouter]["links"][curSwitch][
                                "ipv6"] = "{}/{}".format(
                                    ipv6Next, topo["link_ip_start"]["v6mask"])
                            ipv6Next = ipaddress.IPv6Address(
                                int(ipv6Next) + ipv6Step)

            logger.debug(
                "Generated link data for router: %s\n%s",
                curRouter,
                json.dumps(topo["routers"][curRouter]["links"],
                           indent=4,
                           sort_keys=True),
            )
コード例 #15
0
ファイル: ospf.py プロジェクト: vishaldhingra/frr
def config_ospf_interface(tgen,
                          topo,
                          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")
    if not input_dict:
        input_dict = deepcopy(topo)
    else:
        input_dict = deepcopy(input_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 configs is not present in"
                    "input_dict, passed input_dict",
                    router,
                    input_dict,
                )
                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)

            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 in ospf_data:
                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 in ospf_data:
                cmd = "ip ospf cost {}".format(ospf_data["cost"])
                if "del_action" in ospf_data:
                    cmd = "no {}".format(cmd)
                config_data.append(cmd)

            if build:
                return config_data
            else:
                result = create_common_configuration(tgen,
                                                     router,
                                                     config_data,
                                                     "interface_config",
                                                     build=build)
    logger.debug("Exiting lib API: create_igmp_config()")
    return result
コード例 #16
0
def build_topo_from_json(tgen, topo):
    """
    Reads configuration from JSON file. Adds routers, creates interface
    names dynamically and link routers as defined in JSON to create
    topology. Assigns IPs dynamically to all interfaces of each router.
    * `tgen`: Topogen object
    * `topo`: json file data
    """

    ROUTER_LIST = sorted(topo["routers"].keys(),
                         key=lambda x: int(re_search("\d+", x).group(0)))

    SWITCH_LIST = []
    if "switches" in topo:
        SWITCH_LIST = sorted(topo["switches"].keys(),
                             key=lambda x: int(re_search("\d+", x).group(0)))

    listRouters = ROUTER_LIST[:]
    listSwitches = SWITCH_LIST[:]
    listAllRouters = deepcopy(listRouters)
    dictSwitches = {}

    for routerN in ROUTER_LIST:
        logger.info("Topo: Add router {}".format(routerN))
        tgen.add_router(routerN)
        listRouters.append(routerN)

    for switchN in SWITCH_LIST:
        logger.info("Topo: Add switch {}".format(switchN))
        dictSwitches[switchN] = tgen.add_switch(switchN)
        listSwitches.append(switchN)

    if "ipv4base" in topo:
        ipv4Next = ipaddress.IPv4Address(topo["link_ip_start"]["ipv4"])
        ipv4Step = 2**(32 - topo["link_ip_start"]["v4mask"])
        if topo["link_ip_start"]["v4mask"] < 32:
            ipv4Next += 1
    if "ipv6base" in topo:
        ipv6Next = ipaddress.IPv6Address(topo["link_ip_start"]["ipv6"])
        ipv6Step = 2**(128 - topo["link_ip_start"]["v6mask"])
        if topo["link_ip_start"]["v6mask"] < 127:
            ipv6Next += 1
    for router in listRouters:
        topo["routers"][router]["nextIfname"] = 0

    while listRouters != []:
        curRouter = listRouters.pop(0)
        # Physical Interfaces
        if "links" in topo["routers"][curRouter]:

            def link_sort(x):
                if x == "lo":
                    return 0
                elif "link" in x:
                    return int(x.split("-link")[1])
                else:
                    return int(re_search("\d+", x).group(0))

            for destRouterLink, data in sorted(
                    topo["routers"][curRouter]["links"].items(),
                    key=lambda x: link_sort(x[0]),
            ):
                currRouter_lo_json = topo["routers"][curRouter]["links"][
                    destRouterLink]
                # Loopback interfaces
                if "type" in data and data["type"] == "loopback":
                    if ("ipv4" in currRouter_lo_json
                            and currRouter_lo_json["ipv4"] == "auto"):
                        currRouter_lo_json["ipv4"] = "{}{}.{}/{}".format(
                            topo["lo_prefix"]["ipv4"],
                            number_to_row(curRouter),
                            number_to_column(curRouter),
                            topo["lo_prefix"]["v4mask"],
                        )
                    if ("ipv6" in currRouter_lo_json
                            and currRouter_lo_json["ipv6"] == "auto"):
                        currRouter_lo_json["ipv6"] = "{}{}:{}/{}".format(
                            topo["lo_prefix"]["ipv6"],
                            number_to_row(curRouter),
                            number_to_column(curRouter),
                            topo["lo_prefix"]["v6mask"],
                        )

                if "-" in destRouterLink:
                    # Spliting and storing destRouterLink data in tempList
                    tempList = destRouterLink.split("-")

                    # destRouter
                    destRouter = tempList.pop(0)

                    # Current Router Link
                    tempList.insert(0, curRouter)
                    curRouterLink = "-".join(tempList)
                else:
                    destRouter = destRouterLink
                    curRouterLink = curRouter

                if destRouter in listRouters:
                    currRouter_link_json = topo["routers"][curRouter]["links"][
                        destRouterLink]
                    destRouter_link_json = topo["routers"][destRouter][
                        "links"][curRouterLink]

                    # Assigning name to interfaces
                    currRouter_link_json["interface"] = "{}-{}-eth{}".format(
                        curRouter, destRouter,
                        topo["routers"][curRouter]["nextIfname"])
                    destRouter_link_json["interface"] = "{}-{}-eth{}".format(
                        destRouter, curRouter,
                        topo["routers"][destRouter]["nextIfname"])

                    topo["routers"][curRouter]["nextIfname"] += 1
                    topo["routers"][destRouter]["nextIfname"] += 1

                    # Linking routers to each other as defined in JSON file
                    tgen.gears[curRouter].add_link(
                        tgen.gears[destRouter],
                        topo["routers"][curRouter]["links"][destRouterLink]
                        ["interface"],
                        topo["routers"][destRouter]["links"][curRouterLink]
                        ["interface"],
                    )

                    # IPv4
                    if "ipv4" in currRouter_link_json:
                        if currRouter_link_json["ipv4"] == "auto":
                            currRouter_link_json["ipv4"] = "{}/{}".format(
                                ipv4Next, topo["link_ip_start"]["v4mask"])
                            destRouter_link_json["ipv4"] = "{}/{}".format(
                                ipv4Next + 1, topo["link_ip_start"]["v4mask"])
                            ipv4Next += ipv4Step
                    # IPv6
                    if "ipv6" in currRouter_link_json:
                        if currRouter_link_json["ipv6"] == "auto":
                            currRouter_link_json["ipv6"] = "{}/{}".format(
                                ipv6Next, topo["link_ip_start"]["v6mask"])
                            destRouter_link_json["ipv6"] = "{}/{}".format(
                                ipv6Next + 1, topo["link_ip_start"]["v6mask"])
                            ipv6Next = ipaddress.IPv6Address(
                                int(ipv6Next) + ipv6Step)

            logger.debug(
                "Generated link data for router: %s\n%s",
                curRouter,
                json_dumps(topo["routers"][curRouter]["links"],
                           indent=4,
                           sort_keys=True),
            )

    switch_count = 0
    add_switch_to_topo = []
    while listSwitches != []:
        curSwitch = listSwitches.pop(0)
        # Physical Interfaces
        if "links" in topo['switches'][curSwitch]:
            for destRouterLink, data in sorted(
                    topo['switches'][curSwitch]['links'].items()):

                # Loopback interfaces
                if "dst_node" in data:
                    destRouter = data['dst_node']

                elif "-" in destRouterLink:
                    # Spliting and storing destRouterLink data in tempList
                    tempList = destRouterLink.split("-")
                    # destRouter
                    destRouter = tempList.pop(0)
                else:
                    destRouter = destRouterLink

                if destRouter in listAllRouters:

                    topo['routers'][destRouter]['links'][curSwitch] = \
                        deepcopy(topo['switches'][curSwitch]['links'][destRouterLink])

                    # Assigning name to interfaces
                    topo['routers'][destRouter]['links'][curSwitch]['interface'] = \
                        '{}-{}-eth{}'.format(destRouter, curSwitch, topo['routers'] \
                            [destRouter]['nextIfname'])

                    topo['switches'][curSwitch]['links'][destRouter]['interface'] = \
                        '{}-{}-eth{}'.format(curSwitch, destRouter, topo['routers'] \
                            [destRouter]['nextIfname'])

                    topo['routers'][destRouter]['nextIfname'] += 1

                    # Add links
                    dictSwitches[curSwitch].add_link(tgen.gears[destRouter], \
                        topo['switches'][curSwitch]['links'][destRouter]['interface'],
                        topo['routers'][destRouter]['links'][curSwitch]['interface'],
                        )

                    # IPv4
                    if 'ipv4' in topo['routers'][destRouter]['links'][
                            curSwitch]:
                        if topo['routers'][destRouter]['links'][curSwitch][
                                'ipv4'] == 'auto':
                            topo['routers'][destRouter]['links'][curSwitch]['ipv4'] = \
                                '{}/{}'.format(ipv4Next, topo['link_ip_start'][ \
                                    'v4mask'])
                            ipv4Next += 1
                    # IPv6
                    if 'ipv6' in topo['routers'][destRouter]['links'][
                            curSwitch]:
                        if topo['routers'][destRouter]['links'][curSwitch][
                                'ipv6'] == 'auto':
                            topo['routers'][destRouter]['links'][curSwitch]['ipv6'] = \
                                '{}/{}'.format(ipv6Next, topo['link_ip_start'][ \
                                    'v6mask'])
                            ipv6Next = ipaddr.IPv6Address(
                                int(ipv6Next) + ipv6Step)

            logger.debug(
                "Generated link data for router: %s\n%s",
                curRouter,
                json_dumps(topo["routers"][curRouter]["links"],
                           indent=4,
                           sort_keys=True),
            )
コード例 #17
0
def verify_stale_routes_list(tgen, addr_type, dut, input_dict):
    """
    This API is use verify Stale routes on refering the network with next hop value
    Parameters
    ----------
    * `tgen`: topogen object
    * `dut`: input dut router name
    * `addr_type` : ip type ipv4/ipv6
    * `input_dict` : input dict, has details of static routes
    Usage
    -----
    dut = 'r1'
    input_dict = {
                "r3": {
                    "static_routes": [

                        {
                            "network": [NETWORK1_1[addr_type]],
                            "no_of_ip": 2,
                            "vrf": "RED"
                        }
                    ]
                }
            }

    result = verify_stale_routes_list(tgen, addr_type, dut, input_dict)
    Returns
    -------
    errormsg(str) or True
    """
    logger.debug("Entering lib API: verify_stale_routes_list()")
    router_list = tgen.routers()
    additional_nexthops_in_required_nhs = []
    list1 = []
    list2 = []
    found_hops = []
    for routerInput in input_dict.keys():
        for router, rnode in router_list.items():
            if router != dut:
                continue
            # Verifying RIB routes
            command = "show bgp"
            # Static routes
            sleep(2)
            logger.info('Checking router {} BGP RIB:'.format(dut))
            if 'static_routes' in input_dict[routerInput]:
                static_routes = input_dict[routerInput]["static_routes"]
                for static_route in static_routes:
                    found_routes = []
                    missing_routes = []
                    st_found = False
                    nh_found = False
                    vrf = static_route.setdefault("vrf", None)
                    community = static_route.setdefault("community", None)
                    largeCommunity = \
                        static_route.setdefault("largeCommunity", None)
                    if vrf:
                        cmd = "{} vrf {} {}".\
                            format(command, vrf, addr_type)
                        if community:
                            cmd = "{} community {}".\
                                format(cmd, community)
                        if largeCommunity:
                            cmd = "{} large-community {}".\
                                format(cmd, largeCommunity)
                    else:
                        cmd = "{} {}".\
                            format(command, addr_type)
                    cmd = "{} json".format(cmd)
                    rib_routes_json = run_frr_cmd(rnode, cmd, isjson=True)
                    # Verifying output dictionary rib_routes_json is not empty
                    if bool(rib_routes_json) == False:
                        errormsg = "[DUT: {}]: No route found in rib of router". \
                            format(router)
                        return errormsg
                    elif "warning" in rib_routes_json:
                        errormsg = "[DUT: {}]: {}". \
                            format(router, rib_routes_json["warning"])
                        return errormsg
                    network = static_route["network"]
                    if "no_of_ip" in static_route:
                        no_of_ip = static_route["no_of_ip"]
                    else:
                        no_of_ip = 1
                    # Generating IPs for verification
                    ip_list = generate_ips(network, no_of_ip)

                    for st_rt in ip_list:
                        st_rt = str(ipaddress.ip_network(st_rt))
                        _addr_type = validate_ip_address(st_rt)
                        if _addr_type != addr_type:
                            continue
                        if st_rt in rib_routes_json["routes"]:
                            st_found = True

                            found_routes.append(st_rt)
                            for mnh in range(0, len(rib_routes_json[
                                'routes'][st_rt])):
                                found_hops.append([rib_r[
                                        "ip"] for rib_r in rib_routes_json[
                                            'routes'][st_rt][
                                                mnh]["nexthops"]])
                            return found_hops
                        else:
                            return 'error  msg - no hops found'