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

©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.