tests/topotests/lib/topogen.py

   1 #
   2 # topogen.py
   3 # Library of helper functions for NetDEF Topology Tests
   4 #
   5 # Copyright (c) 2017 by
   6 # Network Device Education Foundation, Inc. ("NetDEF")
   7 #
   8 # Permission to use, copy, modify, and/or distribute this software
   9 # for any purpose with or without fee is hereby granted, provided
  10 # that the above copyright notice and this permission notice appear
  11 # in all copies.
  12 #
  13 # THE SOFTWARE IS PROVIDED "AS IS" AND NETDEF DISCLAIMS ALL WARRANTIES
  14 # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  15 # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NETDEF BE LIABLE FOR
  16 # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
  17 # DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  18 # WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
  19 # ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20 # OF THIS SOFTWARE.
  21 #
  22
  23 """
  24 Topogen (Topology Generator) is an abstraction around Topotest and Mininet to
  25 help reduce boilerplate code and provide a stable interface to build topology
  26 tests on.
  27
  28 Basic usage instructions:
  29
  30 * Define a Topology class with a build method using mininet.topo.Topo.
  31   See examples/test_template.py.
  32 * Use Topogen inside the build() method with get_topogen.
  33   e.g. get_topogen(self).
  34 * Start up your topology with: Topogen(YourTopology)
  35 * Initialize the Mininet with your topology with: tgen.start_topology()
  36 * Configure your routers/hosts and start them
  37 * Run your tests / mininet cli.
  38 * After running stop Mininet with: tgen.stop_topology()
  39 """
  40
  41 import grp
  42 import inspect
  43 import json
  44 import logging
  45 import os
  46 import platform
  47 import pwd
  48 import re
  49 import subprocess
  50 import sys
  51 from collections import OrderedDict
  52
  53 if sys.version_info[0] > 2:
  54     import configparser
  55 else:
  56     import ConfigParser as configparser
  57
  58 import lib.topolog as topolog
  59 from lib.micronet import Commander
  60 from lib.micronet_compat import Mininet
  61 from lib.topolog import logger
  62 from lib.topotest import g_extra_config
  63
  64 from lib import topotest
  65
  66 CWD = os.path.dirname(os.path.realpath(__file__))
  67
  68 # pylint: disable=C0103
  69 # Global Topogen variable. This is being used to keep the Topogen available on
  70 # all test functions without declaring a test local variable.
  71 global_tgen = None
  72
  73
  74 def get_topogen(topo=None):
  75     """
  76     Helper function to retrieve Topogen. Must be called with `topo` when called
  77     inside the build() method of Topology class.
  78     """
  79     if topo is not None:
  80         global_tgen.topo = topo
  81     return global_tgen
  82
  83
  84 def set_topogen(tgen):
  85     "Helper function to set Topogen"
  86     # pylint: disable=W0603
  87     global global_tgen
  88     global_tgen = tgen
  89
  90
  91 def is_string(value):
  92     """Return True if value is a string."""
  93     try:
  94         return isinstance(value, basestring)  # type: ignore
  95     except NameError:
  96         return isinstance(value, str)
  97
  98
  99 def get_exabgp_cmd(commander=None):
 100     """Return the command to use for ExaBGP version < 4."""
 101
 102     if commander is None:
 103         commander = Commander("topogen")
 104
 105     def exacmd_version_ok(exacmd):
 106         logger.debug("checking %s for exabgp < version 4", exacmd)
 107         _, stdout, _ = commander.cmd_status(exacmd + " -v", warn=False)
 108         m = re.search(r"ExaBGP\s*:\s*((\d+)\.(\d+)(?:\.(\d+))?)", stdout)
 109         if not m:
 110             return False
 111         version = m.group(1)
 112         if topotest.version_cmp(version, "4") >= 0:
 113             logging.debug("found exabgp version >= 4 in %s will keep looking", exacmd)
 114             return False
 115         logger.info("Using ExaBGP version %s in %s", version, exacmd)
 116         return True
 117
 118     exacmd = commander.get_exec_path("exabgp")
 119     if exacmd and exacmd_version_ok(exacmd):
 120         return exacmd
 121     py2_path = commander.get_exec_path("python2")
 122     if py2_path:
 123         exacmd = py2_path + " -m exabgp"
 124         if exacmd_version_ok(exacmd):
 125             return exacmd
 126     py2_path = commander.get_exec_path("python")
 127     if py2_path:
 128         exacmd = py2_path + " -m exabgp"
 129         if exacmd_version_ok(exacmd):
 130             return exacmd
 131     return None
 132
 133
 134 #
 135 # Main class: topology builder
 136 #
 137
 138 # Topogen configuration defaults
 139 tgen_defaults = {
 140     "verbosity": "info",
 141     "frrdir": "/usr/lib/frr",
 142     "routertype": "frr",
 143     "memleak_path": "",
 144 }
 145
 146
 147 class Topogen(object):
 148     "A topology test builder helper."
 149
 150     CONFIG_SECTION = "topogen"
 151
 152     def __init__(self, topodef, modname="unnamed"):
 153         """
 154         Topogen initialization function, takes the following arguments:
 155         * `cls`: OLD:uthe topology class that is child of mininet.topo or a build function.
 156         * `topodef`: A dictionary defining the topology, a filename of a json file, or a
 157           function that will do the same
 158         * `modname`: module name must be a unique name to identify logs later.
 159         """
 160         self.config = None
 161         self.net = None
 162         self.gears = {}
 163         self.routern = 1
 164         self.switchn = 1
 165         self.modname = modname
 166         self.errorsd = {}
 167         self.errors = ""
 168         self.peern = 1
 169         self.cfg_gen = 0
 170         self.exabgp_cmd = None
 171         self._init_topo(topodef)
 172
 173         logger.info("loading topology: {}".format(self.modname))
 174
 175     # @staticmethod
 176     # def _mininet_reset():
 177     #     "Reset the mininet environment"
 178     #     # Clean up the mininet environment
 179     #     os.system("mn -c > /dev/null 2>&1")
 180
 181     def __str__(self):
 182         return "Topogen()"
 183
 184     def _init_topo(self, topodef):
 185         """
 186         Initialize the topogily provided by the user. The user topology class
 187         must call get_topogen() during build() to get the topogen object.
 188         """
 189         # Set the global variable so the test cases can access it anywhere
 190         set_topogen(self)
 191
 192         # Increase host based limits
 193         topotest.fix_host_limits()
 194
 195         # Test for MPLS Kernel modules available
 196         self.hasmpls = False
 197         if not topotest.module_present("mpls-router"):
 198             logger.info("MPLS tests will not run (missing mpls-router kernel module)")
 199         elif not topotest.module_present("mpls-iptunnel"):
 200             logger.info("MPLS tests will not run (missing mpls-iptunnel kernel module)")
 201         else:
 202             self.hasmpls = True
 203
 204         # Load the default topology configurations
 205         self._load_config()
 206
 207         # Create new log directory
 208         self.logdir = topotest.get_logs_path(g_extra_config["rundir"])
 209         subprocess.check_call(
 210             "mkdir -p {0} && chmod 1777 {0}".format(self.logdir), shell=True
 211         )
 212         try:
 213             routertype = self.config.get(self.CONFIG_SECTION, "routertype")
 214             # Only allow group, if it exist.
 215             gid = grp.getgrnam(routertype)[2]
 216             os.chown(self.logdir, 0, gid)
 217             os.chmod(self.logdir, 0o775)
 218         except KeyError:
 219             # Allow anyone, but set the sticky bit to avoid file deletions
 220             os.chmod(self.logdir, 0o1777)
 221
 222         # Remove old twisty way of creating sub-classed topology object which has it's
 223         # build method invoked which calls Topogen methods which then call Topo methods
 224         # to create a topology within the Topo object, which is then used by
 225         # Mininet(Micronet) to build the actual topology.
 226         assert not inspect.isclass(topodef)
 227
 228         self.net = Mininet(controller=None)
 229
 230         # New direct way: Either a dictionary defines the topology or a build function
 231         # is supplied, or a json filename all of which build the topology by calling
 232         # Topogen methods which call Mininet(Micronet) methods to create the actual
 233         # topology.
 234         if not inspect.isclass(topodef):
 235             if callable(topodef):
 236                 topodef(self)
 237                 self.net.configure_hosts()
 238             elif is_string(topodef):
 239                 # topojson imports topogen in one function too,
 240                 # switch away from this use here to the topojson
 241                 # fixutre and remove this case
 242                 from lib.topojson import build_topo_from_json
 243
 244                 with open(topodef, "r") as topof:
 245                     self.json_topo = json.load(topof)
 246                 build_topo_from_json(self, self.json_topo)
 247                 self.net.configure_hosts()
 248             elif topodef:
 249                 self.add_topology_from_dict(topodef)
 250
 251     def add_topology_from_dict(self, topodef):
 252
 253         keylist = (
 254             topodef.keys()
 255             if isinstance(topodef, OrderedDict)
 256             else sorted(topodef.keys())
 257         )
 258         # ---------------------------
 259         # Create all referenced hosts
 260         # ---------------------------
 261         for oname in keylist:
 262             tup = (topodef[oname],) if is_string(topodef[oname]) else topodef[oname]
 263             for e in tup:
 264                 desc = e.split(":")
 265                 name = desc[0]
 266                 if name not in self.gears:
 267                     logging.debug("Adding router: %s", name)
 268                     self.add_router(name)
 269
 270         # ------------------------------
 271         # Create all referenced switches
 272         # ------------------------------
 273         for oname in keylist:
 274             if oname is not None and oname not in self.gears:
 275                 logging.debug("Adding switch: %s", oname)
 276                 self.add_switch(oname)
 277
 278         # ----------------
 279         # Create all links
 280         # ----------------
 281         for oname in keylist:
 282             if oname is None:
 283                 continue
 284             tup = (topodef[oname],) if is_string(topodef[oname]) else topodef[oname]
 285             for e in tup:
 286                 desc = e.split(":")
 287                 name = desc[0]
 288                 ifname = desc[1] if len(desc) > 1 else None
 289                 sifname = desc[2] if len(desc) > 2 else None
 290                 self.add_link(self.gears[oname], self.gears[name], sifname, ifname)
 291
 292         self.net.configure_hosts()
 293
 294     def _load_config(self):
 295         """
 296         Loads the configuration file `pytest.ini` located at the root dir of
 297         topotests.
 298         """
 299         self.config = configparser.ConfigParser(tgen_defaults)
 300         pytestini_path = os.path.join(CWD, "../pytest.ini")
 301         self.config.read(pytestini_path)
 302
 303     def add_router(self, name=None, cls=None, **params):
 304         """
 305         Adds a new router to the topology. This function has the following
 306         options:
 307         * `name`: (optional) select the router name
 308         * `daemondir`: (optional) custom daemon binary directory
 309         * `routertype`: (optional) `frr`
 310         Returns a TopoRouter.
 311         """
 312         if cls is None:
 313             cls = topotest.Router
 314         if name is None:
 315             name = "r{}".format(self.routern)
 316         if name in self.gears:
 317             raise KeyError("router already exists")
 318
 319         params["frrdir"] = self.config.get(self.CONFIG_SECTION, "frrdir")
 320         params["memleak_path"] = self.config.get(self.CONFIG_SECTION, "memleak_path")
 321         if "routertype" not in params:
 322             params["routertype"] = self.config.get(self.CONFIG_SECTION, "routertype")
 323
 324         self.gears[name] = TopoRouter(self, cls, name, **params)
 325         self.routern += 1
 326         return self.gears[name]
 327
 328     def add_switch(self, name=None):
 329         """
 330         Adds a new switch to the topology. This function has the following
 331         options:
 332         name: (optional) select the switch name
 333         Returns the switch name and number.
 334         """
 335         if name is None:
 336             name = "s{}".format(self.switchn)
 337         if name in self.gears:
 338             raise KeyError("switch already exists")
 339
 340         self.gears[name] = TopoSwitch(self, name)
 341         self.switchn += 1
 342         return self.gears[name]
 343
 344     def add_exabgp_peer(self, name, ip, defaultRoute):
 345         """
 346         Adds a new ExaBGP peer to the topology. This function has the following
 347         parameters:
 348         * `ip`: the peer address (e.g. '1.2.3.4/24')
 349         * `defaultRoute`: the peer default route (e.g. 'via 1.2.3.1')
 350         """
 351         if name is None:
 352             name = "peer{}".format(self.peern)
 353         if name in self.gears:
 354             raise KeyError("exabgp peer already exists")
 355
 356         self.gears[name] = TopoExaBGP(self, name, ip=ip, defaultRoute=defaultRoute)
 357         self.peern += 1
 358         return self.gears[name]
 359
 360     def add_host(self, name, ip, defaultRoute):
 361         """
 362         Adds a new host to the topology. This function has the following
 363         parameters:
 364         * `ip`: the peer address (e.g. '1.2.3.4/24')
 365         * `defaultRoute`: the peer default route (e.g. 'via 1.2.3.1')
 366         """
 367         if name is None:
 368             name = "host{}".format(self.peern)
 369         if name in self.gears:
 370             raise KeyError("host already exists")
 371
 372         self.gears[name] = TopoHost(self, name, ip=ip, defaultRoute=defaultRoute)
 373         self.peern += 1
 374         return self.gears[name]
 375
 376     def add_link(self, node1, node2, ifname1=None, ifname2=None):
 377         """
 378         Creates a connection between node1 and node2. The nodes can be the
 379         following:
 380         * TopoGear
 381           * TopoRouter
 382           * TopoSwitch
 383         """
 384         if not isinstance(node1, TopoGear):
 385             raise ValueError("invalid node1 type")
 386         if not isinstance(node2, TopoGear):
 387             raise ValueError("invalid node2 type")
 388
 389         if ifname1 is None:
 390             ifname1 = node1.new_link()
 391         if ifname2 is None:
 392             ifname2 = node2.new_link()
 393
 394         node1.register_link(ifname1, node2, ifname2)
 395         node2.register_link(ifname2, node1, ifname1)
 396         self.net.add_link(node1.name, node2.name, ifname1, ifname2)
 397
 398     def get_gears(self, geartype):
 399         """
 400         Returns a dictionary of all gears of type `geartype`.
 401
 402         Normal usage:
 403         * Dictionary iteration:
 404         ```py
 405         tgen = get_topogen()
 406         router_dict = tgen.get_gears(TopoRouter)
 407         for router_name, router in router_dict.items():
 408             # Do stuff
 409         ```
 410         * List iteration:
 411         ```py
 412         tgen = get_topogen()
 413         peer_list = tgen.get_gears(TopoExaBGP).values()
 414         for peer in peer_list:
 415             # Do stuff
 416         ```
 417         """
 418         return dict(
 419             (name, gear)
 420             for name, gear in self.gears.items()
 421             if isinstance(gear, geartype)
 422         )
 423
 424     def routers(self):
 425         """
 426         Returns the router dictionary (key is the router name and value is the
 427         router object itself).
 428         """
 429         return self.get_gears(TopoRouter)
 430
 431     def exabgp_peers(self):
 432         """
 433         Returns the exabgp peer dictionary (key is the peer name and value is
 434         the peer object itself).
 435         """
 436         return self.get_gears(TopoExaBGP)
 437
 438     def start_topology(self):
 439         """Starts the topology class."""
 440         logger.info("starting topology: {}".format(self.modname))
 441         self.net.start()
 442
 443     def start_router(self, router=None):
 444         """
 445         Call the router startRouter method.
 446         If no router is specified it is called for all registred routers.
 447         """
 448         if router is None:
 449             # pylint: disable=r1704
 450             # XXX should be hosts?
 451             for _, router in self.routers().items():
 452                 router.start()
 453         else:
 454             if isinstance(router, str):
 455                 router = self.gears[router]
 456
 457             router.start()
 458
 459     def stop_topology(self):
 460         """
 461         Stops the network topology. This function will call the stop() function
 462         of all gears before calling the mininet stop function, so they can have
 463         their oportunity to do a graceful shutdown. stop() is called twice. The
 464         first is a simple kill with no sleep, the second will sleep if not
 465         killed and try with a different signal.
 466         """
 467         logger.info("stopping topology: {}".format(self.modname))
 468         errors = ""
 469         for gear in self.gears.values():
 470             errors += gear.stop()
 471         if len(errors) > 0:
 472             logger.error(
 473                 "Errors found post shutdown - details follow: {}".format(errors)
 474             )
 475
 476         self.net.stop()
 477
 478     def get_exabgp_cmd(self):
 479         if not self.exabgp_cmd:
 480             self.exabgp_cmd = get_exabgp_cmd(self.net)
 481         return self.exabgp_cmd
 482
 483     def cli(self):
 484         """
 485         Interrupt the test and call the command line interface for manual
 486         inspection. Should be only used on non production code.
 487         """
 488         self.net.cli()
 489
 490     mininet_cli = cli
 491
 492     def is_memleak_enabled(self):
 493         "Returns `True` if memory leak report is enable, otherwise `False`."
 494         # On router failure we can't run the memory leak test
 495         if self.routers_have_failure():
 496             return False
 497
 498         memleak_file = os.environ.get("TOPOTESTS_CHECK_MEMLEAK") or self.config.get(
 499             self.CONFIG_SECTION, "memleak_path"
 500         )
 501         if memleak_file == "" or memleak_file == None:
 502             return False
 503         return True
 504
 505     def report_memory_leaks(self, testname=None):
 506         "Run memory leak test and reports."
 507         if not self.is_memleak_enabled():
 508             return
 509
 510         # If no name was specified, use the test module name
 511         if testname is None:
 512             testname = self.modname
 513
 514         router_list = self.routers().values()
 515         for router in router_list:
 516             router.report_memory_leaks(self.modname)
 517
 518     def set_error(self, message, code=None):
 519         "Sets an error message and signal other tests to skip."
 520         logger.info(message)
 521
 522         # If no code is defined use a sequential number
 523         if code is None:
 524             code = len(self.errorsd)
 525
 526         self.errorsd[code] = message
 527         self.errors += "\n{}: {}".format(code, message)
 528
 529     def has_errors(self):
 530         "Returns whether errors exist or not."
 531         return len(self.errorsd) > 0
 532
 533     def routers_have_failure(self):
 534         "Runs an assertion to make sure that all routers are running."
 535         if self.has_errors():
 536             return True
 537
 538         errors = ""
 539         router_list = self.routers().values()
 540         for router in router_list:
 541             result = router.check_router_running()
 542             if result != "":
 543                 errors += result + "\n"
 544
 545         if errors != "":
 546             self.set_error(errors, "router_error")
 547             assert False, errors
 548             return True
 549         return False
 550
 551
 552 #
 553 # Topology gears (equipment)
 554 #
 555
 556
 557 class TopoGear(object):
 558     "Abstract class for type checking"
 559
 560     def __init__(self, tgen, name, **params):
 561         self.tgen = tgen
 562         self.name = name
 563         self.params = params
 564         self.links = {}
 565         self.linkn = 0
 566
 567         # Would be nice for this to point at the gears log directory rather than the
 568         # test's.
 569         self.logdir = tgen.logdir
 570         self.gearlogdir = None
 571
 572     def __str__(self):
 573         links = ""
 574         for myif, dest in self.links.items():
 575             _, destif = dest
 576             if links != "":
 577                 links += ","
 578             links += '"{}"<->"{}"'.format(myif, destif)
 579
 580         return 'TopoGear<name="{}",links=[{}]>'.format(self.name, links)
 581
 582     @property
 583     def net(self):
 584         return self.tgen.net[self.name]
 585
 586     def start(self):
 587         "Basic start function that just reports equipment start"
 588         logger.info('starting "{}"'.format(self.name))
 589
 590     def stop(self, wait=True, assertOnError=True):
 591         "Basic stop function that just reports equipment stop"
 592         logger.info('"{}" base stop called'.format(self.name))
 593         return ""
 594
 595     def cmd(self, command, **kwargs):
 596         """
 597         Runs the provided command string in the router and returns a string
 598         with the response.
 599         """
 600         return self.net.cmd_legacy(command, **kwargs)
 601
 602     def cmd_raises(self, command, **kwargs):
 603         """
 604         Runs the provided command string in the router and returns a string
 605         with the response. Raise an exception on any error.
 606         """
 607         return self.net.cmd_raises(command, **kwargs)
 608
 609     run = cmd
 610
 611     def popen(self, *params, **kwargs):
 612         """
 613         Creates a pipe with the given command. Same args as python Popen.
 614         If `command` is a string then will be invoked with shell, otherwise
 615         `command` is a list and will be invoked w/o shell. Returns a popen object.
 616         """
 617         return self.net.popen(*params, **kwargs)
 618
 619     def add_link(self, node, myif=None, nodeif=None):
 620         """
 621         Creates a link (connection) between myself and the specified node.
 622         Interfaces name can be speficied with:
 623         myif: the interface name that will be created in this node
 624         nodeif: the target interface name that will be created on the remote node.
 625         """
 626         self.tgen.add_link(self, node, myif, nodeif)
 627
 628     def link_enable(self, myif, enabled=True, netns=None):
 629         """
 630         Set this node interface administrative state.
 631         myif: this node interface name
 632         enabled: whether we should enable or disable the interface
 633         """
 634         if myif not in self.links.keys():
 635             raise KeyError("interface doesn't exists")
 636
 637         if enabled is True:
 638             operation = "up"
 639         else:
 640             operation = "down"
 641
 642         logger.info(
 643             'setting node "{}" link "{}" to state "{}"'.format(
 644                 self.name, myif, operation
 645             )
 646         )
 647         extract = ""
 648         if netns is not None:
 649             extract = "ip netns exec {} ".format(netns)
 650
 651         return self.run("{}ip link set dev {} {}".format(extract, myif, operation))
 652
 653     def peer_link_enable(self, myif, enabled=True, netns=None):
 654         """
 655         Set the peer interface administrative state.
 656         myif: this node interface name
 657         enabled: whether we should enable or disable the interface
 658
 659         NOTE: this is used to simulate a link down on this node, since when the
 660         peer disables their interface our interface status changes to no link.
 661         """
 662         if myif not in self.links.keys():
 663             raise KeyError("interface doesn't exists")
 664
 665         node, nodeif = self.links[myif]
 666         node.link_enable(nodeif, enabled, netns)
 667
 668     def new_link(self):
 669         """
 670         Generates a new unique link name.
 671
 672         NOTE: This function should only be called by Topogen.
 673         """
 674         ifname = "{}-eth{}".format(self.name, self.linkn)
 675         self.linkn += 1
 676         return ifname
 677
 678     def register_link(self, myif, node, nodeif):
 679         """
 680         Register link between this node interface and outside node.
 681
 682         NOTE: This function should only be called by Topogen.
 683         """
 684         if myif in self.links.keys():
 685             raise KeyError("interface already exists")
 686
 687         self.links[myif] = (node, nodeif)
 688
 689     def _setup_tmpdir(self):
 690         topotest.setup_node_tmpdir(self.logdir, self.name)
 691         self.gearlogdir = "{}/{}".format(self.logdir, self.name)
 692         return "{}/{}.log".format(self.logdir, self.name)
 693
 694
 695 class TopoRouter(TopoGear):
 696     """
 697     Router abstraction.
 698     """
 699
 700     # The default required directories by FRR
 701     PRIVATE_DIRS = [
 702         "/etc/frr",
 703         "/etc/snmp",
 704         "/var/run/frr",
 705         "/var/log",
 706     ]
 707
 708     # Router Daemon enumeration definition.
 709     RD_ZEBRA = 1
 710     RD_RIP = 2
 711     RD_RIPNG = 3
 712     RD_OSPF = 4
 713     RD_OSPF6 = 5
 714     RD_ISIS = 6
 715     RD_BGP = 7
 716     RD_LDP = 8
 717     RD_PIM = 9
 718     RD_EIGRP = 10
 719     RD_NHRP = 11
 720     RD_STATIC = 12
 721     RD_BFD = 13
 722     RD_SHARP = 14
 723     RD_BABEL = 15
 724     RD_PBRD = 16
 725     RD_PATH = 17
 726     RD_SNMP = 18
 727     RD = {
 728         RD_ZEBRA: "zebra",
 729         RD_RIP: "ripd",
 730         RD_RIPNG: "ripngd",
 731         RD_OSPF: "ospfd",
 732         RD_OSPF6: "ospf6d",
 733         RD_ISIS: "isisd",
 734         RD_BGP: "bgpd",
 735         RD_PIM: "pimd",
 736         RD_LDP: "ldpd",
 737         RD_EIGRP: "eigrpd",
 738         RD_NHRP: "nhrpd",
 739         RD_STATIC: "staticd",
 740         RD_BFD: "bfdd",
 741         RD_SHARP: "sharpd",
 742         RD_BABEL: "babeld",
 743         RD_PBRD: "pbrd",
 744         RD_PATH: "pathd",
 745         RD_SNMP: "snmpd",
 746     }
 747
 748     def __init__(self, tgen, cls, name, **params):
 749         """
 750         The constructor has the following parameters:
 751         * tgen: Topogen object
 752         * cls: router class that will be used to instantiate
 753         * name: router name
 754         * daemondir: daemon binary directory
 755         * routertype: 'frr'
 756         """
 757         super(TopoRouter, self).__init__(tgen, name, **params)
 758         self.routertype = params.get("routertype", "frr")
 759         if "privateDirs" not in params:
 760             params["privateDirs"] = self.PRIVATE_DIRS
 761
 762         # Propagate the router log directory
 763         logfile = self._setup_tmpdir()
 764         params["logdir"] = self.logdir
 765
 766         self.logger = topolog.get_logger(name, log_level="debug", target=logfile)
 767         params["logger"] = self.logger
 768         tgen.net.add_host(self.name, cls=cls, **params)
 769         topotest.fix_netns_limits(tgen.net[name])
 770
 771         # Mount gear log directory on a common path
 772         self.net.bind_mount(self.gearlogdir, "/tmp/gearlogdir")
 773
 774         # Ensure pid file
 775         with open(os.path.join(self.logdir, self.name + ".pid"), "w") as f:
 776             f.write(str(self.net.pid) + "\n")
 777
 778     def __str__(self):
 779         gear = super(TopoRouter, self).__str__()
 780         gear += " TopoRouter<>"
 781         return gear
 782
 783     def check_capability(self, daemon, param):
 784         """
 785         Checks a capability daemon against an argument option
 786         Return True if capability available. False otherwise
 787         """
 788         daemonstr = self.RD.get(daemon)
 789         self.logger.info('check capability {} for "{}"'.format(param, daemonstr))
 790         return self.net.checkCapability(daemonstr, param)
 791
 792     def load_config(self, daemon, source=None, param=None):
 793         """Loads daemon configuration from the specified source
 794         Possible daemon values are: TopoRouter.RD_ZEBRA, TopoRouter.RD_RIP,
 795         TopoRouter.RD_RIPNG, TopoRouter.RD_OSPF, TopoRouter.RD_OSPF6,
 796         TopoRouter.RD_ISIS, TopoRouter.RD_BGP, TopoRouter.RD_LDP,
 797         TopoRouter.RD_PIM, TopoRouter.RD_PBR, TopoRouter.RD_SNMP.
 798
 799         Possible `source` values are `None` for an empty config file, a path name which is
 800         used directly, or a file name with no path components which is first looked for
 801         directly and then looked for under a sub-directory named after router.
 802
 803         This API unfortunately allows for source to not exist for any and
 804         all routers.
 805         """
 806         daemonstr = self.RD.get(daemon)
 807         self.logger.info('loading "{}" configuration: {}'.format(daemonstr, source))
 808         self.net.loadConf(daemonstr, source, param)
 809
 810     def check_router_running(self):
 811         """
 812         Run a series of checks and returns a status string.
 813         """
 814         self.logger.info("checking if daemons are running")
 815         return self.net.checkRouterRunning()
 816
 817     def start(self):
 818         """
 819         Start router:
 820         * Load modules
 821         * Clean up files
 822         * Configure interfaces
 823         * Start daemons (e.g. FRR)
 824         * Configure daemon logging files
 825         """
 826
 827         nrouter = self.net
 828         result = nrouter.startRouter(self.tgen)
 829
 830         # Enable command logging
 831
 832         # Enable all daemon command logging, logging files
 833         # and set them to the start dir.
 834         for daemon, enabled in nrouter.daemons.items():
 835             if enabled and daemon != "snmpd":
 836                 self.vtysh_cmd(
 837                     "\n".join(
 838                         [
 839                             "clear log cmdline-targets",
 840                             "conf t",
 841                             "log file {}.log debug".format(daemon),
 842                             "log commands",
 843                             "log timestamp precision 3",
 844                         ]
 845                     ),
 846                     daemon=daemon,
 847                 )
 848
 849         if result != "":
 850             self.tgen.set_error(result)
 851         elif nrouter.daemons["ldpd"] == 1 or nrouter.daemons["pathd"] == 1:
 852             # Enable MPLS processing on all interfaces.
 853             for interface in self.links:
 854                 topotest.sysctl_assure(
 855                     nrouter, "net.mpls.conf.{}.input".format(interface), 1
 856                 )
 857
 858         return result
 859
 860     def stop(self):
 861         """
 862         Stop router cleanly:
 863         * Signal daemons twice, once with SIGTERM, then with SIGKILL.
 864         """
 865         self.logger.debug("stopping (no assert)")
 866         return self.net.stopRouter(False)
 867
 868     def startDaemons(self, daemons):
 869         """
 870         Start Daemons: to start specific daemon(user defined daemon only)
 871         * Start daemons (e.g. FRR)
 872         * Configure daemon logging files
 873         """
 874         self.logger.debug("starting")
 875         nrouter = self.net
 876         result = nrouter.startRouterDaemons(daemons)
 877
 878         if daemons is None:
 879             daemons = nrouter.daemons.keys()
 880
 881         # Enable all daemon command logging, logging files
 882         # and set them to the start dir.
 883         for daemon in daemons:
 884             enabled = nrouter.daemons[daemon]
 885             if enabled and daemon != "snmpd":
 886                 self.vtysh_cmd(
 887                     "\n".join(
 888                         [
 889                             "clear log cmdline-targets",
 890                             "conf t",
 891                             "log file {}.log debug".format(daemon),
 892                             "log commands",
 893                             "log timestamp precision 3",
 894                         ]
 895                     ),
 896                     daemon=daemon,
 897                 )
 898
 899         if result != "":
 900             self.tgen.set_error(result)
 901
 902         return result
 903
 904     def killDaemons(self, daemons, wait=True, assertOnError=True):
 905         """
 906         Kill specific daemon(user defined daemon only)
 907         forcefully using SIGKILL
 908         """
 909         self.logger.debug("Killing daemons using SIGKILL..")
 910         return self.net.killRouterDaemons(daemons, wait, assertOnError)
 911
 912     def vtysh_cmd(self, command, isjson=False, daemon=None):
 913         """
 914         Runs the provided command string in the vty shell and returns a string
 915         with the response.
 916
 917         This function also accepts multiple commands, but this mode does not
 918         return output for each command. See vtysh_multicmd() for more details.
 919         """
 920         # Detect multi line commands
 921         if command.find("\n") != -1:
 922             return self.vtysh_multicmd(command, daemon=daemon)
 923
 924         dparam = ""
 925         if daemon is not None:
 926             dparam += "-d {}".format(daemon)
 927
 928         vtysh_command = 'vtysh {} -c "{}" 2>/dev/null'.format(dparam, command)
 929
 930         self.logger.info('vtysh command => "{}"'.format(command))
 931         output = self.run(vtysh_command)
 932
 933         dbgout = output.strip()
 934         if dbgout:
 935             if "\n" in dbgout:
 936                 dbgout = dbgout.replace("\n", "\n\t")
 937                 self.logger.info("vtysh result:\n\t{}".format(dbgout))
 938             else:
 939                 self.logger.info('vtysh result: "{}"'.format(dbgout))
 940
 941         if isjson is False:
 942             return output
 943
 944         try:
 945             return json.loads(output)
 946         except ValueError as error:
 947             logger.warning(
 948                 "vtysh_cmd: %s: failed to convert json output: %s: %s",
 949                 self.name,
 950                 str(output),
 951                 str(error),
 952             )
 953             return {}
 954
 955     def vtysh_multicmd(self, commands, pretty_output=True, daemon=None):
 956         """
 957         Runs the provided commands in the vty shell and return the result of
 958         execution.
 959
 960         pretty_output: defines how the return value will be presented. When
 961         True it will show the command as they were executed in the vty shell,
 962         otherwise it will only show lines that failed.
 963         """
 964         # Prepare the temporary file that will hold the commands
 965         fname = topotest.get_file(commands)
 966
 967         dparam = ""
 968         if daemon is not None:
 969             dparam += "-d {}".format(daemon)
 970
 971         # Run the commands and delete the temporary file
 972         if pretty_output:
 973             vtysh_command = "vtysh {} < {}".format(dparam, fname)
 974         else:
 975             vtysh_command = "vtysh {} -f {}".format(dparam, fname)
 976
 977         dbgcmds = commands if is_string(commands) else "\n".join(commands)
 978         dbgcmds = "\t" + dbgcmds.replace("\n", "\n\t")
 979         self.logger.info("vtysh command => FILE:\n{}".format(dbgcmds))
 980
 981         res = self.run(vtysh_command)
 982         os.unlink(fname)
 983
 984         dbgres = res.strip()
 985         if dbgres:
 986             if "\n" in dbgres:
 987                 dbgres = dbgres.replace("\n", "\n\t")
 988                 self.logger.info("vtysh result:\n\t{}".format(dbgres))
 989             else:
 990                 self.logger.info('vtysh result: "{}"'.format(dbgres))
 991         return res
 992
 993     def report_memory_leaks(self, testname):
 994         """
 995         Runs the router memory leak check test. Has the following parameter:
 996         testname: the test file name for identification
 997
 998         NOTE: to run this you must have the environment variable
 999         TOPOTESTS_CHECK_MEMLEAK set or memleak_path configured in `pytest.ini`.
1000         """
1001         memleak_file = (
1002             os.environ.get("TOPOTESTS_CHECK_MEMLEAK") or self.params["memleak_path"]
1003         )
1004         if memleak_file == "" or memleak_file == None:
1005             return
1006
1007         self.stop()
1008
1009         self.logger.info("running memory leak report")
1010         self.net.report_memory_leaks(memleak_file, testname)
1011
1012     def version_info(self):
1013         "Get equipment information from 'show version'."
1014         output = self.vtysh_cmd("show version").split("\n")[0]
1015         columns = topotest.normalize_text(output).split(" ")
1016         try:
1017             return {
1018                 "type": columns[0],
1019                 "version": columns[1],
1020             }
1021         except IndexError:
1022             return {
1023                 "type": None,
1024                 "version": None,
1025             }
1026
1027     def has_version(self, cmpop, version):
1028         """
1029         Compares router version using operation `cmpop` with `version`.
1030         Valid `cmpop` values:
1031         * `>=`: has the same version or greater
1032         * '>': has greater version
1033         * '=': has the same version
1034         * '<': has a lesser version
1035         * '<=': has the same version or lesser
1036
1037         Usage example: router.has_version('>', '1.0')
1038         """
1039         return self.net.checkRouterVersion(cmpop, version)
1040
1041     def has_type(self, rtype):
1042         """
1043         Compares router type with `rtype`. Returns `True` if the type matches,
1044         otherwise `false`.
1045         """
1046         curtype = self.version_info()["type"]
1047         return rtype == curtype
1048
1049     def has_mpls(self):
1050         return self.net.hasmpls
1051
1052
1053 class TopoSwitch(TopoGear):
1054     """
1055     Switch abstraction. Has the following properties:
1056     * cls: switch class that will be used to instantiate
1057     * name: switch name
1058     """
1059
1060     # pylint: disable=too-few-public-methods
1061
1062     def __init__(self, tgen, name, **params):
1063         super(TopoSwitch, self).__init__(tgen, name, **params)
1064         tgen.net.add_switch(name)
1065
1066     def __str__(self):
1067         gear = super(TopoSwitch, self).__str__()
1068         gear += " TopoSwitch<>"
1069         return gear
1070
1071
1072 class TopoHost(TopoGear):
1073     "Host abstraction."
1074     # pylint: disable=too-few-public-methods
1075
1076     def __init__(self, tgen, name, **params):
1077         """
1078         Mininet has the following known `params` for hosts:
1079         * `ip`: the IP address (string) for the host interface
1080         * `defaultRoute`: the default route that will be installed
1081           (e.g. 'via 10.0.0.1')
1082         * `privateDirs`: directories that will be mounted on a different domain
1083           (e.g. '/etc/important_dir').
1084         """
1085         super(TopoHost, self).__init__(tgen, name, **params)
1086
1087         # Propagate the router log directory
1088         logfile = self._setup_tmpdir()
1089         params["logdir"] = self.logdir
1090
1091         # Odd to have 2 logfiles for each host
1092         self.logger = topolog.get_logger(name, log_level="debug", target=logfile)
1093         params["logger"] = self.logger
1094         tgen.net.add_host(name, **params)
1095         topotest.fix_netns_limits(tgen.net[name])
1096
1097         # Mount gear log directory on a common path
1098         self.net.bind_mount(self.gearlogdir, "/tmp/gearlogdir")
1099
1100     def __str__(self):
1101         gear = super(TopoHost, self).__str__()
1102         gear += ' TopoHost<ip="{}",defaultRoute="{}",privateDirs="{}">'.format(
1103             self.params["ip"],
1104             self.params["defaultRoute"],
1105             str(self.params["privateDirs"]),
1106         )
1107         return gear
1108
1109
1110 class TopoExaBGP(TopoHost):
1111     "ExaBGP peer abstraction."
1112     # pylint: disable=too-few-public-methods
1113
1114     PRIVATE_DIRS = [
1115         "/etc/exabgp",
1116         "/var/run/exabgp",
1117         "/var/log",
1118     ]
1119
1120     def __init__(self, tgen, name, **params):
1121         """
1122         ExaBGP usually uses the following parameters:
1123         * `ip`: the IP address (string) for the host interface
1124         * `defaultRoute`: the default route that will be installed
1125           (e.g. 'via 10.0.0.1')
1126
1127         Note: the different between a host and a ExaBGP peer is that this class
1128         has a privateDirs already defined and contains functions to handle ExaBGP
1129         things.
1130         """
1131         params["privateDirs"] = self.PRIVATE_DIRS
1132         super(TopoExaBGP, self).__init__(tgen, name, **params)
1133
1134     def __str__(self):
1135         gear = super(TopoExaBGP, self).__str__()
1136         gear += " TopoExaBGP<>".format()
1137         return gear
1138
1139     def start(self, peer_dir, env_file=None):
1140         """
1141         Start running ExaBGP daemon:
1142         * Copy all peer* folder contents into /etc/exabgp
1143         * Copy exabgp env file if specified
1144         * Make all python files runnable
1145         * Run ExaBGP with env file `env_file` and configuration peer*/exabgp.cfg
1146         """
1147         exacmd = self.tgen.get_exabgp_cmd()
1148         assert exacmd, "Can't find a usabel ExaBGP (must be < version 4)"
1149
1150         self.run("mkdir -p /etc/exabgp")
1151         self.run("chmod 755 /etc/exabgp")
1152         self.run("cp {}/exa-* /etc/exabgp/".format(CWD))
1153         self.run("cp {}/* /etc/exabgp/".format(peer_dir))
1154         if env_file is not None:
1155             self.run("cp {} /etc/exabgp/exabgp.env".format(env_file))
1156         self.run("chmod 644 /etc/exabgp/*")
1157         self.run("chmod a+x /etc/exabgp/*.py")
1158         self.run("chown -R exabgp:exabgp /etc/exabgp")
1159
1160         output = self.run(exacmd + " -e /etc/exabgp/exabgp.env /etc/exabgp/exabgp.cfg")
1161         if output == None or len(output) == 0:
1162             output = "<none>"
1163
1164         logger.info("{} exabgp started, output={}".format(self.name, output))
1165
1166     def stop(self, wait=True, assertOnError=True):
1167         "Stop ExaBGP peer and kill the daemon"
1168         self.run("kill `cat /var/run/exabgp/exabgp.pid`")
1169         return ""
1170
1171
1172 #
1173 # Diagnostic function
1174 #
1175
1176 # Disable linter branch warning. It is expected to have these here.
1177 # pylint: disable=R0912
1178 def diagnose_env_linux(rundir):
1179     """
1180     Run diagnostics in the running environment. Returns `True` when everything
1181     is ok, otherwise `False`.
1182     """
1183     ret = True
1184
1185     # Load configuration
1186     config = configparser.ConfigParser(defaults=tgen_defaults)
1187     pytestini_path = os.path.join(CWD, "../pytest.ini")
1188     config.read(pytestini_path)
1189
1190     # Test log path exists before installing handler.
1191     os.system("mkdir -p " + rundir)
1192     # Log diagnostics to file so it can be examined later.
1193     fhandler = logging.FileHandler(filename="{}/diagnostics.txt".format(rundir))
1194     fhandler.setLevel(logging.DEBUG)
1195     fhandler.setFormatter(logging.Formatter(fmt=topolog.FORMAT))
1196     logger.addHandler(fhandler)
1197
1198     logger.info("Running environment diagnostics")
1199
1200     # Assert that we are running as root
1201     if os.getuid() != 0:
1202         logger.error("you must run topotest as root")
1203         ret = False
1204
1205     # Assert that we have mininet
1206     # if os.system("which mn >/dev/null 2>/dev/null") != 0:
1207     #     logger.error("could not find mininet binary (mininet is not installed)")
1208     #     ret = False
1209
1210     # Assert that we have iproute installed
1211     if os.system("which ip >/dev/null 2>/dev/null") != 0:
1212         logger.error("could not find ip binary (iproute is not installed)")
1213         ret = False
1214
1215     # Assert that we have gdb installed
1216     if os.system("which gdb >/dev/null 2>/dev/null") != 0:
1217         logger.error("could not find gdb binary (gdb is not installed)")
1218         ret = False
1219
1220     # Assert that FRR utilities exist
1221     frrdir = config.get("topogen", "frrdir")
1222     if not os.path.isdir(frrdir):
1223         logger.error("could not find {} directory".format(frrdir))
1224         ret = False
1225     else:
1226         try:
1227             pwd.getpwnam("frr")[2]
1228         except KeyError:
1229             logger.warning('could not find "frr" user')
1230
1231         try:
1232             grp.getgrnam("frr")[2]
1233         except KeyError:
1234             logger.warning('could not find "frr" group')
1235
1236         try:
1237             if "frr" not in grp.getgrnam("frrvty").gr_mem:
1238                 logger.error(
1239                     '"frr" user and group exist, but user is not under "frrvty"'
1240                 )
1241         except KeyError:
1242             logger.warning('could not find "frrvty" group')
1243
1244         for fname in [
1245             "zebra",
1246             "ospfd",
1247             "ospf6d",
1248             "bgpd",
1249             "ripd",
1250             "ripngd",
1251             "isisd",
1252             "pimd",
1253             "ldpd",
1254             "pbrd",
1255         ]:
1256             path = os.path.join(frrdir, fname)
1257             if not os.path.isfile(path):
1258                 # LDPd is an exception
1259                 if fname == "ldpd":
1260                     logger.info(
1261                         "could not find {} in {}".format(fname, frrdir)
1262                         + "(LDPd tests will not run)"
1263                     )
1264                     continue
1265
1266                 logger.warning("could not find {} in {}".format(fname, frrdir))
1267                 ret = False
1268             else:
1269                 if fname != "zebra":
1270                     continue
1271
1272                 os.system("{} -v 2>&1 >{}/frr_zebra.txt".format(path, rundir))
1273
1274     # Test MPLS availability
1275     krel = platform.release()
1276     if topotest.version_cmp(krel, "4.5") < 0:
1277         logger.info(
1278             'LDPd tests will not run (have kernel "{}", but it requires 4.5)'.format(
1279                 krel
1280             )
1281         )
1282
1283     # Test for MPLS Kernel modules available
1284     if not topotest.module_present("mpls-router", load=False) != 0:
1285         logger.info("LDPd tests will not run (missing mpls-router kernel module)")
1286     if not topotest.module_present("mpls-iptunnel", load=False) != 0:
1287         logger.info("LDPd tests will not run (missing mpls-iptunnel kernel module)")
1288
1289     if not get_exabgp_cmd():
1290         logger.warning("Failed to find exabgp < 4")
1291
1292     logger.removeHandler(fhandler)
1293     fhandler.close()
1294
1295     return ret
1296
1297
1298 def diagnose_env_freebsd():
1299     return True
1300
1301
1302 def diagnose_env(rundir):
1303     if sys.platform.startswith("linux"):
1304         return diagnose_env_linux(rundir)
1305     elif sys.platform.startswith("freebsd"):
1306         return diagnose_env_freebsd()
1307
1308     return False