resources/libraries/python/honeycomb/HcAPIKwInterfaces.py

   1 # Copyright (c) 2017 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 """Keywords to manipulate interface configuration using Honeycomb REST API.
  15
  16 The keywords make possible to put and get configuration data and to get
  17 operational data.
  18 """
  19 from robot.api import logger
  20
  21 from resources.libraries.python.topology import Topology
  22 from resources.libraries.python.HTTPRequest import HTTPCodes
  23 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
  24 from resources.libraries.python.honeycomb.HoneycombUtil \
  25     import DataRepresentation
  26 from resources.libraries.python.honeycomb.HoneycombUtil \
  27     import HoneycombUtil as HcUtil
  28
  29
  30 class InterfaceKeywords(object):
  31     """Keywords for Interface manipulation.
  32
  33     Implements keywords which get configuration and operational data about
  34     vpp interfaces and set the interface's parameters using Honeycomb REST API.
  35     """
  36
  37     INTF_PARAMS = ("name", "description", "type", "enabled",
  38                    "link-up-down-trap-enable", "v3po:l2", "v3po:vxlan-gpe",
  39                    "vpp-vlan:sub-interfaces")
  40     IPV4_PARAMS = ("enabled", "forwarding", "mtu")
  41     IPV6_PARAMS = ("enabled", "forwarding", "mtu", "dup-addr-detect-transmits")
  42     IPV6_AUTOCONF_PARAMS = ("create-global-addresses",
  43                             "create-temporary-addresses",
  44                             "temporary-valid-lifetime",
  45                             "temporary-preferred-lifetime")
  46     ETH_PARAMS = ("mtu", )
  47     ROUTING_PARAMS = ("ipv4-vrf-id", "ipv6-vrf-id")
  48     VXLAN_PARAMS = ("src", "dst", "vni", "encap-vrf-id")
  49     L2_PARAMS = ("bridge-domain", "split-horizon-group",
  50                  "bridged-virtual-interface")
  51     TAP_PARAMS = ("tap-name", "mac", "device-instance")
  52     VHOST_USER_PARAMS = ("socket", "role")
  53     SUB_IF_PARAMS = ("identifier",
  54                      "vlan-type",
  55                      "enabled")
  56     SUB_IF_MATCH = ("default",
  57                     "untagged",
  58                     "vlan-tagged",
  59                     "vlan-tagged-exact-match")
  60     BD_PARAMS = ("bridge-domain",
  61                  "split-horizon-group",
  62                  "bridged-virtual-interface")
  63     VXLAN_GPE_PARAMS = ("local",
  64                         "remote",
  65                         "vni",
  66                         "next-protocol",
  67                         "encap-vrf-id",
  68                         "decap-vrf-id")
  69
  70     def __init__(self):
  71         pass
  72
  73     @staticmethod
  74     def _configure_interface(node, interface, data,
  75                              data_representation=DataRepresentation.JSON):
  76         """Send interface configuration data and check the response.
  77
  78         :param node: Honeycomb node.
  79         :param interface: The name of interface.
  80         :param data: Configuration data to be sent in PUT request.
  81         :param data_representation: How the data is represented.
  82         :type node: dict
  83         :type interface: str
  84         :type data: dict
  85         :type data_representation: DataRepresentation
  86         :returns: Content of response.
  87         :rtype: bytearray
  88         :raises HoneycombError: If the status code in response on PUT is not
  89         200 = OK.
  90         """
  91
  92         status_code, resp = HcUtil.\
  93             put_honeycomb_data(node, "config_vpp_interfaces", data,
  94                                data_representation=data_representation)
  95         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
  96             raise HoneycombError(
  97                 "The configuration of interface '{0}' was not successful. "
  98                 "Status code: {1}.".format(interface, status_code))
  99         return resp
 100
 101     @staticmethod
 102     def get_all_interfaces_cfg_data(node):
 103         """Get configuration data about all interfaces from Honeycomb.
 104
 105         :param node: Honeycomb node.
 106         :type node: dict
 107         :returns: Configuration data about all interfaces from Honeycomb.
 108         :rtype: list
 109         :raises HoneycombError: If it is not possible to get configuration data.
 110         """
 111
 112         status_code, resp = HcUtil.\
 113             get_honeycomb_data(node, "config_vpp_interfaces")
 114         if status_code != HTTPCodes.OK:
 115             raise HoneycombError(
 116                 "Not possible to get configuration information about the "
 117                 "interfaces. Status code: {0}.".format(status_code))
 118         try:
 119             return resp["interfaces"]["interface"]
 120
 121         except (KeyError, TypeError):
 122             return []
 123
 124     @staticmethod
 125     def get_interface_cfg_data(node, interface):
 126         """Get configuration data about the given interface from Honeycomb.
 127
 128         :param node: Honeycomb node.
 129         :param interface: The name of interface.
 130         :type node: dict
 131         :type interface: str
 132         :returns: Configuration data about the given interface from Honeycomb.
 133         :rtype: dict
 134         """
 135
 136         intfs = InterfaceKeywords.get_all_interfaces_cfg_data(node)
 137         for intf in intfs:
 138             if intf["name"] == interface:
 139                 return intf
 140         return {}
 141
 142     @staticmethod
 143     def get_all_interfaces_oper_data(node):
 144         """Get operational data about all interfaces from Honeycomb.
 145
 146         :param node: Honeycomb node.
 147         :type node: dict
 148         :returns: Operational data about all interfaces from Honeycomb.
 149         :rtype: list
 150         :raises HoneycombError: If it is not possible to get operational data.
 151         """
 152
 153         status_code, resp = HcUtil.\
 154             get_honeycomb_data(node, "oper_vpp_interfaces")
 155         if status_code != HTTPCodes.OK:
 156             raise HoneycombError(
 157                 "Not possible to get operational information about the "
 158                 "interfaces. Status code: {0}.".format(status_code))
 159         try:
 160             return resp["interfaces-state"]["interface"]
 161
 162         except (KeyError, TypeError):
 163             return []
 164
 165     @staticmethod
 166     def get_disabled_interfaces_oper_data(node):
 167         """Get operational data about all disabled interfaces from Honeycomb.
 168
 169         :param node: Honeycomb node.
 170         :type node: dict
 171         :returns: Operational data about disabled interfaces.
 172         :rtype: list
 173         :raises HoneycombError: If it is not possible to get operational data.
 174         """
 175
 176         status_code, resp = HcUtil. \
 177             get_honeycomb_data(node, "oper_disabled_interfaces")
 178         if status_code == HTTPCodes.NOT_FOUND:
 179             raise HoneycombError(
 180                 "No disabled interfaces present on node."
 181             )
 182         if status_code != HTTPCodes.OK:
 183             raise HoneycombError(
 184                 "Not possible to get operational information about the "
 185                 "interfaces. Status code: {0}.".format(status_code))
 186         try:
 187             return resp["disabled-interfaces"]["disabled-interface-index"]
 188
 189         except (KeyError, TypeError):
 190             return []
 191
 192     @staticmethod
 193     def get_interface_oper_data(node, interface):
 194         """Get operational data about the given interface from Honeycomb.
 195
 196         :param node: Honeycomb node.
 197         :param interface: The name of interface.
 198         :type node: dict
 199         :type interface: str
 200         :returns: Operational data about the given interface from Honeycomb.
 201         :rtype: dict
 202         """
 203
 204         intfs = InterfaceKeywords.get_all_interfaces_oper_data(node)
 205         for intf in intfs:
 206             if intf["name"] == interface:
 207                 return intf
 208         return {}
 209
 210     @staticmethod
 211     def _set_interface_properties(node, interface, path, new_value=None):
 212         """Set interface properties.
 213
 214         This method reads interface configuration data, creates, changes or
 215         removes the requested data and puts it back to Honeycomb.
 216
 217         :param node: Honeycomb node.
 218         :param interface: The name of interface.
 219         :param path:  Path to data we want to change / create / remove.
 220         :param new_value: The new value to be set. If None, the item will be
 221         removed.
 222         :type node: dict
 223         :type interface: str
 224         :type path: tuple
 225         :type new_value: str, dict or list
 226         :returns: Content of response.
 227         :rtype: bytearray
 228         :raises HoneycombError: If it is not possible to get or set the data.
 229         """
 230
 231         status_code, resp = HcUtil.\
 232             get_honeycomb_data(node, "config_vpp_interfaces")
 233         if status_code != HTTPCodes.OK:
 234             raise HoneycombError(
 235                 "Not possible to get configuration information about the "
 236                 "interfaces. Status code: {0}.".format(status_code))
 237
 238         if new_value:
 239             new_data = HcUtil.set_item_value(resp, path, new_value)
 240         else:
 241             new_data = HcUtil.remove_item(resp, path)
 242         return InterfaceKeywords._configure_interface(node, interface, new_data)
 243
 244     @staticmethod
 245     def set_interface_state(node, interface, state="up"):
 246         """Set VPP interface state.
 247
 248         The keyword changes the administration state of interface to up or down
 249         depending on the parameter "state".
 250
 251         :param node: Honeycomb node.
 252         :param interface: Interface name, key, link name or sw_if_index.
 253         :param state: The requested state, only "up" and "down" are valid
 254         values.
 255         :type node: dict
 256         :type interface: str
 257         :type state: str
 258         :returns: Content of response.
 259         :rtype: bytearray
 260         :raises KeyError: If the argument "state" is nor "up" or "down".
 261         :raises HoneycombError: If the interface is not present on the node.
 262         """
 263
 264         intf_state = {"up": "true",
 265                       "down": "false"}
 266
 267         interface = Topology.convert_interface_reference(
 268             node, interface, "name")
 269
 270         intf = interface.replace("/", "%2F")
 271         path = "/interface/{0}".format(intf)
 272
 273         status_code, resp = HcUtil.\
 274             get_honeycomb_data(node, "config_vpp_interfaces", path)
 275         if status_code != HTTPCodes.OK:
 276             raise HoneycombError(
 277                 "Not possible to get configuration information about the "
 278                 "interfaces. Status code: {0}.".format(status_code))
 279
 280         resp["interface"][0]["enabled"] = intf_state[state.lower()]
 281
 282         status_code, resp = HcUtil. \
 283             put_honeycomb_data(node, "config_vpp_interfaces", resp, path,
 284                                data_representation=DataRepresentation.JSON)
 285         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
 286             raise HoneycombError(
 287                 "The configuration of interface '{0}' was not successful. "
 288                 "Status code: {1}.".format(interface, status_code))
 289         return resp
 290
 291     @staticmethod
 292     def set_interface_up(node, interface):
 293         """Set the administration state of VPP interface to up.
 294
 295         :param node: Honeycomb node.
 296         :param interface: The name of interface.
 297         :type node: dict
 298         :type interface: str
 299         :returns: Content of response
 300         :rtype: bytearray
 301         """
 302
 303         return InterfaceKeywords.set_interface_state(node, interface, "up")
 304
 305     @staticmethod
 306     def set_interface_down(node, interface):
 307         """Set the administration state of VPP interface to down.
 308
 309         :param node: Honeycomb node.
 310         :param interface: The name of interface.
 311         :type node: dict
 312         :type interface: str
 313         :returns: Content of response.
 314         :rtype: bytearray
 315         """
 316
 317         return InterfaceKeywords.set_interface_state(node, interface, "down")
 318
 319     @staticmethod
 320     def add_bridge_domain_to_interface(node, interface, bd_name,
 321                                        split_horizon_group=None, bvi=None):
 322         """Add a new bridge domain to an interface and set its parameters.
 323
 324         :param node: Honeycomb node.
 325         :param interface: Interface name, key, link name or sw_if_index.
 326         :param bd_name: Bridge domain name.
 327         :param split_horizon_group: Split-horizon group name.
 328         :param bvi: The bridged virtual interface.
 329         :type node: dict
 330         :type interface: str
 331         :type bd_name: str
 332         :type split_horizon_group: str
 333         :type bvi: str
 334         :returns: Content of response.
 335         :rtype: bytearray
 336         :raises HoneycombError: If the interface is not present on the node.
 337         """
 338
 339         interface = Topology.convert_interface_reference(
 340             node, interface, "name")
 341
 342         v3po_l2 = {"bridge-domain": str(bd_name)}
 343         if split_horizon_group:
 344             v3po_l2["split-horizon-group"] = str(split_horizon_group)
 345         if bvi:
 346             v3po_l2["bridged-virtual-interface"] = str(bvi)
 347
 348         path = ("interfaces", ("interface", "name", str(interface)), "v3po:l2")
 349
 350         return InterfaceKeywords._set_interface_properties(
 351             node, interface, path, v3po_l2)
 352
 353     @staticmethod
 354     def remove_bridge_domain_from_interface(node, interface):
 355         """Remove bridge domain assignment from interface.
 356
 357         :param node: Honeycomb node.
 358         :param interface: Interface name, key, link name or sw_if_index.
 359         :type node: dict
 360         :type interface: str or int
 361
 362         :raises HoneycombError: If the operation fails.
 363         """
 364
 365         interface = Topology.convert_interface_reference(
 366             node, interface, "name")
 367
 368         intf = interface.replace("/", "%2F")
 369
 370         path = "/interface/{0}/v3po:l2".format(intf)
 371
 372         status_code, response = HcUtil.delete_honeycomb_data(
 373             node, "config_vpp_interfaces", path)
 374
 375         if status_code != HTTPCodes.OK:
 376             if '"error-tag":"data-missing"' in response:
 377                 logger.debug("Data does not exist in path.")
 378             else:
 379                 raise HoneycombError(
 380                     "Could not remove bridge domain assignment from interface "
 381                     "'{0}'. Status code: {1}.".format(interface, status_code))
 382
 383     @staticmethod
 384     def get_bd_oper_data_from_interface(node, interface):
 385         """Returns operational data about bridge domain settings in the
 386         interface.
 387
 388         :param node: Honeycomb node.
 389         :param interface: The name of interface.
 390         :type node: dict
 391         :type interface: str
 392         :returns: Operational data about bridge domain settings in the
 393         interface.
 394         :rtype: dict
 395         """
 396
 397         if_data = InterfaceKeywords.get_interface_oper_data(node, interface)
 398
 399         if if_data:
 400             try:
 401                 return if_data["v3po:l2"]
 402             except KeyError:
 403                 return {}
 404         return {}
 405
 406     @staticmethod
 407     def configure_interface_base(node, interface, param, value):
 408         """Configure the base parameters of interface.
 409
 410         :param node: Honeycomb node.
 411         :param interface: The name of interface.
 412         :param param: Parameter to configure (set, change, remove)
 413         :param value: The value of parameter. If None, the parameter will be
 414         removed.
 415         :type node: dict
 416         :type interface: str
 417         :type param: str
 418         :type value: str
 419         :returns: Content of response.
 420         :rtype: bytearray
 421         :raises HoneycombError: If the parameter is not valid.
 422         """
 423
 424         if param not in InterfaceKeywords.INTF_PARAMS:
 425             raise HoneycombError("The parameter {0} is invalid.".format(param))
 426
 427         path = ("interfaces", ("interface", "name", interface), param)
 428         return InterfaceKeywords._set_interface_properties(
 429             node, interface, path, value)
 430
 431     @staticmethod
 432     def configure_interface_ipv4(node, interface, param, value):
 433         """Configure IPv4 parameters of interface.
 434
 435         :param node: Honeycomb node.
 436         :param interface: The name of interface.
 437         :param param: Parameter to configure (set, change, remove)
 438         :param value: The value of parameter. If None, the parameter will be
 439         removed.
 440         :type node: dict
 441         :type interface: str
 442         :type param: str
 443         :type value: str
 444         :returns: Content of response.
 445         :rtype: bytearray
 446         :raises HoneycombError: If the parameter is not valid.
 447         """
 448
 449         interface = Topology.convert_interface_reference(
 450             node, interface, "name")
 451
 452         if param not in InterfaceKeywords.IPV4_PARAMS:
 453             raise HoneycombError("The parameter {0} is invalid.".format(param))
 454
 455         path = ("interfaces", ("interface", "name", interface),
 456                 "ietf-ip:ipv4", param)
 457         return InterfaceKeywords._set_interface_properties(
 458             node, interface, path, value)
 459
 460     @staticmethod
 461     def add_first_ipv4_address(node, interface, ip_addr, network):
 462         """Add the first IPv4 address.
 463
 464         If there are any other addresses configured, they will be removed.
 465
 466         :param node: Honeycomb node.
 467         :param interface: The name of interface.
 468         :param ip_addr: IPv4 address to be set.
 469         :param network: Netmask or length of network prefix.
 470         :type node: dict
 471         :type interface: str
 472         :type ip_addr: str
 473         :type network: str or int
 474         :returns: Content of response.
 475         :rtype: bytearray
 476         :raises HoneycombError: If the provided netmask or prefix is not valid.
 477         """
 478
 479         interface = Topology.convert_interface_reference(
 480             node, interface, "name")
 481
 482         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
 483         if isinstance(network, basestring):
 484             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
 485         elif isinstance(network, int) and (0 < network < 33):
 486             address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
 487         else:
 488             raise HoneycombError("Value {0} is not a valid netmask or network "
 489                                  "prefix length.".format(network))
 490         return InterfaceKeywords._set_interface_properties(
 491             node, interface, path, address)
 492
 493     @staticmethod
 494     def add_ipv4_address(node, interface, ip_addr, network):
 495         """Add IPv4 address.
 496
 497         :param node: Honeycomb node.
 498         :param interface: The name of interface.
 499         :param ip_addr: IPv4 address to be set.
 500         :param network: Netmask or length of network prefix.
 501         :type node: dict
 502         :type interface: str
 503         :type ip_addr: str
 504         :type network: str or int
 505         :returns: Content of response.
 506         :rtype: bytearray
 507         :raises HoneycombError: If the provided netmask or prefix is not valid.
 508         """
 509
 510         interface = Topology.convert_interface_reference(
 511             node, interface, "name")
 512
 513         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 514                 "address")
 515         if isinstance(network, basestring):
 516             address = [{"ip": ip_addr, "netmask": network}]
 517         elif isinstance(network, int) and (0 < network < 33):
 518             address = [{"ip": ip_addr, "prefix-length": network}]
 519         else:
 520             raise HoneycombError("Value {0} is not a valid netmask or network "
 521                                  "prefix length.".format(network))
 522         return InterfaceKeywords._set_interface_properties(
 523             node, interface, path, address)
 524
 525     @staticmethod
 526     def remove_all_ipv4_addresses(node, interface):
 527         """Remove all IPv4 addresses from interface.
 528
 529         :param node: Honeycomb node.
 530         :param interface: The name of interface.
 531         :type node: dict
 532         :type interface: str
 533         :returns: Content of response.
 534         :rtype: bytearray
 535         """
 536
 537         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 538                 "address")
 539         return InterfaceKeywords._set_interface_properties(
 540             node, interface, path, None)
 541
 542     @staticmethod
 543     def add_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
 544         """Add the IPv4 neighbour.
 545
 546         :param node: Honeycomb node.
 547         :param interface: The name of interface.
 548         :param ip_addr: IPv4 address of neighbour to be set.
 549         :param link_layer_address: Link layer address.
 550         :type node: dict
 551         :type interface: str
 552         :type ip_addr: str
 553         :type link_layer_address: str
 554         :returns: Content of response.
 555         :rtype: bytearray
 556         """
 557
 558         interface = Topology.convert_interface_reference(
 559             node, interface, "name")
 560
 561         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 562                 "neighbor")
 563         neighbor = [{"ip": ip_addr, "link-layer-address": link_layer_address}, ]
 564         return InterfaceKeywords._set_interface_properties(
 565             node, interface, path, neighbor)
 566
 567     @staticmethod
 568     def remove_all_ipv4_neighbors(node, interface):
 569         """Remove all IPv4 neighbours.
 570
 571         :param node: Honeycomb node.
 572         :param interface: The name of interface.
 573         :type node: dict
 574         :type interface: str
 575         :returns: Content of response.
 576         :rtype: bytearray
 577         """
 578
 579         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 580                 "neighbor")
 581         return InterfaceKeywords._set_interface_properties(
 582             node, interface, path, None)
 583
 584     @staticmethod
 585     def configure_interface_ipv6(node, interface, param, value):
 586         """Configure IPv6 parameters of interface
 587
 588         :param node: Honeycomb node.
 589         :param interface: The name of interface.
 590         :param param: Parameter to configure (set, change, remove)
 591         :param value: The value of parameter. If None, the parameter will be
 592         removed.
 593         :type node: dict
 594         :type interface: str
 595         :type param: str
 596         :type value: str
 597         :returns: Content of response.
 598         :rtype: bytearray
 599         :raises HoneycombError: If the parameter is not valid.
 600         """
 601
 602         if param in InterfaceKeywords.IPV6_PARAMS:
 603             path = ("interfaces", ("interface", "name", interface),
 604                     "ietf-ip:ipv6", param)
 605         elif param in InterfaceKeywords.IPV6_AUTOCONF_PARAMS:
 606             path = ("interfaces", ("interface", "name", interface),
 607                     "ietf-ip:ipv6", "autoconf", param)
 608         else:
 609             raise HoneycombError("The parameter {0} is invalid.".format(param))
 610
 611         return InterfaceKeywords._set_interface_properties(
 612             node, interface, path, value)
 613
 614     @staticmethod
 615     def add_first_ipv6_address(node, interface, ip_addr, prefix_len):
 616         """Add the first IPv6 address.
 617
 618         If there are any other addresses configured, they will be removed.
 619
 620         :param node: Honeycomb node.
 621         :param interface: The name of interface.
 622         :param ip_addr: IPv6 address to be set.
 623         :param prefix_len: Prefix length.
 624         :type node: dict
 625         :type interface: str
 626         :type ip_addr: str
 627         :type prefix_len: str
 628         :returns: Content of response.
 629         :rtype: bytearray
 630         """
 631
 632         interface = Topology.convert_interface_reference(
 633             node, interface, "name")
 634
 635         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6")
 636         address = {"address": [{"ip": ip_addr, "prefix-length": prefix_len}, ]}
 637         return InterfaceKeywords._set_interface_properties(
 638             node, interface, path, address)
 639
 640     @staticmethod
 641     def add_ipv6_address(node, interface, ip_addr, prefix_len):
 642         """Add IPv6 address.
 643
 644         :param node: Honeycomb node.
 645         :param interface: The name of interface.
 646         :param ip_addr: IPv6 address to be set.
 647         :param prefix_len: Prefix length.
 648         :type node: dict
 649         :type interface: str
 650         :type ip_addr: str
 651         :type prefix_len: str
 652         :returns: Content of response.
 653         :rtype: bytearray
 654         """
 655
 656         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 657                 "address")
 658         address = [{"ip": ip_addr, "prefix-length": prefix_len}, ]
 659         return InterfaceKeywords._set_interface_properties(
 660             node, interface, path, address)
 661
 662     @staticmethod
 663     def remove_all_ipv6_addresses(node, interface):
 664         """Remove all IPv6 addresses from interface.
 665
 666         :param node: Honeycomb node.
 667         :param interface: The name of interface.
 668         :type node: dict
 669         :type interface: str
 670         :returns: Content of response.
 671         :rtype: bytearray
 672         """
 673
 674         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 675                 "address")
 676         return InterfaceKeywords._set_interface_properties(
 677             node, interface, path, None)
 678
 679     @staticmethod
 680     def add_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
 681         """Add the IPv6 neighbour.
 682
 683         :param node: Honeycomb node.
 684         :param interface: The name of interface.
 685         :param ip_addr: IPv6 address of neighbour to be set.
 686         :param link_layer_address: Link layer address.
 687         :type node: dict
 688         :type interface: str
 689         :type ip_addr: str
 690         :type link_layer_address: str
 691         :returns: Content of response.
 692         :rtype: bytearray
 693         """
 694
 695         interface = Topology.convert_interface_reference(
 696             node, interface, "name")
 697
 698         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 699                 "neighbor")
 700         neighbor = [{"ip": ip_addr, "link-layer-address": link_layer_address}, ]
 701         return InterfaceKeywords._set_interface_properties(
 702             node, interface, path, neighbor)
 703
 704     @staticmethod
 705     def remove_all_ipv6_neighbors(node, interface):
 706         """Remove all IPv6 neighbours.
 707
 708         :param node: Honeycomb node.
 709         :param interface: The name of interface.
 710         :type node: dict
 711         :type interface: str
 712         :returns: Content of response.
 713         :rtype: bytearray
 714         """
 715
 716         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 717                 "neighbor")
 718         return InterfaceKeywords._set_interface_properties(
 719             node, interface, path, None)
 720
 721     @staticmethod
 722     def configure_interface_ethernet(node, interface, param, value):
 723         """Configure the ethernet parameters of interface.
 724
 725         :param node: Honeycomb node.
 726         :param interface: The name of interface.
 727         :param param: Parameter to configure (set, change, remove)
 728         :param value: The value of parameter. If None, the parameter will be
 729         removed.
 730         :type node: dict
 731         :type interface: str
 732         :type param: str
 733         :type value: str
 734         :returns: Content of response.
 735         :rtype: bytearray
 736         :raises HoneycombError: If the parameter is not valid.
 737         """
 738
 739         if param not in InterfaceKeywords.ETH_PARAMS:
 740             raise HoneycombError("The parameter {0} is invalid.".format(param))
 741         path = ("interfaces", ("interface", "name", interface), "v3po:ethernet",
 742                 param)
 743         return InterfaceKeywords._set_interface_properties(
 744             node, interface, path, value)
 745
 746     @staticmethod
 747     def configure_interface_routing(node, interface, param, value):
 748         """Configure the routing parameters of interface.
 749
 750         :param node: Honeycomb node.
 751         :param interface: The name of interface.
 752         :param param: Parameter to configure (set, change, remove)
 753         :param value: The value of parameter. If None, the parameter will be
 754         removed.
 755         :type node: dict
 756         :type interface: str
 757         :type param: str
 758         :type value: str
 759         :returns: Content of response.
 760         :rtype: bytearray
 761         :raises HoneycombError: If the parameter is not valid.
 762         """
 763
 764         interface = Topology.convert_interface_reference(
 765             node, interface, "name")
 766
 767         if param not in InterfaceKeywords.ROUTING_PARAMS:
 768             raise HoneycombError("The parameter {0} is invalid.".format(param))
 769
 770         path = ("interfaces", ("interface", "name", interface), "v3po:routing",
 771                 param)
 772         return InterfaceKeywords._set_interface_properties(
 773             node, interface, path, value)
 774
 775     @staticmethod
 776     def create_vxlan_interface(node, interface, **kwargs):
 777         """Create a new VxLAN interface.
 778
 779         :param node: Honeycomb node.
 780         :param interface: The name of interface.
 781         :param kwargs: Parameters and their values. The accepted parameters are
 782         defined in InterfaceKeywords.VXLAN_PARAMS.
 783         :type node: dict
 784         :type interface: str
 785         :type kwargs: dict
 786         :returns: Content of response.
 787         :rtype: bytearray
 788         :raises HoneycombError: If the parameter is not valid.
 789         """
 790
 791         new_vx_lan = {
 792             "name": interface,
 793             "type": "v3po:vxlan-tunnel",
 794             "v3po:vxlan": {}
 795         }
 796         for param, value in kwargs.items():
 797             if param not in InterfaceKeywords.VXLAN_PARAMS:
 798                 raise HoneycombError("The parameter {0} is invalid.".
 799                                      format(param))
 800             new_vx_lan["v3po:vxlan"][param] = value
 801
 802         path = ("interfaces", "interface")
 803         vx_lan_structure = [new_vx_lan, ]
 804         return InterfaceKeywords._set_interface_properties(
 805             node, interface, path, vx_lan_structure)
 806
 807     @staticmethod
 808     def delete_interface(node, interface):
 809         """Delete an interface.
 810
 811         :param node: Honeycomb node.
 812         :param interface: The name of interface.
 813         :type node: dict
 814         :type interface: str
 815         :returns: Content of response.
 816         :rtype: bytearray
 817         :raises HoneycombError: If it is not possible to get information about
 818         interfaces or it is not possible to delete the interface.
 819         """
 820
 821         path = ("interfaces", ("interface", "name", interface))
 822
 823         status_code, resp = HcUtil.\
 824             get_honeycomb_data(node, "config_vpp_interfaces")
 825         if status_code != HTTPCodes.OK:
 826             raise HoneycombError(
 827                 "Not possible to get configuration information about the "
 828                 "interfaces. Status code: {0}.".format(status_code))
 829
 830         new_data = HcUtil.remove_item(resp, path)
 831         status_code, resp = HcUtil.\
 832             put_honeycomb_data(node, "config_vpp_interfaces", new_data)
 833         if status_code != HTTPCodes.OK:
 834             raise HoneycombError("Not possible to remove interface {0}. "
 835                                  "Status code: {1}.".
 836                                  format(interface, status_code))
 837         return resp
 838
 839     @staticmethod
 840     def configure_interface_vxlan(node, interface, **kwargs):
 841         """Configure VxLAN on the interface.
 842
 843         The keyword configures VxLAN parameters on the given interface. The type
 844         of interface must be set to "v3po:vxlan-tunnel".
 845         The new VxLAN parameters overwrite the current configuration. If a
 846         parameter in new configuration is missing, it is removed from VxLAN
 847         configuration.
 848         If the dictionary kwargs is empty, VxLAN configuration is removed.
 849
 850         :param node: Honeycomb node.
 851         :param interface: The name of interface.
 852         :param kwargs: Parameters and their values. The accepted parameters are
 853         defined in InterfaceKeywords.VXLAN_PARAMS.
 854         :type node: dict
 855         :type interface: str
 856         :type kwargs: dict
 857         :returns: Content of response.
 858         :rtype: bytearray
 859         :raises HoneycombError: If the parameter is not valid.
 860         """
 861
 862         vx_lan_structure = dict()
 863         for param, value in kwargs.items():
 864             if param not in InterfaceKeywords.VXLAN_PARAMS:
 865                 raise HoneycombError("The parameter {0} is invalid.".
 866                                      format(param))
 867             vx_lan_structure[param] = value
 868
 869         path = ("interfaces", ("interface", "name", interface), "v3po:vxlan")
 870         return InterfaceKeywords._set_interface_properties(
 871             node, interface, path, vx_lan_structure)
 872
 873     @staticmethod
 874     def configure_interface_l2(node, interface, param, value):
 875         """Configure the L2 parameters of interface.
 876
 877         :param node: Honeycomb node.
 878         :param interface: The name of interface.
 879         :param param: Parameter to configure (set, change, remove)
 880         :param value: The value of parameter. If None, the parameter will be
 881         removed.
 882         :type node: dict
 883         :type interface: str
 884         :type param: str
 885         :type value: str
 886         :returns: Content of response.
 887         :rtype: bytearray
 888         :raises HoneycombError: If the parameter is not valid.
 889         """
 890
 891         if param not in InterfaceKeywords.L2_PARAMS:
 892             raise HoneycombError("The parameter {0} is invalid.".format(param))
 893         path = ("interfaces", ("interface", "name", interface), "v3po:l2",
 894                 param)
 895         return InterfaceKeywords._set_interface_properties(
 896             node, interface, path, value)
 897
 898     @staticmethod
 899     def create_tap_interface(node, interface, **kwargs):
 900         """Create a new TAP interface.
 901
 902         :param node: Honeycomb node.
 903         :param interface: The name of interface.
 904         :param kwargs: Parameters and their values. The accepted parameters are
 905         defined in InterfaceKeywords.TAP_PARAMS.
 906         :type node: dict
 907         :type interface: str
 908         :type kwargs: dict
 909         :returns: Content of response.
 910         :rtype: bytearray
 911         :raises HoneycombError: If the parameter is not valid.
 912         """
 913
 914         new_tap = {
 915             "name": interface,
 916             "type": "v3po:tap",
 917             "v3po:tap": {}
 918         }
 919         for param, value in kwargs.items():
 920             if param not in InterfaceKeywords.TAP_PARAMS:
 921                 raise HoneycombError("The parameter {0} is invalid.".
 922                                      format(param))
 923             new_tap["v3po:tap"][param] = value
 924
 925         path = ("interfaces", "interface")
 926         new_tap_structure = [new_tap, ]
 927         return InterfaceKeywords._set_interface_properties(
 928             node, interface, path, new_tap_structure)
 929
 930     @staticmethod
 931     def configure_interface_tap(node, interface, **kwargs):
 932         """Configure TAP on the interface.
 933
 934         The keyword configures TAP parameters on the given interface. The type
 935         of interface must be set to "v3po:tap".
 936         The new TAP parameters overwrite the current configuration. If a
 937         parameter in new configuration is missing, it is removed from TAP
 938         configuration.
 939         If the dictionary kwargs is empty, TAP configuration is removed.
 940
 941         :param node: Honeycomb node.
 942         :param interface: The name of interface.
 943         :param kwargs: Parameters and their values. The accepted parameters are
 944         defined in InterfaceKeywords.TAP_PARAMS.
 945         :type node: dict
 946         :type interface: str
 947         :type kwargs: dict
 948         :returns: Content of response.
 949         :rtype: bytearray
 950         :raises HoneycombError: If the parameter is not valid.
 951         """
 952
 953         tap_structure = dict()
 954         for param, value in kwargs.items():
 955             if param not in InterfaceKeywords.TAP_PARAMS:
 956                 raise HoneycombError("The parameter {0} is invalid.".
 957                                      format(param))
 958             tap_structure[param] = value
 959
 960         path = ("interfaces", ("interface", "name", interface), "v3po:tap")
 961         return InterfaceKeywords._set_interface_properties(
 962             node, interface, path, tap_structure)
 963
 964     @staticmethod
 965     def configure_interface_vhost_user(node, interface, **kwargs):
 966         """Configure vhost-user on the interface.
 967
 968         The keyword configures vhost-user parameters on the given interface.
 969         The type of interface must be set to "v3po:vhost-user".
 970         The new vhost-user parameters overwrite the current configuration. If a
 971         parameter in new configuration is missing, it is removed from vhost-user
 972         configuration.
 973         If the dictionary kwargs is empty, vhost-user configuration is removed.
 974
 975         :param node: Honeycomb node.
 976         :param interface: The name of interface.
 977         :param kwargs: Parameters and their values. The accepted parameters are
 978         defined in InterfaceKeywords.VHOST_USER_PARAMS.
 979         :type node: dict
 980         :type interface: str
 981         :type kwargs: dict
 982         :returns: Content of response.
 983         :rtype: bytearray
 984         :raises HoneycombError: If the parameter is not valid.
 985         """
 986
 987         vhost_structure = dict()
 988         for param, value in kwargs.items():
 989             if param not in InterfaceKeywords.VHOST_USER_PARAMS:
 990                 raise HoneycombError("The parameter {0} is invalid.".
 991                                      format(param))
 992             vhost_structure[param] = value
 993
 994         path = ("interfaces", ("interface", "name", interface),
 995                 "v3po:vhost-user")
 996         return InterfaceKeywords._set_interface_properties(
 997             node, interface, path, vhost_structure)
 998
 999     @staticmethod
1000     def create_vhost_user_interface(node, interface, **kwargs):
1001         """Create a new vhost-user interface.
1002
1003         :param node: Honeycomb node.
1004         :param interface: The name of interface.
1005         :param kwargs: Parameters and their values. The accepted parameters are
1006         defined in InterfaceKeywords.VHOST_USER_PARAMS.
1007         :type node: dict
1008         :type interface: str
1009         :type kwargs: dict
1010         :returns: Content of response.
1011         :rtype: bytearray
1012         :raises HoneycombError: If the parameter is not valid.
1013         """
1014
1015         new_vhost = {
1016             "name": interface,
1017             "type": "v3po:vhost-user",
1018             "v3po:vhost-user": {}
1019         }
1020         for param, value in kwargs.items():
1021             if param not in InterfaceKeywords.VHOST_USER_PARAMS:
1022                 raise HoneycombError("The parameter {0} is invalid.".
1023                                      format(param))
1024             new_vhost["v3po:vhost-user"][param] = value
1025
1026         path = ("interfaces", "interface")
1027         new_vhost_structure = [new_vhost, ]
1028         return InterfaceKeywords._set_interface_properties(
1029             node, interface, path, new_vhost_structure)
1030
1031     @staticmethod
1032     def create_sub_interface(node, super_interface, match, tags=None, **kwargs):
1033         """Create a new sub-interface.
1034
1035         :param node: Honeycomb node.
1036         :param super_interface: Super interface.
1037         :param match: Match type. The valid values are defined in
1038         InterfaceKeywords.SUB_IF_MATCH.
1039         :param tags: List of tags.
1040         :param kwargs: Parameters and their values. The accepted parameters are
1041         defined in InterfaceKeywords.SUB_IF_PARAMS.
1042         :type node: dict
1043         :type super_interface: str
1044         :type match: str
1045         :type tags: list
1046         :type kwargs: dict
1047         :returns: Content of response.
1048         :rtype: bytearray
1049         :raises HoneycombError: If the parameter is not valid.
1050         :raises KeyError: If the parameter 'match' is invalid.
1051         """
1052
1053         match_type = {
1054             "default":
1055                 {"default": {}},
1056             "untagged":
1057                 {"untagged": {}},
1058             "vlan-tagged":
1059                 {"vlan-tagged": {"match-exact-tags": "false"}},
1060             "vlan-tagged-exact-match":
1061                 {"vlan-tagged": {"match-exact-tags": "true"}}
1062         }
1063
1064         new_sub_interface = {
1065             "tags": {
1066                 "tag": []
1067             },
1068         }
1069
1070         for param, value in kwargs.items():
1071             if param in InterfaceKeywords.SUB_IF_PARAMS:
1072                 new_sub_interface[param] = value
1073             else:
1074                 raise HoneycombError("The parameter {0} is invalid.".
1075                                      format(param))
1076         try:
1077             new_sub_interface["match"] = match_type[match]
1078         except KeyError:
1079             raise HoneycombError("The value '{0}' of parameter 'match' is "
1080                                  "invalid.".format(match))
1081
1082         if tags:
1083             new_sub_interface["tags"]["tag"].extend(tags)
1084
1085         path = ("interfaces",
1086                 ("interface", "name", super_interface),
1087                 "vpp-vlan:sub-interfaces",
1088                 "sub-interface")
1089         new_sub_interface_structure = [new_sub_interface, ]
1090         return InterfaceKeywords._set_interface_properties(
1091             node, super_interface, path, new_sub_interface_structure)
1092
1093     @staticmethod
1094     def get_sub_interface_oper_data(node, super_interface, identifier):
1095         """Retrieves sub-interface operational data using Honeycomb API.
1096
1097         :param node: Honeycomb node.
1098         :param super_interface: Super interface.
1099         :param identifier: The ID of sub-interface.
1100         :type node: dict
1101         :type super_interface: str
1102         :type identifier: int
1103         :returns: Sub-interface operational data.
1104         :rtype: dict
1105         :raises HoneycombError: If there is no sub-interface with the given ID.
1106         """
1107
1108         if_data = InterfaceKeywords.get_interface_oper_data(node,
1109                                                             super_interface)
1110         for sub_if in if_data["vpp-vlan:sub-interfaces"]["sub-interface"]:
1111             if str(sub_if["identifier"]) == str(identifier):
1112                 return sub_if
1113
1114         raise HoneycombError("The interface {0} does not have sub-interface "
1115                              "with ID {1}".format(super_interface, identifier))
1116
1117     @staticmethod
1118     def remove_all_sub_interfaces(node, super_interface):
1119         """Remove all sub-interfaces from the given interface.
1120
1121         :param node: Honeycomb node.
1122         :param super_interface: Super interface.
1123         :type node: dict
1124         :type super_interface: str
1125         :returns: Content of response.
1126         :rtype: bytearray
1127         """
1128
1129         path = ("interfaces",
1130                 ("interface", "name", super_interface),
1131                 "vpp-vlan:sub-interfaces")
1132
1133         return InterfaceKeywords._set_interface_properties(
1134             node, super_interface, path, {})
1135
1136     @staticmethod
1137     def set_sub_interface_state(node, super_interface, identifier, state):
1138         """Set the administrative state of sub-interface.
1139
1140         :param node: Honeycomb node.
1141         :param super_interface: Super interface.
1142         :param identifier: The ID of sub-interface.
1143         :param state: Required sub-interface state - up or down.
1144         :type node: dict
1145         :type super_interface: str
1146         :type identifier: int
1147         :type state: str
1148         :returns: Content of response.
1149         :rtype: bytearray
1150         """
1151
1152         intf_state = {"up": "true",
1153                       "down": "false"}
1154
1155         path = ("interfaces",
1156                 ("interface", "name", super_interface),
1157                 "vpp-vlan:sub-interfaces",
1158                 ("sub-interface", "identifier", int(identifier)),
1159                 "enabled")
1160
1161         return InterfaceKeywords._set_interface_properties(
1162             node, super_interface, path, intf_state[state])
1163
1164     @staticmethod
1165     def add_bridge_domain_to_sub_interface(node, super_interface, identifier,
1166                                            config):
1167         """Add a sub-interface to a bridge domain and set its parameters.
1168
1169         :param node: Honeycomb node.
1170         :param super_interface: Super interface.
1171         :param identifier: The ID of sub-interface.
1172         :param config: Bridge domain configuration.
1173         :type node: dict
1174         :type super_interface: str
1175         :type identifier: int
1176         :type config: dict
1177         :returns: Content of response.
1178         :rtype: bytearray
1179         """
1180
1181         path = ("interfaces",
1182                 ("interface", "name", super_interface),
1183                 "vpp-vlan:sub-interfaces",
1184                 ("sub-interface", "identifier", int(identifier)),
1185                 "l2")
1186
1187         return InterfaceKeywords._set_interface_properties(
1188             node, super_interface, path, config)
1189
1190     @staticmethod
1191     def get_bd_data_from_sub_interface(node, super_interface, identifier):
1192         """Get the operational data about the bridge domain from sub-interface.
1193
1194         :param node: Honeycomb node.
1195         :param super_interface: Super interface.
1196         :param identifier: The ID of sub-interface.
1197         :type node: dict
1198         :type super_interface: str
1199         :type identifier: int
1200         :returns: Operational data about the bridge domain.
1201         :rtype: dict
1202         :raises HoneycombError: If there is no sub-interface with the given ID.
1203         """
1204
1205         try:
1206             bd_data = InterfaceKeywords.get_sub_interface_oper_data(
1207                 node, super_interface, identifier)["l2"]
1208             return bd_data
1209         except KeyError:
1210             raise HoneycombError("The operational data does not contain "
1211                                  "information about a bridge domain.")
1212
1213     @staticmethod
1214     def configure_tag_rewrite(node, super_interface, identifier, config):
1215         """Add / change / disable vlan tag rewrite on a sub-interface.
1216
1217         :param node: Honeycomb node.
1218         :param super_interface: Super interface.
1219         :param identifier: The ID of sub-interface.
1220         :param config: Rewrite tag configuration.
1221         :type node: dict
1222         :type super_interface: str
1223         :type identifier: int
1224         :type config: dict
1225         :returns: Content of response.
1226         :rtype: bytearray
1227         """
1228
1229         path = ("interfaces",
1230                 ("interface", "name", super_interface),
1231                 "vpp-vlan:sub-interfaces",
1232                 ("sub-interface", "identifier", int(identifier)),
1233                 "l2",
1234                 "rewrite")
1235
1236         return InterfaceKeywords._set_interface_properties(
1237             node, super_interface, path, config)
1238
1239     @staticmethod
1240     def get_tag_rewrite_oper_data(node, super_interface, identifier):
1241         """Get the operational data about tag rewrite.
1242
1243         :param node: Honeycomb node.
1244         :param super_interface: Super interface.
1245         :param identifier: The ID of sub-interface.
1246         :type node: dict
1247         :type super_interface: str
1248         :type identifier: int
1249         :returns: Operational data about tag rewrite.
1250         :rtype: dict
1251         :raises HoneycombError: If there is no sub-interface with the given ID.
1252         """
1253
1254         try:
1255             tag_rewrite = InterfaceKeywords.get_sub_interface_oper_data(
1256                 node, super_interface, identifier)["l2"]["rewrite"]
1257             return tag_rewrite
1258         except KeyError:
1259             raise HoneycombError("The operational data does not contain "
1260                                  "information about the tag-rewrite.")
1261
1262     @staticmethod
1263     def add_ip_address_to_sub_interface(node, super_interface, identifier,
1264                                         ip_addr, network, ip_version):
1265         """Add an ipv4 address to the specified sub-interface, with the provided
1266         netmask or network prefix length. Any existing ipv4 addresses on the
1267         sub-interface will be replaced.
1268
1269         :param node: Honeycomb node.
1270         :param super_interface: Super interface.
1271         :param identifier: The ID of sub-interface.
1272         :param ip_addr: IPv4 address to be set.
1273         :param network: Network mask or network prefix length.
1274         :param ip_version: ipv4 or ipv6
1275         :type node: dict
1276         :type super_interface: str
1277         :type identifier: int
1278         :type ip_addr: str
1279         :type network: str or int
1280         :type ip_version: string
1281         :returns: Content of response.
1282         :rtype: bytearray
1283         :raises HoneycombError: If the provided netmask or prefix is not valid.
1284         """
1285
1286         path = ("interfaces",
1287                 ("interface", "name", super_interface),
1288                 "vpp-vlan:sub-interfaces",
1289                 ("sub-interface", "identifier", int(identifier)),
1290                 ip_version.lower())
1291
1292         if isinstance(network, basestring) and ip_version.lower() == "ipv4":
1293             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
1294
1295         elif isinstance(network, int) and 0 < network < 33:
1296             address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
1297
1298         else:
1299             raise HoneycombError("{0} is not a valid netmask or prefix length."
1300                                  .format(network))
1301
1302         return InterfaceKeywords._set_interface_properties(
1303             node, super_interface, path, address)
1304
1305     @staticmethod
1306     def remove_all_ip_addresses_from_sub_interface(node, super_interface,
1307                                                    identifier, ip_version):
1308         """Remove all ipv4 addresses from the specified sub-interface.
1309
1310         :param node: Honeycomb node.
1311         :param super_interface: Super interface.
1312         :param identifier: The ID of sub-interface.
1313         :param ip_version: ipv4 or ipv6
1314         :type node: dict
1315         :type super_interface: str
1316         :type identifier: int
1317         :type ip_version: string
1318         :returns: Content of response.
1319         :rtype: bytearray
1320         """
1321
1322         path = ("interfaces",
1323                 ("interface", "name", super_interface),
1324                 "vpp-vlan:sub-interfaces",
1325                 ("sub-interface", "identifier", int(identifier)),
1326                 str(ip_version), "address")
1327
1328         return InterfaceKeywords._set_interface_properties(
1329             node, super_interface, path, None)
1330
1331     @staticmethod
1332     def compare_data_structures(data, ref, _path=''):
1333         """Checks if data obtained from UUT is as expected. If it is not,
1334         proceeds down the list/dictionary tree and finds the point of mismatch.
1335
1336         :param data: Data to be checked.
1337         :param ref: Referential data used for comparison.
1338         :param _path: Used in recursive calls, stores the path taken down
1339         the JSON tree.
1340         :type data: dict
1341         :type ref: dict
1342         :type _path: str
1343
1344         :raises HoneycombError: If the data structures do not match in some way,
1345         or if they are not in deserialized JSON format.
1346         """
1347
1348         if data == ref:
1349             return True
1350
1351         elif isinstance(data, dict) and isinstance(ref, dict):
1352             for key in ref:
1353                 if key not in data:
1354                     raise HoneycombError(
1355                         "Key {key} is not present in path {path}. Keys in path:"
1356                         "{data_keys}".format(
1357                             key=key,
1358                             path=_path,
1359                             data_keys=data.keys()))
1360
1361                 if data[key] != ref[key]:
1362                     if isinstance(data[key], list) \
1363                             or isinstance(data[key], dict):
1364                         InterfaceKeywords.compare_data_structures(
1365                             data[key], ref[key],
1366                             _path + '[{0}]'.format(key))
1367                     else:
1368                         raise HoneycombError(
1369                             "Data mismatch, key {key} in path {path} has value"
1370                             " {data}, but should be {ref}".format(
1371                                 key=key,
1372                                 path=_path,
1373                                 data=data[key],
1374                                 ref=ref[key]))
1375
1376         elif isinstance(data, list) and isinstance(ref, list):
1377             for item in ref:
1378                 if item not in data:
1379                     if isinstance(item, dict):
1380                         InterfaceKeywords.compare_data_structures(
1381                             data[0], item,
1382                             _path + '[{0}]'.format(ref.index(item)))
1383                     else:
1384                         raise HoneycombError(
1385                             "Data mismatch, list item {index} in path {path}"
1386                             " has value {data}, but should be {ref}".format(
1387                                 index=ref.index(item),
1388                                 path=_path,
1389                                 data=data[0],
1390                                 ref=item))
1391
1392         else:
1393             raise HoneycombError(
1394                 "Unexpected data type {data_type} in path {path}, reference"
1395                 " type is {ref_type}. Must be list or dictionary.".format(
1396                     data_type=type(data),
1397                     ref_type=type(ref),
1398                     path=_path))
1399
1400     @staticmethod
1401     def compare_interface_lists(list1, list2):
1402         """Compare provided lists of interfaces by name.
1403
1404         :param list1: List of interfaces.
1405         :param list2: List of interfaces.
1406         :type list1: list
1407         :type list2: list
1408         :raises HoneycombError: If an interface exists in only one of the lists.
1409         """
1410
1411         ignore = ["vx_tunnel0", "vxlan_gpe_tunnel0"]
1412         # these have no equivalent in config data and no effect on VPP
1413
1414         names1 = [x['name'] for x in list1]
1415         names2 = [x['name'] for x in list2]
1416
1417         for name in names1:
1418             if name not in names2 and name not in ignore:
1419                 raise HoneycombError("Interface {0} not present in list {1}"
1420                                      .format(name, list2))
1421         for name in names2:
1422             if name not in names1 and name not in ignore:
1423                 raise HoneycombError("Interface {0} not present in list {1}"
1424                                      .format(name, list1))
1425
1426     @staticmethod
1427     def create_vxlan_gpe_interface(node, interface, **kwargs):
1428         """Create a new VxLAN GPE interface.
1429
1430         :param node: Honeycomb node.
1431         :param interface: The name of interface to be created.
1432         :param kwargs: Parameters and their values. The accepted parameters are
1433         defined in InterfaceKeywords.VXLAN_GPE_PARAMS.
1434         :type node: dict
1435         :type interface: str
1436         :type kwargs: dict
1437         :returns: Content of response.
1438         :rtype: bytearray
1439         :raises HoneycombError: If a parameter in kwargs is not valid.
1440         """
1441
1442         new_vxlan_gpe = {
1443             "name": interface,
1444             "type": "v3po:vxlan-gpe-tunnel",
1445             "v3po:vxlan-gpe": {}
1446         }
1447         for param, value in kwargs.items():
1448             if param in InterfaceKeywords.INTF_PARAMS:
1449                 new_vxlan_gpe[param] = value
1450             elif param in InterfaceKeywords.VXLAN_GPE_PARAMS:
1451                 new_vxlan_gpe["v3po:vxlan-gpe"][param] = value
1452             else:
1453                 raise HoneycombError("The parameter {0} is invalid.".
1454                                      format(param))
1455         path = ("interfaces", "interface")
1456         vxlan_gpe_structure = [new_vxlan_gpe, ]
1457         return InterfaceKeywords._set_interface_properties(
1458             node, interface, path, vxlan_gpe_structure)
1459
1460     @staticmethod
1461     def enable_acl_on_interface(node, interface, table_name):
1462         """Enable ACL on the given interface.
1463
1464         :param node: Honeycomb node.
1465         :param interface: The interface where the ACL will be enabled.
1466         :param table_name: Name of the classify table.
1467         :type node: dict
1468         :type interface: str
1469         :type table_name: str
1470         :returns: Content of response.
1471         :rtype: bytearray
1472         :raises HoneycombError: If the configuration of interface is not
1473         successful.
1474         """
1475
1476         interface = interface.replace("/", "%2F")
1477
1478         data = {
1479             "v3po:acl": {
1480                 "ingress": {
1481                     "ip4-acl": {
1482                         "classify-table": table_name
1483                     },
1484                     "l2-acl": {
1485                         "classify-table": table_name
1486                     }
1487                 }
1488             }
1489         }
1490
1491         path = "/interface/" + interface + "/v3po:acl"
1492         status_code, resp = HcUtil.\
1493             put_honeycomb_data(node, "config_vpp_interfaces", data, path,
1494                                data_representation=DataRepresentation.JSON)
1495         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
1496             raise HoneycombError(
1497                 "The configuration of interface '{0}' was not successful. "
1498                 "Status code: {1}.".format(interface, status_code))
1499         return resp
1500
1501     @staticmethod
1502     def disable_acl_on_interface(node, interface):
1503         """Disable ACL on the given interface.
1504
1505         :param node: Honeycomb node.
1506         :param interface: The interface where the ACL will be disabled.
1507         :type node: dict
1508         :type interface: str
1509         :returns: Content of response.
1510         :rtype: bytearray
1511         :raises HoneycombError: If the configuration of interface is not
1512         successful.
1513         """
1514
1515         interface = interface.replace("/", "%2F")
1516
1517         path = "/interface/" + interface + "/v3po:acl"
1518
1519         status_code, resp = HcUtil.\
1520             delete_honeycomb_data(node, "config_vpp_interfaces", path)
1521
1522         if status_code != HTTPCodes.OK:
1523             raise HoneycombError(
1524                 "The configuration of interface '{0}' was not successful. "
1525                 "Status code: {1}.".format(interface, status_code))
1526         return resp
1527
1528     @staticmethod
1529     def create_pbb_sub_interface(node, intf, params):
1530         """Creates a PBB sub-interface on the given interface and sets its
1531         parameters.
1532
1533         :param node: Honeycomb node.
1534         :param intf: The interface where PBB sub-interface will be configured.
1535         :param params: Configuration parameters of the sub-interface to be
1536         created.
1537         :type node: dict
1538         :type intf: str
1539         :type params: dict
1540         :returns: Content of response.
1541         :rtype: bytearray
1542         :raises HoneycombError: If the configuration of sub-interface is not
1543         successful.
1544         """
1545
1546         interface = intf.replace("/", "%2F")
1547         path = "/interface/{0}/pbb-rewrite/".format(interface)
1548         status_code, resp = HcUtil. \
1549             put_honeycomb_data(node, "config_vpp_interfaces", params, path,
1550                                data_representation=DataRepresentation.JSON)
1551         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
1552             raise HoneycombError(
1553                 "The configuration of PBB sub-interface '{0}' was not "
1554                 "successful. Status code: {1}.".format(intf, status_code))
1555         return resp
1556
1557     @staticmethod
1558     def delete_pbb_sub_interface(node, intf):
1559         """Deletes the given PBB sub-interface.
1560
1561         :param node: Honeycomb node.
1562         :param intf: The interface where PBB sub-interface will be deleted.
1563         :type node: dict
1564         :type intf: str
1565         :returns: Content of response.
1566         :rtype: bytearray
1567         :raises HoneycombError: If the removal of sub-interface is not
1568         successful.
1569         """
1570
1571         interface = intf.replace("/", "%2F")
1572         path = "/interface/{0}/pbb-rewrite".format(interface)
1573
1574         status_code, resp = HcUtil. \
1575             delete_honeycomb_data(node, "config_vpp_interfaces", path)
1576         if status_code != HTTPCodes.OK:
1577             raise HoneycombError(
1578                 "The removal of pbb sub-interface '{0}' was not successful. "
1579                 "Status code: {1}.".format(intf, status_code))
1580         return resp
1581
1582     @staticmethod
1583     def get_pbb_sub_interface_oper_data(node, intf, sub_if_id):
1584         """Retrieves PBB sub-interface operational data from Honeycomb.
1585
1586         :param node: Honeycomb node.
1587         :param intf: The interface where PBB sub-interface is located.
1588         :param sub_if_id: ID of the PBB sub-interface.
1589         :type node: dict
1590         :type intf: str
1591         :type sub_if_id: str or int
1592         :returns: PBB sub-interface operational data.
1593         :rtype: dict
1594         :raises HoneycombError: If the removal of sub-interface is not
1595         successful.
1596         """
1597
1598         raise NotImplementedError
1599
1600     @staticmethod
1601     def check_disabled_interface(node, interface):
1602         """Retrieves list of disabled interface indices from Honeycomb,
1603         and matches with the provided interface by index.
1604
1605         :param node: Honeycomb node.
1606         :param interface: Index number of an interface on the node.
1607         :type node: dict
1608         :type interface: int
1609         :returns: True if the interface exists in disabled interfaces.
1610         :rtype: bool
1611         :raises HoneycombError: If the interface is not present
1612          in retrieved list of disabled interfaces.
1613          """
1614         data = InterfaceKeywords.get_disabled_interfaces_oper_data(node)
1615         # decrement by one = conversion from HC if-index to VPP sw_if_index
1616         interface -= 1
1617
1618         for item in data:
1619             if item["index"] == interface:
1620                 return True
1621         raise HoneycombError("Interface index {0} not present in list"
1622                              " of disabled interfaces.".format(interface))
1623
1624     @staticmethod
1625     def configure_interface_span(node, dst_interface, *src_interfaces):
1626         """Configure SPAN port mirroring on the specified interfaces. If no
1627          source interface is provided, SPAN will be disabled.
1628
1629         :param node: Honeycomb node.
1630         :param dst_interface: Interface to mirror packets to.
1631         :param src_interfaces: List of interfaces to mirror packets from.
1632         :type node: dict
1633         :type dst_interface: str
1634         :type src_interfaces: list of str
1635         :returns: Content of response.
1636         :rtype: bytearray
1637         :raises HoneycombError: If SPAN could not be configured.
1638         """
1639
1640         interface = dst_interface.replace("/", "%2F")
1641         path = "/interface/" + interface + "/span"
1642
1643         if not src_interfaces:
1644             status_code, _ = HcUtil.delete_honeycomb_data(
1645                 node, "config_vpp_interfaces", path)
1646
1647         data = {
1648             "span": {
1649                 "mirrored-interfaces": {
1650                     "mirrored-interface": src_interfaces
1651                 }
1652             }
1653         }
1654
1655         status_code, _ = HcUtil.put_honeycomb_data(
1656             node, "config_vpp_interfaces", data, path)
1657
1658         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
1659             raise HoneycombError(
1660                 "Configuring SPAN failed. Status code:{0}".format(status_code))
1661
1662     @staticmethod
1663     def add_interface_local0_to_topology(node):
1664         """Use Topology methods to add interface "local0" to working topology,
1665         if not already present.
1666
1667         :param node: DUT node.
1668         :type node: dict
1669         """
1670
1671         if Topology.get_interface_by_sw_index(node, 0) is None:
1672             local0_key = Topology.add_new_port(node, "localzero")
1673             Topology.update_interface_sw_if_index(node, local0_key, 0)
1674             Topology.update_interface_name(node, local0_key, "local0")