WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/pyCanDaemon/DaemonConfig.py


###########################################################
#
# Daemon configuration
#
###########################################################
import logging as log
import pickle
import hashlib
import os
import imp
import re
from ConfigParser import ConfigParser
import filters
import statespaces
 
from CanPktHandlerBase import CanPktHandlerBase
from CanPktHandler1 import CanPktHandler1
 
class DynamicModuleCfg:
    """Dynamic module manager"""
 
    modSubDir = None
    CHECKSUM_FILE = 'checksums'
    CHECKSUM_SECTION = 'SHA-1_CHECKSUMS'
   
    def __init__(self, modSubDir):
        self.modSubDir = modSubDir
        self.checkSumFile = modSubDir + '/' + self.CHECKSUM_FILE
        if not os.path.exists(self.checkSumFile):
            self.__createCsumsFile()
   
    def loadModule(self, className):
        pFileName = os.getcwd() + '/' + self.modSubDir + '/' + className + '.p'
        log.debug('Reading from ' + pFileName)
        fp = open(pFileName, 'r')
        p = pickle.Unpickler(fp)
        loadedMod = p.load()
        fp.close()
        if not self.__verifyCheckSum(className, pFileName):
            print 'Invalid checksum'
            return None
        else:
            return loadedMod
       
       
    def loadModules(self, config = None):
        subDirFiles = os.listdir(os.getcwd() + '/' + self.modSubDir)
        p = re.compile('.p$', re.IGNORECASE)
        modFiles = [elem for elem in subDirFiles if p.search(elem) is not None]
        modNames = []
        for mfName in modFiles:
            modNames.append(mfName.split('.')[0])
        log.debug('Found modules: ' + str(modNames))
        myMods = {}
        for mName in modNames:
            classObj = self.loadModule(mName)
            if classObj is not None:
                myMods[mName] = classObj
        return myMods
 
   
    def saveModule(self, className, classObj):
        pFileName = os.getcwd() + '/' + self.modSubDir + '/' + className + '.p'
        log.debug('Writing to ' + pFileName)
        fp = open(pFileName, 'w')
        p = pickle.Pickler(fp)
        p.dump(classObj)
        fp.close()
        self.__writeCheckSum(className, pFileName)
   
   
    def __doCheckSum(self, filename):
        f = open(filename, 'r')
        data = f.read()
        f.close()
        hasher = hashlib.sha1()
        hasher.update(data)
        digest = hasher.hexdigest()
        return digest
   
   
    def __createCsumsFile(self):
         csumsfile = open(self.checkSumFile, 'w')
         csumsfile.write('[' + self.CHECKSUM_SECTION + ']\n')
         csumsfile.close()
   
   
    def __writeCheckSum(self, entryname, filename):
        csumsfile = open(self.checkSumFile, 'r+')
        csumcfg = ConfigParser()
        csumcfg.readfp(csumsfile)
        digest = self.__doCheckSum(filename)
        csumcfg.set(self.CHECKSUM_SECTION, entryname, digest)
        csumsfile.seek(0)
        csumcfg.write(csumsfile)
       
       
    def __verifyCheckSum(self, entryname, filename):
        csumsfile = open(self.checkSumFile, 'r')
        csumcfg = ConfigParser()
        csumcfg.readfp(csumsfile)
        digest = csumcfg.get(self.CHECKSUM_SECTION, entryname)
        cur_digest = self.__doCheckSum(filename)
        log.debug('Old checksum ' + digest + '\nNew checksum: ' + cur_digest)
        if cur_digest == digest:
            return True
        return False
   
   
    def importModule(self, className, requiredAttributes):
        """Imports a given class from the module with the same name """
 
        codeFile = os.getcwd() + '/' + self.modSubDir + '/' + className + '.py'
        mod = imp.load_source(self.modSubDir + '.' + className, codeFile)
        newClass = eval('mod.' + className)()
       
        for ra in requiredAttributes:
            if not hasattr(newClass, ra):
                print className, ': missing required symbol \"' + ra + '\"'
                return None
       
        self.saveModule(className, newClass)
        return newClass
 
 
