def get_tam_int_ifa_ts_flow_stats(args):
api_response = {}
api = cc.ApiClient()
# connect to COUNTERS_DB
counters_db = ConfigDBConnector()
counters_db.db_connect('COUNTERS_DB')
if len(args) == 1 and args[0] != "all":
path = cc.Path('/restconf/data/sonic-tam-int-ifa-ts:sonic-tam-int-ifa-ts/TAM_INT_IFA_TS_FLOW_TABLE/TAM_INT_IFA_TS_FLOW_TABLE_LIST={name}', name=args[0])
else:
path = cc.Path('/restconf/data/sonic-tam-int-ifa-ts:sonic-tam-int-ifa-ts/TAM_INT_IFA_TS_FLOW_TABLE')
response = api.get(path)
if response.ok():
if response.content:
if len(args) == 1 and args[0] != "all":
api_response = response.content['sonic-tam-int-ifa-ts:TAM_INT_IFA_TS_FLOW_TABLE_LIST']
else:
api_response = response.content['sonic-tam-int-ifa-ts:TAM_INT_IFA_TS_FLOW_TABLE']['TAM_INT_IFA_TS_FLOW_TABLE_LIST']
for i in range(len(api_response)):
api_response[i]['Packets'] = 0
api_response[i]['Bytes'] = 0
if "acl-table-name" not in api_response[i] and "acl-rule-name" not in api_response[i]:
return
acl_counter_key = 'COUNTERS:' + api_response[i]['acl-table-name'] + ':' + api_response[i]['acl-rule-name']
flow_stats = counters_db.get_all(counters_db.COUNTERS_DB, acl_counter_key)
if flow_stats is not None:
api_response[i]['Packets'] = flow_stats['Packets']
api_response[i]['Bytes'] = flow_stats['Bytes']
show_cli_output("show_tam_int_ifa_ts_flow_stats.j2", api_response)
def tunnel():
"""Show vxlan tunnel information"""
config_db = ConfigDBConnector()
config_db.connect()
header = ['vxlan tunnel name', 'source ip', 'destination ip', 'tunnel map name', 'tunnel map mapping(vni -> vlan)']
# Fetching data from config_db for VXLAN TUNNEL
vxlan_data = config_db.get_table('VXLAN_TUNNEL')
vxlan_keys = natsorted(list(vxlan_data.keys()))
table = []
for k in vxlan_keys:
r = []
r.append(k)
r.append(vxlan_data[k].get('src_ip'))
r.append(vxlan_data[k].get('dst_ip'))
vxlan_map_keys = config_db.keys(config_db.CONFIG_DB,
'VXLAN_TUNNEL_MAP{}{}{}*'.format(config_db.KEY_SEPARATOR, k, config_db.KEY_SEPARATOR))
if vxlan_map_keys:
vxlan_map_mapping = config_db.get_all(config_db.CONFIG_DB, vxlan_map_keys[0])
r.append(vxlan_map_keys[0].split(config_db.KEY_SEPARATOR, 2)[2])
r.append("{} -> {}".format(vxlan_map_mapping.get('vni'), vxlan_map_mapping.get('vlan')))
table.append(r)
click.echo(tabulate(table, header))
class DropMon(object):
def __init__(self):
# connect CONFIG DB
self.config_db = ConfigDBConnector()
self.config_db.connect()
# connect COUNTERS_DB
self.counters_db = ConfigDBConnector()
self.counters_db.db_connect('COUNTERS_DB')
# connect APPL DB
self.app_db = ConfigDBConnector()
self.app_db.db_connect('APPL_DB')
def config_drop_mon(self, args):
self.config_db.mod_entry(
TAM_DROP_MONITOR_FLOW_TABLE, args.flowname, {
'acl-table': args.acl_table,
'acl-rule': args.acl_rule,
'collector': args.dropcollector,
'sample': args.dropsample
})
return
def config_drop_mon_aging(self, args):
self.config_db.mod_entry(TAM_DROP_MONITOR_AGING_INTERVAL_TABLE,
"aging",
{'aging-interval': args.aginginterval})
return
def config_drop_mon_sample(self, args):
self.config_db.mod_entry(SAMPLE_RATE_TABLE, args.samplename,
{'sampling-rate': args.rate})
return
def clear_single_drop_mon_flow(self, key):
entry = self.config_db.get_entry(TAM_DROP_MONITOR_FLOW_TABLE, key)
if entry:
self.config_db.set_entry(TAM_DROP_MONITOR_FLOW_TABLE, key, None)
else:
return False
return
def clear_drop_mon_flow(self, args):
key = args.flowname
if key == "all":
# Get all the flow keys
table_data = self.config_db.get_keys(TAM_DROP_MONITOR_FLOW_TABLE)
if not table_data:
return True
# Clear each flow key
for key in table_data:
self.clear_single_drop_mon_flow(key)
else:
# Clear the specified flow entry
self.clear_single_drop_mon_flow(key)
return
def clear_drop_mon_sample(self, args):
key = args.samplename
entry = self.config_db.get_entry(SAMPLE_RATE_TABLE, key)
if entry:
self.config_db.set_entry(SAMPLE_RATE_TABLE, key, None)
else:
print "Entry Not Found"
return False
return
def clear_drop_mon_aging_int(self, args):
key = "aging"
entry = self.config_db.get_entry(TAM_DROP_MONITOR_AGING_INTERVAL_TABLE,
key)
if entry:
self.config_db.set_entry(TAM_DROP_MONITOR_AGING_INTERVAL_TABLE,
key, None)
else:
return False
return
def show_flow(self, args):
self.get_print_all_dropmon_flows(args.flowname)
return
def get_dropmon_flow_stat(self, flowname):
api_response_stat = {}
api_response, entryfound = self.get_dropmon_flow_info(flowname)
api_response_stat['flow-name'] = flowname
if entryfound is not None:
for k in api_response:
if k == "ietf-ts:each-flow-data":
acl_rule = api_response['ietf-ts:each-flow-data'][
'acl-rule']
acl_table = api_response['ietf-ts:each-flow-data'][
'acl-table']
api_response_stat['rule-name'] = acl_rule
api_response_stat['table-name'] = acl_table
acl_rule_keys = self.config_db.get_keys(ACL_RULE_TABLE_PREFIX)
for acl_rule_key in acl_rule_keys:
if acl_rule_key[1] == acl_rule:
acl_counter_key = 'COUNTERS:' + acl_rule_key[
0] + ':' + acl_rule_key[1]
raw_dropmon_stats = self.counters_db.get_all(
self.counters_db.COUNTERS_DB, acl_counter_key)
api_response_stat['ietf-ts:dropmon-stats'] = raw_ifa_stats
return api_response_stat, entryfound
def get_print_all_dropmon_stats(self, name):
stat_dict = {}
stat_list = []
if name != 'all':
api_response, entryfound = self.get_dropmon_flow_stat(name)
if entryfound is not None:
stat_list.append(api_response)
else:
table_data = self.config_db.get_keys(TAM_DROP_MONITOR_FLOW_TABLE)
# Get data for all keys
for k in table_data:
api_each_stat_response, entryfound = self.get_dropmon_flow_stat(
k)
if entryfound is not None:
stat_list.append(api_each_stat_response)
stat_dict['stat-list'] = stat_list
show_cli_output("show_statistics_flow.j2", stat_dict)
return
def show_statistics(self, args):
self.get_print_all_dropmon_stats(args.flowname)
return
def show_aging_interval(self, args):
key = "aging"
entry = self.config_db.get_entry(TAM_DROP_MONITOR_AGING_INTERVAL_TABLE,
key)
if entry:
print "Aging interval : {}".format(entry['aging-interval'])
return
def show_sample(self, args):
self.get_print_all_sample(args.samplename)
return
def get_dropmon_flow_info(self, k):
flow_data = {}
flow_data['acl-table-name'] = ''
flow_data['sampling-rate'] = ''
flow_data['collector'] = ''
api_response = {}
key = TAM_DROP_MONITOR_FLOW_TABLE + '|' + k
raw_flow_data = self.config_db.get_all(self.config_db.CONFIG_DB, key)
if raw_flow_data:
sample = raw_flow_data['sample']
rate = self.config_db.get_entry(SAMPLE_RATE_TABLE, sample)
raw_flow_data['sample'] = rate['sampling-rate']
api_response['ietf-ts:flow-key'] = k
api_response['ietf-ts:each-flow-data'] = raw_flow_data
return api_response, raw_flow_data
def get_print_all_dropmon_flows(self, name):
flow_dict = {}
flow_list = []
if name != 'all':
api_response, entryfound = self.get_dropmon_flow_info(name)
if entryfound is not None:
flow_list.append(api_response)
else:
table_data = self.config_db.get_keys(TAM_DROP_MONITOR_FLOW_TABLE)
# Get data for all keys
for k in table_data:
api_each_flow_response, entryfound = self.get_dropmon_flow_info(
k)
if entryfound is not None:
flow_list.append(api_each_flow_response)
flow_dict['flow-list'] = flow_list
show_cli_output("show_drop_monitor_flow.j2", flow_dict)
return
def get_sample_info(self, k):
sample_data = {}
sample_data['sampling-rate'] = ''
api_response = {}
key = SAMPLE_RATE_TABLE + '|' + k
raw_sample_data = self.config_db.get_all(self.config_db.CONFIG_DB, key)
api_response['ietf-ts:sample-key'] = k
api_response['ietf-ts:each-sample-data'] = raw_sample_data
return api_response, raw_sample_data
def get_print_all_sample(self, name):
sample_dict = {}
sample_list = []
if name != 'all':
api_response, entryfound = self.get_sample_info(name)
if entryfound is not None:
sample_list.append(api_response)
else:
table_data = self.config_db.get_keys(SAMPLE_RATE_TABLE)
# Get data for all keys
for k in table_data:
api_each_flow_response, entryfound = self.get_sample_info(k)
if entryfound is not None:
sample_list.append(api_each_flow_response)
sample_dict['sample-list'] = sample_list
show_cli_output("show_sample.j2", sample_dict)
return
class Ts(object):
def __init__(self):
# connect CONFIG DB
self.config_db = ConfigDBConnector()
self.config_db.connect()
# connect COUNTER DB
self.counters_db = ConfigDBConnector()
self.counters_db.db_connect('COUNTERS_DB')
# connect APPL DB
self.app_db = ConfigDBConnector()
self.app_db.db_connect('APPL_DB')
def config_enable(self, args):
""" Enable ifa """
key = 'feature'
self.config_db.set_entry(TAM_INT_IFA_TS_FEATURE_TABLE_PREFIX, key,
{'enable': "true"})
print "Enabled IFA"
return
def config_disable(self, args):
""" Disable ifa """
key = 'feature'
self.config_db.set_entry(TAM_INT_IFA_TS_FEATURE_TABLE_PREFIX, key,
{'enable': "false"})
print "Disabled IFA"
return
def config_flow(self, args):
key = TAM_INT_IFA_FLOW_TS_TABLE_PREFIX + '|' + args.flowname
entry = self.config_db.get_all(self.config_db.CONFIG_DB, key)
if entry is None:
if args.acl_table_name:
self.config_db.mod_entry(
TAM_INT_IFA_FLOW_TS_TABLE_PREFIX, args.flowname,
{'acl-table-name': args.acl_table_name})
if args.acl_rule_name:
self.config_db.mod_entry(TAM_INT_IFA_FLOW_TS_TABLE_PREFIX,
args.flowname,
{'acl-rule-name': args.acl_rule_name})
else:
print "Entry Already Exists"
return False
return
def clear_each_flow(self, flowname):
entry = self.config_db.get_entry(TAM_INT_IFA_FLOW_TS_TABLE_PREFIX,
flowname)
if entry:
self.config_db.set_entry(TAM_INT_IFA_FLOW_TS_TABLE_PREFIX,
flowname, None)
else:
print "Entry Not Found"
return False
return
def clear_flow(self, args):
key = args.flowname
if key == "all":
# Get all the flow keys
table_data = self.config_db.get_keys(
TAM_INT_IFA_FLOW_TS_TABLE_PREFIX)
if not table_data:
return True
# Clear each flow key
for key in table_data:
self.clear_each_flow(key)
else:
# Clear the specified flow entry
self.clear_each_flow(key)
return
def show_flow(self, args):
self.get_print_all_ifa_flows(args.flowname)
return
def show_status(self):
# Get data for all keys
flowtable_keys = self.config_db.get_keys(
TAM_INT_IFA_FLOW_TS_TABLE_PREFIX)
api_response = {}
key = TAM_INT_IFA_TS_FEATURE_TABLE_PREFIX + '|' + 'feature'
raw_data_feature = self.config_db.get_all(self.config_db.CONFIG_DB,
key)
api_response['ietf-ts:feature-data'] = raw_data_feature
api_inner_response = {}
api_inner_response["num-of-flows"] = len(flowtable_keys)
api_response['ietf-ts:num-of-flows'] = api_inner_response
key = TAM_DEVICE_TABLE_PREFIX + '|' + 'device'
raw_data_device = self.config_db.get_all(self.config_db.CONFIG_DB, key)
api_response['ietf-ts:device-data'] = raw_data_device
show_cli_output("show_status.j2", api_response)
return
def get_ifa_flow_stat(self, flowname):
api_response_stat = {}
api_response, entryfound = self.get_ifa_flow_info(flowname)
api_response_stat['flow-name'] = flowname
if entryfound is not None:
for k in api_response:
if k == "ietf-ts:each-flow-data":
acl_rule_name = api_response['ietf-ts:each-flow-data'][
'acl-rule-name']
acl_table_name = api_response['ietf-ts:each-flow-data'][
'acl-table-name']
api_response_stat['rule-name'] = acl_rule_name
api_response_stat['table-name'] = acl_table_name
acl_rule_keys = self.config_db.get_keys(ACL_RULE_TABLE_PREFIX)
for acl_rule_key in acl_rule_keys:
if acl_rule_key[1] == acl_rule_name:
acl_counter_key = 'COUNTERS:' + acl_rule_key[
0] + ':' + acl_rule_key[1]
raw_ifa_stats = self.counters_db.get_all(
self.counters_db.COUNTERS_DB, acl_counter_key)
api_response_stat['ietf-ts:ifa-stats'] = raw_ifa_stats
return api_response_stat, entryfound
def get_print_all_ifa_stats(self, name):
stat_dict = {}
stat_list = []
if name != 'all':
api_response, entryfound = self.get_ifa_flow_stat(name)
if entryfound is not None:
stat_list.append(api_response)
else:
table_data = self.config_db.get_keys(
TAM_INT_IFA_FLOW_TS_TABLE_PREFIX)
# Get data for all keys
for k in table_data:
api_each_stat_response, entryfound = self.get_ifa_flow_stat(k)
if entryfound is not None:
stat_list.append(api_each_stat_response)
stat_dict['stat-list'] = stat_list
show_cli_output("show_statistics_flow.j2", stat_dict)
return
def show_statistics(self, args):
self.get_print_all_ifa_stats(args.flowname)
return
def get_ifa_flow_info(self, k):
flow_data = {}
flow_data['acl-table-name'] = ''
flow_data['sampling-rate'] = ''
flow_data['collector'] = ''
api_response = {}
key = TAM_INT_IFA_FLOW_TS_TABLE_PREFIX + '|' + k
raw_flow_data = self.config_db.get_all(self.config_db.CONFIG_DB, key)
api_response['ietf-ts:flow-key'] = k
api_response['ietf-ts:each-flow-data'] = raw_flow_data
return api_response, raw_flow_data
def get_print_all_ifa_flows(self, name):
flow_dict = {}
flow_list = []
if name != 'all':
api_response, entryfound = self.get_ifa_flow_info(name)
if entryfound is not None:
flow_list.append(api_response)
else:
table_data = self.config_db.get_keys(
TAM_INT_IFA_FLOW_TS_TABLE_PREFIX)
# Get data for all keys
for k in table_data:
api_each_flow_response, entryfound = self.get_ifa_flow_info(k)
if entryfound is not None:
flow_list.append(api_each_flow_response)
flow_dict['flow-list'] = flow_list
show_cli_output("show_flow.j2", flow_dict)
return
def get_ifa_supported_info(self):
key = 'TAM_INT_IFA_TS_FEATURE_TABLE|feature'
data = self.config_db.get_all(self.config_db.CONFIG_DB, key)
if data is None:
return
if data['enable'] == "true":
print "TAM INT IFA TS Supported - True"
return True
elif data['enable'] == "false":
print "TAM INT IFA TS Supported - False "
return False
return
def get_ifa_enabled_info(self):
print "In get_ifa_enabled_info"
key = 'SWITCH_TABLE:switch'
data = self.app_db.get(self.app_db.APPL_DB, key, 'ifa_enabled')
if data and data == 'True':
return True
return True
class Tam(object):
def __init__(self):
# connect CONFIG DB
self.config_db = ConfigDBConnector()
self.config_db.connect()
# connect APPL DB
self.app_db = ConfigDBConnector()
self.app_db.db_connect('APPL_DB')
def get_tam_collector_info(self, k):
api_response = {}
key = TAM_COLLECTOR_TABLE_PREFIX + '|' + k
raw_coll_data = self.config_db.get_all(self.config_db.CONFIG_DB, key)
api_response['coll-key'] = k
api_response['each-coll-data'] = raw_coll_data
return api_response, raw_coll_data
def get_print_all_tam_collectors(self, name):
coll_dict = {}
coll_list = []
if name != 'all':
api_response, entryfound = self.get_tam_collector_info(name)
if entryfound is not None:
coll_list.append(api_response)
else:
table_data = self.config_db.get_keys(TAM_COLLECTOR_TABLE_PREFIX)
# Get data for all keys
for k in table_data:
api_each_flow_response, entryfound = self.get_tam_collector_info(
k)
if entryfound is not None:
coll_list.append(api_each_flow_response)
coll_dict['flow-list'] = coll_list
show_cli_output("show_collector.j2", coll_dict)
return
def config_device_id(self, args):
key = 'device'
entry = self.config_db.get_entry(TAM_DEVICE_TABLE_PREFIX, key)
if entry is None:
if args.deviceid:
self.config_db.set_entry(TAM_DEVICE_TABLE_PREFIX, key,
{'deviceid': args.deviceid})
else:
if args.deviceid:
entry_value = entry.get('deviceid', [])
if entry_value != args.deviceid:
self.config_db.mod_entry(TAM_DEVICE_TABLE_PREFIX, key,
{'deviceid': args.deviceid})
return
def config_collector(self, args):
if args.iptype == 'ipv4':
if args.ipaddr == "0.0.0.0":
print "Collector IP should be non-zero ip address"
return False
if args.iptype == 'ipv6':
print "IPv6 Collector type not supported"
return False
self.config_db.mod_entry(
TAM_COLLECTOR_TABLE_PREFIX, args.collectorname, {
'ipaddress-type': args.iptype,
'ipaddress': args.ipaddr,
'port': args.port
})
return
def clear_device_id(self):
key = 'device'
entry = self.config_db.get_entry(TAM_DEVICE_TABLE_PREFIX, key)
if entry:
self.config_db.set_entry(TAM_DEVICE_TABLE_PREFIX, key, None)
return
def clear_collector(self, args):
key = args.collectorname
entry = self.config_db.get_entry(TAM_COLLECTOR_TABLE_PREFIX, key)
if entry:
self.config_db.set_entry(TAM_COLLECTOR_TABLE_PREFIX, key, None)
else:
print "Entry Not Found"
return False
return
def show_device_id(self):
key = TAM_DEVICE_TABLE_PREFIX + '|' + 'device'
data = self.config_db.get_all(self.config_db.CONFIG_DB, key)
print "TAM Device identifier"
print "-------------------------------"
if data:
if 'deviceid' in data:
print "Device Identifier - ", data['deviceid']
return
def show_collector(self, args):
self.get_print_all_tam_collectors(args.collectorname)
return