def getAllLines():
config_db = ConfigDBConnector()
config_db.connect()
# Querying CONFIG_DB to get configured console ports
keys = config_db.get_keys(CONSOLE_PORT_TABLE)
lines = []
for k in keys:
line = config_db.get_entry(CONSOLE_PORT_TABLE, k)
line[LINE_KEY] = k
lines.append(line)
# Querying device directory to get all available console ports
cmd = "ls " + DEVICE_PREFIX + "*"
output = run_command(cmd)
availableTtys = output.split('\n')
availableTtys = list(
filter(lambda dev: re.match(DEVICE_PREFIX + r"\d+", dev) != None,
availableTtys))
for tty in availableTtys:
k = tty[len(DEVICE_PREFIX):]
if k not in keys:
line = {LINE_KEY: k}
lines.append(line)
return lines
def threshold(ctx, port_name, queue_index, queue_type):
""" Clear queue threshold for a queue on a port """
# If no params are provided, clear all priority-group entries.
config_db = ConfigDBConnector()
config_db.connect()
all = False
if port_name is None and queue_index is None and queue_type is None:
# clear all entries.
key = 'queue'
all = True
elif port_name is None or queue_index is None or queue_type is None:
ctx.fail(
"port_name, queue_index and queue_type are mandatory parameters.")
else:
if queue_index not in range(0, 8):
ctx.fail("queue index must be in range 0-7")
if interface_name_is_valid(port_name) is False:
ctx.fail("Interface name is invalid!!")
key = 'queue' + '|' + queue_type + '|' + port_name + '|' + str(
queue_index)
if all is True:
entry_table = config_db.get_keys('THRESHOLD_TABLE')
# Clear data for all keys
for k in natsorted(entry_table):
if k[0] == 'queue':
config_db.set_entry('THRESHOLD_TABLE', k, None)
else:
entry = config_db.get_entry('THRESHOLD_TABLE', key)
if entry:
config_db.set_entry('THRESHOLD_TABLE', key, None)
def get_route_entries():
db = ConfigDBConnector()
db.db_connect('ASIC_DB')
print_message(MODE_DEBUG, "ASIC DB connected")
keys = db.get_keys('ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY', False)
print_message(MODE_DEBUG, json.dumps({"ASIC_ROUTE_ENTRY": keys}, indent=4))
rt = []
for k in keys:
rt.append(k.split("\"", -1)[3])
return sorted(rt)
def get_route_entries():
db = ConfigDBConnector()
db.db_connect('ASIC_DB')
print_message(MODE_DEBUG, "ASIC DB connected")
keys = db.get_keys('ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY', False)
print_message(MODE_DEBUG, json.dumps({"ASIC_ROUTE_ENTRY": keys}, indent=4))
rt = []
for k in keys:
rt.append(k.split("\"", -1)[3])
return sorted(rt)
def get_route_entries():
db = ConfigDBConnector()
db.db_connect('ASIC_DB')
print_message(syslog.LOG_DEBUG, "ASIC DB connected")
keys = db.get_keys('ASIC_STATE:SAI_OBJECT_TYPE_ROUTE_ENTRY', False)
rt = []
for k in keys:
e = k.lower().split("\"", -1)[3]
if not is_local(e):
rt.append(e)
print_message(syslog.LOG_DEBUG, json.dumps({"ASIC_ROUTE_ENTRY": sorted(rt)}, indent=4))
return sorted(rt)
def get_routes():
db = ConfigDBConnector()
db.db_connect('APPL_DB')
print_message(syslog.LOG_DEBUG, "APPL DB connected for routes")
keys = db.get_keys('ROUTE_TABLE')
valid_rt = []
for k in keys:
if not is_local(k):
valid_rt.append(add_prefix_ifnot(k.lower()))
print_message(syslog.LOG_DEBUG, json.dumps({"ROUTE_TABLE": sorted(valid_rt)}, indent=4))
return sorted(valid_rt)
def get_routes():
db = ConfigDBConnector()
db.db_connect('APPL_DB')
print_message(MODE_DEBUG, "APPL DB connected for routes")
keys = db.get_keys('ROUTE_TABLE')
print_message(MODE_DEBUG, json.dumps({"ROUTE_TABLE": keys}, indent=4))
valid_rt = []
skip_rt = []
for k in keys:
if db.get_entry('ROUTE_TABLE', k)['nexthop'] != '':
valid_rt.append(add_prefix_ifnot(k))
else:
skip_rt.append(k)
print_message(MODE_INFO, json.dumps({"skipped_routes" : skip_rt}, indent=4))
return sorted(valid_rt)
def get_routes():
db = ConfigDBConnector()
db.db_connect('APPL_DB')
print_message(MODE_DEBUG, "APPL DB connected for routes")
keys = db.get_keys('ROUTE_TABLE')
print_message(MODE_DEBUG, json.dumps({"ROUTE_TABLE": keys}, indent=4))
valid_rt = []
skip_rt = []
for k in keys:
if db.get_entry('ROUTE_TABLE', k)['nexthop'] != '':
valid_rt.append(add_prefix_ifnot(k))
else:
skip_rt.append(k)
print_message(MODE_INFO, json.dumps({"skipped_routes": skip_rt}, indent=4))
return sorted(valid_rt)
def get_interfaces():
db = ConfigDBConnector()
db.db_connect('APPL_DB')
print_message(MODE_DEBUG, "APPL DB connected for interfaces")
intf = []
keys = db.get_keys('INTF_TABLE')
print_message(MODE_DEBUG, json.dumps({"APPL_DB_INTF": keys}, indent=4))
for k in keys:
subk = k.split(':', -1)
alias = subk[0]
ip_prefix = ":".join(subk[1:])
ip = add_prefix(ip_prefix.split("/", -1)[0])
if (subk[0] == "eth0") or (subk[0] == "docker0"):
continue
if (subk[0] != "lo"):
intf.append(ip_subnet(ip_prefix))
intf.append(ip)
return sorted(intf)
def get_interfaces():
db = ConfigDBConnector()
db.db_connect('APPL_DB')
print_message(MODE_DEBUG, "APPL DB connected for interfaces")
intf = []
keys = db.get_keys('INTF_TABLE')
print_message(MODE_DEBUG, json.dumps({"APPL_DB_INTF": keys}, indent=4))
for k in keys:
subk = k.split(':', -1)
alias = subk[0]
ip_prefix = ":".join(subk[1:])
ip = add_prefix(ip_prefix.split("/", -1)[0])
if (subk[0] == "eth0") or (subk[0] == "docker0"):
continue
if (subk[0] != "lo"):
intf.append(ip_subnet(ip_prefix))
intf.append(ip)
return sorted(intf)
def get_interfaces():
db = ConfigDBConnector()
db.db_connect('APPL_DB')
print_message(syslog.LOG_DEBUG, "APPL DB connected for interfaces")
intf = []
keys = db.get_keys('INTF_TABLE')
for k in keys:
lst = re.split(':', k.lower(), maxsplit=1)
if len(lst) == 1:
# No IP address in key; ignore
continue
ip = add_prefix(lst[1].split("/", -1)[0])
if not is_local(ip):
intf.append(ip)
print_message(syslog.LOG_DEBUG, json.dumps({"APPL_DB_INTF": sorted(intf)}, indent=4))
return sorted(intf)
class TunnelPacketHandler(object):
def __init__(self):
self.config_db = ConfigDBConnector()
self.config_db.connect()
self.state_db = SonicV2Connector()
self.state_db.connect(STATE_DB)
self._portchannel_intfs = None
self.up_portchannels = None
self.netlink_api = IPRoute()
@property
def portchannel_intfs(self):
"""
Gets all portchannel interfaces and IPv4 addresses in config DB
Returns:
(list) Tuples of a portchannel interface name (str) and
associated IPv4 address (str)
"""
if self._portchannel_intfs is None:
intf_keys = self.config_db.get_keys(PORTCHANNEL_INTERFACE_TABLE)
portchannel_intfs = []
for key in intf_keys:
if isinstance(key, tuple) and len(key) > 1:
if ip_interface(key[1]).version == 4:
portchannel_intfs.append(key)
self._portchannel_intfs = portchannel_intfs
return self._portchannel_intfs
def get_portchannel_index_mapping(self):
"""
Gets a mapping of interface kernel indices to portchannel interfaces
Returns:
(list) integers representing kernel indices
"""
index_map = {}
for portchannel in self.portchannel_intfs:
index = self.netlink_api.link_lookup(ifname=portchannel[0])[0]
index_map[index] = portchannel
return index_map
def get_up_portchannels(self):
"""
Returns the portchannels which are operationally up
Returns:
(list) of interface names which are up, as strings
"""
pc_index_map = self.get_portchannel_index_mapping()
pc_indices = list(pc_index_map.keys())
link_statuses = self.netlink_api.get_links(*pc_indices)
up_portchannels = []
for status in link_statuses:
if status['state'] == 'up':
port_index = status['index']
up_portchannels.append(pc_index_map[port_index][0])
return up_portchannels
def all_portchannels_established(self):
"""
Checks if the portchannel interfaces are established
Note that this status does not indicate operational state
Returns:
(bool) True, if all interfaces are established
False, otherwise
"""
intfs = self.portchannel_intfs
for intf in intfs:
intf_table_name = INTF_TABLE_TEMPLATE.format(intf[0], intf[1])
intf_state = self.state_db.get(
STATE_DB,
intf_table_name,
STATE_KEY
)
if intf_state and intf_state.lower() != 'ok':
return False
return True
def wait_for_portchannels(self, interval=5, timeout=60):
"""
Continuosly checks if all portchannel host interfaces are established
Args:
interval: the interval (in seconds) at which to perform the check
timeout: maximum allowed duration (in seconds) to wait for
interfaces to come up
Raises:
RuntimeError if the timeout duration is reached and interfaces are
still not up
"""
start = datetime.now()
while (datetime.now() - start).seconds < timeout:
if self.all_portchannels_established():
logger.log_info("All portchannel intfs are established")
return None
logger.log_info("Not all portchannel intfs are established")
time.sleep(interval)
raise RuntimeError('Portchannel intfs were not established '
'within {}'.format(timeout))
def get_ipinip_tunnel_addrs(self):
"""
Get the IP addresses used for the IPinIP tunnel
These should be the Loopback0 addresses for this device and the
peer device
Returns:
((str) self_loopback_ip, (str) peer_loopback_ip)
or
(None, None) If the tunnel type is not IPinIP
or
if an error is encountered. This most likely means
the host device is not a dual ToR device
"""
try:
peer_switch = self.config_db.get_keys(PEER_SWITCH_TABLE)[0]
tunnel = self.config_db.get_keys(TUNNEL_TABLE)[0]
except IndexError:
logger.log_warning('PEER_SWITCH or TUNNEL table'
'not found in config DB')
return None, None
try:
tunnel_table = self.config_db.get_entry(TUNNEL_TABLE, tunnel)
tunnel_type = tunnel_table[TUNNEL_TYPE_KEY].lower()
self_loopback_ip = tunnel_table[DST_IP_KEY]
peer_loopback_ip = self.config_db.get_entry(
PEER_SWITCH_TABLE, peer_switch
)[ADDRESS_IPV4_KEY]
except KeyError as e:
logger.log_warning(
'PEER_SWITCH or TUNNEL table missing data, '
'could not find key {}'
.format(e)
)
return None, None
if tunnel_type == IPINIP_TUNNEL:
return self_loopback_ip, peer_loopback_ip
return None, None
def get_inner_pkt_type(self, packet):
"""
Get the type of an inner encapsulated packet
Returns:
(str) 'v4' if the inner packet is IPv4
(str) 'v6' if the inner packet is IPv6
(bool) False if `packet` is not an IPinIP packet
"""
if packet.haslayer(IP):
# Determine inner packet type based on IP protocol number
# The outer packet type should always be IPv4
if packet[IP].proto == 4:
return IP
elif packet[IP].proto == 41:
return IPv6
return False
def wait_for_netlink_msgs(self):
"""
Gathers any RTM_NEWLINK messages
Returns:
(list) containing any received messages
"""
msgs = []
with IPRoute() as ipr:
ipr.bind()
for msg in ipr.get():
if msg['event'] == RTM_NEWLINK:
msgs.append(msg)
return msgs
def sniffer_restart_required(self, messages):
"""
Determines if the packet sniffer needs to be restarted
A restart is required if all of the following conditions are met:
1. A netlink message of type RTM_NEWLINK is received
(this is checked by `wait_for_netlink_msgs`)
2. The interface index of the message corresponds to a portchannel
interface
3. The state of the interface in the message is 'up'
Here, we do not care about an interface going down since
the sniffer is able to continue sniffing on the other
interfaces. However, if an interface has gone down and
come back up, we need to restart the sniffer to be able
to sniff traffic on the interface that has come back up.
"""
pc_index_map = self.get_portchannel_index_mapping()
for msg in messages:
if msg['index'] in pc_index_map:
if msg['state'] == 'up':
logger.log_info('{} came back up, sniffer restart required'
.format(pc_index_map[msg['index']]))
return True
return False
def listen_for_tunnel_pkts(self):
"""
Listens for tunnel packets that are trapped to CPU
These packets may be trapped if there is no neighbor info for the
inner packet destination IP in the hardware.
"""
def _ping_inner_dst(packet):
"""
Pings the inner destination IP for an encapsulated packet
Args:
packet: The encapsulated packet received
"""
inner_packet_type = self.get_inner_pkt_type(packet)
if inner_packet_type and packet[IP].dst == self_ip:
cmds = ['timeout', '0.2', 'ping', '-c1',
'-W1', '-i0', '-n', '-q']
if inner_packet_type == IPv6:
cmds.append('-6')
dst_ip = packet[IP].payload[inner_packet_type].dst
cmds.append(dst_ip)
logger.log_info("Running command '{}'".format(' '.join(cmds)))
subprocess.run(cmds, stdout=subprocess.DEVNULL)
self_ip, peer_ip = self.get_ipinip_tunnel_addrs()
if self_ip is None or peer_ip is None:
logger.log_notice('Could not get tunnel addresses from '
'config DB, exiting...')
return None
packet_filter = 'host {} and host {}'.format(self_ip, peer_ip)
logger.log_notice('Starting tunnel packet handler for {}'
.format(packet_filter))
sniff_intfs = self.get_up_portchannels()
logger.log_info("Listening on interfaces {}".format(sniff_intfs))
sniffer = AsyncSniffer(
iface=sniff_intfs,
filter=packet_filter,
prn=_ping_inner_dst
)
sniffer.start()
while True:
msgs = self.wait_for_netlink_msgs()
if self.sniffer_restart_required(msgs):
sniffer.stop()
sniff_intfs = self.get_up_portchannels()
logger.log_notice('Restarting tunnel packet handler on '
'interfaces {}'.format(sniff_intfs))
sniffer = AsyncSniffer(
iface=sniff_intfs,
filter=packet_filter,
prn=_ping_inner_dst
)
sniffer.start()
def run(self):
self.wait_for_portchannels()
self.listen_for_tunnel_pkts()
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
