home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1842 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  9.0 KB  |  248 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __docformat__ = 'restructuredtext en'
  5. import os
  6. import sys
  7. from twisted.application import service
  8. from twisted.internet import defer, reactor
  9. from twisted.python import log, components
  10. from zope.interface import Interface, implements, Attribute
  11. import zope.interface as zi
  12. from IPython.kernel.engineservice import IEngineCore, IEngineSerialized, IEngineQueued
  13. from IPython.genutils import get_ipython_dir
  14. from IPython.kernel import codeutil
  15.  
  16. class IControllerCore(Interface):
  17.     engines = Attribute('A dict of engine ids and engine instances.')
  18.     
  19.     def register_engine(remoteEngine, id = None, ip = None, port = None, pid = None):
  20.         pass
  21.  
  22.     
  23.     def unregister_engine(id):
  24.         pass
  25.  
  26.     
  27.     def on_register_engine_do(f, includeID, *args, **kwargs):
  28.         pass
  29.  
  30.     
  31.     def on_unregister_engine_do(f, includeID, *args, **kwargs):
  32.         pass
  33.  
  34.     
  35.     def on_register_engine_do_not(f):
  36.         pass
  37.  
  38.     
  39.     def on_unregister_engine_do_not(f):
  40.         pass
  41.  
  42.     
  43.     def on_n_engines_registered_do(n, f, *arg, **kwargs):
  44.         pass
  45.  
  46.  
  47.  
  48. class IControllerBase(IControllerCore):
  49.     pass
  50.  
  51.  
  52. class ControllerService(object, service.Service):
  53.     implements(IControllerBase)
  54.     name = 'ControllerService'
  55.     
  56.     def __init__(self, maxEngines = 511, saveIDs = False):
  57.         self.saveIDs = saveIDs
  58.         self.engines = { }
  59.         self.availableIDs = range(maxEngines, -1, -1)
  60.         self._onRegister = []
  61.         self._onUnregister = []
  62.         self._onNRegistered = []
  63.  
  64.     
  65.     def _buildEngineInfoString(self, id, ip, port, pid):
  66.         if id is None:
  67.             id = -99
  68.         
  69.         if ip is None:
  70.             ip = '-99'
  71.         
  72.         if port is None:
  73.             port = -99
  74.         
  75.         if pid is None:
  76.             pid = -99
  77.         
  78.         return 'Engine Info: %d %s %d %d' % (id, ip, port, pid)
  79.  
  80.     
  81.     def _logEngineInfo(self, id, ip, port, pid):
  82.         log.msg(self._buildEngineInfoString(id, ip, port, pid))
  83.  
  84.     
  85.     def _getEngineInfoLogFile(self):
  86.         ipdir = get_ipython_dir()
  87.         pjoin = os.path.join
  88.         logdir_base = pjoin(ipdir, 'log')
  89.         if not os.path.isdir(logdir_base):
  90.             os.makedirs(logdir_base)
  91.         
  92.         logfile = os.path.join(logdir_base, 'ipcontroller-%s-engine-info.log' % os.getpid())
  93.         return logfile
  94.  
  95.     
  96.     def _logEngineInfoToFile(self, id, ip, port, pid):
  97.         fname = self._getEngineInfoLogFile()
  98.         f = open(fname, 'a')
  99.         s = self._buildEngineInfoString(id, ip, port, pid)
  100.         f.write(s + '\n')
  101.         f.close()
  102.  
  103.     
  104.     def register_engine(self, remoteEngine, id = None, ip = None, port = None, pid = None):
  105.         desiredID = id
  106.         if desiredID in self.engines.keys():
  107.             desiredID = None
  108.         
  109.         if desiredID in self.availableIDs:
  110.             getID = desiredID
  111.             self.availableIDs.remove(desiredID)
  112.         else:
  113.             getID = self.availableIDs.pop()
  114.         remoteEngine.id = getID
  115.         remoteEngine.service = self
  116.         self.engines[getID] = remoteEngine
  117.         self._logEngineInfoToFile(getID, ip, port, pid)
  118.         msg = 'registered engine with id: %i' % getID
  119.         log.msg(msg)
  120.         for i in range(len(self._onRegister)):
  121.             (f, args, kwargs, ifid) = self._onRegister[i]
  122.             
  123.             try:
  124.                 if ifid:
  125.                     f(getID, *args, **kwargs)
  126.                 else:
  127.                     f(*args, **kwargs)
  128.             continue
  129.             self._onRegister.pop(i)
  130.             continue
  131.  
  132.         
  133.         for n, f, args, kwargs in enumerate(self._onNRegistered):
  134.             if len(self.engines.keys()) == n:
  135.                 
  136.                 try:
  137.                     f(*args, **kwargs)
  138.                 except:
  139.                     log.msg('Function %r failed when the %ith engine registered' % (f, n))
  140.                 finally:
  141.                     self._onNRegistered.pop(i)
  142.  
  143.                 continue
  144.         
  145.         return {
  146.             'id': getID }
  147.  
  148.     
  149.     def unregister_engine(self, id):
  150.         msg = 'unregistered engine with id: %i' % id
  151.         log.msg(msg)
  152.         
  153.         try:
  154.             del self.engines[id]
  155.         except KeyError:
  156.             log.msg('engine with id %i was not registered' % id)
  157.  
  158.         if not self.saveIDs:
  159.             self.availableIDs.append(id)
  160.             self.availableIDs.sort(reverse = True)
  161.         else:
  162.             log.msg('preserving id %i' % id)
  163.         for i in range(len(self._onUnregister)):
  164.             (f, args, kwargs, ifid) = self._onUnregister[i]
  165.             
  166.             try:
  167.                 if ifid:
  168.                     f(id, *args, **kwargs)
  169.                 else:
  170.                     f(*args, **kwargs)
  171.             continue
  172.             self._onUnregister.pop(i)
  173.             continue
  174.  
  175.         
  176.  
  177.     
  178.     def on_register_engine_do(self, f, includeID, *args, **kwargs):
  179.         self._onRegister.append((f, args, kwargs, includeID))
  180.  
  181.     
  182.     def on_unregister_engine_do(self, f, includeID, *args, **kwargs):
  183.         self._onUnregister.append((f, args, kwargs, includeID))
  184.  
  185.     
  186.     def on_register_engine_do_not(self, f):
  187.         for i in range(len(self._onRegister)):
  188.             g = self._onRegister[i][0]
  189.             if f == g:
  190.                 self._onRegister.pop(i)
  191.                 return None
  192.         
  193.  
  194.     
  195.     def on_unregister_engine_do_not(self, f):
  196.         for i in range(len(self._onUnregister)):
  197.             g = self._onUnregister[i][0]
  198.             if f == g:
  199.                 self._onUnregister.pop(i)
  200.                 return None
  201.         
  202.  
  203.     
  204.     def on_n_engines_registered_do(self, n, f, *args, **kwargs):
  205.         if len(self.engines.keys()) >= n:
  206.             f(*args, **kwargs)
  207.         else:
  208.             self._onNRegistered.append((n, f, args, kwargs))
  209.  
  210.  
  211.  
  212. class ControllerAdapterBase(object):
  213.     implements(IControllerBase)
  214.     
  215.     def __init__(self, controller):
  216.         self.controller = controller
  217.         self.engines = self.controller.engines
  218.  
  219.     
  220.     def register_engine(self, remoteEngine, id = None, ip = None, port = None, pid = None):
  221.         return self.controller.register_engine(remoteEngine, id, ip, port, pid)
  222.  
  223.     
  224.     def unregister_engine(self, id):
  225.         return self.controller.unregister_engine(id)
  226.  
  227.     
  228.     def on_register_engine_do(self, f, includeID, *args, **kwargs):
  229.         return self.controller.on_register_engine_do(f, includeID, *args, **kwargs)
  230.  
  231.     
  232.     def on_unregister_engine_do(self, f, includeID, *args, **kwargs):
  233.         return self.controller.on_unregister_engine_do(f, includeID, *args, **kwargs)
  234.  
  235.     
  236.     def on_register_engine_do_not(self, f):
  237.         return self.controller.on_register_engine_do_not(f)
  238.  
  239.     
  240.     def on_unregister_engine_do_not(self, f):
  241.         return self.controller.on_unregister_engine_do_not(f)
  242.  
  243.     
  244.     def on_n_engines_registered_do(self, n, f, *args, **kwargs):
  245.         return self.controller.on_n_engines_registered_do(n, f, *args, **kwargs)
  246.  
  247.  
  248.