1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
#!/usr/bin/env python
# $Id$
from elementtree.ElementTree import XML
from syslog import syslog, LOG_ERR
class Generator(object):
'''This is a class that generators can be subclassed from.
__name__, __version__, and __author__ must be set for the module
__provides__ is a dictionary mapping listing the entity type and name to a function name
__requires__ is a set of external published data needed for operation
__croninterval__ is the frequency in second with which the Cron method should be executed'''
__name__ = None
__version__ = None
__croninterval__ = False
__provides__ = {}
__requires__ = []
def __init__(self, core, datastore):
self.core = core
self.data = "%s/%s"%(datastore,self.__name__)
self.__setup__()
def __setup__(self):
'''This method must be overloaded during subclassing.
All module specific setup, including all publication, occurs here.'''
def CompleteSetup(self):
self.ReadAll()
print "%s loaded"%(self.__version__)
def Cron(self):
'''Cron defines periodic tasks to maintain data coherence'''
pass
def Publish(self,key,value):
self.core.Publish(self.__name__,key,value)
def Read(self,key):
self.core.ReadValue(key)
def ReadAll(self):
self.external = {}
for field in self.__requires__:
self.external[field] = self.Read(field)
def GetMetadata(self,client,field):
'''GetMetadata returns current metadata file client. Field can be one of:
image, tags, bundles'''
pass
def Notify(self,region):
'''Generate change notification for region'''
pass
def GetProbes(self, metadata):
return []
def AcceptProbeData(self, client, probedata):
return
class FileBacked(object):
'''This object caches file data in memory.
HandleEvent is called whenever fam registers an event.
Index can parse the data into member data as required.
This object is meant to be used as a part of DirectoryBacked.'''
def __init__(self, name):
self.name = name
self.HandleEvent()
def HandleEvent(self, event=None):
try:
self.data = file(self.name).read()
except IOError, e:
syslog(LOG_ERR, "Failed to read file %s"%(self.name))
self.Index()
def Index(self):
pass
class DirectoryBacked(object):
'''This object is a coherent cache for a filesystem hierarchy of files.'''
__child__ = FileBacked
def __init__(self, name, fam):
self.name = name
self.fam = fam
self.entries = {}
self.inventory = False
fam.AddMonitor(name, self)
def __getitem__(self, key):
return self.entries[key]
def __iter__(self):
return self.entries.iteritems()
def AddEntry(self, name):
if self.entries.has_key(name):
print "got multiple adds"
else:
if ((name[-1] == '~') or (name[:2] == '.#') or (name == 'SCCS') or (name[-4:] == '.swp')):
return
self.entries[name] = self.__child__('%s/%s'%(self.name, name))
self.entries[name].HandleEvent()
def HandleEvent(self, event):
action = event.code2str()
if action == 'exists':
if event.filename != self.name:
self.AddEntry(event.filename)
elif action == 'created':
self.AddEntry(event.filename)
elif action == 'changed':
self.entries[event.filename].HandleEvent(event)
elif action == 'deleted':
if self.entries.has_key(event.filename):
del self.entries[event.filename]
elif action in ['endExist']:
pass
else:
print "Got unknown event %s %s %s"%(event.requestID, event.code2str(), event.filename)
class XMLFileBacked(FileBacked):
'''This object is a coherent cache for an XML file to be used as a part of DirectoryBacked.'''
__identifier__ = 'name'
def Index(self):
try:
a = XML(self.data)
except:
syslog(LOG_ERR, "Failed to parse %s"%(self.name))
return
self.label = a.attrib[self.__identifier__]
self.entries = a.getchildren()
def __iter__(self):
return iter(self.entries)
class SingleXMLFileBacked(XMLFileBacked):
'''This object is a coherent cache for an independent XML File.'''
def __init__(self,filename,fam):
XMLFileBacked.__init__(self, filename)
fam.AddMonitor(filename, self)
class ScopedXMLFile(SingleXMLFileBacked):
__containers__ = ['Class','Host','Image']
def StoreRecord(self, metadata, entry):
if not self.store.has_key(entry.tag):
self.store[entry.tag] = {}
if not self.store[entry.tag].has_key(entry.attrib['name']):
self.store[entry.tag][entry.attrib['name']] = []
self.store[entry.tag][entry.attrib['name']].append((metadata, entry))
def Index(self):
try:
a = XML(self.data)
except:
syslog(LOG_ERR, "Failed to parse %s"%(self.name))
return
self.store = {}
for e in a.getchildren():
if e.tag not in self.__containers__:
self.StoreRecord(('Global','all'), e)
else:
m = (e.tag, e.attrib['name'])
for entry in e.getchildren():
self.StoreRecord(m, entry)
# now to build the __provides__ table
self.__provides__ = {}
for key in self.store.keys():
self.__provides__[key] = {}
for j in self.store[key].keys():
self.__provides__[key][j] = self.FetchRecord
# also need to sort all leaf node lists
self.store[key][j].sort(self.Sort)
def Sort(self, m1, m2):
d = {('Global','Host'):-1,('Global','Image'):-1,("Global",'Class'):-1,
('Image', 'Global'):1, ('Image', 'Image'):0, ('Image', 'Host'):1, ('Image', 'Class'):-1,
('Class','Global'):1, ('Class', 'Image'):1, ('Class','Class'):0, ('Class', 'Host'): -1,
('Host', 'Global'):1, ('Host', 'Image'):1, ('Host','Class'):1, ('Host','Host'):0}
if d.has_key((m1[0][0], m2[0][0])):
return d[(m1[0][0],m2[0][0])]
def MatchMetadata(self, m, metadata):
if m[0] == 'Global':
return True
elif m[0] == 'Image':
if m[1] == metadata.image:
return True
elif m[0] == 'Class':
if m[1] in metadata.classes:
return True
elif m[0] == 'Host':
if m[1] == metadata.hostname:
return True
return False
def FetchRecord(self, entry, metadata):
l = self.store[entry.tag][entry.attrib['name']]
useful = filter(lambda x:self.MatchMetadata(x[0], metadata), l)
data = useful[-1][-1]
entry.attrib.update(data.attrib)
|
