home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1472 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  15.5 KB  |  487 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import re
  6.  
  7. try:
  8.     set
  9. except NameError:
  10.     from sets import Set as set
  11.  
  12. import signal as _signal
  13. import sys
  14. import time
  15. import threading
  16.  
  17. class SimplePlugin(object):
  18.     
  19.     def __init__(self, bus):
  20.         self.bus = bus
  21.  
  22.     
  23.     def subscribe(self):
  24.         for channel in self.bus.listeners:
  25.             method = getattr(self, channel, None)
  26.             if method is not None:
  27.                 self.bus.subscribe(channel, method)
  28.                 continue
  29.         
  30.  
  31.     
  32.     def unsubscribe(self):
  33.         for channel in self.bus.listeners:
  34.             method = getattr(self, channel, None)
  35.             if method is not None:
  36.                 self.bus.unsubscribe(channel, method)
  37.                 continue
  38.         
  39.  
  40.  
  41.  
  42. class SignalHandler(object):
  43.     signals = { }
  44.     for k, v in vars(_signal).items():
  45.         if k.startswith('SIG') and not k.startswith('SIG_'):
  46.             signals[v] = k
  47.             continue
  48.     
  49.     del k
  50.     del v
  51.     
  52.     def __init__(self, bus):
  53.         self.bus = bus
  54.         self.handlers = {
  55.             'SIGTERM': self.bus.exit,
  56.             'SIGHUP': self.handle_SIGHUP,
  57.             'SIGUSR1': self.bus.graceful }
  58.         self._previous_handlers = { }
  59.  
  60.     
  61.     def subscribe(self):
  62.         for sig, func in self.handlers.iteritems():
  63.             
  64.             try:
  65.                 self.set_handler(sig, func)
  66.             continue
  67.             except ValueError:
  68.                 continue
  69.             
  70.  
  71.         
  72.  
  73.     
  74.     def unsubscribe(self):
  75.         for signum, handler in self._previous_handlers.iteritems():
  76.             signame = self.signals[signum]
  77.             if handler is None:
  78.                 self.bus.log('Restoring %s handler to SIG_DFL.' % signame)
  79.                 handler = _signal.SIG_DFL
  80.             else:
  81.                 self.bus.log('Restoring %s handler %r.' % (signame, handler))
  82.             
  83.             try:
  84.                 our_handler = _signal.signal(signum, handler)
  85.                 if our_handler is None:
  86.                     self.bus.log('Restored old %s handler %r, but our handler was not registered.' % (signame, handler), level = 30)
  87.             continue
  88.             except ValueError:
  89.                 self.bus.log('Unable to restore %s handler %r.' % (signame, handler), level = 40, traceback = True)
  90.                 continue
  91.             
  92.  
  93.         
  94.  
  95.     
  96.     def set_handler(self, signal, listener = None):
  97.         if isinstance(signal, basestring):
  98.             signum = getattr(_signal, signal, None)
  99.             if signum is None:
  100.                 raise ValueError('No such signal: %r' % signal)
  101.             signum is None
  102.             signame = signal
  103.         else:
  104.             
  105.             try:
  106.                 signame = self.signals[signal]
  107.             except KeyError:
  108.                 raise ValueError('No such signal: %r' % signal)
  109.  
  110.             signum = signal
  111.         prev = _signal.signal(signum, self._handle_signal)
  112.         self._previous_handlers[signum] = prev
  113.         if listener is not None:
  114.             self.bus.log('Listening for %s.' % signame)
  115.             self.bus.subscribe(signame, listener)
  116.         
  117.  
  118.     
  119.     def _handle_signal(self, signum = None, frame = None):
  120.         signame = self.signals[signum]
  121.         self.bus.log('Caught signal %s.' % signame)
  122.         self.bus.publish(signame)
  123.  
  124.     
  125.     def handle_SIGHUP(self):
  126.         if os.isatty(sys.stdin.fileno()):
  127.             self.bus.log('SIGHUP caught but not daemonized. Exiting.')
  128.             self.bus.exit()
  129.         else:
  130.             self.bus.log('SIGHUP caught while daemonized. Restarting.')
  131.             self.bus.restart()
  132.  
  133.  
  134.  
  135. try:
  136.     import pwd
  137.     import grp
  138. except ImportError:
  139.     (pwd, grp) = (None, None)
  140.  
  141.  
  142. class DropPrivileges(SimplePlugin):
  143.     
  144.     def __init__(self, bus, umask = None, uid = None, gid = None):
  145.         SimplePlugin.__init__(self, bus)
  146.         self.finalized = False
  147.         self.uid = uid
  148.         self.gid = gid
  149.         self.umask = umask
  150.  
  151.     
  152.     def _get_uid(self):
  153.         return self._uid
  154.  
  155.     
  156.     def _set_uid(self, val):
  157.         if val is not None:
  158.             if pwd is None:
  159.                 self.bus.log('pwd module not available; ignoring uid.', level = 30)
  160.                 val = None
  161.             elif isinstance(val, basestring):
  162.                 val = pwd.getpwnam(val)[2]
  163.             
  164.         
  165.         self._uid = val
  166.  
  167.     uid = property(_get_uid, _set_uid, doc = 'The uid under which to run.')
  168.     
  169.     def _get_gid(self):
  170.         return self._gid
  171.  
  172.     
  173.     def _set_gid(self, val):
  174.         if val is not None:
  175.             if grp is None:
  176.                 self.bus.log('grp module not available; ignoring gid.', level = 30)
  177.                 val = None
  178.             elif isinstance(val, basestring):
  179.                 val = grp.getgrnam(val)[2]
  180.             
  181.         
  182.         self._gid = val
  183.  
  184.     gid = property(_get_gid, _set_gid, doc = 'The gid under which to run.')
  185.     
  186.     def _get_umask(self):
  187.         return self._umask
  188.  
  189.     
  190.     def _set_umask(self, val):
  191.         if val is not None:
  192.             
  193.             try:
  194.                 os.umask
  195.             except AttributeError:
  196.                 self.bus.log('umask function not available; ignoring umask.', level = 30)
  197.                 val = None
  198.             except:
  199.                 None<EXCEPTION MATCH>AttributeError
  200.             
  201.  
  202.         None<EXCEPTION MATCH>AttributeError
  203.         self._umask = val
  204.  
  205.     umask = property(_get_umask, _set_umask, doc = 'The umask under which to run.')
  206.     
  207.     def start(self):
  208.         
  209.         def current_ids():
  210.             (name, group) = (None, None)
  211.             if pwd:
  212.                 name = pwd.getpwuid(os.getuid())[0]
  213.             
  214.             if grp:
  215.                 group = grp.getgrgid(os.getgid())[0]
  216.             
  217.             return (name, group)
  218.  
  219.         if self.finalized:
  220.             if not self.uid is None and self.gid is None:
  221.                 self.bus.log('Already running as uid: %r gid: %r' % current_ids())
  222.             
  223.         elif self.uid is None and self.gid is None:
  224.             if pwd or grp:
  225.                 self.bus.log('uid/gid not set', level = 30)
  226.             
  227.         else:
  228.             self.bus.log('Started as uid: %r gid: %r' % current_ids())
  229.             if self.gid is not None:
  230.                 os.setgid(self.gid)
  231.             
  232.             if self.uid is not None:
  233.                 os.setuid(self.uid)
  234.             
  235.             self.bus.log('Running as uid: %r gid: %r' % current_ids())
  236.         if self.finalized:
  237.             if self.umask is not None:
  238.                 self.bus.log('umask already set to: %03o' % self.umask)
  239.             
  240.         elif self.umask is None:
  241.             self.bus.log('umask not set', level = 30)
  242.         else:
  243.             old_umask = os.umask(self.umask)
  244.             self.bus.log('umask old: %03o, new: %03o' % (old_umask, self.umask))
  245.         self.finalized = True
  246.  
  247.     start.priority = 77
  248.  
  249.  
  250. class Daemonizer(SimplePlugin):
  251.     
  252.     def __init__(self, bus, stdin = '/dev/null', stdout = '/dev/null', stderr = '/dev/null'):
  253.         SimplePlugin.__init__(self, bus)
  254.         self.stdin = stdin
  255.         self.stdout = stdout
  256.         self.stderr = stderr
  257.         self.finalized = False
  258.  
  259.     
  260.     def start(self):
  261.         if self.finalized:
  262.             self.bus.log('Already deamonized.')
  263.         
  264.         if threading.activeCount() != 1:
  265.             self.bus.log('There are %r active threads. Daemonizing now may cause strange failures.' % threading.enumerate(), level = 30)
  266.         
  267.         sys.stdout.flush()
  268.         sys.stderr.flush()
  269.         
  270.         try:
  271.             pid = os.fork()
  272.             if pid == 0:
  273.                 pass
  274.             else:
  275.                 self.bus.log('Forking once.')
  276.                 os._exit(0)
  277.         except OSError:
  278.             exc = None
  279.             sys.exit('%s: fork #1 failed: (%d) %s\n' % (sys.argv[0], exc.errno, exc.strerror))
  280.  
  281.         os.setsid()
  282.         
  283.         try:
  284.             pid = os.fork()
  285.             if pid > 0:
  286.                 self.bus.log('Forking twice.')
  287.                 os._exit(0)
  288.         except OSError:
  289.             exc = None
  290.             sys.exit('%s: fork #2 failed: (%d) %s\n' % (sys.argv[0], exc.errno, exc.strerror))
  291.  
  292.         os.chdir('/')
  293.         os.umask(0)
  294.         si = open(self.stdin, 'r')
  295.         so = open(self.stdout, 'a+')
  296.         se = open(self.stderr, 'a+', 0)
  297.         os.dup2(si.fileno(), sys.stdin.fileno())
  298.         os.dup2(so.fileno(), sys.stdout.fileno())
  299.         os.dup2(se.fileno(), sys.stderr.fileno())
  300.         self.bus.log('Daemonized to PID: %s' % os.getpid())
  301.         self.finalized = True
  302.  
  303.     start.priority = 65
  304.  
  305.  
  306. class PIDFile(SimplePlugin):
  307.     
  308.     def __init__(self, bus, pidfile):
  309.         SimplePlugin.__init__(self, bus)
  310.         self.pidfile = pidfile
  311.         self.finalized = False
  312.  
  313.     
  314.     def start(self):
  315.         pid = os.getpid()
  316.         if self.finalized:
  317.             self.bus.log('PID %r already written to %r.' % (pid, self.pidfile))
  318.         else:
  319.             open(self.pidfile, 'wb').write(str(pid))
  320.             self.bus.log('PID %r written to %r.' % (pid, self.pidfile))
  321.             self.finalized = True
  322.  
  323.     start.priority = 70
  324.     
  325.     def exit(self):
  326.         
  327.         try:
  328.             os.remove(self.pidfile)
  329.             self.bus.log('PID file removed: %r.' % self.pidfile)
  330.         except (KeyboardInterrupt, SystemExit):
  331.             raise 
  332.         except:
  333.             pass
  334.  
  335.  
  336.  
  337.  
  338. class PerpetualTimer(threading._Timer):
  339.     
  340.     def run(self):
  341.         while True:
  342.             self.finished.wait(self.interval)
  343.             if self.finished.isSet():
  344.                 return None
  345.             self.function(*self.args, **self.kwargs)
  346.             continue
  347.             self.finished.isSet()
  348.  
  349.  
  350.  
  351. class Monitor(SimplePlugin):
  352.     frequency = 60
  353.     
  354.     def __init__(self, bus, callback, frequency = 60):
  355.         SimplePlugin.__init__(self, bus)
  356.         self.callback = callback
  357.         self.frequency = frequency
  358.         self.thread = None
  359.  
  360.     
  361.     def start(self):
  362.         if self.frequency > 0:
  363.             threadname = self.__class__.__name__
  364.             if self.thread is None:
  365.                 self.thread = PerpetualTimer(self.frequency, self.callback)
  366.                 self.thread.setName(threadname)
  367.                 self.thread.start()
  368.                 self.bus.log('Started monitor thread %r.' % threadname)
  369.             else:
  370.                 self.bus.log('Monitor thread %r already started.' % threadname)
  371.         
  372.  
  373.     start.priority = 70
  374.     
  375.     def stop(self):
  376.         if self.thread is None:
  377.             self.bus.log('No thread running for %s.' % self.__class__.__name__)
  378.         elif self.thread is not threading.currentThread():
  379.             name = self.thread.getName()
  380.             self.thread.cancel()
  381.             self.thread.join()
  382.             self.bus.log('Stopped thread %r.' % name)
  383.         
  384.         self.thread = None
  385.  
  386.     
  387.     def graceful(self):
  388.         self.stop()
  389.         self.start()
  390.  
  391.  
  392.  
  393. class Autoreloader(Monitor):
  394.     frequency = 1
  395.     match = '.*'
  396.     
  397.     def __init__(self, bus, frequency = 1, match = '.*'):
  398.         self.mtimes = { }
  399.         self.files = set()
  400.         self.match = match
  401.         Monitor.__init__(self, bus, self.run, frequency)
  402.  
  403.     
  404.     def start(self):
  405.         if self.thread is None:
  406.             self.mtimes = { }
  407.         
  408.         Monitor.start(self)
  409.  
  410.     start.priority = 70
  411.     
  412.     def run(self):
  413.         sysfiles = set()
  414.         for k, m in sys.modules.items():
  415.             if re.match(self.match, k):
  416.                 if hasattr(m, '__loader__'):
  417.                     if hasattr(m.__loader__, 'archive'):
  418.                         k = m.__loader__.archive
  419.                     
  420.                 
  421.                 k = getattr(m, '__file__', None)
  422.                 sysfiles.add(k)
  423.                 continue
  424.         
  425.         for filename in sysfiles | self.files:
  426.             if filename:
  427.                 if filename.endswith('.pyc'):
  428.                     filename = filename[:-1]
  429.                 
  430.                 oldtime = self.mtimes.get(filename, 0)
  431.                 if oldtime is None:
  432.                     continue
  433.                 
  434.                 
  435.                 try:
  436.                     mtime = os.stat(filename).st_mtime
  437.                 except OSError:
  438.                     mtime = None
  439.  
  440.                 if filename not in self.mtimes:
  441.                     self.mtimes[filename] = mtime
  442.                 elif mtime is None or mtime > oldtime:
  443.                     self.bus.log('Restarting because %s changed.' % filename)
  444.                     self.thread.cancel()
  445.                     self.bus.log('Stopped thread %r.' % self.thread.getName())
  446.                     self.bus.restart()
  447.                     return None
  448.                 continue
  449.         
  450.  
  451.  
  452.  
  453. class ThreadManager(SimplePlugin):
  454.     
  455.     def __init__(self, bus):
  456.         self.threads = { }
  457.         SimplePlugin.__init__(self, bus)
  458.         self.bus.listeners.setdefault('acquire_thread', set())
  459.         self.bus.listeners.setdefault('release_thread', set())
  460.  
  461.     
  462.     def acquire_thread(self):
  463.         thread_ident = threading._get_ident()
  464.         if thread_ident not in self.threads:
  465.             i = len(self.threads) + 1
  466.             self.threads[thread_ident] = i
  467.             self.bus.publish('start_thread', i)
  468.         
  469.  
  470.     
  471.     def release_thread(self):
  472.         thread_ident = threading._get_ident()
  473.         i = self.threads.pop(thread_ident, None)
  474.         if i is not None:
  475.             self.bus.publish('stop_thread', i)
  476.         
  477.  
  478.     
  479.     def stop(self):
  480.         for thread_ident, i in self.threads.iteritems():
  481.             self.bus.publish('stop_thread', i)
  482.         
  483.         self.threads.clear()
  484.  
  485.     graceful = stop
  486.  
  487.