diff --git a/bin/Barreleye.py b/bin/Barreleye.py
index ce24a0b..7d0bf12 100644
--- a/bin/Barreleye.py
+++ b/bin/Barreleye.py
@@ -2,20 +2,61 @@
 import dbus
 import Openbmc
 
+CACHED_INTERFACES = {
+	'org.openbmc.Fru' : True
+}
+
 SYSTEM_CONFIG = {}
 
+SYSTEM_CONFIG['org.openbmc.managers.Sensors'] = {
+		'exe_name' : 'bin/sensor_manager.py',
+		'heartbeat' : 'no',
+		'rest_name' : 'sensors',
+		'instances' : [	
+			{
+				'name' : 'Barreleye',
+				'user_label': 'Sensor Manager',
+			}
+		]
+	}
+
+#SYSTEM_CONFIG['org.openbmc.managers.Frus'] = {
+#		'exe_name' : 'bin/fru_manager.py',
+#		'heartbeat' : 'no',
+#		'rest_name' : 'frus',
+#		'instances' : [	
+#			{
+#				'name' : 'Barreleye',
+#				'user_label': 'Fru Manager',
+#			}
+#		]
+#	}
+
+
 SYSTEM_CONFIG['org.openbmc.loggers.EventLogger'] = {
 		'exe_name' : 'bin/eventlogger.py',
 		'heartbeat' : 'no',
 		'rest_name' : 'events',
 		'instances' : [	
 			{
-				'name' : 'Chassis',
-				'user_label': 'Chassis Control',
+				'name' : 'Barreleye',
+				'user_label': 'Event Logger',
 			}
 		]
 	}
 
+SYSTEM_CONFIG['org.openbmc.managers.IpmiTranslator'] = {
+		'exe_name' : 'bin/ipmi_translator.py',
+		'heartbeat' : 'no',
+		'instances' : [	
+			{
+				'name' : 'Barreleye',
+				'user_label': 'IPMI Translator',
+			}
+		]
+	}
+
+
 SYSTEM_CONFIG['org.openbmc.control.Power'] = {
 		'exe_name' : 'bin/power_control.exe',
 		'heartbeat' : 'yes',
@@ -30,35 +71,41 @@
 SYSTEM_CONFIG['org.openbmc.sensors.Temperature.Ambient'] = {
 		'exe_name' : 'bin/sensor_ambient.exe',
 		'heartbeat' : 'yes',
+		'init_methods' : ['org.openbmc.SensorInteger'],
+		'poll_interval': 5000,    
 		'instances' : [	
 			{
 				'name' : 'AmbientTemperature1',
 				'user_label': 'Ambient Temperature 1',
-				'parameters': ['/dev/i2c0','0xA0'],
-				'poll_interval': 5000,     
+				'sensor_id' : 41,
 				'properties' : { 
 					'org.openbmc.SensorIntegerThreshold' : {
 						'lower_critical': 5,
 						'lower_warning' : 10,
 						'upper_warning' : 15,
 						'upper_critical': 20
+					},
+					'org.openbmc.SensorI2c' : {
+						'dev_path' : '/dev/i2c/i2c0',
+						'address' : '0xA0'
 					}
 				}
 			},
 			{
 				'name' : 'AmbientTemperature2',
 				'user_label': 'Ambient Temperature 2',
-				'parameters': ['/dev/i2c0','0xA2'],
-				'poll_interval': 5000,    
  				'properties' : { 
 					'org.openbmc.SensorIntegerThreshold' : {
 						'lower_critical': 5,
 						'lower_warning' : 10,
 						'upper_warning' : 15,
 						'upper_critical': 20
+					},
+					'org.openbmc.SensorI2c' : {
+						'dev_path' : '/dev/i2c/i2c0',
+						'address' : '0xA2'
 					}
 				}
-     
 			}
 		]
 	}
@@ -79,6 +126,7 @@
 			{
 				'name' : 'HostStatus1',
 				'user_label': 'Host Status',
+				'sensor_id' : 43,
 			}
 		]
 	}
@@ -204,13 +252,50 @@
 		]
 	}
 
