raise ImportError("%s - required module not found" % str(e))
VERSION = '2.0'
SYSLOG_IDENTIFIER = "sfputil"
PLATFORM_SPECIFIC_MODULE_NAME = "sfputil"
PLATFORM_SPECIFIC_CLASS_NAME = "SfpUtil"
# Global platform-specific sfputil class instance
platform_sfputil = None
PLATFORM_JSON = 'platform.json'
PORT_CONFIG_INI = 'port_config.ini'
# Global logger instance
log = logger.Logger(SYSLOG_IDENTIFIER)
# ========================== Methods for printing ==========================
# Convert arraw of raw bytes into pretty-printed string
def raw_bytes_to_string_pretty(raw_bytes):
hexstr = ""
for i in range(0, len(raw_bytes)):
if i > 0 and (i % 8) == 0:
hexstr += " "
if i > 0 and (i % 16) == 0:
hexstr += "\n"
COPPER_PORT_END = 48
SFP_PORT_START = 49
SFP_PORT_END = 52
PORT_END = 52
# Device counts
MAX_7215_FAN_DRAWERS = 2
MAX_7215_FANS_PER_DRAWER = 1
MAX_7215_PSU = 2
MAX_7215_THERMAL = 6
# Temp - disable these to help with early debug
MAX_7215_COMPONENT = 2
SYSLOG_IDENTIFIER = "chassis"
sonic_logger = logger.Logger(SYSLOG_IDENTIFIER)
class Chassis(ChassisBase):
"""
Nokia platform-specific Chassis class
Derived from Dell S6000 platform.
customized for the 7215 platform.
"""
def __init__(self):
ChassisBase.__init__(self)
self.system_led_supported_color = [
'off', 'amber', 'green', 'amber_blink', 'green_blink'
]
# Port numbers for SFP List Initialization
self.COPPER_PORT_START = COPPER_PORT_START
# definitions of the offset with width accomodated for values
# of MUX register specs of upper page 0x04 starting at 640
# info eeprom for Y Cable
Y_CABLE_IDENTFIER_LOWER_PAGE = 0
Y_CABLE_IDENTFIER_UPPER_PAGE = 128
Y_CABLE_DETERMINE_CABLE_READ_SIDE = 640
Y_CABLE_CHECK_LINK_ACTIVE = 641
Y_CABLE_SWITCH_MUX_DIRECTION = 642
Y_CABLE_MUX_DIRECTION = 644
Y_CABLE_ACTIVE_TOR_INDICATOR = 645
Y_CABLE_MANUAL_SWITCH_COUNT = 669
SYSLOG_IDENTIFIER = "sonic_y_cable"
# Global logger instance for helper functions and classes to log
helper_logger = logger.Logger(SYSLOG_IDENTIFIER)
# Global platform_chassis instance to call get_sfp required for read/write eeprom
platform_chassis = None
try:
platform_chassis = sonic_platform.platform.Platform().get_chassis()
helper_logger.log_info("chassis loaded {}".format(platform_chassis))
except Exception as e:
helper_logger.log_warning("Failed to load chassis due to {}".format(
repr(e)))
def toggle_mux_to_torA(physical_port):
"""
This API specifically does a hard switch toggle of the Y cable's MUX regardless of link state to
packet is trapped to the CPU. In this case, we should ping the inner
destination IP to trigger the process of obtaining neighbor information
"""
import subprocess
import time
from datetime import datetime
from ipaddress import ip_interface
from pyroute2 import IPRoute
from scapy.layers.inet import IP
from scapy.layers.inet6 import IPv6
from scapy.sendrecv import AsyncSniffer
from swsssdk import ConfigDBConnector, SonicV2Connector
from sonic_py_common import logger as log
logger = log.Logger()
STATE_DB = 'STATE_DB'
PORTCHANNEL_INTERFACE_TABLE = 'PORTCHANNEL_INTERFACE'
TUNNEL_TABLE = 'TUNNEL'
PEER_SWITCH_TABLE = 'PEER_SWITCH'
INTF_TABLE_TEMPLATE = 'INTERFACE_TABLE|{}|{}'
STATE_KEY = 'state'
TUNNEL_TYPE_KEY = 'tunnel_type'
DST_IP_KEY = 'dst_ip'
ADDRESS_IPV4_KEY = 'address_ipv4'
IPINIP_TUNNEL = 'ipinip'
RTM_NEWLINK = 'RTM_NEWLINK'
from sonic_platform.eeprom import Eeprom
except ImportError as e:
raise ImportError(str(e) + "- required module not found")
if sys.version_info[0] < 3:
import commands as cmd
else:
import subprocess as cmd
smbus_present = 1
try:
import smbus
except ImportError as e:
smbus_present = 0
sonic_logger = logger.Logger('psu')
class Psu(PsuBase):
"""Nokia platform-specific PSU class for 7215 """
def __init__(self, psu_index):
PsuBase.__init__(self)
# PSU is 1-based in Nokia platforms
self.index = psu_index + 1
self._fan_list = []
# PSU eeprom
self.eeprom = Eeprom(is_psu=True, psu_index=self.index)
def get_name(self):
"""
# SDK sniffer file path and name
SDK_SNIFFER_TARGET_PATH = '/var/log/mellanox/sniffer/'
SDK_SNIFFER_FILENAME_PREFIX = 'sx_sdk_sniffer_'
SDK_SNIFFER_FILENAME_EXT = '.pcap'
# Supervisor config file path
TMP_SNIFFER_CONF_FILE = '/tmp/tmp.conf'
CONTAINER_NAME = 'syncd'
SNIFFER_CONF_FILE = '/etc/supervisor/conf.d/mlnx_sniffer.conf'
SNIFFER_CONF_FILE_IN_CONTAINER = CONTAINER_NAME + ':' + SNIFFER_CONF_FILE
# Command to restart swss service
COMMAND_RESTART_SWSS = 'systemctl restart swss.service'
# Global logger instance
log = logger.Logger(SNIFFER_SYSLOG_IDENTIFIER)
# generate sniffer target file name include a time stamp.
def sniffer_filename_generate(path, filename_prefix, filename_ext):
time_stamp = time.strftime("%Y%m%d%H%M%S")
filename = path + filename_prefix + time_stamp + filename_ext
return filename
# write environment variable in local tmp file for sniffer
def env_variable_write(env_variable_string):
conf_file = open(TMP_SNIFFER_CONF_FILE, 'a')
if os.path.getsize(TMP_SNIFFER_CONF_FILE) == 0:
conf_file.write('[program:syncd]\n')
conf_file.write(env_variable_string)
conf_file.close()
#############################################################################
# Nokia
#
# Module contains an implementation of SONiC Platform Base API and
# provides the Fan Drawer status which is available in the platform
#
#############################################################################
try:
from sonic_platform_base.fan_drawer_base import FanDrawerBase
from sonic_py_common import logger
except ImportError as e:
raise ImportError(str(e) + "- required module not found")
sonic_logger = logger.Logger('fan_drawer')
class NokiaFanDrawer(FanDrawerBase):
def __init__(self, index):
super(NokiaFanDrawer, self).__init__()
self._index = index + 1
self._led = None
def get_index(self):
return self._index
def get_presence(self):
return self._fan_list[0].get_presence()
def get_model(self):
"""
IO_TYPE_WATCHDOG = 'W' << 8
WDR_INT = IO_READ | IO_SIZE_INT | IO_TYPE_WATCHDOG
""" Watchdog ioctl commands """
WDIOC_SETOPTIONS = 4 | WDR_INT
WDIOC_KEEPALIVE = 5 | WDR_INT
WDIOC_GETTIMEOUT = 7 | WDR_INT
""" Watchdog status constants """
WDIOS_DISABLECARD = 0x0001
WDIOS_ENABLECARD = 0x0002
""" watchdog sysfs """
WD_SYSFS_PATH = "/sys/class/watchdog/"
WD_COMMON_ERROR = -1
sonic_logger = logger.Logger()
class WatchdogImplBase(WatchdogBase):
"""
Base class that implements common logic for interacting
with watchdog using ioctl commands
"""
def __init__(self, wd_device_path):
"""
Open a watchdog handle
@param wd_device_path Path to watchdog device
"""
self.watchdog_path = wd_device_path
self.watchdog = os.open(self.watchdog_path, os.O_WRONLY)
#!/usr/bin/env python3
import subprocess
from sonic_py_common import logger
from swsscommon import swsscommon
log = logger.Logger('mark_dhcp_packet')
class MarkDhcpPacket(object):
"""
Class used to configure dhcp packet mark in ebtables
"""
def __init__(self):
self.config_db_connector = None
self.state_db_connector = None
@property
def config_db(self):
"""
Returns config DB connector.
Initializes the connector during the first call
"""
if self.config_db_connector is None:
self.config_db_connector = swsscommon.ConfigDBConnector()
self.config_db_connector.connect()
return self.config_db_connector
@property
########################################################################
# Nokia IXS7215
#
# Module contains an implementation of SONiC Platform Base API and
# provides the Thermals' information which are available in the platform
#
########################################################################
try:
import os
from sonic_platform_base.thermal_base import ThermalBase
from sonic_py_common import logger
except ImportError as e:
raise ImportError(str(e) + "- required module not found")
sonic_logger = logger.Logger('thermal')
class Thermal(ThermalBase):
"""Nokia platform-specific Thermal class"""
I2C_CLASS_DIR = "/sys/class/i2c-adapter/"
I2C_DEV_MAPPING = (['i2c-0/0-004a/hwmon/',
1], ['i2c-0/0-004b/hwmon/',
1], ['i2c-0/0-002e/',
1], ['i2c-0/0-002e/',
2], ['i2c-0/0-002e/', 3])
HWMON_CLASS_DIR = "/sys/class/hwmon/"
THERMAL_NAME = ("PCB PHY", "PCB MAC", "ADT7473-CPU", "ADT7473-LOC",
#!/usr/bin/env python3
import time
from sonic_py_common import logger as log
from swsscommon.swsscommon import ConfigDBConnector, DBConnector, FieldValuePairs, ProducerStateTable, SonicV2Connector, Table
from swsscommon.swsscommon import APPL_DB, STATE_DB
logger = log.Logger('write_standby')
REDIS_SOCK_PATH = '/var/run/redis/redis.sock'
def create_fvs(**kwargs):
return FieldValuePairs(list(kwargs.items()))
class MuxStateWriter(object):
"""
Class used to write standby mux state to APP DB
"""
def __init__(self):
self.config_db_connector = None
self.appl_db_connector = None
self.state_db_connector = None
self.asic_db_connector = None
@property
def config_db(self):
"""
Returns config DB connector.
import os
from sonic_platform_base.fan_base import FanBase
from sonic_py_common import logger
except ImportError as e:
raise ImportError(str(e) + "- required module not found")
smbus_present = 1
try:
import smbus
except ImportError as e:
smbus_present = 0
MAX_IXS7215_FAN_SPEED = 19000
WORKING_IXS7215_FAN_SPEED = 960
sonic_logger = logger.Logger('fan')
class Fan(FanBase):
"""Nokia platform-specific Fan class"""
def __init__(self, fan_index, fan_drawer, psu_fan=False, dependency=None):
self.is_psu_fan = psu_fan
ADT7473_DIR = "/sys/bus/i2c/devices/0-002e/"
if not self.is_psu_fan:
# Fan is 1-based in Nokia platforms
self.index = fan_index + 1
self.fan_drawer = fan_drawer
self.set_fan_speed_reg = ADT7473_DIR + "pwm{}".format(self.index)
self.get_fan_speed_reg = ADT7473_DIR + "fan{}_input".format(
self.index)
import os
import pkgutil
import importlib
from sonic_py_common import logger
# Constants ====================================================================
PDDF_SUPPORT_FILE = '/usr/share/sonic/platform/pddf_support'
# Helper classs
log = logger.Logger()
class UtilHelper(object):
def __init__(self):
pass
def load_plugins(self, plugins_namespace):
""" Discover and load CLI plugins. Yield a plugin module. """
def iter_namespace(ns_pkg):
return pkgutil.iter_modules(ns_pkg.__path__, ns_pkg.__name__ + ".")
for _, module_name, ispkg in iter_namespace(plugins_namespace):
if ispkg:
continue
log.log_debug('importing plugin: {}'.format(module_name))
try:
module = importlib.import_module(module_name)
except Exception as err:
log.log_error('failed to import plugin {}: {}'.format(
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 import logger
sonic_logger = logger.Logger('thermal_actions')
class SetFanSpeedAction(ThermalPolicyActionBase):
"""
Base thermal action class to set speed for fans
"""
# JSON field definition
JSON_FIELD_SPEED = 'speed'
JSON_FIELD_DEFAULT_SPEED = 'default_speed'
JSON_FIELD_HIGHTEMP_SPEED = 'hightemp_speed'
def __init__(self):
"""
Constructor of SetFanSpeedAction
"""
self.default_speed = 50
self.hightemp_speed = 100
self.speed = self.default_speed
def load_from_json(self, json_obj):
"""
Construct SetFanSpeedAction via JSON. JSON example:
{
"type": "fan.all.set_speed"
"speed": "100"
try:
from sonic_platform_base.sonic_eeprom.eeprom_base import EepromDecoder
from sonic_platform_base.sonic_eeprom.eeprom_tlvinfo import TlvInfoDecoder
from sonic_py_common import logger
except ImportError as e:
raise ImportError(str(e) + "- required module not found")
# PSU eeprom fields in format required by EepromDecoder
psu_eeprom_format = [
('Model', 's', 15), ('burn', 'x', 1),
('Part Number', 's', 14), ('burn', 'x', 40),
('Serial Number', 's', 11)
]
sonic_logger = logger.Logger('eeprom')
class Eeprom(TlvInfoDecoder):
"""Nokia platform-specific EEPROM class"""
I2C_DIR = "/sys/class/i2c-adapter/"
def __init__(self, is_psu=False, psu_index=0, is_fan=False, fan_index=0):
self.is_psu_eeprom = is_psu
self.is_fan_eeprom = is_fan
self.is_sys_eeprom = not (is_psu | is_fan)
if self.is_sys_eeprom:
self.start_offset = 0
self.eeprom_path = self.I2C_DIR + "i2c-0/0-0053/eeprom"
