home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 July / CMCD0704.ISO / Software / Shareware / Comunicatii / jyte / jyte.exe / dispatcher.py < prev    next >
Text File  |  2004-01-26  |  8KB  |  243 lines
  1. """Dispatcher
  2.  
  3. Please see policy.py for a discussion on dispatchers and policies
  4. """
  5. import pythoncom, traceback, win32api
  6. from sys import exc_info
  7.  
  8. #
  9. from win32com.server.exception import IsCOMServerException
  10. from win32com.util import IIDToInterfaceName
  11.  
  12. class DispatcherBase:
  13.   """ The base class for all Dispatchers.  
  14.  
  15.       This dispatcher supports wrapping all operations in exception handlers, 
  16.       and all the necessary delegation to the policy.
  17.  
  18.       This base class supports the printing of "unexpected" exceptions.  Note, however,
  19.       that exactly where the output of print goes may not be useful!  A derived class may
  20.       provide additional semantics for this.
  21.   """
  22.   def __init__(self, policyClass, object):
  23.     self.policy = policyClass(object)
  24.  
  25.   def _CreateInstance_(self, clsid, reqIID):
  26.     try:
  27.       self.policy._CreateInstance_(clsid, reqIID)
  28.       return pythoncom.WrapObject(self, reqIID)
  29.     except:
  30.       self._HandleException_()
  31.  
  32.   def _QueryInterface_(self, iid):
  33.     try:
  34.       return self.policy._QueryInterface_(iid)
  35.     except:
  36.       self._HandleException_()
  37.  
  38.   def _Invoke_(self, dispid, lcid, wFlags, args):
  39.     try:
  40.       return self.policy._Invoke_(dispid, lcid, wFlags, args)
  41.     except:
  42.       self._HandleException_()
  43.  
  44.   def _GetIDsOfNames_(self, names, lcid):
  45.     try:
  46.       return self.policy._GetIDsOfNames_(names, lcid)
  47.     except:
  48.       self._HandleException_()
  49.  
  50.   def _GetDispID_(self, name, fdex):
  51.     try:
  52.       return self.policy._GetDispID_(name, fdex)
  53.     except:
  54.       self._HandleException_()
  55.  
  56.   def _InvokeEx_(self, dispid, lcid, wFlags, args, kwargs, serviceProvider):
  57.     try:
  58.       return self.policy._InvokeEx_(dispid, lcid, wFlags, args, kwargs, serviceProvider)
  59.     except:
  60.       self._HandleException_()
  61.  
  62.   def _DeleteMemberByName_(self, name, fdex):
  63.     try:
  64.       return self.policy._DeleteMemberByName_(name, fdex)
  65.     except:
  66.       self._HandleException_()
  67.  
  68.   def _DeleteMemberByDispID_(self, id):
  69.     try:
  70.       return self.policy._DeleteMemberByDispID_(id)
  71.     except:
  72.       self._HandleException_()
  73.  
  74.   def _GetMemberProperties_(self, id, fdex):
  75.     try:
  76.       return self.policy._GetMemberProperties_(id, fdex)
  77.     except:
  78.       self._HandleException_()
  79.  
  80.   def _GetMemberName_(self, dispid):
  81.     try:
  82.       return self.policy._GetMemberName_(dispid)
  83.     except:
  84.       self._HandleException_()
  85.  
  86.   def _GetNextDispID_(self, fdex, flags):
  87.     try:
  88.       return self.policy._GetNextDispID_(fdex, flags)
  89.     except:
  90.       self._HandleException_()
  91.  
  92.   def _GetNameSpaceParent_(self):
  93.     try:
  94.       return self.policy._GetNameSpaceParent_()
  95.     except:
  96.       self._HandleException_()
  97.  
  98.   def _HandleException_(self):
  99.     """Called whenever an exception is raised.
  100.  
  101.        Default behaviour is to print the exception.
  102.     """
  103.     # If not a COM exception, print it for the developer.
  104.     if not IsCOMServerException():
  105.       traceback.print_exc()
  106.     # But still raise it for the framework.
  107.     reraise()
  108.  
  109.   def _trace_(self, *args):
  110.     for arg in args[:-1]:
  111.       print arg,
  112.     print args[-1]
  113.     
  114. class DispatcherTrace(DispatcherBase):
  115.   """A dispatcher, which causes a 'print' line for each COM function called.
  116.   """
  117.   def _QueryInterface_(self, iid):
  118.     rc = DispatcherBase._QueryInterface_(self, iid)
  119.     if not rc:
  120.       self._trace_("in %s._QueryInterface_ with unsupported IID %s (%s)" % (`self.policy._obj_`, IIDToInterfaceName(iid),iid))
  121.     return rc
  122.  
  123.   def _GetIDsOfNames_(self, names, lcid):
  124.     self._trace_("in _GetIDsOfNames_ with '%s' and '%d'\n" % (names, lcid))
  125.     return DispatcherBase._GetIDsOfNames_(self, names, lcid)
  126.  
  127.   def _Invoke_(self, dispid, lcid, wFlags, args):
  128.     self._trace_("in _Invoke_ with", dispid, lcid, wFlags, args)
  129.     return DispatcherBase._Invoke_(self, dispid, lcid, wFlags, args)
  130.  
  131.   def _GetDispID_(self, name, fdex):
  132.     self._trace_("in _GetDispID_ with", name, fdex)
  133.     return DispatcherBase._GetDispID_(self, name, fdex)
  134.  
  135.   def _InvokeEx_(self, dispid, lcid, wFlags, args, kwargs, serviceProvider):
  136.     self._trace_("in %r._InvokeEx_-%s%r [%x,%s,%r]" % (self.policy._obj_, dispid, args, wFlags, lcid, serviceProvider))
  137.     return DispatcherBase._InvokeEx_(self, dispid, lcid, wFlags, args, kwargs, serviceProvider)
  138.  
  139.   def _DeleteMemberByName_(self, name, fdex):
  140.     self._trace_("in _DeleteMemberByName_ with", name, fdex)
  141.     return DispatcherBase._DeleteMemberByName_(self, name, fdex)
  142.  
  143.   def _DeleteMemberByDispID_(self, id):
  144.     self._trace_("in _DeleteMemberByDispID_ with", id)
  145.     return DispatcherBase._DeleteMemberByDispID_(self, id)
  146.  
  147.   def _GetMemberProperties_(self, id, fdex):
  148.     self._trace_("in _GetMemberProperties_ with", id, fdex)
  149.     return DispatcherBase._GetMemberProperties_(self, id, fdex)
  150.  
  151.   def _GetMemberName_(self, dispid):
  152.     self._trace_("in _GetMemberName_ with", dispid)
  153.     return DispatcherBase._GetMemberName_(self, dispid)
  154.  
  155.   def _GetNextDispID_(self, fdex, flags):
  156.     self._trace_("in _GetNextDispID_ with", fdex, flags)
  157.     return DispatcherBase._GetNextDispID_(self, fdex, flags)
  158.  
  159.   def _GetNameSpaceParent_(self):
  160.     self._trace_("in _GetNameSpaceParent_")
  161.     return DispatcherBase._GetNameSpaceParent_(self)
  162.  
  163.  
  164. class DispatcherWin32trace(DispatcherTrace):
  165.   """A tracing dispatcher that sends its output to the win32trace remote collector.
  166.   
  167.   """
  168.   def __init__(self, policyClass, object):
  169.     DispatcherTrace.__init__(self, policyClass, object)
  170.     import win32traceutil # Sets up everything.
  171.     print "Object with win32trace dispatcher created (object=%s)" % `object`
  172.  
  173.  
  174. class DispatcherOutputDebugString(DispatcherTrace):
  175.   """A tracing dispatcher that sends its output to win32api.OutputDebugString
  176.   
  177.   """
  178.   def _trace_(self, *args):
  179.     for arg in args[:-1]:
  180.       win32api.OutputDebugString(str(arg)+" ")
  181.     win32api.OutputDebugString(str(args[-1])+"\n")
  182.  
  183.  
  184. class DispatcherWin32dbg(DispatcherBase):
  185.   """A source-level debugger dispatcher
  186.  
  187.   A dispatcher which invokes the debugger as an object is instantiated, or 
  188.   when an unexpected exception occurs.
  189.  
  190.   Requires Pythonwin.
  191.   """
  192.   def __init__(self, policyClass, ob):
  193.     import pywin.debugger 
  194.     pywin.debugger.brk()
  195.     # DEBUGGER Note - You can either:
  196.     # * Hit Run and wait for a (non Exception class) exception to occur!
  197.     # * Set a breakpoint and hit run.
  198.     # * Step into the object creation (a few steps away!)
  199.     DispatcherBase.__init__(self, policyClass, ob)
  200.  
  201.   def _HandleException_(self):
  202.     """ Invoke the debugger post mortem capability """
  203.     # Save details away.
  204.     typ, val, tb = exc_info()
  205.     import pywin.debugger, pywin.debugger.dbgcon
  206.     debug = 0
  207.     try:
  208.       raise typ, val
  209.     except Exception: # AARG - What is this Exception???
  210.       # Use some inside knowledge to borrow a Debugger option which dictates if we
  211.       # stop at "expected" exceptions.
  212.       debug = pywin.debugger.GetDebugger().get_option(pywin.debugger.dbgcon.OPT_STOP_EXCEPTIONS)
  213.     except:
  214.       debug = 1
  215.     if debug:
  216.       try:
  217.         pywin.debugger.post_mortem(tb, typ, val) # The original exception
  218.       except:
  219.         traceback.print_exc()
  220.  
  221.     # But still raise it.
  222.     del tb
  223.     reraise()
  224.  
  225. def reraise():
  226.   """Handy function for re-raising errors.
  227.  
  228.   Note: storing a traceback in a local variable can introduce reference
  229.   loops if you aren't careful.  Specifically, that local variable should
  230.   not be within an execution context contained with the traceback.
  231.  
  232.   By using a utility function, we ensure that our local variable holding
  233.   the traceback is not referenced by the traceback itself.
  234.   """
  235.   t, v, tb = exc_info()
  236.   raise t, v, tb
  237.  
  238. try:
  239.   import win32trace
  240.   DefaultDebugDispatcher = DispatcherWin32trace
  241. except ImportError: # no win32trace module - just use a print based one.
  242.   DefaultDebugDispatcher = DispatcherTrace
  243.