vcs.maemo.org Git - ussd-widget/blob - ussd-pad/src/opt/ussd-pad/com/MessageBus.py

   1 """
   2 B{Used internally.}
   3 """
   4
   5 from exc import *
   6 import msgs
   7 from utils import logging
   8
   9
  10 class _MessageBus(object):
  11     """
  12     Application message bus singleton. This class is intented to be used by
  13     the Mediator class only.
  14     """
  15
  16     def __init__(self):
  17
  18         #self.__mediators = []
  19         self.__handlers = []
  20
  21
  22     def add_mediator(self, mediator):
  23
  24         #self.__mediators.append(mediator)
  25         self.__inspect_mediator(mediator)
  26
  27
  28     def __inspect_mediator(self, mediator):
  29
  30         supported_events = [ ev[7:] for ev in dir(mediator)
  31                              if ev.startswith("handle_") ]
  32         for ev in supported_events:
  33             ev_id = msgs._name_to_id(ev)
  34
  35             if (ev_id != -1):
  36                 while (len(self.__handlers) <= ev_id):
  37                     self.__handlers.append([])
  38
  39                 handler = getattr(mediator, "handle_" + ev)
  40                 self.__handlers[ev_id].append(handler)
  41             #end if
  42         #end for
  43
  44
  45     def send_event(self, src, event, *args):
  46
  47         if (logging.is_level(logging.DEBUG)):
  48             logging.debug("*** %s%s ***", msgs._id_to_name(event), `args`[:30])
  49
  50         try:
  51             handlers = self.__handlers[event]
  52         except:
  53             handlers = []
  54
  55         for handler in handlers:
  56             try:
  57                 handler(*args)
  58             except:
  59                 logging.error("error during event call: %s\n%s",
  60                               msgs._id_to_name(event), logging.stacktrace())
  61         #end for
  62
  63         """
  64         handler_name = "handle_" + msgs._id_to_name(event)
  65         for mediator in self.__mediators:
  66             if (mediator == src): continue
  67
  68             # TODO: the pass type was never really used and should go away
  69             mediator.set_pass_type(mediator.PASS_TYPE_PASS_ON)
  70             try:
  71                 if (hasattr(mediator, handler_name)):
  72                     getattr(mediator, handler_name)(*args)
  73                 else:
  74                     mediator.handle_message(event, *args)
  75             except:
  76                 import traceback; traceback.print_exc()
  77                 continue
  78
  79
  80
  81             ptype = mediator.get_pass_type()
  82             if (ptype == mediator.PASS_TYPE_DROP):
  83                 break
  84             elif (ptype == mediator.PASS_TYPE_PASS_ON):
  85                 continue
  86             else:
  87                 raise SyntaxError("mediator '%s' must specify pass type" \
  88                                   % mediator)
  89         #end for
  90         """
  91
  92
  93     def call_service(self, svc, *args):
  94
  95         if (logging.is_level(logging.DEBUG)):
  96             logging.debug("*** %s%s ***", msgs._id_to_name(svc), `args`[:30])
  97
  98         try:
  99             handlers = self.__handlers[svc]
 100         except:
 101             handlers = []
 102
 103         for handler in handlers:
 104             try:
 105                 return handler(*args)
 106             except:
 107                 logging.error("error during service call: %s\n%s",
 108                               msgs._id_to_name(svc), logging.stacktrace())
 109         #end for
 110
 111
 112         """
 113         handler_name = "handle_" + msgs._id_to_name(svc)
 114         handler = self.__services.get(svc)
 115
 116         if (not handler):
 117             for mediator in self.__mediators:
 118                 try:
 119                     if (hasattr(mediator, handler_name)):
 120                         ret = getattr(mediator, handler_name)(*args)
 121                     else:
 122                         ret = mediator.handle_message(svc, *args)
 123                 except:
 124                     import traceback; traceback.print_exc()
 125                     pass
 126
 127                 if (ret != None):
 128                     self.__services[svc] = mediator
 129                     return ret
 130             #end for
 131
 132             raise ServiceNotAvailableError(msgs._id_to_name(svc))
 133
 134         else:
 135             if (hasattr(handler, handler_name)):
 136                 ret = getattr(handler, handler_name)(*args)
 137             else:
 138                 ret = handler.handle_message(svc, *args)
 139
 140             return ret
 141     """
 142
 143 _singleton = _MessageBus()
 144 def MessageBus(): return _singleton