+SYSTEM_CONFIG['org.openbmc.frus.Board'] = {
+		'exe_name' : 'bin/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'] = {
 		'exe_name' : 'bin/fru_generic.exe',
 		'heartbeat' : 'no',
-		'instances' : [	
+		'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' : 'DIMM0',
 				'user_label': 'DIMM A0 Slot 0',
+				'fru_id' : 12,
 				'properties' : { 
 					'org.openbmc.Fru' : {
 						'label' : 'DIMM0',
diff --git a/bin/Openbmc.py b/bin/Openbmc.py
index c250bdf..ffa38dd 100644
--- a/bin/Openbmc.py
+++ b/bin/Openbmc.py
@@ -5,17 +5,56 @@
 
 
 FRU_TYPES = {
-	'CPU' : dbus.Byte(1),
-	'DIMM' : dbus.Byte(2),
-	'BACKPLANE' : dbus.Byte(3),
-	'RISER_CARD' : dbus.Byte(4),
-	'FAN' : dbus.Byte(4)
+	'CPU' : 1,
+	'DIMM' : 2,
+	'BACKPLANE' : 3,
+	'RISER_CARD' : 4,
+	'FAN' : 5
 }
-
 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']
 }
-	
+
+class DbusProperty:
+	def __init__(self,name,value):
+		self.dbusBaseType = {
+			'dbus.Byte' : 'int',
+			'dbus.Float' : '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.value = None
+		try: 
+			self.value = eval(self.dbusBaseType[self.dbusType]+"(value)")
+		except:
+			raise Exception("Unknown dbus type: "+self.dbusType)
+
+	def changeValue(self,value):
+		try: 
+			self.value = eval(self.dbusBaseType[self.dbusType]+"(value)")
+		except:
+			raise Exception("Unknown dbus type: "+self.dbusType)
+
+
+	def getName(self):
+		return self.name
+	def getValue(self):
+		e = self.dbusType+"(self.value)"
+		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 __str__(self):
+		return self.dbusType+":"+str(self.value)
diff --git a/bin/chassis_control.py b/bin/chassis_control.py
index c319527..ccea354 100644
--- a/bin/chassis_control.py
+++ b/bin/chassis_control.py
@@ -15,10 +15,15 @@
 class ChassisControlObject(dbus.service.Object):
 	def __init__(self,bus,name):
 		self.dbus_objects = { }
+
+		## 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' } ]
+			'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.power_sequence = 0
 		dbus.service.Object.__init__(self,bus,name)
@@ -26,12 +31,16 @@
 		try: 
 			for bus_name in self.dbus_busses.keys():
 				self.request_name(bus_name,"",bus_name)
-			bus.add_signal_receiver(self.request_name,
-					dbus_interface = 'org.freedesktop.DBus', 
-					signal_name = "NameOwnerChanged")
-		except dbus.exceptions.DBusException, e:
-			# TODO: not sure what to do if can't find other services
-			print e
+
+		except:
+			## its ok if this fails.  hotplug will detect too
+			print "Warning: One of processes not started yet."
+			pass
+
+		## 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", 
@@ -45,12 +54,13 @@
 	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']
 					obj =  bus.get_object(bus_name,obj_path+"/"+inst_name)
-					print "Interface:  "+inst_name+","+objs['intf']
 					self.dbus_objects[inst_name] = dbus.Interface(obj, objs['intf'])
 	
 
diff --git a/bin/eventlogger.py b/bin/eventlogger.py
new file mode 100644
index 0000000..113bd03
--- /dev/null
+++ b/bin/eventlogger.py
@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+
+import sys
+import gobject
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+import syslog
+import json
+
+DBUS_NAME = 'org.openbmc.loggers.EventLogger'
+OBJ_NAME = '/org/openbmc/loggers/EventLogger/'+sys.argv[1]
+
+class EventLogger(dbus.service.Object):
+	def __init__(self,bus,name):
+		dbus.service.Object.__init__(self,bus,name)
+		bus = dbus.SessionBus()
+		syslog.openlog('openbmc')
+
+		bus.add_signal_receiver(self.event_log_signal_handler, 
+					dbus_interface = "org.openbmc.EventLog", signal_name = "EventLog" )
+
+	## Signal handler
+	def event_log_signal_handler(self,message):
+		syslog.syslog(json.dumps(message))
+
+if __name__ == '__main__':
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+    bus = dbus.SessionBus()
+    name = dbus.service.BusName(DBUS_NAME, bus)
+    obj = EventLogger(bus, OBJ_NAME)
+    mainloop = gobject.MainLoop()
+    
+    print "Running EventLogger"
+    mainloop.run()
+
diff --git a/bin/ipmi_bt.py b/bin/ipmi_bt.py
new file mode 100644
index 0000000..8e4566e
--- /dev/null
+++ b/bin/ipmi_bt.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+import sys
+import subprocess
+import gobject
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+import xml.etree.ElementTree as ET
+
+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,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)
+
+
+if __name__ == '__main__':
+
+	cmd = sys.argv[2]
+	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)
+		
+
+    #mainloop.run()
+
diff --git a/bin/ipmi_translator.py b/bin/ipmi_translator.py
new file mode 100644
index 0000000..ec56057
--- /dev/null
+++ b/bin/ipmi_translator.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python
+
+import sys
+import subprocess
+import gobject
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+import xml.etree.ElementTree as ET
+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)
+		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)
+			PropertyManager.saveProperties(bus,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]
+			data = { 'value' : value }
+			## save sensor value
+			## TODO:  need to accomodate any sensor interface
+			interface_name = 'org.openbmc.SensorInteger'
+			#cache = System.CACHED_INTERFACES.has_key(interface_name)
+			obj = bus.get_object(bus_name,obj_path)
+			intf = dbus.Interface(obj, interface_name)
+			#intf.setValue(value)
+			PropertyManager.saveProperties(bus,bus_name,obj_path,interface_name,cache,data)
+		else:
+			## TODO: error handling
+			pass
+
+	@dbus.service.method(DBUS_NAME,
+		in_signature='i', out_signature='i')
+	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)
+			print "value = "+str(val)
+
+		return val
+
+
+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/sensor_manager.py b/bin/sensor_manager.py
new file mode 100644
index 0000000..33feebf
--- /dev/null
+++ b/bin/sensor_manager.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python
+
+import sys
+import gobject
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+
+if (len(sys.argv) < 2):
+	print "Usage:  sensor_manager.py [system name]"
+	exit(1)
+
+import Openbmc
+
+DBUS_NAME = 'org.openbmc.managers.Sensors'
+OBJ_NAME = '/org/openbmc/managers/Sensors/'+sys.argv[1]
+
+class SensorManager(dbus.service.Object):
+	def __init__(self,bus,name):
+		dbus.service.Object.__init__(self,bus,name)
+		bus.add_signal_receiver(self.UpdateSensor,
+					dbus_interface = 'org.openbmc.SensorInteger', 
+					signal_name = 'Changed', path_keyword='path')
+		bus.add_signal_receiver(self.NormalThreshold,
+					dbus_interface = 'org.openbmc.SensorIntegerThreshold', 
+					signal_name = 'Normal', path_keyword='path')
+		bus.add_signal_receiver(self.WarningThreshold,
+					dbus_interface = 'org.openbmc.SensorIntegerThreshold', 
+					signal_name = 'Warning', path_keyword='path')
+		bus.add_signal_receiver(self.CriticalThreshold,
+					dbus_interface = 'org.openbmc.SensorIntegerThreshold', 
+					signal_name = 'Critical', path_keyword='path')
+
+		self.sensor_cache = {}
+		
+	@dbus.service.method(DBUS_NAME,
+		in_signature='s', out_signature='i')
+	def getSensor(self,path):
+		val = None
+		if (self.sensor_cache.has_key(path) == True):
+			val = self.sensor_cache[path]['value']
+		return val
+		
+	def UpdateSensor(self,value, units, path = None):
+		if (self.sensor_cache.has_key(path) == False):
+			self.sensor_cache[path] = {}
+		self.sensor_cache[path]['value'] = value
+		self.sensor_cache[path]['units'] = units
+
+	@dbus.service.signal(DBUS_NAME)
+	def CriticalThreshold(self, path = None):
+		print "Critical: "+path
+		if (self.sensor_cache.has_key(path) == False):
+			self.sensor_cache[path] = {}
+		self.sensor_cache[path]['threshold'] = "CRITICAL"
+
+
+	@dbus.service.signal(DBUS_NAME)
+	def WarningThreshold(self, path = None):
+		print "Warning: "+path
+		if (self.sensor_cache.has_key(path) == False):
+			self.sensor_cache[path] = {}
+		self.sensor_cache[path]['threshold'] = "WARNING"
+
+
+	@dbus.service.signal(DBUS_NAME)
+	def NormalThreshold(self, path = None):
+		print "Normal: "+path
+		if (self.sensor_cache.has_key(path) == False):
+			self.sensor_cache[path] = {}
+		self.sensor_cache[path]['threshold'] = "NORMAL"
+
+
+
+
+if __name__ == '__main__':
+    dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+    bus = dbus.SessionBus()
+    name = dbus.service.BusName(DBUS_NAME,bus)
+    obj = SensorManager(bus,OBJ_NAME)
+    mainloop = gobject.MainLoop()
+
+    print "Running Sensor Manager"
+    mainloop.run()
+
diff --git a/bin/system_manager.py b/bin/system_manager.py
index 7b902c2..3275dc9 100644
--- a/bin/system_manager.py
+++ b/bin/system_manager.py
@@ -6,7 +6,9 @@
 import dbus
 import dbus.service
 import dbus.mainloop.glib
