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 + \
