summaryrefslogtreecommitdiffstats
path: root/src/lib/Client/Tools/__init__.py
blob: 90d3cedbc81014aebef4ac625977d41c1923bf8d (plain)
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')))