-import xml.etree.ElementTree as ET
+#import xml.etree.ElementTree as ET
+import os
+import PropertyManager
 
 if (len(sys.argv) < 2):
 	print "Usage:  system_manager.py [system name]"
@@ -19,50 +21,47 @@
 OBJ_NAME = '/org/openbmc/managers/System'
 HEARTBEAT_CHECK_INTERVAL = 20000
 
-def findConfigInstance(bus_name,obj_path):
-	line = obj_path.split('/')
-	instance_name = line[len(line)-1]
-	if (System.SYSTEM_CONFIG.has_key(bus_name) == False):
-		return {}
-	for instance in System.SYSTEM_CONFIG[bus_name]['instances']:
-		if (instance['name'] == instance_name):
-			return instance
-
-def parseIntrospection(bus_name,obj_name,interfaces,init_interfaces):
-	obj = bus.get_object(bus_name, obj_name)
-	introspect_iface = dbus.Interface(obj,'org.freedesktop.DBus.Introspectable')
-	tree = ET.ElementTree(ET.fromstring(introspect_iface.Introspect()))
-	root = tree.getroot()
-	interfaces[obj_name] = []
-	init_interfaces[obj_name] = {}
-	for intf in root.iter('interface'):
-		intf_name = intf.attrib['name']
-		if (intf_name == 'org.freedesktop.DBus.ObjectManager'):
-			manager = dbus.Interface(obj,'org.freedesktop.DBus.ObjectManager')
-			for managed_obj in manager.GetManagedObjects():
-				parseIntrospection(bus_name,managed_obj,interfaces,init_interfaces)
-		elif (intf_name.find(Openbmc.BUS_PREFIX) == 0):
-			interfaces[obj_name].append(intf_name)
-			for method in intf.iter('method'):
-				if (method.attrib['name'] == 'init'):
-					#print "Init: "+obj_name+" : "+intf_name
-					init_interfaces[obj_name][intf_name]=1
-				
-
-
 
 class SystemManager(dbus.service.Object):
 	def __init__(self,bus,name):
 		dbus.service.Object.__init__(self,bus,name)
