resources/libraries/python/Classify.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 """Classify utilities library."""
  15
  16 from robot.api import logger
  17
  18 from resources.libraries.python.VatExecutor import VatExecutor, VatTerminal
  19 from resources.libraries.python.topology import Topology
  20
  21
  22 class Classify(object):
  23     """Classify utilities."""
  24
  25     @staticmethod
  26     def vpp_creates_classify_table_l3(node, ip_version, direction):
  27         """Create classify table for IP address filtering.
  28
  29         :param node: VPP node to create classify table.
  30         :param ip_version: Version of IP protocol.
  31         :param direction: Direction of traffic - src/dst.
  32         :type node: dict
  33         :type ip_version: str
  34         :type direction: str
  35         :returns (table_index, skip_n, match_n)
  36         table_index: Classify table index.
  37         skip_n: Number of skip vectors.
  38         match_n: Number of match vectors.
  39         :rtype: tuple(int, int, int)
  40         :raises RuntimeError: If VPP can't create table.
  41         """
  42
  43         output = VatExecutor.cmd_from_template(node, "classify_add_table.vat",
  44                                                ip_version=ip_version,
  45                                                direction=direction)
  46
  47         if output[0]["retval"] == 0:
  48             table_index = output[0]["new_table_index"]
  49             skip_n = output[0]["skip_n_vectors"]
  50             match_n = output[0]["match_n_vectors"]
  51             logger.trace('Classify table with table_index {} created on node {}'
  52                          .format(table_index, node['host']))
  53         else:
  54             raise RuntimeError('Unable to create classify table on node {}'
  55                                .format(node['host']))
  56
  57         return table_index, skip_n, match_n
  58
  59     @staticmethod
  60     def vpp_creates_classify_table_l2(node, direction):
  61         """Create classify table for MAC address filtering.
  62
  63         :param node: VPP node to create classify table.
  64         :param direction: Direction of traffic - src/dst.
  65         :type node: dict
  66         :type direction: str
  67         :returns (table_index, skip_n, match_n)
  68         table_index: Classify table index.
  69         skip_n: Number of skip vectors.
  70         match_n: Number of match vectors.
  71         :rtype: tuple(int, int, int)
  72         :raises RuntimeError: If VPP can't create table.
  73         """
  74         output = VatExecutor.cmd_from_template(node,
  75                                                "classify_add_table_l2.vat",
  76                                                direction=direction)
  77
  78         if output[0]["retval"] == 0:
  79             table_index = output[0]["new_table_index"]
  80             skip_n = output[0]["skip_n_vectors"]
  81             match_n = output[0]["match_n_vectors"]
  82             logger.trace('Classify table with table_index {} created on node {}'
  83                          .format(table_index, node['host']))
  84         else:
  85             raise RuntimeError('Unable to create classify table on node {}'
  86                                .format(node['host']))
  87
  88         return table_index, skip_n, match_n
  89
  90     @staticmethod
  91     def vpp_creates_classify_table_hex(node, hex_mask):
  92         """Create classify table with hex mask.
  93
  94         :param node: VPP node to create classify table based on hex mask.
  95         :param hex_mask: Classify hex mask.
  96         :type node: dict
  97         :type hex_mask: str
  98         :returns (table_index, skip_n, match_n)
  99         table_index: Classify table index.
 100         skip_n: Number of skip vectors.
 101         match_n: Number of match vectors.
 102         :rtype: tuple(int, int, int)
 103         :raises RuntimeError: If VPP can't create table.
 104         """
 105         output = VatExecutor.cmd_from_template(node,
 106                                                "classify_add_table_hex.vat",
 107                                                hex_mask=hex_mask)
 108
 109         if output[0]["retval"] == 0:
 110             table_index = output[0]["new_table_index"]
 111             skip_n = output[0]["skip_n_vectors"]
 112             match_n = output[0]["match_n_vectors"]
 113             logger.trace('Classify table with table_index {} created on node {}'
 114                          .format(table_index, node['host']))
 115         else:
 116             raise RuntimeError('Unable to create classify table on node {}'
 117                                .format(node['host']))
 118
 119         return table_index, skip_n, match_n
 120
 121     @staticmethod
 122     def vpp_configures_classify_session_l3(node, acl_method, table_index,
 123                                            skip_n, match_n, ip_version,
 124                                            direction, address):
 125         """Configuration of classify session for IP address filtering.
 126
 127         :param node: VPP node to setup classify session.
 128         :param acl_method: ACL method - deny/permit.
 129         :param table_index: Classify table index.
 130         :param skip_n: Number of skip vectors based on mask.
 131         :param match_n: Number of match vectors based on mask.
 132         :param ip_version: Version of IP protocol.
 133         :param direction: Direction of traffic - src/dst.
 134         :param address: IPv4 or IPv6 address.
 135         :type node: dict
 136         :type acl_method: str
 137         :type table_index: int
 138         :type skip_n: int
 139         :type match_n: int
 140         :type ip_version: str
 141         :type direction: str
 142         :type address: str
 143         """
 144         with VatTerminal(node) as vat:
 145             vat.vat_terminal_exec_cmd_from_template("classify_add_session.vat",
 146                                                     acl_method=acl_method,
 147                                                     table_index=table_index,
 148                                                     skip_n=skip_n,
 149                                                     match_n=match_n,
 150                                                     ip_version=ip_version,
 151                                                     direction=direction,
 152                                                     address=address)
 153
 154     @staticmethod
 155     def vpp_configures_classify_session_l2(node, acl_method, table_index,
 156                                            skip_n, match_n, direction, address):
 157         """Configuration of classify session for MAC address filtering.
 158
 159         :param node: VPP node to setup classify session.
 160         :param acl_method: ACL method - deny/permit.
 161         :param table_index: Classify table index.
 162         :param skip_n: Number of skip vectors based on mask.
 163         :param match_n: Number of match vectors based on mask.
 164         :param direction: Direction of traffic - src/dst.
 165         :param address: IPv4 or IPv6 address.
 166         :type node: dict
 167         :type acl_method: str
 168         :type table_index: int
 169         :type skip_n: int
 170         :type match_n: int
 171         :type direction: str
 172         :type address: str
 173         """
 174         with VatTerminal(node) as vat:
 175             vat.vat_terminal_exec_cmd_from_template(
 176                 "classify_add_session_l2.vat",
 177                 acl_method=acl_method,
 178                 table_index=table_index,
 179                 skip_n=skip_n,
 180                 match_n=match_n,
 181                 direction=direction,
 182                 address=address)
 183
 184     @staticmethod
 185     def vpp_configures_classify_session_hex(node, acl_method, table_index,
 186                                             skip_n, match_n, hex_value):
 187         """Configuration of classify session with hex value.
 188
 189         :param node: VPP node to setup classify session.
 190         :param acl_method: ACL method - deny/permit.
 191         :param table_index: Classify table index.
 192         :param skip_n: Number of skip vectors based on mask.
 193         :param match_n: Number of match vectors based on mask.
 194         :param hex_value: Classify hex value.
 195         :type node: dict
 196         :type acl_method: str
 197         :type table_index: int
 198         :type skip_n: int
 199         :type match_n: int
 200         :type hex_value: str
 201         """
 202         with VatTerminal(node) as vat:
 203             vat.vat_terminal_exec_cmd_from_template(
 204                 "classify_add_session_hex.vat",
 205                 acl_method=acl_method,
 206                 table_index=table_index,
 207                 skip_n=skip_n,
 208                 match_n=match_n,
 209                 hex_value=hex_value)
 210
 211     @staticmethod
 212     def vpp_configures_classify_session_generic(node, session_type, table_index,
 213                                                 skip_n, match_n, match,
 214                                                 match2=''):
 215         """Configuration of classify session.
 216
 217         :param node: VPP node to setup classify session.
 218         :param session_type: Session type - hit-next, l2-hit-next, acl-hit-next
 219         or policer-hit-next, and their respective parameters.
 220         :param table_index: Classify table index.
 221         :param skip_n: Number of skip vectors based on mask.
 222         :param match_n: Number of match vectors based on mask.
 223         :param match: Match value - l2, l3, l4 or hex, and their
 224         respective parameters.
 225         :param match2: Additional match values, to avoid using overly long
 226         variables in RobotFramework.
 227         :type node: dict
 228         :type session_type: str
 229         :type table_index: int
 230         :type skip_n: int
 231         :type match_n: int
 232         :type match: str
 233         :type match2: str
 234         """
 235
 236         match = ' '.join((match, match2))
 237
 238         with VatTerminal(node) as vat:
 239             vat.vat_terminal_exec_cmd_from_template(
 240                 "classify_add_session_generic.vat",
 241                 type=session_type,
 242                 table_index=table_index,
 243                 skip_n=skip_n,
 244                 match_n=match_n,
 245                 match=match,
 246             )
 247
 248     @staticmethod
 249     def compute_classify_hex_mask(ip_version, protocol, direction):
 250         """Compute classify hex mask for TCP or UDP packet matching.
 251
 252         :param ip_version: Version of IP protocol.
 253         :param protocol: Type of protocol.
 254         :param direction: Traffic direction.
 255         :type ip_version: str
 256         :type protocol: str
 257         :type direction: str
 258         :returns: Classify hex mask.
 259         :rtype : str
 260         :raises ValueError: If protocol is not TCP or UDP.
 261         :raises ValueError: If direction is not source or destination or
 262                             source + destination.
 263         """
 264         if protocol == 'TCP' or protocol == 'UDP':
 265             base_mask = Classify._compute_base_mask(ip_version)
 266
 267             if direction == 'source':
 268                 return base_mask + 'FFFF0000'
 269             elif direction == 'destination':
 270                 return base_mask + '0000FFFF'
 271             elif direction == 'source + destination':
 272                 return base_mask + 'FFFFFFFF'
 273             else:
 274                 raise ValueError("Invalid direction!")
 275         else:
 276             raise ValueError("Invalid protocol!")
 277
 278     @staticmethod
 279     def compute_classify_hex_value(hex_mask, source_port, destination_port):
 280         """Compute classify hex value for TCP or UDP packet matching.
 281
 282         :param hex_mask: Classify hex mask.
 283         :param source_port: Source TCP/UDP port.
 284         :param destination_port: Destination TCP/UDP port.
 285         :type hex_mask: str
 286         :type source_port: str
 287         :type destination_port: str
 288         :returns: Classify hex value.
 289         :rtype: str
 290         """
 291         source_port_hex = Classify._port_convert(source_port)
 292         destination_port_hex = Classify._port_convert(destination_port)
 293
 294         return hex_mask[:-8] + source_port_hex + destination_port_hex
 295
 296     @staticmethod
 297     def _port_convert(port):
 298         """Convert port number for classify hex table format.
 299
 300         :param port: TCP/UDP port number.
 301         :type port: str
 302         :returns: TCP/UDP port number in 4-digit hexadecimal format.
 303         :rtype: str
 304         """
 305         return '{0:04x}'.format(int(port))
 306
 307     @staticmethod
 308     def _compute_base_mask(ip_version):
 309         """Compute base classify hex mask based on IP version.
 310
 311         :param ip_version: Version of IP protocol.
 312         :type ip_version: str
 313         :return: Base hex mask.
 314         :rtype: str
 315         """
 316         if ip_version == 'ip4':
 317             return 68 * '0'
 318             # base value of classify hex table for IPv4 TCP/UDP ports
 319         elif ip_version == 'ip6':
 320             return 108 * '0'
 321             # base value of classify hex table for IPv6 TCP/UDP ports
 322         else:
 323             raise ValueError("Invalid IP version!")
 324
 325     @staticmethod
 326     def get_classify_table_data(node, table_index):
 327         """Retrieve settings for classify table by ID.
 328
 329         :param node: VPP node to retrieve classify data from.
 330         :param table_index: Index of a specific classify table.
 331         :type node: dict
 332         :type table_index: int
 333         :returns: Classify table settings.
 334         :rtype: dict
 335         """
 336         with VatTerminal(node) as vat:
 337             data = vat.vat_terminal_exec_cmd_from_template(
 338                 "classify_table_info.vat",
 339                 table_id=table_index
 340             )
 341         return data[0]
 342
 343     @staticmethod
 344     def get_classify_session_data(node, table_index, session_index=None):
 345         """Retrieve settings for all classify sessions in a table,
 346         or for a specific classify session.
 347
 348         :param node: VPP node to retrieve classify data from.
 349         :param table_index: Index of a classify table.
 350         :param session_index: Index of a specific classify session. (Optional)
 351         :type node: dict
 352         :type table_index: int
 353         :type session_index: int
 354         :returns: List of classify session settings, or a dictionary of settings
 355          for a specific classify session.
 356         :rtype: list or dict
 357         """
 358         with VatTerminal(node) as vat:
 359             data = vat.vat_terminal_exec_cmd_from_template(
 360                 "classify_session_dump.vat",
 361                 table_id=table_index
 362             )
 363         if session_index is not None:
 364             return data[0][session_index]
 365         else:
 366             return data[0]
 367
 368     @staticmethod
 369     def vpp_log_plugin_acl_settings(node):
 370         """Retrieve configured settings from the ACL plugin
 371          and write to robot log.
 372
 373         :param node: VPP node.
 374         :type node: dict
 375         """
 376         try:
 377             VatExecutor.cmd_from_template(
 378                 node, "acl_plugin/acl_dump.vat")
 379         except (ValueError, RuntimeError):
 380             # Fails to parse JSON data in response, but it is still logged
 381             pass
 382
 383     @staticmethod
 384     def vpp_log_plugin_acl_interface_assignment(node):
 385         """Retrieve interface assignment from the ACL plugin
 386         and write to robot log.
 387
 388         :param node: VPP node.
 389         :type node: dict
 390         """
 391         try:
 392             VatExecutor.cmd_from_template(
 393                 node, "acl_plugin/acl_interface_dump.vat", json_out=False)
 394         except RuntimeError:
 395             # Fails to parse response, but it is still logged
 396             pass
 397
 398     @staticmethod
 399     def set_acl_list_for_interface(node, interface, acl_type, acl_idx=None):
 400         """Set the list of input or output ACLs applied to the interface. It
 401         unapplies any previously applied ACLs.
 402
 403         :param node: VPP node to set ACL on.
 404         :param interface: Interface name or sw_if_index.
 405         :param acl_type: Type of ACL(s) - input or output.
 406         :param acl_idx: Index(ies) of ACLs to be applied on the interface.
 407         :type node: dict
 408         :type interface: str or int
 409         :type acl_type: str
 410         :type acl_idx: list
 411         :raises RuntimeError: If unable to set ACL list for the interface.
 412         """
 413         if isinstance(interface, basestring):
 414             sw_if_index = Topology.get_interface_sw_index(node, interface)
 415         else:
 416             sw_if_index = interface
 417
 418         acl_list = acl_type + ' ' + ' '.join(str(idx) for idx in acl_idx) \
 419             if acl_idx else acl_type
 420
 421         try:
 422             with VatTerminal(node, json_param=False) as vat:
 423                 vat.vat_terminal_exec_cmd_from_template(
 424                     "acl_plugin/acl_interface_set_acl_list.vat",
 425                     interface=sw_if_index, acl_list=acl_list)
 426         except RuntimeError:
 427             raise RuntimeError("Setting of ACL list for interface {0} failed "
 428                                "on node {1}".format(interface, node['host']))
 429
 430     @staticmethod
 431     def add_replace_acl(node, acl_idx=None, ip_ver="ipv4", action="permit",
 432                         src=None, dst=None, sport=None, dport=None, proto=None,
 433                         tcpflg_val=None, tcpflg_mask=None):
 434         """Add a new ACL or replace the existing one. To replace an existing
 435         ACL, pass the ID of this ACL.
 436
 437         :param node: VPP node to set ACL on.
 438         :param acl_idx: ID of ACL. (Optional)
 439         :param ip_ver: IP version. (Optional)
 440         :param action: ACL action. (Optional)
 441         :param src: Source IP in format IP/plen. (Optional)
 442         :param dst: Destination IP in format IP/plen. (Optional)
 443         :param sport: Source port or ICMP4/6 type - range format X-Y allowed.
 444          (Optional)
 445         :param dport: Destination port or ICMP4/6 code - range format X-Y
 446          allowed. (Optional)
 447         :param proto: L4 protocol (http://www.iana.org/assignments/protocol-
 448          numbers/protocol-numbers.xhtml). (Optional)
 449         :param tcpflg_val: TCP flags value. (Optional)
 450         :param tcpflg_mask: TCP flags mask. (Optional)
 451         :type node: dict
 452         :type acl_idx: int
 453         :type ip_ver: str
 454         :type action: str
 455         :type src: str
 456         :type dst: str
 457         :type sport: str or int
 458         :type dport: str or int
 459         :type proto: int
 460         :type tcpflg_val: int
 461         :type tcpflg_mask: int
 462         :raises RuntimeError: If unable to add or replace ACL.
 463         """
 464         acl_idx = '{0}'.format(acl_idx) if acl_idx else ''
 465
 466         src = 'src {0}'.format(src) if src else ''
 467
 468         dst = 'dst {0}'.format(dst) if dst else ''
 469
 470         sport = 'sport {0}'.format(sport) if sport else ''
 471
 472         dport = 'dport {0}'.format(dport) if dport else ''
 473
 474         proto = 'proto {0}'.format(proto) if proto else ''
 475
 476         tcpflags = 'tcpflags {0} {1}'.format(tcpflg_val, tcpflg_mask) \
 477             if tcpflg_val and tcpflg_mask else ''
 478
 479         try:
 480             with VatTerminal(node, json_param=False) as vat:
 481                 vat.vat_terminal_exec_cmd_from_template(
 482                     "acl_plugin/acl_add_replace.vat", acl_idx=acl_idx,
 483                     ip_ver=ip_ver, action=action, src=src, dst=dst, sport=sport,
 484                     dport=dport, proto=proto, tcpflags=tcpflags)
 485         except RuntimeError:
 486             raise RuntimeError("Adding or replacing of ACL failed on "
 487                                "node {0}".format(node['host']))
 488
 489     @staticmethod
 490     def add_replace_acl_multi_entries(node, acl_idx=None, rules=None):
 491         """Add a new ACL or replace the existing one. To replace an existing
 492         ACL, pass the ID of this ACL.
 493
 494         :param node: VPP node to set ACL on.
 495         :param acl_idx: ID of ACL. (Optional)
 496         :param rules: Required rules. (Optional)
 497         :type node: dict
 498         :type acl_idx: int
 499         :type rules: str
 500         :raises RuntimeError: If unable to add or replace ACL.
 501         """
 502         acl_idx = '{0}'.format(acl_idx) if acl_idx else ''
 503
 504         rules = '{0}'.format(rules) if rules else ''
 505
 506         try:
 507             with VatTerminal(node, json_param=False) as vat:
 508                 vat.vat_terminal_exec_cmd_from_template(
 509                     "acl_plugin/acl_add_replace.vat", acl_idx=acl_idx,
 510                     ip_ver=rules, action='', src='', dst='', sport='',
 511                     dport='', proto='', tcpflags='')
 512         except RuntimeError:
 513             raise RuntimeError("Adding or replacing of ACL failed on "
 514                                "node {0}".format(node['host']))
 515
 516     @staticmethod
 517     def delete_acl(node, idx):
 518         """Delete required ACL.
 519
 520         :param node: VPP node to delete ACL on.
 521         :param idx: Index of ACL to be deleted.
 522         :type node: dict
 523         :type idx: int or str
 524         :raises RuntimeError: If unable to delete ACL.
 525         """
 526         try:
 527             with VatTerminal(node, json_param=False) as vat:
 528                 vat.vat_terminal_exec_cmd_from_template(
 529                     "acl_plugin/acl_delete.vat", idx=idx)
 530         except RuntimeError:
 531             raise RuntimeError("Deletion of ACL failed on node {0}".
 532                                format(node['host']))
 533
 534     @staticmethod
 535     def cli_show_acl(node, acl_idx=None):
 536         """Show ACLs.
 537
 538         :param node: VPP node to show ACL on.
 539         :param acl_idx: Index of ACL to be shown.
 540         :type node: dict
 541         :type acl_idx: int or str
 542         :raises RuntimeError: If unable to delete ACL.
 543         """
 544         acl_idx = '{0}'.format(acl_idx) if acl_idx else ''
 545
 546         try:
 547             with VatTerminal(node, json_param=False) as vat:
 548                 vat.vat_terminal_exec_cmd_from_template(
 549                     "acl_plugin/show_acl.vat", idx=acl_idx)
 550         except RuntimeError:
 551             raise RuntimeError("Failed to show ACL on node {0}".
 552                                format(node['host']))
 553
 554     @staticmethod
 555     def add_macip_acl(node, ip_ver="ipv4", action="permit", src_ip=None,
 556                       src_mac=None, src_mac_mask=None):
 557         """Add a new MACIP ACL.
 558
 559         :param node: VPP node to set MACIP ACL on.
 560         :param ip_ver: IP version. (Optional)
 561         :param action: ACL action. (Optional)
 562         :param src_ip: Source IP in format IP/plen. (Optional)
 563         :param src_mac: Source MAC address in format with colons. (Optional)
 564         :param src_mac_mask: Source MAC address mask in format with colons.
 565          00:00:00:00:00:00 is a wildcard mask. (Optional)
 566         :type node: dict
 567         :type ip_ver: str
 568         :type action: str
 569         :type src_ip: str
 570         :type src_mac: str
 571         :type src_mac_mask: str
 572         :raises RuntimeError: If unable to add MACIP ACL.
 573         """
 574         src_ip = 'ip {0}'.format(src_ip) if src_ip else ''
 575
 576         src_mac = 'mac {0}'.format(src_mac) if src_mac else ''
 577
 578         src_mac_mask = 'mask {0}'.format(src_mac_mask) if src_mac_mask else ''
 579
 580         try:
 581             with VatTerminal(node, json_param=False) as vat:
 582                 vat.vat_terminal_exec_cmd_from_template(
 583                     "acl_plugin/macip_acl_add.vat", ip_ver=ip_ver,
 584                     action=action, src_ip=src_ip, src_mac=src_mac,
 585                     src_mac_mask=src_mac_mask)
 586         except RuntimeError:
 587             raise RuntimeError("Adding of MACIP ACL failed on node {0}".
 588                                format(node['host']))
 589
 590     @staticmethod
 591     def add_macip_acl_multi_entries(node, rules=None):
 592         """Add a new MACIP ACL.
 593
 594         :param node: VPP node to set MACIP ACL on.
 595         :param rules: Required MACIP rules. (Optional)
 596         :type node: dict
 597         :type rules: str
 598         :raises RuntimeError: If unable to add MACIP ACL.
 599         """
 600         rules = '{0}'.format(rules) if rules else ''
 601
 602         try:
 603             with VatTerminal(node, json_param=False) as vat:
 604                 vat.vat_terminal_exec_cmd_from_template(
 605                     "acl_plugin/macip_acl_add.vat", ip_ver=rules, action='',
 606                     src_ip='', src_mac='', src_mac_mask='')
 607         except RuntimeError:
 608             raise RuntimeError("Adding of MACIP ACL failed on node {0}".
 609                                format(node['host']))
 610
 611     @staticmethod
 612     def delete_macip_acl(node, idx):
 613         """Delete required MACIP ACL.
 614
 615         :param node: VPP node to delete MACIP ACL on.
 616         :param idx: Index of ACL to be deleted.
 617         :type node: dict
 618         :type idx: int or str
 619         :raises RuntimeError: If unable to delete MACIP ACL.
 620         """
 621         try:
 622             with VatTerminal(node, json_param=False) as vat:
 623                 vat.vat_terminal_exec_cmd_from_template(
 624                     "acl_plugin/macip_acl_delete.vat", idx=idx)
 625         except RuntimeError:
 626             raise RuntimeError("Deletion of MACIP ACL failed on node {0}".
 627                                format(node['host']))
 628
 629     @staticmethod
 630     def vpp_log_macip_acl_settings(node):
 631         """Retrieve configured MACIP settings from the ACL plugin
 632          and write to robot log.
 633
 634         :param node: VPP node.
 635         :type node: dict
 636         """
 637         try:
 638             VatExecutor.cmd_from_template(
 639                 node, "acl_plugin/macip_acl_dump.vat")
 640         except (ValueError, RuntimeError):
 641             # Fails to parse JSON data in response, but it is still logged
 642             pass
 643
 644     @staticmethod
 645     def add_del_macip_acl_interface(node, interface, action, acl_idx):
 646         """Apply/un-apply the MACIP ACL to/from a given interface.
 647
 648         :param node: VPP node to set MACIP ACL on.
 649         :param interface: Interface name or sw_if_index.
 650         :param action: Required action - add or del.
 651         :param acl_idx: ACL index to be applied on the interface.
 652         :type node: dict
 653         :type interface: str or int
 654         :type action: str
 655         :type acl_idx: str or int
 656         :raises RuntimeError: If unable to set MACIP ACL for the interface.
 657         """
 658         if isinstance(interface, basestring):
 659             sw_if_index = Topology.get_interface_sw_index(node, interface)
 660         else:
 661             sw_if_index = interface
 662
 663         try:
 664             with VatTerminal(node, json_param=False) as vat:
 665                 vat.vat_terminal_exec_cmd_from_template(
 666                     "acl_plugin/macip_acl_interface_add_del.vat",
 667                     sw_if_index=sw_if_index, action=action, acl_idx=acl_idx)
 668         except RuntimeError:
 669             raise RuntimeError("Setting of MACIP ACL index for interface {0} "
 670                                "failed on node {1}".
 671                                format(interface, node['host']))
 672
 673     @staticmethod
 674     def vpp_log_macip_acl_interface_assignment(node):
 675         """Get interface list and associated MACIP ACLs and write to robot log.
 676
 677         :param node: VPP node.
 678         :type node: dict
 679         """
 680         try:
 681             VatExecutor.cmd_from_template(
 682                 node, "acl_plugin/macip_acl_interface_get.vat", json_out=False)
 683         except RuntimeError:
 684             # Fails to parse response, but it is still logged
 685             pass