class FilterCfg:
    """Filter resource manager"""
   
    REQUIRED_ATTRIBUTES = ['ASSOCIATED_SPACES', 'DESCRIPTIVE_NAME',
                           'attach', 'detach', 'filter']
   
    dynamicModuleCfg = None
    FILTER_SUBDIR = 'filters'
    filterModules = {}
   
    def __init__(self):
        self.dynamicModuleCfg = DynamicModuleCfg(self.FILTER_SUBDIR)
   
    def loadFilter(self, name):
        newFilt = self.dynamicModuleCfg.loadModule(name)
        if newFilt is not None:
            self.filterModules[name] = newFilt
            return True
        else:
            return False
 
    def loadFilters(self, config = None):
        self.filterModules = self.dynamicModuleCfg.loadModules()
        for fM in self.filterModules:
            log.debug(fM)
 
    def __saveFilter(self, className, classObj):
        self.dynamicModuleCfg.saveModule(className, classObj)
 
    def saveFilters(self):
        for className in self.filterModules:
            self.__saveFilter(className, self.filterModules[className])
       
    def importFilter(self, className):
        """Imports a given filter definition """
        classObj = self.dynamicModuleCfg.importModule(className, self.REQUIRED_ATTRIBUTES)
        if classObj is not None:
            print 'Imported: ' + classObj.DESCRIPTIVE_NAME
            return True
        else:
            return False
       
 
class StateSpaceCfg:
    """State space resource manager"""
   
    REQUIRED_ATTRIBUTES = ['DESCRIPTIVE_NAME', 'RELATED_SPACES'
                           'load', 'reset', 'run', 'unload']
   
    dynamicModuleCfg = None
    FILTER_SUBDIR = 'statespaces'
    spaceModules = {}
   
    def __init__(self):
        self.dynamicModuleCfg = DynamicModuleCfg(self.FILTER_SUBDIR)
   
    def loadSpace(self, name):
        newSpace = self.dynamicModuleCfg.loadModule(name)
        if newSpace is not None:
            self.spaceModules[name] = newFilt
            return True
        else:
            return False
 
    def loadSpaces(self, config = None):
        self.spaceModules = self.dynamicModuleCfg.loadModules()
        for sM in self.spaceModules:
            log.debug(sM)
 
    def __saveSpace(self, className, classObj):
        self.dynamicModuleCfg.saveModule(className, classObj)
 
    def saveSpaces(self):
        for className in self.spaceModules:
            self.__saveSpace(className, self.spaceModules[className])
   
    def importSpace(self, name):
        """Imports a given state space definition file """
        classObj = self.dynamicModuleCfg.importModule(name, self.REQUIRED_ATTRIBUTES)
        if classObj is not None:
            print 'Imported: ' + classObj.DESCRIPTIVE_NAME
            return True
        else:
            return False
 
class DaemonConfig:
   
    stateSpaceCfg = None
    filterCfg = None
    pktHandler = None
   
    filterChain = []
    nodeInterfaces = []
    nodeInterfaceMap = {}
   
    def __init__ (self):
        self.filterCfg = FilterCfg()
        self.stateSpaceCfg = StateSpaceCfg()
        self.pktHandler = CanPktHandler1()
       
    def load(self):
        self.stateSpaceCfg.loadSpaces()
        self.stateSpaceCfg.loadFilters()
        __setupFilterBindings()
        __setupFilterChain()
   
    def save(self):
        self.stateSpaceCfg.saveSpaces()
        self.filterCfg.saveFilters()
       
    def __setupFilterChain(self):
        self.filterChain = ['DefaultFilter']
   
    def __setupFilterBindings(self):
        for f in self.filterCfg.filterModules.values():
            assocSpaces = []
            for s in f.ASSOCIATED_SPACES:
                if self.stateSpaceCfg.spaceModules.has_key(s):
                    assocSpaces.append(self.stateSpaceCfg.spaceModules[s])
                else:
                    print 'WARNING: Reference to undefined state space: ' + s
            setattr(f, '__ASSOCIATED_SPACES__', assocSpaces)
   
 
    def setupStateSpaceRelations(self):
        for sm in self.stateSpaceCfg.spaceModules:
            relatedSpaceNames = self.stateSpaceCfg.spaceModules[sm].RELATED_SPACES
            relatedSpaces = {}
            for rsname in relatedSpaceNames:
                relatedSpaces[rsname] = self.stateSpaceCfg.spaceModules[rsname]
            setattr(sm, '__RELATED_SPACES__', relatedSpaces)
           
 