-		bus.add_signal_receiver(self.request_name,
+		#self.sensor_manager_running = False
+		#self.fru_manager_running = False
+		#self.inited = False
+		
+		## Signal handlers
+		bus.add_signal_receiver(self.NewBusHandler,
 					dbus_interface = 'org.freedesktop.DBus', 
 					signal_name = "NameOwnerChanged")
-		# launch dbus object processes
-		for bus_name in System.SYSTEM_CONFIG.keys():
-			self.start_process(bus_name)
+		#bus.add_signal_receiver(self.FruRunningHandler,
+		#			dbus_interface = 'org.openbmc.managers.Frus'
+		#			signal_name = "OpenBmcRunning")
+		#bus.add_signal_receiver(self.SensorRunningHandler,
+		#			dbus_interface = 'org.openbmc.managers.Sensors'
+		#			signal_name = "OpenBmcRunning")
+		bus.add_signal_receiver(self.CacheMeHandler,
+					signal_name = 'CacheMe', path_keyword='path',interface_keyword='interface')
 
+
+		try:
+			# launch dbus object processes
+			for bus_name in System.SYSTEM_CONFIG.keys():
+				self.start_process(bus_name)
+		except Exception as e:
+			## TODO: error handling
+			pass
+		
+		bus.add_signal_receiver(self.HeartbeatHandler, signal_name = "Heartbeat")
     		gobject.timeout_add(HEARTBEAT_CHECK_INTERVAL, self.heartbeat_check)
 
+	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)
+		PropertyManager.saveProperties(bus,busname,path,interface,cache,data)
+
+
 	def start_process(self,bus_name):
 		exe_name = System.SYSTEM_CONFIG[bus_name]['exe_name']
 		cmdline = [ ]
