Source code for testcases.LightPathDiagnostics

#!/usr/bin/env python3
# IBM_PROLOG_BEGIN_TAG
# This is an automatically generated prolog.
#
# $Source: op-test-framework/testcases/LightPathDiagnostics.py $
#
# OpenPOWER Automated Test Project
#
# Contributors Listed Below - COPYRIGHT 2015
# [+] International Business Machines Corp.
#
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
# implied. See the License for the specific language governing
# permissions and limitations under the License.
#
# IBM_PROLOG_END_TAG

'''
LightPathDiagnostics
--------------------

Currently runs only in FSP platforms.
'''

import time
import subprocess
import re

from common.OpTestIPMI import OpTestIPMI
from common.OpTestConstants import OpTestConstants as BMC_CONST
from common.OpTestError import OpTestError

import unittest
import OpTestConfiguration
from common.OpTestSystem import OpSystemState

import logging
import OpTestLogger
log = OpTestLogger.optest_logger_glob.get_logger(__name__)


class LightPathDiagnostics(unittest.TestCase):
    def setUp(self):
        conf = OpTestConfiguration.conf
        self.system = conf.system()
        self.fsp = self.system.bmc
        self.host = conf.host()
        self.bmc_type = conf.args.bmc_type
        self.system.goto_state(OpSystemState.OS)

    def lpd_init(self):
        # Check if system has LED support
        if not self.system.has_host_led_support():
            self.skipTest("System has no LED support")

        self.assertTrue(self.host.host_check_dt_node_exist("ibm,opal/leds"),
                        "ibm,opal/leds DT Node doesn't exist")

        # If it has support, check for led's presence
        res = self.host.host_run_command("ls /sys/class/leds/ | wc -l")
        self.assertNotEqual(int(''.join(res).strip()), 0,
                            "No LED's found in sysfs /sys/class/leds/")

        self.fsp.fsp_get_console()
        if not self.fsp.mount_exists():
            raise OpTestError("Please mount NFS and retry the test")

    def get_location_codes(self):
        res = self.host.host_run_command("usysident")
        loc_codes = []
        for loc in res:
            loc_codes.append(loc.split("\t")[0])
        return loc_codes

    def get_sysattn_indicator_loc(self):
        res = self.host.host_run_command("usysattn")
        loc_codes = []
        for loc in res:
            loc_codes.append(loc.split("\t")[0])
        return loc_codes[0]


class UsysIdentifyTest(LightPathDiagnostics):
    '''
    This function tests usysident identification of LEDs
    '''

    def runTest(self):
        self.lpd_init()
        loc_codes = self.get_location_codes()
        log.debug("Executing indicator identify tests")
        # Using -l option(Location code) Identifying a single device
        for loc in loc_codes:
            log.debug("Turn on indicator {} from Host".format(loc))
            self.host.host_run_command(
                "usysident -l {} -s identify".format(loc))
            tries = 20
            for i in range(1, tries+1):
                response = self.host.host_run_command(
                    "usysident -l {}".format(loc))
                if "on" in ''.join(response):
                    break
                time.sleep(1)
            self.assertIn("on", response,
                          "Turn ON of indicator {} failed".format(loc))
            log.debug("Current identification state of {} is ON".format(loc))

        self.host.host_run_command("usysident")

        # Setting to normal state of device(Turn off Device)
        for loc in loc_codes:
            log.debug("Turn off {} from Host".format(loc))
            self.host.host_run_command("usysident -l {} -s normal".format(loc))
            tries = 20
            for i in range(1, tries+1):
                response = self.host.host_run_command(
                    "usysident -l {}".format(loc))
                if "off" in ''.join(response):
                    break
                time.sleep(1)
            self.assertIn("off", response,
                          "Turn OFF {} failed".format(loc))
            log.debug("Current identification state of {} is OFF".format(loc))


