dc248589f987603fef1ea0a10abced9a68ff4f41
[csit.git] / 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         intf_state = {"up": "true",
1166                       "down": "false"}
1167
1168         path = ("interfaces",
1169                 ("interface", "name", super_interface),
1170                 "vpp-vlan:sub-interfaces",
1171                 ("sub-interface", "identifier", int(identifier)),
1172                 "enabled")
1173
1174         return InterfaceKeywords._set_interface_properties(
1175             node, super_interface, path, intf_state[state])
1176
1177     @staticmethod
1178     def add_bridge_domain_to_sub_interface(node, super_interface, identifier,
1179                                            config):
1180         """Add a sub-interface to a bridge domain and set its parameters.
1181
1182         :param node: Honeycomb node.
1183         :param super_interface: Super interface.
1184         :param identifier: The ID of sub-interface.
1185         :param config: Bridge domain configuration.
1186         :type node: dict
1187         :type super_interface: str
1188         :type identifier: int
1189         :type config: dict
1190         :returns: Content of response.
1191         :rtype: bytearray
1192         """
1193
1194         path = ("interfaces",
1195                 ("interface", "name", super_interface),
1196                 "vpp-vlan:sub-interfaces",
1197                 ("sub-interface", "identifier", int(identifier)),
1198                 "l2")
1199
1200         return InterfaceKeywords._set_interface_properties(
1201             node, super_interface, path, config)
1202
1203     @staticmethod
1204     def get_bd_data_from_sub_interface(node, super_interface, identifier):
1205         """Get the operational data about the bridge domain from sub-interface.
1206
1207         :param node: Honeycomb node.
1208         :param super_interface: Super interface.
1209         :param identifier: The ID of sub-interface.
1210         :type node: dict
1211         :type super_interface: str
1212         :type identifier: int
1213         :returns: Operational data about the bridge domain.
1214         :rtype: dict
1215         :raises HoneycombError: If there is no sub-interface with the given ID.
1216         """
1217
1218         try:
1219             bd_data = InterfaceKeywords.get_sub_interface_oper_data(
1220                 node, super_interface, identifier)["l2"]
1221             return bd_data
1222         except KeyError:
1223             raise HoneycombError("The operational data does not contain "
1224                                  "information about a bridge domain.")
1225
1226     @staticmethod
1227     def configure_tag_rewrite(node, super_interface, identifier, config):
1228         """Add / change / disable vlan tag rewrite on a sub-interface.
1229
1230         :param node: Honeycomb node.
1231         :param super_interface: Super interface.
1232         :param identifier: The ID of sub-interface.
1233         :param config: Rewrite tag configuration.
1234         :type node: dict
1235         :type super_interface: str
1236         :type identifier: int
1237         :type config: dict
1238         :returns: Content of response.
1239         :rtype: bytearray
1240         """
1241
1242         path = ("interfaces",
1243                 ("interface", "name", super_interface),
1244                 "vpp-vlan:sub-interfaces",
1245                 ("sub-interface", "identifier", int(identifier)),
1246                 "l2",
1247                 "rewrite")
1248
1249         return InterfaceKeywords._set_interface_properties(
1250             node, super_interface, path, config)
1251
1252     @staticmethod
1253     def get_tag_rewrite_oper_data(node, super_interface, identifier):
1254         """Get the operational data about tag rewrite.
1255
1256         :param node: Honeycomb node.
1257         :param super_interface: Super interface.
1258         :param identifier: The ID of sub-interface.
1259         :type node: dict
1260         :type super_interface: str
1261         :type identifier: int
1262         :returns: Operational data about tag rewrite.
1263         :rtype: dict
1264         :raises HoneycombError: If there is no sub-interface with the given ID.
1265         """
1266
1267         try:
1268             tag_rewrite = InterfaceKeywords.get_sub_interface_oper_data(
1269                 node, super_interface, identifier)["l2"]["rewrite"]
1270             return tag_rewrite
1271         except KeyError:
1272             raise HoneycombError("The operational data does not contain "
1273                                  "information about the tag-rewrite.")
1274
1275     @staticmethod
1276     def add_ip_address_to_sub_interface(node, super_interface, identifier,
1277                                         ip_addr, network, ip_version):
1278         """Add an ipv4 address to the specified sub-interface, with the provided
1279         netmask or network prefix length. Any existing ipv4 addresses on the
1280         sub-interface will be replaced.
1281
1282         :param node: Honeycomb node.
1283         :param super_interface: Super interface.
1284         :param identifier: The ID of sub-interface.
1285         :param ip_addr: IPv4 address to be set.
1286         :param network: Network mask or network prefix length.
1287         :param ip_version: ipv4 or ipv6
1288         :type node: dict
1289         :type super_interface: str
1290         :type identifier: int
1291         :type ip_addr: str
1292         :type network: str or int
1293         :type ip_version: string
1294         :returns: Content of response.
1295         :rtype: bytearray
1296         :raises HoneycombError: If the provided netmask or prefix is not valid.
1297         """
1298
1299         path = ("interfaces",
1300                 ("interface", "name", super_interface),
1301                 "vpp-vlan:sub-interfaces",
1302                 ("sub-interface", "identifier", int(identifier)),
1303                 ip_version.lower())
1304
1305         if isinstance(network, basestring) and ip_version.lower() == "ipv4":
1306             address = {"address": [{"ip": ip_addr, "netmask": network}, ]}
1307
1308         elif isinstance(network, int) and 0 < network < 33:
1309             address = {"address": [{"ip": ip_addr, "prefix-length": network}, ]}
1310
1311         else:
1312             raise HoneycombError("{0} is not a valid netmask or prefix length."
1313                                  .format(network))
1314
1315         return InterfaceKeywords._set_interface_properties(
1316             node, super_interface, path, address)
1317
1318     @staticmethod
1319     def remove_all_ip_addresses_from_sub_interface(node, super_interface,
1320                                                    identifier, ip_version):
1321         """Remove all ipv4 addresses from the specified sub-interface.
1322
1323         :param node: Honeycomb node.
1324         :param super_interface: Super interface.
1325         :param identifier: The ID of sub-interface.
1326         :param ip_version: ipv4 or ipv6
1327         :type node: dict
1328         :type super_interface: str
1329         :type identifier: int
1330         :type ip_version: string
1331         :returns: Content of response.
1332         :rtype: bytearray
1333         """
1334
1335         path = ("interfaces",
1336                 ("interface", "name", super_interface),
1337                 "vpp-vlan:sub-interfaces",
1338                 ("sub-interface", "identifier", int(identifier)),
1339                 str(ip_version), "address")
1340
1341         return InterfaceKeywords._set_interface_properties(
1342             node, super_interface, path, None)
1343
1344     @staticmethod
1345     def compare_data_structures(data, ref, _path=''):
1346         """Checks if data obtained from UUT is as expected. If it is not,
1347         proceeds down the list/dictionary tree and finds the point of mismatch.
1348
1349         :param data: Data to be checked.
1350         :param ref: Referential data used for comparison.
1351         :param _path: Used in recursive calls, stores the path taken down
1352         the JSON tree.
1353         :type data: dict
1354         :type ref: dict
1355         :type _path: str
1356
1357         :raises HoneycombError: If the data structures do not match in some way,
1358         or if they are not in deserialized JSON format.
1359         """
1360
1361         if data == ref:
1362             return True
1363
1364         elif isinstance(data, dict) and isinstance(ref, dict):
1365             for key in ref:
1366                 if key not in data:
1367                     raise HoneycombError(
1368                         "Key {key} is not present in path {path}. Keys in path:"
1369                         "{data_keys}".format(
1370                             key=key,
1371                             path=_path,
1372                             data_keys=data.keys()))
1373
1374                 if data[key] != ref[key]:
1375                     if isinstance(data[key], list) \
1376                             or isinstance(data[key], dict):
1377                         InterfaceKeywords.compare_data_structures(
1378                             data[key], ref[key],
1379                             _path + '[{0}]'.format(key))
1380                     else:
1381                         raise HoneycombError(
1382                             "Data mismatch, key {key} in path {path} has value"
1383                             " {data}, but should be {ref}".format(
1384                                 key=key,
1385                                 path=_path,
1386                                 data=data[key],
1387                                 ref=ref[key]))
1388
1389         elif isinstance(data, list) and isinstance(ref, list):
1390             for item in ref:
1391                 if item not in data:
1392                     if isinstance(item, dict):
1393                         InterfaceKeywords.compare_data_structures(
1394                             data[0], item,
1395                             _path + '[{0}]'.format(ref.index(item)))
1396                     else:
1397                         raise HoneycombError(
1398                             "Data mismatch, list item {index} in path {path}"
1399                             " has value {data}, but should be {ref}".format(
1400                                 index=ref.index(item),
1401                                 path=_path,
1402                                 data=data[0],
1403                                 ref=item))
1404
1405         else:
1406             raise HoneycombError(
1407                 "Unexpected data type {data_type} in path {path}, reference"
1408                 " type is {ref_type}. Must be list or dictionary.".format(
1409                     data_type=type(data),
1410                     ref_type=type(ref),
1411                     path=_path))
1412
1413     @staticmethod
1414     def compare_interface_lists(list1, list2):
1415         """Compare provided lists of interfaces by name.
1416
1417         :param list1: List of interfaces.
1418         :param list2: List of interfaces.
1419         :type list1: list
1420         :type list2: list
1421         :raises HoneycombError: If an interface exists in only one of the lists.
1422         """
1423
1424         ignore = ["vx_tunnel0", "vxlan_gpe_tunnel0"]
1425         # these have no equivalent in config data and no effect on VPP
1426
1427         names1 = [x['name'] for x in list1]
1428         names2 = [x['name'] for x in list2]
1429
1430         for name in names1:
1431             if name not in names2 and name not in ignore:
1432                 raise HoneycombError("Interface {0} not present in list {1}"
1433                                      .format(name, list2))
1434         for name in names2:
1435             if name not in names1 and name not in ignore:
1436                 raise HoneycombError("Interface {0} not present in list {1}"
1437                                      .format(name, list1))
1438
1439     @staticmethod
1440     def create_vxlan_gpe_interface(node, interface, **kwargs):
1441         """Create a new VxLAN GPE interface.
1442
1443         :param node: Honeycomb node.
1444         :param interface: The name of interface to be created.
1445         :param kwargs: Parameters and their values. The accepted parameters are
1446         defined in InterfaceKeywords.VXLAN_GPE_PARAMS.
1447         :type node: dict
1448         :type interface: str
1449         :type kwargs: dict
1450         :returns: Content of response.
1451         :rtype: bytearray
1452         :raises HoneycombError: If a parameter in kwargs is not valid.
1453         """
1454
1455         new_vxlan_gpe = {
1456             "name": interface,
1457             "type": "v3po:vxlan-gpe-tunnel",
1458             "v3po:vxlan-gpe": {}
1459         }
1460         for param, value in kwargs.items():
1461             if param in InterfaceKeywords.INTF_PARAMS:
1462                 new_vxlan_gpe[param] = value
1463             elif param in InterfaceKeywords.VXLAN_GPE_PARAMS:
1464                 new_vxlan_gpe["v3po:vxlan-gpe"][param] = value
1465             else:
1466                 raise HoneycombError("The parameter {0} is invalid.".
1467                                      format(param))
1468         path = ("interfaces", "interface")
1469         vxlan_gpe_structure = [new_vxlan_gpe, ]
1470         return InterfaceKeywords._set_interface_properties(
1471             node, interface, path, vxlan_gpe_structure)
1472
1473     @staticmethod
1474     def enable_acl_on_interface(node, interface, table_name):
1475         """Enable ACL on the given interface.
1476
1477         :param node: Honeycomb node.
1478         :param interface: The interface where the ACL will be enabled.
1479         :param table_name: Name of the classify table.
1480         :type node: dict
1481         :type interface: str
1482         :type table_name: str
1483         :returns: Content of response.
1484         :rtype: bytearray
1485         :raises HoneycombError: If the configuration of interface is not
1486         successful.
1487         """
1488
1489         interface = interface.replace("/", "%2F")
1490
1491         data = {
1492             "vpp-interface-acl:acl": {
1493                 "ingress": {
1494                     "ip4-acl": {
1495                         "classify-table": table_name
1496                     },
1497                     "l2-acl": {
1498                         "classify-table": table_name
1499                     }
1500                 }
1501             }
1502         }
1503
1504         path = "/interface/" + interface + "/vpp-interface-acl:acl"
1505         status_code, resp = HcUtil.\
1506             put_honeycomb_data(node, "config_vpp_interfaces", data, path,
1507                                data_representation=DataRepresentation.JSON)
1508         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
1509             raise HoneycombError(
1510                 "The configuration of interface '{0}' was not successful. "
1511                 "Status code: {1}.".format(interface, status_code))
1512         return resp
1513
1514     @staticmethod
1515     def enable_policer_on_interface(node, interface, table_name):
1516         """Enable Policer on the given interface.
1517
1518         :param node: Honeycomb node.
1519         :param interface: The interface where policer will be enabled.
1520         :param table_name: Name of the classify table.
1521         :type node: dict
1522         :type interface: str
1523         :type table_name: str
1524         :returns: Content of response.
1525         :rtype: bytearray
1526         :raises HoneycombError: If the configuration of interface is not
1527         successful.
1528         """
1529         interface = Topology.convert_interface_reference(
1530             node, interface, "name")
1531         interface = interface.replace("/", "%2F")
1532
1533         data = {
1534             "interface-policer:policer": {
1535                 "ip4-table": table_name
1536                 }
1537             }
1538
1539         path = "/interface/" + interface + "/interface-policer:policer"
1540         status_code, resp = HcUtil.\
1541             put_honeycomb_data(node, "config_vpp_interfaces", data, path,
1542                                data_representation=DataRepresentation.JSON)
1543         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
1544             raise HoneycombError(
1545                 "The configuration of interface '{0}' was not successful. "
1546                 "Status code: {1}.".format(interface, status_code))
1547         return resp
1548
1549     @staticmethod
1550     def disable_policer_on_interface(node, interface):
1551         """Disable Policer on the given interface.
1552
1553         :param node: Honeycomb node.
1554         :param interface: The interface where policer will be disabled.
1555         :param table_name: Name of the classify table.
1556         :type node: dict
1557         :type interface: str
1558         :type table_name: str
1559         :returns: Content of response.
1560         :rtype: bytearray
1561         :raises HoneycombError: If the configuration of interface is not
1562         successful.
1563         """
1564         interface = Topology.convert_interface_reference(
1565             node, interface, "name")
1566         interface = interface.replace("/", "%2F")
1567
1568         path = "/interface/" + interface + "/interface-policer:policer"
1569         status_code, resp = HcUtil.\
1570             delete_honeycomb_data(node, "config_vpp_interfaces", path)
1571         if status_code != HTTPCodes.OK:
1572             raise HoneycombError(
1573                 "The configuration of interface '{0}' was not successful. "
1574                 "Status code: {1}.".format(interface, status_code))
1575         return resp
1576
1577     @staticmethod
1578     def disable_acl_on_interface(node, interface):
1579         """Disable ACL on the given interface.
1580
1581         :param node: Honeycomb node.
1582         :param interface: The interface where the ACL will be disabled.
1583         :type node: dict
1584         :type interface: str
1585         :returns: Content of response.
1586         :rtype: bytearray
1587         :raises HoneycombError: If the configuration of interface is not
1588         successful.
1589         """
1590
1591         interface = interface.replace("/", "%2F")
1592
1593         path = "/interface/" + interface + "/vpp-interface-acl:acl"
1594
1595         status_code, resp = HcUtil.\
1596             delete_honeycomb_data(node, "config_vpp_interfaces", path)
1597
1598         if status_code != HTTPCodes.OK:
1599             raise HoneycombError(
1600                 "The configuration of interface '{0}' was not successful. "
1601                 "Status code: {1}.".format(interface, status_code))
1602         return resp
1603
1604     @staticmethod
1605     def create_pbb_sub_interface(node, intf, params):
1606         """Creates a PBB sub-interface on the given interface and sets its
1607         parameters.
1608
1609         :param node: Honeycomb node.
1610         :param intf: The interface where PBB sub-interface will be configured.
1611         :param params: Configuration parameters of the sub-interface to be
1612         created.
1613         :type node: dict
1614         :type intf: str
1615         :type params: dict
1616         :returns: Content of response.
1617         :rtype: bytearray
1618         :raises HoneycombError: If the configuration of sub-interface is not
1619         successful.
1620         """
1621
1622         interface = intf.replace("/", "%2F")
1623         path = "/interface/{0}/pbb-rewrite".format(interface)
1624         status_code, resp = HcUtil. \
1625             put_honeycomb_data(node, "config_vpp_interfaces", params, path,
1626                                data_representation=DataRepresentation.JSON)
1627         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
1628             raise HoneycombError(
1629                 "The configuration of PBB sub-interface '{0}' was not "
1630                 "successful. Status code: {1}.".format(intf, status_code))
1631         return resp
1632
1633     @staticmethod
1634     def delete_pbb_sub_interface(node, intf):
1635         """Deletes the given PBB sub-interface.
1636
1637         :param node: Honeycomb node.
1638         :param intf: The interface where PBB sub-interface will be deleted.
1639         :type node: dict
1640         :type intf: str
1641         :returns: Content of response.
1642         :rtype: bytearray
1643         :raises HoneycombError: If the removal of sub-interface is not
1644         successful.
1645         """
1646
1647         interface = intf.replace("/", "%2F")
1648         path = "/interface/{0}/pbb-rewrite".format(interface)
1649
1650         status_code, resp = HcUtil. \
1651             delete_honeycomb_data(node, "config_vpp_interfaces", path)
1652         if status_code != HTTPCodes.OK:
1653             raise HoneycombError(
1654                 "The removal of pbb sub-interface '{0}' was not successful. "
1655                 "Status code: {1}.".format(intf, status_code))
1656         return resp
1657
1658     @staticmethod
1659     def get_pbb_sub_interface_oper_data(node, intf, sub_if_id):
1660         """Retrieves PBB sub-interface operational data from Honeycomb.
1661
1662         :param node: Honeycomb node.
1663         :param intf: The interface where PBB sub-interface is located.
1664         :param sub_if_id: ID of the PBB sub-interface.
1665         :type node: dict
1666         :type intf: str
1667         :type sub_if_id: str or int
1668         :returns: PBB sub-interface operational data.
1669         :rtype: dict
1670         :raises HoneycombError: If the removal of sub-interface is not
1671         successful.
1672         """
1673
1674         raise NotImplementedError
1675
1676     @staticmethod
1677     def check_disabled_interface(node, interface):
1678         """Retrieves list of disabled interface indices from Honeycomb,
1679         and matches with the provided interface by index.
1680
1681         :param node: Honeycomb node.
1682         :param interface: Index number of an interface on the node.
1683         :type node: dict
1684         :type interface: int
1685         :returns: True if the interface exists in disabled interfaces.
1686         :rtype: bool
1687         :raises HoneycombError: If the interface is not present
1688          in retrieved list of disabled interfaces.
1689          """
1690         data = InterfaceKeywords.get_disabled_interfaces_oper_data(node)
1691         # decrement by one = conversion from HC if-index to VPP sw_if_index
1692         interface -= 1
1693
1694         for item in data:
1695             if item["index"] == interface:
1696                 return True
1697         raise HoneycombError("Interface index {0} not present in list"
1698                              " of disabled interfaces.".format(interface))
1699
1700     @staticmethod
1701     def configure_interface_span(node, dst_interface, src_interfaces=None):
1702         """Configure SPAN port mirroring on the specified interfaces. If no
1703          source interface is provided, SPAN will be disabled.
1704
1705         :param node: Honeycomb node.
1706         :param dst_interface: Interface to mirror packets to.
1707         :param src_interfaces: List of interfaces to mirror packets from.
1708         :type node: dict
1709         :type dst_interface: str
1710         :type src_interfaces: list of dict
1711         :returns: Content of response.
1712         :rtype: bytearray
1713         :raises HoneycombError: If SPAN could not be configured.
1714         """
1715
1716         interface = Topology.convert_interface_reference(
1717             node, dst_interface, "name")
1718         interface = interface.replace("/", "%2F")
1719         path = "/interface/" + interface + "/span"
1720
1721         if not src_interfaces:
1722             status_code, _ = HcUtil.delete_honeycomb_data(
1723                 node, "config_vpp_interfaces", path)
1724         else:
1725             for src_interface in src_interfaces:
1726                 src_interface["iface-ref"] = Topology.\
1727                     convert_interface_reference(
1728                         node, src_interface["iface-ref"], "name")
1729             data = {
1730                 "span": {
1731                     "mirrored-interfaces": {
1732                         "mirrored-interface": src_interfaces
1733                     }
1734                 }
1735             }
1736
1737             status_code, _ = HcUtil.put_honeycomb_data(
1738                 node, "config_vpp_interfaces", data, path)
1739
1740         if status_code not in (HTTPCodes.OK, HTTPCodes.ACCEPTED):
1741             raise HoneycombError(
1742                 "Configuring SPAN failed. Status code:{0}".format(status_code))
1743
1744     @staticmethod
1745     def add_interface_local0_to_topology(node):
1746         """Use Topology methods to add interface "local0" to working topology,
1747         if not already present.
1748
1749         :param node: DUT node.
1750         :type node: dict
1751         """
1752
1753         if Topology.get_interface_by_sw_index(node, 0) is None:
1754             local0_key = Topology.add_new_port(node, "localzero")
1755             Topology.update_interface_sw_if_index(node, local0_key, 0)
1756             Topology.update_interface_name(node, local0_key, "local0")

©2016 FD.io a Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation. Linux is a registered trademark of Linus Torvalds.
Please see our privacy policy and terms of use.