@@ -76,7 +75,6 @@
 			## TODO: error
 			print "Error starting process: "+" ".join(cmdline)
 
-
 	def heartbeat_check(self):
 		print "heartbeat check"
 		for bus_name in System.SYSTEM_CONFIG.keys():
@@ -88,10 +86,13 @@
 				print "Process for "+bus_name+" appears to be dead"
 				self.start_process(bus_name)
 
+			## process is alive, now check if heartbeat received
+			## during previous interval
 			elif (System.SYSTEM_CONFIG[bus_name]['heartbeat'] == 'yes'):
 				if (System.SYSTEM_CONFIG[bus_name]['heartbeat_count'] == 0):
 					print "Heartbeat error: "+bus_name
 					p = System.SYSTEM_CONFIG[bus_name]['popen']
+					## TODO: error checking
 					p.poll()
 					if (p.returncode == None):
 						print "Process must be hung, so killing"
@@ -104,61 +105,34 @@
 					
 		return True
 
-	def heartbeat_update(self,bus_name):
+	def HeartbeatHandler(self,bus_name):
 		System.SYSTEM_CONFIG[bus_name]['heartbeat_count']=1	
 
-	def setup_sensor(self,intf):
-		pass 
-
-	def request_name(self, bus_name, a, b):
+	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_name = "/"+bus_name.replace('.','/')
-				interfaces = {}
-				init_interfaces = {}
-				# introspect object to get used interfaces
-				parseIntrospection(bus_name,obj_name,interfaces,init_interfaces)
-				for obj_path in interfaces.keys():
-					# find instance in system config
-					instance = findConfigInstance(bus_name,obj_path)
-					for intf_name in interfaces[obj_path]:
-						self.initObject(bus_name,obj_path,intf_name,instance)
-					for init_intf in init_interfaces[obj_path].keys():
-						obj = bus.get_object(bus_name,obj_path)
-						intf = dbus.Interface(obj,init_intf)
-						intf.init()
+				obj_root = "/"+bus_name.replace('.','/')
+				obj_paths = []
+
+				## 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')):
+						PropertyManager.loadProperties(bus,bus_name,obj_path,												instance['properties'])
+
+				## 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:
+						for init_interface in System.SYSTEM_CONFIG[bus_name]['init_methods']:
+							obj = bus.get_object(bus_name,obj_path)
+							intf = dbus.Interface(obj,init_interface)
+							print "calling init:" +init_interface
+							intf.init()
 
 
-	def initObject(self,bus_name,obj_path,intf_name,instance):
-		obj = bus.get_object(bus_name,obj_path)
-		intf = dbus.Interface(obj,intf_name)
-		if (instance.has_key('properties')):
-			properties = dbus.Interface(obj, 'org.freedesktop.DBus.Properties')
-			for prop_intf in instance['properties']:
-				for prop in instance['properties'][prop_intf]:
-					value = instance['properties'][prop_intf][prop]
-					properties.Set(prop_intf,prop,value)
-
-		## TODO: fix this explicit check
-		if (intf_name == 'org.openbmc.Control' or intf_name == 'org.openbmc.SensorInteger'):
-			if (System.SYSTEM_CONFIG[bus_name]['heartbeat'] == 'yes'):
-				print "Add heartbeat: "+intf_name;
-				bus.add_signal_receiver(self.heartbeat_update,
-						dbus_interface = intf_name, 
-						signal_name = "Heartbeat")
-		
-			if (instance.has_key('parameters')):
-				intf.setConfigData(instance['parameters'])
-
-
-	@dbus.service.signal(DBUS_NAME)
-	def CriticalThreshold(self, obj):
-		print "Critical: "+obj
-
-	@dbus.service.signal(DBUS_NAME)
-	def WarningThreshold(self, obj):
-		print "Warning: "+obj
 
 	@dbus.service.method(DBUS_NAME,
 		in_signature='s', out_signature='sis')