a582c13e98
Add new platform x86_64-ruijie_b6510-48vs8cq-r0 (Trident 3)
ASIC Vendor: Broadcom
Switch ASIC: Trident 3
Port Config: 48x25G+8x100G
Signed-off-by: tim-rj <sonic_rd@ruijie.com.cn>
1829 lines
57 KiB
Python
Executable File
1829 lines
57 KiB
Python
Executable File
# -*- coding: UTF-8 -*-
|
||
#-------------------------------------------------------------------------
|
||
# Name: ruijieutil
|
||
# Purpose: common configuration and api
|
||
#
|
||
# Author: rd
|
||
#
|
||
# Created: 02/07/2018
|
||
# Copyright: (c) rd 2018
|
||
#-------------------------------------------------------------------------
|
||
import sys
|
||
import os
|
||
import re
|
||
import subprocess
|
||
import syslog
|
||
import time
|
||
import binascii
|
||
import tty
|
||
import termios
|
||
import threading
|
||
import click
|
||
import mmap
|
||
from ruijieconfig import rg_eeprom, FRULISTS, MAC_DEFAULT_PARAM, MAC_AVS_PARAM, FANS_DEF, \
|
||
FAN_PROTECT, E2_LOC, E2_PROTECT, RUIJIE_SERVICE_TAG, RUIJIE_DIAG_VERSION, \
|
||
STARTMODULE, RUIJIE_CARDID, RUIJIE_PRODUCTNAME, RUIJIE_PART_NUMBER, \
|
||
RUIJIE_LABEL_REVISION, RUIJIE_MAC_SIZE, RUIJIE_MANUF_NAME, RUIJIE_MANUF_COUNTRY, \
|
||
RUIJIE_VENDOR_NAME, MAILBOX_DIR
|
||
|
||
try:
|
||
from eepromutil.fru import ipmifru
|
||
|
||
except Exception or SystemExit:
|
||
pass
|
||
|
||
import logging.handlers
|
||
import shutil
|
||
import gzip
|
||
import glob
|
||
|
||
__all__ = ["MENUID", "MENUPARENT", "MENUVALUE", "CHILDID", "MENUITEMNAME", "MENUITEMDEAL",
|
||
"GOBACK", "GOQUIT", "file_name", "CRITICAL", "FATAL", "ERROR", "WARNING", "WARN",
|
||
"INFO", "DEBUG", "NOTSET", "levelNames", "TLV_INFO_ID_STRING", "TLV_INFO_VERSION",
|
||
"TLV_INFO_LENGTH", "TLV_INFO_LENGTH_VALUE", "TLV_CODE_PRODUCT_NAME",
|
||
"TLV_CODE_PART_NUMBER", "TLV_CODE_SERIAL_NUMBER", "TLV_CODE_MAC_BASE",
|
||
"TLV_CODE_MANUF_DATE", "TLV_CODE_DEVICE_VERSION", "TLV_CODE_LABEL_REVISION",
|
||
"TLV_CODE_PLATFORM_NAME", "TLV_CODE_ONIE_VERSION", "TLV_CODE_MAC_SIZE",
|
||
"TLV_CODE_MANUF_NAME", "TLV_CODE_MANUF_COUNTRY", "TLV_CODE_VENDOR_NAME",
|
||
"TLV_CODE_DIAG_VERSION", "TLV_CODE_SERVICE_TAG", "TLV_CODE_VENDOR_EXT",
|
||
"TLV_CODE_CRC_32", "_TLV_DISPLAY_VENDOR_EXT", "TLV_CODE_RJ_CARID",
|
||
"_TLV_INFO_HDR_LEN", "SYSLOG_IDENTIFIER", "log_info", "log_debug", "log_warning",
|
||
"log_error", "CompressedRotatingFileHandler", "SETMACException", "checkinput",
|
||
"checkinputproduct", "getInputSetmac", "fan_tlv", "AVSUTIL", "I2CUTIL", "BMC",
|
||
"getSdkReg", "getfilevalue", "get_sysfs_value", "write_sysfs_value",
|
||
"RJPRINTERR", "strtoint", "inttostr", "str_to_hex", "hex_to_str", "str_to_bin",
|
||
"bin_to_str", "getMacTemp", "getMacTemp_sysfs", "restartDockerService",
|
||
"waitForDhcp", "waitForSdk", "waitForDocker", "getTLV_BODY", "_crc32",
|
||
"printvalue", "generate_value", "getsyseeprombyId", "fac_init_cardidcheck",
|
||
"isValidMac", "util_setmac", "getInputCheck", "getrawch", "upper_input",
|
||
"changeTypeValue", "astrcmp", "generate_ext", "rji2cget", "rji2cset", "rjpcird",
|
||
"rjpciwr", "rjsysset", "rji2cgetWord", "rji2csetWord", "fan_setmac", "checkfansninput",
|
||
"checkfanhwinput", "util_show_fanse2", "get_fane2_sysfs", "util_show_fane2", "getPid",
|
||
"fac_fans_setmac_tlv", "fac_fan_setmac_fru", "fac_fans_setmac", "fac_fan_setmac",
|
||
"writeToEEprom", "get_local_eth0_mac", "getonieversion", "createbmcMac",
|
||
"fac_board_setmac", "ipmi_set_mac", "getInputValue", "bmc_setmac", "closeProtocol",
|
||
"checkSdkMem", "getch", "get_raw_input", "getsysvalue", "get_pmc_register", "decoder",
|
||
"decode_eeprom", "get_sys_eeprom", "getCardId", "getsysmeminfo", "getsysmeminfo_detail",
|
||
"getDmiSysByType", "gethwsys", "getsysbios", "searchDirByName", "getUsbLocation",
|
||
"getusbinfo", "get_cpu_info", "get_version_config_info", "io_rd", "io_wr"]
|
||
|
||
MENUID = "menuid"
|
||
MENUPARENT = "parentid"
|
||
MENUVALUE = "value"
|
||
CHILDID = "childid"
|
||
MENUITEMNAME = "name"
|
||
MENUITEMDEAL = "deal"
|
||
GOBACK = "goBack"
|
||
GOQUIT = "quit"
|
||
|
||
file_name = "/etc/init.d/opennsl-modules-3.16.0-5-amd64"
|
||
##########################################################################
|
||
# ERROR LOG LEVEL
|
||
##########################################################################
|
||
CRITICAL = 50
|
||
FATAL = CRITICAL
|
||
ERROR = 40
|
||
WARNING = 30
|
||
WARN = WARNING
|
||
INFO = 20
|
||
DEBUG = 10
|
||
NOTSET = 0
|
||
|
||
levelNames = {
|
||
CRITICAL: 'CRITICAL',
|
||
ERROR: 'ERROR',
|
||
WARNING: 'WARNING',
|
||
INFO: 'INFO',
|
||
DEBUG: 'DEBUG',
|
||
NOTSET: 'NOTSET',
|
||
'CRITICAL': CRITICAL,
|
||
'ERROR': ERROR,
|
||
'WARN': WARNING,
|
||
'WARNING': WARNING,
|
||
'INFO': INFO,
|
||
'DEBUG': DEBUG,
|
||
'NOTSET': NOTSET,
|
||
}
|
||
|
||
TLV_INFO_ID_STRING = "TlvInfo\x00"
|
||
TLV_INFO_VERSION = 0x01
|
||
TLV_INFO_LENGTH = 0x00
|
||
TLV_INFO_LENGTH_VALUE = 0xba
|
||
|
||
##########################################################################
|
||
# eeprom info
|
||
##########################################################################
|
||
TLV_CODE_PRODUCT_NAME = 0x21
|
||
TLV_CODE_PART_NUMBER = 0x22
|
||
TLV_CODE_SERIAL_NUMBER = 0x23
|
||
TLV_CODE_MAC_BASE = 0x24
|
||
TLV_CODE_MANUF_DATE = 0x25
|
||
TLV_CODE_DEVICE_VERSION = 0x26
|
||
TLV_CODE_LABEL_REVISION = 0x27
|
||
TLV_CODE_PLATFORM_NAME = 0x28
|
||
TLV_CODE_ONIE_VERSION = 0x29
|
||
TLV_CODE_MAC_SIZE = 0x2A
|
||
TLV_CODE_MANUF_NAME = 0x2B
|
||
TLV_CODE_MANUF_COUNTRY = 0x2C
|
||
TLV_CODE_VENDOR_NAME = 0x2D
|
||
TLV_CODE_DIAG_VERSION = 0x2E
|
||
TLV_CODE_SERVICE_TAG = 0x2F
|
||
TLV_CODE_VENDOR_EXT = 0xFD
|
||
TLV_CODE_CRC_32 = 0xFE
|
||
_TLV_DISPLAY_VENDOR_EXT = 1
|
||
TLV_CODE_RJ_CARID = 0x01
|
||
_TLV_INFO_HDR_LEN = 11
|
||
|
||
|
||
SYSLOG_IDENTIFIER = "UTILTOOL"
|
||
|
||
# ========================== Syslog wrappers ==========================
|
||
|
||
def log_info(msg, also_print_to_console=False):
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_INFO, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
|
||
|
||
def log_debug(msg, also_print_to_console=False):
|
||
try:
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_DEBUG, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
except Exception as e:
|
||
pass
|
||
|
||
|
||
def log_warning(msg, also_print_to_console=False):
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_WARNING, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
|
||
|
||
def log_error(msg, also_print_to_console=False):
|
||
syslog.openlog(SYSLOG_IDENTIFIER)
|
||
syslog.syslog(syslog.LOG_ERR, msg)
|
||
syslog.closelog()
|
||
|
||
if also_print_to_console:
|
||
click.echo(msg)
|
||
|
||
class CompressedRotatingFileHandler(logging.handlers.RotatingFileHandler):
|
||
def doRollover(self):
|
||
"""
|
||
Do a rollover, as described in __init__().
|
||
"""
|
||
if self.stream:
|
||
self.stream.close()
|
||
self.stream = None
|
||
if self.backupCount > 0:
|
||
for i in range(self.backupCount - 1, 0, -1):
|
||
sfn = "%s.%d.gz" % (self.baseFilename, i)
|
||
dfn = "%s.%d.gz" % (self.baseFilename, i + 1)
|
||
if os.path.exists(sfn):
|
||
if os.path.exists(dfn):
|
||
os.remove(dfn)
|
||
os.rename(sfn, dfn)
|
||
dfn = self.baseFilename + ".1.gz"
|
||
if os.path.exists(dfn):
|
||
os.remove(dfn)
|
||
# These two lines below are the only new lines. I commented out the os.rename(self.baseFilename, dfn) and
|
||
# replaced it with these two lines.
|
||
with open(self.baseFilename, 'rb') as f_in, gzip.open(dfn, 'wb') as f_out:
|
||
shutil.copyfileobj(f_in, f_out)
|
||
self.mode = 'w'
|
||
self.stream = self._open()
|
||
|
||
|
||
class SETMACException(Exception):
|
||
def __init__(self, param='ERROR', errno="-1"):
|
||
err = "Setmac fail[%s]: %s" % (errno, param)
|
||
Exception.__init__(self, err)
|
||
self.param = param
|
||
self.errno = errno
|
||
|
||
def checkinput(b):
|
||
if b.isdigit() == False:
|
||
raise Exception("Ivalid Number")
|
||
if int(b) > 0xff or int(b) < 0:
|
||
raise Exception("Out of area")
|
||
|
||
def checkinputproduct(b):
|
||
if b.isalnum() ==False:
|
||
raise Exception("Invalid string")
|
||
|
||
def getInputSetmac(val):
|
||
bia = val.boardInfoArea
|
||
pia = val.productInfoArea
|
||
if bia != None:
|
||
a = raw_input("[Board Card]Product Serial Number:")
|
||
if len(a) != 13:
|
||
raise Exception("Invalid Serial Number length")
|
||
checkinputproduct(a)
|
||
bia.boardSerialNumber = a
|
||
b = raw_input("[Board Card]Product Version:(from 1-255)")
|
||
checkinput(b)
|
||
b = "%0x" % int(b)
|
||
bia.boardextra1 = b.upper()
|
||
if pia != None:
|
||
a = raw_input("[Product Area]Product Serial Number:")
|
||
if len(a) != 13:
|
||
raise Exception("Invalid Serial Number")
|
||
checkinputproduct(a)
|
||
pia.productSerialNumber = a
|
||
b = raw_input("[Product Area]Product Version:(from 1-255)")
|
||
checkinput(b)
|
||
b = "%0x" % int(b)
|
||
pia.productVersion = b.upper()
|
||
return val
|
||
|
||
class fan_tlv(object):
|
||
VERSION = 0x01 # E2PROM Version，start from 0x01
|
||
FLAG = 0x7E # New E2PROM version flag is 0x7E
|
||
HW_VER = 0X01 # compose by master version and fixed version
|
||
TYPE = 0xf1 # hw type defination
|
||
TLV_LEN = 00 # data length (16bit)
|
||
_FAN_TLV_HDR_LEN = 6
|
||
_FAN_TLV_CRC_LEN = 2
|
||
|
||
_FAN_TLV_TYPE_NAME = 0x02
|
||
_FAN_TLV_TYPE_SN = 0x03
|
||
_FAN_TLV_TYPE_HW_INFO = 0x05
|
||
_FAN_TLV_TYPE_DEV_TYPE = 0x06
|
||
|
||
_fandecodetime = 0
|
||
|
||
@property
|
||
def dstatus(self):
|
||
return self._dstatus
|
||
|
||
@property
|
||
def typename(self):
|
||
return self._typename
|
||
|
||
@property
|
||
def typesn(self):
|
||
return self._typesn
|
||
|
||
@property
|
||
def typehwinfo(self):
|
||
return self._typehwinfo
|
||
|
||
@property
|
||
def typedevtype(self):
|
||
return self._typedevtype
|
||
|
||
@property
|
||
def fanbus(self):
|
||
return self._fanbus
|
||
|
||
@property
|
||
def fanloc(self):
|
||
return self._fanloc
|
||
|
||
@property
|
||
def fandecodetime(self):
|
||
return self._fandecodetime
|
||
|
||
def __init__(self):
|
||
self._typename = ""
|
||
self._typesn = ""
|
||
self._typehwinfo = ""
|
||
self._typedevtype = ""
|
||
self._dstatus = 0
|
||
|
||
def strtoarr(self, str):
|
||
s = []
|
||
if str is not None:
|
||
for index in range(len(str)):
|
||
s.append(str[index])
|
||
return s
|
||
|
||
def generate_fan_value(self):
|
||
bin_buffer = [chr(0xff)] * 256
|
||
bin_buffer[0] = chr(self.VERSION)
|
||
bin_buffer[1] = chr(self.FLAG)
|
||
bin_buffer[2] = chr(self.HW_VER)
|
||
bin_buffer[3] = chr(self.TYPE)
|
||
|
||
temp_t = "%08x" % self.typedevtype # handle devtype first
|
||
typedevtype_t = hex_to_str(temp_t)
|
||
total_len = len(self.typename) + len(self.typesn) + \
|
||
len(self.typehwinfo) + len(typedevtype_t) + 8
|
||
|
||
bin_buffer[4] = chr(total_len >> 8)
|
||
bin_buffer[5] = chr(total_len & 0x00FF)
|
||
|
||
index_start = 6
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_NAME)
|
||
bin_buffer[index_start + 1] = chr(len(self.typename))
|
||
bin_buffer[index_start + 2: index_start + 2 +
|
||
len(self.typename)] = self.strtoarr(self.typename)
|
||
index_start = index_start + 2 + len(self.typename)
|
||
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_SN)
|
||
bin_buffer[index_start + 1] = chr(len(self.typesn))
|
||
bin_buffer[index_start + 2:index_start + 2 +
|
||
len(self.typesn)] = self.strtoarr(self.typesn)
|
||
index_start = index_start + 2 + len(self.typesn)
|
||
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_HW_INFO)
|
||
bin_buffer[index_start + 1] = chr(len(self.typehwinfo))
|
||
bin_buffer[index_start + 2:index_start + 2 +
|
||
len(self.typehwinfo)] = self.strtoarr(self.typehwinfo)
|
||
index_start = index_start + 2 + len(self.typehwinfo)
|
||
|
||
bin_buffer[index_start] = chr(self._FAN_TLV_TYPE_DEV_TYPE)
|
||
bin_buffer[index_start + 1] = chr(len(typedevtype_t))
|
||
bin_buffer[index_start + 2:index_start + 2 +
|
||
len(typedevtype_t)] = self.strtoarr(typedevtype_t)
|
||
index_start = index_start + 2 + len(typedevtype_t)
|
||
|
||
crcs = fan_tlv.fancrc(''.join(bin_buffer[0:index_start])) # check 2bytes
|
||
bin_buffer[index_start] = chr(crcs >> 8)
|
||
bin_buffer[index_start + 1] = chr(crcs & 0x00ff)
|
||
return bin_buffer
|
||
|
||
def decode(self, e2):
|
||
ret = []
|
||
self.VERSION = ord(e2[0])
|
||
self.FLAG = ord(e2[1])
|
||
self.HW_VER = ord(e2[2])
|
||
self.TYPE = ord(e2[3])
|
||
self.TLV_LEN = (ord(e2[4]) << 8) | ord(e2[5])
|
||
|
||
tlv_index = self._FAN_TLV_HDR_LEN
|
||
tlv_end = self._FAN_TLV_HDR_LEN + self.TLV_LEN
|
||
|
||
# check checksum
|
||
if len(e2) < self._FAN_TLV_HDR_LEN + self.TLV_LEN + 2:
|
||
self._dstatus = -2
|
||
return ret
|
||
sumcrc = fan_tlv.fancrc(e2[0:self._FAN_TLV_HDR_LEN + self.TLV_LEN])
|
||
readcrc = ord(e2[self._FAN_TLV_HDR_LEN + self.TLV_LEN]
|
||
) << 8 | ord(e2[self._FAN_TLV_HDR_LEN + self.TLV_LEN + 1])
|
||
if sumcrc != readcrc:
|
||
self._dstatus = -1
|
||
return ret
|
||
else:
|
||
self._dstatus = 0
|
||
while (tlv_index + 2) < len(e2) and tlv_index < tlv_end:
|
||
s = self.decoder(
|
||
e2[tlv_index:tlv_index + 2 + ord(e2[tlv_index + 1])])
|
||
tlv_index += ord(e2[tlv_index + 1]) + 2
|
||
ret.append(s)
|
||
|
||
return ret
|
||
|
||
@staticmethod
|
||
def fancrc(t):
|
||
sum = 0
|
||
for index in range(len(t)):
|
||
sum += ord(t[index])
|
||
return sum
|
||
|
||
def decoder(self, t):
|
||
try:
|
||
name = ""
|
||
value = ""
|
||
if ord(t[0]) == self._FAN_TLV_TYPE_NAME:
|
||
name = "Product Name"
|
||
value = str(t[2:2 + ord(t[1])])
|
||
self._typename = value
|
||
elif ord(t[0]) == self._FAN_TLV_TYPE_SN:
|
||
name = "serial Number"
|
||
value = str(t[2:2 + ord(t[1])])
|
||
self._typesn = value
|
||
elif ord(t[0]) == self._FAN_TLV_TYPE_HW_INFO:
|
||
name = "hardware info"
|
||
value = str(t[2:2 + ord(t[1])])
|
||
self._typehwinfo = value
|
||
elif ord(t[0]) == self._FAN_TLV_TYPE_DEV_TYPE:
|
||
name = "dev type"
|
||
value = str(t[2:2 + ord(t[1])])
|
||
value = str_to_hex(value)
|
||
self._typedevtype = value
|
||
value = "0x08%x" % value
|
||
except Exception as e:
|
||
print(e)
|
||
return {"name": name, "code": ord(t[0]), "value": value}
|
||
|
||
def __str__(self):
|
||
formatstr = "VERSION : 0x%02x \n" \
|
||
" FLAG : 0x%02x \n" \
|
||
" HW_VER : 0x%02x \n" \
|
||
" TYPE : 0x%02x \n" \
|
||
"typename : %s \n" \
|
||
"typesn : %s \n" \
|
||
"typehwinfo : %s \n"
|
||
return formatstr % (self.VERSION, self.FLAG, self.HW_VER, self.TYPE, self.typename, self.typesn, self.typehwinfo)
|
||
|
||
|
||
class AVSUTIL():
|
||
@staticmethod
|
||
def mac_avs_chip(bus, devno, loc, open, close, loop, protectaddr, level, loopaddr):
|
||
# disable protection
|
||
rji2cset(bus, devno, protectaddr, open)
|
||
rji2cset(bus, devno, loopaddr, loop)
|
||
rji2csetWord(bus, devno, loc, level)
|
||
ret, value = rji2cgetWord(bus, devno, loc)
|
||
if strtoint(value) == level:
|
||
ret = 0
|
||
# enable protection
|
||
rji2cset(bus, devno, protectaddr, close)
|
||
if ret == 0:
|
||
return True
|
||
return False
|
||
|
||
@staticmethod
|
||
def macPressure_adj(macavs, avs_param, mac_def_param):
|
||
# check whether it within range
|
||
max_adj = max(avs_param.keys())
|
||
min_adj = min(avs_param.keys())
|
||
type = mac_def_param["type"]
|
||
level = 0
|
||
if type == 0:
|
||
if macavs not in range(min_adj, max_adj + 1):
|
||
return False
|
||
else:
|
||
level = macavs
|
||
else:
|
||
if macavs not in range(min_adj, max_adj + 1):
|
||
level = mac_def_param["default"]
|
||
else:
|
||
level = macavs
|
||
ret = AVSUTIL.mac_avs_chip(mac_def_param["bus"], mac_def_param["devno"], mac_def_param["addr"], mac_def_param["open"],
|
||
mac_def_param["close"], mac_def_param["loop"], mac_def_param["protectaddr"], avs_param[level], mac_def_param["loopaddr"])
|
||
return ret
|
||
|
||
@staticmethod
|
||
def mac_adj():
|
||
macavs = 0
|
||
name = MAC_DEFAULT_PARAM["sdkreg"]
|
||
ret, status = getSdkReg(name)
|
||
if ret == False:
|
||
return False
|
||
status = strtoint(status)
|
||
# shift operation
|
||
if MAC_DEFAULT_PARAM["sdktype"] != 0:
|
||
status = (
|
||
status >> MAC_DEFAULT_PARAM["macregloc"]) & MAC_DEFAULT_PARAM["mask"]
|
||
macavs = status
|
||
ret = AVSUTIL.macPressure_adj(macavs, MAC_AVS_PARAM, MAC_DEFAULT_PARAM)
|
||
return ret
|
||
|
||
|
||
class I2CUTIL():
|
||
@staticmethod
|
||
def getvaluefromdevice(name):
|
||
ret = []
|
||
for item in DEVICE:
|
||
if item["name"] == name:
|
||
ret.append(item)
|
||
return ret
|
||
|
||
@staticmethod
|
||
def openFanE2Protect():
|
||
rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"], FAN_PROTECT["open"])
|
||
|
||
@staticmethod
|
||
def closeFanE2Protect():
|
||
rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"], FAN_PROTECT["close"])
|
||
|
||
@staticmethod
|
||
def writeToFanE2(bus, loc, rst_arr):
|
||
index = 0
|
||
for item in rst_arr:
|
||
rji2cset(bus, loc, index, ord(item))
|
||
index += 1
|
||
|
||
@staticmethod
|
||
def writeToE2(bus, loc, rst_arr):
|
||
index = 0
|
||
for item in rst_arr:
|
||
rji2cset(bus, loc, index, ord(item))
|
||
index += 1
|
||
|
||
@staticmethod
|
||
def getE2File(bus, loc):
|
||
return "/sys/bus/i2c/devices/%d-00%02x/eeprom" % (bus, loc)
|
||
|
||
|
||
class BMC():
|
||
_instance_lock = threading.Lock()
|
||
|
||
def __init__(self):
|
||
pass
|
||
|
||
def __new__(cls, *args, **kwargs):
|
||
if not hasattr(Singleton, "_instance"):
|
||
with Singleton._instance_lock:
|
||
if not hasattr(Singleton, "_instance"):
|
||
Singleton._instance = object.__new__(cls)
|
||
return Singleton._instance
|
||
|
||
# Internal interface
|
||
|
||
|
||
def getSdkReg(reg):
|
||
try:
|
||
cmd = "bcmcmd -t 1 'getr %s ' < /dev/null" % reg
|
||
ret, result = rj_os_system(cmd)
|
||
result_t = result.strip().replace("\r", "").replace("\n", "")
|
||
if ret != 0 or "Error:" in result_t:
|
||
return False, result
|
||
patt = r"%s.(.*):(.*)>drivshell" % reg
|
||
rt = re.findall(patt, result_t, re.S)
|
||
test = re.findall("=(.*)", rt[0][0])[0]
|
||
except Exception as e:
|
||
return False, 'getsdk register error'
|
||
return True, test
|
||
|
||
|
||
def getfilevalue(location):
|
||
try:
|
||
with open(location, 'r') as fd:
|
||
value = fd.read()
|
||
return True, value.strip()
|
||
except Exception as e:
|
||
return False, "error"
|
||
|
||
|
||
def get_sysfs_value(location):
|
||
pos_t = str(location)
|
||
name = get_pmc_register(pos_t)
|
||
return name
|
||
|
||
|
||
def write_sysfs_value(reg_name, value):
|
||
fileLoc = MAILBOX_DIR + reg_name
|
||
try:
|
||
if not os.path.isfile(fileLoc):
|
||
print(fileLoc, 'not found !')
|
||
return False
|
||
with open(fileLoc, 'w') as fd:
|
||
fd.write(value)
|
||
except Exception as error:
|
||
log_error("Unable to open " + fileLoc + "file !")
|
||
return False
|
||
return True
|
||
|
||
|
||
def RJPRINTERR(str):
|
||
print("\033[0;31m%s\033[0m" % str)
|
||
|
||
|
||
def strtoint(str): # convert Hex string to int such as "4040"/"0x4040"/"0X4040" = 16448
|
||
value = 0
|
||
rest_v = str.replace("0X", "").replace("0x", "")
|
||
for index in range(len(rest_v)):
|
||
print(rest_v[index])
|
||
value |= int(rest_v[index], 16) << ((len(rest_v) - index - 1) * 4)
|
||
return value
|
||
|
||
def inttostr(vl,len): # convert int to string such as 0x3030 = 00
|
||
if type(vl) != int:
|
||
raise Exception(" type error")
|
||
index = 0
|
||
ret_t = ""
|
||
while index < len:
|
||
ret = 0xff & (vl >> index * 8)
|
||
ret_t += chr(ret)
|
||
index += 1;
|
||
return ret_t
|
||
|
||
def str_to_hex(rest_v):
|
||
value = 0
|
||
for index in range(len(rest_v)):
|
||
value |= ord(rest_v[index]) << ((len(rest_v) - index - 1) * 8)
|
||
return value
|
||
|
||
|
||
def hex_to_str(s):
|
||
len_t = len(s)
|
||
if len_t % 2 != 0:
|
||
return 0
|
||
ret = ""
|
||
for t in range(0, int(len_t / 2)):
|
||
ret += chr(int(s[2 * t:2 * t + 2], 16))
|
||
return ret
|
||
|
||
|
||
def str_to_bin(s):
|
||
return ' '.join([bin(ord(c)).replace('0b', '') for c in s])
|
||
|
||
|
||
def bin_to_str(s):
|
||
return ''.join([chr(i) for i in [int(b, 2) for b in s.split(' ')]])
|
||
|
||
|
||
def getMacTemp():
|
||
result = {}
|
||
#waitForDocker()
|
||
# exec twice, get the second result
|
||
rj_os_system("bcmcmd -t 1 \"show temp\" < /dev/null")
|
||
ret, log = rj_os_system("bcmcmd -t 1 \"show temp\" < /dev/null")
|
||
if ret:
|
||
return False, result
|
||
else:
|
||
# decode obtained info
|
||
logs = log.splitlines()
|
||
for line in logs:
|
||
if "average" in line:
|
||
b = re.findall(r'\d+.\d+', line)
|
||
result["average"] = b[0]
|
||
elif "maximum" in line:
|
||
b = re.findall(r'\d+.\d+', line)
|
||
result["maximum"] = b[0]
|
||
return True, result
|
||
|
||
def getMacTemp_sysfs(mactempconf):
|
||
try:
|
||
temp = -1000000
|
||
temp_list = []
|
||
mac_temp_loc = mactempconf.get("loc", [])
|
||
mac_temp_flag = mactempconf.get("flag",None)
|
||
if mac_temp_flag is not None: # check mac temperature vaild flag
|
||
gettype = mac_temp_flag.get('gettype')
|
||
okbit = mac_temp_flag.get('okbit')
|
||
okval = mac_temp_flag.get('okval')
|
||
if gettype == "io":
|
||
io_addr = mac_temp_flag.get('io_addr')
|
||
val = io_rd(io_addr)
|
||
if val is None:
|
||
raise Exception("get mac_flag by io failed.")
|
||
else:
|
||
bus = mac_temp_flag.get('bus')
|
||
loc = mac_temp_flag.get('loc')
|
||
offset = mac_temp_flag.get('offset')
|
||
ind, val = rji2cget(bus, loc, offset)
|
||
if ind is not True:
|
||
raise Exception("get mac_flag by i2c failed.")
|
||
val_t = (int(val,16) & (1<< okbit)) >> okbit
|
||
if val_t != okval:
|
||
raise Exception("mac_flag invalid, val_t:%d." % val_t)
|
||
for loc in mac_temp_loc:
|
||
temp_s = get_sysfs_value(loc)
|
||
if isinstance(temp_s, str) and temp_s.startswith("ERR"):
|
||
raise Exception("get mac temp error. loc:%s" % loc)
|
||
temp_t = int(temp_s)
|
||
if temp_t == -1000000:
|
||
raise Exception("mac temp invalid.loc:%s" % loc)
|
||
temp_list.append(temp_t)
|
||
temp_list.sort(reverse=True)
|
||
temp = temp_list[0]
|
||
except Exception as e:
|
||
return False, temp
|
||
return True, temp
|
||
|
||
def restartDockerService(force=False):
|
||
container_name = ["database","snmp","syncd","swss","dhcp_relay","radv","teamd","pmon"]
|
||
ret, status = rj_os_system("docker ps")
|
||
if ret == 0 :
|
||
for tmpname in container_name:
|
||
if (tmpname not in status):
|
||
if (force == True):
|
||
rj_os_system("docker restart %s"%tmpname)
|
||
else:
|
||
rj_os_system("systemctl restart %s"%tmpname)
|
||
|
||
|
||
def waitForDhcp(timeout):
|
||
time_cnt = 0
|
||
while True:
|
||
try:
|
||
ret, status = rj_os_system("systemctl status dhcp_relay.service")
|
||
if (ret == 0 and "running" in status) or "SUCCESS" in status:
|
||
break
|
||
else:
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
time_cnt = time_cnt + 1
|
||
if time_cnt > timeout:
|
||
raise Exception("waitForDhcp timeout")
|
||
time.sleep(1)
|
||
except Exception as e:
|
||
return False
|
||
return True
|
||
|
||
def waitForSdk(sdk_fpath ,timeout):
|
||
time_cnt = 0
|
||
while True:
|
||
try:
|
||
if os.path.exists(sdk_fpath):
|
||
break
|
||
else:
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
time_cnt = time_cnt + 1
|
||
if time_cnt > timeout:
|
||
raise Exception("waitForSdk timeout")
|
||
time.sleep(1)
|
||
except Exception as e:
|
||
return False
|
||
return True
|
||
|
||
def waitForDocker(need_restart=False,timeout=180):
|
||
sdkcheck_params = STARTMODULE.get("sdkcheck",{})
|
||
if sdkcheck_params.get("checktype") == "file": # pass file check
|
||
sdk_fpath = sdkcheck_params.get("sdk_fpath")
|
||
return waitForSdk(sdk_fpath,timeout)
|
||
return waitForDhcp(timeout)
|
||
|
||
|
||
def getTLV_BODY(type, productname):
|
||
x = []
|
||
temp_t = ""
|
||
if type == TLV_CODE_MAC_BASE:
|
||
arr = productname.split(':')
|
||
for tt in arr:
|
||
temp_t += chr(int(tt, 16))
|
||
elif type == TLV_CODE_DEVICE_VERSION:
|
||
temp_t = chr(productname)
|
||
elif type == TLV_CODE_MAC_SIZE:
|
||
temp_t = chr(productname >> 8) + chr(productname & 0x00ff)
|
||
else:
|
||
temp_t = productname
|
||
x.append(chr(type))
|
||
x.append(chr(len(temp_t)))
|
||
for i in temp_t:
|
||
x.append(i)
|
||
return x
|
||
|
||
|
||
def _crc32(v):
|
||
return '0x%08x' % (binascii.crc32(v) & 0xffffffff) # get 8 bytes of crc32 %x return hex
|
||
|
||
|
||
def printvalue(b):
|
||
index = 0
|
||
for i in range(0, len(b)):
|
||
if index % 16 == 0:
|
||
print(" ")
|
||
print("%02x " % ord(b[i]))
|
||
index += 1
|
||
print("\n")
|
||
|
||
|
||
def generate_value(_t):
|
||
ret = []
|
||
for i in TLV_INFO_ID_STRING:
|
||
ret.append(i)
|
||
ret.append(chr(TLV_INFO_VERSION))
|
||
ret.append(chr(TLV_INFO_LENGTH))
|
||
ret.append(chr(TLV_INFO_LENGTH_VALUE))
|
||
|
||
total_len = 0
|
||
for key in _t:
|
||
x = getTLV_BODY(key, _t[key])
|
||
ret += x
|
||
total_len += len(x)
|
||
ret[10] = chr(total_len + 6)
|
||
|
||
ret.append(chr(0xFE))
|
||
ret.append(chr(0x04))
|
||
s = _crc32(''.join(ret))
|
||
for t in range(0, 4):
|
||
ret.append(chr(int(s[2 * t + 2:2 * t + 4], 16)))
|
||
totallen = len(ret)
|
||
if (totallen < 256):
|
||
for left_t in range(0, 256 - totallen):
|
||
ret.append(chr(0x00))
|
||
return (ret, True)
|
||
|
||
|
||
def getsyseeprombyId(id):
|
||
ret = get_sys_eeprom()
|
||
for item in ret:
|
||
if item["code"] == id:
|
||
return item
|
||
return None
|
||
|
||
|
||
def fac_init_cardidcheck():
|
||
rest = getsyseeprombyId(TLV_CODE_RJ_CARID) # check cardId same or not
|
||
if rest is None:
|
||
print("need to program write bin file")
|
||
return False
|
||
else:
|
||
rest_v = rest['value']
|
||
value = strtoint(rest_v)
|
||
if value == RUIJIE_CARDID:
|
||
log_debug("check card ID pass")
|
||
else:
|
||
log_debug("check card ID error")
|
||
return False
|
||
return True
|
||
|
||
|
||
def isValidMac(mac):
|
||
if re.match(r"^\s*([0-9a-fA-F]{2,2}:){5,5}[0-9a-fA-F]{2,2}\s*$", mac):
|
||
return True
|
||
return False
|
||
|
||
# Internet cardsetmac
|
||
|
||
|
||
def util_setmac(eth, mac):
|
||
rulefile = "/etc/udev/rules.d/70-persistent-net.rules"
|
||
if isValidMac(mac) == False:
|
||
return False, "MAC invaild"
|
||
cmd = "ethtool -e %s | grep 0x0010 | awk '{print \"0x\"$13$12$15$14}'" % eth
|
||
ret, log = rj_os_system(cmd)
|
||
log_debug(log)
|
||
magic = ""
|
||
if ret == 0 and len(log):
|
||
magic = log
|
||
macs = mac.upper().split(":")
|
||
|
||
# chage ETH0 to value after setmac
|
||
ifconfigcmd = "ifconfig eth0 hw ether %s" % mac
|
||
log_debug(ifconfigcmd)
|
||
ret, status = rj_os_system(ifconfigcmd)
|
||
if ret:
|
||
raise SETMACException("software set Internet cardMAC error")
|
||
index = 0
|
||
for item in macs:
|
||
cmd = "ethtool -E %s magic %s offset %d value 0x%s" % (
|
||
eth, magic, index, item)
|
||
log_debug(cmd)
|
||
index += 1
|
||
ret, log = rj_os_system(cmd)
|
||
if ret != 0:
|
||
raise SETMACException(" set hardware Internet card MAC error")
|
||
# get value after setting
|
||
cmd_t = "ethtool -e eth0 offset 0 length 6"
|
||
ret, log = rj_os_system(cmd_t)
|
||
m = re.split(':', log)[-1].strip().upper()
|
||
mac_result = m.upper().split(" ")
|
||
|
||
for ind, s in enumerate(macs):
|
||
if s != mac_result[ind]:
|
||
RJPRINTERR("MAC comparison error")
|
||
if os.path.exists(rulefile):
|
||
os.remove(rulefile)
|
||
print("MGMT MAC[%s]" % mac)
|
||
return True
|
||
|
||
|
||
def getInputCheck(tips):
|
||
str = raw_input(tips)
|
||
if astrcmp(str, "y") or astrcmp(str, "ye") or astrcmp(str, "yes") or astrcmp(str, ""):
|
||
return True
|
||
else:
|
||
return False
|
||
|
||
def getrawch():
|
||
fd = sys.stdin.fileno()
|
||
old_settings = termios.tcgetattr(fd)
|
||
try:
|
||
tty.setraw(sys.stdin.fileno())
|
||
ch = sys.stdin.read(1)
|
||
finally:
|
||
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
|
||
return ch
|
||
|
||
def upper_input(tips):
|
||
sys.stdout.write(tips)
|
||
sys.stdout.flush()
|
||
passwd = []
|
||
while True:
|
||
ch = getrawch().upper()
|
||
if ch == "\r" or ch == "\n":
|
||
return "".join(passwd)
|
||
elif ch == '\b' or ord(ch) == 127:
|
||
if passwd:
|
||
del passwd[-1]
|
||
sys.stdout.write('\b \b')
|
||
else:
|
||
sys.stdout.write(ch)
|
||
passwd.append(ch)
|
||
|
||
def changeTypeValue(_value, type1, tips, example):
|
||
if type1 == TLV_CODE_PRODUCT_NAME:
|
||
while True:
|
||
print("please check (1)air from forward to backward/(2)air from backward to forward:")
|
||
option = raw_input()
|
||
if option == "1":
|
||
_value[type1] = example + "-F-RJ"
|
||
print("check Product is air from forward to backward device,Product Name:%s"%_value[type1])
|
||
break
|
||
elif option == "2":
|
||
_value[type1] = example + "-R-RJ"
|
||
print("check Product is air from backward to forward device,Product Name:%s"%_value[type1])
|
||
break
|
||
else:
|
||
print("input incorrect, check please")
|
||
return True
|
||
print("Please input[%s]such as(%s):" % (tips, example))
|
||
name = upper_input("")
|
||
if type1 == TLV_CODE_MAC_BASE:
|
||
if len(name) != 12:
|
||
raise SETMACException("MAC address length incorrect, check please")
|
||
release_mac = ""
|
||
for i in range(int(len(name) / 2)):
|
||
if i == 0:
|
||
release_mac += name[i * 2:i * 2 + 2]
|
||
else:
|
||
release_mac += ":" + name[i * 2:i * 2 + 2]
|
||
if isValidMac(release_mac) == True:
|
||
_value[type1] = release_mac
|
||
else:
|
||
raise SETMACException("MAC address invaild, check please")
|
||
elif type1 == TLV_CODE_DEVICE_VERSION:
|
||
if name.isdigit():
|
||
_value[type1] = int(name)
|
||
else:
|
||
raise SETMACException("Version is not number, check please")
|
||
elif type1 == TLV_CODE_MAC_SIZE:
|
||
if name.isdigit():
|
||
_value[type1] = int(name, 16)
|
||
else:
|
||
raise SETMACException("Version is not number, check please")
|
||
elif type1 == TLV_CODE_SERIAL_NUMBER:
|
||
if name.isalnum() == False:
|
||
raise SETMACException("Serial Number invaild string, check please")
|
||
elif len(name) != 13:
|
||
raise SETMACException("Serial Number length incorrect, check please")
|
||
else:
|
||
_value[type1] = name
|
||
elif type1 == TLV_CODE_VENDOR_EXT:
|
||
_value[type1] = name
|
||
else:
|
||
_value[type1] = name
|
||
return True
|
||
|
||
|
||
def astrcmp(str1, str2):
|
||
return str1.lower() == str2.lower()
|
||
|
||
|
||
def generate_ext(cardid):
|
||
s = "%08x" % cardid
|
||
ret = ""
|
||
for t in range(0, 4):
|
||
ret += chr(int(s[2 * t:2 * t + 2], 16))
|
||
ret = chr(0x01) + chr(len(ret)) + ret
|
||
return ret
|
||
|
||
|
||
def rji2cget(bus, devno, address):
|
||
command_line = "i2cget -f -y %d 0x%02x 0x%02x " % (bus, devno, address)
|
||
retrytime = 6
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = rj_os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
time.sleep(0.1)
|
||
return False, ret_t
|
||
|
||
|
||
def rji2cset(bus, devno, address, byte):
|
||
command_line = "i2cset -f -y %d 0x%02x 0x%02x 0x%02x" % (
|
||
bus, devno, address, byte)
|
||
retrytime = 6
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = rj_os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
return False, ret_t
|
||
|
||
def rjpcird(pcibus , slot , fn, bar, offset):
|
||
'''read pci register'''
|
||
if offset % 4 != 0:
|
||
return
|
||
filename = "/sys/bus/pci/devices/0000:%02x:%02x.%x/resource%d" % (int(pcibus), int(slot), int(fn), int(bar))
|
||
file = open(filename, "r+")
|
||
size = os.path.getsize(filename)
|
||
data = mmap.mmap(file.fileno(), size)
|
||
result = data[offset: offset + 4]
|
||
s = result[::-1]
|
||
val = 0
|
||
for i in range(0, len(s)):
|
||
val = val << 8 | ord(s[i])
|
||
return "0x%08x" % val
|
||
|
||
|
||
def rjpciwr(pcibus , slot ,fn, bar, offset, data):
|
||
'''write pci register'''
|
||
ret = inttostr(data, 4)
|
||
filename = "/sys/bus/pci/devices/0000:%02x:%02x.%x/resource%d" % (int(pcibus), int(slot), int(fn), int(bar))
|
||
file = open(filename, "r+")
|
||
size = os.path.getsize(filename)
|
||
data = mmap.mmap(file.fileno(), size)
|
||
data[offset: offset + 4] = ret
|
||
result = data[offset: offset + 4]
|
||
s = result[::-1]
|
||
val = 0
|
||
for i in range(0, len(s)):
|
||
val = val << 8 | ord(s[i])
|
||
data.close()
|
||
|
||
def rjsysset(location, value):
|
||
command_line = "echo 0x%02x > %s" % (value, location)
|
||
retrytime = 6
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = rj_os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
return False, ret_t
|
||
|
||
|
||
def rji2cgetWord(bus, devno, address):
|
||
command_line = "i2cget -f -y %d 0x%02x 0x%02x w" % (bus, devno, address)
|
||
retrytime = 3
|
||
ret_t = ""
|
||
for i in range(retrytime):
|
||
ret, ret_t = rj_os_system(command_line)
|
||
if ret == 0:
|
||
return True, ret_t
|
||
return False, ret_t
|
||
|
||
|
||
def rji2csetWord(bus, devno, address, byte):
|
||
command_line = "i2cset -f -y %d 0x%02x 0x%02x 0x%x w" % (
|
||
bus, devno, address, byte)
|
||
rj_os_system(command_line)
|
||
|
||
|
||
def fan_setmac():
|
||
rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"], FAN_PROTECT["open"])
|
||
rji2cset(FAN_PROTECT["bus"], FAN_PROTECT["devno"],
|
||
FAN_PROTECT["addr"], FAN_PROTECT["close"])
|
||
|
||
|
||
def checkfansninput(fan_sn, fansntemp):
|
||
if fan_sn in fansntemp:
|
||
RJPRINTERR("exist same Serial Number，please input again")
|
||
return False
|
||
if(len(fan_sn) != 13):
|
||
RJPRINTERR("Serial Number length incorrect，please input again")
|
||
return False
|
||
return True
|
||
|
||
# check 输入的hardware version
|
||
|
||
|
||
def checkfanhwinput(hw):
|
||
if len(hw) != 4:
|
||
RJPRINTERR("hardware version length incorrect, please input again")
|
||
return False
|
||
if hw.find(".") != 1:
|
||
RJPRINTERR("hardware version incorrect, please input again")
|
||
return False
|
||
return True
|
||
|
||
|
||
def util_show_fanse2(fans):
|
||
formatstr = "%-8s %-20s %-20s %-20s %-20s"
|
||
print(formatstr % ("id", "Name", "hardware version", "Serial Number", "Time"))
|
||
print(formatstr % ("------", "---------------", "---------------", "---------------", "----"))
|
||
for fan in fans:
|
||
# print fan.dstatus
|
||
if fan.dstatus < 0:
|
||
print("%-8s" % ("FAN%d" % (fans.index(fan) + 1)))
|
||
RJPRINTERR(" decode e2 error")
|
||
else:
|
||
print(formatstr % ("FAN%d" % (fans.index(fan) + 1), fan.typename.replace(chr(0x00), ""),
|
||
fan.typehwinfo.replace(chr(0x00), ""), fan.typesn.replace(chr(0x00), ""), fan.fandecodetime))
|
||
|
||
|
||
def get_fane2_sysfs(bus, loc):
|
||
rg_fan_e2 = "%d-%04x/fan" % (bus, loc)
|
||
eeprom = get_sysfs_value(rg_fan_e2)
|
||
return eeprom
|
||
|
||
|
||
def util_show_fane2():
|
||
ret = sorted(I2CUTIL.getvaluefromdevice("rg_fan"))
|
||
if len(ret) <=0:
|
||
return None
|
||
fans = []
|
||
for index in range(len(ret)):
|
||
t1 = (int(round(time.time() * 1000)))
|
||
eeprom = get_fane2_sysfs(ret[index]["bus"], ret[index]["loc"])
|
||
t2 = (int(round(time.time() * 1000)))
|
||
fane2 = fan_tlv()
|
||
fane2.fandecodetime = t2 - t1
|
||
fane2.decode(eeprom)
|
||
fans.append(fane2)
|
||
util_show_fanse2(fans)
|
||
|
||
|
||
def getPid(name):
|
||
ret = []
|
||
for dirname in os.listdir('/proc'):
|
||
if dirname == 'curproc':
|
||
continue
|
||
try:
|
||
with open('/proc/{}/cmdline'.format(dirname), mode='rb') as fd:
|
||
content = fd.read()
|
||
except Exception:
|
||
continue
|
||
if name in content:
|
||
ret.append(dirname)
|
||
return ret
|
||
|
||
def fac_fans_setmac_tlv(ret):
|
||
if len(ret) <=0:
|
||
return None
|
||
fans = []
|
||
fansntemp = []
|
||
for index in range(len(ret)):
|
||
item = ret[index]
|
||
log_debug(item)
|
||
eeprom = get_fane2_sysfs(item["bus"], item["loc"])
|
||
fane2 = fan_tlv()
|
||
fane2.decode(eeprom)
|
||
fane2.fanbus = item["bus"]
|
||
fane2.fanloc = item["loc"]
|
||
log_debug("decode eeprom success")
|
||
|
||
print("Fan[%d]-[%s]setmac" % ((index + 1), FANS_DEF[fane2.typedevtype]))
|
||
while True:
|
||
print("Please input[%s]:" % "Serial Number")
|
||
fan_sn = raw_input()
|
||
if checkfansninput(fan_sn, fansntemp) == False:
|
||
continue
|
||
fansntemp.append(fan_sn)
|
||
fan_sn = fan_sn + chr(0x00)
|
||
fane2.typesn = fan_sn + chr(0x00)
|
||
break
|
||
while True:
|
||
print("Please input[%s]:" % "hardware version")
|
||
hwinfo = raw_input()
|
||
if checkfanhwinput(hwinfo) == False:
|
||
continue
|
||
fan_hwinfo = hwinfo + chr(0x00)
|
||
fane2.typehwinfo = fan_hwinfo + chr(0x00)
|
||
break
|
||
log_debug(fane2.typedevtype)
|
||
fane2.typename = FANS_DEF[fane2.typedevtype] + chr(0x00)
|
||
fans.append(fane2)
|
||
print("\n")
|
||
print("\n*******************************\n")
|
||
|
||
util_show_fanse2(fans)
|
||
if getInputCheck("check input correctly or not（Yes/No):") == True:
|
||
for fan in fans:
|
||
log_debug("ouput fan")
|
||
fac_fan_setmac(fan)
|
||
else:
|
||
print("setmac quit")
|
||
return False
|
||
|
||
|
||
def fac_fan_setmac_fru(ret):
|
||
fans = FRULISTS.get('fans')
|
||
|
||
fanfrus = {}
|
||
newfrus = {}
|
||
|
||
#getmsg
|
||
try:
|
||
for fan in fans:
|
||
print("===============%s ================getmessage" % fan.get('name'))
|
||
eeprom = getsysvalue(I2CUTIL.getE2File(fan.get('bus'), fan.get('loc')))
|
||
fru = ipmifru()
|
||
fru.decodeBin(eeprom)
|
||
fanfrus[fan.get('name')] = fru
|
||
except Exception as e:
|
||
print(str(e))
|
||
return False
|
||
|
||
#setmsg
|
||
for fan in fans:
|
||
print("===============%s ================setmac" % fan.get('name'))
|
||
fruold = fanfrus.get(fan.get('name'))
|
||
newfru = getInputSetmac(fruold)
|
||
newfru.recalcute()
|
||
newfrus[fan.get('name')] = newfru
|
||
#writemsg
|
||
for fan in fans:
|
||
print("===============%s ================writeToE2" % fan.get('name'))
|
||
ret_t = newfrus.get(fan.get('name'))
|
||
I2CUTIL.openFanE2Protect()
|
||
I2CUTIL.writeToFanE2(fan.get('bus'), fan.get('loc'), ret_t.bindata)
|
||
I2CUTIL.closeFanE2Protect()
|
||
#check
|
||
try:
|
||
for fan in fans:
|
||
print("===============%s ================getmessage" % fan.get('name'))
|
||
eeprom = getsysvalue(I2CUTIL.getE2File(fan.get('bus'), fan.get('loc')))
|
||
fru = ipmifru()
|
||
fru.decodeBin(eeprom)
|
||
except Exception as e:
|
||
print(str(e))
|
||
return False
|
||
return True
|
||
|
||
def fac_fans_setmac():
|
||
ret = I2CUTIL.getvaluefromdevice("rg_fan")
|
||
if ret is not None and len(ret) > 0:
|
||
return fac_fans_setmac_tlv(ret)
|
||
fans = FRULISTS.get('fans', None)
|
||
if fans is not None and len(fans)>0:
|
||
return fac_fan_setmac_fru(ret)
|
||
return False
|
||
|
||
def fac_fan_setmac(item):
|
||
I2CUTIL.openFanE2Protect()
|
||
I2CUTIL.writeToFanE2(item.fanbus, item.fanloc, item.generate_fan_value())
|
||
I2CUTIL.closeFanE2Protect()
|
||
|
||
def writeToEEprom(rst_arr):
|
||
dealtype = E2_PROTECT.get('gettype',None)
|
||
if dealtype is None:
|
||
rji2cset(E2_PROTECT["bus"], E2_PROTECT["devno"],
|
||
E2_PROTECT["addr"], E2_PROTECT["open"])
|
||
elif dealtype == "io":
|
||
io_wr(E2_PROTECT["io_addr"], E2_PROTECT["open"])
|
||
index = 0
|
||
for item in rst_arr:
|
||
rji2cset(E2_LOC["bus"], E2_LOC["devno"], index, ord(item))
|
||
index += 1
|
||
|
||
if dealtype is None:
|
||
rji2cset(E2_PROTECT["bus"], E2_PROTECT["devno"],
|
||
E2_PROTECT["addr"], E2_PROTECT["close"])
|
||
elif dealtype == "io":
|
||
io_wr(E2_PROTECT["io_addr"], E2_PROTECT["close"])
|
||
# deal last drivers
|
||
os.system("rmmod at24 ")
|
||
os.system("modprobe at24 ")
|
||
os.system("rm -f /var/cache/sonic/decode-syseeprom/syseeprom_cache")
|
||
|
||
|
||
def get_local_eth0_mac():
|
||
cmd = "ifconfig eth0 |grep HWaddr"
|
||
print(rj_os_system(cmd))
|
||
|
||
def getonieversion():
|
||
if not os.path.isfile('/host/machine.conf'):
|
||
return ""
|
||
machine_vars = {}
|
||
with open('/host/machine.conf') as machine_file:
|
||
for line in machine_file:
|
||
tokens = line.split('=')
|
||
if len(tokens) < 2:
|
||
continue
|
||
machine_vars[tokens[0]] = tokens[1].strip()
|
||
return machine_vars.get("onie_version")
|
||
|
||
def createbmcMac(cpumac , num = 2):
|
||
bcmvalue = strtoint(cpumac[cpumac.rindex(":")+ 1:len(cpumac)]) + num
|
||
# bmcmac =
|
||
t = cpumac.split(":")
|
||
t[5] = "%02x" % bcmvalue
|
||
bmcmac = ":".join(t)
|
||
return bmcmac.upper()
|
||
|
||
|
||
def fac_board_setmac():
|
||
_value = {}
|
||
# default value
|
||
_value[TLV_CODE_VENDOR_EXT] = generate_ext(RUIJIE_CARDID) # generate id
|
||
_value[TLV_CODE_PRODUCT_NAME] = RUIJIE_PRODUCTNAME
|
||
_value[TLV_CODE_PART_NUMBER] = RUIJIE_PART_NUMBER
|
||
_value[TLV_CODE_LABEL_REVISION] = RUIJIE_LABEL_REVISION
|
||
_value[TLV_CODE_PLATFORM_NAME] = platform
|
||
_value[TLV_CODE_ONIE_VERSION] = getonieversion()
|
||
_value[TLV_CODE_MAC_SIZE] = RUIJIE_MAC_SIZE
|
||
_value[TLV_CODE_MANUF_NAME] = RUIJIE_MANUF_NAME
|
||
_value[TLV_CODE_MANUF_COUNTRY] = RUIJIE_MANUF_COUNTRY
|
||
_value[TLV_CODE_VENDOR_NAME] = RUIJIE_VENDOR_NAME
|
||
_value[TLV_CODE_DIAG_VERSION] = RUIJIE_DIAG_VERSION
|
||
_value[TLV_CODE_SERVICE_TAG] = RUIJIE_SERVICE_TAG
|
||
try:
|
||
if 0x00004052 == RUIJIE_CARDID:
|
||
_value[TLV_CODE_PRODUCT_NAME] = RUIJIE_PRODUCTNAME + "-RJ"
|
||
elif 0x00004051 == RUIJIE_CARDID or 0x00004050 == RUIJIE_CARDID:
|
||
changeTypeValue(_value, TLV_CODE_PRODUCT_NAME,
|
||
"Product name",RUIJIE_PRODUCTNAME)
|
||
|
||
changeTypeValue(_value, TLV_CODE_SERIAL_NUMBER,
|
||
"SN", "0000000000000") # add serial number
|
||
changeTypeValue(_value, TLV_CODE_DEVICE_VERSION,
|
||
"hardware version", "101") # hardware version
|
||
changeTypeValue(_value, TLV_CODE_MAC_BASE,
|
||
"MAC address", "58696cfb2108") # MAC address
|
||
_value[TLV_CODE_MANUF_DATE] = time.strftime(
|
||
'%m/%d/%Y %H:%M:%S', time.localtime()) # add setmac time
|
||
rst, ret = generate_value(_value)
|
||
if util_setmac("eth0", _value[TLV_CODE_MAC_BASE]) == True: # set Internet cardIP
|
||
writeToEEprom(rst) # write to e2
|
||
# set BMC MAC
|
||
if "bmcsetmac" in FACTESTMODULE and FACTESTMODULE['bmcsetmac'] == 1:
|
||
bmcmac = createbmcMac(_value[TLV_CODE_MAC_BASE])
|
||
if ipmi_set_mac(bmcmac) == True:
|
||
print("BMC MAC[%s]"%bmcmac)
|
||
else:
|
||
print("SET BMC MAC FAILED")
|
||
return False
|
||
else:
|
||
return False
|
||
except SETMACException as e:
|
||
#print(e)
|
||
RJPRINTERR("\n\n%s\n\n" % e)
|
||
return False
|
||
except ValueError as e:
|
||
return False
|
||
return True
|
||
|
||
|
||
def ipmi_set_mac(mac):
|
||
macs = mac.split(":")
|
||
cmdinit = "ipmitool raw 0x0c 0x01 0x01 0xc2 0x00"
|
||
cmdset = "ipmitool raw 0x0c 0x01 0x01 0x05"
|
||
for ind in range(len(macs)):
|
||
cmdset += " 0x%02x" % int(macs[ind], 16)
|
||
rj_os_system(cmdinit)
|
||
ret, status = rj_os_system(cmdset)
|
||
if ret:
|
||
RJPRINTERR("\n\n%s\n\n" % status)
|
||
return False
|
||
return True
|
||
|
||
|
||
def getInputValue(title, tips):
|
||
print("Please input[%s]such as(%s):" % (title, tips))
|
||
name = raw_input()
|
||
|
||
return name
|
||
|
||
|
||
def bmc_setmac():
|
||
tips = "BMC MAC"
|
||
print("Please input value you want to change[%s]:" % tips)
|
||
name = raw_input()
|
||
if len(name) != 12:
|
||
RJPRINTERR("\nMAC address invaild, try again\n")
|
||
return False
|
||
release_mac = ""
|
||
for i in range(int(len(name) / 2)):
|
||
if i == 0:
|
||
release_mac += name[i * 2:i * 2 + 2]
|
||
else:
|
||
release_mac += ":" + name[i * 2:i * 2 + 2]
|
||
if isValidMac(release_mac) == True:
|
||
if ipmi_set_mac(release_mac) == True:
|
||
return True
|
||
else:
|
||
RJPRINTERR("\nMAC address invaild, try again\n")
|
||
return False
|
||
|
||
|
||
def closeProtocol():
|
||
# disable LLDP
|
||
log_info("disable LLDP")
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
rj_os_system("systemctl stop lldp.service")
|
||
log_info("disable lldp service")
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
rj_os_system("systemctl stop bgp.service")
|
||
log_info("disable bgp service")
|
||
sys.stdout.write(".")
|
||
sys.stdout.flush()
|
||
#ret, status = rj_os_system('bcmcmd "port ce,xe stp=disable"')
|
||
|
||
# check SDK memory must be 256M
|
||
|
||
|
||
def checkSdkMem():
|
||
ind = 0
|
||
file_data = ""
|
||
with open(file_name, "r") as f:
|
||
for line in f:
|
||
if "dmasize=16M" in line:
|
||
line = line.replace("dmasize=16M", "dmasize=256M")
|
||
ind = -1
|
||
file_data += line
|
||
if ind == 0:
|
||
return
|
||
with open(file_name, "w") as f:
|
||
f.write(file_data)
|
||
print("change SDK memory to 256, reboot required")
|
||
rj_os_system("sync")
|
||
rj_os_system("reboot")
|
||
|
||
##########################################################################
|
||
# receives a character setting
|
||
##########################################################################
|
||
|
||
|
||
def getch(msg):
|
||
ret = ""
|
||
fd = sys.stdin.fileno()
|
||
old_ttyinfo = termios.tcgetattr(fd)
|
||
new_ttyinfo = old_ttyinfo[:]
|
||
new_ttyinfo[3] &= ~termios.ICANON
|
||
new_ttyinfo[3] &= ~termios.ECHO
|
||
sys.stdout.write(msg)
|
||
sys.stdout.flush()
|
||
try:
|
||
termios.tcsetattr(fd, termios.TCSANOW, new_ttyinfo)
|
||
ret = os.read(fd, 1)
|
||
finally:
|
||
# print "try to setting"
|
||
termios.tcsetattr(fd, termios.TCSANOW, old_ttyinfo)
|
||
return ret
|
||
|
||
def get_raw_input():
|
||
ret=""
|
||
fd=sys.stdin.fileno()
|
||
old_ttyinfo=termios.tcgetattr(fd)
|
||
new_ttyinfo=old_ttyinfo[:]
|
||
new_ttyinfo[3] &= ~termios.ICANON
|
||
new_ttyinfo[3] &= ~termios.ECHO
|
||
try:
|
||
termios.tcsetattr(fd,termios.TCSANOW,new_ttyinfo)
|
||
ret=raw_input("")
|
||
except Exception as e:
|
||
print(e)
|
||
finally:
|
||
termios.tcsetattr(fd,termios.TCSANOW,old_ttyinfo)
|
||
return ret
|
||
|
||
|
||
def getsysvalue(location):
|
||
retval = None
|
||
mb_reg_file = location
|
||
if (not os.path.isfile(mb_reg_file)):
|
||
print(mb_reg_file, 'not found !')
|
||
return retval
|
||
try:
|
||
if (not os.path.isfile(mb_reg_file)):
|
||
print(mb_reg_file, 'not found !')
|
||
return retval
|
||
with open(mb_reg_file, 'r') as fd:
|
||
retval = fd.read()
|
||
except Exception as error:
|
||
log_error("Unable to open " + mb_reg_file + "file !")
|
||
retval = retval.rstrip('\r\n')
|
||
retval = retval.lstrip(" ")
|
||
#log_debug(retval)
|
||
return retval
|
||
|
||
# get file value
|
||
|
||
|
||
def get_pmc_register(reg_name):
|
||
retval = 'ERR'
|
||
mb_reg_file = MAILBOX_DIR + reg_name
|
||
filepath = glob.glob(mb_reg_file)
|
||
if(len(filepath) == 0):
|
||
return "%s %s notfound"% (retval , mb_reg_file)
|
||
mb_reg_file = filepath[0]
|
||
if (not os.path.isfile(mb_reg_file)):
|
||
return "%s %s notfound"% (retval , mb_reg_file)
|
||
try:
|
||
with open(mb_reg_file, 'r') as fd:
|
||
retval = fd.read()
|
||
except Exception as error:
|
||
pass
|
||
retval = retval.rstrip('\r\n')
|
||
retval = retval.lstrip(" ")
|
||
return retval
|
||
|
||
# decode EEPROM
|
||
|
||
|
||
def decoder(s, t):
|
||
if ord(t[0]) == TLV_CODE_PRODUCT_NAME:
|
||
name = "Product Name"
|
||
value = str(t[2:2 + ord(t[1])])
|
||
elif ord(t[0]) == TLV_CODE_PART_NUMBER:
|
||
name = "Part Number"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_SERIAL_NUMBER:
|
||
name = "Serial Number"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_MAC_BASE:
|
||
name = "Base MAC Address"
|
||
value = ":".join([binascii.b2a_hex(T) for T in t[2:8]]).upper()
|
||
elif ord(t[0]) == TLV_CODE_MANUF_DATE:
|
||
name = "Manufacture Date"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_DEVICE_VERSION:
|
||
name = "Device Version"
|
||
value = str(ord(t[2]))
|
||
elif ord(t[0]) == TLV_CODE_LABEL_REVISION:
|
||
name = "Label Revision"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_PLATFORM_NAME:
|
||
name = "Platform Name"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_ONIE_VERSION:
|
||
name = "ONIE Version"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_MAC_SIZE:
|
||
name = "MAC Addresses"
|
||
value = str((ord(t[2]) << 8) | ord(t[3]))
|
||
elif ord(t[0]) == TLV_CODE_MANUF_NAME:
|
||
name = "Manufacturer"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_MANUF_COUNTRY:
|
||
name = "Manufacture Country"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_VENDOR_NAME:
|
||
name = "Vendor Name"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_DIAG_VERSION:
|
||
name = "Diag Version"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_SERVICE_TAG:
|
||
name = "Service Tag"
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_VENDOR_EXT:
|
||
name = "Vendor Extension"
|
||
value = ""
|
||
if _TLV_DISPLAY_VENDOR_EXT:
|
||
value = t[2:2 + ord(t[1])]
|
||
elif ord(t[0]) == TLV_CODE_CRC_32 and len(t) == 6:
|
||
name = "CRC-32"
|
||
value = "0x%08X" % (((ord(t[2]) << 24) | (
|
||
ord(t[3]) << 16) | (ord(t[4]) << 8) | ord(t[5])),)
|
||
elif ord(t[0]) == TLV_CODE_RJ_CARID:
|
||
name = "rj_cardid"
|
||
value = ""
|
||
for c in t[2:2 + ord(t[1])]:
|
||
value += "%02X" % (ord(c),)
|
||
else:
|
||
name = "Unknown"
|
||
value = ""
|
||
for c in t[2:2 + ord(t[1])]:
|
||
value += "0x%02X " % (ord(c),)
|
||
return {"name": name, "code": ord(t[0]), "value": value}
|
||
|
||
|
||
def decode_eeprom(e):
|
||
total_len = (ord(e[9]) << 8) | ord(e[10])
|
||
tlv_index = _TLV_INFO_HDR_LEN
|
||
tlv_end = _TLV_INFO_HDR_LEN + total_len
|
||
ret = []
|
||
while (tlv_index + 2) < len(e) and tlv_index < tlv_end:
|
||
rt = decoder(None, e[tlv_index:tlv_index + 2 + ord(e[tlv_index + 1])])
|
||
ret.append(rt)
|
||
if ord(e[tlv_index]) == TLV_CODE_CRC_32:
|
||
break
|
||
tlv_index += ord(e[tlv_index + 1]) + 2
|
||
for item in ret:
|
||
if item['code'] == TLV_CODE_VENDOR_EXT:
|
||
rt = decoder(None, item["value"]
|
||
[0: 0 + 2 + ord(item["value"][0 + 1])])
|
||
ret.append(rt)
|
||
return ret
|
||
|
||
|
||
def get_sys_eeprom():
|
||
eeprom = get_sysfs_value(rg_eeprom)
|
||
return decode_eeprom(eeprom)
|
||
|
||
# get card ID
|
||
def getCardId():
|
||
ret = get_sys_eeprom()
|
||
for item in ret:
|
||
if item['code'] == TLV_CODE_RJ_CARID:
|
||
return item.get('value',None)
|
||
return None
|
||
|
||
# ====================================
|
||
# execute shell command
|
||
# ====================================
|
||
def rj_os_system(cmd):
|
||
status, output = subprocess.getstatusoutput(cmd)
|
||
return status, output
|
||
|
||
###########################################
|
||
# get memory slot and number via DMI command
|
||
###########################################
|
||
def getsysmeminfo():
|
||
ret, log = rj_os_system("which dmidecode ")
|
||
if ret != 0 or len(log) <= 0:
|
||
error = "cmd find dmidecode"
|
||
return False, error
|
||
cmd = log + "|grep -P -A5 \"Memory\s+Device\"|grep Size|grep -v Range"
|
||
# get total number first
|
||
result = []
|
||
ret1, log1 = rj_os_system(cmd)
|
||
if ret1 == 0 and len(log1):
|
||
log1 = log1.lstrip()
|
||
arr = log1.split("\n")
|
||
#total = len(arr) # total slot number
|
||
for i in range(len(arr)):
|
||
val = re.sub("\D", "", arr[i])
|
||
if val == "":
|
||
val = arr[i].lstrip()
|
||
val = re.sub('Size:', '', val).lstrip()
|
||
# print val
|
||
result.append({"slot": i + 1, "size": val})
|
||
return True, result
|
||
return False, "error"
|
||
|
||
###########################################
|
||
# get memory slot and number via DMI command
|
||
# return various arrays
|
||
###########################################
|
||
def getsysmeminfo_detail():
|
||
ret, log = rj_os_system("which dmidecode ")
|
||
if ret != 0 or len(log) <= 0:
|
||
error = "cmd find dmidecode"
|
||
return False, error
|
||
cmd = log + " -t 17 | grep -A21 \"Memory Device\"" # 17
|
||
# get total number
|
||
ret1, log1 = rj_os_system(cmd)
|
||
if ret1 != 0 or len(log1) <= 0:
|
||
return False, "command execution error[%s]" % cmd
|
||
result_t = log1.split("--")
|
||
mem_rets = []
|
||
for item in result_t:
|
||
its = item.replace("\t", "").strip().split("\n")
|
||
ret = {}
|
||
for it in its:
|
||
if ":" in it:
|
||
key = it.split(":")[0].lstrip()
|
||
value = it.split(":")[1].lstrip()
|
||
ret[key] = value
|
||
mem_rets.append(ret)
|
||
return True, mem_rets
|
||
|
||
|
||
###########################################
|
||
# get BIOS info via DMI command
|
||
###########################################
|
||
def getDmiSysByType(type_t):
|
||
ret, log = rj_os_system("which dmidecode ")
|
||
if ret != 0 or len(log) <= 0:
|
||
error = "cmd find dmidecode"
|
||
return False, error
|
||
cmd = log + " -t %s" % type_t
|
||
# get total number
|
||
ret1, log1 = rj_os_system(cmd)
|
||
if ret1 != 0 or len(log1) <= 0:
|
||
return False, "command execution error[%s]" % cmd
|
||
its = log1.replace("\t", "").strip().split("\n")
|
||
ret = {}
|
||
for it in its:
|
||
if ":" in it:
|
||
key = it.split(":")[0].lstrip()
|
||
value = it.split(":")[1].lstrip()
|
||
ret[key] = value
|
||
return True, ret
|
||
|
||
|
||
def gethwsys():
|
||
return getDmiSysByType(1)
|
||
|
||
###########################################
|
||
# get BIOS info via DMI command
|
||
|
||
|
||
def getsysbios():
|
||
return getDmiSysByType(0)
|
||
|
||
|
||
def searchDirByName(name, dir):
|
||
result = []
|
||
try:
|
||
files = os.listdir(dir)
|
||
for file in files:
|
||
if name in file:
|
||
result.append(os.path.join(dir, file))
|
||
except Exception as e:
|
||
pass
|
||
return result
|
||
|
||
|
||
def getUsbLocation():
|
||
dir = "/sys/block/"
|
||
spect = "sd"
|
||
usbpath = ""
|
||
result = searchDirByName(spect, dir)
|
||
if len(result) <= 0:
|
||
return False
|
||
for item in result:
|
||
with open(os.path.join(item, "removable"), 'r') as fd:
|
||
value = fd.read()
|
||
if value.strip() == "1": # U-Disk found
|
||
usbpath = item
|
||
break
|
||
if usbpath == "": # no U-Disk found
|
||
log_debug("no usb found")
|
||
return False, usbpath
|
||
return True, usbpath
|
||
|
||
# judge USB file
|
||
def getusbinfo():
|
||
ret, path = getUsbLocation()
|
||
if ret == False:
|
||
return False, "not usb exists"
|
||
str = os.path.join(path, "size")
|
||
ret, value = getfilevalue(str)
|
||
if ret == True:
|
||
return True, {"id": os.path.basename(path), "size": float(value) * 512 / 1024 / 1024 / 1024}
|
||
else:
|
||
return False, "Err"
|
||
|
||
def get_cpu_info():
|
||
cmd = "cat /proc/cpuinfo |grep processor -A18" # 17
|
||
|
||
ret, log1 = rj_os_system(cmd)
|
||
if ret != 0 or len(log1) <= 0:
|
||
return False, "command execution error[%s]" % cmd
|
||
result_t = log1.split("--")
|
||
mem_rets = []
|
||
for item in result_t:
|
||
its = item.replace("\t", "").strip().split("\n")
|
||
ret = {}
|
||
for it in its:
|
||
if ":" in it:
|
||
key = it.split(":")[0].lstrip()
|
||
value = it.split(":")[1].lstrip()
|
||
ret[key] = value
|
||
mem_rets.append(ret)
|
||
return True, mem_rets
|
||
# read file
|
||
def get_version_config_info(attr_key, file_name=None):
|
||
if file_name is None:
|
||
version_conf_filename = "/root/version.json"
|
||
else:
|
||
version_conf_filename = file_name
|
||
if not os.path.isfile(version_conf_filename):
|
||
return None
|
||
with open(version_conf_filename) as rjconf_file:
|
||
for line in rjconf_file:
|
||
tokens = line.split('=')
|
||
if len(tokens) < 2:
|
||
continue
|
||
if tokens[0] == attr_key:
|
||
return tokens[1].strip()
|
||
return None
|
||
|
||
|
||
def io_rd(reg_addr, len =1):
|
||
u'''io read'''
|
||
try:
|
||
regaddr = 0
|
||
if type(reg_addr) == int:
|
||
regaddr = reg_addr
|
||
else:
|
||
regaddr = int(reg_addr, 16)
|
||
devfile = "/dev/port"
|
||
fd = os.open(devfile, os.O_RDWR|os.O_CREAT)
|
||
os.lseek(fd, regaddr, os.SEEK_SET)
|
||
str = os.read(fd, len)
|
||
return "".join(["%02x"% ord(item) for item in str])
|
||
except ValueError:
|
||
return None
|
||
except Exception as e:
|
||
print(e)
|
||
return None
|
||
finally:
|
||
os.close(fd)
|
||
|
||
|
||
def io_wr(reg_addr, reg_data):
|
||
u'''io write'''
|
||
try:
|
||
regdata = 0
|
||
regaddr = 0
|
||
if type(reg_addr) == int:
|
||
regaddr = reg_addr
|
||
else:
|
||
regaddr = int(reg_addr, 16)
|
||
if type(reg_data) == int:
|
||
regdata = reg_data
|
||
else:
|
||
regdata = int(reg_data, 16)
|
||
devfile = "/dev/port"
|
||
fd = os.open(devfile, os.O_RDWR|os.O_CREAT)
|
||
os.lseek(fd, regaddr, os.SEEK_SET)
|
||
os.write(fd, chr(regdata))
|
||
return True
|
||
except ValueError as e:
|
||
print(e)
|
||
return False
|
||
except Exception as e:
|
||
print(e)
|
||
return False
|
||
finally:
|
||
os.close(fd)
|
||
|