class UsysAttnFSPTest(LightPathDiagnostics):
    '''
    This function tests system attention indicator LED
    '''

    def runTest(self):
        self.lpd_init()
        loc_code = self.get_sysattn_indicator_loc()
        log.debug("Executing system attention indicator tests")
        response = self.fsp.fsp_run_command("ledscommandline -V")
        log.debug(response)
        # Setting system attention indicator from FSP
        log.debug("Setting system attention indicator from FSP")
        response = self.fsp.fsp_run_command("ledscommandline -a -s")
        log.debug(response)
        response = self.fsp.fsp_run_command("ledscommandline -a -q")
        log.debug(response)
        tries = 10
        for i in range(1, tries+1):
            cmd = "usysattn -l %s" % loc_code
            response = self.host.host_run_command(cmd)
            if "on" in ''.join(response):
                break
            time.sleep(1)
        self.assertIn("on", response,
                      "Turn ON of system attention indicator is failed")
        log.debug("Current system attention indicator state is ON")

        # Clearing(resetting) system attention indicator from FSP
        log.debug("Clearing system attention indicator from FSP")
        response = self.fsp.fsp_run_command("ledscommandline -a -r")
        log.debug(response)
        response = self.fsp.fsp_run_command("ledscommandline -a -q")
        log.debug(response)
        tries = 10
        for i in range(1, tries+1):
            cmd = "usysattn -l %s" % loc_code
            response = self.host.host_run_command(cmd)
            if "off" in ''.join(response):
                break
            time.sleep(1)
        self.assertIn("off", response,
                      "Turn OFF of system attention indicator is failed")
        log.debug("Current system attention indicator state is OFF")


class UsysAttnHostTest(LightPathDiagnostics):
    '''
    This function tests system attention indicator LED
    '''

    def runTest(self):
        self.lpd_init()
        loc_code = self.get_sysattn_indicator_loc()
        log.debug("Executing system attention indicator tests")
        # Setting system attention indicator from HOST
        log.debug("Setting system attention indicator from Host")
        cmd = "echo 1 > /sys/class/leds/%s:attention/brightness" % loc_code
        self.host.host_run_command(cmd)
        tries = 10
        for i in range(1, tries+1):
            cmd = "usysattn -l %s" % loc_code
            response = self.host.host_run_command(cmd)
            if "on" in ''.join(response):
                break
            time.sleep(1)
        self.assertIn("on", response,
                      "Turn ON of system attention indicator is failed")
        log.debug("Current system attention indicator state is ON")

        # Clearing(resetting) system attention indicator
        log.debug("Clearing system attention indicator from Host")
        cmd = "echo 0 > /sys/class/leds/%s:attention/brightness" % loc_code
        self.host.host_run_command(cmd)
        tries = 10
        for i in range(1, tries+1):
            cmd = "usysattn -l %s" % loc_code
            response = self.host.host_run_command(cmd)
            if "off" in ''.join(response):
                break
            time.sleep(1)
        self.assertIn("off", response,
                      "Turn OFF of system attention indicator is failed")
        log.debug("Current system attention indicator state is OFF")


class UsysFaultTest(LightPathDiagnostics):
    '''
    This function tests usysfault identification of LED's
    '''

    def runTest(self):
        self.lpd_init()
        loc_codes = self.get_location_codes()
        log.debug("Executing fault indicator tests for all fault locators")
        for indicator in loc_codes:
            log.debug("Test for {} locator".format(indicator))
            # Setting a fault indicator from HOST os
            log.debug("Setting fault indicator {} from Host".format(indicator))
            cmd = "echo 1 > /sys/class/leds/{}:fault/brightness".format(
                indicator)
            self.host.host_run_command(cmd)
            tries = 10
            for i in range(1, tries+1):
                cmd = "usysattn -l %s" % indicator
                response = self.host.host_run_command(cmd)
                if "on" in ''.join(response):
                    break
                time.sleep(1)
            self.assertIn("on", response,
                          "Turn ON of fault indicator {} is failed".format(
                              indicator))
            log.debug("Current fault indicator state of {} is ON".format(
                indicator))

            # Clearing fault indicator from Host OS
            log.debug("Clearing fault indicator %s from Host OS" % indicator)
            cmd = "usysattn -l %s -s normal" % indicator
            self.host.host_run_command(cmd)
            tries = 10
            for i in range(1, tries+1):
                cmd = "usysattn -l %s" % indicator
                response = self.host.host_run_command(cmd)
                if "off" in response:
                    break
                time.sleep(1)
            self.assertIn("off", response,
                          "Turn OFF of fault indicator %s is failed".format(
                              indicator))
            log.debug("Current fault indicator state of %s is OFF" % indicator)


def suite():
    s = unittest.TestSuite()
    s.addTest(UsysIdentifyTest())
    s.addTest(UsysAttnHostTest())
    s.addTest(UsysFaultTest())
    return s


def extended_suite():
    s = unittest.TestSuite()
    s.addTest(UsysIdentifyTest())
    s.addTest(UsysAttnFSPTest())
    s.addTest(UsysAttnHostTest())
    s.addTest(UsysFaultTest())
    return s