Broadcast Unknown-multicast and Unknown-unicast Storm-control

config/main.py

@@ -632,6 +632,66 @@ def _clear_cbf():
         for cbf_table in CBF_TABLE_NAMES:
             config_db.delete_table(cbf_table)
 
+#API to validate the interface passed for storm-control configuration
+def storm_control_interface_validate(port_name):
+    if get_interface_naming_mode() == "alias":
+        port_name = interface_alias_to_name(None, port_name)
+        if port_name is None:
+            click.echo("'port_name' is None!")
+            return False
+
+    if (port_name.startswith("Ethernet")):
+        if interface_name_is_valid(None, port_name) is False:
+            click.echo("Interface name %s is invalid. Please enter a valid interface name" %(port_name))
+            return False
+    else:
+        click.echo("Storm-control is supported only on Ethernet interfaces. Not supported on %s" %(port_name))
+        return False
+
+    return True
+
+#API to configure the PORT_STORM_CONTROL table 
+def storm_control_set_entry(port_name, kbps, storm_type):
+
+    if storm_control_interface_validate(port_name) is False:
+        return False
+
+    #Validate kbps value
+    config_db = ConfigDBConnector()
+    config_db.connect()
+    key = port_name + '|' + storm_type
+    entry = config_db.get_entry('PORT_STORM_CONTROL', key)
+
+    if len(entry) == 0:
+        config_db.set_entry('PORT_STORM_CONTROL', key, {'kbps':kbps})
+    else:
+        kbps_value = int(entry.get('kbps',0))
+        click.echo("Existing value of kbps %d" %(kbps_value))
+        if kbps_value != kbps:
+            config_db.mod_entry('PORT_STORM_CONTROL', key, {'kbps':kbps})
+
+    return True
+
+#API to remove an entry from PORT_STORM_CONTROL table 
+def storm_control_delete_entry(port_name, storm_type):
+
+    if storm_control_interface_validate(port_name) is False:
+        return False
+
+    config_db = ConfigDBConnector()
+    config_db.connect()
+    key = port_name + '|' + storm_type
+    entry = config_db.get_entry('PORT_STORM_CONTROL', key)
+
+    if len(entry) == 0:
+        click.echo("%s storm-control not enabled on interface %s" %(storm_type, port_name))
+        return False
+    else:
+        config_db.set_entry('PORT_STORM_CONTROL', key, None)
+        click.echo("deleted %s storm-control from interface %s" %(storm_type, port_name))
+
+    return True
+
 
 def _clear_qos():
     QOS_TABLE_NAMES = [
@@ -5324,6 +5384,83 @@ def naming_mode_alias():
     """Set CLI interface naming mode to ALIAS (Vendor port alias)"""
     set_interface_naming_mode('alias')
 
+@interface.group('storm-control')
+@click.pass_context
+def storm_control(ctx):
+    """ Configure storm-control"""
+    pass
+
+@storm_control.group('broadcast')
+def broadcast():
+    """ Configure broadcast storm-control"""
+    pass
+
+@broadcast.command('add')
+@click.argument('port_name', metavar='<port_name>', required=True)
+@click.argument('kbps', metavar='<kbps_value>', required=True, type=click.IntRange(0,100000000))
+@click.pass_context
+def add_broadcast_storm(ctx, port_name, kbps):
+    click.echo("add broadcast storm-control")
+
+    if storm_control_set_entry(port_name, kbps, 'broadcast') is False:
+        ctx.fail("Unable to add broadcast storm-control")
+
+@broadcast.command('del')
+@click.argument('port_name', metavar='<port_name>', required=True)
+@click.pass_context
+def del_broadcast_storm(ctx, port_name):
+    click.echo("del broadcast storm-control")
+
+    if storm_control_delete_entry(port_name, 'broadcast') is False:
+        ctx.fail("Unable to delete broadcast storm-control")
+
+@storm_control.group('unknown-unicast')
+def unknown_unicast():
+    """ Configure unknown-unicast storm-control"""
+    pass
+
+@unknown_unicast.command('add')
+@click.argument('port_name', metavar='<port_name>', required=True)
+@click.argument('kbps', metavar='<kbps_value>', required=True, type=click.IntRange(0,100000000))
+@click.pass_context
+def add_unknown_unicast_storm(ctx, port_name, kbps):
+    click.echo("add unknown-unicast storm-control")
+
+    if storm_control_set_entry(port_name, kbps, 'unknown-unicast') is False:
+        ctx.fail("Unable to add unknown-unicast storm-control")
+
+@unknown_unicast.command('del')
+@click.argument('port_name', metavar='<port_name>', required=True)
+@click.pass_context
+def del_unknown_unicast_storm(ctx, port_name):
+    click.echo("del unknown-unicast storm-control")
+
+    if storm_control_delete_entry(port_name, 'unknown-unicast') is False:
+        ctx.fail("Unable to delete unknown-unicast storm-control")
+
+@storm_control.group('unknown-multicast')
+def unknown_multicast():
+    """ Configure unknown-multicast storm-control"""
+    pass
+
+@unknown_multicast.command('add')
+@click.argument('port_name', metavar='<port_name>', required=True)
+@click.argument('kbps', metavar='<kbps_value>', required=True, type=click.IntRange(0,100000000))
+@click.pass_context
+def add_unknown_multicast_storm(ctx, port_name, kbps):
+    click.echo("add unknown-multicast storm-control")
+
+    if storm_control_set_entry(port_name, kbps, 'unknown-multicast') is False:
+        ctx.fail("Unable to add unknown-multicast storm-control")
+
+@unknown_multicast.command('del')
+@click.argument('port_name', metavar='<port_name>', required=True)
+@click.pass_context
+def del_unknown_multicast_storm(ctx, port_name):
+    click.echo("del unknown-multicast storm-control")
+
+    if storm_control_delete_entry(port_name, 'unknown-multicast') is False:
+        ctx.fail("Unable to delete unknown-multicast storm-control")
 def is_loopback_name_valid(loopback_name):
     """Loopback name validation
     """

scripts/storm_control.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+
+############################################
+#
+# script to test storm_control functionality
+#
+############################################
+
+import argparse
+import sys
+import os
+
+# mock the redis for unit test purposes #
+try:
+    if os.environ["UTILITIES_UNIT_TESTING"] == "2":
+        modules_path = os.path.join(os.path.dirname(__file__), "..")
+        test_path = os.path.join(modules_path, "tests")
+        sys.path.insert(0, modules_path)
+        sys.path.insert(0, test_path)
+        import mock_tables.dbconnector
+
+except KeyError:
+    pass
+
+from natsort import natsorted
+from tabulate import tabulate
+from swsscommon.swsscommon import SonicV2Connector, ConfigDBConnector
+from utilities_common.general import load_db_config
+
+STORM_TABLE_NAME = "PORT_STORM_CONTROL"
+
+class storm_control(object):
+    def __init__(self):
+        self.config_db = ConfigDBConnector()
+        self.config_db.connect()
+        self.db = SonicV2Connector(use_unix_socket_path=False)
+        self.db.connect(self.db.CONFIG_DB)
+    def show_storm_config(self, port):
+        header = ['Interface Name', 'Storm Type', 'Rate (kbps)']
+        storm_type_list = ['broadcast','unknown-unicast','unknown-multicast']
+        body = []
+        configs = self.db.get_table(STORM_TABLE_NAME)
+        if not configs:
+            return
+        storm_configs = natsorted(configs)
+        if port is not None:
+            for storm_type in storm_type_list:
+                storm_key = port + '|' + storm_type
+                data = self.db.get_entry(STORM_TABLE_NAME, storm_key)
+                if data:
+                    kbps = data['kbps']
+                    body.append([port, storm_type, kbps])
+        else:
+            for storm_key in storm_configs:
+                interface_name = storm_key[0]
+                storm_type = storm_key[1]
+                data = self.db.get_entry(STORM_TABLE_NAME, storm_key)
+                if data:
+                    kbps = data['kbps']
+                    body.append([interface_name, storm_type, kbps])
+        print(tabulate(body,header,tablefmt="grid")) 
+
+    def validate_interface(self, port):
+        if not (port.startswith("Eth")):
+            return False
+        return True
+
+    def validate_kbps(self, kbps):
+        return True
+
+    def add_storm_config(self, port, storm_type, kbps):
+        if not validate_interface(port):
+            print ("Invalid Interface:{}".format(port))
+            return False
+        if not validate_kbps(kbps):
+            print ("Invalid kbps value:{}".format(kbps))
+            return False
+        key = port + '|' + storm_type
+        entry = self.db.get_entry(STORM_TABLE_NAME,key)
+        if len(entry) == 0:
+            self.db.set_entry(STORM_TABLE_NAME, key, {'kbps':kbps})
+        else:
+            kbps_value = int(entry.get('kbps',0))
+            if kbps_value != kbps:
+                self.db.mod_entry(STORM_TABLE_NAME, key, {'kbps':kbps})
+        return True
+
+    def del_storm_config(self, port, storm_type):
+        if not validate_interface(port):
+            print ("Invalid Interface:{}".format(port))
+            return False
+        key = port_name + '|' + storm_type
+        entry = self.db.get_entry(STORM_TABLE_NAME, key)
+        if len(entry):
+            self.db.set_entry(STORM_TABLE_NAME, key, None)
+        return True
+
+def main():
+    parser  = argparse.ArgumentParser(description='Configure and Display storm-control configuration',
+                                        formatter_class=argparse.RawTextHelpFormatter)
+    parser.add_argument('-l', '--list', action='store_true', help='show storm-control configuration', default=False)
+    parser.add_argument('-p', '--port', type=str, help='port name (e.g. Ethernet0)', required=True, default=None)
+    parser.add_argument('-t', '--storm-type', type=str, help='storm-type (broadcast, unknown-unicast, unknown-multicast)', required=True, default=None)
+    parser.add_argument('-r', '--rate-kbps', type=int, help='kbps value', required=True, default=None)
+    parser.add_argument('-d', '--delete', help='delete storm-control')
+    parser.add_argument('-f', '--filename', help='file used by mock test', type=str, default=None)
+    args = parser.parse_args()
+
+    # Load database config files
+    load_db_config()
+    try:
+        storm = storm_control()
+        if args.list:
+            input_port=""
+            if args.port:
+                input_port = args.port
+            storm.show_storm_config(input_port)
+        elif args.port and args.storm_type and args.rate_kbps:
+            if args.delete:
+                storm.del_storm_config(args.port, args.storm_type)
+            else:
+                storm.add_storm_config(args.port, args.storm_type, args.rate_kbps)
+        else:
+            parser.print_help()
+            sys.exit(1)
+
+    except Exception as e:
+        try:
+            if os.environ["UTILITIES_UNIT_TESTING"] == "1" or os.environ["UTILITIES_UNIT_TESTING"] == "2":
+                print(str(e), file=sys.stdout)
+        except KeyError:
+            print(str(e), file=sys.stderr)
+
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

setup.py

@@ -144,6 +144,7 @@
         'scripts/null_route_helper',
         'scripts/coredump_gen_handler.py',
         'scripts/techsupport_cleanup.py',
+        'scripts/storm_control.py',
         'scripts/check_db_integrity.py'
     ],
     entry_points={

show/main.py

@@ -307,6 +307,70 @@ def is_mgmt_vrf_enabled(ctx):
 
     return False
 
+@cli.group('storm-control')
+def storm_control():
+    """ show storm-control """
+    pass
+
+@storm_control.command('all')
+def storm_control_all():
+    """ Show storm-control for all interfaces"""
+
+    header = ['Interface Name', 'Storm Type', 'Rate (kbps)']
+    body = []
+
+    config_db = ConfigDBConnector()
+    config_db.connect()
+
+    table = config_db.get_table('PORT_STORM_CONTROL')
+
+    #To avoid further looping below
+    if not table:
+        return
+
+    sorted_table = natsorted(table)
+
+    for storm_key in sorted_table:
+        interface_name = storm_key[0]
+        storm_type = storm_key[1]
+        #interface_name, storm_type = storm_key.split(':')
+        data = config_db.get_entry('PORT_STORM_CONTROL', storm_key)
+
+        if data:
+            kbps = data['kbps']
+            body.append([interface_name, storm_type, kbps])
+
+    click.echo(tabulate(body, header, tablefmt="grid"))
+
+@storm_control.command('interface')
+@click.argument('interfacename', required=True)
+def storm_control_interface(interfacename):
+    """ Show storm-control for an interface"""
+
+    storm_type_list = ['broadcast','unknown-unicast','unknown-multicast']
+
+    header = ['Interface Name', 'Storm Type', 'Rate (kbps)']
+    body = []
+
+    config_db = ConfigDBConnector()
+    config_db.connect()
+
+    table = config_db.get_table('PORT_STORM_CONTROL')
+
+    #To avoid further looping below
+    if not table:
+        return
+
+    for storm_type in storm_type_list:
+        storm_key = interfacename + '|' + storm_type
+        data = config_db.get_entry('PORT_STORM_CONTROL', storm_key)
+
+        if data:
+            kbps = data['kbps']
+            body.append([interfacename, storm_type, kbps])
+
+    click.echo(tabulate(body, header, tablefmt="grid"))
+
 #
 # 'mgmt-vrf' group ("show mgmt-vrf ...")
 #

tests/mock_tables/config_db.json

@@ -1529,6 +1529,26 @@
         "nhopself": "0",
         "rrclient": "0"
     },
+    "PORT_STORM_CONTROL": {
+        "Ethernet0|broadcast": {
+            "kbps":"100000"
+        },
+        "Ethernet0|unknown-unicast": {
+            "kbps":"200000"
+        },
+        "Ethernet0|unknown-multicast": {
+            "kbps":"300000"
+        },
+        "Ethernet4|broadcast": {
+            "kbps":"400000"
+        },
+        "Ethernet8|unknown-unicast": {
+            "kbps":"500000"
+        },
+        "Ethernet8|unknown-multicast": {
+            "kbps":"600000"
+        }
+    },
     "FLEX_COUNTER_TABLE|QUEUE": {
             "POLL_INTERVAL": "10000",
             "FLEX_COUNTER_STATUS": "enable"