resources/libraries/python/topology.py

   1 # Copyright (c) 2016 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """Defines nodes and topology structure."""
  15
  16 from resources.libraries.python.parsers.JsonParser import JsonParser
  17 from resources.libraries.python.VatExecutor import VatExecutor
  18 from resources.libraries.python.ssh import SSH
  19 from resources.libraries.python.InterfaceSetup import InterfaceSetup
  20 from robot.api import logger
  21 from robot.libraries.BuiltIn import BuiltIn
  22 from robot.api.deco import keyword
  23 from yaml import load
  24
  25 __all__ = ["DICT__nodes", 'Topology']
  26
  27
  28 def load_topo_from_yaml():
  29     """Load topology from file defined in "${TOPOLOGY_PATH}" variable
  30
  31     :return: nodes from loaded topology
  32     """
  33     topo_path = BuiltIn().get_variable_value("${TOPOLOGY_PATH}")
  34
  35     with open(topo_path) as work_file:
  36         return load(work_file.read())['nodes']
  37
  38
  39 class NodeType(object):
  40     """Defines node types used in topology dictionaries"""
  41     # Device Under Test (this node has VPP running on it)
  42     DUT = 'DUT'
  43     # Traffic Generator (this node has traffic generator on it)
  44     TG = 'TG'
  45
  46
  47 class NodeSubTypeTG(object):
  48     #T-Rex traffic generator
  49     TREX = 'TREX'
  50     # Moongen
  51     MOONGEN = 'MOONGEN'
  52     # IxNetwork
  53     IXNET = 'IXNET'
  54
  55 DICT__nodes = load_topo_from_yaml()
  56
  57
  58 class Topology(object):
  59     """Topology data manipulation and extraction methods
  60
  61     Defines methods used for manipulation and extraction of data from
  62     the used topology.
  63     """
  64
  65     @staticmethod
  66     def get_node_by_hostname(nodes, hostname):
  67         """Get node from nodes of the topology by hostname.
  68
  69         :param nodes: Nodes of the test topology.
  70         :param hostname: Host name.
  71         :type nodes: dict
  72         :type hostname: str
  73         :return: Node dictionary or None if not found.
  74         """
  75         for node in nodes.values():
  76             if node['host'] == hostname:
  77                 return node
  78
  79         return None
  80
  81     @staticmethod
  82     def get_links(nodes):
  83         """Get list of links(networks) in the topology.
  84
  85         :param nodes: Nodes of the test topology.
  86         :type nodes: dict
  87         :return: Links in the topology.
  88         :rtype: list
  89         """
  90         links = []
  91
  92         for node in nodes.values():
  93             for interface in node['interfaces'].values():
  94                 link = interface.get('link')
  95                 if link is not None:
  96                     if link not in links:
  97                         links.append(link)
  98
  99         return links
 100
 101     @staticmethod
 102     def _get_interface_by_key_value(node, key, value):
 103         """Return node interface name according to key and value
 104
 105         :param node: :param node: the node dictionary
 106         :param key: key by which to select the interface.
 107         :param value: value that should be found using the key.
 108         :return:
 109         """
 110
 111         interfaces = node['interfaces']
 112         retval = None
 113         for interface in interfaces.values():
 114             k_val = interface.get(key)
 115             if k_val is not None:
 116                 if k_val == value:
 117                     retval = interface['name']
 118                     break
 119         return retval
 120
 121     def get_interface_by_link_name(self, node, link_name):
 122         """Return interface name of link on node.
 123
 124         This method returns the interface name asociated with a given link
 125         for a given node.
 126         :param link_name: name of the link that a interface is connected to.
 127         :param node: the node topology dictionary
 128         :return: interface name of the interface connected to the given link
 129         """
 130
 131         return self._get_interface_by_key_value(node, "link", link_name)
 132
 133     def get_interfaces_by_link_names(self, node, link_names):
 134         """Return dictionary of dicitonaries {"interfaceN", interface name}.
 135
 136         This method returns the interface names asociated with given links
 137         for a given node.
 138         The resulting dictionary can be then used to with VatConfigGenerator
 139         to generate a VAT script with proper interface names.
 140         :param link_names: list of names of the link that a interface is
 141         connected to.
 142         :param node: the node topology directory
 143         :return: dictionary of interface names that are connected to the given
 144         links
 145         """
 146
 147         retval = {}
 148         interface_key_tpl = "interface{}"
 149         interface_number = 1
 150         for link_name in link_names:
 151             interface_name = self.get_interface_by_link_name(node, link_name)
 152             interface_key = interface_key_tpl.format(str(interface_number))
 153             retval[interface_key] = interface_name
 154             interface_number += 1
 155         return retval
 156
 157     def get_interface_by_sw_index(self, node, sw_index):
 158         """Return interface name of link on node.
 159
 160         This method returns the interface name asociated with a software index
 161         assigned to the interface by vpp for a given node.
 162         :param sw_index: sw_index of the link that a interface is connected to.
 163         :param node: the node topology dictionary
 164         :return: interface name of the interface connected to the given link
 165         """
 166
 167         return self._get_interface_by_key_value(node, "vpp_sw_index", sw_index)
 168
 169     @staticmethod
 170     def convert_mac_to_number_list(mac_address):
 171         """Convert mac address string to list of decimal numbers.
 172
 173         Converts a : separated mac address to decimal number list as used
 174         in json interface dump.
 175         :param mac_address: string mac address
 176         :return: list representation of mac address
 177         """
 178
 179         list_mac = []
 180         for num in mac_address.split(":"):
 181             list_mac.append(int(num, 16))
 182         return list_mac
 183
 184     def _extract_vpp_interface_by_mac(self, interfaces_list, mac_address):
 185         """Return interface dictionary from interface_list by mac address.
 186
 187         Extracts interface dictionary from all of the interfaces in interfaces
 188         list parsed from json according to mac_address of the interface
 189         :param interfaces_list: dictionary of all interfaces parsed from json
 190         :param mac_address: string mac address of interface we are looking for
 191         :return: interface dictionary from json
 192         """
 193
 194         interface_dict = {}
 195         list_mac_address = self.convert_mac_to_number_list(mac_address)
 196         logger.trace(str(list_mac_address))
 197         for interface in interfaces_list:
 198             # TODO: create vat json integrity checking and move there
 199             if "l2_address" not in interface:
 200                 raise KeyError(
 201                     "key l2_address not found in interface dict."
 202                     "Probably input list is not parsed from correct VAT "
 203                     "json output.")
 204             if "l2_address_length" not in interface:
 205                 raise KeyError(
 206                     "key l2_address_length not found in interface "
 207                     "dict. Probably input list is not parsed from correct "
 208                     "VAT json output.")
 209             mac_from_json = interface["l2_address"][:6]
 210             if mac_from_json == list_mac_address:
 211                 if interface["l2_address_length"] != 6:
 212                     raise ValueError("l2_address_length value is not 6.")
 213                 interface_dict = interface
 214                 break
 215         return interface_dict
 216
 217     def vpp_interface_name_from_json_by_mac(self, json_data, mac_address):
 218         """Return vpp interface name string from VAT interface dump json output
 219
 220         Extracts the name given to an interface by VPP.
 221         These interface names differ from what you would see if you
 222         used the ipconfig or similar command.
 223         Required json data can be obtained by calling :
 224         VatExecutor.execute_script_json_out("dump_interfaces.vat", node)
 225         :param json_data: string json data from sw_interface_dump VAT command
 226         :param mac_address: string containing mac address of interface
 227         whose vpp name we wish to discover.
 228         :return: string vpp interface name
 229         """
 230
 231         interfaces_list = JsonParser().parse_data(json_data)
 232         # TODO: checking if json data is parsed correctly
 233         interface_dict = self._extract_vpp_interface_by_mac(interfaces_list,
 234                                                             mac_address)
 235         interface_name = interface_dict["interface_name"]
 236         return interface_name
 237
 238     def _update_node_interface_data_from_json(self, node, interface_dump_json):
 239         """Update node vpp data in node__DICT from json interface dump.
 240
 241         This method updates vpp interface names and sw indexexs according to
 242         interface mac addresses found in interface_dump_json
 243         :param node: node dictionary
 244         :param interface_dump_json: json output from dump_interface_list VAT
 245         command
 246         """
 247
 248         interface_list = JsonParser().parse_data(interface_dump_json)
 249         for ifc in node['interfaces'].values():
 250             if 'link' not in ifc:
 251                 continue
 252             if_mac = ifc['mac_address']
 253             interface_dict = self._extract_vpp_interface_by_mac(interface_list,
 254                                                                 if_mac)
 255             if not interface_dict:
 256                 raise Exception('Interface {0} not found by MAC {1}'.
 257                         format(ifc, if_mac))
 258             ifc['name'] = interface_dict["interface_name"]
 259             ifc['vpp_sw_index'] = interface_dict["sw_if_index"]
 260
 261     def update_vpp_interface_data_on_node(self, node):
 262         """Update vpp generated interface data for a given node in DICT__nodes
 263
 264         Updates interface names, software index numbers and any other details
 265         generated specifically by vpp that are unknown before testcase run.
 266         :param node: Node selected from DICT__nodes
 267         """
 268
 269         vat_executor = VatExecutor()
 270         vat_executor.execute_script_json_out("dump_interfaces.vat", node)
 271         interface_dump_json = vat_executor.get_script_stdout()
 272         self._update_node_interface_data_from_json(node,
 273                                                    interface_dump_json)
 274
 275     @staticmethod
 276     def update_tg_interface_data_on_node(node):
 277         """Update interface name for TG/linux node in DICT__nodes
 278
 279         :param node: Node selected from DICT__nodes.
 280         :type node: dict
 281
 282         .. note::
 283             # for dev in `ls /sys/class/net/`;
 284             > do echo "\"`cat /sys/class/net/$dev/address`\": \"$dev\""; done
 285             "52:54:00:9f:82:63": "eth0"
 286             "52:54:00:77:ae:a9": "eth1"
 287             "52:54:00:e1:8a:0f": "eth2"
 288             "00:00:00:00:00:00": "lo"
 289
 290         .. todo:: parse lshw -json instead
 291         """
 292         # First setup interface driver specified in yaml file
 293         InterfaceSetup.tg_set_interfaces_default_driver(node)
 294
 295         # Get interface names
 296         ssh = SSH()
 297         ssh.connect(node)
 298
 299         cmd = 'for dev in `ls /sys/class/net/`; do echo "\\"`cat ' \
 300               '/sys/class/net/$dev/address`\\": \\"$dev\\""; done;'
 301
 302         (ret_code, stdout, _) = ssh.exec_command(cmd)
 303         if int(ret_code) != 0:
 304             raise Exception('Get interface name and MAC failed')
 305         tmp = "{" + stdout.rstrip().replace('\n', ',') + "}"
 306         interfaces = JsonParser().parse_data(tmp)
 307         for if_k, if_v in node['interfaces'].items():
 308             if if_k == 'mgmt':
 309                 continue
 310             name = interfaces.get(if_v['mac_address'])
 311             if name is None:
 312                 continue
 313             if_v['name'] = name
 314
 315         # Set udev rules for interfaces
 316         InterfaceSetup.tg_set_interfaces_udev_rules(node)
 317
 318     def update_all_interface_data_on_all_nodes(self, nodes):
 319         """Update interface names on all nodes in DICT__nodes
 320
 321         :param nodes: Nodes in the topology.
 322         :type nodes: dict
 323
 324         This method updates the topology dictionary by querying interface lists
 325         of all nodes mentioned in the topology dictionary.
 326         It does this by dumping interface list to json output from all devices
 327         using vpp_api_test, and pairing known information from topology
 328         (mac address/pci address of interface) to state from VPP.
 329         For TG/linux nodes add interface name only.
 330         """
 331
 332         for node_data in nodes.values():
 333             if node_data['type'] == NodeType.DUT:
 334                 self.update_vpp_interface_data_on_node(node_data)
 335             elif node_data['type'] == NodeType.TG:
 336                 self.update_tg_interface_data_on_node(node_data)
 337
 338     @staticmethod
 339     def get_interface_sw_index(node, interface):
 340         """Get VPP sw_index for the interface.
 341
 342         :param node: Node to get interface sw_index on.
 343         :param interface: Interface name.
 344         :type node: dict
 345         :type interface: str
 346         :return: Return sw_index or None if not found.
 347         """
 348         for port in node['interfaces'].values():
 349             port_name = port.get('name')
 350             if port_name is None:
 351                 continue
 352             if port_name == interface:
 353                 return port.get('vpp_sw_index')
 354
 355         return None
 356
 357     @staticmethod
 358     def get_interface_mac_by_port_key(node, port_key):
 359         """Get MAC address for the interface based on port key.
 360
 361         :param node: Node to get interface mac on.
 362         :param port_key: Dictionary key name of interface.
 363         :type node: dict
 364         :type port_key: str
 365         :return: Return MAC or None if not found.
 366         """
 367         for port_name, port_data in node['interfaces'].iteritems():
 368             if port_name == port_key:
 369                 return port_data['mac_address']
 370
 371         return None
 372
 373     @staticmethod
 374     def get_interface_mac(node, interface):
 375         """Get MAC address for the interface.
 376
 377         :param node: Node to get interface sw_index on.
 378         :param interface: Interface name.
 379         :type node: dict
 380         :type interface: str
 381         :return: Return MAC or None if not found.
 382         """
 383         for port in node['interfaces'].values():
 384             port_name = port.get('name')
 385             if port_name is None:
 386                 continue
 387             if port_name == interface:
 388                 return port.get('mac_address')
 389
 390         return None
 391
 392     @staticmethod
 393     def get_adjacent_node_and_interface_by_key(nodes_info, node, port_key):
 394         """Get node and interface adjacent to specified interface
 395         on local network.
 396
 397         :param nodes_info: Dictionary containing information on all nodes
 398         in topology.
 399         :param node: Node that contains specified interface.
 400         :param port_key: Interface port key.
 401         :type nodes_info: dict
 402         :type node: dict
 403         :type port_key: str
 404         :return: Return (node, interface info) tuple or None if not found.
 405         :rtype: (dict, dict)
 406         """
 407         link_name = None
 408         # get link name where the interface belongs to
 409         for port_name, port_data in node['interfaces'].iteritems():
 410             if port_name == 'mgmt':
 411                 continue
 412             if port_name == port_key:
 413                 link_name = port_data['link']
 414                 break
 415
 416         if link_name is None:
 417             return None
 418
 419         # find link
 420         for node_data in nodes_info.values():
 421             # skip self
 422             if node_data['host'] == node['host']:
 423                 continue
 424             for interface, interface_data \
 425                     in node_data['interfaces'].iteritems():
 426                 if 'link' not in interface_data:
 427                     continue
 428                 if interface_data['link'] == link_name:
 429                     return node_data, node_data['interfaces'][interface]
 430
 431     @staticmethod
 432     def get_adjacent_node_and_interface(nodes_info, node, interface_name):
 433         """Get node and interface adjacent to specified interface
 434         on local network.
 435
 436         :param nodes_info: Dictionary containing information on all nodes
 437         in topology.
 438         :param node: Node that contains specified interface.
 439         :param interface_name: Interface name.
 440         :type nodes_info: dict
 441         :type node: dict
 442         :type interface_name: str
 443         :return: Return (node, interface info) tuple or None if not found.
 444         :rtype: (dict, dict)
 445         """
 446         link_name = None
 447         # get link name where the interface belongs to
 448         for port_name, port_data in node['interfaces'].iteritems():
 449             if port_name == 'mgmt':
 450                 continue
 451             if port_data['name'] == interface_name:
 452                 link_name = port_data['link']
 453                 break
 454
 455         if link_name is None:
 456             return None
 457
 458         # find link
 459         for node_data in nodes_info.values():
 460             # skip self
 461             if node_data['host'] == node['host']:
 462                 continue
 463             for interface, interface_data \
 464                     in node_data['interfaces'].iteritems():
 465                 if 'link' not in interface_data:
 466                     continue
 467                 if interface_data['link'] == link_name:
 468                     return node_data, node_data['interfaces'][interface]
 469
 470     @staticmethod
 471     def get_interface_pci_addr(node, interface):
 472         """Get interface PCI address.
 473
 474         :param node: Node to get interface PCI address on.
 475         :param interface: Interface name.
 476         :type node: dict
 477         :type interface: str
 478         :return: Return PCI address or None if not found.
 479         """
 480         for port in node['interfaces'].values():
 481             if interface == port.get('name'):
 482                 return port.get('pci_address')
 483         return None
 484
 485     @staticmethod
 486     def get_interface_driver(node, interface):
 487         """Get interface driver.
 488
 489         :param node: Node to get interface driver on.
 490         :param interface: Interface name.
 491         :type node: dict
 492         :type interface: str
 493         :return: Return interface driver or None if not found.
 494         """
 495         for port in node['interfaces'].values():
 496             if interface == port.get('name'):
 497                 return port.get('driver')
 498         return None
 499
 500     @staticmethod
 501     def get_node_link_mac(node, link_name):
 502         """Return interface mac address by link name
 503
 504         :param node: Node to get interface sw_index on
 505         :param link_name: link name
 506         :type node: dict
 507         :type link_name: string
 508         :return: mac address string
 509         """
 510         for port in node['interfaces'].values():
 511             if port.get('link') == link_name:
 512                 return port.get('mac_address')
 513         return None
 514
 515     @staticmethod
 516     def _get_node_active_link_names(node):
 517         """Return list of link names that are other than mgmt links
 518
 519         :param node: node topology dictionary
 520         :return: list of strings that represent link names occupied by the node
 521         """
 522         interfaces = node['interfaces']
 523         link_names = []
 524         for interface in interfaces.values():
 525             if 'link' in interface:
 526                 link_names.append(interface['link'])
 527         if len(link_names) == 0:
 528             link_names = None
 529         return link_names
 530
 531     @keyword('Get active links connecting "${node1}" and "${node2}"')
 532     def get_active_connecting_links(self, node1, node2):
 533         """Return list of link names that connect together node1 and node2
 534
 535         :param node1: node topology dictionary
 536         :param node2: node topology dictionary
 537         :return: list of strings that represent connecting link names
 538         """
 539
 540         logger.trace("node1: {}".format(str(node1)))
 541         logger.trace("node2: {}".format(str(node2)))
 542         node1_links = self._get_node_active_link_names(node1)
 543         node2_links = self._get_node_active_link_names(node2)
 544         connecting_links = list(set(node1_links).intersection(node2_links))
 545
 546         return connecting_links
 547
 548     @keyword('Get first active connecting link between node "${node1}" and '
 549              '"${node2}"')
 550     def get_first_active_connecting_link(self, node1, node2):
 551         """
 552
 553         :param node1: Connected node
 554         :type node1: dict
 555         :param node2: Connected node
 556         :type node2: dict
 557         :return: name of link connecting the two nodes together
 558         :raises: RuntimeError
 559         """
 560
 561         connecting_links = self.get_active_connecting_links(node1, node2)
 562         if len(connecting_links) == 0:
 563             raise RuntimeError("No links connecting the nodes were found")
 564         else:
 565             return connecting_links[0]
 566
 567     @keyword('Get egress interfaces on "${node1}" for link with "${node2}"')
 568     def get_egress_interfaces_for_nodes(self, node1, node2):
 569         """Get egress interfaces on node1 for link with node2.
 570
 571         :param node1: First node, node to get egress interface on.
 572         :param node2: Second node.
 573         :type node1: dict
 574         :type node2: dict
 575         :return: Egress interfaces.
 576         :rtype: list
 577         """
 578         interfaces = []
 579         links = self.get_active_connecting_links(node1, node2)
 580         if len(links) == 0:
 581             raise RuntimeError('No link between nodes')
 582         for interface in node1['interfaces'].values():
 583             link = interface.get('link')
 584             if link is None:
 585                 continue
 586             if link in links:
 587                 continue
 588             name = interface.get('name')
 589             if name is None:
 590                 continue
 591             interfaces.append(name)
 592         return interfaces
 593
 594     @keyword('Get first egress interface on "${node1}" for link with '
 595              '"${node2}"')
 596     def get_first_egress_interface_for_nodes(self, node1, node2):
 597         """Get first egress interface on node1 for link with node2.
 598
 599         :param node1: First node, node to get egress interface on.
 600         :param node2: Second node.
 601         :type node1: dict
 602         :type node2: dict
 603         :return: Egress interface.
 604         :rtype: str
 605         """
 606         interfaces = self.get_egress_interfaces_for_nodes(node1, node2)
 607         if not interfaces:
 608             raise RuntimeError('No egress interface for nodes')
 609         return interfaces[0]
 610
 611     @keyword('Get link data useful in circular topology test from tg "${tgen}"'
 612              ' dut1 "${dut1}" dut2 "${dut2}"')
 613     def get_links_dict_from_nodes(self, tgen, dut1, dut2):
 614         """Return link combinations used in tests in circular topology.
 615
 616         For the time being it returns links from the Node path:
 617         TG->DUT1->DUT2->TG
 618         :param tgen: traffic generator node data
 619         :param dut1: DUT1 node data
 620         :param dut2: DUT2 node data
 621         :type tgen: dict
 622         :type dut1: dict
 623         :type dut2: dict
 624         :return: dictionary of possible link combinations
 625         the naming convention until changed to something more general is
 626         implemented is this:
 627         DUT1_DUT2_LINK: link name between DUT! and DUT2
 628         DUT1_TG_LINK: link name between DUT1 and TG
 629         DUT2_TG_LINK: link name between DUT2 and TG
 630         TG_TRAFFIC_LINKS: list of link names that generated traffic is sent
 631         to and from
 632         DUT1_BD_LINKS: list of link names that will be connected by the bridge
 633         domain on DUT1
 634         DUT2_BD_LINKS: list of link names that will be connected by the bridge
 635         domain on DUT2
 636         """
 637         # TODO: replace with generic function.
 638         dut1_dut2_link = self.get_first_active_connecting_link(dut1, dut2)
 639         dut1_tg_link = self.get_first_active_connecting_link(dut1, tgen)
 640         dut2_tg_link = self.get_first_active_connecting_link(dut2, tgen)
 641         tg_traffic_links = [dut1_tg_link, dut2_tg_link]
 642         dut1_bd_links = [dut1_dut2_link, dut1_tg_link]
 643         dut2_bd_links = [dut1_dut2_link, dut2_tg_link]
 644         topology_links = {'DUT1_DUT2_LINK': dut1_dut2_link,
 645                           'DUT1_TG_LINK': dut1_tg_link,
 646                           'DUT2_TG_LINK': dut2_tg_link,
 647                           'TG_TRAFFIC_LINKS': tg_traffic_links,
 648                           'DUT1_BD_LINKS': dut1_bd_links,
 649                           'DUT2_BD_LINKS': dut2_bd_links}
 650         return topology_links
 651
 652     @staticmethod
 653     def is_tg_node(node):
 654         """Find out whether the node is TG
 655
 656         :param node: node to examine
 657         :return: True if node is type of TG; False otherwise
 658         """
 659         return node['type'] == NodeType.TG
 660
 661     @staticmethod
 662     def get_node_hostname(node):
 663         """Return host (hostname/ip address) of the node.
 664
 665         :param node: Node created from topology.
 666         :type node: dict
 667         :return: host as 'str' type
 668         """
 669         return node['host']