hgext: fixup a couple missed file().read() instances

hgext/convert/monotone.py

@@ -1,358 +1,360 b''
 # monotone.py - monotone support for the convert extension
 #
 #  Copyright 2008, 2009 Mikkel Fahnoe Jorgensen <[e-mail]> and
 #  others
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 import os, re
 from mercurial import util
 from common import NoRepo, commit, converter_source, checktool
 from common import commandline
 from mercurial.i18n import _
 
 class monotone_source(converter_source, commandline):
     def __init__(self, ui, path=None, rev=None):
         converter_source.__init__(self, ui, path, rev)
         commandline.__init__(self, ui, 'mtn')
 
         self.ui = ui
         self.path = path
         self.automatestdio = False
         self.rev = rev
 
         norepo = NoRepo(_("%s does not look like a monotone repository")
                         % path)
         if not os.path.exists(os.path.join(path, '_MTN')):
             # Could be a monotone repository (SQLite db file)
             try:
-                header = file(path, 'rb').read(16)
+                f = file(path, 'rb')
+                header = f.read(16)
+                f.close()
             except:
                 header = ''
             if header != 'SQLite format 3\x00':
                 raise norepo
 
         # regular expressions for parsing monotone output
         space    = r'\s*'
         name     = r'\s+"((?:\\"|[^"])*)"\s*'
         value    = name
         revision = r'\s+\[(\w+)\]\s*'
         lines    = r'(?:.|\n)+'
 
         self.dir_re      = re.compile(space + "dir" + name)
         self.file_re     = re.compile(space + "file" + name +
                                       "content" + revision)
         self.add_file_re = re.compile(space + "add_file" + name +
                                       "content" + revision)
         self.patch_re    = re.compile(space + "patch" + name +
                                       "from" + revision + "to" + revision)
         self.rename_re   = re.compile(space + "rename" + name + "to" + name)
         self.delete_re   = re.compile(space + "delete" + name)
         self.tag_re      = re.compile(space + "tag" + name + "revision" +
                                       revision)
         self.cert_re     = re.compile(lines + space + "name" + name +
                                       "value" + value)
 
         attr = space + "file" + lines + space + "attr" + space
         self.attr_execute_re = re.compile(attr  + '"mtn:execute"' +
                                           space + '"true"')
 
         # cached data
         self.manifest_rev = None
         self.manifest = None
         self.files = None
         self.dirs  = None
 
         checktool('mtn', abort=False)
 
     def mtnrun(self, *args, **kwargs):
         if self.automatestdio:
             return self.mtnrunstdio(*args, **kwargs)
         else:
             return self.mtnrunsingle(*args, **kwargs)
 
     def mtnrunsingle(self, *args, **kwargs):
         kwargs['d'] = self.path
         return self.run0('automate', *args, **kwargs)
 
     def mtnrunstdio(self, *args, **kwargs):
         # Prepare the command in automate stdio format
         command = []
         for k, v in kwargs.iteritems():
             command.append("%s:%s" % (len(k), k))
             if v:
                 command.append("%s:%s" % (len(v), v))
         if command:
             command.insert(0, 'o')
             command.append('e')
 
         command.append('l')
         for arg in args:
             command += "%s:%s" % (len(arg), arg)
         command.append('e')
         command = ''.join(command)
 
         self.ui.debug("mtn: sending '%s'\n" % command)
         self.mtnwritefp.write(command)
         self.mtnwritefp.flush()
 
         return self.mtnstdioreadcommandoutput(command)
 
     def mtnstdioreadpacket(self):
         read = None
         commandnbr = ''
         while read != ':':
             read = self.mtnreadfp.read(1)
             if not read:
                 raise util.Abort(_('bad mtn packet - no end of commandnbr'))
             commandnbr += read
         commandnbr = commandnbr[:-1]
 
         stream = self.mtnreadfp.read(1)
         if stream not in 'mewptl':
             raise util.Abort(_('bad mtn packet - bad stream type %s' % stream))
 
         read = self.mtnreadfp.read(1)
         if read != ':':
             raise util.Abort(_('bad mtn packet - no divider before size'))
 
         read = None
         lengthstr = ''
         while read != ':':
             read = self.mtnreadfp.read(1)
             if not read:
                 raise util.Abort(_('bad mtn packet - no end of packet size'))
             lengthstr += read
         try:
             length = long(lengthstr[:-1])
         except TypeError:
             raise util.Abort(_('bad mtn packet - bad packet size %s')
                 % lengthstr)
 
         read = self.mtnreadfp.read(length)
         if len(read) != length:
             raise util.Abort(_("bad mtn packet - unable to read full packet "
                 "read %s of %s") % (len(read), length))
 
         return (commandnbr, stream, length, read)
 
     def mtnstdioreadcommandoutput(self, command):
         retval = []
         while True:
             commandnbr, stream, length, output = self.mtnstdioreadpacket()
             self.ui.debug('mtn: read packet %s:%s:%s\n' %
                 (commandnbr, stream, length))
 
             if stream == 'l':
                 # End of command
                 if output != '0':
                     raise util.Abort(_("mtn command '%s' returned %s") %
                         (command, output))
                 break
             elif stream in 'ew':
                 # Error, warning output
                 self.ui.warn(_('%s error:\n') % self.command)
                 self.ui.warn(output)
             elif stream == 'p':
                 # Progress messages
                 self.ui.debug('mtn: ' + output)
             elif stream == 'm':
                 # Main stream - command output
                 retval.append(output)
 
         return ''.join(retval)
 
     def mtnloadmanifest(self, rev):
         if self.manifest_rev == rev:
             return
         self.manifest = self.mtnrun("get_manifest_of", rev).split("\n\n")
         self.manifest_rev = rev
         self.files = {}
         self.dirs = {}
 
         for e in self.manifest:
             m = self.file_re.match(e)
             if m:
                 attr = ""
                 name = m.group(1)
                 node = m.group(2)
                 if self.attr_execute_re.match(e):
                     attr += "x"
                 self.files[name] = (node, attr)
             m = self.dir_re.match(e)
             if m:
                 self.dirs[m.group(1)] = True
 
     def mtnisfile(self, name, rev):
         # a non-file could be a directory or a deleted or renamed file
         self.mtnloadmanifest(rev)
         return name in self.files
 
     def mtnisdir(self, name, rev):
         self.mtnloadmanifest(rev)
         return name in self.dirs
 
     def mtngetcerts(self, rev):
         certs = {"author":"<missing>", "date":"<missing>",
             "changelog":"<missing>", "branch":"<missing>"}
         certlist = self.mtnrun("certs", rev)
         # mtn < 0.45:
         #   key "[e-mail]"
         # mtn >= 0.45:
         #   key [ff58a7ffb771907c4ff68995eada1c4da068d328]
         certlist = re.split('\n\n      key ["\[]', certlist)
         for e in certlist:
             m = self.cert_re.match(e)
             if m:
                 name, value = m.groups()
                 value = value.replace(r'\"', '"')
                 value = value.replace(r'\\', '\\')
                 certs[name] = value
         # Monotone may have subsecond dates: 2005-02-05T09:39:12.364306
         # and all times are stored in UTC
         certs["date"] = certs["date"].split('.')[0] + " UTC"
         return certs
 
     # implement the converter_source interface:
 
     def getheads(self):
         if not self.rev:
             return self.mtnrun("leaves").splitlines()
         else:
             return [self.rev]
 
     def getchanges(self, rev):
         #revision = self.mtncmd("get_revision %s" % rev).split("\n\n")
         revision = self.mtnrun("get_revision", rev).split("\n\n")
         files = {}
         ignoremove = {}
         renameddirs = []
         copies = {}
         for e in revision:
             m = self.add_file_re.match(e)
             if m:
                 files[m.group(1)] = rev
                 ignoremove[m.group(1)] = rev
             m = self.patch_re.match(e)
             if m:
                 files[m.group(1)] = rev
             # Delete/rename is handled later when the convert engine
             # discovers an IOError exception from getfile,
             # but only if we add the "from" file to the list of changes.
             m = self.delete_re.match(e)
             if m:
                 files[m.group(1)] = rev
             m = self.rename_re.match(e)
             if m:
                 toname = m.group(2)
                 fromname = m.group(1)
                 if self.mtnisfile(toname, rev):
                     ignoremove[toname] = 1
                     copies[toname] = fromname
                     files[toname] = rev
                     files[fromname] = rev
                 elif self.mtnisdir(toname, rev):
                     renameddirs.append((fromname, toname))
 
         # Directory renames can be handled only once we have recorded
         # all new files
         for fromdir, todir in renameddirs:
             renamed = {}
             for tofile in self.files:
                 if tofile in ignoremove:
                     continue
                 if tofile.startswith(todir + '/'):
                     renamed[tofile] = fromdir + tofile[len(todir):]
                     # Avoid chained moves like:
                     # d1(/a) => d3/d1(/a)
                     # d2 => d3
                     ignoremove[tofile] = 1
             for tofile, fromfile in renamed.items():
                 self.ui.debug (_("copying file in renamed directory "
                                  "from '%s' to '%s'")
                                % (fromfile, tofile), '\n')
                 files[tofile] = rev
                 copies[tofile] = fromfile
             for fromfile in renamed.values():
                 files[fromfile] = rev
 
         return (files.items(), copies)
 
     def getfile(self, name, rev):
         if not self.mtnisfile(name, rev):
             raise IOError() # file was deleted or renamed
         try:
             data = self.mtnrun("get_file_of", name, r=rev)
         except:
             raise IOError() # file was deleted or renamed
         self.mtnloadmanifest(rev)
         node, attr = self.files.get(name, (None, ""))
         return data, attr
 
     def getcommit(self, rev):
         extra = {}
         certs = self.mtngetcerts(rev)
         if certs.get('suspend') == certs["branch"]:
             extra['close'] = '1'
         return commit(
             author=certs["author"],
             date=util.datestr(util.strdate(certs["date"], "%Y-%m-%dT%H:%M:%S")),
             desc=certs["changelog"],
             rev=rev,
             parents=self.mtnrun("parents", rev).splitlines(),
             branch=certs["branch"],
             extra=extra)
 
     def gettags(self):
         tags = {}
         for e in self.mtnrun("tags").split("\n\n"):
             m = self.tag_re.match(e)
             if m:
                 tags[m.group(1)] = m.group(2)
         return tags
 
     def getchangedfiles(self, rev, i):
         # This function is only needed to support --filemap
         # ... and we don't support that
         raise NotImplementedError()
 
     def before(self):
         # Check if we have a new enough version to use automate stdio
         version = 0.0
         try:
             versionstr = self.mtnrunsingle("interface_version")
             version = float(versionstr)
         except Exception:
             raise util.Abort(_("unable to determine mtn automate interface "
                 "version"))
 
         if version >= 12.0:
             self.automatestdio = True
             self.ui.debug("mtn automate version %s - using automate stdio\n" %
                 version)
 
             # launch the long-running automate stdio process
             self.mtnwritefp, self.mtnreadfp = self._run2('automate', 'stdio',
                 '-d', self.path)
             # read the headers
             read = self.mtnreadfp.readline()
             if read != 'format-version: 2\n':
                 raise util.Abort(_('mtn automate stdio header unexpected: %s')
                     % read)
             while read != '\n':
                 read = self.mtnreadfp.readline()
                 if not read:
                     raise util.Abort(_("failed to reach end of mtn automate "
                         "stdio headers"))
         else:
             self.ui.debug("mtn automate version %s - not using automate stdio "
                 "(automate >= 12.0 - mtn >= 0.46 is needed)\n" % version)
 
     def after(self):
         if self.automatestdio:
             self.mtnwritefp.close()
             self.mtnwritefp = None
             self.mtnreadfp.close()
             self.mtnreadfp = None
 

