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