lots of changes
diff --git a/bin/Barreleye.py b/bin/Barreleye.py
index 50a3492..328da30 100644
--- a/bin/Barreleye.py
+++ b/bin/Barreleye.py
@@ -7,32 +7,74 @@
HOME_PATH = '/media/sf_vbox/openbmc/'
BIN_PATH = HOME_PATH+'bin/'
CACHE_PATH = HOME_PATH+'cache/'
+FRU_PATH = CACHE_PATH+'frus/'
-CACHED_INTERFACES = {
- 'org.openbmc.Fru' : True
+SYSTEM_STATES = [
+ 'INIT',
+ 'STANDBY',
+ 'POWERING_ON',
+ 'POWERED_ON',
+ 'BOOTING',
+ 'HOST_UP',
+ 'SHUTTING_DOWN',
+ 'POWERING_DOWN'
+]
+
+ENTER_STATE_CALLBACK = {
+ 'POWERED_ON' : {
+ 'bus_name' : 'org.openbmc.control.Host',
+ 'obj_name' : '/org/openbmc/control/Host_0',
+ 'interface_name' : 'org.openbmc.control.Host',
+ 'method_name' : 'boot'
+ }
}
SYSTEM_CONFIG = {}
-SYSTEM_CONFIG['org.openbmc.watchdog.HostWatchdog'] = {
+SYSTEM_CONFIG['org.openbmc.control.Bmc'] = {
+ 'system_state' : 'INIT',
'start_process' : True,
- 'process_name' : 'host_watchdog.exe',
+ 'process_name' : 'control_bmc.exe',
'heartbeat' : 'no',
- 'rest_name' : 'watchdog',
'instances' : [
{
- 'name' : 'Watchdog1',
- 'user_label': 'Host Watchdog',
- 'properties' : {
- 'org.openbmc.Watchdog' : {
- 'poll_interval': 300000,
- }
- }
+ 'name' : 'Bmc_0',
+ 'user_label': 'Master Bmc',
}
]
}
+SYSTEM_CONFIG['org.openbmc.managers.Frus'] = {
+ 'system_state' : 'STANDBY',
+ 'start_process' : True,
+ 'process_name' : 'fru_manager.py',
+ 'heartbeat' : 'no',
+ 'rest_name' : 'frus',
+ 'instances' : [
+ {
+ 'name' : 'Barreleye',
+ 'user_label': 'Fru Manager',
+ }
+ ]
+ }
+
+SYSTEM_CONFIG['org.openbmc.managers.Ipmi'] = {
+ 'system_state' : 'STANDBY',
+ 'start_process' : True,
+ 'process_name' : 'ipmi_manager.py',
+ 'heartbeat' : 'no',
+ 'rest_name' : 'frus',
+ 'instances' : [
+ {
+ 'name' : 'Barreleye',
+ 'user_label': 'Fru Manager',
+ }
+ ]
+ }
+
+
SYSTEM_CONFIG['org.openbmc.managers.Sensors'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'sensor_manager.py',
'heartbeat' : 'no',
@@ -46,6 +88,7 @@
}
SYSTEM_CONFIG['org.openbmc.loggers.EventLogger'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'eventlogger.py',
'heartbeat' : 'no',
@@ -58,26 +101,33 @@
]
}
-SYSTEM_CONFIG['org.openbmc.managers.IpmiTranslator'] = {
+SYSTEM_CONFIG['org.openbmc.watchdog.Host'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
- 'process_name' : 'ipmi_translator.py',
+ 'process_name' : 'host_watchdog.exe',
'heartbeat' : 'no',
+ 'rest_name' : 'watchdog',
'instances' : [
{
- 'name' : 'Barreleye',
- 'user_label': 'IPMI Translator',
+ 'name' : 'HostWatchdog_0',
+ 'user_label': 'Host Watchdog',
+ 'properties' : {
+ 'org.openbmc.Watchdog' : {
+ 'poll_interval': 3000,
+ }
+ }
}
]
}
-
SYSTEM_CONFIG['org.openbmc.control.Power'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'power_control.exe',
'heartbeat' : 'yes',
'instances' : [
{
- 'name' : 'PowerControl1',
+ 'name' : 'SystemPower_0',
'user_label': 'Power control',
'properties' : {
'org.openbmc.Control': {
@@ -89,18 +139,17 @@
}
SYSTEM_CONFIG['org.openbmc.sensors.Temperature.Ambient'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'sensor_ambient.exe',
'heartbeat' : 'yes',
- 'init_methods' : ['org.openbmc.SensorValue'],
'instances' : [
{
- 'name' : 'AmbientTemperature1',
+ 'name' : 'FrontChassis',
'user_label': 'Ambient Temperature 1',
- 'sensor_id' : 41,
'properties' : {
'org.openbmc.SensorValue': {
- 'poll_interval' : 5000
+ 'poll_interval' : 5000,
},
'org.openbmc.SensorThreshold' : {
'lower_critical': 5,
@@ -114,85 +163,77 @@
}
}
},
- {
- 'name' : 'AmbientTemperature2',
- 'user_label': 'Ambient Temperature 2',
- 'properties' : {
- 'org.openbmc.SensorValue': {
- 'poll_interval' : 5000
- },
- 'org.openbmc.SensorThreshold' : {
- 'lower_critical': 5,
- 'lower_warning' : 10,
- 'upper_warning' : 15,
- 'upper_critical': 20
- },
- 'org.openbmc.SensorI2c' : {
- 'dev_path' : '/dev/i2c/i2c0',
- 'address' : '0xA2'
- }
- }
- }
]
}
-SYSTEM_CONFIG['org.openbmc.buttons.ButtonPower'] = {
+SYSTEM_CONFIG['org.openbmc.buttons.Power'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'button_power.exe',
'heartbeat' : 'no',
'instances' : [
{
- 'name' : 'PowerButton1',
+ 'name' : 'PowerButton_0',
'user_label': 'Main Power Button',
}
]
}
SYSTEM_CONFIG['org.openbmc.sensors.HostStatus'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'sensor_host_status.exe',
'heartbeat' : "no",
'instances' : [
{
- 'name' : 'HostStatus1',
+ 'name' : 'HostStatus_0',
'user_label': 'Host Status',
- 'sensor_id' : 43,
+ 'properties' : {
+ 'org.openbmc.SensorValue': {
+ 'ipmi_id' : 43,
+ },
+ }
+
}
]
}
SYSTEM_CONFIG['org.openbmc.leds.ChassisIdentify'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'chassis_identify.exe',
'heartbeat' : 'no',
'instances' : [
{
- 'name' : 'ChassisIdentify1',
+ 'name' : 'ChassisIdentify_0',
'user_label': 'Chassis Identify LED',
}
]
}
SYSTEM_CONFIG['org.openbmc.flash.BIOS'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'flash_bios.exe',
'heartbeat' : 'no',
'rest_name' : 'flash',
'instances' : [
{
- 'name' : 'BIOS1',
+ 'name' : 'BIOS_0',
'user_label': 'BIOS SPI Flash',
}
]
}
SYSTEM_CONFIG['org.openbmc.control.Host'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'control_host.exe',
'heartbeat' : 'no',
'instances' : [
{
- 'name' : 'HostControl1',
+ 'name' : 'Host_0',
'user_label': 'Host Control',
}
]
}
SYSTEM_CONFIG['org.openbmc.control.Chassis'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'chassis_control.py',
'heartbeat' : 'no',
@@ -204,174 +245,87 @@
}
]
}
-SYSTEM_CONFIG['org.openbmc.frus.Fan'] = {
+
+SYSTEM_CONFIG['org.openbmc.sensors.Occ'] = {
+ 'system_state' : 'POWERED_ON',
+ 'start_process' : True,
+ 'process_name' : 'sensor_occ.exe',
+ 'heartbeat' : 'no',
+ 'instances' : [
+ {
+ 'name' : 'Occ_0',
+ 'user_label': 'CPU0',
+ 'properties' : {
+ 'org.openbmc.Occ' : {
+ 'poll_interval' : 3000,
+ }
+ }
+ },
+
+ ]
+ }
+
+SYSTEM_CONFIG['org.openbmc.sensors.Fan'] = {
+ 'system_state' : 'STANDBY',
'start_process' : True,
'process_name' : 'fan.exe',
'heartbeat' : 'no',
- 'instances' : [
- {
- 'name' : 'Fan0',
- 'user_label': 'Fan 0',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'FAN0',
- 'location' : 'F0',
- 'type' : Openbmc.FRU_TYPES['FAN'],
- }
- }
-
- },
- {
- 'name' : 'Fan1',
- 'user_label': 'Fan 1',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'FAN1',
- 'location' : 'F1',
- 'type' : Openbmc.FRU_TYPES['FAN'],
- }
- }
-
- },
- {
- 'name' : 'Fan2',
- 'user_label': 'Fan 2',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'FAN2',
- 'location' : 'F2',
- 'type' : Openbmc.FRU_TYPES['FAN'],
- }
- }
-
- },
- {
- 'name' : 'Fan3',
- 'user_label': 'Fan 3',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'FAN3',
- 'location' : 'F3',
- 'type' : Openbmc.FRU_TYPES['FAN'],
- }
- }
-
- },
- {
- 'name' : 'Fan4',
- 'user_label': 'Fan 4',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'FAN4',
- 'location' : 'F4',
- 'type' : Openbmc.FRU_TYPES['FAN'],
- }
- }
-
- },
- {
- 'name' : 'Fan5',
- 'user_label': 'Fan 5',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'FAN5',
- 'location' : 'F5',
- 'type' : Openbmc.FRU_TYPES['FAN'],
- }
- }
-
- }
-
- ]
- }
-
-SYSTEM_CONFIG['org.openbmc.frus.Board'] = {
- 'start_process' : True,
- 'process_name' : 'fru_board.exe',
- 'init_methods' : ['org.openbmc.Fru'],
- 'heartbeat' : 'no',
'instances' : [
{
- 'name' : 'IO_Planer',
- 'user_label': 'IO Planar',
- 'fru_id' : 61,
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'IO Planar',
- 'location' : 'IO_PLANAR',
- 'type' : Openbmc.FRU_TYPES['BACKPLANE']
- },
- 'org.openbmc.Fru.Eeprom' : {
- 'i2c_address' : '0xA8',
- 'i2c_dev_path' : '/dev/i2c/i2c5'
- }
- }
- }
- ]
- }
-
-SYSTEM_CONFIG['org.openbmc.frus.Fru'] = {
- 'start_process' : True,
- 'process_name' : 'fru_generic.exe',
- 'heartbeat' : 'no',
- 'instances' : [
- {
- 'name' : 'Backplane',
- 'user_label': '2S Motherboard',
- 'fru_id' : 60,
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'MAIN_PLANAR',
- 'location' : 'C0',
- 'type' : Openbmc.FRU_TYPES['BACKPLANE'],
- }
- }
+ 'name' : 'Fan_0',
+ 'user_label': 'FAN 0',
},
{
- 'name' : 'DIMM0',
- 'user_label': 'DIMM A0 Slot 0',
- 'fru_id' : 12,
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'DIMM0',
- 'location' : 'A0',
- 'type' : Openbmc.FRU_TYPES['DIMM'],
- }
- }
+ 'name' : 'Fan_1',
+ 'user_label': 'FAN 1',
},
{
- 'name' : 'DIMM1',
- 'user_label': 'DIMM A1 Slot 0',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'DIMM1',
- 'location' : 'A1',
- 'type' : Openbmc.FRU_TYPES['DIMM'],
- }
- }
- },
- {
- 'name' : 'CPU0',
- 'user_label': 'CPU0',
- 'properties' : {
- 'org.openbmc.Fru' : {
- 'label' : 'CPU0',
- 'location' : 'CPU0',
- 'type' : Openbmc.FRU_TYPES['CPU'],
- }
- }
+ 'name' : 'Fan_2',
+ 'user_label': 'FAN 2',
},
]
}
+NON_CACHABLE_PROPERTIES = {
+ 'name' : True,
+ 'user_label' : True,
+ 'location' : True,
+ 'cache' : True
+}
+
+FRUS = {}
+
+## key is IPMI FRU ID
+
+FRUS[32] = {
+ 'name' : 'CPU0',
+ 'user_label' : "IBM POWER8 CPU",
+ 'ftype' : Openbmc.FRU_TYPES['CPU'],
+ 'location' : "P0",
+ 'manufacturer' : "IBM",
+ 'cache' : True,
+ 'state' : Openbmc.FRU_STATES['NORMAL'],
+ 'sensor_id' : 10,
+ }
+
+FRUS[21] = {
+ 'name' : 'IO_PLANAR',
+ 'user_label' : "BARRELEYE IO PLANAR",
+ 'ftype' : Openbmc.FRU_TYPES['BACKPLANE'],
+ 'cache' : False,
+ 'state' : Openbmc.FRU_STATES['NORMAL'],
+ 'sensor_id' : 11,
+ }
+
+
GPIO_CONFIG = {}
-GPIO_CONFIG['FSI_CLK'] = { 'gpio_num': 23, 'direction': 'out' }
-GPIO_CONFIG['FSI_DATA'] = { 'gpio_num': 24, 'direction': 'out' }
-GPIO_CONFIG['FSI_ENABLE'] = { 'gpio_num': 25, 'direction': 'out' }
-GPIO_CONFIG['POWER_PIN'] = { 'gpio_num': 26, 'direction': 'out' }
-GPIO_CONFIG['CRONUS_SEL'] = { 'gpio_num': 27, 'direction': 'out' }
-GPIO_CONFIG['PGOOD'] = { 'gpio_num': 28, 'direction': 'in' }
-GPIO_CONFIG['IDENTIFY'] = { 'gpio_num': 30, 'direction': 'out' }
-GPIO_CONFIG['POWER_BUTTON'] = { 'gpio_num': 31, 'direction': 'in' }
+GPIO_CONFIG['FSI_CLK'] = { 'gpio_num': 4, 'direction': 'out' }
+GPIO_CONFIG['FSI_DATA'] = { 'gpio_num': 5, 'direction': 'out' }
+GPIO_CONFIG['FSI_ENABLE'] = { 'gpio_num': 24, 'direction': 'out' }
+GPIO_CONFIG['POWER_PIN'] = { 'gpio_num': 33, 'direction': 'out' }
+GPIO_CONFIG['CRONUS_SEL'] = { 'gpio_num': 6, 'direction': 'out' }
+GPIO_CONFIG['PGOOD'] = { 'gpio_num': 23, 'direction': 'in' }
+GPIO_CONFIG['IDENTIFY'] = { 'gpio_num': 34, 'direction': 'out' }
+GPIO_CONFIG['POWER_BUTTON'] = { 'gpio_num': 32, 'direction': 'in' }
diff --git a/bin/Openbmc.py b/bin/Openbmc.py
index 12f93c7..97d20bf 100644
--- a/bin/Openbmc.py
+++ b/bin/Openbmc.py
@@ -2,6 +2,7 @@
import xml.etree.ElementTree as ET
BUS_PREFIX = 'org.openbmc'
+OBJ_PREFIX = "/org/openbmc"
GPIO_DEV = '/sys/class/gpio'
@@ -12,60 +13,104 @@
'RISER_CARD' : 4,
'FAN' : 5
}
+FRU_STATES = {
+ 'NORMAL' : 0,
+ 'RECOVERABLE_ERROR' : 1,
+ 'FATAL_ERROR' : 2,
+ 'NOT_PRESENT' : 3,
+}
ENUMS = {
'org.openbmc.SensorIntegerThreshold.state' :
['NOT_SET','NORMAL','LOWER_CRITICAL','LOWER_WARNING','UPPER_WARNING','UPPER_CRITICAL'],
- 'org.openbmc.Fru.type' :
- ['NONE','CPU','DIMM','BACKPLANE','RISER_CARD','FAN']
+}
+
+DBUS_TO_BASE_TYPES = {
+ 'dbus.Byte' : 'int',
+ 'dbus.Double' : 'float',
+ 'dbus.Int32' : 'int',
+ 'dbus.UInt32' : 'long',
+ 'dbus.String' : 'str',
+ 'dbus.UInt64' : 'long',
+ 'dbus.Boolean' : 'bool',
+}
+
+BASE_TO_DBUS_TYPES = {
+ 'int' : 'dbus.Int32',
+ 'float' : 'dbus.Double',
+ 'str' : 'dbus.String',
+ 'long' : 'dbus.Int64',
+ 'bool' : 'dbus.Boolean'
}
-def object_to_bus_name(obj):
- parts = obj.split('/')
- parts.pop(0)
- parts.pop()
- return ".".join(parts)
+def getManagerInterface(bus,manager):
+ bus_name = "org.openbmc.managers."+manager
+ obj_name = "/org/openbmc/managers/"+manager
+ obj = bus.get_object(bus_name,obj_name)
+ return dbus.Interface(obj,bus_name)
-def bus_to_object_name(bus_name):
- return "/"+bus_name.replace('.','/')
-def get_methods(obj):
- methods = {}
+def get_objs(bus,bus_name,path,objects):
+ obj = bus.get_object(bus_name,path)
introspect_iface = dbus.Interface(obj,"org.freedesktop.DBus.Introspectable")
+ #print introspect_iface.Introspect()
tree = ET.ElementTree(ET.fromstring(introspect_iface.Introspect()))
root = tree.getroot()
- for intf in root.iter('interface'):
- intf_name = intf.attrib['name']
- if (intf_name.find(BUS_PREFIX)==0):
- methods[intf_name] = {}
- for method in intf.iter('method'):
- methods[intf_name][method.attrib['name']] = True
-
- return methods
+ for node in root.iter('node'):
+ if (node.attrib.has_key('name') == False):
+ for intf in node.iter('interface'):
+ intf_name = intf.attrib['name']
+ if (intf_name.find(BUS_PREFIX)==0):
+ parts=path.split('/')
+ instance = parts[len(parts)-1]
+ if (objects.has_key(instance) == False):
+ objects[instance] = {}
+ objects[instance]['PATH'] = path
+ objects[instance]['INIT'] = []
+ for method in intf.iter('method'):
+ if (method.attrib['name'] == "init"):
+ objects[instance]['INIT'].append(intf_name)
+
+ else:
+ node_name = node.attrib['name']
+ if (node_name != path):
+ get_objs(bus,bus_name,path+"/"+node.attrib['name'],objects)
+
+
+
+#def get_methods(obj):
+# methods = {}
+# introspect_iface = dbus.Interface(obj,"org.freedesktop.DBus.Introspectable")
+ # tree = ET.ElementTree(ET.fromstring(introspect_iface.Introspect()))
+ # root = tree.getroot()
+# for intf in root.iter('interface'):
+ # intf_name = intf.attrib['name']
+# if (intf_name.find(BUS_PREFIX)==0):
+# methods[intf_name] = {}
+# for method in intf.iter('method'):
+# methods[intf_name][method.attrib['name']] = True
+#
+# return methods
class DbusProperty:
def __init__(self,name,value):
- self.dbusBaseType = {
- 'dbus.Byte' : 'int',
- 'dbus.Double' : 'float',
- 'dbus.Int32' : 'int',
- 'dbus.UInt32' : 'long',
- 'dbus.String' : 'str',
- 'dbus.UInt64' : 'long',
- }
self.name = str(name)
self.dbusType = str(type(value)).split("'")[1]
- self.variant_level = value.variant_level
+ self.variant_level = 2
self.value = None
-
- try:
- self.value = eval(self.dbusBaseType[self.dbusType]+"(value)")
- except:
- raise Exception("Unknown dbus type: "+self.dbusType)
+ if (BASE_TO_DBUS_TYPES.has_key(self.dbusType) == False):
+ self.variant_level = value.variant_level
+ try:
+ self.value = eval(DBUS_TO_BASE_TYPES[self.dbusType]+"(value)")
+ except:
+ raise Exception("Unknown dbus type: "+self.dbusType)
+ else:
+ self.dbusType = BASE_TO_DBUS_TYPES[self.dbusType]
+ self.value = value
def setValue(self,value):
try:
- self.value = eval(self.dbusBaseType[self.dbusType]+"(value)")
+ self.value = eval(DBUS_TO_BASE_TYPES[self.dbusType]+"(value)")
except:
raise Exception("Unknown dbus type: "+self.dbusType)
@@ -79,12 +124,8 @@
e = self.dbusType+"(self.value, variant_level="+str(self.variant_level)+")"
return eval(e)
- #def __getstate__(self):
- # odict = self.__dict__.copy() # copy the dict since we change it
- # return odict
-
- ##def __setstate__(self, dict):
- # self.__dict__.update(dict) # update attributes
+ def getBaseValue(self):
+ return self.value
def __str__(self):
return self.dbusType+":"+str(self.value)
diff --git a/bin/PropertyManager.py b/bin/PropertyManager.py
index 6af3af7..d3176d1 100644
--- a/bin/PropertyManager.py
+++ b/bin/PropertyManager.py
@@ -32,8 +32,9 @@
directory = self.save_path+directory.lstrip('.')
filename = directory+"/"+prop_interface
if (os.path.isfile(filename) == False):
+ pass
## not an error
- print "No cache available for: "+filename
+ #print "No cache available for: "+filename
else:
try:
print "Loading from disk: "+obj_path
diff --git a/bin/chassis_control.py b/bin/chassis_control.py
index 4be1afc..455030b 100644
--- a/bin/chassis_control.py
+++ b/bin/chassis_control.py
@@ -7,7 +7,7 @@
import dbus.mainloop.glib
DBUS_NAME = 'org.openbmc.control.Chassis'
-OBJ_NAME = '/org/openbmc/control/Chassis/'+sys.argv[1]
+OBJ_NAME = '/org/openbmc/control/'+sys.argv[1]
POWER_OFF = 0
POWER_ON = 1
@@ -20,61 +20,37 @@
dbus.service.Object.__init__(self,bus,name)
## load utilized objects
- self.dbus_busses = {
- 'org.openbmc.control.Power' :
- [ { 'name' : 'PowerControl1' , 'intf' : 'org.openbmc.control.Power' } ],
- 'org.openbmc.leds.ChassisIdentify' :
- [ { 'name' : 'ChassisIdentify1', 'intf' : 'org.openbmc.control.Chassis' } ],
- 'org.openbmc.control.Host' :
- [ { 'name' : 'HostControl1', 'intf' : 'org.openbmc.control.Host' } ]
+ self.dbus_objects = {
+ 'power_control' : {
+ 'bus_name' : 'org.openbmc.control.Power',
+ 'object_name' : '/org/openbmc/control/SystemPower_0',
+ 'interface_name' : 'org.openbmc.control.Power'
+ },
+ 'identify_led' : {
+ 'bus_name' : 'org.openbmc.leds.ChassisIdentify',
+ 'object_name' : '/org/openbmc/leds/ChassisIdentify_0',
+ 'interface_name' : 'org.openbmc.Led'
+ }
}
- self.power_sequence = 0
+ #self.power_sequence = 0
self.reboot = 0
self.last_power_state = 0
bus = dbus.SessionBus()
- ## add signal handler to detect when new objects show up on dbus
- bus.add_signal_receiver(self.request_name,
- dbus_interface = 'org.freedesktop.DBus',
- signal_name = "NameOwnerChanged")
bus.add_signal_receiver(self.power_button_signal_handler,
dbus_interface = "org.openbmc.Button", signal_name = "ButtonPressed",
- path="/org/openbmc/buttons/ButtonPower/PowerButton1" )
- bus.add_signal_receiver(self.power_good_signal_handler,
- dbus_interface = "org.openbmc.control.Power", signal_name = "PowerGood")
- bus.add_signal_receiver(self.power_lost_signal_handler,
- dbus_interface = "org.openbmc.control.Power", signal_name = "PowerLost")
+ path="/org/openbmc/buttons/PowerButton_0" )
bus.add_signal_receiver(self.host_watchdog_signal_handler,
dbus_interface = "org.openbmc.Watchdog", signal_name = "WatchdogError")
- bus.add_signal_receiver(self.host_status_signal_handler,
- dbus_interface = "org.openbmc.SensorMatch", signal_name = "SensorMatch",
- path="/org/openbmc/sensors/HostStatus/HostStatus1")
+ bus.add_signal_receiver(self.SystemStateHandler,signal_name = "GotoSystemState")
- try:
- for bus_name in self.dbus_busses.keys():
- self.request_name(bus_name,"",bus_name)
- except:
- ## its ok if this fails. hotplug will detect too
- print "Warning: One of processes not started yet."
- pass
-
-
- def request_name(self, bus_name, a, b):
- # bus added
- if (len(b) > 0 ):
- ## if bus in required list for this object, then save a pointer to interface
- ## for method calls
- if (self.dbus_busses.has_key(bus_name)):
- obj_path = "/"+bus_name.replace('.','/')
- for objs in self.dbus_busses[bus_name]:
- inst_name = objs['name']
- print "Chassis control: "+inst_name
- obj = bus.get_object(bus_name,obj_path+"/"+inst_name)
- self.dbus_objects[inst_name] = dbus.Interface(obj, objs['intf'])
-
+ def getInterface(self,name):
+ o = self.dbus_objects[name]
+ obj = bus.get_object(o['bus_name'],o['object_name'])
+ return dbus.Interface(obj,o['interface_name'])
@dbus.service.method(DBUS_NAME,
in_signature='', out_signature='s')
@@ -85,40 +61,56 @@
in_signature='', out_signature='')
def setIdentify(self):
print "Turn on identify"
- self.dbus_objects['ChassisIdentify1'].setOn()
+ intf = self.getInterface('identify_led')
+ intf.setOn()
return None
@dbus.service.method(DBUS_NAME,
in_signature='', out_signature='')
def clearIdentify(self):
- print "Turn off identify"
- r=self.dbus_objects['ChassisIdentify1'].setOff()
+ print "Turn on identify"
+ intf = self.getInterface('identify_led')
+ intf.setOff()
return None
@dbus.service.method(DBUS_NAME,
in_signature='', out_signature='')
- def setPowerOn(self):
+ def powerOn(self):
print "Turn on power and boot"
- self.power_sequence = 0
self.reboot = 0
if (self.getPowerState()==0):
- self.dbus_objects['PowerControl1'].setPowerState(POWER_ON)
- self.power_sequence = 1
+ intf = self.getInterface('power_control')
+ intf.setPowerState(POWER_ON)
return None
@dbus.service.method(DBUS_NAME,
in_signature='', out_signature='')
- def setPowerOff(self):
- self.power_sequence = 0
+ def powerOff(self):
print "Turn off power"
- self.dbus_objects['PowerControl1'].setPowerState(POWER_OFF);
+ intf = self.getInterface('power_control')
+ intf.setPowerState(POWER_OFF)
+ return None
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='')
+ def softPowerOff(self):
+ print "Soft off power"
+ ## Somehow tell host to shutdown via ipmi
+ return None
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='')
+ def reboot(self):
+ print "Rebooting"
+ self.reboot=1
+ intf.softPowerOff()
return None
@dbus.service.method(DBUS_NAME,
in_signature='', out_signature='i')
def getPowerState(self):
- state = self.dbus_objects['PowerControl1'].getPowerState();
- return state
+ intf = self.getInterface('power_control')
+ return intf.getPowerState()
@dbus.service.method(DBUS_NAME,
in_signature='', out_signature='')
@@ -132,36 +124,26 @@
## Signal handler
+
+ def SystemStateHandler(self,state_name):
+ if (state_name == "POWERED_OFF" and self.reboot==1):
+ self.powerOn()
+
+
def power_button_signal_handler(self):
# toggle power
state = self.getPowerState()
if state == POWER_OFF:
- self.setPowerOn()
+ self.powerOn()
elif state == POWER_ON:
- self.setPowerOff();
+ self.powerOff();
# TODO: handle long press and reset
- ## Signal handlers
- def power_good_signal_handler(self):
- if (self.power_sequence==1):
- self.dbus_objects['HostControl1'].boot()
- self.power_sequence = 2
-
- def host_status_signal_handler(self,value):
- if (value == BOOTED and self.power_sequence==2):
- self.power_sequence=0
- print "Host booted"
-
- def power_lost_signal_handler(self):
- ## Reboot if power is lost but reboot requested
- if (self.reboot == 1):
- self.setPowerOn()
-
def host_watchdog_signal_handler(self):
- print "Watchdog Error, Rebooting"
+ print "Watchdog Error, Hard Rebooting"
self.reboot = 1
- self.setPowerOff()
+ self.powerOff()
if __name__ == '__main__':
diff --git a/bin/fru_manager.py b/bin/fru_manager.py
new file mode 100644
index 0000000..1150552
--- /dev/null
+++ b/bin/fru_manager.py
@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+
+import os
+import sys
+import gobject
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+import cPickle
+import json
+
+if (len(sys.argv) < 2):
+ print "Usage: fru_manager.py [system name]"
+ exit(1)
+System = __import__(sys.argv[1])
+import Openbmc
+
+DBUS_NAME = 'org.openbmc.managers.Frus'
+OBJ_NAME = '/org/openbmc/managers/Frus'
+FRU_PATH = System.FRU_PATH
+
+class Fru:
+ def __init__(self,fru_id,data):
+ if (data.has_key('ftype') == False):
+ raise Exception("Fru must have ftype")
+
+ self.fru_id = fru_id
+ self.data = { 'fru_id' : fru_id }
+ self.ftype = data['ftype']
+ self.update(data)
+
+ def getField(self,field):
+ return self.data[field]
+
+ def getId(self):
+ return self.fru_id
+
+ def update(self,data):
+ for k in data.keys():
+ self.data[k] = data[k]
+
+ def isCached(self):
+ is_cached = False
+ if (self.data.has_key('cache')):
+ if (self.data['cache']):
+ is_cached = True
+ return is_cached
+
+ def saveToCache(self):
+ if (self.isCached() == False):
+ return
+ global FRU_PATH
+ print "Caching: "+str(self.fru_id)
+ filename = FRU_PATH+"fru_"+str(self.fru_id)
+ output = open(filename, 'wb')
+ ## just pickle dict not whole object
+ cPickle.dump(self.data,output)
+ output.close()
+
+ def loadFromCache(self):
+ if (self.isCached() == False):
+ return;
+ ## overlay with pickled data
+ global FRU_PATH
+ filename = FRU_PATH+"fru_"+str(self.fru_id)
+
+ if (os.path.isfile(filename)):
+ print "Loading from cache: "+filename
+ p = open(filename, 'rb')
+ data2 = cPickle.load(p)
+ for k in data2.keys():
+ self.data[k] = data2[k]
+ def toJson(self):
+ return json.dumps(self.data)
+
+ def __str__(self):
+ r = "Fru: "+str(self.fru_id)+"\n"
+ for f in self.data.keys():
+ r = r+f+" = "+str(self.data[f])+"\n"
+ return r
+
+
+
+class FruManager(dbus.service.Object):
+ def __init__(self,bus,name):
+ dbus.service.Object.__init__(self,bus,name)
+
+ bus.add_signal_receiver(self.UpdateFruHandler,
+ signal_name = 'UpdateFru')
+
+ self.fru_db = {}
+ for fid in System.FRUS.keys():
+ self.updateFru(fid,System.FRUS[fid])
+
+
+ #@dbus.service.signal(DBUS_NAME)
+ #def OpenBmcRunning(self):
+ # pass
+ def UpdateFruHandler(self,fru_id,data):
+ self.updateFru(fru_id,data)
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='isv', out_signature='')
+ def updateFruField(self,fru_id,field,value):
+ data = { field : value }
+ self.updateFru(fru_id,data)
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='ia{sv}', out_signature='')
+ def updateFru(self,fru_id,data):
+ ## translate dbus data into basic data types
+ for k in data.keys():
+ d = Openbmc.DbusProperty(k,data[k])
+ data[k] = d.getBaseValue()
+
+ if (self.fru_db.has_key(fru_id)):
+ ## update properties then save to cache
+ print "Updating FRU: "+str(fru_id)
+ self.fru_db[fru_id].update(data)
+ self.fru_db[fru_id].saveToCache()
+ else:
+ ## fru doesn't exist, so add
+ ## then overlay with data from cache
+ print "Adding FRU: "+str(fru_id)
+ fru = Fru(fru_id,data)
+ self.fru_db[fru_id] = fru
+ fru.loadFromCache()
+
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='s')
+ def getFrus(self):
+ r = ""
+ for f in self.fru_db.keys():
+ r=r+"["+self.fru_db[f].toJson()+"],"
+ return r
+
+
+if __name__ == '__main__':
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+ bus = dbus.SessionBus()
+ name = dbus.service.BusName(DBUS_NAME,bus)
+ obj = FruManager(bus,OBJ_NAME)
+ mainloop = gobject.MainLoop()
+
+ print "Running Fru Manager"
+ mainloop.run()
+
diff --git a/bin/ipmi_bt.py b/bin/ipmi_bt.py
deleted file mode 100644
index d3e79cd..0000000
--- a/bin/ipmi_bt.py
+++ /dev/null
@@ -1,101 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-import subprocess
-import dbus
-from gi.repository import GObject
-import dbus.service
-import dbus.mainloop.glib
-
-if (len(sys.argv) < 2):
- print "Usage: ipmi_bt.py [system name]"
- exit(1)
-
-System = __import__(sys.argv[1])
-import Openbmc
-
-DBUS_NAME = 'org.openbmc.control.IpmiBt'
-OBJ_NAME = '/org/openbmc/control/IpmiBt'
-
-class IpmiBt(dbus.service.Object):
- def __init__(self,bus,name):
- dbus.service.Object.__init__(self,bus,name)
-
- @dbus.service.signal(DBUS_NAME)
- def UpdateFru(self, iid, message):
- pass
-
- @dbus.service.signal(DBUS_NAME)
- def UpdateSensor(self, iid, message):
- pass
-
- @dbus.service.method(DBUS_NAME)
- def emitUpdateFru(self,ipmi_id,mfg):
- data = {
- 'manufacturer' : mfg
- }
- self.UpdateFru(ipmi_id,data)
- return 'Signal emitted'
-
- @dbus.service.method(DBUS_NAME)
- def emitUpdateSensor(self,ipmi_id,data):
- self.UpdateSensor(ipmi_id,dbus.Byte(int(data)))
- print "update sensor emitted"
- return 'Signal emitted'
-
- def getSensor(self,ipmi_id):
- obj = bus.get_object('org.openbmc.managers.IpmiTranslator',
- '/org/openbmc/managers/IpmiTranslator/Barreleye')
- intf = dbus.Interface(obj, 'org.openbmc.managers.IpmiTranslator' )
- return intf.getSensor(ipmi_id)
-
- def pokeHostWatchdog(self):
- obj = bus.get_object('org.openbmc.managers.IpmiTranslator',
- '/org/openbmc/managers/IpmiTranslator/Barreleye')
- intf = dbus.Interface(obj, 'org.openbmc.managers.IpmiTranslator' )
- intf.pokeHostWatchdog()
-
- def startHostWatchdog(self):
- obj = bus.get_object('org.openbmc.managers.IpmiTranslator',
- '/org/openbmc/managers/IpmiTranslator/Barreleye')
- intf = dbus.Interface(obj, 'org.openbmc.managers.IpmiTranslator' )
- intf.startHostWatchdog()
-
-
-
-
-
-if __name__ == '__main__':
-
- cmd = ""
- data = None
- ipmi_id = 0
- if (len(sys.argv) > 2):
- cmd = sys.argv[2]
- if (len(sys.argv) > 3):
- ipmi_id = int(sys.argv[3])
- if (len(sys.argv)>4):
- data = sys.argv[4]
-
- dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
- bus = dbus.SessionBus()
- name = dbus.service.BusName(DBUS_NAME,bus)
- obj = IpmiBt(bus,OBJ_NAME)
- mainloop = GObject.MainLoop()
-
- if (cmd == 'updatefru'):
- obj.emitUpdateFru(ipmi_id,data)
- elif (cmd == 'setsensor'):
- obj.emitUpdateSensor(ipmi_id,data)
- elif (cmd == 'getsensor'):
- print obj.getSensor(ipmi_id)
- elif (cmd == 'pokewatchdog'):
- print obj.pokeHostWatchdog()
- elif (cmd == 'startwatchdog'):
- print obj.startHostWatchdog()
- else:
- print "ERROR: Invalid command"
- print "Valid commands: updatefru, setsensor, getsensor, startwatchdog, pokewatchdog"
-
- #mainloop.run()
-
diff --git a/bin/ipmi_manager.py b/bin/ipmi_manager.py
new file mode 100644
index 0000000..479d1a1
--- /dev/null
+++ b/bin/ipmi_manager.py
@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+
+import sys
+import subprocess
+from gi.repository import GObject
+
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+import PropertyManager
+
+if (len(sys.argv) < 2):
+ print "Usage: ipmi_manager.py [system name]"
+ exit(1)
+
+System = __import__(sys.argv[1])
+import Openbmc
+
+DBUS_NAME = 'org.openbmc.managers.Ipmi'
+OBJ_NAME = '/org/openbmc/managers/Ipmi'
+
+
+class IpmiManager(dbus.service.Object):
+ def __init__(self,bus,name):
+ dbus.service.Object.__init__(self,bus,name)
+
+ ## IPMI commands
+ @dbus.service.method(DBUS_NAME,
+ in_signature='yv', out_signature='')
+ def setSensor(self,sensor_id,value):
+ intf_sens = Openbmc.getManagerInterface(bus,"Sensors")
+ intf_sens.setSensorFromId(sensor_id,value)
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='y', out_signature='v')
+ def getSensor(self,sensor_id):
+ intf_sens = Openbmc.getManagerInterface(bus,"Sensors")
+ return intf_sens.getSensorFromId(sensor_id)
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='ia{sv}', out_signature='')
+ def updateFru(self,fru_id,data):
+ intf_fru = Openbmc.getManagerInterface(bus,"Frus")
+ intf_fru.updateFru(fru_id,data)
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='s')
+ def getFrus(self):
+ intf_fru = Openbmc.getManagerInterface(bus,"Frus")
+ return intf_fru.getFrus()
+
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='')
+ def pokeHostWatchdog(self):
+ ## TODO don't do hardcoding
+ obj = bus.get_object('org.openbmc.watchdog.Host',
+ '/org/openbmc/watchdog/HostWatchdog_0')
+ intf = dbus.Interface(obj, 'org.openbmc.Watchdog' )
+ intf.poke()
+ return None
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='')
+ def startHostWatchdog(self):
+ ## TODO don't do hardcoding
+ obj = bus.get_object('org.openbmc.watchdog.Host',
+ '/org/openbmc/watchdog/HostWatchdog_0')
+ intf = dbus.Interface(obj, 'org.openbmc.Watchdog' )
+ intf.start()
+ return None
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='')
+ def powerOn(self):
+ ## TODO don't do hardcoding
+ obj = bus.get_object('org.openbmc.control.Chassis',
+ '/org/openbmc/control/Chassis')
+ intf = dbus.Interface(obj, 'org.openbmc.control.Chassis' )
+ intf.powerOn()
+ return None
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='')
+ def powerOff(self):
+ ## TODO don't do hardcoding
+ obj = bus.get_object('org.openbmc.control.Chassis',
+ '/org/openbmc/control/Chassis')
+ intf = dbus.Interface(obj, 'org.openbmc.control.Chassis' )
+ intf.powerOff()
+ return None
+
+
+
+
+if __name__ == '__main__':
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+ bus = dbus.SessionBus()
+ name = dbus.service.BusName(DBUS_NAME,bus)
+ obj = IpmiManager(bus,OBJ_NAME)
+ mainloop = GObject.MainLoop()
+
+ print "Running IpmiManager"
+ mainloop.run()
+
diff --git a/bin/ipmi_translator.py b/bin/ipmi_translator.py
deleted file mode 100644
index 2f3d0bb..0000000
--- a/bin/ipmi_translator.py
+++ /dev/null
@@ -1,138 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-import subprocess
-from gi.repository import GObject
-
-import dbus
-import dbus.service
-import dbus.mainloop.glib
-import PropertyManager
-
-if (len(sys.argv) < 2):
- print "Usage: ipmi_translator.py [system name]"
- exit(1)
-
-System = __import__(sys.argv[1])
-import Openbmc
-
-DBUS_NAME = 'org.openbmc.managers.IpmiTranslator'
-OBJ_NAME = '/org/openbmc/managers/IpmiTranslator/'+sys.argv[1]
-ID_LOOKUP = {
- 'BUS_NAME' : {},
- 'FRU' : {},
- 'SENSOR' : {},
-}
-
-
-class IpmiTranslator(dbus.service.Object):
- def __init__(self,bus,name):
- dbus.service.Object.__init__(self,bus,name)
- self.property_manager = PropertyManager.PropertyManager(bus,System.CACHE_PATH)
- bus.add_signal_receiver(self.UpdateFruHandler,
- dbus_interface = 'org.openbmc.control.IpmiBt',
- signal_name = "UpdateFru")
- bus.add_signal_receiver(self.UpdateSensorHandler,
- dbus_interface = 'org.openbmc.control.IpmiBt',
- signal_name = "UpdateSensor")
-
- ## generate fru and sensor id to dbus object path lookup
- for bus_name in System.SYSTEM_CONFIG.keys():
- obj_name = "/"+bus_name.replace('.','/')
- for instances in System.SYSTEM_CONFIG[bus_name]['instances']:
- obj_path = obj_name+"/"+instances['name']
- if (instances.has_key('sensor_id')):
- iid = instances['sensor_id']
- ID_LOOKUP['BUS_NAME'][iid] = bus_name
- ID_LOOKUP['SENSOR'][iid] = obj_path
- if (instances.has_key('fru_id')):
- iid = instances['fru_id']
- ID_LOOKUP['BUS_NAME'][iid] = bus_name
- ID_LOOKUP['FRU'][iid] = obj_path
-
-
- ## TODO: Should be event driven instead of calling object methods because
- ## object could be hung
- def UpdateFruHandler(self,fru_id,data):
- if (ID_LOOKUP['FRU'].has_key(fru_id)):
- obj_path = ID_LOOKUP['FRU'][fru_id]
- bus_name = ID_LOOKUP['BUS_NAME'][fru_id]
- ## save fru object to object and disk
- interface_name = 'org.openbmc.Fru'
- cache = System.CACHED_INTERFACES.has_key(interface_name)
- self.property_manager.saveProperties(bus_name,obj_path,interface_name,cache,data)
- else:
- ## TODO: error handling
- pass
-
- def UpdateSensorHandler(self,sensor_id,value):
- if (ID_LOOKUP['SENSOR'].has_key(sensor_id)):
- obj_path = ID_LOOKUP['SENSOR'][sensor_id]
- bus_name = ID_LOOKUP['BUS_NAME'][sensor_id]
-
- ## change to variant data type
- ## comes in off dbus from ipmi_bt as a basic data type
- dvalue = Openbmc.DbusProperty('value',value)
- dvalue.setVariant(1)
- ## save sensor value
- interface_name = 'org.openbmc.SensorValue'
- cache = System.CACHED_INTERFACES.has_key(interface_name)
- obj = bus.get_object(bus_name,obj_path)
- intf = dbus.Interface(obj, interface_name)
- intf.setValue(dvalue.getValue())
- else:
- ## TODO: error handling
- pass
-
- @dbus.service.method(DBUS_NAME,
- in_signature='i', out_signature='v')
- def getSensor(self,sensor_id):
- val = 0
- if (ID_LOOKUP['SENSOR'].has_key(sensor_id)):
- obj_path = ID_LOOKUP['SENSOR'][sensor_id]
- bus_name = ID_LOOKUP['BUS_NAME'][sensor_id]
- print "getSensor: "+obj_path+","+bus_name
- ## TODO don't do hardcoding
- obj = bus.get_object('org.openbmc.managers.Sensors',
- '/org/openbmc/managers/Sensors/Barreleye')
- intf = dbus.Interface(obj, 'org.openbmc.managers.Sensors' )
- val = intf.getSensor(obj_path)
-
- return val
-
- @dbus.service.method(DBUS_NAME,
- in_signature='', out_signature='')
- def pokeHostWatchdog(self):
- ## TODO don't do hardcoding
- obj = bus.get_object('org.openbmc.watchdog.HostWatchdog',
- '/org/openbmc/watchdog/HostWatchdog/Watchdog1')
- intf = dbus.Interface(obj, 'org.openbmc.Watchdog' )
- intf.poke()
-
- return None
-
- @dbus.service.method(DBUS_NAME,
- in_signature='', out_signature='')
- def startHostWatchdog(self):
- ## TODO don't do hardcoding
- obj = bus.get_object('org.openbmc.watchdog.HostWatchdog',
- '/org/openbmc/watchdog/HostWatchdog/Watchdog1')
- intf = dbus.Interface(obj, 'org.openbmc.Watchdog' )
- intf.start()
-
- return None
-
-
-
-
-
-if __name__ == '__main__':
- dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
- bus = dbus.SessionBus()
- name = dbus.service.BusName(DBUS_NAME,bus)
- obj = IpmiTranslator(bus,OBJ_NAME)
- mainloop = GObject.MainLoop()
-
- print "Running IpmiTranslator"
- mainloop.run()
-
diff --git a/bin/ipmitool.py b/bin/ipmitool.py
new file mode 100644
index 0000000..973f071
--- /dev/null
+++ b/bin/ipmitool.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+
+import sys
+import subprocess
+import dbus
+from gi.repository import GObject
+import dbus.service
+import dbus.mainloop.glib
+import Openbmc
+
+
+if __name__ == '__main__':
+ cmd = sys.argv[1]
+ data = None
+ ipmi_id = dbus.Byte(0)
+ if (len(sys.argv) > 2):
+ ipmi_id = dbus.Byte(int(sys.argv[2]))
+ if (len(sys.argv)>3):
+ data = sys.argv[3]
+
+ bus = dbus.SessionBus()
+ intf = Openbmc.getManagerInterface(bus,"Ipmi")
+
+ if (cmd == 'updatefru'):
+ d = { 'manufacturer' : data }
+ intf.updateFru(ipmi_id,d)
+ elif (cmd == 'getfrus'):
+ print intf.getFrus()
+ elif (cmd == 'setsensor'):
+ data_b = dbus.Byte(int(data))
+ intf.setSensor(ipmi_id,data_b)
+ elif (cmd == 'getsensor'):
+ print intf.getSensor(ipmi_id)
+ elif (cmd == 'pokewatchdog'):
+ print intf.pokeHostWatchdog()
+ elif (cmd == 'startwatchdog'):
+ print intf.startHostWatchdog()
+ elif (cmd == 'poweron'):
+ print intf.powerOn()
+ elif (cmd == 'poweroff'):
+ print intf.powerOff()
+ else:
+ print "ERROR: Invalid command"
+ print "Valid commands: updatefru, setsensor, getsensor, startwatchdog, pokewatchdog"
+
+ #mainloop.run()
+
diff --git a/bin/sensor_manager.py b/bin/sensor_manager.py
index cb0904e..bcf3fd8 100644
--- a/bin/sensor_manager.py
+++ b/bin/sensor_manager.py
@@ -13,12 +13,12 @@
import Openbmc
DBUS_NAME = 'org.openbmc.managers.Sensors'
-OBJ_NAME = '/org/openbmc/managers/Sensors/'+sys.argv[1]
+OBJ_NAME = '/org/openbmc/managers/Sensors'
class SensorManager(dbus.service.Object):
def __init__(self,bus,name):
dbus.service.Object.__init__(self,bus,name)
- bus.add_signal_receiver(self.UpdateSensor,
+ bus.add_signal_receiver(self.SensorChangedHandler,
dbus_interface = 'org.openbmc.SensorValue',
signal_name = 'Changed', path_keyword='path')
bus.add_signal_receiver(self.NormalThreshold,
@@ -32,16 +32,46 @@
signal_name = 'Critical', path_keyword='path')
self.sensor_cache = {}
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='', out_signature='a{sv}')
+ def getSensorsAll(self):
+ return self.sensor_cache;
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='y', out_signature='v')
+ def getSensorFromId(self,ipmi_id):
+ intf_sys = Openbmc.getManagerInterface(bus,"System")
+ obj_info = intf_sys.getObjFromIpmi(ipmi_id)
+ intf_name = str(obj_info[0])
+ obj_name = str(obj_info[1])
+ return self.getSensor(obj_name)
+
+ @dbus.service.method(DBUS_NAME,
+ in_signature='yv', out_signature='')
+ def setSensorFromId(self,ipmi_id,value):
+ intf_sys = Openbmc.getManagerInterface(bus,"System")
+ obj_info = intf_sys.getObjFromIpmi(ipmi_id)
+ obj = bus.get_object(obj_info[0],obj_info[1])
+ intf = dbus.Interface(obj,"org.openbmc.SensorValue")
+ intf.setValue(value)
+ return None
+
+
@dbus.service.method(DBUS_NAME,
in_signature='s', out_signature='v')
def getSensor(self,path):
- val = None
+ val = 0
if (self.sensor_cache.has_key(path) == True):
val = self.sensor_cache[path]['value']
+ else:
+ # TODO: error handling
+ print "Unknown sensor at: "+path
return val
-
- def UpdateSensor(self,value,units,path = None):
+
+ ## Signal handlers
+ def SensorChangedHandler(self,value,units,path = None):
self.initSensorEntry(path)
self.sensor_cache[path]['value'] = value
self.sensor_cache[path]['units'] = units
diff --git a/bin/system_manager.py b/bin/system_manager.py
index cb37c41..515fa1f 100644
--- a/bin/system_manager.py
+++ b/bin/system_manager.py
@@ -32,30 +32,39 @@
bus.add_signal_receiver(self.NewBusHandler,
dbus_interface = 'org.freedesktop.DBus',
signal_name = "NameOwnerChanged")
- bus.add_signal_receiver(self.CacheMeHandler,
- signal_name = 'CacheMe', path_keyword='path',interface_keyword='interface')
bus.add_signal_receiver(self.HeartbeatHandler, signal_name = "Heartbeat")
+ bus.add_signal_receiver(self.SystemStateHandler,signal_name = "GotoSystemState")
- try:
- # launch dbus object processes
- for bus_name in System.SYSTEM_CONFIG.keys():
+ self.current_state = ""
+ self.system_states = {}
+ self.IPMI_ID_LOOKUP = {}
+ for bus_name in System.SYSTEM_CONFIG.keys():
+ sys_state = System.SYSTEM_CONFIG[bus_name]['system_state']
+ if (self.system_states.has_key(sys_state) == False):
+ self.system_states[sys_state] = []
+ self.system_states[sys_state].append(bus_name)
+ self.SystemStateHandler("INIT")
+ print "SystemManager Init Done"
+
+
+ def SystemStateHandler(self,state_name):
+ print "Running System State: "+state_name
+ if (self.system_states.has_key(state_name)):
+ for bus_name in self.system_states[state_name]:
self.start_process(bus_name)
- except Exception as e:
- ## TODO: error handling
- pass
- ## Add poll for heartbeat
- GObject.timeout_add(HEARTBEAT_CHECK_INTERVAL, self.heartbeat_check)
+ if (state_name == "INIT"):
+ ## Add poll for heartbeat
+ GObject.timeout_add(HEARTBEAT_CHECK_INTERVAL, self.heartbeat_check)
+ if (System.ENTER_STATE_CALLBACK.has_key(state_name)):
+ cb = System.ENTER_STATE_CALLBACK[state_name]
+ obj = bus.get_object(cb['bus_name'],cb['obj_name'])
+ method = obj.get_dbus_method(cb['method_name'],cb['interface_name'])
+ method()
- def CacheMeHandler(self,busname,path=None,interface=None):
- #interface_name = 'org.openbmc.Fru'
- print "CacheME: "+busname+","+path+","+interface
- data = {}
- cache = System.CACHED_INTERFACES.has_key(interface)
- self.property_manager.saveProperties(busname,path,interface,cache,data)
-
-
+ current_state = state_name
+
def start_process(self,bus_name):
if (System.SYSTEM_CONFIG[bus_name]['start_process'] == True):
process_name = System.BIN_PATH+System.SYSTEM_CONFIG[bus_name]['process_name']
@@ -64,16 +73,17 @@
for instance in System.SYSTEM_CONFIG[bus_name]['instances']:
cmdline.append(instance['name'])
try:
- print "Starting process: "+" ".join(cmdline)
+ print "Starting process: "+" ".join(cmdline)+": "+bus_name
System.SYSTEM_CONFIG[bus_name]['popen'] = subprocess.Popen(cmdline);
except Exception as e:
## TODO: error
print "Error starting process: "+" ".join(cmdline)
def heartbeat_check(self):
- print "heartbeat check"
+ #print "heartbeat check"
for bus_name in System.SYSTEM_CONFIG.keys():
- if (System.SYSTEM_CONFIG[bus_name]['start_process'] == True):
+ if (System.SYSTEM_CONFIG[bus_name]['start_process'] == True and
+ System.SYSTEM_CONFIG[bus_name].has_key('popen')):
## even if process doesn't request heartbeat check,
## make sure process is still alive
p = System.SYSTEM_CONFIG[bus_name]['popen']
@@ -97,44 +107,50 @@
self.start_process(bus_name)
else:
System.SYSTEM_CONFIG[bus_name]['heartbeat_count'] = 0
- print "Heartbeat ok: "+bus_name
+ #print "Heartbeat ok: "+bus_name
return True
def HeartbeatHandler(self,bus_name):
+ #print "Heartbeat seen: "+bus_name
System.SYSTEM_CONFIG[bus_name]['heartbeat_count']=1
def NewBusHandler(self, bus_name, a, b):
if (len(b) > 0 and bus_name.find(Openbmc.BUS_PREFIX) == 0):
if (System.SYSTEM_CONFIG.has_key(bus_name)):
System.SYSTEM_CONFIG[bus_name]['heartbeat_count'] = 0
- obj_root = "/"+bus_name.replace('.','/')
- obj_paths = []
+ objects = {}
+ Openbmc.get_objs(bus,bus_name,Openbmc.OBJ_PREFIX,objects)
+
+ for instance_name in objects.keys():
+ obj_path = objects[instance_name]['PATH']
+ for instance in System.SYSTEM_CONFIG[bus_name]['instances']:
+ if (instance.has_key('properties') and instance['name'] == instance_name):
+ props = instance['properties']
+ print "Load Properties: "+obj_path
+ self.property_manager.loadProperties(bus_name,obj_path,props)
+ ## create a lookup for ipmi id to object path
+ if (props.has_key('org.openbmc.SensorValue')):
+ if (props['org.openbmc.SensorValue'].has_key('ipmi_id')):
+ ipmi_id = props['org.openbmc.SensorValue']['ipmi_id']
+ ## TODO: check for duplicate ipmi id
+ self.IPMI_ID_LOOKUP[ipmi_id]=[bus_name,obj_path]
- ## Loads object properties from system config file
- ## then overlays saved properties from file
- for instance in System.SYSTEM_CONFIG[bus_name]['instances']:
- obj_path = obj_root+'/'+instance['name']
- obj_paths.append(obj_path)
- if (instance.has_key('properties')):
- print "load props: "+obj_path
- self.property_manager.loadProperties(bus_name,obj_path, instance['properties'])
-
- ## scan all used interfaces and get interfaces with init method
-
-
- ## After object properties are setup, call init method if requested
- #if (System.SYSTEM_CONFIG[bus_name].has_key('init_methods')):
- for obj_path in obj_paths:
- obj = bus.get_object(bus_name,obj_path)
- methods = Openbmc.get_methods(obj)
- for intf_name in methods.keys():
- if (methods[intf_name].has_key('init')):
- intf = dbus.Interface(obj,intf_name)
- print "Calling init: " +intf_name
- intf.init()
-
-
+ ## If object has an init method, call it
+ for init_intf in objects[instance_name]['INIT']:
+ obj = bus.get_object(bus_name,obj_path)
+ intf = dbus.Interface(obj,init_intf)
+ print "Calling init method: " +obj_path+" : "+init_intf
+ intf.init()
+#
+ @dbus.service.method(DBUS_NAME,
+ in_signature='y', out_signature='ss')
+ def getObjFromIpmi(self,ipmi_id):
+ obj_path = ""
+ ## TODO: handle lookup failing
+ if (self.IPMI_ID_LOOKUP.has_key(ipmi_id) == True):
+ obj_info = self.IPMI_ID_LOOKUP[ipmi_id]
+ return obj_info
@dbus.service.method(DBUS_NAME,
in_signature='s', out_signature='sis')