Rev 748	Rev 749
1	###########################################################	1	###########################################################
2	#	2	#
3	# Daemon configuration	3	# Daemon configuration
4	#	4	#
5	###########################################################	5	###########################################################
6	import logging as log	6	import logging as log
7	import pickle	7	import pickle
8	import hashlib	8	import hashlib
9	import os	9	import os
10	import imp	10	import imp
11	import re	11	import re
12	from ConfigParser import ConfigParser	12	from ConfigParser import ConfigParser
13	import filters	13	import filters
14	import statespaces	14	import statespaces
15		-
-		15	from CanPktHandlerBase import CanPktHandlerBase
-		16	from CanPktHandler1 import CanPktHandler1
16		17
17	class DynamicModuleCfg:	18	class DynamicModuleCfg:
18	"""Dynamic module manager"""	19	"""Dynamic module manager"""
19		20
20	modSubDir = None	21	modSubDir = None
21	CHECKSUM_FILE = 'checksums'	22	CHECKSUM_FILE = 'checksums'
22	CHECKSUM_SECTION = 'SHA-1_CHECKSUMS'	23	CHECKSUM_SECTION = 'SHA-1_CHECKSUMS'
23		24
24	def __init__(self, modSubDir):	25	def __init__(self, modSubDir):
25	self.modSubDir = modSubDir	26	self.modSubDir = modSubDir
26	self.checkSumFile = modSubDir + '/' + self.CHECKSUM_FILE	27	self.checkSumFile = modSubDir + '/' + self.CHECKSUM_FILE
27	if not os.path.exists(self.checkSumFile):	28	if not os.path.exists(self.checkSumFile):
28	self.__createCsumsFile()	29	self.__createCsumsFile()
29		30
30	def loadModule(self, className):	31	def loadModule(self, className):
31	pFileName = os.getcwd() + '/' + self.modSubDir + '/' + className + '.p'	32	pFileName = os.getcwd() + '/' + self.modSubDir + '/' + className + '.p'
32	log.debug('Reading from ' + pFileName)	33	log.debug('Reading from ' + pFileName)
33	fp = open(pFileName, 'r')	34	fp = open(pFileName, 'r')
34	p = pickle.Unpickler(fp)	35	p = pickle.Unpickler(fp)
35	loadedMod = p.load()	36	loadedMod = p.load()
36	fp.close()	37	fp.close()
37	if not self.__verifyCheckSum(className, pFileName):	38	if not self.__verifyCheckSum(className, pFileName):
38	print 'Invalid checksum'	39	print 'Invalid checksum'
39	return None	40	return None
40	else:	41	else:
41	return loadedMod	42	return loadedMod
42		43
43		44
44	def loadModules(self, config = None):	45	def loadModules(self, config = None):
45	subDirFiles = os.listdir(os.getcwd() + '/' + self.modSubDir)	46	subDirFiles = os.listdir(os.getcwd() + '/' + self.modSubDir)
46	p = re.compile('.p$', re.IGNORECASE)	47	p = re.compile('.p$', re.IGNORECASE)
47	modFiles = [elem for elem in subDirFiles if p.search(elem) is not None]	48	modFiles = [elem for elem in subDirFiles if p.search(elem) is not None]
48	modNames = []	49	modNames = []
49	for mfName in modFiles:	50	for mfName in modFiles:
50	modNames.append(mfName.split('.')[0])	51	modNames.append(mfName.split('.')[0])
51	log.debug('Found modules: ' + str(modNames))	52	log.debug('Found modules: ' + str(modNames))
52	myMods = {}	53	myMods = {}
53	for mName in modNames:	54	for mName in modNames:
54	classObj = self.loadModule(mName)	55	classObj = self.loadModule(mName)
55	if classObj is not None:	56	if classObj is not None:
56	myMods[mName] = classObj	57	myMods[mName] = classObj
57	return myMods	58	return myMods
58		59
59		60
60	def saveModule(self, className, classObj):	61	def saveModule(self, className, classObj):
61	pFileName = os.getcwd() + '/' + self.modSubDir + '/' + className + '.p'	62	pFileName = os.getcwd() + '/' + self.modSubDir + '/' + className + '.p'
62	log.debug('Writing to ' + pFileName)	63	log.debug('Writing to ' + pFileName)
63	fp = open(pFileName, 'w')	64	fp = open(pFileName, 'w')
64	p = pickle.Pickler(fp)	65	p = pickle.Pickler(fp)
65	p.dump(classObj)	66	p.dump(classObj)
66	fp.close()	67	fp.close()
67	self.__writeCheckSum(className, pFileName)	68	self.__writeCheckSum(className, pFileName)
68		69
69		70
70	def __doCheckSum(self, filename):	71	def __doCheckSum(self, filename):
71	f = open(filename, 'r')	72	f = open(filename, 'r')
72	data = f.read()	73	data = f.read()
73	f.close()	74	f.close()
74	hasher = hashlib.sha1()	75	hasher = hashlib.sha1()
75	hasher.update(data)	76	hasher.update(data)
76	digest = hasher.hexdigest()	77	digest = hasher.hexdigest()
77	return digest	78	return digest
78		79
79		80
80	def __createCsumsFile(self):	81	def __createCsumsFile(self):
81	csumsfile = open(self.checkSumFile, 'w')	82	csumsfile = open(self.checkSumFile, 'w')
82	csumsfile.write('[' + self.CHECKSUM_SECTION + ']\n')	83	csumsfile.write('[' + self.CHECKSUM_SECTION + ']\n')
83	csumsfile.close()	84	csumsfile.close()
84		85
85		86
86	def __writeCheckSum(self, entryname, filename):	87	def __writeCheckSum(self, entryname, filename):
87	csumsfile = open(self.checkSumFile, 'r+')	88	csumsfile = open(self.checkSumFile, 'r+')
88	csumcfg = ConfigParser()	89	csumcfg = ConfigParser()
89	csumcfg.readfp(csumsfile)	90	csumcfg.readfp(csumsfile)
90	digest = self.__doCheckSum(filename)	91	digest = self.__doCheckSum(filename)
91	csumcfg.set(self.CHECKSUM_SECTION, entryname, digest)	92	csumcfg.set(self.CHECKSUM_SECTION, entryname, digest)
92	csumsfile.seek(0)	93	csumsfile.seek(0)
93	csumcfg.write(csumsfile)	94	csumcfg.write(csumsfile)
94		95
95		96
96	def __verifyCheckSum(self, entryname, filename):	97	def __verifyCheckSum(self, entryname, filename):
97	csumsfile = open(self.checkSumFile, 'r')	98	csumsfile = open(self.checkSumFile, 'r')
98	csumcfg = ConfigParser()	99	csumcfg = ConfigParser()
99	csumcfg.readfp(csumsfile)	100	csumcfg.readfp(csumsfile)
100	digest = csumcfg.get(self.CHECKSUM_SECTION, entryname)	101	digest = csumcfg.get(self.CHECKSUM_SECTION, entryname)
101	cur_digest = self.__doCheckSum(filename)	102	cur_digest = self.__doCheckSum(filename)
102	log.debug('Old checksum ' + digest + '\nNew checksum: ' + cur_digest)	103	log.debug('Old checksum ' + digest + '\nNew checksum: ' + cur_digest)
103	if cur_digest == digest:	104	if cur_digest == digest:
104	return True	105	return True
105	return False	106	return False
106		107
107		108
108	def importModule(self, className, requiredAttributes):	109	def importModule(self, className, requiredAttributes):
109	"""Imports a given class from the module with the same name """	110	"""Imports a given class from the module with the same name """
110		111
111	codeFile = os.getcwd() + '/' + self.modSubDir + '/' + className + '.py'	112	codeFile = os.getcwd() + '/' + self.modSubDir + '/' + className + '.py'
112	mod = imp.load_source(self.modSubDir + '.' + className, codeFile)	113	mod = imp.load_source(self.modSubDir + '.' + className, codeFile)
113	newClass = eval('mod.' + className)()	114	newClass = eval('mod.' + className)()
114		115
115	for ra in requiredAttributes:	116	for ra in requiredAttributes:
116	if not hasattr(newClass, ra):	117	if not hasattr(newClass, ra):
117	print className, ': missing required symbol \"' + ra + '\"'	118	print className, ': missing required symbol \"' + ra + '\"'
118	return None	119	return None
119		120
120	self.saveModule(className, newClass)	121	self.saveModule(className, newClass)
121	return newClass	122	return newClass
122		123
123		124
124	class FilterCfg:	125	class FilterCfg:
125	"""Filter resource manager"""	126	"""Filter resource manager"""
126		127
127	REQUIRED_ATTRIBUTES = ['ASSOCIATED_SPACES', 'DESCRIPTIVE_NAME',	128	REQUIRED_ATTRIBUTES = ['ASSOCIATED_SPACES', 'DESCRIPTIVE_NAME',
128	'attach', 'detach', 'filter']	129	'attach', 'detach', 'filter']
129		130
130	dynamicModuleCfg = None	131	dynamicModuleCfg = None
131	FILTER_SUBDIR = 'filters'	132	FILTER_SUBDIR = 'filters'
132	filterModules = {}	133	filterModules = {}
133		134
134	def __init__(self):	135	def __init__(self):
135	self.dynamicModuleCfg = DynamicModuleCfg(self.FILTER_SUBDIR)	136	self.dynamicModuleCfg = DynamicModuleCfg(self.FILTER_SUBDIR)
136		137
137	def loadFilter(self, name):	138	def loadFilter(self, name):
138	newFilt = self.dynamicModuleCfg.loadModule(name)	139	newFilt = self.dynamicModuleCfg.loadModule(name)
139	if newFilt is not None:	140	if newFilt is not None:
140	self.filterModules[name] = newFilt	141	self.filterModules[name] = newFilt
141	return True	142	return True
142	else:	143	else:
143	return False	144	return False
144		145
145	def loadFilters(self, config = None):	146	def loadFilters(self, config = None):
146	self.filterModules = self.dynamicModuleCfg.loadModules()	147	self.filterModules = self.dynamicModuleCfg.loadModules()
147	for fM in self.filterModules:	148	for fM in self.filterModules:
148	log.debug(fM)	149	log.debug(fM)
149		150
150	def __saveFilter(self, className, classObj):	151	def __saveFilter(self, className, classObj):
151	self.dynamicModuleCfg.saveModule(className, classObj)	152	self.dynamicModuleCfg.saveModule(className, classObj)
152		153
153	def saveFilters(self):	154	def saveFilters(self):
154	for className in self.filterModules:	155	for className in self.filterModules:
155	self.__saveFilter(className, self.filterModules[className])	156	self.__saveFilter(className, self.filterModules[className])
156		157
157	def importFilter(self, className):	158	def importFilter(self, className):
158	"""Imports a given filter definition """	159	"""Imports a given filter definition """
159	classObj = self.dynamicModuleCfg.importModule(className, self.REQUIRED_ATTRIBUTES)	160	classObj = self.dynamicModuleCfg.importModule(className, self.REQUIRED_ATTRIBUTES)
160	if classObj is not None:	161	if classObj is not None:
161	print 'Imported: ' + classObj.DESCRIPTIVE_NAME	162	print 'Imported: ' + classObj.DESCRIPTIVE_NAME
162	return True	163	return True
163	else:	164	else:
164	return False	165	return False
165		166
166		167
167	class StateSpaceCfg:	168	class StateSpaceCfg:
168	"""State space resource manager"""	169	"""State space resource manager"""
169		170
170	REQUIRED_ATTRIBUTES = ['DESCRIPTIVE_NAME', 'RELATED_SPACES'	171	REQUIRED_ATTRIBUTES = ['DESCRIPTIVE_NAME', 'RELATED_SPACES'
171	'load', 'reset', 'run', 'unload']	172	'load', 'reset', 'run', 'unload']
172		173
173	dynamicModuleCfg = None	174	dynamicModuleCfg = None
174	FILTER_SUBDIR = 'statespaces'	175	FILTER_SUBDIR = 'statespaces'
175	spaceModules = {}	176	spaceModules = {}
176		177
177	def __init__(self):	178	def __init__(self):
178	self.dynamicModuleCfg = DynamicModuleCfg(self.FILTER_SUBDIR)	179	self.dynamicModuleCfg = DynamicModuleCfg(self.FILTER_SUBDIR)
179		180
180	def loadSpace(self, name):	181	def loadSpace(self, name):
181	newSpace = self.dynamicModuleCfg.loadModule(name)	182	newSpace = self.dynamicModuleCfg.loadModule(name)
182	if newSpace is not None:	183	if newSpace is not None:
183	self.spaceModules[name] = newFilt	184	self.spaceModules[name] = newFilt
184	return True	185	return True
185	else:	186	else:
186	return False	187	return False
187		188
188	def loadSpaces(self, config = None):	189	def loadSpaces(self, config = None):
189	self.spaceModules = self.dynamicModuleCfg.loadModules()	190	self.spaceModules = self.dynamicModuleCfg.loadModules()
190	for sM in self.spaceModules:	191	for sM in self.spaceModules:
191	log.debug(sM)	192	log.debug(sM)
192		193
193	def __saveSpace(self, className, classObj):	194	def __saveSpace(self, className, classObj):
194	self.dynamicModuleCfg.saveModule(className, classObj)	195	self.dynamicModuleCfg.saveModule(className, classObj)
195		196
196	def saveSpaces(self):	197	def saveSpaces(self):
197	for className in self.spaceModules:	198	for className in self.spaceModules:
198	self.__saveSpace(className, self.spaceModules[className])	199	self.__saveSpace(className, self.spaceModules[className])
199		200
200	def importSpace(self, name):	201	def importSpace(self, name):
201	"""Imports a given state space definition file """	202	"""Imports a given state space definition file """
202	classObj = self.dynamicModuleCfg.importModule(name, self.REQUIRED_ATTRIBUTES)	203	classObj = self.dynamicModuleCfg.importModule(name, self.REQUIRED_ATTRIBUTES)
203	if classObj is not None:	204	if classObj is not None:
204	print 'Imported: ' + classObj.DESCRIPTIVE_NAME	205	print 'Imported: ' + classObj.DESCRIPTIVE_NAME
205	return True	206	return True
206	else:	207	else:
207	return False	208	return False
208		209
209	class DaemonConfig:	210	class DaemonConfig:
210		211
211	stateSpaceCfg = None	212	stateSpaceCfg = None
212	filterCfg = None	213	filterCfg = None
-		214	pktHandler = None
-		215
213	filterChain = []	216	filterChain = []
-		217	nodeInterfaces = []
-		218	nodeInterfaceMap = {}
214		219
215	def __init__ (self):	220	def __init__ (self):
216	self.filterCfg = FilterCfg()	221	self.filterCfg = FilterCfg()
217	self.stateSpaceCfg = StateSpaceCfg()	222	self.stateSpaceCfg = StateSpaceCfg()
-		223	self.pktHandler = CanPktHandler1()
-		224
-		225	def load(self):
-		226	self.stateSpaceCfg.loadSpaces()
-		227	self.stateSpaceCfg.loadFilters()
-		228	__setupFilterBindings()
-		229	__setupFilterChain()
-		230
-		231	def save(self):
-		232	self.stateSpaceCfg.saveSpaces()
-		233	self.filterCfg.saveFilters()
218		234
219	def ~~setupFilterChain~~(self):	235	def __setupFilterChain(self):
220	self.filterChain = ['DefaultFilter']	236	self.filterChain = ['DefaultFilter']
221		237
222	def ~~setupFilterBindings~~(self):	238	def __setupFilterBindings(self):
223	for f in self.filterCfg.filterModules.values():	239	for f in self.filterCfg.filterModules.values():
224	assocSpaces = []	240	assocSpaces = []
225	for s in f.ASSOCIATED_SPACES:	241	for s in f.ASSOCIATED_SPACES:
226	if self.stateSpaceCfg.spaceModules.has_key(s):	242	if self.stateSpaceCfg.spaceModules.has_key(s):
227	assocSpaces.append(self.stateSpaceCfg.spaceModules[s])	243	assocSpaces.append(self.stateSpaceCfg.spaceModules[s])
228	else:	244	else:
229	print 'WARNING: Reference to undefined state space: ' + s	245	print 'WARNING: Reference to undefined state space: ' + s
230	setattr(f, '__ASSOCIATED_SPACES__', assocSpaces)	246	setattr(f, '__ASSOCIATED_SPACES__', assocSpaces)
231		247
232		248
233	def setupStateSpaceRelations(self):	249	def setupStateSpaceRelations(self):
234	for sm in self.stateSpaceCfg.spaceModules:	250	for sm in self.stateSpaceCfg.spaceModules:
235	relatedSpaceNames = self.stateSpaceCfg.spaceModules[sm].RELATED_SPACES	251	relatedSpaceNames = self.stateSpaceCfg.spaceModules[sm].RELATED_SPACES
236	relatedSpaces = {}	252	relatedSpaces = {}
237	for rsname in relatedSpaceNames:	253	for rsname in relatedSpaceNames:
238	relatedSpaces[rsname] = self.stateSpaceCfg.spaceModules[rsname]	254	relatedSpaces[rsname] = self.stateSpaceCfg.spaceModules[rsname]
239	setattr(sm, '__RELATED_SPACES__', relatedSpaces)	255	setattr(sm, '__RELATED_SPACES__', relatedSpaces)
240		256
241		257

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/pyCanDaemon/DaemonConfig.py @ 749 – Rev 748 → 749