def dispatch_one(self, msg): if not all(p.is_authorized(self, msg) for p in self.policies): LOG.error('%r: unauthorized message %r', self, msg) msg.reply(mitogen.core.CallError('Unauthorized')) return if len(msg.data) > self.max_message_size: LOG.error('%r: larger than permitted size: %r', self, msg) msg.reply(mitogen.core.CallError('Message size exceeded')) return args = msg.unpickle(throw=False) if (args == mitogen.core._DEAD or isinstance(args, mitogen.core.CallError) or not self.validate_args(args)): LOG.warning('Received junk message: %r', args) return try: response = self.dispatch(args, msg) if response is not self.NO_REPLY: msg.reply(response) except Exception, e: LOG.exception('While invoking %r.dispatch()', self) msg.reply(mitogen.core.CallError(e))
def _on_get_module(self, msg): LOG.debug('%r.get_module(%r)', self, msg) if msg == mitogen.core._DEAD: return stream = self._router.stream_by_id(msg.src_id) fullname = msg.data if fullname in stream.sent_modules: LOG.warning('_on_get_module(): dup request for %r from %r', fullname, stream) try: tup = self._build_tuple(fullname) for name in tup[4]: # related parent, _, _ = name.partition('.') if parent != fullname and parent not in stream.sent_modules: # Parent hasn't been sent, so don't load submodule yet. continue if name in stream.sent_modules: # Submodule has been sent already, skip. continue self._send_load_module(stream, msg, name) self._send_load_module(stream, msg, fullname) except Exception: LOG.debug('While importing %r', fullname, exc_info=True) msg.reply((fullname, None, None, None, []), handle=mitogen.core.LOAD_MODULE)
def _on_control(self, msg): if msg != mitogen.core._DEAD: command, arg = msg.unpickle() LOG.debug('%r._on_control(%r, %s)', self, command, arg) func = getattr(self, '_on_%s' % (command, ), None) if func: return func(msg, arg) LOG.warning('%r: unknown command %r', self, command)
def _on_detaching(self, msg): if msg.is_dead: return stream = self.stream_by_id(msg.src_id) if stream.remote_id != msg.src_id or stream.detached: LOG.warning('bad DETACHING received on %r: %r', stream, msg) return LOG.debug('%r: marking as detached', stream) stream.detached = True msg.reply(None)
def _on_control(self, msg): if not msg.is_dead: command, arg = msg.unpickle(throw=False) LOG.debug('%r._on_control(%r, %s)', self, command, arg) func = getattr(self, '_on_%s' % (command, ), None) if func: return func(msg, arg) LOG.warning('%r: unknown command %r', self, command)
def _on_control(self, msg): if not msg.is_dead: command, arg = msg.unpickle(throw=False) LOG.debug('%r._on_control(%r, %s)', self, command, arg) func = getattr(self, '_on_%s' % (command,), None) if func: return func(msg, arg) LOG.warning('%r: unknown command %r', self, command)
def _on_get_module(self, msg): if msg.is_dead: return LOG.debug('%r._on_get_module(%r)', self, msg.data) stream = self._router.stream_by_id(msg.src_id) fullname = msg.data.decode() if fullname in stream.sent_modules: LOG.warning('_on_get_module(): dup request for %r from %r', fullname, stream) self._send_module_and_related(stream, fullname)
def on_receive_message(self, msg): try: response = self._on_receive_message(msg) if response is not self.NO_REPLY: msg.reply(response) except mitogen.core.CallError: e = sys.exc_info()[1] LOG.warning('%r: call error: %s: %s', self, msg, e) msg.reply(e) except Exception: LOG.exception('While invoking %r.dispatch()', self) e = sys.exc_info()[1] msg.reply(mitogen.core.CallError(e))
def _on_service_call(self, recv, msg): self._validate(msg) service_name, method_name, kwargs = msg.unpickle() try: invoker = self.get_invoker(service_name, msg) return invoker.invoke(method_name, kwargs, msg) except mitogen.core.CallError: e = sys.exc_info()[1] LOG.warning('%r: call error: %s: %s', self, msg, e) msg.reply(e) except Exception: LOG.exception('While invoking %r._invoke()', self) e = sys.exc_info()[1] msg.reply(mitogen.core.CallError(e))
def _run(self): while True: tup = self._pop() if tup is None: return method_name, kwargs, msg = tup try: super(SerializedInvoker, self).invoke(method_name, kwargs, msg) except mitogen.core.CallError: e = sys.exc_info()[1] LOG.warning('%r: call error: %s: %s', self, msg, e) msg.reply(e) except Exception: LOG.exception('%r: while invoking %s()', self, method_name) msg.reply(mitogen.core.Message.dead())
def _on_service_call(self, event): msg = event.data service_name = None method_name = None try: self._validate(msg) service_name, method_name, kwargs = msg.unpickle() invoker = self.get_invoker(service_name, msg) return invoker.invoke(method_name, kwargs, msg) except mitogen.core.CallError: e = sys.exc_info()[1] LOG.warning('%r: call error: %s: %s', self, msg, e) msg.reply(e) except Exception: LOG.exception('%r: while invoking %r of %r', self, method_name, service_name) e = sys.exc_info()[1] msg.reply(mitogen.core.CallError(e))
def dispatch_one(self, msg): if len(msg.data) > self.max_message_size: LOG.error('%r: larger than permitted size: %r', self, msg) msg.reply(mitogen.core.CallError('Message size exceeded')) return args = msg.unpickle(throw=False) if (args == mitogen.core._DEAD or isinstance(args, mitogen.core.CallError) or not self.validate_args(args)): LOG.warning('Received junk message: %r', args) return try: msg.reply(self.dispatch(args, msg)) except Exception, e: LOG.exception('While invoking %r.dispatch()', self) msg.reply(mitogen.core.CallError(e))
def _on_get_module(self, msg): if msg.is_dead: return stream = self._router.stream_by_id(msg.src_id) if stream is None: return fullname = msg.data.decode() self._log.debug('%s requested module %s', stream.name, fullname) self.get_module_count += 1 if fullname in stream.protocol.sent_modules: LOG.warning('_on_get_module(): dup request for %r from %r', fullname, stream) t0 = mitogen.core.now() try: self._send_module_and_related(stream, fullname) finally: self.get_module_secs += mitogen.core.now() - t0
def _send_module_and_related(self, stream, fullname): try: tup = self._build_tuple(fullname) if tup[2] and is_stdlib_path(tup[2]): # Prevent loading of 2.x<->3.x stdlib modules! This costs one # RTT per hit, so a client-side solution is also required. LOG.warning('%r: refusing to serve stdlib module %r', self, fullname) self._send_module_load_failed(stream, fullname) return for name in tup[4]: # related parent, _, _ = name.partition('.') if parent != fullname and parent not in stream.sent_modules: # Parent hasn't been sent, so don't load submodule yet. continue self._send_load_module(stream, name) self._send_load_module(stream, fullname) except Exception: LOG.debug('While importing %r', fullname, exc_info=True) self._send_module_load_failed(stream, fullname)
def get_module_source(self, fullname): """Given the name of a loaded module `fullname`, attempt to find its source code. :returns: Tuple of `(module path, source text, is package?)`, or ``None`` if the source cannot be found. """ tup = self._found_cache.get(fullname) if tup: return tup for method in self.get_module_methods: tup = method(self, fullname) if tup: break else: tup = None, None, None LOG.warning('get_module_source(%r): cannot find source', fullname) self._found_cache[fullname] = tup return tup
class Service(object): #: If ``None``, a handle is dynamically allocated, otherwise the fixed #: integer handle to use. handle = None max_message_size = 0 def __init__(self, router): self.router = router self.recv = mitogen.core.Receiver(router, self.handle) self.handle = self.recv.handle self.running = True def validate_args(self, args): return True def run_once(self): try: msg = self.recv.get() except mitogen.core.ChannelError, e: # Channel closed due to broker shutdown, exit gracefully. LOG.debug('%r: channel closed: %s', self, e) self.running = False return if len(msg.data) > self.max_message_size: LOG.error('%r: larger than permitted size: %r', self, msg) msg.reply(mitogen.core.CallError('Message size exceeded')) return args = msg.unpickle(throw=False) if (args == mitogen.core._DEAD or isinstance(args, mitogen.core.CallError) or not self.validate_args(args)): LOG.warning('Received junk message: %r', args) return try: msg.reply(self.dispatch(args, msg)) except Exception, e: LOG.exception('While invoking %r.dispatch()', self) msg.reply(mitogen.core.CallError(e))