def kill_fan_controller(self):
'''
Helper method to kill fan controller: FSCD, fand
'''
self.assertNotEqual(self.kill_fan_ctrl_cmd, None, "Kill Fan Controller cmd not set")
for cmd in self.kill_fan_ctrl_cmd:
run_shell_cmd(cmd)
def set_endpoint_sensors_attributes(self):
self.endpoint_sensors_attrb = [
"ncp4200-i2c-1-60",
"ncp4200-i2c-2-60",
"tmp75-i2c-3-48",
"tmp75-i2c-3-49",
"tmp75-i2c-3-4a",
"fb_panther_plus-i2c-4-40",
"max127-i2c-6-28",
"ncp4200-i2c-8-60",
"adm1278-i2c-12-10",
]
psu_i2c_devices = run_shell_cmd(cmd=RestEndpointTest.PSU_I2C_CMD)
if RestEndpointTest.PSU1_I2C_DEVICE in psu_i2c_devices:
self.endpoint_sensors_attrb.append(
RestEndpointTest.PSU1_I2C_DEVICE)
if RestEndpointTest.PSU2_I2C_DEVICE in psu_i2c_devices:
self.endpoint_sensors_attrb.append(
RestEndpointTest.PSU2_I2C_DEVICE)
adc_detected = run_shell_cmd(cmd=RestEndpointTest.LIST_ADC_CMD)
for name in RestEndpointTest.ASPEED_ADC_DEVICES:
if name in adc_detected:
self.endpoint_sensors_attrb.append(name)
pwm_detected = run_shell_cmd(cmd=RestEndpointTest.LIST_PWM_CMD)
for name in RestEndpointTest.ASPEED_PWM_DEVICES:
if name in pwm_detected:
self.endpoint_sensors_attrb.append(name)
def setUp(self):
self.brd_type = pal_get_board_type()
if self.brd_type is None:
self.fail("Get board type failed!")
elif self.brd_type == "Wedge400":
Logger.info(
"[FSCD Testing] skip Wedge400C fscd test on {} platform".format(
self.brd_type
)
)
self.skipTest(
"skip Wedge400C fscd test on {} platform".format(self.brd_type)
)
elif self.brd_type == "Wedge400C":
config_file = "fsc-config-wedge400c.json"
Logger.info(
"[FSCD Testing] test fscd on {} platform with config file {}".format(
self.brd_type, config_file
)
)
else:
self.fail("Invalid platform!")
# Backup original config
run_shell_cmd("cp /etc/fsc/zone-w400c.fsc /etc/fsc/zone-w400c.fsc.orig")
# Overwrite fscd config
run_shell_cmd(
"cp {}/zone-w400c.fsc /etc/fsc/zone-w400c.fsc".format(
super().TEST_DATA_PATH
)
)
super().setUp(config=config_file, test_data_path=super().TEST_DATA_PATH)
def restart_fscd(self):
if running_systemd():
run_shell_cmd("/bin/systemctl restart fscd")
else:
run_shell_cmd("sv restart fscd")
time.sleep(20)
def start_fan_controller(self):
'''
Helper method to start fan controller: FSCD, fand
'''
self.assertNotEqual(self.start_fan_ctrl_cmd, None, "Kill Fan Controller cmd not set")
for cmd in self.start_fan_ctrl_cmd:
run_shell_cmd(cmd)
time.sleep(10) # allow time for fans to be properly set
def test_kv_get_key(self):
self.set_kv_keys()
self.assertNotEqual(self.kv_keys, None, "Expected set of kv keys not set")
for key in self.kv_keys:
with self.subTest(key=key):
cmd = "/usr/bin/kv get {} persistent".format(key)
run_shell_cmd(cmd)
def set_fan_speed(self, fan_id, pwm):
'''
Helper function to set fan speed
'''
cmd = '/usr/local/bin/fan-util --set ' + str(pwm) + ' ' + str(fan_id)
Logger.debug("Executing: {}".format(cmd))
run_shell_cmd(cmd)
time.sleep(10) # allow time for fans to be properly set
def set_all_fans_speed(self, pwm):
"""
Helper function to set fan speed
"""
cmd = "/usr/local/bin/fan-util --set " + str(pwm)
Logger.debug("Executing: {}".format(cmd))
run_shell_cmd(cmd)
time.sleep(10) # allow time for fans to be properly set
def test_psumuxmon_runit_sv_status(self):
if running_systemd():
cmd = ["/bin/systemctl status psumuxmon"]
data = run_shell_cmd(cmd)
self.assertIn("running", data, "psumuxmon unit not running")
else:
cmd = ["/usr/bin/sv status psumuxmon"]
data = run_shell_cmd(cmd)
self.assertIn("run", data, "psumuxmon process not running")
def set_fan_speed(self, fan_id, pwm):
"""
Helper function to set fan speed
"""
self.assertNotEqual(self.write_fans_cmd, None, "Set Fan cmd not set")
cmd = self.write_fans_cmd + " " + str(pwm) + " " + str(fan_id)
Logger.debug("Executing: {}".format(cmd))
run_shell_cmd(cmd)
time.sleep(10) # allow time for fans to be properly set
def kill_watchdog_daemon(self):
'''
Helper method to kill watchdog daemon: FSCD, fand, healthd
'''
self.set_kill_watchdog_daemon_cmd()
self.assertNotEqual(self.kill_watchdog_daemon_cmd, None,
"Kill watchdog daemon controller cmd not set")
Logger.info("killing watchdog-kicking daemon processes")
for cmd in self.kill_watchdog_daemon_cmd:
run_shell_cmd(cmd)
def test_eeprom_read(self):
data = run_shell_cmd("{} read 0x0".format(
self.eeprom_util)).split("\n")
self.assertIn("0x0: 0xa8", data[0], "OOB EEPROM magic code missing")
data = run_shell_cmd("{} read 0x3ff".format(
self.eeprom_util)).split("\n")
m = re.match(r"0x3ff: (0x[0-9a-f]+)", data[0])
self.assertIsNotNone(
m, "Could not parse version word: {}".format(data[0]))
version = int(m.group(1), 0)
self.assertGreater(version, 0, "Invalid version: {}".format(version))
def tearDown(self):
#
# Step 6: restore watchdog-kicking daemon process.
#
Logger.info("Restoring watchdog-kicking process")
self.set_start_watchdog_daemon_cmd()
self.assertNotEqual(self.start_watchdog_daemon_cmd, None,
"Starting watchdog daemon controller cmd not set")
for cmd in self.start_watchdog_daemon_cmd:
run_shell_cmd(cmd)
sleep(10) # wait before daemon started back
def run_pwm_test(
self,
userver_temp=DEFAULT_TEMP,
switch_temp=DEFAULT_TEMP,
intake_temp=DEFAULT_TEMP,
outlet_temp=DEFAULT_TEMP,
expected_pwm=28,
):
PWM_VAL = expected_pwm
Logger.info("[FSCD Testing] Setting (userver={}C, switch={}C ,"
"intake={}C, outlet={}C, expected pwm={})".format(
int(userver_temp) / 1000,
int(switch_temp) / 1000,
int(intake_temp) / 1000,
int(outlet_temp) / 1000,
int(expected_pwm),
))
run_shell_cmd("echo {} > {}/userver/temp1_input".format(
userver_temp, self.TEST_DATA_PATH))
run_shell_cmd("echo {} > {}/switch/temp1_input".format(
switch_temp, self.TEST_DATA_PATH))
run_shell_cmd("echo {} > {}/intake/temp1_input".format(
intake_temp, self.TEST_DATA_PATH))
run_shell_cmd("echo {} > {}/outlet/temp1_input".format(
outlet_temp, self.TEST_DATA_PATH))
# Wait for fans to change PWM
time.sleep(10)
return self.get_fan_pwm(pwm_val=PWM_VAL)
def test_mdio_read(self):
# Test the IMP port state register
data = run_shell_cmd("{} read8 0x0 0xe".format(
self.mdio_util)).split("\n")
self.assertIn("0x0/0xe 0x87", data[0],
"unexpected OOB MDIO IMP port state value")
# Test writing/reading to unused port-2
run_shell_cmd("{} write8 0x0 0x2 0x3".format(self.mdio_util))
data = run_shell_cmd("{} read8 0x0 0x2".format(
self.mdio_util)).split("\n")
self.assertIn("0x0/0x2 0x3", data[0],
"unexpected OOB MDIO port 2 state value")
run_shell_cmd("{} write8 0x0 0x2 0x0".format(self.mdio_util))
data = run_shell_cmd("{} read8 0x0 0x2".format(
self.mdio_util)).split("\n")
self.assertIn("0x0/0x2 0x0", data[0],
"unexpected OOB MDIO port 2 state value")
# Validate 64-bit counter register. Only validate the format, not the value itself.
data = run_shell_cmd("{} read64 0x28 0x0".format(
self.mdio_util)).split("\n")
m = re.match(r"0x28/0x0 \S+ ==( [01]{4}){16}", data[0])
self.assertIsNotNone(m,
"Failed to retrieve OOB MDIO 64-bit TX counter")
def test_cpld_version_sysfs_path_access(self):
for path in self.cpld_paths:
with self.subTest(path=path):
cmd = "head -n 1 " + path
data = run_shell_cmd(cmd).rstrip("\n")
self.assertTrue(int(data, 16),
"CPLD major version is not digit")
def get_fan_speed(self, fan_id=None):
self.assertNotEqual(self.read_fans_cmd, None, "Get Fan cmd not set")
cmd = self.read_fans_cmd
if fan_id:
cmd = self.read_fans_cmd + " " + str(fan_id)
Logger.debug("Executing: {}".format(cmd))
return run_shell_cmd(cmd)
def get_installed_kmods(self):
self.set_kmod_cmd()
self.assertNotEqual(self.kmod_cmd, None,
"Command to get kmod is not set")
Logger.info("Executing cmd={}".format(self.kmod_cmd))
info = run_shell_cmd(cmd=self.kmod_cmd)
return info
def run_eeprom_cmd(self):
self.assertNotEqual(self.eeprom_cmd, None, "EEPROM command not set")
Logger.info("Running EEPROM command: " + str(self.eeprom_cmd))
self.eeprom_info = run_shell_cmd(cmd=self.eeprom_cmd)
Logger.info(self.eeprom_info)
return self.eeprom_info
def setUp(self, config=None, test_data_path=None):
"""
Series of tests that are driven by changing the temperature sensors
"""
Logger.start(name=self._testMethodName)
self.assertNotEqual(config, None, "FSC TEST config needs to be set")
self.assertNotEqual(test_data_path, None, "FSC TEST data path needs to be set")
# Backup original config
run_shell_cmd("cp /etc/fsc-config.json /etc/fsc-config.json.orig")
# Copy test config to fsc-config and restart fsc
run_shell_cmd(
"cp {}/{} /etc/fsc-config.json".format(test_data_path, str(config))
)
self.restart_fscd()
def test_cpld_revision_format(self):
'''
cpld_rev returns X.X
'''
version = run_shell_cmd(self.cpld_rev).rstrip('\n').split(".")
self.assertTrue(version[0].isdigit(),"CPLD major version is not digit, received={}".format(version))
self.assertTrue(version[1].isdigit(),"CPLD minor version is not digit, received={}".format(version))
def parse_sensors(self):
self.set_sensors_cmd()
data = run_shell_cmd(self.sensors_cmd)
if "not present" in data:
return {"present": False}
result = {"present": True}
# VCCGBE VR Vol (0x54) : 1.05 Volts | (ok)
# SOC DIMMA1 Temp (0xB5) : NA | (na)
name_regex = re.compile(r"^(.+)\s+\(0x.+\)\s*")
for edata in data.split("\n"):
try:
adata = edata.split(" : ")
sensor_name = name_regex.match(adata[0]).group(1).strip()
value_group = adata[1].split(" | ")
value_units = value_group[0].strip().split(" ")
sensor_value = value_units[0].strip()
if sensor_value == "NA":
sensor_value = str(0)
result[sensor_name] = sensor_value
# Save for future use.
# sensor_status = value_group[1]
# sensor_units = "NA"
# if len(value_units) == 2:
# sensor_units = value_units[1].strip()
except Exception:
Logger.error("Cannot parse: {}".format(edata))
return result
def run_pem_cmd(self):
self.set_pem_cmd()
self.assertNotEqual(self.pem_cmd, None, "PEM command not set")
Logger.info("Running PEM command: " + str(self.pem_cmd))
self.pem_info = run_shell_cmd(cmd=self.pem_cmd)
Logger.info(self.pem_info)
return self.pem_info
def get_json_threshold_result(self):
self.set_sensors_cmd()
self.sensors_cmd[0] += " --json --threshold"
data = run_shell_cmd(self.sensors_cmd)
if "not present" in data:
return {"present": False}
result = {"present": True}
result.update(json.loads(data))
return result
def test_host_mac(self):
self.set_host_mac()
self.assertNotEqual(self.host_mac_cmd, None,
"Host MAC command not set")
Logger.info("Executing cmd={}".format(self.host_mac_cmd))
info = run_shell_cmd(cmd=self.host_mac_cmd)
self.assertTrue(
mac_verify(info), "Host MAC is incorrectly formatted to \
{}".format(info))
def test_host_mac_zero_test(self):
self.set_host_mac()
self.assertNotEqual(self.host_mac_cmd, None,
"Host MAC command not set")
Logger.info("Executing cmd={}".format(self.host_mac_cmd))
info = run_shell_cmd(cmd=self.host_mac_cmd)
zero_mac = '00:00:00:00:00:00'
self.assertNotEqual(info, zero_mac,
"Host MAC is zeros {}".format(info))
def test_ec_revision_format(self):
'''
ec version returns version and date
'''
data = run_shell_cmd(self.ec_version).split("\n")
self.assertIn("EC Released Version", data[0],
"EC released version missing received={}".format(data))
self.assertIn("EC Released Date", data[1],
"EC released date missing received={}".format(data))
def get_fw_upgrade_utils(self):
self.set_fw_upgrade_utils_cmd()
self.assertNotEqual(
self.fw_upgrade_utils_cmd,
None,
"Command to get fw upgrade utils is not set",
)
Logger.info("Executing cmd={}".format(self.fw_upgrade_utils_cmd))
info = run_shell_cmd(cmd=self.fw_upgrade_utils_cmd)
return info
def get_fan_speed(self, fan_id=None):
"""
Helper function to get fan speed
"""
cmd = "/usr/local/bin/fan-util --get"
if fan_id is not None:
cmd = cmd + " " + str(fan_id)
Logger.debug("Executing: {}".format(cmd))
ret = run_shell_cmd(cmd)
return ret
def test_scd_fpga_revision_format(self):
data = run_shell_cmd(self.fpga_version).split("\n")
self.assertIn("SCD_FPGA", data[3],
"SCD_FPGA missing received={}".format(data))
value = data[3].split(":")[1]
self.assertRegex(
value,
r"\b[0-9]+\.[0-9]+\b",
"SCD_FPGA version {} isn't numeric".format(value),
)