Decoupled Proxy of a State Bearing Object in a Multiprocessing Environment (Python recipe) by Mateyuzo

ActiveState Code (http://code.activestate.com/recipes/577180/)

#!/usr/bin/env python
import inspect
import multiprocessing
from multiprocessing.managers import SyncManager
import new, sys, types, time, datetime, random

#
#
#
class Commander(object):
   '''
      object to handle all requests
      from delegates. purpose generally to be
      borg or singleton of an object that can
      not be easily shared between different processes.
      Just an Example....
   '''
   def __init__(self, prefix='with_',**kwds):
      self._createTime = datetime.datetime.now()
      self._prefix = prefix
      self.id = random.Random()
      for k,v in kwds.items():
         setattr(self, k, v)
   #
   @property
   def Prefix(self):
      return self._prefix
   #
   @property
   def Commands(self):
      # want a dict comprehension that returns 
      # k,v of name of method, method for
      # method names that start with Prefix
      # but
      # dict comprehensions require another
      # dicussion entirely
      return self.__dict__.items()
   #
   def with_exposed(self, *args, **kwds):
      '''
         method exposed to SyncManager and 'the world'
         will print to std obj ids
      '''
      stack = inspect.stack()[0] # trying to make this file readable
      print '\n***\nCommander_%s.\nwith_exposed(%s, %s)called\nbound to self id %s\nand id %s\n***'%(
         stack, str(args), str(kwds), str(self), str(self.id)
         )
#
#
#
class _DelegatedMethod(object):
   '''
      idea of this class was lifted from Pyro.core
      i might put a async process here in __call__
      but didn't want to mess with callbks for an example
   '''
   def __init__(self, f, name):
      self.__f = f
      self.__name = name
   def __call__(self, *args, **kwds):
      return self.__f(*args, **kwds)
#
#
#
class CommanderDelegate(object):
   '''
      dynamic delegate for a Commander class
      should make sure its type Commander.
      As long as its a Commander, a sort of Mixin
      would be helpful, following the API. 'with_'
      or whatever was appropriate
   '''
   #
   def __init__(self, commanderClz, *args, **kwds):
      self._dispatchMap = {}
      self._commander = commanderClz(*args, **kwds)
      for m in inspect.getmembers(self._commander):
         if inspect.ismethod(m[1]) and m[0].startswith(self._commander.Prefix):
            self._dispatchMap[m[0]] = m[1]
   #
   def __getattribute__(self, name):
      # the important bits...
      d = object.__getattribute__(self, '_dispatchMap')
      if d.has_key(name):
         return _DelegatedMethod(d[name], name)
      return object.__getattribute__(self, name)
#
#
#
class SharedProctor(SyncManager):
   def __init__(self):
      SyncManager.__init__(self)
      self.register('CommanderProctor', 
            callable=CommanderDelegate, 
            exposed=('with_exposed',))
#
#
#
class MyProcess(multiprocessing.Process):
   #
   def __init__(self, dp=None, dpLock=None):
      multiprocessing.Process.__init__(self)
      self.dp = dp
      self.dpLock = dpLock
   def run(self):
      self.__say()
   def __say(self):
      with self.dpLock:
         s = self.dp.with_exposed()
#     
if __name__ == '__main__':
   
   sp = SharedProctor()
   sp.start()
   cp = sp.CommanderProctor(Commander)
   cpLock = sp.Lock()
   for i in xrange(0,100):
      m = MyProcess(dp=cp, dpLock=cpLock)
      m.start()
      time.sleep(.01)
   
   m.join()