resources/libraries/python/honeycomb/HcAPIKwInterfaces.py

   1 # Copyright (c) 2016 Cisco and/or its affiliates.
   2 # Licensed under the Apache License, Version 2.0 (the "License");
   3 # you may not use this file except in compliance with the License.
   4 # You may obtain a copy of the License at:
   5 #
   6 #     http://www.apache.org/licenses/LICENSE-2.0
   7 #
   8 # Unless required by applicable law or agreed to in writing, software
   9 # distributed under the License is distributed on an "AS IS" BASIS,
  10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11 # See the License for the specific language governing permissions and
  12 # limitations under the License.
  13
  14 """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
  20 from resources.libraries.python.HTTPRequest import HTTPCodes
  21 from resources.libraries.python.honeycomb.HoneycombSetup import HoneycombError
  22 from resources.libraries.python.honeycomb.HoneycombUtil \
  23     import DataRepresentation
  24 from resources.libraries.python.honeycomb.HoneycombUtil \
  25     import HoneycombUtil as HcUtil
  26
  27
  28 class InterfaceKeywords(object):
  29     """Keywords for Interface manipulation.
  30
  31     Implements keywords which get configuration and operational data about
  32     vpp interfaces and set the interface's parameters using Honeycomb REST API.
  33     """
  34
  35     INTF_PARAMS = ("name", "description", "type", "enabled",
  36                    "link-up-down-trap-enable")
  37     IPV4_PARAMS = ("enabled", "forwarding", "mtu")
  38     IPV6_PARAMS = ("enabled", "forwarding", "mtu", "dup-addr-detect-transmits")
  39     IPV6_AUTOCONF_PARAMS = ("create-global-addresses",
  40                             "create-temporary-addresses",
  41                             "temporary-valid-lifetime",
  42                             "temporary-preferred-lifetime")
  43     ETH_PARAMS = ("mtu", )
  44     ROUTING_PARAMS = ("vrf-id", )
  45     VXLAN_PARAMS = ("src", "dst", "vni", "encap-vrf-id")
  46     L2_PARAMS = ("bridge-domain", "split-horizon-group",
  47                  "bridged-virtual-interface")
  48
  49     def __init__(self):
  50         pass
  51
  52     @staticmethod
  53     def _configure_interface(node, interface, data,
  54                              data_representation=DataRepresentation.JSON):
  55         """Send interface configuration data and check the response.
  56
  57         :param node: Honeycomb node.
  58         :param interface: The name of interface.
  59         :param data: Configuration data to be sent in PUT request.
  60         :param data_representation: How the data is represented.
  61         :type node: dict
  62         :type interface: str
  63         :type data: dict
  64         :type data_representation: DataRepresentation
  65         :return: Content of response.
  66         :rtype: bytearray
  67         :raises HoneycombError: If the status code in response on PUT is not
  68         200 = OK.
  69         """
  70
  71         status_code, resp = HcUtil.\
  72             put_honeycomb_data(node, "config_vpp_interfaces", data,
  73                                data_representation=data_representation)
  74         if status_code != HTTPCodes.OK:
  75             raise HoneycombError(
  76                 "The configuration of interface '{0}' was not successful. "
  77                 "Status code: {1}.".format(interface, status_code))
  78         return resp
  79
  80     @staticmethod
  81     def get_all_interfaces_cfg_data(node):
  82         """Get configuration data about all interfaces from Honeycomb.
  83
  84         :param node: Honeycomb node.
  85         :type node: dict
  86         :return: Configuration data about all interfaces from Honeycomb.
  87         :rtype: list
  88         :raises HoneycombError: If it is not possible to get configuration data.
  89         """
  90
  91         status_code, resp = HcUtil.\
  92             get_honeycomb_data(node, "config_vpp_interfaces")
  93         if status_code != HTTPCodes.OK:
  94             raise HoneycombError(
  95                 "Not possible to get configuration information about the "
  96                 "interfaces. Status code: {0}.".format(status_code))
  97         try:
  98             return resp["interfaces"]["interface"]
  99
 100         except (KeyError, TypeError):
 101             return []
 102
 103     @staticmethod
 104     def get_interface_cfg_data(node, interface):
 105         """Get configuration data about the given interface from Honeycomb.
 106
 107         :param node: Honeycomb node.
 108         :param interface: The name of interface.
 109         :type node: dict
 110         :type interface: str
 111         :return: Configuration data about the given interface from Honeycomb.
 112         :rtype: dict
 113         """
 114
 115         intfs = InterfaceKeywords.get_all_interfaces_cfg_data(node)
 116         for intf in intfs:
 117             if intf["name"] == interface:
 118                 return intf
 119         return {}
 120
 121     @staticmethod
 122     def get_all_interfaces_oper_data(node):
 123         """Get operational data about all interfaces from Honeycomb.
 124
 125         :param node: Honeycomb node.
 126         :type node: dict
 127         :return: Operational data about all interfaces from Honeycomb.
 128         :rtype: list
 129         :raises HoneycombError: If it is not possible to get operational data.
 130         """
 131
 132         status_code, resp = HcUtil.\
 133             get_honeycomb_data(node, "oper_vpp_interfaces")
 134         if status_code != HTTPCodes.OK:
 135             raise HoneycombError(
 136                 "Not possible to get operational information about the "
 137                 "interfaces. Status code: {0}.".format(status_code))
 138         try:
 139             return resp["interfaces-state"]["interface"]
 140
 141         except (KeyError, TypeError):
 142             return []
 143
 144     @staticmethod
 145     def get_interface_oper_data(node, interface):
 146         """Get operational data about the given interface from Honeycomb.
 147
 148         :param node: Honeycomb node.
 149         :param interface: The name of interface.
 150         :type node: dict
 151         :type interface: str
 152         :return: Operational data about the given interface from Honeycomb.
 153         :rtype: dict
 154         """
 155
 156         intfs = InterfaceKeywords.get_all_interfaces_oper_data(node)
 157         for intf in intfs:
 158             if intf["name"] == interface:
 159                 return intf
 160         return {}
 161
 162     @staticmethod
 163     def _set_interface_properties(node, interface, path, new_value=None):
 164         """Set interface properties.
 165
 166         This method reads interface configuration data, creates, changes or
 167         removes the requested data and puts it back to Honeycomb.
 168
 169         :param node: Honeycomb node.
 170         :param interface: The name of interface.
 171         :param path:  Path to data we want to change / create / remove.
 172         :param new_value: The new value to be set. If None, the item will be
 173         removed.
 174         :type node: dict
 175         :type interface: str
 176         :type path: tuple
 177         :type new_value: str, dict or list
 178         :return: Content of response.
 179         :rtype: bytearray
 180         :raises HoneycombError: If it is not possible to get or set the data.
 181         """
 182
 183         status_code, resp = HcUtil.\
 184             get_honeycomb_data(node, "config_vpp_interfaces")
 185         if status_code != HTTPCodes.OK:
 186             raise HoneycombError(
 187                 "Not possible to get configuration information about the "
 188                 "interfaces. Status code: {0}.".format(status_code))
 189
 190         if new_value:
 191             new_data = HcUtil.set_item_value(resp, path, new_value)
 192         else:
 193             new_data = HcUtil.remove_item(resp, path)
 194         return InterfaceKeywords._configure_interface(node, interface, new_data)
 195
 196     @staticmethod
 197     def set_interface_state(node, interface, state="up"):
 198         """Set VPP interface state.
 199
 200         The keyword changes the administration state of interface to up or down
 201         depending on the parameter "state".
 202
 203         :param node: Honeycomb node.
 204         :param interface: The name of interface.
 205         :param state: The requested state, only "up" and "down" are valid
 206         values.
 207         :type node: dict
 208         :type interface: str
 209         :type state: str
 210         :return: Content of response.
 211         :rtype: bytearray
 212         :raises KeyError: If the argument "state" is nor "up" or "down".
 213         :raises HoneycombError: If the interface is not present on the node.
 214         """
 215
 216         intf_state = {"up": "true",
 217                       "down": "false"}
 218
 219         path = ("interfaces", ("interface", "name", str(interface)), "enabled")
 220         return InterfaceKeywords._set_interface_properties(
 221             node, interface, path, intf_state[state.lower()])
 222
 223     @staticmethod
 224     def set_interface_up(node, interface):
 225         """Set the administration state of VPP interface to up.
 226
 227         :param node: Honeycomb node.
 228         :param interface: The name of interface.
 229         :type node: dict
 230         :type interface: str
 231         :return: Content of response
 232         :rtype: bytearray
 233         """
 234
 235         return InterfaceKeywords.set_interface_state(node, interface, "up")
 236
 237     @staticmethod
 238     def set_interface_down(node, interface):
 239         """Set the administration state of VPP interface to down.
 240
 241         :param node: Honeycomb node.
 242         :param interface: The name of interface.
 243         :type node: dict
 244         :type interface: str
 245         :return: Content of response.
 246         :rtype: bytearray
 247         """
 248
 249         return InterfaceKeywords.set_interface_state(node, interface, "down")
 250
 251     @staticmethod
 252     def add_bridge_domain_to_interface(node, interface, bd_name,
 253                                        split_horizon_group=None, bvi=None):
 254         """Add a new bridge domain to an interface and set its parameters.
 255
 256         :param node: Honeycomb node.
 257         :param interface: The name of interface.
 258         :param bd_name: Bridge domain name.
 259         :param split_horizon_group: Split-horizon group name.
 260         :param bvi: The bridged virtual interface.
 261         :type node: dict
 262         :type interface: str
 263         :type bd_name: str
 264         :type split_horizon_group: str
 265         :type bvi: str
 266         :return: Content of response.
 267         :rtype: bytearray
 268         :raises HoneycombError: If the interface is not present on the node.
 269         """
 270
 271         v3po_l2 = {"bridge-domain": str(bd_name)}
 272         if split_horizon_group:
 273             v3po_l2["split-horizon-group"] = str(split_horizon_group)
 274         if bvi:
 275             v3po_l2["bridged-virtual-interface"] = str(bvi)
 276
 277         path = ("interfaces", ("interface", "name", str(interface)), "v3po:l2")
 278
 279         return InterfaceKeywords._set_interface_properties(
 280             node, interface, path, v3po_l2)
 281
 282     @staticmethod
 283     def configure_interface_base(node, interface, param, value):
 284         """Configure the base parameters of interface.
 285
 286         :param node: Honeycomb node.
 287         :param interface: The name of interface.
 288         :param param: Parameter to configure (set, change, remove)
 289         :param value: The value of parameter. If None, the parameter will be
 290         removed.
 291         :type node: dict
 292         :type interface: str
 293         :type param: str
 294         :type value: str
 295         :return: Content of response.
 296         :rtype: bytearray
 297         :raises HoneycombError: If the parameter is not valid.
 298         """
 299
 300         if param not in InterfaceKeywords.INTF_PARAMS:
 301             raise HoneycombError("The parameter {0} is invalid.".format(param))
 302
 303         path = ("interfaces", ("interface", "name", interface), param)
 304         return InterfaceKeywords._set_interface_properties(
 305             node, interface, path, value)
 306
 307     @staticmethod
 308     def configure_interface_ipv4(node, interface, param, value):
 309         """Configure IPv4 parameters of interface
 310
 311         :param node: Honeycomb node.
 312         :param interface: The name of interface.
 313         :param param: Parameter to configure (set, change, remove)
 314         :param value: The value of parameter. If None, the parameter will be
 315         removed.
 316         :type node: dict
 317         :type interface: str
 318         :type param: str
 319         :type value: str
 320         :return: Content of response.
 321         :rtype: bytearray
 322         :raises HoneycombError: If the parameter is not valid.
 323         """
 324
 325         if param not in InterfaceKeywords.IPV4_PARAMS:
 326             raise HoneycombError("The parameter {0} is invalid.".format(param))
 327
 328         path = ("interfaces", ("interface", "name", interface),
 329                 "ietf-ip:ipv4", param)
 330         return InterfaceKeywords._set_interface_properties(
 331             node, interface, path, value)
 332
 333     @staticmethod
 334     def add_first_ipv4_address(node, interface, ip_addr, network):
 335         """Add the first IPv4 address.
 336
 337         If there are any other addresses configured, they will be removed.
 338
 339         :param node: Honeycomb node.
 340         :param interface: The name of interface.
 341         :param ip_addr: IPv4 address to be set.
 342         :param network: Netmask or length of network prefix.
 343         :type node: dict
 344         :type interface: str
 345         :type ip_addr: str
 346         :type network: str or int
 347         :return: Content of response.
 348         :rtype: bytearray
 349         """
 350
 351         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
 352         if isinstance(network, basestring):
 353             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
 354         elif isinstance(network, int) and (0 < network < 33):
 355             address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
 356         else:
 357             raise HoneycombError("Value {0} is not a valid netmask or network "
 358                                  "prefix length.".format(network))
 359         return InterfaceKeywords._set_interface_properties(
 360             node, interface, path, address)
 361
 362     @staticmethod
 363     def add_ipv4_address(node, interface, ip_addr, network):
 364         """Add IPv4 address.
 365
 366         :param node: Honeycomb node.
 367         :param interface: The name of interface.
 368         :param ip_addr: IPv4 address to be set.
 369         :param network: Netmask or length of network prefix.
 370         :type node: dict
 371         :type interface: str
 372         :type ip_addr: str
 373         :type network: str or int
 374         :return: Content of response.
 375         :rtype: bytearray
 376         """
 377
 378         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 379                 "address")
 380         if isinstance(network, basestring):
 381             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
 382         elif isinstance(network, int) and (0 < network < 33):
 383             address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
 384         else:
 385             raise HoneycombError("Value {0} is not a valid netmask or network "
 386                                  "prefix length.".format(network))
 387         return InterfaceKeywords._set_interface_properties(
 388             node, interface, path, address)
 389
 390     @staticmethod
 391     def remove_all_ipv4_addresses(node, interface):
 392         """Remove all IPv4 addresses from interface.
 393
 394         :param node: Honeycomb node.
 395         :param interface: The name of interface.
 396         :type node: dict
 397         :type interface: str
 398         :return: Content of response.
 399         :rtype: bytearray
 400         """
 401
 402         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 403                 "address")
 404         return InterfaceKeywords._set_interface_properties(
 405             node, interface, path, None)
 406
 407     @staticmethod
 408     def add_first_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
 409         """Add the first IPv4 neighbour.
 410
 411         If there are any other neighbours configured, they will be removed.
 412
 413         :param node: Honeycomb node.
 414         :param interface: The name of interface.
 415         :param ip_addr: IPv4 address of neighbour to be set.
 416         :param link_layer_address: Link layer address.
 417         :type node: dict
 418         :type interface: str
 419         :type ip_addr: str
 420         :type link_layer_address: str
 421         :return: Content of response.
 422         :rtype: bytearray
 423         """
 424
 425         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
 426         neighbor = {"neighbor": [{"ip": ip_addr,
 427                                   "link-layer-address": link_layer_address}, ]}
 428         return InterfaceKeywords._set_interface_properties(
 429             node, interface, path, neighbor)
 430
 431     @staticmethod
 432     def add_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
 433         """Add the IPv4 neighbour.
 434
 435         :param node: Honeycomb node.
 436         :param interface: The name of interface.
 437         :param ip_addr: IPv4 address of neighbour to be set.
 438         :param link_layer_address: Link layer address.
 439         :type node: dict
 440         :type interface: str
 441         :type ip_addr: str
 442         :type link_layer_address: str
 443         :return: Content of response.
 444         :rtype: bytearray
 445         """
 446
 447         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 448                 "neighbor")
 449         neighbor = [{"ip": ip_addr, "link-layer-address": link_layer_address}, ]
 450         return InterfaceKeywords._set_interface_properties(
 451             node, interface, path, neighbor)
 452
 453     @staticmethod
 454     def remove_all_ipv4_neighbors(node, interface):
 455         """Remove all IPv4 neighbours.
 456
 457         :param node: Honeycomb node.
 458         :param interface: The name of interface.
 459         :type node: dict
 460         :type interface: str
 461         :return: Content of response.
 462         :rtype: bytearray
 463         """
 464
 465         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 466                 "neighbor")
 467         return InterfaceKeywords._set_interface_properties(
 468             node, interface, path, None)
 469
 470     @staticmethod
 471     def configure_interface_ipv6(node, interface, param, value):
 472         """Configure IPv6 parameters of interface
 473
 474         :param node: Honeycomb node.
 475         :param interface: The name of interface.
 476         :param param: Parameter to configure (set, change, remove)
 477         :param value: The value of parameter. If None, the parameter will be
 478         removed.
 479         :type node: dict
 480         :type interface: str
 481         :type param: str
 482         :type value: str
 483         :return: Content of response.
 484         :rtype: bytearray
 485         :raises HoneycombError: If the parameter is not valid.
 486         """
 487
 488         if param in InterfaceKeywords.IPV6_PARAMS:
 489             path = ("interfaces", ("interface", "name", interface),
 490                     "ietf-ip:ipv6", param)
 491         elif param in InterfaceKeywords.IPV6_AUTOCONF_PARAMS:
 492             path = ("interfaces", ("interface", "name", interface),
 493                     "ietf-ip:ipv6", "autoconf", param)
 494         else:
 495             raise HoneycombError("The parameter {0} is invalid.".format(param))
 496
 497         return InterfaceKeywords._set_interface_properties(
 498             node, interface, path, value)
 499
 500     @staticmethod
 501     def add_first_ipv6_address(node, interface, ip_addr, prefix_len):
 502         """Add the first IPv6 address.
 503
 504         If there are any other addresses configured, they will be removed.
 505
 506         :param node: Honeycomb node.
 507         :param interface: The name of interface.
 508         :param ip_addr: IPv6 address to be set.
 509         :param prefix_len: Prefix length.
 510         :type node: dict
 511         :type interface: str
 512         :type ip_addr: str
 513         :type prefix_len: str
 514         :return: Content of response.
 515         :rtype: bytearray
 516         """
 517
 518         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6")
 519         address = {"address": [{"ip": ip_addr, "prefix-length": prefix_len}, ]}
 520         return InterfaceKeywords._set_interface_properties(
 521             node, interface, path, address)
 522
 523     @staticmethod
 524     def add_ipv6_address(node, interface, ip_addr, prefix_len):
 525         """Add IPv6 address.
 526
 527         :param node: Honeycomb node.
 528         :param interface: The name of interface.
 529         :param ip_addr: IPv6 address to be set.
 530         :param prefix_len: Prefix length.
 531         :type node: dict
 532         :type interface: str
 533         :type ip_addr: str
 534         :type prefix_len: str
 535         :return: Content of response.
 536         :rtype: bytearray
 537         """
 538
 539         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 540                 "address")
 541         address = [{"ip": ip_addr, "prefix-length": prefix_len}, ]
 542         return InterfaceKeywords._set_interface_properties(
 543             node, interface, path, address)
 544
 545     @staticmethod
 546     def remove_all_ipv6_addresses(node, interface):
 547         """Remove all IPv6 addresses from interface.
 548
 549         :param node: Honeycomb node.
 550         :param interface: The name of interface.
 551         :type node: dict
 552         :type interface: str
 553         :return: Content of response.
 554         :rtype: bytearray
 555         """
 556
 557         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 558                 "address")
 559         return InterfaceKeywords._set_interface_properties(
 560             node, interface, path, None)
 561
 562     @staticmethod
 563     def add_first_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
 564         """Add the first IPv6 neighbour.
 565
 566         If there are any other neighbours configured, they will be removed.
 567
 568         :param node: Honeycomb node.
 569         :param interface: The name of interface.
 570         :param ip_addr: IPv6 address of neighbour to be set.
 571         :param link_layer_address: Link layer address.
 572         :type node: dict
 573         :type interface: str
 574         :type ip_addr: str
 575         :type link_layer_address: str
 576         :return: Content of response.
 577         :rtype: bytearray
 578         """
 579
 580         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6")
 581         neighbor = {"neighbor": [{"ip": ip_addr,
 582                                   "link-layer-address": link_layer_address}, ]}
 583         return InterfaceKeywords._set_interface_properties(
 584             node, interface, path, neighbor)
 585
 586     @staticmethod
 587     def add_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
 588         """Add the IPv6 neighbour.
 589
 590         :param node: Honeycomb node.
 591         :param interface: The name of interface.
 592         :param ip_addr: IPv6 address of neighbour to be set.
 593         :param link_layer_address: Link layer address.
 594         :type node: dict
 595         :type interface: str
 596         :type ip_addr: str
 597         :type link_layer_address: str
 598         :return: Content of response.
 599         :rtype: bytearray
 600         """
 601
 602         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 603                 "neighbor")
 604         neighbor = [{"ip": ip_addr, "link-layer-address": link_layer_address}, ]
 605         return InterfaceKeywords._set_interface_properties(
 606             node, interface, path, neighbor)
 607
 608     @staticmethod
 609     def remove_all_ipv6_neighbors(node, interface):
 610         """Remove all IPv6 neighbours.
 611
 612         :param node: Honeycomb node.
 613         :param interface: The name of interface.
 614         :type node: dict
 615         :type interface: str
 616         :return: Content of response.
 617         :rtype: bytearray
 618         """
 619
 620         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 621                 "neighbor")
 622         return InterfaceKeywords._set_interface_properties(
 623             node, interface, path, None)
 624
 625     @staticmethod
 626     def configure_interface_ethernet(node, interface, param, value):
 627         """Configure the ethernet parameters of interface.
 628
 629         :param node: Honeycomb node.
 630         :param interface: The name of interface.
 631         :param param: Parameter to configure (set, change, remove)
 632         :param value: The value of parameter. If None, the parameter will be
 633         removed.
 634         :type node: dict
 635         :type interface: str
 636         :type param: str
 637         :type value: str
 638         :return: Content of response.
 639         :rtype: bytearray
 640         :raises HoneycombError: If the parameter is not valid.
 641         """
 642
 643         if param not in InterfaceKeywords.ETH_PARAMS:
 644             raise HoneycombError("The parameter {0} is invalid.".format(param))
 645         path = ("interfaces", ("interface", "name", interface), "v3po:ethernet",
 646                 param)
 647         return InterfaceKeywords._set_interface_properties(
 648             node, interface, path, value)
 649
 650     @staticmethod
 651     def configure_interface_routing(node, interface, param, value):
 652         """Configure the routing parameters of interface.
 653
 654         :param node: Honeycomb node.
 655         :param interface: The name of interface.
 656         :param param: Parameter to configure (set, change, remove)
 657         :param value: The value of parameter. If None, the parameter will be
 658         removed.
 659         :type node: dict
 660         :type interface: str
 661         :type param: str
 662         :type value: str
 663         :return: Content of response.
 664         :rtype: bytearray
 665         :raises HoneycombError: If the parameter is not valid.
 666         """
 667
 668         if param not in InterfaceKeywords.ROUTING_PARAMS:
 669             raise HoneycombError("The parameter {0} is invalid.".format(param))
 670
 671         path = ("interfaces", ("interface", "name", interface), "v3po:routing",
 672                 param)
 673         return InterfaceKeywords._set_interface_properties(
 674             node, interface, path, value)
 675
 676     @staticmethod
 677     def create_vxlan_interface(node, interface, **kwargs):
 678         """Create a new VxLAN interface.
 679
 680         :param node: Honeycomb node.
 681         :param interface: The name of interface.
 682         :param kwargs: Parameters and their values. The accepted parameters are
 683         defined in InterfaceKeywords.VXLAN_PARAMS.
 684         :type node: dict
 685         :type interface: str
 686         :type kwargs: dict
 687         :return: Content of response.
 688         :rtype: bytearray
 689         :raises HoneycombError: If the parameter is not valid.
 690         """
 691
 692         new_vx_lan = {
 693             "name": interface,
 694             "type": "v3po:vxlan-tunnel",
 695             "v3po:vxlan": {}
 696         }
 697         for param, value in kwargs.items():
 698             if param not in InterfaceKeywords.VXLAN_PARAMS:
 699                 raise HoneycombError("The parameter {0} is invalid.".
 700                                      format(param))
 701             new_vx_lan["v3po:vxlan"][param] = value
 702
 703         path = ("interfaces", "interface")
 704         vx_lan_structure = [new_vx_lan, ]
 705         return InterfaceKeywords._set_interface_properties(
 706             node, interface, path, vx_lan_structure)
 707
 708     @staticmethod
 709     def delete_interface(node, interface):
 710         """Delete an interface.
 711
 712         :param node: Honeycomb node.
 713         :param interface: The name of interface.
 714         :type node: dict
 715         :type interface: str
 716         :return: Content of response.
 717         :rtype: bytearray
 718         :raises HoneycombError: If it is not possible to get information about
 719         interfaces or it is not possible to delete the interface.
 720         """
 721
 722         path = ("interfaces", ("interface", "name", interface))
 723
 724         status_code, resp = HcUtil.\
 725             get_honeycomb_data(node, "config_vpp_interfaces")
 726         if status_code != HTTPCodes.OK:
 727             raise HoneycombError(
 728                 "Not possible to get configuration information about the "
 729                 "interfaces. Status code: {0}.".format(status_code))
 730
 731         new_data = HcUtil.remove_item(resp, path)
 732         status_code, resp = HcUtil.\
 733             put_honeycomb_data(node, "config_vpp_interfaces", new_data)
 734         if status_code != HTTPCodes.OK:
 735             raise HoneycombError("Not possible to remove interface {0}. "
 736                                  "Status code: {1}.".
 737                                  format(interface, status_code))
 738         return resp
 739
 740     @staticmethod
 741     def configure_interface_vxlan(node, interface, **kwargs):
 742         """Configure VxLAN on the interface.
 743
 744         The keyword configures VxLAN parameters on the given interface. The type
 745         of interface must be set to "v3po:vxlan-tunnel".
 746         The new VxLAN parameters overwrite the current configuration. If a
 747         parameter in new configuration is missing, it is removed from VxLAN
 748         configuration.
 749         If the dictionary kwargs is empty, VxLAN configuration is removed.
 750
 751         :param node: Honeycomb node.
 752         :param interface: The name of interface.
 753         :param kwargs: Parameters and their values. The accepted parameters are
 754         defined in InterfaceKeywords.VXLAN_PARAMS.
 755         :type node: dict
 756         :type interface: str
 757         :type kwargs: dict
 758         :return: Content of response.
 759         :rtype: bytearray
 760         :raises HoneycombError: If the parameter is not valid.
 761         """
 762
 763         vx_lan_structure = dict()
 764         for param, value in kwargs.items():
 765             if param not in InterfaceKeywords.VXLAN_PARAMS:
 766                 raise HoneycombError("The parameter {0} is invalid.".
 767                                      format(param))
 768             vx_lan_structure[param] = value
 769
 770         path = ("interfaces", ("interface", "name", interface), "v3po:vxlan")
 771         return InterfaceKeywords._set_interface_properties(
 772             node, interface, path, vx_lan_structure)
 773
 774     @staticmethod
 775     def configure_interface_l2(node, interface, param, value):
 776         """Configure the L2 parameters of interface.
 777
 778         :param node: Honeycomb node.
 779         :param interface: The name of interface.
 780         :param param: Parameter to configure (set, change, remove)
 781         :param value: The value of parameter. If None, the parameter will be
 782         removed.
 783         :type node: dict
 784         :type interface: str
 785         :type param: str
 786         :type value: str
 787         :return: Content of response.
 788         :rtype: bytearray
 789         :raises HoneycombError: If the parameter is not valid.
 790         """
 791
 792         if param not in InterfaceKeywords.L2_PARAMS:
 793             raise HoneycombError("The parameter {0} is invalid.".format(param))
 794         path = ("interfaces", ("interface", "name", interface), "v3po:l2",
 795                 param)
 796         return InterfaceKeywords._set_interface_properties(
 797             node, interface, path, value)