Broadcast Unknown-multicast and Unknown-unicast Storm-control

config/main.py

@@ -28,6 +28,7 @@
 from utilities_common import bgp_util
 import utilities_common.cli as clicommon
 from utilities_common.general import load_db_config, load_module_from_source
+import utilities_common.multi_asic as multi_asic_util
 
 from .utils import log
 
@@ -637,6 +638,78 @@ 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 clicommon.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
+
+def is_storm_control_supported(storm_type, namespace):
+    asic_id = multi_asic.get_asic_index_from_namespace(namespace)
+    #state_db[asic_id] = swsscommon.DBConnector("STATE_DB", REDIS_TIMEOUT_MSECS, True, namespace)
+    #supported = state_db[asic_id].get_entry('BUM_STORM_CAPABILITY', storm_type)
+    state_db = SonicV2Connector(host='127.0.0.1')
+    state_db.connect(state_db.STATE_DB, False)
+    entry_name="BUM_STORM_CAPABILITY|"+storm_type
+    supported = state_db.get(state_db.STATE_DB, entry_name,"supported")
+    return supported
+
+#API to configure the PORT_STORM_CONTROL table 
+def storm_control_set_entry(port_name, kbps, storm_type, namespace):
+
+    if storm_control_interface_validate(port_name) is False:
+        return False
+
+    if is_storm_control_supported(storm_type, namespace) == 0:
+        click.echo("Storm-control is not supported on this namespace {}".format(namespace))
+        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))
+        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)
+
+    return True
+
 
 def _clear_qos():
     QOS_TABLE_NAMES = [
@@ -5736,6 +5809,45 @@ 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.command('add')
+@click.argument('port_name',metavar='<port_name>', required=True)
+@click.argument('storm_type',metavar='<storm_type>', required=True, type=click.Choice(["broadcast", "unknown-unicast", "unknown-multicast"]))
+@click.argument('kbps',metavar='<kbps_value>', required=True, type=click.IntRange(0,100000000))
+@click.option('--namespace',
+              '-n',
+              'namespace',
+              default=None,
+              type=str,
+              show_default=True,
+              help='Namespace name or all',
+              callback=multi_asic_util.multi_asic_namespace_validation_callback)
+@click.pass_context
+def add_interface_storm(ctx, port_name,storm_type, kbps, namespace):
+    if storm_control_set_entry(port_name, kbps, storm_type, namespace) is False:
+        ctx.fail("Unable to add {} storm-control to interface {}".format(storm_type, port_name))
+
+@storm_control.command('del')
+@click.argument('port_name',metavar='<port_name>', required=True)
+@click.argument('storm_type',metavar='<storm_type>', required=True, type=click.Choice(["broadcast", "unknown-unicast", "unknown-multicast"]))
+@click.option('--namespace',
+              '-n',
+              'namespace',
+              default=None,
+              type=str,
+              show_default=True,
+              help='Namespace name or all',
+              callback=multi_asic_util.multi_asic_namespace_validation_callback)
+@click.pass_context
+def del_interface_storm(ctx,port_name,storm_type, namespace):
+    if storm_control_delete_entry(port_name, storm_type) is False:
+        ctx.fail("Unable to delete {} storm-control from interface {}".format(storm_type, port_name))
+
 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

@@ -147,6 +147,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={