hgext/inotify/linuxserver.py

@@ -1,441 +1,441 b''
 # linuxserver.py - inotify status server for linux
 #
 # Copyright 2006, 2007, 2008 Bryan O'Sullivan <[e-mail]>
 # Copyright 2007, 2008 Brendan Cully <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 from mercurial.i18n import _
 from mercurial import osutil, util
 import server
 import errno, os, select, stat, sys, time
 
 try:
     import linux as inotify
     from linux import watcher
 except ImportError:
     raise
 
 def walkrepodirs(dirstate, absroot):
     '''Iterate over all subdirectories of this repo.
     Exclude the .hg directory, any nested repos, and ignored dirs.'''
     def walkit(dirname, top):
         fullpath = server.join(absroot, dirname)
         try:
             for name, kind in osutil.listdir(fullpath):
                 if kind == stat.S_IFDIR:
                     if name == '.hg':
                         if not top:
                             return
                     else:
                         d = server.join(dirname, name)
                         if dirstate._ignore(d):
                             continue
                         for subdir in walkit(d, False):
                             yield subdir
         except OSError, err:
             if err.errno not in server.walk_ignored_errors:
                 raise
         yield fullpath
 
     return walkit('', True)
 
 def _explain_watch_limit(ui, dirstate, rootabs):
     path = '/proc/sys/fs/inotify/max_user_watches'
     try:
