Merge lp:~bladernr/opencompute/merge-github-junk into lp:opencompute/opencompute-testing

[Jeff Lane ]

Merges in all the stuff ITRI put into github.

[Jeff Lane  (bladernr)]

self approve... merge them all, let Jeff sort them out.

review: Approve

=== added file 'README.tips'
--- README.tips	1970-01-01 00:00:00 +0000
+++ README.tips	2015-08-14 22:03:31 +0000
@@ -0,0 +1,121 @@
+############User manual and installation guide################
+Note: Please use Ubuntu 12.04 or lately.
+
+######[Run Checkbox]######
+$ opencompute-certification
+Note, sudo is not necessary, you should be prompted for a root password.
+
+######[Important directory]######
+Runtime Logs: $HOME/.cache/plainbox/
+Results: $HOME/.local/plainbox/
+
+##############################################################################################
+Before running ME/BMC test, please fill in related information in configuration file.
+Each section exists in configuration file has its own purpose.
+The following will explain how to fill in settings in each section.
+
+Note:
+1. Path of configuration file: /etc/xdg/bmc.cfg or /etc/xdg/me.cfg
+2. Without these settings pre-setting in configuration file, you won't start tests smoothly.
+
+##############################################################################################
+
+
+############User manual of each section################
+
+######[Targets]######
+For remotely access via IPMI/DCMI, you need to fill in ME/BMC IP address of SUT.
+For example, ME/BMC IP: 10.2.107.5
+[Targets]
+Target1: 10.2.107.5
+
+######[Account]######
+For remotely access via IPMI/DCMI, you need to fill in ME/BMC account here.
+For example, USER/PASSWORD: OCP/OCP. Then, the settings in this section must be
+[Account]
+USER: OCP
+PASSWORD: OCP
+
+######[Sensors] and [SensorsForCPUTemp]######
+For thermal tests of ME/BMC sensors, you need to check and set Sensor ID before starting tests.
+Refers to TC-001-0006-Hardware_Monitoring.txt.in,
+there are five kinds of sensors to monitor, so please write corresponding sensor ID to this field.
+For example, the sensor ID related to these five kinds of sensors on Winterfell
+are "outlet Temp", "inlet Temp", "PCH Temp", "P0 DIMM Temp", "P1 DIMM Temp", "P0 Therm Margin",
+"P1 Therm Margin", "CPU0 Tjmax", "CPU1 Tjmax"
+[Sensors]
+Outlet: Outlet Temp
+Inlet: Inlet Temp
+PCH: PCH Temp
+Px DIMM: P0 DIMM Temp
+Py DIMM: P1 DIMM Temp
+CPUx: CPU0 Temp
+CPUy: CPU1 Temp
+
+Note:
+        Case1. There are CPU sensors to monitor CPU temperature directly.
+               You just fill in sensor IDs behind key "CPUx" and "CPUy" and
+               don't care the section [SensorsForCPUTemp] at all.
+        Case2. There are no CPU sensors to monitor CPU temperature directly.
+               CPUx temperature is derived from Px Therm Margin and CPUx Tjmax.
+               ie,"CPU0 Temp" = "P0 Therm Margin" + "CPU0 Tjmax"
+               (It still requires "PU0 Temp" marked behind key "CPUx")
+               Besides, please also fill in "P0 Therm Margin", "PU0 Tjmax"
+               to corresponding section presented as below.
+               [SensorsForCPUTemp]
+               Px Therm Margin: P0 Therm Margin
+               Py Therm Margin: P1 Therm Margin
+               CPUx Tjmax: CPU0 Tjmax
+               CPUy Tjmax: CPU1 Tjmax
+
+
+######[SensorsForSampling]######
+Refers to test case TC-002-0008-001-Temp_Sampling_Increment, the description is to retrieve CPU and intake temperature 30 times.
+For example, the related sensor IDs on Winterfell are "Inlet Temp", "P0 Therm Margin", "P1 Therm Margin", "CPU0 Tjmax", "CPU1 Tjmax".
+[SensorsForSampling]
+Inlet: Inlet Temp
+CPUx: CPU0 Temp
+CPUy: CPU1 Temp
+Note: if the CPU0 temperature derives from "P0 therm Margin" and "CPU0 Tjmax",
+you have to give a string "CPU0 temp" behind key "CPUx". And also remember to fill in the sensor ID in section [SensorsForCPUTemp].
+Please refer to section [Sensors].
+
+
+##############################################################################################
+The following four sections [Admin Level], [Operator Level], [User Level] and [Add User Test] are for User level test.
+Please refer to TC-002-0009-User_Levels.txt.in. In these four sections, you don't need to modify settings here.
+
+######[Admin Level]######
+[Admin Level]
+ADMIN_NAME: ccma_admin
+ADMIN_PASSWD: ccma_admin
+priv_level: 4
+user_id: 3
+channel_num: 1
+Note: But please set the settings in the section using ipmitool/dcmitool manually on SUT before starting user level test.
+
+######[Operator Level]######
+[Operator Level]
+OPER_NAME: ccma_oper
+OPER_PASSWD: ccma_oper
+priv_level: 3
+user_id: 4
+channel_num: 1
+Note: But please set the settings in the section using ipmitool/dcmitool manually on SUT before starting user level test.
+
+######[User Level]######
+[User Level]
+USER_NAME: ccma_user
+USER_PASSWD: ccma_user
+priv_level: 2
+user_id: 5
+channel_num: 1
+Note: But please set the settings in the section using ipmitool/dcmitool manually on SUT before starting user level test.
+
+
+######[Add User Test]######
+[Add User Test]
+NEW_USER_NAME: ccma_test
+NEW_USER_ID: 6
+Note: Do not need to create this account manually
+

=== added file 'bin/bad_block_test'
--- bin/bad_block_test	1970-01-01 00:00:00 +0000
+++ bin/bad_block_test	2015-08-14 22:03:31 +0000
@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+It is NOT YET officially approved by OCP.
+
+bad_block_test
+ 1. Use badblocks command to perform a full disk bad block scan 
+    with given pattern.
+ 2. The duration of the test is under 24 hours.
+ 3. Criteria: pass if no hard disk error.
+
+Authors
+  Nelson Chu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+import os
+import re
+import sys
+from subprocess import check_output, STDOUT
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+def run(pattern, device):
+    return_code = 0
+    command = "badblocks -wsvf -t {0} {1}".format(pattern, device)
+
+    try:
+        with open(os.devnull, "w") as NULL:
+            output = check_output(command, stderr=STDOUT, shell=True)
+            output = output.decode('utf-8')
+    except Exception as e:
+        print(e.output.decode('utf-8'))
+        return_code = 10
+        return return_code
+
+    bad_blocks_match = re.search(r'\n(Pass completed\,\s(\d+)\s.*)\n$', output)
+    if bad_blocks_match:
+        print(bad_blocks_match.group(1))
+        if int(bad_blocks_match.group(2)) != 0:
+            return_code = 20
+    else:
+        print("Cannot parse badblocks output.")
+        return_code = 30
+    return return_code
+
+def main():
+    parser = ArgumentParser(formatter_class=RawTextHelpFormatter)
+    parser.add_argument('-t', '--pattern', type=str, required=True,
+                        help=("Specify a test pattern to be read \n"
+                              + "(and written) to disk  blocks."))
+    parser.add_argument('-d', '--device', type=str, required=True,
+                        help=("The device which tests in badblocks."))
+    args = parser.parse_args()
+    return run(args.pattern, args.device)
+
+if __name__ == '__main__':
+    sys.exit(main())

=== modified file 'bin/bios_info'
--- bin/bios_info	2015-03-03 15:59:42 +0000
+++ bin/bios_info	2015-08-14 22:03:31 +0000
@@ -3,6 +3,8 @@
 Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
 Industrial Technology Research Institute
 
+It is NOT YET officially approved by OCP.
+
 bios_info
   1. Use lshw command to gather BIOS information.
   2. The program will output BIOS vendor, version and release date.

=== added file 'bin/block_device_resource'
--- bin/block_device_resource	1970-01-01 00:00:00 +0000
+++ bin/block_device_resource	2015-08-14 22:03:31 +0000
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+
+import os
+import re
+from glob import glob
+
+rootdir_pattern = re.compile('^.*?/devices')
+
+def device_state(name):
+    """
+    Follow pmount policy to determine whether a device is removable or internal.
+    """
+    with open('/sys/block/%s/device/block/%s/removable' % (name, name)) as f:
+        if f.read(1) == '1':
+            return 'removable'
+
+    path = rootdir_pattern.sub('', os.readlink('/sys/block/%s' % name))
+    hotplug_buses = ("usb", "ieee1394", "mmc", "pcmcia", "firewire")
+    for bus in hotplug_buses:
+        if os.path.exists('/sys/bus/%s' % bus):
+            for device_bus in os.listdir('/sys/bus/%s/devices' % bus):
+                device_link = rootdir_pattern.sub('', os.readlink(
+                    '/sys/bus/%s/devices/%s' % (bus, device_bus)))
+                if re.search(device_link, path):
+                    return 'removable'
+
+    return 'internal'
+
+
+def usb_support(name, version):
+    """
+    Check the USB specification number for both hub port and device
+    """
+    path = rootdir_pattern.sub('', os.readlink('/sys/block/%s' % name))
+
+    # Remove the usb config.interface part of the path
+    m = re.match('((.*usb\d+).*\/)\d-[\d\.:\-]+\/.*', path)
+    if m:
+        device_path = m.group(1)
+        hub_port_path = m.group(2)
+
+        # Check the highest version of USB the device supports
+        with open('/sys/devices/%s/version' %device_path) as f:
+            if float(f.readline()) < version:
+                return 'unsupported'
+
+        # Check the highest version of USB the hub supports
+        with open('/sys/devices/%s/version' %hub_port_path) as f:
+            if float(f.readline()) < version:
+                return 'unsupported'
+
+        return 'supported'
+
+    return 'unsupported'
+
+def device_rotation(name):
+    with open('/sys/block/%s/device/block/%s/queue/rotational' % (name, name)) as f:
+        if f.read(1) == '1':
+            return 'yes'
+
+    return 'no'
+
+for path in glob('/sys/block/*/device'):
+    name = re.sub('.*/(.*?)/device', '\g<1>', path)
+    state = device_state(name)
+    usb2 = usb_support(name, 2.00)
+    usb3 = usb_support(name, 3.00)
+    rotation = device_rotation(name)
+    # FIXME: Remove leading block device name when the requirements
+    # checking code in Checkbox allows it
+    print("""\
+%(name)s_state: %(state)s
+%(name)s_usb2: %(usb2)s
+%(name)s_usb3: %(usb3)s
+%(name)s_rotation: %(rotation)s
+""" % {"name": name,
+       "state": state,
+       "usb2": usb2,
+       "usb3": usb3,
+       "rotation": rotation})

=== modified file 'bin/check_sata_port'
--- bin/check_sata_port	2015-03-03 15:59:42 +0000
+++ bin/check_sata_port	2015-08-14 22:03:31 +0000
@@ -3,6 +3,8 @@
 # Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
 # Industrial Technology Research Institute
 #
+# It is NOT YET officially approved by OCP.
+#
 # check_sata_port
 #   1. Use dmesg command to gather SATA information.
 #   2. Criteria: SATA port speed up to 6.0Gps.

