def update_data(self): """ Update redis (caches config) Pulls the table references for each interface. """ self.vlanmac_ifindex_map = {} self.vlanmac_ifindex_list = [] fdb_strings = Namespace.dbs_keys(self.db_conn, mibs.ASIC_DB, "ASIC_STATE:SAI_OBJECT_TYPE_FDB_ENTRY:*") if not fdb_strings: return for s in fdb_strings: fdb_str = s.decode() try: fdb = json.loads(fdb_str.split(":", maxsplit=2)[-1]) except ValueError as e: # includes simplejson.decoder.JSONDecodeError mibs.logger.error("SyncD 'ASIC_DB' includes invalid FDB_ENTRY '{}': {}.".format(fdb_str, e)) break ent = Namespace.dbs_get_all(self.db_conn, mibs.ASIC_DB, s, blocking=True) # Example output: oid:0x3a000000000608 bridge_port_id = ent[b"SAI_FDB_ENTRY_ATTR_BRIDGE_PORT_ID"][6:] if bridge_port_id not in self.if_bpid_map: continue port_id = self.if_bpid_map[bridge_port_id] vlanmac = self.fdb_vlanmac(fdb) self.vlanmac_ifindex_map[vlanmac] = mibs.get_index(self.if_id_map[port_id]) self.vlanmac_ifindex_list.append(vlanmac) self.vlanmac_ifindex_list.sort()
def update_data(self): """ Update redis (caches config) Pulls the table references for each interface. """ self.nexthop_map = {} self.route_list = [] route_entries = Namespace.dbs_keys(self.db_conn, mibs.APPL_DB, "ROUTE_TABLE:*") if not route_entries: return for route_entry in route_entries: routestr = route_entry.decode() ipnstr = routestr[len("ROUTE_TABLE:"):] if ipnstr == "0.0.0.0/0": ipn = ipaddress.ip_network(ipnstr) ent = Namespace.dbs_get_all(self.db_conn, mibs.APPL_DB, routestr, blocking=True) nexthops = ent[b"nexthop"].decode() for nh in nexthops.split(','): # TODO: if ipn contains IP range, create more sub_id here sub_id = ip2tuple_v4(ipn.network_address) self.route_list.append(sub_id) self.nexthop_map[sub_id] = ipaddress.ip_address(nh).packed break # Just need the first nexthop self.route_list.sort()
def reinit_data(self): self.entity_to_oid_map.clear() # retrieve the initial list of entity in db key_info = Namespace.dbs_keys(self.mib_updater.statedb, mibs.STATE_DB, self.get_key_pattern()) if key_info: keys = [entry for entry in key_info] else: keys = [] # update cache with initial data for key in keys: # extract entity name name = key.split(mibs.TABLE_NAME_SEPARATOR_VBAR)[-1] self._update_entity_cache(name)
def reinit_data(self): """ Reinit data, clear cache """ # clear cache self.ent_phy_sensor_type_map = {} self.ent_phy_sensor_scale_map = {} self.ent_phy_sensor_precision_map = {} self.ent_phy_sensor_value_map = {} self.ent_phy_sensor_oper_state_map = {} transceiver_dom_encoded = Namespace.dbs_keys( self.statedb, mibs.STATE_DB, self.TRANSCEIVER_DOM_KEY_PATTERN) if transceiver_dom_encoded: self.transceiver_dom = [entry for entry in transceiver_dom_encoded]
def reinit_data(self): """ Re-initialize all data. """ # reinit cache self.physical_classes_map = {} self.physical_description_map = {} self.physical_hw_version_map = {} self.physical_serial_number_map = {} self.physical_mfg_name_map = {} self.physical_model_name_map = {} # update interface maps _, self.if_alias_map, _, _ = \ Namespace.get_sync_d_from_all_namespace(mibs.init_sync_d_interface_tables, Namespace.init_namespace_dbs()) device_metadata = mibs.get_device_metadata(self.statedb[0]) chassis_sub_id = (self.CHASSIS_ID, ) self.physical_entities = [chassis_sub_id] if not device_metadata or not device_metadata.get( b"chassis_serial_number"): chassis_serial_number = "" else: chassis_serial_number = device_metadata[b"chassis_serial_number"] self.physical_classes_map[chassis_sub_id] = PhysicalClass.CHASSIS self.physical_serial_number_map[chassis_sub_id] = chassis_serial_number # retrieve the initial list of transceivers that are present in the system transceiver_info = Namespace.dbs_keys(self.statedb, mibs.STATE_DB, self.TRANSCEIVER_KEY_PATTERN) if transceiver_info: self.transceiver_entries = [entry.decode() \ for entry in transceiver_info] else: self.transceiver_entries = [] # update cache with initial data for transceiver_entry in self.transceiver_entries: # extract interface name interface = transceiver_entry.split( mibs.TABLE_NAME_SEPARATOR_VBAR)[-1] self._update_transceiver_cache(interface)
def reinit_data(self): """ Subclass update loopback information """ self.loips = {} loopbacks = Namespace.dbs_keys(self.db_conn, mibs.APPL_DB, "INTF_TABLE:lo:*") if not loopbacks: return ## Collect only ipv4 lo interfaces for loopback in loopbacks: lostr = loopback loipmask = lostr[len("INTF_TABLE:lo:"):] loip = loipmask.split('/')[0] ipa = ipaddress.ip_address(loip) if isinstance(ipa, ipaddress.IPv4Address): self.loips[loip] = ipa
def update_data(self): """ Update redis (caches config) Pulls the table references for each interface. """ self.route_dest_map = {} self.route_dest_list = [] ## The nexthop for loopbacks should be all zero for loip in self.loips: sub_id = ip2tuple_v4(loip) + (255, 255, 255, 255) + (self.tos, ) + (0, 0, 0, 0) self.route_dest_list.append(sub_id) self.route_dest_map[sub_id] = self.loips[loip].packed route_entries = Namespace.dbs_keys(self.db_conn, mibs.APPL_DB, "ROUTE_TABLE:*") if not route_entries: return for route_entry in route_entries: routestr = route_entry.decode() ipnstr = routestr[len("ROUTE_TABLE:"):] if ipnstr == "0.0.0.0/0": ipn = ipaddress.ip_network(ipnstr) ent = Namespace.dbs_get_all(self.db_conn, mibs.APPL_DB, routestr, blocking=True) nexthops = ent[b"nexthop"].decode() ifnames = ent[b"ifname"].decode() for nh, ifn in zip(nexthops.split(','), ifnames.split(',')): ## Ignore non front panel interfaces ## TODO: non front panel interfaces should not be in APPL_DB at very beginning ## This is to workaround the bug in current sonic-swss implementation if ifn == "eth0" or ifn == "lo" or ifn == "docker0": continue sub_id = ip2tuple_v4(ipn.network_address) + ip2tuple_v4( ipn.netmask) + (self.tos, ) + ip2tuple_v4(nh) self.route_dest_list.append(sub_id) self.route_dest_map[sub_id] = ipn.network_address.packed self.route_dest_list.sort()
def reinit_data(self): """ Reinit data, clear cache """ # clear cache self.ent_phy_sensor_type_map = {} self.ent_phy_sensor_scale_map = {} self.ent_phy_sensor_precision_map = {} self.ent_phy_sensor_value_map = {} self.ent_phy_sensor_oper_state_map = {} transceiver_dom_encoded = Namespace.dbs_keys( self.statedb, mibs.STATE_DB, self.TRANSCEIVER_DOM_KEY_PATTERN) if transceiver_dom_encoded: self.transceiver_dom = [entry for entry in transceiver_dom_encoded] # for FAN, PSU and thermal sensors, they are in host namespace DB, to avoid iterating all namespace DBs, # just get data from host namespace DB, which is self.statedb[0]. fan_sensor_encoded = self.statedb[HOST_NAMESPACE_DB_IDX].keys( self.statedb[HOST_NAMESPACE_DB_IDX].STATE_DB, self.FAN_SENSOR_KEY_PATTERN) if fan_sensor_encoded: self.fan_sensor = [entry for entry in fan_sensor_encoded] psu_sensor_encoded = self.statedb[HOST_NAMESPACE_DB_IDX].keys( self.statedb[HOST_NAMESPACE_DB_IDX].STATE_DB, self.PSU_SENSOR_KEY_PATTERN) if psu_sensor_encoded: self.psu_sensor = [entry for entry in psu_sensor_encoded] thermal_sensor_encoded = self.statedb[HOST_NAMESPACE_DB_IDX].keys( self.statedb[HOST_NAMESPACE_DB_IDX].STATE_DB, self.THERMAL_SENSOR_KEY_PATTERN) if thermal_sensor_encoded: self.thermal_sensor = [entry for entry in thermal_sensor_encoded]