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     TAP_PARAMS = ("tap-name", "mac", "device-instance")
  49     VHOST_USER_PARAMS = ("socket", "role")
  50
  51     def __init__(self):
  52         pass
  53
  54     @staticmethod
  55     def _configure_interface(node, interface, data,
  56                              data_representation=DataRepresentation.JSON):
  57         """Send interface configuration data and check the response.
  58
  59         :param node: Honeycomb node.
  60         :param interface: The name of interface.
  61         :param data: Configuration data to be sent in PUT request.
  62         :param data_representation: How the data is represented.
  63         :type node: dict
  64         :type interface: str
  65         :type data: dict
  66         :type data_representation: DataRepresentation
  67         :return: Content of response.
  68         :rtype: bytearray
  69         :raises HoneycombError: If the status code in response on PUT is not
  70         200 = OK.
  71         """
  72
  73         status_code, resp = HcUtil.\
  74             put_honeycomb_data(node, "config_vpp_interfaces", data,
  75                                data_representation=data_representation)
  76         if status_code != HTTPCodes.OK:
  77             raise HoneycombError(
  78                 "The configuration of interface '{0}' was not successful. "
  79                 "Status code: {1}.".format(interface, status_code))
  80         return resp
  81
  82     @staticmethod
  83     def get_all_interfaces_cfg_data(node):
  84         """Get configuration data about all interfaces from Honeycomb.
  85
  86         :param node: Honeycomb node.
  87         :type node: dict
  88         :return: Configuration data about all interfaces from Honeycomb.
  89         :rtype: list
  90         :raises HoneycombError: If it is not possible to get configuration data.
  91         """
  92
  93         status_code, resp = HcUtil.\
  94             get_honeycomb_data(node, "config_vpp_interfaces")
  95         if status_code != HTTPCodes.OK:
  96             raise HoneycombError(
  97                 "Not possible to get configuration information about the "
  98                 "interfaces. Status code: {0}.".format(status_code))
  99         try:
 100             return resp["interfaces"]["interface"]
 101
 102         except (KeyError, TypeError):
 103             return []
 104
 105     @staticmethod
 106     def get_interface_cfg_data(node, interface):
 107         """Get configuration data about the given interface from Honeycomb.
 108
 109         :param node: Honeycomb node.
 110         :param interface: The name of interface.
 111         :type node: dict
 112         :type interface: str
 113         :return: Configuration data about the given interface from Honeycomb.
 114         :rtype: dict
 115         """
 116
 117         intfs = InterfaceKeywords.get_all_interfaces_cfg_data(node)
 118         for intf in intfs:
 119             if intf["name"] == interface:
 120                 return intf
 121         return {}
 122
 123     @staticmethod
 124     def get_all_interfaces_oper_data(node):
 125         """Get operational data about all interfaces from Honeycomb.
 126
 127         :param node: Honeycomb node.
 128         :type node: dict
 129         :return: Operational data about all interfaces from Honeycomb.
 130         :rtype: list
 131         :raises HoneycombError: If it is not possible to get operational data.
 132         """
 133
 134         status_code, resp = HcUtil.\
 135             get_honeycomb_data(node, "oper_vpp_interfaces")
 136         if status_code != HTTPCodes.OK:
 137             raise HoneycombError(
 138                 "Not possible to get operational information about the "
 139                 "interfaces. Status code: {0}.".format(status_code))
 140         try:
 141             return resp["interfaces-state"]["interface"]
 142
 143         except (KeyError, TypeError):
 144             return []
 145
 146     @staticmethod
 147     def get_interface_oper_data(node, interface):
 148         """Get operational data about the given interface from Honeycomb.
 149
 150         :param node: Honeycomb node.
 151         :param interface: The name of interface.
 152         :type node: dict
 153         :type interface: str
 154         :return: Operational data about the given interface from Honeycomb.
 155         :rtype: dict
 156         """
 157
 158         intfs = InterfaceKeywords.get_all_interfaces_oper_data(node)
 159         for intf in intfs:
 160             if intf["name"] == interface:
 161                 return intf
 162         return {}
 163
 164     @staticmethod
 165     def _set_interface_properties(node, interface, path, new_value=None):
 166         """Set interface properties.
 167
 168         This method reads interface configuration data, creates, changes or
 169         removes the requested data and puts it back to Honeycomb.
 170
 171         :param node: Honeycomb node.
 172         :param interface: The name of interface.
 173         :param path:  Path to data we want to change / create / remove.
 174         :param new_value: The new value to be set. If None, the item will be
 175         removed.
 176         :type node: dict
 177         :type interface: str
 178         :type path: tuple
 179         :type new_value: str, dict or list
 180         :return: Content of response.
 181         :rtype: bytearray
 182         :raises HoneycombError: If it is not possible to get or set the data.
 183         """
 184
 185         status_code, resp = HcUtil.\
 186             get_honeycomb_data(node, "config_vpp_interfaces")
 187         if status_code != HTTPCodes.OK:
 188             raise HoneycombError(
 189                 "Not possible to get configuration information about the "
 190                 "interfaces. Status code: {0}.".format(status_code))
 191
 192         if new_value:
 193             new_data = HcUtil.set_item_value(resp, path, new_value)
 194         else:
 195             new_data = HcUtil.remove_item(resp, path)
 196         return InterfaceKeywords._configure_interface(node, interface, new_data)
 197
 198     @staticmethod
 199     def set_interface_state(node, interface, state="up"):
 200         """Set VPP interface state.
 201
 202         The keyword changes the administration state of interface to up or down
 203         depending on the parameter "state".
 204
 205         :param node: Honeycomb node.
 206         :param interface: The name of interface.
 207         :param state: The requested state, only "up" and "down" are valid
 208         values.
 209         :type node: dict
 210         :type interface: str
 211         :type state: str
 212         :return: Content of response.
 213         :rtype: bytearray
 214         :raises KeyError: If the argument "state" is nor "up" or "down".
 215         :raises HoneycombError: If the interface is not present on the node.
 216         """
 217
 218         intf_state = {"up": "true",
 219                       "down": "false"}
 220
 221         path = ("interfaces", ("interface", "name", str(interface)), "enabled")
 222         return InterfaceKeywords._set_interface_properties(
 223             node, interface, path, intf_state[state.lower()])
 224
 225     @staticmethod
 226     def set_interface_up(node, interface):
 227         """Set the administration state of VPP interface to up.
 228
 229         :param node: Honeycomb node.
 230         :param interface: The name of interface.
 231         :type node: dict
 232         :type interface: str
 233         :return: Content of response
 234         :rtype: bytearray
 235         """
 236
 237         return InterfaceKeywords.set_interface_state(node, interface, "up")
 238
 239     @staticmethod
 240     def set_interface_down(node, interface):
 241         """Set the administration state of VPP interface to down.
 242
 243         :param node: Honeycomb node.
 244         :param interface: The name of interface.
 245         :type node: dict
 246         :type interface: str
 247         :return: Content of response.
 248         :rtype: bytearray
 249         """
 250
 251         return InterfaceKeywords.set_interface_state(node, interface, "down")
 252
 253     @staticmethod
 254     def add_bridge_domain_to_interface(node, interface, bd_name,
 255                                        split_horizon_group=None, bvi=None):
 256         """Add a new bridge domain to an interface and set its parameters.
 257
 258         :param node: Honeycomb node.
 259         :param interface: The name of interface.
 260         :param bd_name: Bridge domain name.
 261         :param split_horizon_group: Split-horizon group name.
 262         :param bvi: The bridged virtual interface.
 263         :type node: dict
 264         :type interface: str
 265         :type bd_name: str
 266         :type split_horizon_group: str
 267         :type bvi: str
 268         :return: Content of response.
 269         :rtype: bytearray
 270         :raises HoneycombError: If the interface is not present on the node.
 271         """
 272
 273         v3po_l2 = {"bridge-domain": str(bd_name)}
 274         if split_horizon_group:
 275             v3po_l2["split-horizon-group"] = str(split_horizon_group)
 276         if bvi:
 277             v3po_l2["bridged-virtual-interface"] = str(bvi)
 278
 279         path = ("interfaces", ("interface", "name", str(interface)), "v3po:l2")
 280
 281         return InterfaceKeywords._set_interface_properties(
 282             node, interface, path, v3po_l2)
 283
 284     @staticmethod
 285     def configure_interface_base(node, interface, param, value):
 286         """Configure the base parameters of interface.
 287
 288         :param node: Honeycomb node.
 289         :param interface: The name of interface.
 290         :param param: Parameter to configure (set, change, remove)
 291         :param value: The value of parameter. If None, the parameter will be
 292         removed.
 293         :type node: dict
 294         :type interface: str
 295         :type param: str
 296         :type value: str
 297         :return: Content of response.
 298         :rtype: bytearray
 299         :raises HoneycombError: If the parameter is not valid.
 300         """
 301
 302         if param not in InterfaceKeywords.INTF_PARAMS:
 303             raise HoneycombError("The parameter {0} is invalid.".format(param))
 304
 305         path = ("interfaces", ("interface", "name", interface), param)
 306         return InterfaceKeywords._set_interface_properties(
 307             node, interface, path, value)
 308
 309     @staticmethod
 310     def configure_interface_ipv4(node, interface, param, value):
 311         """Configure IPv4 parameters of interface
 312
 313         :param node: Honeycomb node.
 314         :param interface: The name of interface.
 315         :param param: Parameter to configure (set, change, remove)
 316         :param value: The value of parameter. If None, the parameter will be
 317         removed.
 318         :type node: dict
 319         :type interface: str
 320         :type param: str
 321         :type value: str
 322         :return: Content of response.
 323         :rtype: bytearray
 324         :raises HoneycombError: If the parameter is not valid.
 325         """
 326
 327         if param not in InterfaceKeywords.IPV4_PARAMS:
 328             raise HoneycombError("The parameter {0} is invalid.".format(param))
 329
 330         path = ("interfaces", ("interface", "name", interface),
 331                 "ietf-ip:ipv4", param)
 332         return InterfaceKeywords._set_interface_properties(
 333             node, interface, path, value)
 334
 335     @staticmethod
 336     def add_first_ipv4_address(node, interface, ip_addr, network):
 337         """Add the first IPv4 address.
 338
 339         If there are any other addresses configured, they will be removed.
 340
 341         :param node: Honeycomb node.
 342         :param interface: The name of interface.
 343         :param ip_addr: IPv4 address to be set.
 344         :param network: Netmask or length of network prefix.
 345         :type node: dict
 346         :type interface: str
 347         :type ip_addr: str
 348         :type network: str or int
 349         :return: Content of response.
 350         :rtype: bytearray
 351         """
 352
 353         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
 354         if isinstance(network, basestring):
 355             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
 356         elif isinstance(network, int) and (0 < network < 33):
 357             address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
 358         else:
 359             raise HoneycombError("Value {0} is not a valid netmask or network "
 360                                  "prefix length.".format(network))
 361         return InterfaceKeywords._set_interface_properties(
 362             node, interface, path, address)
 363
 364     @staticmethod
 365     def add_ipv4_address(node, interface, ip_addr, network):
 366         """Add IPv4 address.
 367
 368         :param node: Honeycomb node.
 369         :param interface: The name of interface.
 370         :param ip_addr: IPv4 address to be set.
 371         :param network: Netmask or length of network prefix.
 372         :type node: dict
 373         :type interface: str
 374         :type ip_addr: str
 375         :type network: str or int
 376         :return: Content of response.
 377         :rtype: bytearray
 378         """
 379
 380         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 381                 "address")
 382         if isinstance(network, basestring):
 383             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
 384         elif isinstance(network, int) and (0 < network < 33):
 385             address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
 386         else:
 387             raise HoneycombError("Value {0} is not a valid netmask or network "
 388                                  "prefix length.".format(network))
 389         return InterfaceKeywords._set_interface_properties(
 390             node, interface, path, address)
 391
 392     @staticmethod
 393     def remove_all_ipv4_addresses(node, interface):
 394         """Remove all IPv4 addresses from interface.
 395
 396         :param node: Honeycomb node.
 397         :param interface: The name of interface.
 398         :type node: dict
 399         :type interface: str
 400         :return: Content of response.
 401         :rtype: bytearray
 402         """
 403
 404         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 405                 "address")
 406         return InterfaceKeywords._set_interface_properties(
 407             node, interface, path, None)
 408
 409     @staticmethod
 410     def add_first_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
 411         """Add the first IPv4 neighbour.
 412
 413         If there are any other neighbours configured, they will be removed.
 414
 415         :param node: Honeycomb node.
 416         :param interface: The name of interface.
 417         :param ip_addr: IPv4 address of neighbour to be set.
 418         :param link_layer_address: Link layer address.
 419         :type node: dict
 420         :type interface: str
 421         :type ip_addr: str
 422         :type link_layer_address: str
 423         :return: Content of response.
 424         :rtype: bytearray
 425         """
 426
 427         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4")
 428         neighbor = {"neighbor": [{"ip": ip_addr,
 429                                   "link-layer-address": link_layer_address}, ]}
 430         return InterfaceKeywords._set_interface_properties(
 431             node, interface, path, neighbor)
 432
 433     @staticmethod
 434     def add_ipv4_neighbor(node, interface, ip_addr, link_layer_address):
 435         """Add the IPv4 neighbour.
 436
 437         :param node: Honeycomb node.
 438         :param interface: The name of interface.
 439         :param ip_addr: IPv4 address of neighbour to be set.
 440         :param link_layer_address: Link layer address.
 441         :type node: dict
 442         :type interface: str
 443         :type ip_addr: str
 444         :type link_layer_address: str
 445         :return: Content of response.
 446         :rtype: bytearray
 447         """
 448
 449         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 450                 "neighbor")
 451         neighbor = [{"ip": ip_addr, "link-layer-address": link_layer_address}, ]
 452         return InterfaceKeywords._set_interface_properties(
 453             node, interface, path, neighbor)
 454
 455     @staticmethod
 456     def remove_all_ipv4_neighbors(node, interface):
 457         """Remove all IPv4 neighbours.
 458
 459         :param node: Honeycomb node.
 460         :param interface: The name of interface.
 461         :type node: dict
 462         :type interface: str
 463         :return: Content of response.
 464         :rtype: bytearray
 465         """
 466
 467         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv4",
 468                 "neighbor")
 469         return InterfaceKeywords._set_interface_properties(
 470             node, interface, path, None)
 471
 472     @staticmethod
 473     def configure_interface_ipv6(node, interface, param, value):
 474         """Configure IPv6 parameters of interface
 475
 476         :param node: Honeycomb node.
 477         :param interface: The name of interface.
 478         :param param: Parameter to configure (set, change, remove)
 479         :param value: The value of parameter. If None, the parameter will be
 480         removed.
 481         :type node: dict
 482         :type interface: str
 483         :type param: str
 484         :type value: str
 485         :return: Content of response.
 486         :rtype: bytearray
 487         :raises HoneycombError: If the parameter is not valid.
 488         """
 489
 490         if param in InterfaceKeywords.IPV6_PARAMS:
 491             path = ("interfaces", ("interface", "name", interface),
 492                     "ietf-ip:ipv6", param)
 493         elif param in InterfaceKeywords.IPV6_AUTOCONF_PARAMS:
 494             path = ("interfaces", ("interface", "name", interface),
 495                     "ietf-ip:ipv6", "autoconf", param)
 496         else:
 497             raise HoneycombError("The parameter {0} is invalid.".format(param))
 498
 499         return InterfaceKeywords._set_interface_properties(
 500             node, interface, path, value)
 501
 502     @staticmethod
 503     def add_first_ipv6_address(node, interface, ip_addr, prefix_len):
 504         """Add the first IPv6 address.
 505
 506         If there are any other addresses configured, they will be removed.
 507
 508         :param node: Honeycomb node.
 509         :param interface: The name of interface.
 510         :param ip_addr: IPv6 address to be set.
 511         :param prefix_len: Prefix length.
 512         :type node: dict
 513         :type interface: str
 514         :type ip_addr: str
 515         :type prefix_len: str
 516         :return: Content of response.
 517         :rtype: bytearray
 518         """
 519
 520         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6")
 521         address = {"address": [{"ip": ip_addr, "prefix-length": prefix_len}, ]}
 522         return InterfaceKeywords._set_interface_properties(
 523             node, interface, path, address)
 524
 525     @staticmethod
 526     def add_ipv6_address(node, interface, ip_addr, prefix_len):
 527         """Add IPv6 address.
 528
 529         :param node: Honeycomb node.
 530         :param interface: The name of interface.
 531         :param ip_addr: IPv6 address to be set.
 532         :param prefix_len: Prefix length.
 533         :type node: dict
 534         :type interface: str
 535         :type ip_addr: str
 536         :type prefix_len: str
 537         :return: Content of response.
 538         :rtype: bytearray
 539         """
 540
 541         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 542                 "address")
 543         address = [{"ip": ip_addr, "prefix-length": prefix_len}, ]
 544         return InterfaceKeywords._set_interface_properties(
 545             node, interface, path, address)
 546
 547     @staticmethod
 548     def remove_all_ipv6_addresses(node, interface):
 549         """Remove all IPv6 addresses from interface.
 550
 551         :param node: Honeycomb node.
 552         :param interface: The name of interface.
 553         :type node: dict
 554         :type interface: str
 555         :return: Content of response.
 556         :rtype: bytearray
 557         """
 558
 559         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 560                 "address")
 561         return InterfaceKeywords._set_interface_properties(
 562             node, interface, path, None)
 563
 564     @staticmethod
 565     def add_first_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
 566         """Add the first IPv6 neighbour.
 567
 568         If there are any other neighbours configured, they will be removed.
 569
 570         :param node: Honeycomb node.
 571         :param interface: The name of interface.
 572         :param ip_addr: IPv6 address of neighbour to be set.
 573         :param link_layer_address: Link layer address.
 574         :type node: dict
 575         :type interface: str
 576         :type ip_addr: str
 577         :type link_layer_address: str
 578         :return: Content of response.
 579         :rtype: bytearray
 580         """
 581
 582         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6")
 583         neighbor = {"neighbor": [{"ip": ip_addr,
 584                                   "link-layer-address": link_layer_address}, ]}
 585         return InterfaceKeywords._set_interface_properties(
 586             node, interface, path, neighbor)
 587
 588     @staticmethod
 589     def add_ipv6_neighbor(node, interface, ip_addr, link_layer_address):
 590         """Add the IPv6 neighbour.
 591
 592         :param node: Honeycomb node.
 593         :param interface: The name of interface.
 594         :param ip_addr: IPv6 address of neighbour to be set.
 595         :param link_layer_address: Link layer address.
 596         :type node: dict
 597         :type interface: str
 598         :type ip_addr: str
 599         :type link_layer_address: str
 600         :return: Content of response.
 601         :rtype: bytearray
 602         """
 603
 604         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 605                 "neighbor")
 606         neighbor = [{"ip": ip_addr, "link-layer-address": link_layer_address}, ]
 607         return InterfaceKeywords._set_interface_properties(
 608             node, interface, path, neighbor)
 609
 610     @staticmethod
 611     def remove_all_ipv6_neighbors(node, interface):
 612         """Remove all IPv6 neighbours.
 613
 614         :param node: Honeycomb node.
 615         :param interface: The name of interface.
 616         :type node: dict
 617         :type interface: str
 618         :return: Content of response.
 619         :rtype: bytearray
 620         """
 621
 622         path = ("interfaces", ("interface", "name", interface), "ietf-ip:ipv6",
 623                 "neighbor")
 624         return InterfaceKeywords._set_interface_properties(
 625             node, interface, path, None)
 626
 627     @staticmethod
 628     def configure_interface_ethernet(node, interface, param, value):
 629         """Configure the ethernet parameters of interface.
 630
 631         :param node: Honeycomb node.
 632         :param interface: The name of interface.
 633         :param param: Parameter to configure (set, change, remove)
 634         :param value: The value of parameter. If None, the parameter will be
 635         removed.
 636         :type node: dict
 637         :type interface: str
 638         :type param: str
 639         :type value: str
 640         :return: Content of response.
 641         :rtype: bytearray
 642         :raises HoneycombError: If the parameter is not valid.
 643         """
 644
 645         if param not in InterfaceKeywords.ETH_PARAMS:
 646             raise HoneycombError("The parameter {0} is invalid.".format(param))
 647         path = ("interfaces", ("interface", "name", interface), "v3po:ethernet",
 648                 param)
 649         return InterfaceKeywords._set_interface_properties(
 650             node, interface, path, value)
 651
 652     @staticmethod
 653     def configure_interface_routing(node, interface, param, value):
 654         """Configure the routing parameters of interface.
 655
 656         :param node: Honeycomb node.
 657         :param interface: The name of interface.
 658         :param param: Parameter to configure (set, change, remove)
 659         :param value: The value of parameter. If None, the parameter will be
 660         removed.
 661         :type node: dict
 662         :type interface: str
 663         :type param: str
 664         :type value: str
 665         :return: Content of response.
 666         :rtype: bytearray
 667         :raises HoneycombError: If the parameter is not valid.
 668         """
 669
 670         if param not in InterfaceKeywords.ROUTING_PARAMS:
 671             raise HoneycombError("The parameter {0} is invalid.".format(param))
 672
 673         path = ("interfaces", ("interface", "name", interface), "v3po:routing",
 674                 param)
 675         return InterfaceKeywords._set_interface_properties(
 676             node, interface, path, value)
 677
 678     @staticmethod
 679     def create_vxlan_interface(node, interface, **kwargs):
 680         """Create a new VxLAN interface.
 681
 682         :param node: Honeycomb node.
 683         :param interface: The name of interface.
 684         :param kwargs: Parameters and their values. The accepted parameters are
 685         defined in InterfaceKeywords.VXLAN_PARAMS.
 686         :type node: dict
 687         :type interface: str
 688         :type kwargs: dict
 689         :return: Content of response.
 690         :rtype: bytearray
 691         :raises HoneycombError: If the parameter is not valid.
 692         """
 693
 694         new_vx_lan = {
 695             "name": interface,
 696             "type": "v3po:vxlan-tunnel",
 697             "v3po:vxlan": {}
 698         }
 699         for param, value in kwargs.items():
 700             if param not in InterfaceKeywords.VXLAN_PARAMS:
 701                 raise HoneycombError("The parameter {0} is invalid.".
 702                                      format(param))
 703             new_vx_lan["v3po:vxlan"][param] = value
 704
 705         path = ("interfaces", "interface")
 706         vx_lan_structure = [new_vx_lan, ]
 707         return InterfaceKeywords._set_interface_properties(
 708             node, interface, path, vx_lan_structure)
 709
 710     @staticmethod
 711     def delete_interface(node, interface):
 712         """Delete an interface.
 713
 714         :param node: Honeycomb node.
 715         :param interface: The name of interface.
 716         :type node: dict
 717         :type interface: str
 718         :return: Content of response.
 719         :rtype: bytearray
 720         :raises HoneycombError: If it is not possible to get information about
 721         interfaces or it is not possible to delete the interface.
 722         """
 723
 724         path = ("interfaces", ("interface", "name", interface))
 725
 726         status_code, resp = HcUtil.\
 727             get_honeycomb_data(node, "config_vpp_interfaces")
 728         if status_code != HTTPCodes.OK:
 729             raise HoneycombError(
 730                 "Not possible to get configuration information about the "
 731                 "interfaces. Status code: {0}.".format(status_code))
 732
 733         new_data = HcUtil.remove_item(resp, path)
 734         status_code, resp = HcUtil.\
 735             put_honeycomb_data(node, "config_vpp_interfaces", new_data)
 736         if status_code != HTTPCodes.OK:
 737             raise HoneycombError("Not possible to remove interface {0}. "
 738                                  "Status code: {1}.".
 739                                  format(interface, status_code))
 740         return resp
 741
 742     @staticmethod
 743     def configure_interface_vxlan(node, interface, **kwargs):
 744         """Configure VxLAN on the interface.
 745
 746         The keyword configures VxLAN parameters on the given interface. The type
 747         of interface must be set to "v3po:vxlan-tunnel".
 748         The new VxLAN parameters overwrite the current configuration. If a
 749         parameter in new configuration is missing, it is removed from VxLAN
 750         configuration.
 751         If the dictionary kwargs is empty, VxLAN configuration is removed.
 752
 753         :param node: Honeycomb node.
 754         :param interface: The name of interface.
 755         :param kwargs: Parameters and their values. The accepted parameters are
 756         defined in InterfaceKeywords.VXLAN_PARAMS.
 757         :type node: dict
 758         :type interface: str
 759         :type kwargs: dict
 760         :return: Content of response.
 761         :rtype: bytearray
 762         :raises HoneycombError: If the parameter is not valid.
 763         """
 764
 765         vx_lan_structure = dict()
 766         for param, value in kwargs.items():
 767             if param not in InterfaceKeywords.VXLAN_PARAMS:
 768                 raise HoneycombError("The parameter {0} is invalid.".
 769                                      format(param))
 770             vx_lan_structure[param] = value
 771
 772         path = ("interfaces", ("interface", "name", interface), "v3po:vxlan")
 773         return InterfaceKeywords._set_interface_properties(
 774             node, interface, path, vx_lan_structure)
 775
 776     @staticmethod
 777     def configure_interface_l2(node, interface, param, value):
 778         """Configure the L2 parameters of interface.
 779
 780         :param node: Honeycomb node.
 781         :param interface: The name of interface.
 782         :param param: Parameter to configure (set, change, remove)
 783         :param value: The value of parameter. If None, the parameter will be
 784         removed.
 785         :type node: dict
 786         :type interface: str
 787         :type param: str
 788         :type value: str
 789         :return: Content of response.
 790         :rtype: bytearray
 791         :raises HoneycombError: If the parameter is not valid.
 792         """
 793
 794         if param not in InterfaceKeywords.L2_PARAMS:
 795             raise HoneycombError("The parameter {0} is invalid.".format(param))
 796         path = ("interfaces", ("interface", "name", interface), "v3po:l2",
 797                 param)
 798         return InterfaceKeywords._set_interface_properties(
 799             node, interface, path, value)
 800
 801     @staticmethod
 802     def create_tap_interface(node, interface, **kwargs):
 803         """Create a new TAP interface.
 804
 805         :param node: Honeycomb node.
 806         :param interface: The name of interface.
 807         :param kwargs: Parameters and their values. The accepted parameters are
 808         defined in InterfaceKeywords.TAP_PARAMS.
 809         :type node: dict
 810         :type interface: str
 811         :type kwargs: dict
 812         :return: Content of response.
 813         :rtype: bytearray
 814         :raises HoneycombError: If the parameter is not valid.
 815         """
 816
 817         new_tap = {
 818             "name": interface,
 819             "type": "v3po:tap",
 820             "v3po:tap": {}
 821         }
 822         for param, value in kwargs.items():
 823             if param not in InterfaceKeywords.TAP_PARAMS:
 824                 raise HoneycombError("The parameter {0} is invalid.".
 825                                      format(param))
 826             new_tap["v3po:tap"][param] = value
 827
 828         path = ("interfaces", "interface")
 829         new_tap_structure = [new_tap, ]
 830         return InterfaceKeywords._set_interface_properties(
 831             node, interface, path, new_tap_structure)
 832
 833     @staticmethod
 834     def configure_interface_tap(node, interface, **kwargs):
 835         """Configure TAP on the interface.
 836
 837         The keyword configures TAP parameters on the given interface. The type
 838         of interface must be set to "v3po:tap".
 839         The new TAP parameters overwrite the current configuration. If a
 840         parameter in new configuration is missing, it is removed from TAP
 841         configuration.
 842         If the dictionary kwargs is empty, TAP configuration is removed.
 843
 844         :param node: Honeycomb node.
 845         :param interface: The name of interface.
 846         :param kwargs: Parameters and their values. The accepted parameters are
 847         defined in InterfaceKeywords.TAP_PARAMS.
 848         :type node: dict
 849         :type interface: str
 850         :type kwargs: dict
 851         :return: Content of response.
 852         :rtype: bytearray
 853         :raises HoneycombError: If the parameter is not valid.
 854         """
 855
 856         tap_structure = dict()
 857         for param, value in kwargs.items():
 858             if param not in InterfaceKeywords.TAP_PARAMS:
 859                 raise HoneycombError("The parameter {0} is invalid.".
 860                                      format(param))
 861             tap_structure[param] = value
 862
 863         path = ("interfaces", ("interface", "name", interface), "v3po:tap")
 864         return InterfaceKeywords._set_interface_properties(
 865             node, interface, path, tap_structure)
 866
 867     @staticmethod
 868     def configure_interface_vhost_user(node, interface, **kwargs):
 869         """Configure vhost-user on the interface.
 870
 871         The keyword configures vhost-user parameters on the given interface.
 872         The type of interface must be set to "v3po:vhost-user".
 873         The new vhost-user parameters overwrite the current configuration. If a
 874         parameter in new configuration is missing, it is removed from vhost-user
 875         configuration.
 876         If the dictionary kwargs is empty, vhost-user configuration is removed.
 877
 878         :param node: Honeycomb node.
 879         :param interface: The name of interface.
 880         :param kwargs: Parameters and their values. The accepted parameters are
 881         defined in InterfaceKeywords.VHOST_USER_PARAMS.
 882         :type node: dict
 883         :type interface: str
 884         :type kwargs: dict
 885         :return: Content of response.
 886         :rtype: bytearray
 887         :raises HoneycombError: If the parameter is not valid.
 888         """
 889
 890         vhost_structure = dict()
 891         for param, value in kwargs.items():
 892             if param not in InterfaceKeywords.VHOST_USER_PARAMS:
 893                 raise HoneycombError("The parameter {0} is invalid.".
 894                                      format(param))
 895             vhost_structure[param] = value
 896
 897         path = ("interfaces", ("interface", "name", interface),
 898                 "v3po:vhost-user")
 899         return InterfaceKeywords._set_interface_properties(
 900             node, interface, path, vhost_structure)
 901
 902     @staticmethod
 903     def create_vhost_user_interface(node, interface, **kwargs):
 904         """Create a new vhost-user interface.
 905
 906         :param node: Honeycomb node.
 907         :param interface: The name of interface.
 908         :param kwargs: Parameters and their values. The accepted parameters are
 909         defined in InterfaceKeywords.VHOST_USER_PARAMS.
 910         :type node: dict
 911         :type interface: str
 912         :type kwargs: dict
 913         :return: Content of response.
 914         :rtype: bytearray
 915         :raises HoneycombError: If the parameter is not valid.
 916         """
 917
 918         new_vhost = {
 919             "name": interface,
 920             "type": "v3po:vhost-user",
 921             "v3po:vhost-user": {}
 922         }
 923         for param, value in kwargs.items():
 924             if param not in InterfaceKeywords.VHOST_USER_PARAMS:
 925                 raise HoneycombError("The parameter {0} is invalid.".
 926                                      format(param))
 927             new_vhost["v3po:vhost-user"][param] = value
 928
 929         path = ("interfaces", "interface")
 930         new_vhost_structure = [new_vhost, ]
 931         return InterfaceKeywords._set_interface_properties(
 932             node, interface, path, new_vhost_structure)