def __init__(self, sfp_list): self._api_helper = APIHelper() self._sfp_list = sfp_list self._logger = Logger() # clear interrupt self._api_helper.read_one_line_file(self.INT_PATH)
def __init__(self, sfp_list): self._api_common = Common() self._sfp_list = sfp_list self._logger = Logger() # clear interrupt self._api_common.read_one_line_file(self.INT_PATH)
class SfpEvent: ''' Listen to insert/remove sfp events ''' SFP_NUM_START = 49 DELAY = 0.05 INT_PATH = '/sys/devices/platform/e1031.smc/SFP/modabs_int' GPIO_SUS7 = '/sys/devices/platform/hlx-ich.0/sci_int_gpio_sus7' def __init__(self, sfp_list): self._api_helper = APIHelper() self._sfp_list = sfp_list self._logger = Logger() # clear interrupt self._api_helper.read_one_line_file(self.INT_PATH) def get_sfp_event(self, timeout): epoll = select.epoll() port_dict = {} timeout_sec = timeout / 1000 try: # We get notified when there is an SCI interrupt from GPIO SUS7 fd = open(self.GPIO_SUS7, "r") fd.read() epoll.register(fd.fileno(), select.EPOLLIN & select.EPOLLET) events = epoll.poll(timeout=timeout_sec if timeout != 0 else -1) if events: # Read the QSFP ABS interrupt & status registers port_changes = self._api_helper.read_one_line_file( self.INT_PATH) changes = int(port_changes, 16) for sfp in self._sfp_list: if sfp.port_num < self.SFP_NUM_START: continue change = (changes >> sfp.port_num - self.SFP_NUM_START) & 1 if change == 1: time.sleep(self.DELAY) port_status = sfp.get_presence() port_dict[str( sfp.port_num)] = '1' if port_status else '0' return port_dict except Exception as e: self._logger.log_error("Failed to detect SfpEvent - " + repr(e)) return False finally: fd.close() epoll.close() return False
class SfpEvent: ''' Listen to insert/remove sfp events ''' QSFP_MODPRS_IRQ = '/sys/devices/platform/dx010_cpld/qsfp_modprs_irq' GPIO_SUS6 = "/sys/devices/platform/slx-ich.0/sci_int_gpio_sus6" def __init__(self, sfp_list): self._api_helper = APIHelper() self._sfp_list = sfp_list self._logger = Logger() def get_sfp_event(self, timeout): epoll = select.epoll() port_dict = {} timeout_sec = timeout / 1000 try: # We get notified when there is an SCI interrupt from GPIO SUS6 fd = open(self.GPIO_SUS6, "r") fd.read() epoll.register(fd.fileno(), select.EPOLLIN & select.EPOLLET) events = epoll.poll(timeout=timeout_sec if timeout != 0 else -1) if events: # Read the QSFP ABS interrupt & status registers port_changes = self._api_helper.read_one_line_file( self.QSFP_MODPRS_IRQ) changes = int(port_changes, 16) for sfp in self._sfp_list: change = (changes >> sfp.port_num - 1) & 1 if change == 1: port_dict[str(sfp.port_num)] = str( int(sfp.get_presence())) return port_dict except Exception as e: self._logger.log_error("Failed to detect SfpEvent - " + repr(e)) return False finally: fd.close() epoll.close() return False
# from __future__ import print_function import os import time import subprocess from swsscommon import swsscommon from platform_ndk import nokia_common from platform_ndk import platform_ndk_pb2 from sonic_platform.sfp import Sfp from sonic_py_common.logger import Logger from sonic_py_common import daemon_base # from sfp.Sfp import SfpHasBeenTransitioned logger = Logger("sfp_event") MAX_NOKIA_SFP_EVENT_SLEEP_TIME = 5 TRANSCEIVER_INFO_TABLE = 'TRANSCEIVER_INFO' SFPEVENT_TOTAL_NUM_TESTS = 4 # @todo-nokia Remove once the below APIs are present in util_base.py as part of PDDF PLATFORM_ROOT_DOCKER = '/usr/share/sonic/platform' SONIC_CFGGEN_PATH = '/usr/local/bin/sonic-cfggen' HWSKU_KEY = 'DEVICE_METADATA.localhost.hwsku' PLATFORM_KEY = 'DEVICE_METADATA.localhost.platform' class sfp_event: ''' Listen to plugin/plugout cable events ''' def __init__(self, num_ports, stub):
#!/usr/bin/env python try: import os import copy from sonic_py_common.logger import Logger except ImportError as e: raise ImportError(str(e) + "- required module not found") logger = Logger("platDev") PLATFORM_NAME = "aurora-715" MAX_FAN_MODULE = 5 MAX_FAN = 2 THERMAL_SENSOR_LIST = [{ 'name': "pch_haswell", 'temp_index': [1], 'sysfile_path': "/sys/class/hwmon/hwmon0/", 'support_mask': 0x81, 'ext_sysfile_list': None }, { 'name': "CPU core temp", 'temp_index': [1, 2], 'sysfile_path': "/sys/class/hwmon/hwmon1/", 'support_mask': 0x8B, 'ext_sysfile_list': None }, { 'name': "NCT7511Y(U73)", 'temp_index': [1, 2], 'sysfile_path': "/sys/class/hwmon/hwmon2/device/NBA715_THERMAL/", 'support_mask': 0x0F,
def main(): logger = Logger(SYSLOG_IDENTIFIER) logger.set_min_log_priority_info() if len(sys.argv) != 3: raise Exception('Pass service and valid asic-id as arguments') service = sys.argv[1] args_asic_id = sys.argv[2] # Get num asics num_asics = multi_asic.get_num_asics() if num_asics == 0: logger.log_error( 'Detected no asics on this platform for service {}'.format( service)) sys.exit(1) # Connect to STATE_DB and subscribe to chassis-module table notifications state_db = daemon_base.db_connect("CHASSIS_STATE_DB") sel = swsscommon.Select() sst = swsscommon.SubscriberStateTable(state_db, CHASSIS_ASIC_INFO_TABLE) sel.addSelectable(sst) while True: (state, c) = sel.select(SELECT_TIMEOUT_MSECS) if state == swsscommon.Select.TIMEOUT: continue if state != swsscommon.Select.OBJECT: continue (asic_key, asic_op, asic_fvp) = sst.pop() asic_id = re.search(r'\d+$', asic_key) global_asic_id = asic_id.group(0) if asic_op == 'SET': asic_fvs = dict(asic_fvp) asic_name = asic_fvs.get('name') if asic_name is None: logger.log_info('Unable to get asic_name for asic{}'.format( global_asic_id)) continue if asic_name.startswith('FABRIC-CARD') is False: logger.log_info( 'Skipping module with asic_name {} for asic{}'.format( asic_name, global_asic_id)) continue if (global_asic_id == args_asic_id): logger.log_info( 'Detected asic{} is online'.format(global_asic_id)) sys.exit(0) elif asic_op == 'DEL': logger.log_info( 'Detected asic{} is offline'.format(global_asic_id)) sys.exit(1) else: continue
from sonic_platform_base.sonic_thermal_control.thermal_action_base import ThermalPolicyActionBase from sonic_platform_base.sonic_thermal_control.thermal_json_object import thermal_json_object from sonic_py_common.logger import Logger from platform_ndk import nokia_common from platform_ndk import platform_ndk_pb2 logger = Logger('thermal_actions') @thermal_json_object('thermal.platform.publish') class PublishThermalAlgoAction(ThermalPolicyActionBase): """ Action to publish thermal information to platform """ def execute(self, thermal_info_dict): """ Publish thermal information to platform :param thermal_info_dict: A dictionary stores all thermal information. :return: """ from .thermal_infos import ChassisInfo from .thermal_infos import ThermalInfo if ChassisInfo.INFO_NAME in thermal_info_dict: # chassis_info_obj = thermal_info_dict[ChassisInfo.INFO_NAME] # chassis = chassis_info_obj.get_chassis() pass else: return
def __init__(self, sfp_list): self._api_helper = APIHelper() self._sfp_list = sfp_list self._logger = Logger() self._sfp_change_event_data = {'present': 0}
def __init__(self, sfp_list): self._api_helper = APIHelper() self._sfp_list = sfp_list self._logger = Logger()
import subprocess import sys from sonic_py_common.logger import Logger from swsscommon import swsscommon SYSLOG_IDENTIFIER = os.path.basename(__file__) WARM_BOOT_FILE_DIR = '/var/warmboot/nat/' NAT_WARM_BOOT_FILE = 'nat_entries.dump' IP_PROTO_TCP = '6' MATCH_CONNTRACK_ENTRY = '^(\w+)\s+(\d+).*src=([\d.]+)\s+dst=([\d.]+)\s+sport=(\d+)\s+dport=(\d+).*src=([\d.]+)\s+dst=([\d.]+)\s+sport=(\d+)\s+dport=(\d+)' # Global logger instance logger = Logger(SYSLOG_IDENTIFIER) logger.set_min_log_priority_info() def add_nat_conntrack_entry_in_kernel(ipproto, srcip, dstip, srcport, dstport, natsrcip, natdstip, natsrcport, natdstport): # pyroute2 doesn't have support for adding conntrack entries via netlink yet. So, invoking the conntrack utility to add the entries. state = '' if (ipproto == IP_PROTO_TCP): state = ' --state ESTABLISHED ' ctcmd = 'conntrack -I -n ' + natdstip + ':' + natdstport + ' -g ' + natsrcip + ':' + natsrcport + \ ' --protonum ' + ipproto + state + ' --timeout 432000 --src ' + srcip + ' --sport ' + srcport + \ ' --dst ' + dstip + ' --dport ' + dstport + ' -u ASSURED' subprocess.call(ctcmd, shell=True) logger.log_info("Restored NAT entry: {}".format(ctcmd))
# # Description: Module contains the definitions of SONiC platform APIs # try: from sonic_platform_base.psu_base import PsuBase from sonic_py_common.logger import Logger from sonic_platform.fan import Fan, FanConst except ImportError as e: raise ImportError(str(e) + "- required module not found") VOLTAGE_UPPER_LIMIT = 14 VOLTAGE_LOWER_LIMIT = 10 PSU_SYS_FS = "/sys/devices/virtual/hwmon/hwmon1/device/" logger = Logger('sonic-platform-psu') class Psu(PsuBase): __num_of_fans = 1 __name_of_psus = ['PSU1', 'PSU2'] def __init__(self, index): self.__index = index self.__psu_presence_attr = PSU_SYS_FS + "psu{}".format(self.__index + 1) self.__psu_voltage_out_attr = PSU_SYS_FS + \ "psoc_psu{}_vout".format(self.__index + 1) self.__psu_current_out_attr = PSU_SYS_FS + \ "psoc_psu{}_iout".format(self.__index + 1)
#!/usr/bin/env python3 import os import sys import yaml from sonic_py_common.logger import Logger from swsssdk import ConfigDBConnector db = ConfigDBConnector() db.connect() SYSLOG_IDENTIFIER = 'snmp_yml_to_configdb.py' logger = Logger(SYSLOG_IDENTIFIER) logger.set_min_log_priority_info() snmp_comm_config_db = db.get_table('SNMP_COMMUNITY') snmp_config_db_communities = snmp_comm_config_db.keys() snmp_general_config_db = db.get_table('SNMP') snmp_general_keys = snmp_general_config_db.keys() full_snmp_comm_list = [ 'snmp_rocommunity', 'snmp_rocommunities', 'snmp_rwcommunity', 'snmp_rwcommunities' ] if not os.path.exists('/etc/sonic/snmp.yml'): logger.log_info('/etc/sonic/snmp.yml does not exist') sys.exit(1) with open('/etc/sonic/snmp.yml', 'r') as yaml_file:
############################################################################# # # Module contains an implementation of SONiC Platform Base API and # provides the PSUs status which are available in the platform # ############################################################################# try: from sonic_py_common.logger import Logger from sonic_platform_base.thermal_base import ThermalBase except ImportError as e: raise ImportError(str(e) + "- required module not found") logger = Logger("thermal") class Thermal(ThermalBase): """Platform-specific Thermal class""" def __init__(self, index, name, sysfile_path, is_bmc, support_mask=0x1, ext_sysfile_list=None): # index is used to indicate the temp{} under sffile_path # support_mask: 1:support 0:not support # bit 0 : temperature (always 1) # bit 1 : high threshold # bit 2 : low threshold # bit 3 : high critical threshold
from sonic_platform_base.sonic_thermal_control.thermal_info_base import ThermalPolicyInfoBase from sonic_platform_base.sonic_thermal_control.thermal_json_object import thermal_json_object from sonic_py_common import daemon_base from sonic_py_common.logger import Logger from swsscommon import swsscommon from sonic_platform_base.module_base import ModuleBase logger = Logger('thermal_infos') @thermal_json_object('fan_info') class FanInfo(ThermalPolicyInfoBase): """ FanOverride information needed by thermal policy """ INFO_NAME = 'fan_info' def __init__(self): self._chassis = None self._fan_platform_override = False def collect(self, chassis): """ Collect platform chassis. :param chassis: The chassis object :return: """ self._chassis = chassis def get_fanalgo_override(self): """
import docker import os import pickle import re from swsscommon import swsscommon from sonic_py_common import multi_asic from sonic_py_common.logger import Logger from .health_checker import HealthChecker from . import utils SYSLOG_IDENTIFIER = 'service_checker' logger = Logger(log_identifier=SYSLOG_IDENTIFIER) class ServiceChecker(HealthChecker): """ Checker that checks critical system service status via monit service. """ # Cache file to save container_critical_processes CRITICAL_PROCESS_CACHE = '/tmp/critical_process_cache' CRITICAL_PROCESSES_PATH = 'etc/supervisor/critical_processes' # Command to get merged directory of a container GET_CONTAINER_FOLDER_CMD = 'docker inspect {} --format "{{{{.GraphDriver.Data.MergedDir}}}}"' # Command to query the status of monit service. CHECK_MONIT_SERVICE_CMD = 'systemctl is-active monit.service'
def main(): logger = Logger(SYSLOG_IDENTIFIER) logger.set_min_log_priority_info() if os.getuid() != 0: logger.log_error('Root required to clean up core files') return logger.log_info('Cleaning up core files') core_files = [f for f in os.listdir(CORE_FILE_DIR) if os.path.isfile(os.path.join(CORE_FILE_DIR, f))] core_files_by_process = defaultdict(list) for f in core_files: process = f.split('.')[0] curr_files = core_files_by_process[process] curr_files.append(f) if len(curr_files) > MAX_CORE_FILES: curr_files.sort(reverse = True, key = lambda x: datetime.utcfromtimestamp(int(x.split('.')[1]))) oldest_core = curr_files[MAX_CORE_FILES] logger.log_info('Deleting {}'.format(oldest_core)) try: os.remove(os.path.join(CORE_FILE_DIR, oldest_core)) except: logger.log_error('Unexpected error occured trying to delete {}'.format(oldest_core)) core_files_by_process[process] = curr_files[0:MAX_CORE_FILES] logger.log_info('Finished cleaning up core files')
#!/usr/bin/env python3 import signal import sys import traceback from sonic_py_common.logger import Logger from socket import if_nametoindex from swsssdk import SonicV2Connector, port_util from swsscommon import swsscommon SYSLOG_IDENTIFIER = 'port_index_mapper' # Global logger instance logger = Logger(SYSLOG_IDENTIFIER) logger.set_min_log_priority_info() class PortIndexMapper(object): def __init__(self): REDIS_TIMEOUT_MS = 0 # Update this list to support more interfaces tbl_lst = [ swsscommon.STATE_PORT_TABLE_NAME, swsscommon.STATE_VLAN_TABLE_NAME ] self.appl_db = swsscommon.DBConnector("STATE_DB", REDIS_TIMEOUT_MS, True) self.state_db = SonicV2Connector(host='127.0.0.1', decode_responses=True) self.state_db.connect(self.state_db.STATE_DB, False) self.sel = swsscommon.Select()
from __future__ import print_function try: from sonic_platform_base.watchdog_base import WatchdogBase from sonic_py_common.logger import Logger except ImportError as e: raise ImportError(str(e) + "- required module not found") logger = Logger("wdog") class Watchdog(WatchdogBase): _initialized = False def __init__(self, watchdog): # logger.set_min_log_priority_info() logger.log_info("Watchdog __init__{}".format(self)) def arm(self, seconds): self._initialized = True logger.log_info("Watchdog arm") # hook this up to actual kicker shortly return seconds def disarm(self): logger.log_info("Watchdog disarm") return False def is_armed(self): if self._initialized is True: logger.log_info("Watchdog is_armed")
asicname = "" acctname = "" acctkey = "" sharename = "" cwd = [] HOURS_4 = (4 * 60 * 60) PAUSE_ON_FAIL = (60 * 60) WAIT_FILE_WRITE1 = (10 * 60) WAIT_FILE_WRITE2 = (5 * 60) POLL_SLEEP = (60 * 60) MAX_RETRIES = 5 UPLOAD_PREFIX = "UPLOADED_" # Global logger instance logger = Logger(SYSLOG_IDENTIFIER) logger.set_min_log_priority_info() def make_new_dir(p): os.system("rm -rf " + p) os.system("mkdir -p " + p) def parse_a_json(data, prefix, val): for i in data: if type(data[i]) == dict: parse_a_json(data[i], prefix + (i,), val) else: val[prefix + (i,)] = data[i]
# # Third-Party Code: This code may depend on other components under separate # copyright notice and license terms. Your use of the source code for those # components is subject to the terms and conditions of the respective license # as noted in the Third-Party source code file. import time import os.path import sfputil as jnpr_sfp from sonic_py_common.logger import Logger from pprint import pprint SYSLOG_IDENTIFIER = "sfputil" # Global logger class instance logger = Logger(SYSLOG_IDENTIFIER) DEBUG = False def i2c_eeprom_dev_update(port, create_eeprom): eeprom_path = "/sys/class/i2c-adapter/i2c-{0}/{0}-0050/eeprom" i2c_path = "/sys/class/i2c-adapter/i2c-{0}" i2c_port = port + jnpr_sfp.SFP_I2C_OFFSET port_eeprom_path = eeprom_path.format(i2c_port) port_i2c_path = i2c_path.format(i2c_port) if create_eeprom: if not os.path.exists(port_eeprom_path): try: i2c_file = open(port_i2c_path + "/new_device", "w") i2c_file.write("optoe2 0x50")
from sonic_platform_base.module_base import ModuleBase from sonic_platform.module import Module from sonic_platform.psu import Psu from sonic_platform.thermal import Thermal from sonic_platform.fan_drawer import FanDrawer from sonic_platform.fan import Fan from sonic_platform.component import Component from sonic_platform.watchdog import Watchdog from sonic_platform.eeprom import Eeprom from sonic_py_common.logger import Logger from platform_ndk import nokia_common from platform_ndk import platform_ndk_pb2 except ImportError as e: raise ImportError(str(e) + "- required module not found") logger = Logger("Chassis") # Support for vodka only here. Need to modify this logic later to discern actual # number of ASICs and ports per prior to next platform NUM_SFP = 36 class Chassis(ChassisBase): """ NOKIA IXR7250 Platform-specific Chassis class """ REBOOT_CAUSE_DICT = { 'powerloss': ChassisBase.REBOOT_CAUSE_POWER_LOSS, 'overtemp': ChassisBase.REBOOT_CAUSE_THERMAL_OVERLOAD_OTHER, 'reboot': ChassisBase.REBOOT_CAUSE_NON_HARDWARE,
PORT_TYPE_MASK = 0xF0000000 NVE_MASK = PORT_TYPE_MASK & (PORT_TYPE_NVE << PORT_TYPE_OFFSET) CPU_MASK = PORT_TYPE_MASK & (PORT_TYPE_CPU << PORT_TYPE_OFFSET) # parameters for SFP presence SFP_STATUS_INSERTED = '1' # SFP constants SFP_PAGE_SIZE = 256 SFP_UPPER_PAGE_OFFSET = 128 SFP_VENDOR_PAGE_START = 640 BYTES_IN_DWORD = 4 # Global logger class instance logger = Logger() # SDK initializing stuff, called from chassis def initialize_sdk_handle(): rc, sdk_handle = sx_api_open(None) if (rc != SX_STATUS_SUCCESS): logger.log_warning( "Failed to open api handle, please check whether SDK is running.") sdk_handle = None return sdk_handle def deinitialize_sdk_handle(sdk_handle): if sdk_handle is not None:
from sonic_py_common.logger import Logger except ImportError as e: raise ImportError(str(e) + "- required module not found") MAX_SPEED_OF_FAN_FRONT = 23000 MAX_SPEED_OF_FAN_BACK = 20500 MAX_SPEED_OF_FAN_PSU = 18100 MAX_PWM_OF_FAN = 255 class FanConst: FAN_PSU_START_INDEX = 4 FAN_SYS_FS = "/sys/devices/virtual/hwmon/hwmon1/" logger = Logger('sonic-platform-fan') class Fan(FanBase): __name_of_fans = ['FAN1', 'FAN2', 'FAN3', 'FAN4', 'PSU1_FAN1', 'PSU2_FAN1'] __start_of_psu_fans = FanConst().FAN_PSU_START_INDEX __fan_gpi_attr = FAN_SYS_FS + "fan_gpi" def __init__(self, index): self.__index = index if self.__index >= self.__start_of_psu_fans: self.__presence_attr = FAN_SYS_FS + \ "psu{}".format(self.__index - self.__start_of_psu_fans + 1) self.__pwm_attr = FAN_SYS_FS + \