home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1866 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  15.3 KB  |  416 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __docformat__ = 'restructuredtext en'
  5. import os
  6. import time
  7. import cPickle as pickle
  8. from twisted.python import components, log, failure
  9. from twisted.python.failure import Failure
  10. from twisted.internet import defer, reactor, threads
  11. from twisted.internet.interfaces import IProtocolFactory
  12. from zope.interface import Interface, implements, Attribute
  13. from twisted.internet.base import DelayedCall
  14. DelayedCall.debug = True
  15. from foolscap import Referenceable, DeadReferenceError
  16. from foolscap.referenceable import RemoteReference
  17. from IPython.kernel.pbutil import packageFailure, unpackageFailure
  18. from IPython.kernel.util import printer
  19. from IPython.kernel.twistedutil import gatherBoth
  20. from IPython.kernel import newserialized
  21. from IPython.kernel.error import ProtocolError
  22. from IPython.kernel import controllerservice
  23. from IPython.kernel.controllerservice import IControllerBase
  24. from IPython.kernel.engineservice import IEngineBase, IEngineQueued, EngineService, StrictDict
  25. from IPython.kernel.pickleutil import can, canDict, canSequence, uncan, uncanDict, uncanSequence
  26.  
  27. class IFCEngine(Interface):
  28.     pass
  29.  
  30.  
  31. class FCEngineReferenceFromService(Referenceable, object):
  32.     implements(IFCEngine)
  33.     
  34.     def __init__(self, service):
  35.         self.service = service
  36.         self.collectors = { }
  37.  
  38.     
  39.     def remote_get_id(self):
  40.         return self.service.id
  41.  
  42.     
  43.     def remote_set_id(self, id):
  44.         self.service.id = id
  45.  
  46.     
  47.     def _checkProperties(self, result):
  48.         dosync = self.service.properties.modified
  49.         self.service.properties.modified = False
  50.         if dosync:
  51.             pass
  52.         return (pickle.dumps(self.service.properties, 2), result)
  53.  
  54.     
  55.     def remote_execute(self, lines):
  56.         d = self.service.execute(lines)
  57.         d.addErrback(packageFailure)
  58.         d.addCallback(self._checkProperties)
  59.         d.addErrback(packageFailure)
  60.         return d
  61.  
  62.     
  63.     def remote_push(self, pNamespace):
  64.         
  65.         try:
  66.             namespace = pickle.loads(pNamespace)
  67.         except:
  68.             return defer.fail(failure.Failure()).addErrback(packageFailure)
  69.  
  70.         return self.service.push(namespace).addErrback(packageFailure)
  71.  
  72.     
  73.     def remote_pull(self, keys):
  74.         d = self.service.pull(keys)
  75.         d.addCallback(pickle.dumps, 2)
  76.         d.addErrback(packageFailure)
  77.         return d
  78.  
  79.     
  80.     def remote_push_function(self, pNamespace):
  81.         
  82.         try:
  83.             namespace = pickle.loads(pNamespace)
  84.         except:
  85.             return defer.fail(failure.Failure()).addErrback(packageFailure)
  86.  
  87.         namespace = uncanDict(namespace, globals())
  88.         return self.service.push_function(namespace).addErrback(packageFailure)
  89.  
  90.     
  91.     def remote_pull_function(self, keys):
  92.         d = self.service.pull_function(keys)
  93.         if len(keys) > 1:
  94.             d.addCallback(canSequence)
  95.         elif len(keys) == 1:
  96.             d.addCallback(can)
  97.         
  98.         d.addCallback(pickle.dumps, 2)
  99.         d.addErrback(packageFailure)
  100.         return d
  101.  
  102.     
  103.     def remote_get_result(self, i = None):
  104.         return self.service.get_result(i).addErrback(packageFailure)
  105.  
  106.     
  107.     def remote_reset(self):
  108.         return self.service.reset().addErrback(packageFailure)
  109.  
  110.     
  111.     def remote_kill(self):
  112.         return self.service.kill().addErrback(packageFailure)
  113.  
  114.     
  115.     def remote_keys(self):
  116.         return self.service.keys().addErrback(packageFailure)
  117.  
  118.     
  119.     def remote_push_serialized(self, pNamespace):
  120.         
  121.         try:
  122.             namespace = pickle.loads(pNamespace)
  123.         except:
  124.             return defer.fail(failure.Failure()).addErrback(packageFailure)
  125.  
  126.         d = self.service.push_serialized(namespace)
  127.         return d.addErrback(packageFailure)
  128.  
  129.     
  130.     def remote_pull_serialized(self, keys):
  131.         d = self.service.pull_serialized(keys)
  132.         d.addCallback(pickle.dumps, 2)
  133.         d.addErrback(packageFailure)
  134.         return d
  135.  
  136.     
  137.     def remote_set_properties(self, pNamespace):
  138.         
  139.         try:
  140.             namespace = pickle.loads(pNamespace)
  141.         except:
  142.             return defer.fail(failure.Failure()).addErrback(packageFailure)
  143.  
  144.         return self.service.set_properties(namespace).addErrback(packageFailure)
  145.  
  146.     
  147.     def remote_get_properties(self, keys = None):
  148.         d = self.service.get_properties(keys)
  149.         d.addCallback(pickle.dumps, 2)
  150.         d.addErrback(packageFailure)
  151.         return d
  152.  
  153.     
  154.     def remote_has_properties(self, keys):
  155.         d = self.service.has_properties(keys)
  156.         d.addCallback(pickle.dumps, 2)
  157.         d.addErrback(packageFailure)
  158.         return d
  159.  
  160.     
  161.     def remote_del_properties(self, keys):
  162.         d = self.service.del_properties(keys)
  163.         d.addErrback(packageFailure)
  164.         return d
  165.  
  166.     
  167.     def remote_clear_properties(self):
  168.         d = self.service.clear_properties()
  169.         d.addErrback(packageFailure)
  170.         return d
  171.  
  172.  
  173. components.registerAdapter(FCEngineReferenceFromService, IEngineBase, IFCEngine)
  174.  
  175. class EngineFromReference(object):
  176.     implements(IEngineBase)
  177.     
  178.     def __init__(self, reference):
  179.         self.reference = reference
  180.         self._id = None
  181.         self._properties = StrictDict()
  182.         self.currentCommand = None
  183.  
  184.     
  185.     def callRemote(self, *args, **kwargs):
  186.         
  187.         try:
  188.             return self.reference.callRemote(*args, **kwargs)
  189.         except DeadReferenceError:
  190.             self.notifier()
  191.             self.stopNotifying(self.notifier)
  192.             return defer.fail()
  193.  
  194.  
  195.     
  196.     def get_id(self):
  197.         return self._id
  198.  
  199.     
  200.     def set_id(self, id):
  201.         self._id = id
  202.         return self.callRemote('set_id', id)
  203.  
  204.     id = property(get_id, set_id)
  205.     
  206.     def syncProperties(self, r):
  207.         
  208.         try:
  209.             (psync, result) = r
  210.         except (ValueError, TypeError):
  211.             return r
  212.  
  213.         if psync:
  214.             log.msg('sync properties')
  215.             pick = self.checkReturnForFailure(psync)
  216.             if isinstance(pick, failure.Failure):
  217.                 self.properties = pick
  218.                 return pick
  219.             self.properties = pickle.loads(pick)
  220.         
  221.         return result
  222.  
  223.     
  224.     def _set_properties(self, dikt):
  225.         self._properties.clear()
  226.         self._properties.update(dikt)
  227.  
  228.     
  229.     def _get_properties(self):
  230.         if isinstance(self._properties, failure.Failure):
  231.             self._properties.raiseException()
  232.         
  233.         return self._properties
  234.  
  235.     properties = property(_get_properties, _set_properties)
  236.     
  237.     def execute(self, lines):
  238.         d = self.callRemote('execute', lines)
  239.         d.addCallback(self.syncProperties)
  240.         return d.addCallback(self.checkReturnForFailure)
  241.  
  242.     
  243.     def push(self, namespace):
  244.         
  245.         try:
  246.             package = pickle.dumps(namespace, 2)
  247.         except:
  248.             return defer.fail(failure.Failure())
  249.  
  250.         if isinstance(package, failure.Failure):
  251.             return defer.fail(package)
  252.         d = self.callRemote('push', package)
  253.         return d.addCallback(self.checkReturnForFailure)
  254.  
  255.     
  256.     def pull(self, keys):
  257.         d = self.callRemote('pull', keys)
  258.         d.addCallback(self.checkReturnForFailure)
  259.         d.addCallback(pickle.loads)
  260.         return d
  261.  
  262.     
  263.     def push_function(self, namespace):
  264.         
  265.         try:
  266.             package = pickle.dumps(canDict(namespace), 2)
  267.         except:
  268.             return defer.fail(failure.Failure())
  269.  
  270.         if isinstance(package, failure.Failure):
  271.             return defer.fail(package)
  272.         d = self.callRemote('push_function', package)
  273.         return d.addCallback(self.checkReturnForFailure)
  274.  
  275.     
  276.     def pull_function(self, keys):
  277.         d = self.callRemote('pull_function', keys)
  278.         d.addCallback(self.checkReturnForFailure)
  279.         d.addCallback(pickle.loads)
  280.         if len(keys) == 1:
  281.             d.addCallback(uncan, globals())
  282.         elif len(keys) > 1:
  283.             d.addCallback(uncanSequence, globals())
  284.         
  285.         return d
  286.  
  287.     
  288.     def get_result(self, i = None):
  289.         return self.callRemote('get_result', i).addCallback(self.checkReturnForFailure)
  290.  
  291.     
  292.     def reset(self):
  293.         self._refreshProperties = True
  294.         d = self.callRemote('reset')
  295.         d.addCallback(self.syncProperties)
  296.         return d.addCallback(self.checkReturnForFailure)
  297.  
  298.     
  299.     def kill(self):
  300.         d = self.callRemote('kill')
  301.         d.addCallback(self.syncProperties)
  302.         d.addCallback(self.checkReturnForFailure)
  303.         d.addErrback(self.killBack)
  304.         return d
  305.  
  306.     
  307.     def killBack(self, f):
  308.         log.msg('filling engine: %s' % f)
  309.  
  310.     
  311.     def keys(self):
  312.         return self.callRemote('keys').addCallback(self.checkReturnForFailure)
  313.  
  314.     
  315.     def set_properties(self, properties):
  316.         
  317.         try:
  318.             package = pickle.dumps(properties, 2)
  319.         except:
  320.             return defer.fail(failure.Failure())
  321.  
  322.         if isinstance(package, failure.Failure):
  323.             return defer.fail(package)
  324.         d = self.callRemote('set_properties', package)
  325.         return d.addCallback(self.checkReturnForFailure)
  326.         return d
  327.  
  328.     
  329.     def get_properties(self, keys = None):
  330.         d = self.callRemote('get_properties', keys)
  331.         d.addCallback(self.checkReturnForFailure)
  332.         d.addCallback(pickle.loads)
  333.         return d
  334.  
  335.     
  336.     def has_properties(self, keys):
  337.         d = self.callRemote('has_properties', keys)
  338.         d.addCallback(self.checkReturnForFailure)
  339.         d.addCallback(pickle.loads)
  340.         return d
  341.  
  342.     
  343.     def del_properties(self, keys):
  344.         d = self.callRemote('del_properties', keys)
  345.         d.addCallback(self.checkReturnForFailure)
  346.         return d
  347.  
  348.     
  349.     def clear_properties(self):
  350.         d = self.callRemote('clear_properties')
  351.         d.addCallback(self.checkReturnForFailure)
  352.         return d
  353.  
  354.     
  355.     def push_serialized(self, namespace):
  356.         
  357.         try:
  358.             package = pickle.dumps(namespace, 2)
  359.         except:
  360.             return defer.fail(failure.Failure())
  361.  
  362.         if isinstance(package, failure.Failure):
  363.             return defer.fail(package)
  364.         d = self.callRemote('push_serialized', package)
  365.         return d.addCallback(self.checkReturnForFailure)
  366.  
  367.     
  368.     def pull_serialized(self, keys):
  369.         d = self.callRemote('pull_serialized', keys)
  370.         d.addCallback(self.checkReturnForFailure)
  371.         d.addCallback(pickle.loads)
  372.         return d
  373.  
  374.     
  375.     def checkReturnForFailure(self, r):
  376.         return unpackageFailure(r)
  377.  
  378.  
  379. components.registerAdapter(EngineFromReference, RemoteReference, IEngineBase)
  380.  
  381. class IFCControllerBase(Interface):
  382.     
  383.     def remote_register_engine(self, engineReference, id = None, pid = None, pproperties = None):
  384.         pass
  385.  
  386.  
  387.  
  388. class FCRemoteEngineRefFromService(Referenceable):
  389.     implements(IFCControllerBase)
  390.     
  391.     def __init__(self, service):
  392.         self.service = service
  393.  
  394.     
  395.     def remote_register_engine(self, engine_reference, id = None, pid = None, pproperties = None):
  396.         engine = IEngineBase(engine_reference)
  397.         if pproperties:
  398.             engine.properties = pickle.loads(pproperties)
  399.         
  400.         remote_engine = IEngineQueued(engine)
  401.         peer_address = engine_reference.tracker.broker.transport.getPeer()
  402.         ip = peer_address.host
  403.         port = peer_address.port
  404.         reg_dict = self.service.register_engine(remote_engine, id, ip, port, pid)
  405.         
  406.         def notify(*args):
  407.             return self.service.unregister_engine(reg_dict['id'])
  408.  
  409.         engine_reference.tracker.broker.notifyOnDisconnect(notify)
  410.         engine.notifier = notify
  411.         engine.stopNotifying = engine_reference.tracker.broker.dontNotifyOnDisconnect
  412.         return reg_dict
  413.  
  414.  
  415. components.registerAdapter(FCRemoteEngineRefFromService, IControllerBase, IFCControllerBase)
  416.