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')