=== added file 'bin/check_sata_port_leopard'
--- bin/check_sata_port_leopard	1970-01-01 00:00:00 +0000
+++ bin/check_sata_port_leopard	2015-08-14 22:03:31 +0000
@@ -0,0 +1,38 @@
+#!/bin/bash
+#
+# Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+# Industrial Technology Research Institute
+#
+# It is NOT YET officially approved by OCP.
+#
+# check_sata_port
+#   1. Retrieve dmesg log to gather SATA information.
+#   2. Criteria: SATA port speed up to 6.0Gps.
+#
+# Authors
+#   Nelson Chu <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+output=(`cat /var/log/dmesg |grep -i "SATA link up"| awk '{print $7}'`)
+
+for ((i=0; i<${#output[@]}; i++)); do
+    if [ "$output" != "6.0" ]; then
+	echo "Do not support SATA 6Gps ports"
+	exit 1
+    fi
+done
+
+echo "Support SATA 6Gps ports"
+exit 0

=== modified file 'bin/check_usb_port'
--- bin/check_usb_port	2015-03-03 15:59:42 +0000
+++ bin/check_usb_port	2015-08-14 22:03:31 +0000
@@ -3,6 +3,8 @@
 # Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
 # Industrial Technology Research Institute
 #
+# It is NOT YET officially approved by OCP.
+#
 # check_usb_port
 #   1. Use dmesg command to gather USB information.
 #   2. Criteria: USB version must be 2.0.

=== added file 'bin/check_usb_port_leopard'
--- bin/check_usb_port_leopard	1970-01-01 00:00:00 +0000
+++ bin/check_usb_port_leopard	2015-08-14 22:03:31 +0000
@@ -0,0 +1,43 @@
+#!/bin/bash
+#
+# Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+# Industrial Technology Research Institute
+#
+# It is NOT YET officially approved by OCP.
+#
+# check_usb_port
+#   1. Retrieve dmesg log to gather USB information.
+#   2. Criteria: USB version must be 2.0 or higher.
+#
+# Authors
+#   Nelson Chu <[e-mail]>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 3,
+# as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+support_usb_3=`cat /var/log/dmesg |grep -i "xhci_hcd" -c`
+
+if [ "$support_usb_3" -gt "0" ]; then
+    echo "Support USB 3.0 ports."
+    exit 0
+fi
+
+output=`cat /var/log/dmesg |grep -i ehci_hcd:| awk '{print $5}'`
+
+if [ "$output" = "2.0" ]; then
+    echo "Support USB 2.0 ports."
+    exit 0
+fi
+
+echo "Do not support USB 2.0 ports or higher."
+exit 1

=== modified file 'bin/cpu_info'
--- bin/cpu_info	2015-03-03 15:59:42 +0000
+++ bin/cpu_info	2015-08-14 22:03:31 +0000
@@ -3,6 +3,8 @@
 Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications 
 Industrial Technology Research Institute
 
+It is NOT YET officially approved by OCP.
+
 cpu_info
   Use lshw command to gather CPU information.
   The program will output CPU model and L1, L2, L3 cache size.

=== added file 'bin/cpu_info_leopard'
--- bin/cpu_info_leopard	1970-01-01 00:00:00 +0000
+++ bin/cpu_info_leopard	2015-08-14 22:03:31 +0000
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications 
+Industrial Technology Research Institute
+
+It is NOT YET officially approved by OCP.
+
+cpu_info
+  Use dmidecode command to gather CPU information.
+  The program will output CPU model and L1, L2, L3 cache size.
+  Criteria: CPU model and product family must match user's input.
+
+Authors
+  Nelson Chu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+import os
+import re
+import sys
+import xml.etree.ElementTree as ET
+from subprocess import check_output
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+def run(product, family):
+    command = "dmidecode -t processor |grep -E 'Version|Cache'"
+    with open(os.devnull, 'w') as NULL:
+        output = check_output(command, stderr=NULL, shell=True)
+    output = output.decode('utf-8').strip()
+
+    cpu_attr = []
+    for item in output.split('\n'):
+        cpu_attr.append(item.strip())
+
+    for attr in cpu_attr:
+        if attr.startswith("Version"):
+            processor = attr.split(':')[1].strip()
+            print(processor)
+            match = re.search(product + '.*' + family, processor)
+            if not match:
+                print("Fail: Cannot match CPU %s %s family." %(product, family)
+                      ,file=sys.stderr)
+                return 1
+        else:
+            cache_handle = attr.split(':')[1].strip()
+            command = "dmidecode -t cache|grep -a6 {0}".format(cache_handle) +\
+                "|grep -E 'Socket Designation|Installed Size'"
+            with open(os.devnull, 'w') as NULL:
+                output = check_output(command, stderr=NULL, shell=True)
+            output = output.decode('utf-8').strip()
+            print(output.split('\n')[0].split(':')[1].strip(),":", end="")
+            print(output.split('\n')[1].split(':')[1].strip())
+
+    return 0
+
+def main():
+    parser = ArgumentParser(formatter_class=RawTextHelpFormatter)
+
+    parser.add_argument('-p', '--product', type=str, required=True,
+                        help=("The CPU product name. [Example: Xeon]"))
+    parser.add_argument('-f', '--family', type=str, required=True,
+                        help=("Processor family. [Example: E5]"))
+
+    args = parser.parse_args()
+
+    product = args.product.title()
+    family = args.family.title()
+    return run(product, family)
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'bin/create_raid'
--- bin/create_raid	1970-01-01 00:00:00 +0000
+++ bin/create_raid	2015-08-14 22:03:31 +0000
@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+It is NOT YET officially approved by OCP.
+
+create_raid
+  Use megacli command to build user desired RAID on JBOD.
+
+  Warning: Make sure there is no RAID configuration in LSI RAID card 
+           before this program is performed.
+
+Authors
+  Nelson Chu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+import os
+import re
+import sys
+from time import sleep
+from subprocess import check_output, STDOUT, CalledProcessError
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+def get_adapter():
+    """
+    Gather all adapter number if there are multiple RAID cards.
+    """
+
+    command = 'megacli -CfgDsply -Aall|grep Adapter'
+    adapter_list = []
+
+    adapter_info = check_output(command, shell=True)
+    adapter_info = adapter_info.decode('utf-8')
+
+    for adapter in adapter_info.strip().split('\n'):
+        adapter_list.append(adapter.strip().split(' ')[-1])
+    return adapter_list
+
+
+def get_all_disk(adapter):
+    """
+    Gather all disks Enclosure and Slot number, and make a 
+    Enclosure:Slot pair list.
+    """
+
+    command = 'megacli -PDList -A{0}'.format(adapter) \
+        + '|grep -E "Enclosure Device ID|Slot Number"'
+
+    disk_list = []
+    disk_info = check_output(command, shell=True)
+    disk_info = disk_info.decode('utf-8')
+
+    for line in disk_info.strip().split('\n'):
+        if line.startswith('Enclosure'):
+            match = re.search(r'\d+', line)
+            disk_list.append(match.group(0))
+        if line.startswith('Slot'):
+            match = re.search(r'\d+', line)
+            enclosure = disk_list.pop()
+            E_S = '%s:%s' %(enclosure, match.group(0))
+            disk_list.append(E_S)
+    return disk_list
+
+
+def build_raid(raid_type, adapter, disk_list):
+    """
+    Use all disks creatd RAID.
+    If RAID type is 6 then set last disk as hot spare.
+    """
+
+    if raid_type == 0:
+        disk = ','.join(disk_list)
+        command = 'megacli -CfgLDadd -r{0} [{1}] WB Direct -a{2}'.format(
+            raid_type, disk, adapter)
+
+    if raid_type == 6:
+        # use the last disk as hot spare
+        spare = disk_list.pop()
+
+        disk = ','.join(disk_list)
+        command = 'megacli -CfgLDadd -r{0} [{1}] WB Direct -Hsp[{2}] -a{3}'.format(
+            raid_type, disk, spare, adapter)
+
+    output = check_output(command, stderr=STDOUT, shell=True)
+    output = output.decode('utf-8')
+    # wait for raid created
+    sleep(5)
+    print(output)
+
+
+def main():
+    parser = ArgumentParser(formatter_class=RawTextHelpFormatter)
+    parser.add_argument('-t', '--type', type=int, required=True,
+                        help=("The RAID type which want to create. "
+                              "[Example: 0 or 6]"))
+    args = parser.parse_args()
+    knox_dict = {}
+
+    # get RAID card adapter number
+    try:
+        adapter_list = get_adapter()
+    except CalledProcessError as e:
+        print(e.output.decode('utf-8'))
+        return 10
+
+    # get all disks in JBOD
+    try:
+        for adapter in adapter_list:
+            knox_dict[adapter] = get_all_disk(adapter)
+    except CalledProcessError as e:
+        print(e.output.decode('utf-8'))
+        return 20
+
+    # use all HDDs to build RAID
+    try:
+        for adapter, disk_list in knox_dict.items():
+            build_raid(args.type, adapter, disk_list)
+    except CalledProcessError as e:
+        print(e.output.decode('utf-8'))
+        return 30
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'bin/dcmi_inventory'
--- bin/dcmi_inventory	1970-01-01 00:00:00 +0000
+++ bin/dcmi_inventory	2015-08-14 22:03:31 +0000
@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_inventory
+  1. Use dcmitool to collect inventory information including Asset Tag, Device ID, System GUI, Firmware/Software Information, Management Controller ID
+  2. Criteria: All information mentioned above must not should not be null
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+import sys
+import time
+import shlex
+import subprocess
+import re
+import subprocess
+from subprocess import (
+    CalledProcessError,
+    check_call,
+    check_output
+)
+
+def get_asset_tag():
+
+    try:
+        cmd = 'dcmitool dcmi asset_tag'
+        dcmi_asset_tag_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing dcmi command for getting asset tag. Reason:%s" % command_exception)
+   
+    try:
+        asset_tag = re.search(r'Asset tag\s*:\s*([a-zA-Z0-9-._ ]+)', dcmi_asset_tag_return)
+        if asset_tag == None:
+            return 'Error'
+        return asset_tag.group(1).strip()
+    except:
+        return 'Error'
+
+def get_guid():
+
+    try:
+        cmd = 'dcmitool mc guid'
+        dcmi_guid_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing dcmi command for getting guid. Reason:%s" % command_exception)
+        
+    try:
+        mcguid = re.search(r'System GUID\s*:\s*([a-zA-Z0-9-._ ]+)', dcmi_guid_return)
+        if mcguid == None:
+            return 'Error'
+        return mcguid.group(1).strip()
+    except:
+        return 'Error'
+    
+def get_mcid():
+
+    try:
+        cmd = 'dcmitool dcmi get_mc_id_string'
+        dcmi_mcid_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing dcmi command for getting mc id. Reason:%s" % command_exception)
+
+    try:
+        mcid =  re.search(r'Get Management Controller Identifier String\s*:\s*([a-zA-Z0-9-._ ]+)', dcmi_mcid_return)
+        if mcid == None:
+            return 'Error'
+        return mcid.group(1).strip()
+    except:
+        return 'Error'
+
+def get_mcinfo():
+
+    try:
+        cmd = 'dcmitool mc info'
+        dcmi_mcinfo_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing dcmi command for getting mc info. Reason:%s" % command_exception)
+    
+    try:
+        deviceid = re.search(r'Device ID\s*:\s*([a-zA-Z0-9-._ ]+)', dcmi_mcinfo_return)
+        Manufac = re.search(r'Manufacturer Name\s*:\s*([a-zA-Z-._ ]+)', dcmi_mcinfo_return)
+        Firm = re.search(r'Firmware Revision\s+\s*:\s*([a-zA-Z0-9-._ ]+)', dcmi_mcinfo_return)
+
+        if deviceid == None or Manufac == None or Firm == None:
+            return 'Error', 'Error', 'Error'
+        return (deviceid.group(1).strip(), Manufac.group(1).strip(), Firm.group(1).strip())
+    except:
+        return 'Error', 'Error', 'Error'
+
+def main():
+
+    flag = 0
+    inventory_dict = {}
+    inventory_list = ['Asset Tag', 'System GUID', 'Get Management Controller Identifier String', 'Device ID', 'Manufacturer Name', 'Firmware Revision']
+    Device_ID, Manufacturer, Firmware = get_mcinfo()
+    inventory_dict.update({'Asset Tag':get_asset_tag()})
+    inventory_dict.update({'System GUID':get_guid()})
+    inventory_dict.update({'Get Management Controller Identifier String':get_mcid()})
+    inventory_dict.update({'Device ID':Device_ID})
+    inventory_dict.update({'Manufacturer Name':Manufacturer})
+    inventory_dict.update({'Firmware Revision':Firmware})
+
+    for item in inventory_list:
+        if inventory_dict.get(item) == 'Error':
+            flag = 1
+        else:
+            print("{}: {}".format(item, inventory_dict.get(item)))
+
+    if flag == 1:
+        return 1
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main())
+
+

=== added file 'bin/dcmi_power_off_on'
--- bin/dcmi_power_off_on	1970-01-01 00:00:00 +0000
+++ bin/dcmi_power_off_on	2015-08-14 22:03:31 +0000
@@ -0,0 +1,190 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_power_off_on
+  Use dcmitool out-of-band access to turn on/off the SUT
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def check_power_status(host_ip, user, password):
+
+    cmd_status_on = 'dcmitool -H {} -U {} -P {} power status| grep -q "on"'\
+			.format(host_ip, user, password)
+    check_on_value = subprocess.call(cmd_status_on, shell=True)
+    time.sleep(5)
+
+    cmd_status_off = 'dcmitool -H {} -U {} -P {} power status| grep -q "off"'\
+			.format(host_ip, user, password)
+    check_off_value = subprocess.call(cmd_status_off, shell=True)
+    time.sleep(5)
+
+    if check_on_value == 0 and check_off_value == 1:
+        check_status = 'on'
+    
+    elif check_on_value == 1 and check_off_value == 0:
+        check_status = 'off'
+
+    else:
+        check_status = 'error'
+
+    return check_status
+
+def run_power_off(host_ip, user, password):
+    cmd_power_off = 'dcmitool -H {} -U {} -P {} power off'\
+        .format(host_ip, user, password)
+    power_off_return_code = subprocess.call(cmd_power_off, shell=True)
+    return power_off_return_code
+
+def run_power_on(host_ip, user, password):
+    cmd_power_on = 'dcmitool -H {} -U {} -P {} power on'\
+        .format(host_ip, user, password)
+    power_on_return_code = subprocess.call(cmd_power_on, shell=True)
+    return power_on_return_code
+
+def dcmi_reset_oob(args):
+
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 30
+
+    try:
+        user_value = config.get('Account', 'USER')
+        passwd_value = config.get('Account', 'PASSWORD')
+        if not user_value or not passwd_value:
+            print("Invalid or Empty credential info")
+            return 40
+
+    except configparser.Error:
+        print("Invalid or Empty credential info")
+        return 50
+
+    ping_flag = 0
+    for tg in targets_list:
+    
+        if not tg or not user_value or not passwd_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 21
+        else:
+
+            print("SUT =", tg)
+            print("USER =", user_value)
+            print("PASSWORD =", passwd_value)
+
+            for n in range(2):
+
+                count = 0
+                while count < 10:
+                    ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(tg)
+                    ping_rtn = subprocess.call(ping_cmd, shell=True)
+                    if ping_rtn == 0:
+                        print("Destination Host Reachable")
+                        
+                        #run test
+                        status = check_power_status(tg, user_value, passwd_value)
+
+                        if status == 'on':
+                            #run power off
+                            power_off_result = run_power_off(tg, user_value, passwd_value)
+                            print(" ")
+                            if power_off_result == 1:
+                                print("Failed to power off SUT.")
+                                return 88
+                        elif status == 'off':
+                            #run power on
+                            power_on_result = run_power_on(tg, user_value, passwd_value)
+                            print(" ")
+                            if power_on_result == 1:
+                                print("Failed to power on SUT.")
+                                return 99
+                        else:
+                            #do nothing
+                            print("Failed to check power status")
+                            return 77
+                        
+                        time.sleep(30)
+                        break
+
+                    else:
+                        time.sleep(10)
+                        count = count+1
+                        print("Destination Host Unreachable")
+
+                if count == 10:         
+                    print("Host Has No Response, End of Test")
+                    ping_flag = 100
+
+    if ping_flag == 100:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message,
+		 formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/me.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return dcmi_reset_oob(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/dcmi_power_reset'
--- bin/dcmi_power_reset	1970-01-01 00:00:00 +0000
+++ bin/dcmi_power_reset	2015-08-14 22:03:31 +0000
@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_power_reset
+  Complete 20 power reset on SUT successfully using dcmitool out-of-band access
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def run(host_ip, user, password):
+    cmd = 'dcmitool -H {} -U {} -P {} power reset'.format(host_ip, user, password)
+    power_reset_return = check_output(shlex.split(cmd), universal_newlines=True)
+    return power_reset_return
+        
+def dcmi_reset_oob(args):
+
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 1
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 2
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 2
+
+    try:
+        user_value = config.get("Account", "USER")
+        password_value = config.get("Account", "PASSWORD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        return 3
+
+    ping_flag = 0
+    for tg in targets_list:    
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 4
+        else:
+            print("SUT =", tg)
+            print("USER =", user_value)
+            print("PASSWORD =", password_value)
+
+            for n in range(20):
+                print("---------------- %s ----------------" % n)
+                count = 0
+                while count < 10:
+                    print("+++++++++++ %s ++++++++++++" % count)
+                    ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(tg)
+                    ping_rtn = subprocess.call(ping_cmd, shell=True)
+
+                    if ping_rtn == 0:
+                        print("Destination Host Reachable")
+
+                        try:
+                            power_control = run(tg, user_value, password_value)
+                            print(power_control)
+                        except CalledProcessError as dcmi_exception:
+                            print("Failed executing dcmi, Reason: %s" % dcmi_exception)
+                            return 6
+
+                        time.sleep(30)
+                        break
+                    else:
+                        time.sleep(10)
+                        count = count+1
+                        print("Destination Host Unreachable")
+                
+                if count == 10:
+                    print("Host Has No Response, End of Test")
+                    ping_flag = 100
+
+    if ping_flag == 100:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config',
+                        default="/etc/checkbox.d/me.cfg",
+                        help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return dcmi_reset_oob(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/dcmi_priv_admin'
--- bin/dcmi_priv_admin	1970-01-01 00:00:00 +0000
+++ bin/dcmi_priv_admin	2015-08-14 22:03:31 +0000
@@ -0,0 +1,174 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_priv_admin  
+  1. Use dcmitool out-of-band to read power status, to perform power reset and add a new user account
+  2. Criteria: Reading power status, performing power reset and adding a user account must all be successful
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_power_status(host_ip, user, password):
+    cmd_status = 'dcmitool -H {} -U {} -P {} power status 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    status_code = subprocess.call(cmd_status, shell=True)
+    return status_code
+    
+def power_reset(host_ip, user, password):
+    cmd_reset = 'dcmitool -H {} -U {} -P {} power reset 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    reset_code = subprocess.call(cmd_reset, shell=True)
+    return reset_code
+
+def add_user(host_ip, user, password, new_id, new_user):
+    cmd_add_user = 'dcmitool -H {} -U {} -P {} user set name {} {} 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password, new_id, new_user)
+    add_user_code = subprocess.call(cmd_add_user, shell=True)
+    return add_user_code
+
+def dcmi_user_level_test(args):
+
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 20
+
+    try:
+        user_value = config.get("Admin Level", "ADMIN_NAME")
+        password_value = config.get("Admin Level", "ADMIN_PASSWD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        print("Require Operator Level info pre-configured in /etc/checkbox.d/me.cfg")
+        return 30
+
+    try:
+        new_user_value = config.get("Add User Test", "NEW_USER_NAME")
+        new_user_id_value = config.get("Add User Test", "NEW_USER_ID")
+    except configparser.NoOptionError:
+        print("Invalid or Empty new user info")
+        print("Require new User info pre-configured in /etc/checkbox.d/me.cfg")
+        return 40
+
+    flag = 0
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 50
+        else:
+            print("SUT", tg)
+
+            ping_result = ping_test(tg)
+            if ping_result != 0:
+                return 88
+
+            status_result = get_power_status(tg, user_value, password_value)
+            time.sleep(5)
+
+            reset_result = power_reset(tg, user_value, password_value)
+            time.sleep(5)
+            if not new_user_value or not new_user_id_value:
+                print("Require new user info pre-configured in /etc/checkbox.d/me.cfg")
+                return 60
+            else:
+
+                ping_result = ping_test(tg)
+                if ping_result != 0:
+                    return 88
+
+                add_user_result = add_user(tg, user_value, password_value, new_user_id_value, new_user_value)
+                time.sleep(5)
+
+            if status_result == 0 and reset_result == 0 and add_user_result == 0:
+                print("User can read power status.")
+                print("User can reset power.")
+                print("User can add a new user.")
+            else:
+                print("Authentication: Not Administrator Level")
+                flag = 1
+
+    if flag == 1:
+        return 100
+    return 0
+
+def ping_test(host_ip):
+    count = 0
+    while count < 10:
+        ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(host_ip)
+        ping_rtn = subprocess.call(ping_cmd, shell=True)
+        if ping_rtn == 0:
+            return 0
+        else:
+            print("Destination Host Unreachable")
+            time.sleep(10)
+            count = count+1
+
+    if count == 10:
+        print("Host Has No Response, End of Test")
+        return 1
+
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/me.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return dcmi_user_level_test(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/dcmi_priv_oper'
--- bin/dcmi_priv_oper	1970-01-01 00:00:00 +0000
+++ bin/dcmi_priv_oper	2015-08-14 22:03:31 +0000
@@ -0,0 +1,174 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_priv_oper
+  1. Use dcmitool out-of-band to read power status, to perform power reset and add a new user account
+  2. Criteria: power status reading and power reset must be successful and must fail at adding a new user account
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_power_status(host_ip, user, password):
+    cmd_status = 'dcmitool -H {} -U {} -P {} power status 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    status_code = subprocess.call(cmd_status, shell=True)
+    return status_code
+    
+def power_reset(host_ip, user, password):
+    cmd_reset = 'dcmitool -H {} -U {} -P {} power reset 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    reset_code = subprocess.call(cmd_reset, shell=True)
+    return reset_code
+
+def add_user(host_ip, user, password, new_id, new_user):
+    cmd_add_user = 'dcmitool -H {} -U {} -P {} user set name {} {} 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password, new_id, new_user)
+    add_user_code = subprocess.call(cmd_add_user, shell=True)
+    return add_user_code
+
+def dcmi_user_level_test(args):
+
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 20
+
+    try:
+        user_value = config.get("Operator Level", "OPER_NAME")
+        password_value = config.get("Operator Level", "OPER_PASSWD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        print("Require Operator Level info pre-configured in /etc/checkbox.d/me.cfg")
+        return 30
+
+    try:
+        new_user_value = config.get("Add User Test", "NEW_USER_NAME")
+        new_user_id_value = config.get("Add User Test", "NEW_USER_ID")
+    except configparser.NoOptionError:
+        print("Invalid or Empty new user info")
+        print("Require new User info pre-configured in /etc/checkbox.d/me.cfg")
+        return 40
+
+    flag = 0
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 50
+        else:
+            print("SUT", tg)
+
+            ping_result = ping_test(tg)
+            if ping_result != 0:
+                return 88
+
+            status_result = get_power_status(tg, user_value, password_value)
+            time.sleep(5)
+
+            reset_result = power_reset(tg, user_value, password_value)
+            time.sleep(5)
+            if not new_user_value or not new_user_id_value:
+                print("Require new user info pre-configured in /etc/checkbox.d/me.cfg")
+                return 60
+            else:
+
+                ping_result = ping_test(tg)
+                if ping_result != 0:
+                    return 88
+
+                add_user_result = add_user(tg, user_value, password_value, new_user_id_value, new_user_value)
+                time.sleep(5)
+
+            if status_result == 0 and reset_result == 0 and add_user_result == 1:
+                print("User can read power status.")
+                print("User can reset power.")
+                print("User can't add a new user.")
+            else:
+                print("Authentication: Not Operator Level")
+                flag = 1
+
+    if flag == 1:
+        return 100
+    return 0
+
+def ping_test(host_ip):
+    count = 0
+    while count < 10:
+        ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(host_ip)
+        ping_rtn = subprocess.call(ping_cmd, shell=True)
+        if ping_rtn == 0:
+            return 0
+        else:
+            print("Destination Host Unreachable")
+            time.sleep(10)
+            count = count+1
+
+    if count == 10:
+        print("Host Has No Response, End of Test")
+        return 1
+
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/me.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return dcmi_user_level_test(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/dcmi_priv_user'
--- bin/dcmi_priv_user	1970-01-01 00:00:00 +0000
+++ bin/dcmi_priv_user	2015-08-14 22:03:31 +0000
@@ -0,0 +1,174 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_priv_uesr  
+  1. Use dcmitool out-of-band to read power status, to perform power reset and add a new user account
+  2. Criteria: power status reading must be successful and must fail at power reset and adding a new user account
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_power_status(host_ip, user, password):
+    cmd_status = 'dcmitool -H {} -U {} -P {} power status 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    status_code = subprocess.call(cmd_status, shell=True)
+    return status_code
+    
+def power_reset(host_ip, user, password):
+    cmd_reset = 'dcmitool -H {} -U {} -P {} power reset 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    reset_code = subprocess.call(cmd_reset, shell=True)
+    return reset_code
+
+def add_user(host_ip, user, password, new_id, new_user):
+    cmd_add_user = 'dcmitool -H {} -U {} -P {} user set name {} {} 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password, new_id, new_user)
+    add_user_code = subprocess.call(cmd_add_user, shell=True)
+    return add_user_code
+
+def dcmi_user_level_test(args):
+
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 20
+
+    try:
+        user_value = config.get("User Level", "USER_NAME")
+        password_value = config.get("User Level", "USER_PASSWD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        print("Require User Level info pre-configured in /etc/checkbox.d/me.cfg")
+        return 30
+
+    try:
+        new_user_value = config.get("Add User Test", "NEW_USER_NAME")
+        new_user_id_value = config.get("Add User Test", "NEW_USER_ID")
+    except configparser.NoOptionError:
+        print("Invalid or Empty new user info")
+        print("Require new User info pre-configured in /etc/checkbox.d/me.cfg")
+        return 40
+
+    flag = 0
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 50
+        else:
+            print("SUT", tg)
+
+            ping_result = ping_test(tg)
+            if ping_result != 0:
+                return 88
+
+            status_result = get_power_status(tg, user_value, password_value)
+            time.sleep(5)
+
+            reset_result = power_reset(tg, user_value, password_value)
+            time.sleep(5)
+            if not new_user_value or not new_user_id_value:
+                print("Require new user info pre-configured in /etc/checkbox.d/me.cfg")
+                return 60
+            else:
+
+                ping_result = ping_test(tg)
+                if ping_result != 0:
+                    return 88
+
+                add_user_result = add_user(tg, user_value, password_value, new_user_id_value, new_user_value)
+                time.sleep(5)
+
+            if status_result == 0 and reset_result == 1 and add_user_result == 1:
+                print("User can read power status.")
+                print("User can't reset power.")
+                print("User can't add a new user.")
+            else:
+                print("Authentication: Not User Level")
+                flag = 1
+
+    if flag == 1:
+        return 100
+    return 0
+
+def ping_test(host_ip):
+    count = 0
+    while count < 10:
+        ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(host_ip)
+        ping_rtn = subprocess.call(ping_cmd, shell=True)
+        if ping_rtn == 0:
+            return 0
+        else:
+            print("Destination Host Unreachable")
+            time.sleep(10)
+            count = count+1
+
+    if count == 10:
+        print("Host Has No Response, End of Test")
+        return 1
+
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/me.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return dcmi_user_level_test(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/dcmi_sampling'
--- bin/dcmi_sampling	1970-01-01 00:00:00 +0000
+++ bin/dcmi_sampling	2015-08-14 22:03:31 +0000
@@ -0,0 +1,271 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_sampling
+  1. Retrieve CPU and intake temperature 30 times at 3 second intervals using dcmitool
+  2. If failed to retrieve temperature at any time within 30 times, the test is considered failed
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+import sys
+import time
+import re
+import configparser
+import shlex
+import subprocess
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_sdr_remote(host_ip, user, password):
+    cmd = "dcmitool -H {} -U {} -P {} sdr".format(host_ip, user, password)
+    sdr_return = subprocess.check_output(shlex.split(cmd), stderr=subprocess.STDOUT,
+                                         universal_newlines=True)
+    return sdr_return
+
+def parse_sdr(output):
+    output = output.strip()
+    output_1Line = output.split("\n")
+    data = {}
+
+    for line in output_1Line:
+        sub_value = {}
+        string_list = line.split("|")
+        name = string_list[0].strip()
+        sensor_output = string_list[1].strip()
+        sub_value.update({'output':sensor_output})
+        status = string_list[2].strip()
+        sub_value.update({'status':status})
+        data.update({name:sub_value})
+    return data
+
+def calculate_CPU_temp(data_dict, CPU_Therm_Margin_id, CPU_Tjmax_id):
+    if data_dict.get(CPU_Therm_Margin_id) and data_dict.get(CPU_Tjmax_id):
+        if data_dict.get(CPU_Therm_Margin_id).get('status') == 'ok' and data_dict.get(CPU_Tjmax_id).get('status') == 'ok':
+            P_Therm_Margin_output = data_dict.get(CPU_Therm_Margin_id).get('output')
+            CPU_Tjmax_output = data_dict.get(CPU_Tjmax_id).get('output')
+            P_Therm_Margin = re.search(r'[0-9-]+', P_Therm_Margin_output).group(0)
+            CPU_Tjmax = re.search(r'[0-9-]+', CPU_Tjmax_output).group(0)
+            CPU_temp = int(P_Therm_Margin)+int(CPU_Tjmax)
+            return str(CPU_temp)+' degrees C'
+        else:
+            return 'Error'
+    else:
+        return 'None'
+        
+def dcmi_sdr(args):
+
+    cmd_flag = 0
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        sensor_nick = config.options("SensorsForSampling")
+    except configparser.NoSectionError:
+        print("No Section: SensorsForSampling")
+        return 20
+
+    if sensor_nick:
+        sensor_list = []
+        for id in sensor_nick:
+            sensor_key = config.get("SensorsForSampling", id)
+            if sensor_key:
+                sensor_list.append(sensor_key)
+            else:
+                print("No Sensor ID specified in Config file")
+                return 30
+    else:
+        print("No key of Sensor ID specified in config file")
+        return 40
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 60
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 60
+
+    try:
+        user_value = config.get("Account", "USER")
+        password_value = config.get("Account", "PASSWORD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        return 70
+
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 80
+        else:
+
+            c = 0
+            while c < 10:
+                ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(tg)
+                ping_rtn = subprocess.call(ping_cmd, shell=True)
+                if ping_rtn == 0:
+                    print("Destination Host Reachable")
+                    break
+                else:
+                    time.sleep(10)
+                    c = c+1
+                    print("Destination Host Unreachable")
+
+            if c == 10:
+                print("Host Has No Response, End of Test")
+                return 99
+
+
+            sampling_data = []
+            times = 30
+            for n in range(times):
+
+                try:
+                    sensor_data = get_sdr_remote(tg, user_value, password_value)
+                    time.sleep(3)
+                except CalledProcessError as dcmi_exception:
+                    print("Failed executing dcmi, Reason: %s" % dcmi_exception)
+                    sensor_data = ''
+
+                sampling_data.append(sensor_data)
+            
+            count = 0
+            prs_flag = 0
+            dis_flag = 0
+            for output in sampling_data:
+                try:
+                    data = parse_sdr(output)
+                except:
+                    print("Parsing output of sdr table error")
+                    print("=======================================================")
+                    prs_flag = 1
+                    count = count+1
+                    continue
+
+                disable = 0
+                need_data = {}
+
+                for need_id in sensor_list:
+
+                    if data.get(need_id):
+                        need_value = data.get(need_id).get('output')
+                        need_data.update({need_id:need_value})
+                        if data.get(need_id).get('status') != 'ok':
+                            disable = 1
+                    else:
+
+                        try:
+                            CPUx_Temp = config.get("Sensors", "CPUx")
+                        except configparser.NoOptionError:
+                            CPUx_Temp = ''
+
+                        try:
+                            CPUy_Temp = config.get("Sensors", "CPUy")
+                        except configparser.NoOptionError:
+                            CPUy_Temp = ''
+                    
+                        if need_id == CPUx_Temp:
+                        
+                            try:
+                                PxTM = config.get("SensorsForCPUTemp", "Px Therm Margin")
+                            except configparser.NoOptionError:
+                                PxTM = ''
+
+                            try:
+                                CPUx_Tjmax = config.get("SensorsForCPUTemp", "CPUx Tjmax")
+                            except configparser.NoOptionError:
+                                CPUx_Tjmax = ''
+
+                            if PxTM and CPUx_Tjmax:
+                                Px_temp = calculate_CPU_temp(data, PxTM, CPUx_Tjmax) 
+                                need_data.update({CPUx_Temp:Px_temp})
+                                if Px_temp == 'None' or Px_temp == 'Error':
+                                    disable = 1
+                            else:
+                                disable = 1
+                                
+                        elif need_id == CPUy_Temp:
+
+                            try:
+                                PyTM = config.get("SensorsForCPUTemp", "Py Therm Margin")
+                            except configparser.NoOptionError:
+                                PyTM = ''
+
+                            try:
+                                CPUy_Tjmax = config.get("SensorsForCPUTemp", "CPUy Tjmax")
+                            except configparser.NoOptionError:
+                                CPUy_Tjmax = ''
+
+                            if PyTM and CPUy_Tjmax:
+                                Py_temp = calculate_CPU_temp(data, PyTM, CPUy_Tjmax)
+                                need_data.update({CPUy_Temp:Py_temp})
+                                if Py_temp == 'None' or Py_temp == 'Error':
+                                    disable = 1
+                            else:
+                                disable = 1
+                                
+                        else:
+                            need_data.update({need_id:'None'})
+                            disable = 1
+            
+                if disable == 1:
+                    dis_flag = 1
+                    print(need_data)
+                    print("=======================================================")
+                    count = count+1
+        print("Pass: %d" %(times-count))
+        print("Fail: %d" %(count))
+        
+    if cmd_flag == 1 or prs_flag == 1 or dis_flag == 1:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str, default="/etc/checkbox.d/me.cfg", help="Supply config file for sensor IDs parameters")
+    args = parser.parse_args()
+    return dcmi_sdr(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/dcmi_thermal_ib'
--- bin/dcmi_thermal_ib	1970-01-01 00:00:00 +0000
+++ bin/dcmi_thermal_ib	2015-08-14 22:03:31 +0000
@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_thermal_ib
+  1. Retrieve CPU, DIMM, chipset, inlet and outlet temperatures via DCMI in-band access using dcmitool.
+  2. The motherboard has five thermal sensors:
+     Two for CPU0 and CPU1 temperatures,
+     Two for CPU0 DIMM group and CPU1 DIMM group temperatures,
+     One for PCH temperature, 
+     One for Inlet temperature,
+     One for outlet temperature.
+  3. Criteria: Must retrieve temperatures from all abovementioned thermal sensors via DCMI in-band access.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+import sys
+import time
+import re
+import configparser
+import shlex
+import subprocess
+import ast
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+
+def get_sdr():
+    cmd = "dcmitool sdr"
+    sdr_return = subprocess.check_output(shlex.split(cmd), universal_newlines=True)
+    return sdr_return
+
+def parse_sdr(output):
+    output = output.strip()
+    output_1Line = output.split("\n")
+    data = {}
+
+    for line in output_1Line:
+        sub_value = {}
+        string_list = line.split("|")
+        name = string_list[0].strip()
+        sensor_output = string_list[1].strip()
+        sub_value.update({'output':sensor_output})
+        status = string_list[2].strip()
+        sub_value.update({'status':status})
+        data.update({name:sub_value})
+    return data
+
+def calculate_CPU_temp(data_dict, CPU_Therm_Margin_id, CPU_Tjmax_id):
+
+    if data_dict.get(CPU_Therm_Margin_id) and data_dict.get(CPU_Tjmax_id):
+        if data_dict.get(CPU_Therm_Margin_id).get('status') == 'ok' and data_dict.get(CPU_Tjmax_id).get('status') == 'ok':
+            P_Therm_Margin_output = data_dict.get(CPU_Therm_Margin_id).get('output')
+            CPU_Tjmax_output = data_dict.get(CPU_Tjmax_id).get('output')
+            P_Therm_Margin = re.search(r'[0-9-]+', P_Therm_Margin_output).group(0)
+            CPU_Tjmax = re.search(r'[0-9-]+', CPU_Tjmax_output).group(0)
+            CPU_temp = int(P_Therm_Margin)+int(CPU_Tjmax)
+            return str(CPU_temp)+' degrees C'
+        else:
+            return 'Error'
+    else:
+        return 'None'
+
+def dcmi_sdr(args):
+
+    flag = 0
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        sensor_nick = config.options("Sensors")			
+    except configparser.NoSectionError:
+        print("No Section: Sensors")
+        return 20
+
+    if sensor_nick:
+        sensor_list = []
+        for id in sensor_nick:
+            sensor_key = config.get("Sensors", id)
+            if sensor_key:
+                sensor_list.append(sensor_key)
+            else:
+                print("No Sensor ID specified in Config file")
+                return 30
+    else:
+        print("No key of Sensor ID specified in config file")
+        return 40
+
+    try:
+        sensor_data = get_sdr()
+        time.sleep(5)
+    except CalledProcessError as dcmi_exception:
+        print("Failed executing dcmi, Reason: %s" % dcmi_exception)
+        return 50
+
+    try:
+        data = parse_sdr(sensor_data)
+    except:
+        print("Parsing output of sdr table error")
+        return 60
+
+    need_data = {}
+    for need_id in sensor_list:
+        if data.get(need_id):
+            need_value = data.get(need_id).get('output')
+            need_data.update({need_id:need_value})
+            
+            if data.get(need_id).get('status') != 'ok':
+                flag = 1
+        else:
+
+           try:
+               CPUx_Temp = config.get("Sensors", "CPUx")
+           except configparser.NoOptionError:
+               CPUx_Temp = ''
+
+           try:
+               CPUy_Temp = config.get("Sensors", "CPUy")
+           except configparser.NoOptionError:
+               CPUy_Temp = ''
+
+           if need_id == CPUx_Temp:
+
+                try:
+                    PxTM = config.get("SensorsForCPUTemp", "Px Therm Margin")
+                except configparser.NoOptionError:
+                    PxTM = ''
+                    
+                try:
+                    CPUx_Tjmax = config.get("SensorsForCPUTemp", "CPUx Tjmax")
+                except configparser.NoOptionError:
+                    CPUx_Tjmax = ''
+
+                if PxTM and CPUx_Tjmax:
+                    need_data.update({CPUx_Temp:calculate_CPU_temp(data, PxTM, CPUx_Tjmax)})
+                    if calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'None' or calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'Error':
+                        flag = 1
+                else:
+                    flag = 1
+
+           elif need_id == CPUy_Temp:
+                
+                try:
+                    PyTM = config.get("SensorsForCPUTemp", "Py Therm Margin")
+                except configparser.NoOptionError:
+                    PyTM = ''
+
+                try:
+                    CPUy_Tjmax = config.get("SensorsForCPUTemp", "CPUy Tjmax")
+                except configparser.NoOptionError:
+                    CPUy_Tjmax = ''
+
+
+                if PyTM and CPUy_Tjmax:
+                    need_data.update({CPUy_Temp:calculate_CPU_temp(data, PyTM, CPUy_Tjmax)})
+                    if calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'None' or calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'Error':
+                        flag = 1
+                else:
+                    flag = 1
+           else:
+                flag = 1
+            
+        print("%s: %s" %(need_id, need_data.get(need_id)))
+
+    if flag == 1:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str, default="/etc/checkbox.d/me.cfg", help="Supply config file for sensor IDs parameters")
+    args = parser.parse_args()
+    return dcmi_sdr(args)
+
+if __name__ == "__main__":
+    sys.exit(main())
+

=== added file 'bin/dcmi_thermal_oob'
--- bin/dcmi_thermal_oob	1970-01-01 00:00:00 +0000
+++ bin/dcmi_thermal_oob	2015-08-14 22:03:31 +0000
@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  dcmi_thermal_oob
+  1. Retrieving CPU, DIMM, chipset, inlet, outlet temperature via DCMI out-of-band access using dcmitool.
+  2. The motherboard has five thermal sensors: Two for CPU0 and CPU1 temperatures,
+     Two for CPU0 DIMM group and CPU1 DIMM group temperatures,
+     One for PCH temperature,
+     One for Inlet temperature,
+     One for outlet temperature.
+  3. Criteria: Must retrieve temperatures from all abovementioned thermal sensors via DCMI out-of-band access.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+import sys
+import time
+import re
+import configparser
+import shlex
+import subprocess
+import ast
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_sdr_remote(host_ip, user, password):
+    cmd = "dcmitool -H {} -U {} -P {} sdr".format(host_ip, user, password)
+    sdr_return = subprocess.check_output(shlex.split(cmd), stderr=subprocess.STDOUT,
+                                         universal_newlines=True)
+    return sdr_return
+
+def parse_sdr(output):
+    output = output.strip()
+    output_1Line = output.split("\n")
+    data = {}
+
+    for line in output_1Line:
+        sub_value = {}
+        string_list = line.split("|")
+        name = string_list[0].strip()
+        sensor_output = string_list[1].strip()
+        sub_value.update({'output':sensor_output})
+        status = string_list[2].strip()
+        sub_value.update({'status':status})
+        data.update({name:sub_value})
+    return data
+
+def calculate_CPU_temp(data_dict, CPU_Therm_Margin_id, CPU_Tjmax_id):
+
+    if data_dict.get(CPU_Therm_Margin_id) and data_dict.get(CPU_Tjmax_id):
+        if data_dict.get(CPU_Therm_Margin_id).get('status') == 'ok' and data_dict.get(CPU_Tjmax_id).get('status') == 'ok':
+            P_Therm_Margin_output = data_dict.get(CPU_Therm_Margin_id).get('output')
+            CPU_Tjmax_output = data_dict.get(CPU_Tjmax_id).get('output')
+            P_Therm_Margin = re.search(r'[0-9-]+', P_Therm_Margin_output).group(0)
+            CPU_Tjmax = re.search(r'[0-9-]+', CPU_Tjmax_output).group(0)
+            CPU_temp = int(P_Therm_Margin)+int(CPU_Tjmax)
+            return str(CPU_temp)+' degrees C'
+        else:
+            return 'Error'
+    else:
+        return 'None'
+
+def dcmi_sdr(args):
+
+    flag = 0
+    #DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        sensor_nick = config.options("Sensors")
+    except configparser.NoSectionError:
+        print("No Section: Sensors")
+        return 20
+    
+    if sensor_nick:
+        sensor_list = []
+        for id in sensor_nick:
+            sensor_key = config.get("Sensors", id)
+            if sensor_key:
+                sensor_list.append(sensor_key)
+            else:
+                print("No Sensor ID specified in Config file")
+                return 30
+    else:
+        print("No key of Sensor ID specified in config file")
+        return 40
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 60
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 60
+
+    try:
+        user_value = config.get("Account", "USER")
+        password_value = config.get("Account", "PASSWORD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        return 70
+
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 80
+        else:
+
+            print("SUT =", tg)
+            print("USER =", user_value)
+            print("PASSWORD =", password_value)
+
+            try:
+                sensor_data = get_sdr_remote(tg, user_value, password_value)
+                time.sleep(5)
+            except CalledProcessError as dcmi_exception:
+                print("Failed executing dcmi, Reason: %s" % dcmi_exception)
+                return 50
+
+            try:
+                data = parse_sdr(sensor_data)
+            except:
+                print("Parsing output of sdr table error")
+                flag = 1
+                continue
+
+            need_data = {}
+            for need_id in sensor_list:
+
+                if data.get(need_id):
+                    need_value = data.get(need_id).get('output')
+                    need_data.update({need_id:need_value})
+
+                    if data.get(need_id).get('status') != 'ok':
+                        flag = 1
+                else:
+
+                    try:
+                        CPUx_Temp = config.get("Sensors", "CPUx")
+                    except configparser.NoOptionError:
+                        CPUx_Temp = ''
+
+                    try:
+                        CPUy_Temp = config.get("Sensors", "CPUy")
+                    except configparser.NoOptionError:
+                        CPUy_Temp = ''
+
+                    if need_id == CPUx_Temp:
+
+                        try:
+                            PxTM = config.get("SensorsForCPUTemp", "Px Therm Margin")
+                        except configparser.NoOptionError:
+                            PxTM = ''
+
+                        try:
+                            CPUx_Tjmax = config.get("SensorsForCPUTemp", "CPUx Tjmax")
+                        except configparser.NoOptionError:
+                            CPUx_Tjmax = ''
+
+                        if PxTM and CPUx_Tjmax:
+                            need_data.update({CPUx_Temp:calculate_CPU_temp(data, PxTM, CPUx_Tjmax)})
+                            if calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'None' or calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'Error':
+                                flag = 1
+                        else:
+                            flag = 1
+
+                    elif need_id == CPUy_Temp:
+                        
+                        try:
+                            PyTM = config.get("SensorsForCPUTemp", "Py Therm Margin")
+                        except configparser.NoOptionError:
+                            PyTM = ''
+
+                        try:
+                            CPUy_Tjmax = config.get("SensorsForCPUTemp", "CPUy Tjmax")
+                        except configparser.NoOptionError:
+                            CPUy_Tjmax = ''
+                        
+                        if PyTM and CPUy_Tjmax:
+                            need_data.update({CPUy_Temp:calculate_CPU_temp(data, PyTM, CPUy_Tjmax)})
+                            if calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'None' or calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'Error':
+                                flag = 1
+                        else:
+                            flag = 1
+                    else:
+                        #need_data.update({need_id:'None'})
+                        flag = 1
+
+                print("%s: %s" %(need_id, need_data.get(need_id)))
+
+    if flag == 1:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str, default="/etc/checkbox.d/me.cfg", help="Supply config file for sensor IDs parameters")
+    args = parser.parse_args()
+    return dcmi_sdr(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/disk_health'
--- bin/disk_health	1970-01-01 00:00:00 +0000
+++ bin/disk_health	2015-08-14 22:03:31 +0000
@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+It is NOT YET officially approved by OCP.
+
+disk_health
+  1. Use smartmontools to monitor disk health.
+  2. SMART threshold, grown defect list (glist or reallocated sectors) 
+     <= 100 for 4TB, glist <=50 for 2TB for all vendors.
+  3. SMART HDD temp <= 60 degrees centigrade.
+  4. Criteria: all threshold must not exceed the criteria listed in item 2 
+               and 3.
+
+Authors
+  Nelson Chu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+import os
+import re
+import sys
+from subprocess import check_output
+from argparse import ArgumentParser, RawTextHelpFormatter
+
+def run(device):
+    return_code = 0
+    command = "smartctl -a {0}".format(device)
+
+    try:
+        with open(os.devnull, "w") as NULL:
+            smartctl_info = check_output(command, stderr=NULL, shell=True)
+    except Exception as e:
+        print(e.output.decode('utf-8'))
+        return_code = 10
+        return return_code
+
+    smartctl_info = smartctl_info.decode('utf-8')
+
+    # Verify disk capacity match the criteria or not.
+    capacity_match =re.search(r'User Capacity.*\[(2|4).*TB\]', smartctl_info)
+    if not capacity_match:
+        print("Disk capacity is not match 2TB or 4TB.")
+        return_code = 20
+        return return_code
+
+    disk_capacity = int(capacity_match.group(1))
+    print("Disk capacity: %dTB" %(disk_capacity))
+
+    # Verify disk temperature match the criteria or not.
+    temperature_match = re.search(r'Temperature_Celsius.*\s(\d+)(\s\(|\n)',
+                                  smartctl_info)
+    if not temperature_match:
+        temperature_match = re.search(r'Current Drive Temperature\D*(\d+)',
+                                      smartctl_info)
+        if not temperature_match:
+            print("Cannot retrieve disk temperature.")
+            return_code = 30
+            return return_code
+
+    disk_temperature = int(temperature_match.group(1))
+    print("Disk current temperature: %d degrees centigrade"
+          %disk_temperature)
+    if disk_temperature > 60:
+        return_code = 40
+
+    # Verify reallocated sectors match the criteria or not.
+    reallocated_sector_match = re.search(r'Reallocated_Sector_Ct.*\s(\d+)\n',
+                                         smartctl_info)
+    if reallocated_sector_match:
+        reallocated_sector = int(reallocated_sector_match.group(1))
+        print("Reallocated_Sector_Ct: %d" %reallocated_sector)
+        if disk_capacity == 2 and reallocated_sector > 50:
+            return_code = 50
+        if disk_capacity == 4 and reallocated_sector > 100:
+            return_code = 60
+
+    # Verify grown defect list match the criteria or not.
+    grown_defect_match = re.search(r'Elements in grown defect list\:\s(\d+)\n',
+                                   smartctl_info)
+    if grown_defect_match:
+        grown_defect_list = int(grown_defect_match.group(1))
+        print("Elements in grown defect list: %d" %grown_defect_list)
+        if disk_capacity == 2 and grown_defect_list > 50:
+            return_code = 70
+        if disk_capacity == 4 and grown_defect_list > 100:
+            return_code = 80
+
+    # Check current pending sectort.
+    current_pending_match = re.search(r'Current_Pending_Sector.*\s(\d+)\n',
+                                      smartctl_info)
+    if current_pending_match:
+        current_pending_sector = int(current_pending_match.group(1))
+        print("Current_Pending_Sector: %d" %current_pending_sector)
+        if current_pending_sector != 0:
+            return_code = 90
+
+    # Check error counter log.
+    total_uncorrected_errors = re.search(
+        r'\nread.*\s(\d+)\nwrite.*\s(\d+)\nverify.*\s(\d+)', smartctl_info)
+    if total_uncorrected_errors:
+        read = int(total_uncorrected_errors.group(1))
+        write = int(total_uncorrected_errors.group(2))
+        verify = int(total_uncorrected_errors.group(3))
+        print("Total uncorrected errors: read=%d write=%d verify=%d"
+              %(read, write, verify))
+        if read != 0 or write != 0 or verify != 0:
+            return_code = 100
+    return return_code
+
+def main():
+    parser = ArgumentParser(formatter_class=RawTextHelpFormatter)
+    parser.add_argument('-d', '--device', type=str, required=True,
+                        help=("The device that wants to monitor health."))
+    args = parser.parse_args()
+    
+    device = args.device
+    if not device.startswith('/dev/'):
+        device = '/dev/' + device
+
+    return run(device)
+
+if __name__ == '__main__':
+    sys.exit(main())

=== modified file 'bin/disk_info'
--- bin/disk_info	2015-03-03 15:59:42 +0000
+++ bin/disk_info	2015-08-14 22:03:31 +0000
@@ -3,6 +3,8 @@
 Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
 Industrial Technology Research Institute
 
+It is NOT YET officially approved by OCP.
+
 disk_info
   1. Use lshw command to gather disk information.
   2. The program will output disk type, vendor, product, capacity.

=== added file 'bin/disk_info_leopard'
--- bin/disk_info_leopard	1970-01-01 00:00:00 +0000
+++ bin/disk_info_leopard	2015-08-14 22:03:31 +0000
@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+It is NOT YET officially approved by OCP.
+
+disk_info
+  1. Use lshw command to gather disk information.
+  2. The program will output disk type, vendor, product, capacity.
+  3. Criteria: must be able to retrieve disk information.
+
+Authors
+  Nelson Chu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+import sys
+import xml.etree.ElementTree as ET
+from subprocess import Popen, PIPE
+
+def main():
+    attribute = ['description', 'product', 'size']
+    command = 'lshw -xml'
+    hwinfo_xml = Popen(command, stdout=PIPE, stderr=PIPE,
+                       shell=True).communicate()[0]
+    root = ET.fromstring(hwinfo_xml)
+
+    # Parse lshw XML for gathering disk information.
+    disk_list = root.findall(".//node[@class='disk']")
+
+    if not disk_list:
+        print("Cannot parse any disk information.", file=sys.stderr)
+        return 10
+
+    for disk in disk_list:
+        for attr in attribute:
+            if disk.find(attr) is None:
+                print(("Cannot found disk %s") %attr, file=sys.stderr)
+                return 20
+
+        disk_size = int(disk.find('size').text) / (1000**3)
+        for attr in attribute:
+            if attr == 'description':
+                print(("Type=\"%s\"") %disk.find(attr).text)
+                continue
+            elif attr == 'size':
+                print(("%s=\"%dGB\"") %(attr.capitalize(), disk_size))
+                continue
+            else:
+                print(("%s=\"%s\"") %(attr.capitalize(), disk.find(attr).text))
+    return 0
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'bin/ipmi_fru'
--- bin/ipmi_fru	1970-01-01 00:00:00 +0000
+++ bin/ipmi_fru	2015-08-14 22:03:31 +0000
@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_fru
+
+Description
+  1. Use ipmitool to retrieve FRU data.
+  2. The data contains product manufacture, product part number, product serial number, motherboard serial number.
+  3. Criteria: Above All data mentioned above must notshould not be null
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import shlex
+import time
+import subprocess
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+import re
+import configparser
+
+def get_system_manufacturer(output):
+    system_manufacture = re.search(r'Product Manufacturer\s*:\s*([a-zA-Z0-9-._ ]+\n)', output)
+    if system_manufacture  == None:
+        return 'Error'
+    else:
+        return system_manufacture.group(1).strip()
+
+def get_system_part_number(output):
+    system_part_number = re.search(r'Product Part Number\s*:\s*([a-zA-Z0-9-._ ]+\n)', output)
+    if system_part_number == None:
+        return 'Error'
+    else:
+        return system_part_number.group(1).strip()
+    
+def get_system_serial_number(output):
+    system_serial_number = re.search(r'Product Serial\s*:\s*([a-zA-Z0-9-._ ]+\n)', output)
+    if system_serial_number == None:
+        return 'Error'
+    else:
+        return system_serial_number.group(1).strip()
+
+def get_board_serial_number(output):
+    board_serial_number = re.search(r'Board Serial\s*:\s*([a-zA-Z0-9-._ ]+\n)', output)
+    if board_serial_number == None:
+        return 'Error'
+    else:
+        return board_serial_number.group(1).strip()
+
+def get_fru_info(host_ip, user, password):
+    fru_cmd = 'ipmitool -H {} -U {} -P {} fru'.format(host_ip, user, password)
+    fru_return = check_output(shlex.split(fru_cmd), universal_newlines=True)
+    return fru_return
+
+def ipmi_fru(args):
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 30
+
+    try:
+        user_value = config.get('Account', 'USER')
+        passwd_value = config.get('Account', 'PASSWORD')
+        if not user_value or not passwd_value:
+            print("Invalid or Empty credential info")
+            return 40
+
+    except configparser.Error:
+        print("Invalid or Empty credential info")
+        return 50
+
+    inevntory_fru = {}
+    flag = 0
+    for tg in targets_list:
+            
+        if not tg or not user_value or not passwd_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 60
+        else:
+            print("SUT =", tg)
+            try:
+                fru_data = get_fru_info(tg, user_value, passwd_value)
+                time.sleep(5)
+            except CalledProcessError as ipmi_exception:
+                print("Failed executing ipmi, Reason: %s" % ipmi_exception)
+                return 70
+
+            inevntory_fru.update({'Product Manufacturer':get_system_manufacturer(fru_data)})
+            inevntory_fru.update({'Product Part Number':get_system_part_number(fru_data)})
+            inevntory_fru.update({'Product Serial':get_system_serial_number(fru_data)})
+            inevntory_fru.update({'Board Serial':get_board_serial_number(fru_data)})
+    
+            inevntory_fru_list = ['Product Manufacturer', 'Product Part Number', 'Product Serial', 'Board Serial']
+            for item in inevntory_fru_list:
+                print("{}: {}".format(item, inevntory_fru.get(item)))
+                if inevntory_fru.get(item) == 'Error' or inevntory_fru.get(item) == '':
+                    flag = 1
+    if flag == 1:
+        return 100
+    return 0
+
+def main():
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+                        default="/etc/checkbox.d/bmc.cfg",
+                        help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return ipmi_fru(args)
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'bin/ipmi_inventory'
--- bin/ipmi_inventory	1970-01-01 00:00:00 +0000
+++ bin/ipmi_inventory	2015-08-14 22:03:31 +0000
@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_inventory
+  1. Use ipmitool to collect inventory information including Asset Tag, Device ID, System GUID, Firmware Revision, IPMI Version, Management Controller ID.
+  2. Criteria: All information mentioned above must not should not be null.
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import shlex
+import time
+import subprocess
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+import re
+import configparser
+
+
+def get_mcinfo(host_ip, user, password):
+
+    try:
+        cmd = 'ipmitool -H {} -U {} -P {} mc info'.format(host_ip, user, password)
+        mcinfo_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing ipmi command for getting mc info. Reason:%s" % command_exception)
+
+    try:
+
+        deviceid = re.search(r'Device ID\s*:\s*([a-zA-Z0-9-._ ]+)', mcinfo_return)
+        if deviceid == None:
+            deviceid = 'Error'
+        else:
+            deviceid = deviceid.group(1).strip()
+
+        Firm = re.search(r'Firmware Revision\s+\s*:\s*([a-zA-Z0-9-._ ]+)', mcinfo_return)
+        if Firm == None:
+            Firm = 'Error'
+        else:
+            Firm = Firm.group(1).strip()
+
+        IPMI_Ver = re.search(r'IPMI Version\s+\s*:\s*([a-zA-Z0-9-._ ]+)', mcinfo_return)
+        if IPMI_Ver == None:
+            IPMI_Ver = 'Error'
+        else:
+            IPMI_Ver = IPMI_Ver.group(1).strip()
+
+        return deviceid, Firm, IPMI_Ver    
+
+    except:
+
+        return 'Error', 'Error', 'Error'
+
+def get_asset_tag(host_ip, user, password):
+
+    try:
+        cmd = 'ipmitool -H {} -U {} -P {} fru'.format(host_ip, user, password)
+        asset_tag_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing ipmi command for getting asset tag. Reason:%s" % command_exception)
+
+    try:
+        asset_tag = re.search(r'Product Asset Tag\s*:\s*([a-zA-Z0-9-._ ]+)', asset_tag_return)
+        if asset_tag == None:
+            return 'Error'
+        return asset_tag.group(1).strip()
+    except:
+        return 'Error'
+
+def get_guid(host_ip, user, password):
+
+    try:
+        cmd = 'ipmitool -H {} -U {} -P {} mc guid'.format(host_ip, user, password)
+        guid_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing ipmi command for getting guid. Reason:%s" % command_exception)
+
+    try:
+        mcguid = re.search(r'System GUID\s*:\s*([a-zA-Z0-9-._ ]+)', guid_return)
+        if mcguid == None:
+            return 'Error'
+        return mcguid.group(1).strip()
+    except:
+        return 'Error'
+
+def get_mcid(host_ip, user, password):
+
+    try:
+        cmd = 'ipmitool -H {} -U {} -P {} dcmi get_mc_id_string'.format(host_ip, user, password)
+        mcid_return = check_output(shlex.split(cmd), universal_newlines=True)
+        time.sleep(5)
+    except CalledProcessError as command_exception:
+        print("Failed executing ipmi command for getting mc id. Reason:%s" % command_exception)
+
+    try:
+        mcid =  re.search(r'Get Management Controller Identifier String\s*:\s*([a-zA-Z0-9-._ ]+)', mcid_return)
+        if mcid == None:
+            return 'Error'
+        return mcid.group(1).strip()
+    except:
+        return 'Error'
+
+def inventory(args):
+
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 30
+
+    try:
+        user_value = config.get('Account', 'USER')
+        passwd_value = config.get('Account', 'PASSWORD')
+        if not user_value or not passwd_value:
+            print("Invalid or Empty credential info")
+            return 40
+
+    except configparser.Error:
+        print("Invalid or Empty credential info")
+        return 50
+
+
+    flag = 0
+    for tg in targets_list:
+        
+        if not tg or not user_value or not passwd_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 60
+        else:
+            print("SUT =", tg)
+            inventory_dict = {}
+            inventory_list = ['Asset Tag', 'System GUID', 'Get Management Controller Identifier String', 'Device ID', 'Firmware Revision', 'IPMI Version']
+            Device_ID, Firmware, IPMI_version = get_mcinfo(tg, user_value, passwd_value)
+            inventory_dict.update({'Asset Tag':get_asset_tag(tg, user_value, passwd_value)})
+            inventory_dict.update({'System GUID':get_guid(tg, user_value, passwd_value)})
+            inventory_dict.update({'Get Management Controller Identifier String':get_mcid(tg, user_value, passwd_value)})
+            inventory_dict.update({'Device ID':Device_ID})
+            #inventory_dict.update({'Manufacturer Name':Manufacturer})
+            inventory_dict.update({'Firmware Revision':Firmware})
+            inventory_dict.update({'IPMI Version':IPMI_version})
+
+            for item in inventory_list:
+                if inventory_dict.get(item) == 'Error' or inventory_dict.get(item) == None:
+                    flag = 1
+                
+                print("{}: {}".format(item, inventory_dict.get(item)))
+
+    if flag == 1:
+        return 1
+    return 0
+
+def main():
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+                        default="/etc/checkbox.d/bmc.cfg",
+                        help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+
+    return inventory(args)
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'bin/ipmi_power_draw'
--- bin/ipmi_power_draw	1970-01-01 00:00:00 +0000
+++ bin/ipmi_power_draw	2015-08-14 22:03:31 +0000
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_power_draw  
+  1. GatherRetrieving power draw datainfo via ipmitool
+  2. The datainfo contains "Minimum during sampling period", "Maximum during sampling period", "Average power reading over sample period", "IPMI timestamp", "Sampling period", "Power reading state".
+  3. Criteria: The return value of each item cannot be null
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+import sys
+import shlex
+import re
+import time
+import configparser
+import subprocess
+from subprocess import (
+    CalledProcessError,
+    check_call,
+    check_output
+)
+
+def get_power_draw(host_ip, user, password):
+    cmd = 'ipmitool -H {} -U {} -P {} dcmi power reading'.format(host_ip, user, password)
+    output = check_output(shlex.split(cmd), universal_newlines=True)    
+    return output
+
+def power_draw_test(args):
+
+    #Default config file to config requirement info for DCMI in-band/out-of-band access
+    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    # Acquire ME IP/Credential parameters from config file
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 30
+
+    try:
+        user_value = config.get('Account', 'USER')
+        passwd_value = config.get('Account', 'PASSWORD')
+    except configparser.Error:
+        print("Invalid or Empty credential info")
+        return 40
+
+    flag = 0
+    for target in targets_list:
+
+        if not target or not user_value or not passwd_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            return 50
+        else:
+            print("SUT =", target)
+
+            try:
+                power_draw_return = get_power_draw(target, user_value, passwd_value)
+                time.sleep(5)
+            except CalledProcessError as command_exception:
+                print("Failed executing dcmi command", command_exception)
+                return 60
+
+            power_list = ['Minimum during sampling period', 'Maximum during sampling period',\
+                      'Average power reading over sample period',\
+                      'IPMI timestamp', 'Sampling period', 'Power reading state is']
+            for i in power_list:
+                value = re.search(i+':\s*([a-zA-Z0-9-: ]+)', power_draw_return)
+                if value == None:
+                    print("{}: Error".format(i))
+                    flag = 1
+                else:
+                    print("{}: {}".format(i, value.group(1)))
+    if flag == 1:
+        return 1
+    return 0
+
+def main():
+    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    parser = ArgumentParser(description=intro_message,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', default="/etc/checkbox.d/me.cfg",
+                        help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return power_draw_test(args)
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'bin/ipmi_power_off_on'
--- bin/ipmi_power_off_on	1970-01-01 00:00:00 +0000
+++ bin/ipmi_power_off_on	2015-08-14 22:03:31 +0000
@@ -0,0 +1,193 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_power_off_on
+
+Description
+  1. Use ipmitool out-of-band access to turn on/off the SUT.
+  2. Criteria: the SUT can be powered on/off by ipmitool out-of-band access.
+ 
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def check_power_status(host_ip, user, password):
+
+    cmd_status_on = 'ipmitool -H {} -U {} -P {} power status| grep -q "on"'\
+			.format(host_ip, user, password)
+    check_on_value = subprocess.call(cmd_status_on, shell=True)
+    time.sleep(5)
+
+    cmd_status_off = 'ipmitool -H {} -U {} -P {} power status| grep -q "off"'\
+			.format(host_ip, user, password)
+    check_off_value = subprocess.call(cmd_status_off, shell=True)
+    time.sleep(5)
+
+    if check_on_value == 0 and check_off_value == 1:
+        check_status = 'on'
+    
+    elif check_on_value == 1 and check_off_value == 0:
+        check_status = 'off'
+
+    else:
+        check_status = 'error'
+
+    return check_status
+
+def run_power_off(host_ip, user, password):
+    cmd_power_off = 'ipmitool -H {} -U {} -P {} power off'\
+        .format(host_ip, user, password)
+    power_off_return_code = subprocess.call(cmd_power_off, shell=True)
+    return power_off_return_code
+
+def run_power_on(host_ip, user, password):
+    cmd_power_on = 'ipmitool -H {} -U {} -P {} power on'\
+        .format(host_ip, user, password)
+    power_on_return_code = subprocess.call(cmd_power_on, shell=True)
+    return power_on_return_code
+
+def ipmi_reset_oob(args):
+
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 30
+
+    try:
+        user_value = config.get('Account', 'USER')
+        passwd_value = config.get('Account', 'PASSWORD')
+        if not user_value or not passwd_value:
+            print("Invalid or Empty credential info")
+            return 40
+
+    except configparser.Error:
+        print("Invalid or Empty credential info")
+        return 50
+
+    ping_flag = 0
+    for tg in targets_list:
+    
+        if not tg or not user_value or not passwd_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 21
+        else:
+
+            print("SUT =", tg)
+            print("USER =", user_value)
+            print("PASSWORD =", passwd_value)
+
+            for n in range(2):
+
+                count = 0
+                while count < 10:
+                    ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(tg)
+                    ping_rtn = subprocess.call(ping_cmd, shell=True)
+                    if ping_rtn == 0:
+                        print("Destination Host Reachable")
+                        
+                        #run test
+                        status = check_power_status(tg, user_value, passwd_value)
+
+                        if status == 'on':
+                            #run power off
+                            power_off_result = run_power_off(tg, user_value, passwd_value)
+                            print(" ")
+                            if power_off_result == 1:
+                                print("Failed to power off SUT.")
+                                return 88
+                        elif status == 'off':
+                            #run power on
+                            power_on_result = run_power_on(tg, user_value, passwd_value)
+                            print(" ")
+                            if power_on_result == 1:
+                                print("Failed to power on SUT.")
+                                return 99
+                        else:
+                            #do nothing
+                            print("Failed to check power status")
+                            return 77
+                        
+                        time.sleep(180)
+                        break
+
+                    else:
+                        time.sleep(10)
+                        count = count+1
+                        print("Destination Host Unreachable")
+
+                if count == 10:         
+                    print("Host Has No Response, End of Test")
+                    ping_flag = 100
+
+    if ping_flag == 100:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message,
+		 formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/bmc.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return ipmi_reset_oob(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/ipmi_power_policy'
--- bin/ipmi_power_policy	1970-01-01 00:00:00 +0000
+++ bin/ipmi_power_policy	2015-08-14 22:03:31 +0000
@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_power_policy
+
+Description
+ 1. Use ipmitool to set power on policy through OOB.
+ 2. Criteria: the change of power policy should take effect without BMC firmware cold reset or system reboot.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import shlex
+import time
+import subprocess
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+import re
+import configparser
+import os
+
+def set_power_policy(host_ip, user, password, rule):
+    os.system('ipmitool -H {} -U {} -P {} chassis policy {}'.format(host_ip, user, password, rule))
+
+def get_chassis_status(host_ip, user, password):
+    cmd = 'ipmitool -H {} -U {} -P {} chassis status'.format(host_ip, user, password)
+    output = check_output(shlex.split(cmd), universal_newlines=True)
+    return output
+
+def get_power_policy(host_ip, user, password):
+    result = get_chassis_status(host_ip, user, password)
+    policy = re.search(r'Power Restore Policy\s*:\s*([a-zA-Z0-9-._ ]+\n)', result)
+    if policy  == None:
+        return 'Error'
+    else:
+        return policy.group(1).strip()
+
+def check_policy(host_ip, user, password, rule):
+    current_policy = get_power_policy(host_ip, user, password)
+    if current_policy == rule:
+        print("Successfully setting power policy")
+        return 0
+    else:
+        return 1
+
+def power_policy_test(args):
+
+    #IPMI config file
+    policy_rule = args.rule
+    if not policy_rule:
+        print("No specified policy to set")
+        return 88
+
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 30
+
+    try:
+        user_value = config.get('Account', 'USER')
+        passwd_value = config.get('Account', 'PASSWORD')
+        if not user_value or not passwd_value:
+            print("Invalid or Empty credential info")
+            return 40
+
+    except configparser.Error:
+        print("Invalid or Empty credential info")
+        return 50
+
+    flag = 0
+    for tg in targets_list:
+            
+        if not tg or not user_value or not passwd_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 60
+        else:
+            print("SUT =", tg)
+
+            try:
+                set_power_policy(tg, user_value, passwd_value, policy_rule)
+            except:
+                print("Fail to set power policy")
+                return 70
+
+            time.sleep(5)          
+
+            try:
+                chassis_status = get_chassis_status(tg, user_value, passwd_value)
+            except:
+                print("Fail to get chassis status")
+                return 80
+
+            current_policy = get_power_policy(tg, user_value, passwd_value)
+
+            value = check_policy(tg, user_value, passwd_value, policy_rule)
+
+            if value == 1:
+                flag = 1
+
+    if flag == 1:
+        return 1
+    return 0
+
+def main():
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+                        default="/etc/checkbox.d/bmc.cfg",
+                        help="Supply config file for getting authentication info")
+    parser.add_argument('--rule', help="always-on, always-off or previous")
+    args = parser.parse_args()
+    return power_policy_test(args)
+
+if __name__ == '__main__':
+    sys.exit(main())

=== added file 'bin/ipmi_power_reset'
--- bin/ipmi_power_reset	1970-01-01 00:00:00 +0000
+++ bin/ipmi_power_reset	2015-08-14 22:03:31 +0000
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_power_reset
+
+Description
+  1. Use ipmitool out-of-band access to power hard reset the SUT 20 times.
+  2. Criteria: complete 20 power hard reset on SUT successfully using ipmitool out-of-band access.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def run(host_ip, user, password):
+    cmd = 'ipmitool -H {} -U {} -P {} power reset'.format(host_ip, user, password)
+    power_reset_return = check_output(shlex.split(cmd), universal_newlines=True)
+    return power_reset_return
+        
+def ipmi_reset_oob(args):
+
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 1
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 2
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 2
+
+    try:
+        user_value = config.get("Account", "USER")
+        password_value = config.get("Account", "PASSWORD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        return 3
+
+    ping_flag = 0
+    for tg in targets_list:    
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 4
+        else:
+            print("SUT =", tg)
+            print("USER =", user_value)
+            print("PASSWORD =", password_value)
+
+            for n in range(20):
+                print("---------------- %s ----------------" % n)
+                count = 0
+                while count < 10:
+                    print("+++++++++++ %s ++++++++++++" % count)
+                    ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(tg)
+                    ping_rtn = subprocess.call(ping_cmd, shell=True)
+
+                    if ping_rtn == 0:
+                        print("Destination Host Reachable")
+
+                        try:
+                            power_control = run(tg, user_value, password_value)
+                            print(power_control)
+                        except CalledProcessError as ipmi_exception:
+                            print("Failed executing ipmi, Reason: %s" % ipmi_exception)
+                            return 6
+
+                        time.sleep(180)
+                        break
+                    else:
+                        time.sleep(10)
+                        count = count+1
+                        print("Destination Host Unreachable")
+                
+                if count == 10:
+                    print("Host Has No Response, End of Test")
+                    ping_flag = 100
+
+    if ping_flag == 100:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message,
+                            formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config',
+                        default="/etc/checkbox.d/bmc.cfg",
+                        help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return ipmi_reset_oob(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/ipmi_priv_admin'
--- bin/ipmi_priv_admin	1970-01-01 00:00:00 +0000
+++ bin/ipmi_priv_admin	2015-08-14 22:03:31 +0000
@@ -0,0 +1,176 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_priv_admin  
+
+Description
+  1. Use ipmitool out-of-band to read power status, to perform power reset and add a new user account.
+  2. Criteria: reading power status, performing power reset and adding a user account must all be successful.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_power_status(host_ip, user, password):
+    cmd_status = 'ipmitool -H {} -U {} -P {} power status 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    status_code = subprocess.call(cmd_status, shell=True)
+    return status_code
+    
+def power_reset(host_ip, user, password):
+    cmd_reset = 'ipmitool -H {} -U {} -P {} power reset 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    reset_code = subprocess.call(cmd_reset, shell=True)
+    return reset_code
+
+def add_user(host_ip, user, password, new_id, new_user):
+    cmd_add_user = 'ipmitool -H {} -U {} -P {} user set name {} {} 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password, new_id, new_user)
+    add_user_code = subprocess.call(cmd_add_user, shell=True)
+    return add_user_code
+
+def ipmi_user_level_test(args):
+
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 20
+
+    try:
+        user_value = config.get("Admin Level", "ADMIN_NAME")
+        password_value = config.get("Admin Level", "ADMIN_PASSWD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        print("Require Operator Level info pre-configured in /etc/checkbox.d/bmc.cfg")
+        return 30
+
+    try:
+        new_user_value = config.get("Add User Test", "NEW_USER_NAME")
+        new_user_id_value = config.get("Add User Test", "NEW_USER_ID")
+    except configparser.NoOptionError:
+        print("Invalid or Empty new user info")
+        print("Require new User info pre-configured in /etc/checkbox.d/bmc.cfg")
+        return 40
+
+    flag = 0
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 50
+        else:
+            print("SUT", tg)
+
+            ping_result = ping_test(tg)
+            if ping_result != 0:
+                return 88
+
+            status_result = get_power_status(tg, user_value, password_value)
+            time.sleep(5)
+
+            reset_result = power_reset(tg, user_value, password_value)
+            time.sleep(180)
+            if not new_user_value or not new_user_id_value:
+                print("Require new user info pre-configured in /etc/checkbox.d/bmc.cfg")
+                return 60
+            else:
+
+                ping_result = ping_test(tg)
+                if ping_result != 0:
+                    return 88
+
+                add_user_result = add_user(tg, user_value, password_value, new_user_id_value, new_user_value)
+                time.sleep(5)
+
+            if status_result == 0 and reset_result == 0 and add_user_result == 0:
+                print("User can read power status.")
+                print("User can reset power.")
+                print("User can add a new user.")
+            else:
+                print("Authentication: Not Administrator Level")
+                flag = 1
+
+    if flag == 1:
+        return 100
+    return 0
+
+def ping_test(host_ip):
+    count = 0
+    while count < 10:
+        ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(host_ip)
+        ping_rtn = subprocess.call(ping_cmd, shell=True)
+        if ping_rtn == 0:
+            return 0
+        else:
+            print("Destination Host Unreachable")
+            time.sleep(10)
+            count = count+1
+
+    if count == 10:
+        print("Host Has No Response, End of Test")
+        return 1
+
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/bmc.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return ipmi_user_level_test(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/ipmi_priv_oper'
--- bin/ipmi_priv_oper	1970-01-01 00:00:00 +0000
+++ bin/ipmi_priv_oper	2015-08-14 22:03:31 +0000
@@ -0,0 +1,174 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_priv_oper
+  1. Use ipmitool out-of-band to read power status, to perform power reset and add a new user account.
+  2. Criteria: power status reading and power reset must be successful and must fail at adding a new user account.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_power_status(host_ip, user, password):
+    cmd_status = 'ipmitool -H {} -U {} -P {} power status -L operator 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    status_code = subprocess.call(cmd_status, shell=True)
+    return status_code
+    
+def power_reset(host_ip, user, password):
+    cmd_reset = 'ipmitool -H {} -U {} -P {} power reset -L operator 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    reset_code = subprocess.call(cmd_reset, shell=True)
+    return reset_code
+
+def add_user(host_ip, user, password, new_id, new_user):
+    cmd_add_user = 'ipmitool -H {} -U {} -P {} user set name {} {} -L operator 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password, new_id, new_user)
+    add_user_code = subprocess.call(cmd_add_user, shell=True)
+    return add_user_code
+
+def ipmi_user_level_test(args):
+
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 20
+
+    try:
+        user_value = config.get("Operator Level", "OPER_NAME")
+        password_value = config.get("Operator Level", "OPER_PASSWD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        print("Require Operator Level info pre-configured in /etc/checkbox.d/bmc.cfg")
+        return 30
+
+    try:
+        new_user_value = config.get("Add User Test", "NEW_USER_NAME")
+        new_user_id_value = config.get("Add User Test", "NEW_USER_ID")
+    except configparser.NoOptionError:
+        print("Invalid or Empty new user info")
+        print("Require new User info pre-configured in /etc/checkbox.d/bmc.cfg")
+        return 40
+
+    flag = 0
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 50
+        else:
+            print("SUT", tg)
+
+            ping_result = ping_test(tg)
+            if ping_result != 0:
+                return 88
+
+            status_result = get_power_status(tg, user_value, password_value)
+            time.sleep(5)
+
+            reset_result = power_reset(tg, user_value, password_value)
+            time.sleep(180)
+            if not new_user_value or not new_user_id_value:
+                print("Require new user info pre-configured in /etc/checkbox.d/bmc.cfg")
+                return 60
+            else:
+
+                ping_result = ping_test(tg)
+                if ping_result != 0:
+                    return 88
+
+                add_user_result = add_user(tg, user_value, password_value, new_user_id_value, new_user_value)
+                time.sleep(5)
+
+            if status_result == 0 and reset_result == 0 and add_user_result == 1:
+                print("User can read power status.")
+                print("User can reset power.")
+                print("User can't add a new user.")
+            else:
+                print("Authentication: Not Operator Level")
+                flag = 1
+
+    if flag == 1:
+        return 100
+    return 0
+
+def ping_test(host_ip):
+    count = 0
+    while count < 10:
+        ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(host_ip)
+        ping_rtn = subprocess.call(ping_cmd, shell=True)
+        if ping_rtn == 0:
+            return 0
+        else:
+            print("Destination Host Unreachable")
+            time.sleep(10)
+            count = count+1
+
+    if count == 10:
+        print("Host Has No Response, End of Test")
+        return 1
+
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/bmc.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return ipmi_user_level_test(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/ipmi_priv_user'
--- bin/ipmi_priv_user	1970-01-01 00:00:00 +0000
+++ bin/ipmi_priv_user	2015-08-14 22:03:31 +0000
@@ -0,0 +1,176 @@
+#! /usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_priv_uesr  
+
+Description
+  1. Use ipmitool out-of-band to read power status, to perform power reset and add a new user account.
+  2. Criteria: power status reading must be successful and must fail at power reset and adding a new user account.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+
+import sys
+import configparser
+import shlex
+import subprocess
+import ast
+import time
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_power_status(host_ip, user, password):
+    cmd_status = 'ipmitool -H {} -U {} -P {} power status -L user 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    status_code = subprocess.call(cmd_status, shell=True)
+    return status_code
+    
+def power_reset(host_ip, user, password):
+    cmd_reset = 'ipmitool -H {} -U {} -P {} power reset -L user 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password)
+    reset_code = subprocess.call(cmd_reset, shell=True)
+    return reset_code
+
+def add_user(host_ip, user, password, new_id, new_user):
+    cmd_add_user = 'ipmitool -H {} -U {} -P {} user set name {} {} -L user 1>/dev/null 2>/dev/null'\
+        .format(host_ip, user, password, new_id, new_user)
+    add_user_code = subprocess.call(cmd_add_user, shell=True)
+    return add_user_code
+
+def ipmi_user_level_test(args):
+
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 20
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 20
+
+    try:
+        user_value = config.get("User Level", "USER_NAME")
+        password_value = config.get("User Level", "USER_PASSWD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        print("Require User Level info pre-configured in /etc/checkbox.d/bmc.cfg")
+        return 30
+
+    try:
+        new_user_value = config.get("Add User Test", "NEW_USER_NAME")
+        new_user_id_value = config.get("Add User Test", "NEW_USER_ID")
+    except configparser.NoOptionError:
+        print("Invalid or Empty new user info")
+        print("Require new User info pre-configured in /etc/checkbox.d/bmc.cfg")
+        return 40
+
+    flag = 0
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 50
+        else:
+            print("SUT", tg)
+
+            ping_result = ping_test(tg)
+            if ping_result != 0:
+                return 88
+
+            status_result = get_power_status(tg, user_value, password_value)
+            time.sleep(5)
+
+            reset_result = power_reset(tg, user_value, password_value)
+            time.sleep(180)
+            if not new_user_value or not new_user_id_value:
+                print("Require new user info pre-configured in /etc/checkbox.d/bmc.cfg")
+                return 60
+            else:
+
+                ping_result = ping_test(tg)
+                if ping_result != 0:
+                    return 88
+
+                add_user_result = add_user(tg, user_value, password_value, new_user_id_value, new_user_value)
+                time.sleep(5)
+
+            if status_result == 0 and reset_result == 1 and add_user_result == 1:
+                print("User can read power status.")
+                print("User can't reset power.")
+                print("User can't add a new user.")
+            else:
+                print("Authentication: Not User Level")
+                flag = 1
+
+    if flag == 1:
+        return 100
+    return 0
+
+def ping_test(host_ip):
+    count = 0
+    while count < 10:
+        ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(host_ip)
+        ping_rtn = subprocess.call(ping_cmd, shell=True)
+        if ping_rtn == 0:
+            return 0
+        else:
+            print("Destination Host Unreachable")
+            time.sleep(10)
+            count = count+1
+
+    if count == 10:
+        print("Host Has No Response, End of Test")
+        return 1
+
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str,
+		 default="/etc/checkbox.d/bmc.cfg",
+		 help="Supply config file for getting authentication info")
+    args = parser.parse_args()
+    return ipmi_user_level_test(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== added file 'bin/ipmi_sampling'
--- bin/ipmi_sampling	1970-01-01 00:00:00 +0000
+++ bin/ipmi_sampling	2015-08-14 22:03:31 +0000
@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_sampling
+
+Description
+  1. Retrieve CPU and intake temperature 30 times at 3 second intervals using ipmitool
+  2. If failed to retrieve temperature at any time within 30 times, the test is considered failed
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+import sys
+import time
+import re
+import configparser
+import shlex
+import subprocess
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_sdr_remote(host_ip, user, password):
+    cmd = "ipmitool -H {} -U {} -P {} sdr".format(host_ip, user, password)
+    sdr_return = subprocess.check_output(shlex.split(cmd), stderr=subprocess.STDOUT,
+                                         universal_newlines=True)
+    return sdr_return
+
+def parse_sdr(output):
+    output = output.strip()
+    output_1Line = output.split("\n")
+    data = {}
+
+    for line in output_1Line:
+        sub_value = {}
+        string_list = line.split("|")
+        name = string_list[0].strip()
+        sensor_output = string_list[1].strip()
+        sub_value.update({'output':sensor_output})
+        status = string_list[2].strip()
+        sub_value.update({'status':status})
+        data.update({name:sub_value})
+    return data
+
+def calculate_CPU_temp(data_dict, CPU_Therm_Margin_id, CPU_Tjmax_id):
+    if data_dict.get(CPU_Therm_Margin_id) and data_dict.get(CPU_Tjmax_id):
+        if data_dict.get(CPU_Therm_Margin_id).get('status') == 'ok' and data_dict.get(CPU_Tjmax_id).get('status') == 'ok':
+            P_Therm_Margin_output = data_dict.get(CPU_Therm_Margin_id).get('output')
+            CPU_Tjmax_output = data_dict.get(CPU_Tjmax_id).get('output')
+            P_Therm_Margin = re.search(r'[0-9-]+', P_Therm_Margin_output).group(0)
+            CPU_Tjmax = re.search(r'[0-9-]+', CPU_Tjmax_output).group(0)
+            CPU_temp = int(P_Therm_Margin)+int(CPU_Tjmax)
+            return str(CPU_temp)+' degrees C'
+        else:
+            return 'Error'
+    else:
+        return 'None'
+        
+def ipmi_sdr(args):
+
+    cmd_flag = 0
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        sensor_nick = config.options("SensorsForSampling")
+    except configparser.NoSectionError:
+        print("No Section: SensorsForSampling")
+        return 20
+
+    if sensor_nick:
+        sensor_list = []
+        for id in sensor_nick:
+            sensor_key = config.get("SensorsForSampling", id)
+            if sensor_key:
+                sensor_list.append(sensor_key)
+            else:
+                print("No Sensor ID specified in Config file")
+                return 30
+    else:
+        print("No key of Sensor ID specified in config file")
+        return 40
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 60
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 60
+
+    try:
+        user_value = config.get("Account", "USER")
+        password_value = config.get("Account", "PASSWORD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        return 70
+
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 80
+        else:
+
+            c = 0
+            while c < 10:
+                ping_cmd = 'ping -c 1 {}>/dev/null 2>/dev/null'.format(tg)
+                ping_rtn = subprocess.call(ping_cmd, shell=True)
+                if ping_rtn == 0:
+                    print("Destination Host Reachable")
+                    break
+                else:
+                    time.sleep(10)
+                    c = c+1
+                    print("Destination Host Unreachable")
+
+            if c == 10:
+                print("Host Has No Response, End of Test")
+                return 99
+
+
+            sampling_data = []
+            times = 30
+            for n in range(times):
+
+                try:
+                    sensor_data = get_sdr_remote(tg, user_value, password_value)
+                    time.sleep(3)
+                except CalledProcessError as ipmi_exception:
+                    print("Failed executing ipmi, Reason: %s" % ipmi_exception)
+                    sensor_data = ''
+
+                sampling_data.append(sensor_data)
+            
+            count = 0
+            prs_flag = 0
+            dis_flag = 0
+            for output in sampling_data:
+                try:
+                    data = parse_sdr(output)
+                except:
+                    print("Parsing output of sdr table error")
+                    print("=======================================================")
+                    prs_flag = 1
+                    count = count+1
+                    continue
+
+                disable = 0
+                need_data = {}
+
+                for need_id in sensor_list:
+
+                    if data.get(need_id):
+                        need_value = data.get(need_id).get('output')
+                        need_data.update({need_id:need_value})
+                        if data.get(need_id).get('status') != 'ok':
+                            disable = 1
+                    else:
+
+                        try:
+                            CPUx_Temp = config.get("Sensors", "CPUx")
+                        except configparser.NoOptionError:
+                            CPUx_Temp = ''
+
+                        try:
+                            CPUy_Temp = config.get("Sensors", "CPUy")
+                        except configparser.NoOptionError:
+                            CPUy_Temp = ''
+                    
+                        if need_id == CPUx_Temp:
+                        
+                            try:
+                                PxTM = config.get("SensorsForCPUTemp", "Px Therm Margin")
+                            except configparser.NoOptionError:
+                                PxTM = ''
+
+                            try:
+                                CPUx_Tjmax = config.get("SensorsForCPUTemp", "CPUx Tjmax")
+                            except configparser.NoOptionError:
+                                CPUx_Tjmax = ''
+
+                            if PxTM and CPUx_Tjmax:
+                                Px_temp = calculate_CPU_temp(data, PxTM, CPUx_Tjmax) 
+                                need_data.update({CPUx_Temp:Px_temp})
+                                if Px_temp == 'None' or Px_temp == 'Error':
+                                    disable = 1
+                            else:
+                                disable = 1
+                                
+                        elif need_id == CPUy_Temp:
+
+                            try:
+                                PyTM = config.get("SensorsForCPUTemp", "Py Therm Margin")
+                            except configparser.NoOptionError:
+                                PyTM = ''
+
+                            try:
+                                CPUy_Tjmax = config.get("SensorsForCPUTemp", "CPUy Tjmax")
+                            except configparser.NoOptionError:
+                                CPUy_Tjmax = ''
+
+                            if PyTM and CPUy_Tjmax:
+                                Py_temp = calculate_CPU_temp(data, PyTM, CPUy_Tjmax)
+                                need_data.update({CPUy_Temp:Py_temp})
+                                if Py_temp == 'None' or Py_temp == 'Error':
+                                    disable = 1
+                            else:
+                                disable = 1
+                                
+                        else:
+                            need_data.update({need_id:'None'})
+                            disable = 1
+            
+                if disable == 1:
+                    dis_flag = 1
+                    print(need_data)
+                    print("=======================================================")
+                    count = count+1
+        print("Pass: %d" %(times-count))
+        print("Fail: %d" %(count))
+        
+    if cmd_flag == 1 or prs_flag == 1 or dis_flag == 1:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str, default="/etc/checkbox.d/bmc.cfg", help="Supply config file for sensor IDs parameters")
+    args = parser.parse_args()
+    return ipmi_sdr(args)
+
+if __name__ == "__main__":
+    sys.exit(main())

=== modified file 'bin/ipmi_sel_entries'
--- bin/ipmi_sel_entries	2015-03-03 15:59:42 +0000
+++ bin/ipmi_sel_entries	2015-08-14 22:03:31 +0000
@@ -5,13 +5,11 @@
 
 File Name
   ipmi_sel_entries
+
+Description
   1. Use ipmitool to collect event log information
   2. Calculate entries number of system event log
-  3. Criteria: the A log must be capable of saving at least 256 entries
-
-Description
-  Use ipmitool to get system event log info and calculate whether 
-  total number of entries is more than 256.
+  3. Criteria: the log must be capable of saving at least 256 entries
 
 Authors
   Sophia Wu <[e-mail]>
@@ -63,8 +61,8 @@
 
 def sel_entry_test(args):
 
-    #Default config file to config requirement info for DCMI in-band/out-of-band access 
-    DEFAULT_CFG = "/etc/checkbox.d/me.cfg"
+    #Default config file to config requirement info for IPMI in-band/out-of-band access 
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
     if not "config" in vars(args):
         config_file = DEFAULT_CFG
     else:
@@ -101,7 +99,7 @@
     for target in targets_list:
 
         if not target or not user_value or not passwd_value:
-            print("Require Taget IP, Account(USER/PASSWORD) for DCMI out-of-band access")
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
             return 50
         else:
             print("SUT =", target)
@@ -135,11 +133,11 @@
 
 def main():
 
-    intro_message = "Default config location is /etc/checkbox.d/me.cfg"
+    intro_message = "Default config location is /etc/xdg/bmc.cfg"
     parser = ArgumentParser(description=intro_message,
                             formatter_class=RawTextHelpFormatter)
-    parser.add_argument('--config', default="/etc/checkbox.d/me.cfg",
-                        help="Supply config file for getting default credential")
+    parser.add_argument('--config', default="/etc/checkbox.d/bmc.cfg",
+                        help="Supply config file for getting authentication info")
     args = parser.parse_args()
     return sel_entry_test(args)
 

=== added file 'bin/ipmi_sensors_ib'
--- bin/ipmi_sensors_ib	1970-01-01 00:00:00 +0000
+++ bin/ipmi_sensors_ib	2015-08-14 22:03:31 +0000
@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_sensors_ib
+
+Description
+  1. Use ipmitool/dcmitool to monitor analog sensors in SDR table through in-band access.
+  2. Criteria: the status of analog sensors should be "ok" and the data should not be null.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+import sys
+import time
+import re
+import configparser
+import shlex
+import subprocess
+import ast
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+
+def get_sdr(TOOL):
+    cmd = "{} sdr".format(TOOL)
+    sdr_return = subprocess.check_output(shlex.split(cmd), universal_newlines=True)
+    return sdr_return
+
+def parse_sdr(output):
+    output = output.strip()
+    output_1Line = output.split("\n")
+    data = {}
+
+    for line in output_1Line:
+        sub_value = {}
+        string_list = line.split("|")
+        name = string_list[0].strip()
+        sensor_output = string_list[1].strip()
+        sub_value.update({'output':sensor_output})
+        status = string_list[2].strip()
+        sub_value.update({'status':status})
+        data.update({name:sub_value})
+    return data
+
+def calculate_CPU_temp(data_dict, CPU_Therm_Margin_id, CPU_Tjmax_id):
+
+    if data_dict.get(CPU_Therm_Margin_id) and data_dict.get(CPU_Tjmax_id):
+        if data_dict.get(CPU_Therm_Margin_id).get('status') == 'ok' and data_dict.get(CPU_Tjmax_id).get('status') == 'ok':
+            P_Therm_Margin_output = data_dict.get(CPU_Therm_Margin_id).get('output')
+            CPU_Tjmax_output = data_dict.get(CPU_Tjmax_id).get('output')
+            P_Therm_Margin = re.search(r'[0-9-]+', P_Therm_Margin_output).group(0)
+            CPU_Tjmax = re.search(r'[0-9-]+', CPU_Tjmax_output).group(0)
+            CPU_temp = int(P_Therm_Margin)+int(CPU_Tjmax)
+            return str(CPU_temp)+' degrees C'
+        else:
+            return 'Error'
+    else:
+        return 'None'
+
+def ipmi_sdr(args):
+
+    flag = 0
+
+    tool_name = args.tool
+    if not tool_name:
+        print("No specified tool to use")
+        return 99
+        
+    #IPMI/DCMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        sensor_nick = config.options("Sensors")			
+    except configparser.NoSectionError:
+        print("No Section: Sensors")
+        return 20
+
+    if sensor_nick:
+        sensor_list = []
+        for id in sensor_nick:
+            sensor_key = config.get("Sensors", id)
+            if sensor_key:
+                sensor_list.append(sensor_key)
+            else:
+                print("No Sensor ID specified in Config file")
+                return 30
+    else:
+        print("No key of Sensor ID specified in config file")
+        return 40
+
+    try:
+        sensor_data = get_sdr(tool_name)
+        time.sleep(5)
+    except CalledProcessError as ipmi_exception:
+        print("Failed executing ipmi, Reason: %s" % ipmi_exception)
+        return 50
+
+    try:
+        data = parse_sdr(sensor_data)
+    except:
+        print("Parsing output of sdr table error")
+        return 60
+
+    need_data = {}
+    for need_id in sensor_list:
+        if data.get(need_id):
+            need_value = data.get(need_id).get('output')
+            need_data.update({need_id:need_value})
+            
+            if data.get(need_id).get('status') != 'ok':
+                flag = 1
+        else:
+
+           try:
+               CPUx_Temp = config.get("Sensors", "CPUx")
+           except configparser.NoOptionError:
+               CPUx_Temp = ''
+
+           try:
+               CPUy_Temp = config.get("Sensors", "CPUy")
+           except configparser.NoOptionError:
+               CPUy_Temp = ''
+
+           if need_id == CPUx_Temp:
+
+                try:
+                    PxTM = config.get("SensorsForCPUTemp", "Px Therm Margin")
+                except configparser.NoOptionError:
+                    PxTM = ''
+                    
+                try:
+                    CPUx_Tjmax = config.get("SensorsForCPUTemp", "CPUx Tjmax")
+                except configparser.NoOptionError:
+                    CPUx_Tjmax = ''
+
+                if PxTM and CPUx_Tjmax:
+                    need_data.update({CPUx_Temp:calculate_CPU_temp(data, PxTM, CPUx_Tjmax)})
+                    if calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'None' or calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'Error':
+                        flag = 1
+                else:
+                    flag = 1
+
+           elif need_id == CPUy_Temp:
+                
+                try:
+                    PyTM = config.get("SensorsForCPUTemp", "Py Therm Margin")
+                except configparser.NoOptionError:
+                    PyTM = ''
+
+                try:
+                    CPUy_Tjmax = config.get("SensorsForCPUTemp", "CPUy Tjmax")
+                except configparser.NoOptionError:
+                    CPUy_Tjmax = ''
+
+
+                if PyTM and CPUy_Tjmax:
+                    need_data.update({CPUy_Temp:calculate_CPU_temp(data, PyTM, CPUy_Tjmax)})
+                    if calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'None' or calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'Error':
+                        flag = 1
+                else:
+                    flag = 1
+           else:
+                flag = 1
+            
+        print("%s: %s" %(need_id, need_data.get(need_id)))
+
+    if flag == 1:
+        return 100
+    return 0
+
+def main():
+
+    intro_message = "Default config location is /etc/checkbox.d/bmc.cfg"
+    parser = ArgumentParser(description=intro_message, formatter_class=RawTextHelpFormatter)
+    parser.add_argument('--config', type=str, default="/etc/checkbox.d/bmc.cfg", help="Supply config file for sensor IDs parameters")
+    parser.add_argument('--tool', help="ipmitool or dcmitool")
+    args = parser.parse_args()
+    return ipmi_sdr(args)
+
+if __name__ == "__main__":
+    sys.exit(main())
+

=== added file 'bin/ipmi_sensors_oob'
--- bin/ipmi_sensors_oob	1970-01-01 00:00:00 +0000
+++ bin/ipmi_sensors_oob	2015-08-14 22:03:31 +0000
@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+Copyright (C) 2010-2013 by Cloud Computing Center for Mobile Applications
+Industrial Technology Research Institute
+
+File Name
+  ipmi_sensors_oob
+
+Description
+  1. Use ipmitool to monitor analog sensors in SDR table through OOB access.
+  2. Criteria: the status of analog sensors should be "ok" and the data should not be null.
+
+Authors
+  Sophia Wu <[e-mail]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3,
+as published by the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+import sys
+import time
+import re
+import configparser
+import shlex
+import subprocess
+import ast
+from argparse import (
+    ArgumentParser,
+    RawTextHelpFormatter
+)
+from subprocess import (
+    check_output,
+    CalledProcessError
+)
+
+def get_sdr_remote(host_ip, user, password):
+    cmd = "ipmitool -H {} -U {} -P {} sdr".format(host_ip, user, password)
+    sdr_return = subprocess.check_output(shlex.split(cmd), stderr=subprocess.STDOUT,
+                                         universal_newlines=True)
+    return sdr_return
+
+def parse_sdr(output):
+    output = output.strip()
+    output_1Line = output.split("\n")
+    data = {}
+
+    for line in output_1Line:
+        sub_value = {}
+        string_list = line.split("|")
+        name = string_list[0].strip()
+        sensor_output = string_list[1].strip()
+        sub_value.update({'output':sensor_output})
+        status = string_list[2].strip()
+        sub_value.update({'status':status})
+        data.update({name:sub_value})
+    return data
+
+def calculate_CPU_temp(data_dict, CPU_Therm_Margin_id, CPU_Tjmax_id):
+
+    if data_dict.get(CPU_Therm_Margin_id) and data_dict.get(CPU_Tjmax_id):
+        if data_dict.get(CPU_Therm_Margin_id).get('status') == 'ok' and data_dict.get(CPU_Tjmax_id).get('status') == 'ok':
+            P_Therm_Margin_output = data_dict.get(CPU_Therm_Margin_id).get('output')
+            CPU_Tjmax_output = data_dict.get(CPU_Tjmax_id).get('output')
+            P_Therm_Margin = re.search(r'[0-9-]+', P_Therm_Margin_output).group(0)
+            CPU_Tjmax = re.search(r'[0-9-]+', CPU_Tjmax_output).group(0)
+            CPU_temp = int(P_Therm_Margin)+int(CPU_Tjmax)
+            return str(CPU_temp)+' degrees C'
+        else:
+            return 'Error'
+    else:
+        return 'None'
+
+def ipmi_sdr(args):
+
+    flag = 0
+    #IPMI config file
+    DEFAULT_CFG = "/etc/checkbox.d/bmc.cfg"
+    if not "config" in vars(args):
+        config_file = DEFAULT_CFG
+    else:
+        config_file = args.config
+
+    config = configparser.RawConfigParser()
+
+    try:
+        config.readfp(open(config_file))
+    except IOError:
+        print("No config file found")
+        return 10
+
+    try:
+        sensor_nick = config.options("Sensors")
+    except configparser.NoSectionError:
+        print("No Section: Sensors")
+        return 20
+    
+    if sensor_nick:
+        sensor_list = []
+        for id in sensor_nick:
+            sensor_key = config.get("Sensors", id)
+            if sensor_key:
+                sensor_list.append(sensor_key)
+            else:
+                print("No Sensor ID specified in Config file")
+                return 30
+    else:
+        print("No key of Sensor ID specified in config file")
+        return 40
+
+    try:
+        targets_options = config.options('Targets')
+        targets_list = []
+        for target_key in targets_options:
+            targets_list.append(config.get('Targets', target_key))
+        if not targets_list:
+            print("Invalid or Empty targets")
+            return 60
+    except configparser.Error:
+        print("Invalid or Empty targets")
+        return 60
+
+    try:
+        user_value = config.get("Account", "USER")
+        password_value = config.get("Account", "PASSWORD")
+    except configparser.NoOptionError:
+        print("Invalid or Empty credential info")
+        return 70
+
+    for tg in targets_list:
+
+        if not tg or not user_value or not password_value:
+            print("Require Taget IP, Account(USER/PASSWORD) for IPMI out-of-band access")
+            return 80
+        else:
+
+            print("SUT =", tg)
+            print("USER =", user_value)
+            print("PASSWORD =", password_value)
+
+            try:
+                sensor_data = get_sdr_remote(tg, user_value, password_value)
+                time.sleep(5)
+            except CalledProcessError as ipmi_exception:
+                print("Failed executing ipmi, Reason: %s" % ipmi_exception)
+                return 50
+
+            try:
+                data = parse_sdr(sensor_data)
+            except:
+                print("Parsing output of sdr table error")
+                flag = 1
+                continue
+
+            need_data = {}
+            for need_id in sensor_list:
+
+                if data.get(need_id):
+                    need_value = data.get(need_id).get('output')
+                    need_data.update({need_id:need_value})
+
+                    if data.get(need_id).get('status') != 'ok':
+                        flag = 1
+                else:
+
+                    try:
+                        CPUx_Temp = config.get("Sensors", "CPUx")
+                    except configparser.NoOptionError:
+                        CPUx_Temp = ''
+
+                    try:
+                        CPUy_Temp = config.get("Sensors", "CPUy")
+                    except configparser.NoOptionError:
+                        CPUy_Temp = ''
+
+                    if need_id == CPUx_Temp:
+
+                        try:
+                            PxTM = config.get("SensorsForCPUTemp", "Px Therm Margin")
+                        except configparser.NoOptionError:
+                            PxTM = ''
+
+                        try:
+                            CPUx_Tjmax = config.get("SensorsForCPUTemp", "CPUx Tjmax")
+                        except configparser.NoOptionError:
+                            CPUx_Tjmax = ''
+
+                        if PxTM and CPUx_Tjmax:
+                            need_data.update({CPUx_Temp:calculate_CPU_temp(data, PxTM, CPUx_Tjmax)})
+                            if calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'None' or calculate_CPU_temp(data, PxTM, CPUx_Tjmax) == 'Error':
+                                flag = 1
+                        else:
+                            flag = 1
+
+                    elif need_id == CPUy_Temp:
+                        
+                        try:
+                            PyTM = config.get("SensorsForCPUTemp", "Py Therm Margin")
+                        except configparser.NoOptionError:
+                            PyTM = ''
+
+                        try:
+                            CPUy_Tjmax = config.get("SensorsForCPUTemp", "CPUy Tjmax")
+                        except configparser.NoOptionError:
+                            CPUy_Tjmax = ''
+                        
+                        if PyTM and CPUy_Tjmax:
+                            need_data.update({CPUy_Temp:calculate_CPU_temp(data, PyTM, CPUy_Tjmax)})
+                            if calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'None' or calculate_CPU_temp(data, PyTM, CPUy_Tjmax) == 'Error':
+                                flag = 1