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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
|
'''This contains all Bcfg2 Tool modules'''
__revision__ = '$Revision$'
__all__ = ["Action", "APT", "Blast", "Chkconfig", "DebInit", "Encap", "launchd",
"Portage", "POSIX", "RPM", "RcUpdate", "SMF", "SYSV", "Yum"]
import os, popen2, stat, sys, Bcfg2.Client.XML
class toolInstantiationError(Exception):
'''This error is called if the toolset cannot be instantiated'''
pass
class readonlypipe(popen2.Popen4):
'''This pipe sets up stdin --> /dev/null'''
def __init__(self, cmd, bufsize=-1):
popen2._cleanup()
c2pread, c2pwrite = os.pipe()
null = open('/dev/null', 'w+')
self.pid = os.fork()
if self.pid == 0:
# Child
os.dup2(null.fileno(), sys.__stdin__.fileno())
#os.dup2(p2cread, 0)
os.dup2(c2pwrite, 1)
os.dup2(c2pwrite, 2)
self._run_child(cmd)
os.close(c2pwrite)
self.fromchild = os.fdopen(c2pread, 'r', bufsize)
popen2._active.append(self)
class executor:
'''this class runs stuff for us'''
def __init__(self, logger):
self.logger = logger
def run(self, command):
'''Run a command in a pipe dealing with stdout buffer overloads'''
self.logger.debug('> %s' % command)
runpipe = readonlypipe(command, bufsize=16384)
output = []
try:#macosx doesn't like this
runpipe.fromchild.flush()
except IOError:
pass
line = runpipe.fromchild.readline()
while line:
if len(line) > 0:
self.logger.debug('< %s' % line[:-1])
output.append(line[:-1])
line = runpipe.fromchild.readline()
cmdstat = runpipe.poll()
return (cmdstat, output)
class Tool:
'''All tools subclass this. It defines all interfaces that need to be defined'''
__name__ = 'Tool'
__execs__ = []
__handles__ = []
__req__ = {}
__important__ = []
def __init__(self, logger, setup, config, states):
self.setup = setup
self.logger = logger
if not hasattr(self, '__ireq__'):
self.__ireq__ = self.__req__
self.config = config
self.cmd = executor(logger)
self.states = states
self.modified = []
self.extra = []
self.handled = [entry for struct in self.config for entry in struct \
if self.handlesEntry(entry)]
for filename in self.__execs__:
try:
mode = stat.S_IMODE(os.stat(filename)[stat.ST_MODE])
if mode & stat.S_IEXEC != stat.S_IEXEC:
self.logger.debug("%s: %s not executable" % \
(self.__name__, filename))
raise toolInstantiationError
except OSError:
raise toolInstantiationError
except:
self.logger.debug("%s failed" % filename, exc_info=1)
raise toolInstantiationError
def BundleUpdated(self, _):
'''This callback is used when bundle updates occur'''
return
def BundleNotUpdated(self, _):
'''This callback is used when a bundle is not updated'''
return
def Inventory(self, structures=[]):
'''Dispatch verify calls to underlying methods'''
if not structures:
structures = self.config.getchildren()
for (struct, entry) in [(struct, entry) for struct in structures \
for entry in struct.getchildren() \
if self.canVerify(entry)]:
try:
func = getattr(self, "Verify%s" % (entry.tag))
self.states[entry] = func(entry, self.buildModlist(entry, struct))
except:
self.logger.error(
"Unexpected failure of verification method for entry type %s" \
% (entry.tag), exc_info=1)
self.extra = self.FindExtra()
def Install(self, entries):
'''Install all entries in sublist'''
for entry in entries:
try:
func = getattr(self, "Install%s" % (entry.tag))
self.states[entry] = func(entry)
self.modified.append(entry)
except:
self.logger.error("Unexpected failure of install method for entry type %s" \
% (entry.tag), exc_info=1)
def Remove(self, entries):
'''Remove specified extra entries'''
pass
def getSupportedEntries(self):
'''return a list of supported entries'''
return [entry for struct in self.config.getchildren() for entry in struct.getchildren() \
if self.handlesEntry(entry)]
def handlesEntry(self, entry):
'''return if entry is handled by this Tool'''
return (entry.tag, entry.get('type')) in self.__handles__
def buildModlist(self, entry, struct):
'''Build a list of potentially modified POSIX paths for this entry'''
if entry.tag != 'Package' or struct.tag != 'Bundle':
return []
return [sentry.get('name') for sentry in struct if sentry.tag in \
['ConfigFile', 'SymLink', 'Directory']]
def canVerify(self, entry):
'''test if entry has enough information to be verified'''
if not self.handlesEntry(entry):
return False
if [attr for attr in self.__req__[entry.tag] if attr not in entry.attrib]:
self.logger.error("Incomplete information for entry %s:%s; cannot verify" \
% (entry.tag, entry.get('name')))
return False
return True
def FindExtra(self):
'''Return a list of extra entries'''
return []
def canInstall(self, entry):
'''test if entry has enough information to be installed'''
if not self.handlesEntry(entry):
return False
if [attr for attr in self.__ireq__[entry.tag] if attr not in entry.attrib]:
self.logger.error("Incomplete information for entry %s:%s; cannot install" \
% (entry.tag, entry.get('name')))
return False
return True
class PkgTool(Tool):
'''PkgTool provides a one-pass install with fallback for use with packaging systems'''
pkgtool = ('echo %s', ('%s', ['name']))
pkgtype = 'echo'
__name__ = 'PkgTool'
def __init__(self, logger, setup, config, states):
Tool.__init__(self, logger, setup, config, states)
self.installed = {}
self.Remove = self.RemovePackages
self.FindExtra = self.FindExtraPackages
self.RefreshPackages()
def VerifyPackage(self, dummy, _):
'''Dummy verification method'''
return False
def Install(self, packages):
'''Run a one-pass install, followed by single pkg installs in case of failure'''
self.logger.info("Trying single pass package install for pkgtype %s" % \
self.pkgtype)
data = [tuple([pkg.get(field) for field in self.pkgtool[1][1]]) for pkg in packages]
pkgargs = " ".join([self.pkgtool[1][0] % datum for datum in data])
self.logger.debug("Installing packages: :%s:" % pkgargs)
self.logger.debug("Running command ::%s::" % (self.pkgtool[0] % pkgargs))
cmdrc = self.cmd.run(self.pkgtool[0] % pkgargs)[0]
if cmdrc == 0:
self.logger.info("Single Pass Succeded")
# set all package states to true and flush workqueues
pkgnames = [pkg.get('name') for pkg in packages]
for entry in [entry for entry in self.states.keys()
if entry.tag == 'Package' and entry.get('type') == self.pkgtype
and entry.get('name') in pkgnames]:
self.logger.debug('Setting state to true for pkg %s' % (entry.get('name')))
self.states[entry] = True
self.RefreshPackages()
else:
self.logger.error("Single Pass Failed")
# do single pass installs
self.RefreshPackages()
for pkg in packages:
# handle state tracking updates
if self.VerifyPackage(pkg, []):
self.logger.info("Forcing state to true for pkg %s" % (pkg.get('name')))
self.states[pkg] = True
else:
self.logger.info("Installing pkg %s version %s" %
(pkg.get('name'), pkg.get('version')))
cmdrc = self.cmd.run(self.pkgtool[0] %
(self.pkgtool[1][0] %
tuple([pkg.get(field) for field in self.pkgtool[1][1]])))
if cmdrc[0] == 0:
self.states[pkg] = True
else:
self.logger.error("Failed to install package %s" % (pkg.get('name')))
for entry in [ent for ent in packages if self.states[ent]]:
self.modified.append(entry)
def RefreshPackages(self):
'''Dummy state refresh method'''
pass
def RemovePackages(self, packages):
'''Dummy implementation of package removal method'''
pass
def FindExtraPackages(self):
'''Find extra packages'''
packages = [entry.get('name') for entry in self.getSupportedEntries()]
extras = [data for data in self.installed.iteritems() if data[0] not in packages]
return [Bcfg2.Client.XML.Element('Package', name=name, \
type=self.pkgtype, version=version) \
for (name, version) in extras]
class SvcTool(Tool):
'''This class defines basic Service behavior'''
__name__ = 'SvcTool'
def BundleUpdated(self, bundle):
'''The Bundle has been updated'''
for entry in bundle:
if self.handlesEntry(entry):
if entry.get('status') == 'on':
self.logger.debug('Restarting service %s' % entry.get('name'))
rc = self.cmd.run('/etc/init.d/%s %s' % \
(entry.get('name'), entry.get('reload', 'reload')))[0]
else:
self.logger.debug('Stopping service %s' % entry.get('name'))
rc = self.cmd.run('/etc/init.d/%s stop' % (entry.get('name')))[0]
if rc:
self.logger.error("Failed to restart service %s" % (entry.get('name')))
|