-        limit = int(file(path).read())
+        limit = int(util.readfile(path))
     except IOError, err:
         if err.errno != errno.ENOENT:
             raise
         raise util.Abort(_('this system does not seem to '
                            'support inotify'))
     ui.warn(_('*** the current per-user limit on the number '
               'of inotify watches is %s\n') % limit)
     ui.warn(_('*** this limit is too low to watch every '
               'directory in this repository\n'))
     ui.warn(_('*** counting directories: '))
     ndirs = len(list(walkrepodirs(dirstate, rootabs)))
     ui.warn(_('found %d\n') % ndirs)
     newlimit = min(limit, 1024)
     while newlimit < ((limit + ndirs) * 1.1):
         newlimit *= 2
     ui.warn(_('*** to raise the limit from %d to %d (run as root):\n') %
             (limit, newlimit))
     ui.warn(_('***  echo %d > %s\n') % (newlimit, path))
     raise util.Abort(_('cannot watch %s until inotify watch limit is raised')
                      % rootabs)
 
 class pollable(object):
     """
     Interface to support polling.
     The file descriptor returned by fileno() is registered to a polling
     object.
     Usage:
         Every tick, check if an event has happened since the last tick:
         * If yes, call handle_events
         * If no, call handle_timeout
     """
     poll_events = select.POLLIN
     instances = {}
     poll = select.poll()
 
     def fileno(self):
         raise NotImplementedError
 
     def handle_events(self, events):
         raise NotImplementedError
 
     def handle_timeout(self):
         raise NotImplementedError
 
     def shutdown(self):
         raise NotImplementedError
 
     def register(self, timeout):
         fd = self.fileno()
 
         pollable.poll.register(fd, pollable.poll_events)
         pollable.instances[fd] = self
 
         self.registered = True
         self.timeout = timeout
 
     def unregister(self):
         pollable.poll.unregister(self)
         self.registered = False
 
     @classmethod
     def run(cls):
         while True:
             timeout = None
             timeobj = None
             for obj in cls.instances.itervalues():
                 if obj.timeout is not None and (timeout is None
                                                 or obj.timeout < timeout):
                     timeout, timeobj = obj.timeout, obj
             try:
                 events = cls.poll.poll(timeout)
             except select.error, err:
                 if err.args[0] == errno.EINTR:
                     continue
                 raise
             if events:
                 by_fd = {}
                 for fd, event in events:
                     by_fd.setdefault(fd, []).append(event)
 
                 for fd, events in by_fd.iteritems():
                     cls.instances[fd].handle_pollevents(events)
 
             elif timeobj:
                 timeobj.handle_timeout()
 
 def eventaction(code):
     """
     Decorator to help handle events in repowatcher
     """
     def decorator(f):
         def wrapper(self, wpath):
             if code == 'm' and wpath in self.lastevent and \
                 self.lastevent[wpath] in 'cm':
                 return
             self.lastevent[wpath] = code
             self.timeout = 250
 
             f(self, wpath)
 
         wrapper.func_name = f.func_name
         return wrapper
     return decorator
 
 class repowatcher(server.repowatcher, pollable):
     """
     Watches inotify events
     """
     mask = (
         inotify.IN_ATTRIB |
         inotify.IN_CREATE |
         inotify.IN_DELETE |
         inotify.IN_DELETE_SELF |
         inotify.IN_MODIFY |
         inotify.IN_MOVED_FROM |
         inotify.IN_MOVED_TO |
         inotify.IN_MOVE_SELF |
         inotify.IN_ONLYDIR |
         inotify.IN_UNMOUNT |
         0)
 
     def __init__(self, ui, dirstate, root):
         server.repowatcher.__init__(self, ui, dirstate, root)
 
         self.lastevent = {}
         self.dirty = False
         try:
             self.watcher = watcher.watcher()
         except OSError, err:
             raise util.Abort(_('inotify service not available: %s') %
                              err.strerror)
         self.threshold = watcher.threshold(self.watcher)
         self.fileno = self.watcher.fileno
         self.register(timeout=None)
 
         self.handle_timeout()
         self.scan()
 
     def event_time(self):
         last = self.last_event
         now = time.time()
         self.last_event = now
 
         if last is None:
             return 'start'
         delta = now - last
         if delta < 5:
             return '+%.3f' % delta
         if delta < 50:
             return '+%.2f' % delta
         return '+%.1f' % delta
 
     def add_watch(self, path, mask):
         if not path:
             return
         if self.watcher.path(path) is None:
             if self.ui.debugflag:
                 self.ui.note(_('watching %r\n') % path[self.prefixlen:])
             try:
                 self.watcher.add(path, mask)
             except OSError, err:
                 if err.errno in (errno.ENOENT, errno.ENOTDIR):
                     return
                 if err.errno != errno.ENOSPC:
                     raise
                 _explain_watch_limit(self.ui, self.dirstate, self.wprefix)
 
     def setup(self):
         self.ui.note(_('watching directories under %r\n') % self.wprefix)
         self.add_watch(self.wprefix + '.hg', inotify.IN_DELETE)
 
     def scan(self, topdir=''):
         ds = self.dirstate._map.copy()
         self.add_watch(server.join(self.wprefix, topdir), self.mask)
         for root, dirs, files in server.walk(self.dirstate, self.wprefix,
                                              topdir):
             for d in dirs:
                 self.add_watch(server.join(root, d), self.mask)
             wroot = root[self.prefixlen:]
             for fn in files:
                 wfn = server.join(wroot, fn)
                 self.updatefile(wfn, self.getstat(wfn))
                 ds.pop(wfn, None)
         wtopdir = topdir
         if wtopdir and wtopdir[-1] != '/':
             wtopdir += '/'
         for wfn, state in ds.iteritems():
             if not wfn.startswith(wtopdir):
                 continue
             try:
                 st = self.stat(wfn)
             except OSError:
                 status = state[0]
                 self.deletefile(wfn, status)
             else:
                 self.updatefile(wfn, st)
         self.check_deleted('!')
         self.check_deleted('r')
 
     @eventaction('c')
     def created(self, wpath):
         if wpath == '.hgignore':
             self.update_hgignore()
         try:
             st = self.stat(wpath)
             if stat.S_ISREG(st[0]) or stat.S_ISLNK(st[0]):
                 self.updatefile(wpath, st)
         except OSError:
             pass
 
     @eventaction('m')
     def modified(self, wpath):
         if wpath == '.hgignore':
             self.update_hgignore()
         try:
             st = self.stat(wpath)
             if stat.S_ISREG(st[0]):
                 if self.dirstate[wpath] in 'lmn':
                     self.updatefile(wpath, st)
         except OSError:
             pass
 
     @eventaction('d')
     def deleted(self, wpath):
         if wpath == '.hgignore':
             self.update_hgignore()
         elif wpath.startswith('.hg/'):
             return
 
         self.deletefile(wpath, self.dirstate[wpath])
 
     def process_create(self, wpath, evt):
         if self.ui.debugflag:
             self.ui.note(_('%s event: created %s\n') %
                          (self.event_time(), wpath))
 
         if evt.mask & inotify.IN_ISDIR:
             self.scan(wpath)
         else:
             self.created(wpath)
 
     def process_delete(self, wpath, evt):
         if self.ui.debugflag:
             self.ui.note(_('%s event: deleted %s\n') %
                          (self.event_time(), wpath))
 
         if evt.mask & inotify.IN_ISDIR:
             tree = self.tree.dir(wpath)
             todelete = [wfn for wfn, ignore in tree.walk('?')]
             for fn in todelete:
                 self.deletefile(fn, '?')
             self.scan(wpath)
         else:
             self.deleted(wpath)
 
     def process_modify(self, wpath, evt):
         if self.ui.debugflag:
             self.ui.note(_('%s event: modified %s\n') %
                          (self.event_time(), wpath))
 
         if not (evt.mask & inotify.IN_ISDIR):
             self.modified(wpath)
 
     def process_unmount(self, evt):
         self.ui.warn(_('filesystem containing %s was unmounted\n') %
                      evt.fullpath)
         sys.exit(0)
 
     def handle_pollevents(self, events):
         if self.ui.debugflag:
             self.ui.note(_('%s readable: %d bytes\n') %
                          (self.event_time(), self.threshold.readable()))
         if not self.threshold():
             if self.registered:
                 if self.ui.debugflag:
                     self.ui.note(_('%s below threshold - unhooking\n') %
                                  (self.event_time()))
                 self.unregister()
                 self.timeout = 250
         else:
             self.read_events()
 
     def read_events(self, bufsize=None):
         events = self.watcher.read(bufsize)
         if self.ui.debugflag:
             self.ui.note(_('%s reading %d events\n') %
                          (self.event_time(), len(events)))
         for evt in events:
             if evt.fullpath == self.wprefix[:-1]:
                 # events on the root of the repository
                 # itself, e.g. permission changes or repository move
                 continue
             assert evt.fullpath.startswith(self.wprefix)
             wpath = evt.fullpath[self.prefixlen:]
 
             # paths have been normalized, wpath never ends with a '/'
 
             if wpath.startswith('.hg/') and evt.mask & inotify.IN_ISDIR:
                 # ignore subdirectories of .hg/ (merge, patches...)
                 continue
             if wpath == ".hg/wlock":
                 if evt.mask & inotify.IN_DELETE:
                     self.dirstate.invalidate()
                     self.dirty = False
                     self.scan()
                 elif evt.mask & inotify.IN_CREATE:
                     self.dirty = True
             else:
                 if self.dirty:
                     continue
 
                 if evt.mask & inotify.IN_UNMOUNT:
                     self.process_unmount(wpath, evt)
                 elif evt.mask & (inotify.IN_MODIFY | inotify.IN_ATTRIB):
                     self.process_modify(wpath, evt)
                 elif evt.mask & (inotify.IN_DELETE | inotify.IN_DELETE_SELF |
                                  inotify.IN_MOVED_FROM):
                     self.process_delete(wpath, evt)
                 elif evt.mask & (inotify.IN_CREATE | inotify.IN_MOVED_TO):
                     self.process_create(wpath, evt)
 
         self.lastevent.clear()
 
     def handle_timeout(self):
         if not self.registered:
             if self.ui.debugflag:
                 self.ui.note(_('%s hooking back up with %d bytes readable\n') %
                              (self.event_time(), self.threshold.readable()))
             self.read_events(0)
             self.register(timeout=None)
 
         self.timeout = None
 
     def shutdown(self):
         self.watcher.close()
 
     def debug(self):
         """
         Returns a sorted list of relatives paths currently watched,
         for debugging purposes.
         """
         return sorted(tuple[0][self.prefixlen:] for tuple in self.watcher)
 
 class socketlistener(server.socketlistener, pollable):
     """
     Listens for client queries on unix socket inotify.sock
     """
     def __init__(self, ui, root, repowatcher, timeout):
         server.socketlistener.__init__(self, ui, root, repowatcher, timeout)
         self.register(timeout=timeout)
 
     def handle_timeout(self):
         raise server.TimeoutException
 
     def handle_pollevents(self, events):
         for e in events:
             self.accept_connection()
 
     def shutdown(self):
         self.sock.close()
         try:
             os.unlink(self.sockpath)
             if self.realsockpath:
                 os.unlink(self.realsockpath)
                 os.rmdir(os.path.dirname(self.realsockpath))
         except OSError, err:
             if err.errno != errno.ENOENT:
                 raise
 
     def answer_stat_query(self, cs):
         if self.repowatcher.timeout:
             # We got a query while a rescan is pending.  Make sure we
             # rescan before responding, or we could give back a wrong
             # answer.
             self.repowatcher.handle_timeout()
         return server.socketlistener.answer_stat_query(self, cs)
 
 class master(object):
     def __init__(self, ui, dirstate, root, timeout=None):
         self.ui = ui
         self.repowatcher = repowatcher(ui, dirstate, root)
         self.socketlistener = socketlistener(ui, root, self.repowatcher,
                                              timeout)
 
     def shutdown(self):
         for obj in pollable.instances.itervalues():
             obj.shutdown()
 
     def run(self):
         self.repowatcher.setup()
         self.ui.note(_('finished setup\n'))
         if os.getenv('TIME_STARTUP'):
             sys.exit(0)
         pollable.run()