def file_to_string_iterable(self, cls, value): if value.data is None: if value.handle is None: assert value.path is not None, "You need to write data to " \ "persistent storage first if you want to read it back." try: path = value.path if not isabs(value.path): path = join(value.store, value.path) f = open(path, 'rb') except IOError as e: if e.errno == errno.ENOENT: raise ResourceNotFoundError(value.path) else: raise InternalError("Error accessing requested file") else: f = value.handle f.seek(0) return _file_to_iter(f) else: if isinstance(value.data, (list,tuple)) and \ isinstance(value.data[0], mmap): return _file_to_iter(value.data[0]) else: return iter(value.data)
def file_to_bytes_iterable(self, cls, value, **_): if value.data is not None: if isinstance(value.data, (list, tuple)) and \ isinstance(value.data[0], mmap): return _file_to_iter(value.data[0]) return iter(value.data) if value.handle is not None: f = value.handle f.seek(0) return _file_to_iter(f) assert value.path is not None, "You need to write data to " \ "persistent storage first if you want to read it back." try: path = value.path if not isabs(value.path): path = join(value.store, value.path) assert abspath(path).startswith(value.store), \ "No relative paths are allowed" return _file_to_iter(open(path, 'rb')) except IOError as e: if e.errno == errno.ENOENT: raise ResourceNotFoundError(value.path) else: raise InternalError("Error accessing requested file")
class Application(AppBase): def __init__(self, services, tns, name=None, in_protocol=None, out_protocol=None, db=None): AppBase.__init__(self, services, tns, name, in_protocol, out_protocol) self.event_manager.add_listener("method_call", _on_method_call) self.event_manager.add_listener("method_context_closed", _on_method_context_closed) self.db = db self.Session = sessionmaker(bind=db, expire_on_commit=False) def call_wrapper(self, ctx): try: return ctx.service_class.call_wrapper(ctx) except NoResultFound: raise ResourceNotFoundError(ctx.in_object) except Fault, e: log.err() raise except Exception, e: log.err() # This should not happen! Let the team know via email! if EXCEPTION_ADDRESS: email_exception(EXCEPTION_ADDRESS) raise InternalError(e)
class MyApplication(Application): def __init__(self, services, tns, name=None, in_protocol=None, out_protocol=None): Application.__init__(self, services, tns, name, in_protocol, out_protocol) self.event_manager.add_listener('method_call', _on_method_call) self.event_manager.add_listener("method_context_closed", _on_method_context_closed) def call_wrapper(self, ctx): try: return ctx.service_class.call_wrapper(ctx) except NoResultFound: raise ResourceNotFoundError(ctx.in_object) except Fault, e: logger.error(e) raise except Exception, e: logger.exception(e) # This should not happen! Let the team know via email email_exception(EXCEPTION_ADDRESS) raise InternalError(e)
def _cb_deferred(ret, prot, p_ctx, others, nowrap=False): # if there is one return value or the output is bare (which means there # can't be anything other than 1 return value case) use the enclosing list. # otherwise, the return value is a tuple anyway, so leave it alone. if nowrap: p_ctx.out_object = ret else: if p_ctx.descriptor.is_out_bare(): p_ctx.out_object = [ret] else: if len(p_ctx.descriptor.out_message._type_info) > 1: p_ctx.out_object = ret else: p_ctx.out_object = [ret] try: prot.spyne_tpt.get_out_string(p_ctx) prot.spyne_tpt.pack(p_ctx) out_string = b''.join(p_ctx.out_string) p_ctx.transport.resp_length = len(out_string) prot.enqueue_outresp_data(id(p_ctx), out_string) except Exception as e: logger.exception(e) logger.error("%r", p_ctx) prot.handle_error(p_ctx, others, InternalError(e)) finally: p_ctx.close() process_contexts(prot.spyne_tpt, others, p_ctx)
class MyApplication(Application): def __init__(self, services, tns, name=None, in_protocol=None, out_protocol=None): super(MyApplication, self).__init__(services, tns, name, in_protocol, out_protocol) self.event_manager.add_listener('method_call', _on_method_call) self.event_manager.add_listener("method_context_closed", _on_method_context_closed) def call_wrapper(self, ctx): try: return ctx.service_class.call_wrapper(ctx) except NoResultFound: raise ResourceNotFoundError(ctx.in_object) except Fault, e: logging.error(e) raise except Exception, e: logging.exception(e) raise InternalError(e)
def _eb_deferred(ret, request, p_ctx, others, resource): app = p_ctx.app # DRY this with what's in Application.process_request if issubclass(ret.type, Redirect): try: ret.value.do_redirect() # Now that the processing is switched to the outgoing message, # point ctx.protocol to ctx.out_protocol p_ctx.protocol = p_ctx.outprot_ctx _cb_deferred(None, request, p_ctx, others, resource, cb=False) # fire events app.event_manager.fire_event('method_redirect', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_redirect', p_ctx) except Exception as e: logger_server.exception(e) p_ctx.out_error = Fault('Server', get_fault_string_from_exception(e)) # fire events app.event_manager.fire_event('method_redirect_exception', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_redirect_exception', p_ctx) elif issubclass(ret.type, Fault): p_ctx.out_error = ret.value ret = resource.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) # fire events app.event_manager.fire_event('method_exception_object', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_exception_object', p_ctx) request.write(ret) else: p_ctx.out_error = ret.value ret.printTraceback() p_ctx.out_error = InternalError(ret.value) # fire events app.event_manager.fire_event('method_exception_object', p_ctx) if p_ctx.service_class is not None: p_ctx.service_class.event_manager.fire_event( 'method_exception_object', p_ctx) request.finish()
def _eb_deferred(retval, request, p_ctx, others, resource): p_ctx.out_error = retval.value if not issubclass(retval.type, Fault): retval.printTraceback() p_ctx.out_error = InternalError(retval.value) ret = resource.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) request.write(ret) request.finish()
def _eb_deferred(retval, prot, p_ctx, others): p_ctx.out_error = retval.value if not issubclass(retval.type, Fault): retval.printTraceback() p_ctx.out_error = InternalError(retval.value) ret = prot.handle_rpc_error(p_ctx, others, p_ctx.out_error) prot.transport.write(ret) prot.transport.loseConnection()
def _eb_deferred(fail, prot, p_ctx, others): assert isinstance(fail, Failure) if isinstance(fail.value, Fault): p_ctx.out_error = fail.value else: p_ctx.out_error = InternalError(fail.value) if not getattr(fail, 'logged', False): fail.printTraceback() prot.handle_error(p_ctx, others, p_ctx.out_error)
def _eb_deferred(retval, prot, p_ctx, others): p_ctx.out_error = retval.value tb = None if isinstance(retval, Failure): tb = retval.getTracebackObject() retval.printTraceback() p_ctx.out_error = InternalError(retval.value) prot.handle_error(p_ctx, others, p_ctx.out_error) prot.transport.write(''.join(p_ctx.out_string)) prot.transport.loseConnection() return Failure(p_ctx.out_error, p_ctx.out_error.__class__, tb)
def call_wrapper(self, ctx): try: return ctx.service_class.call_wrapper(ctx) except NoResultFound: raise ResourceNotFoundError(ctx.in_object) except Fault as e: logging.error(e) raise except Exception as e: logging.exception(e) raise InternalError(e)
def _eb_deferred(fail, prot, p_ctx, others): assert isinstance(fail, Failure) if isinstance(fail.value, Fault): p_ctx.out_error = fail.value else: p_ctx.out_error = InternalError(fail.value) if not getattr(fail, 'logged', False): logger.error(fail.getTraceback()) try: prot.handle_error(p_ctx, others, p_ctx.out_error) except Exception as e: logger.exception(e) raise
def call_wrapper(self, ctx): try: return ctx.service_class.call_wrapper(ctx) except NoResultFound: raise ResourceNotFoundError(ctx.in_object) except Fault as e: log.err() raise except Exception as e: log.err() # This should not happen! Let the team know via email! if EXCEPTION_ADDRESS: email_exception(EXCEPTION_ADDRESS) raise InternalError(e)
def CreateEvent(ctx, CreateEventInput: EventTicketRequest): create_event_url = ctx.udc.create_event_url # Get auth_key, event, list section, callback URL auth_key = ctx.udc.token event = CreateEventInput.event list_section = CreateEventInput.list_section callback_type = CreateEventInput.callback_type callback = CreateEventInput.callback # Create payload and request to create_event_url payload = create_request(event, list_section, callback, callback_type, auth_key) camunda_resp = requests.post(create_event_url, json=payload) if camunda_resp.status_code == 404: raise ResourceNotFoundError(camunda_resp) elif not camunda_resp.ok: raise InternalError(Exception("Spyne Server Error")) return EventTicketResp( 200, "Processing your input. Detail will be given to your callback URL")
def _eb_deferred(fail, prot, p_ctx, others): p_ctx.out_error = fail.value tb = None if isinstance(fail, Failure): tb = fail.getTracebackObject() fail.printTraceback() p_ctx.out_error = InternalError(fail.value) prot.handle_error(p_ctx, others, p_ctx.out_error) data_len = 0 for data in p_ctx.out_string: prot.transport_write(data) data_len += len(data) p_ctx.transport.resp_length = data_len return Failure(p_ctx.out_error, p_ctx.out_error.__class__, tb)
def _eb_deferred(fail, prot, p_ctx, others): assert isinstance(fail, Failure) if isinstance(fail.value, Fault): p_ctx.out_error = fail.value else: p_ctx.out_error = InternalError(fail.value) if not getattr(fail, 'logged', False): fail.printTraceback() prot.handle_error(p_ctx, others, p_ctx.out_error) data_len = 0 for data in p_ctx.out_string: prot.enqueue_outresp_data(id(p_ctx), data) data_len += len(data) p_ctx.transport.resp_length = data_len
class Application(SpyneApplication): """ Замена Application из spyne. Позволяет дополнительно обрабатывать эксепшны файрит ивент, method_call_exception, но в аргументе передает не контекст, а форматированный текст exception """ def call_wrapper(self, ctx): try: return super(Application, self).call_wrapper(ctx) except Fault, e: logger.exception(e) raise except Exception, e: e_text = unicode(format_exc(), errors="ignore") self.event_manager.fire_event("method_call_exception", e_text) logger.exception(e) raise InternalError(e)
def _eb_deferred(ret, request, p_ctx, others, resource): # DRY this with what's in Application.process_request if ret.check(Redirect): try: ret.value.do_redirect() # Now that the processing is switched to the outgoing message, # point ctx.protocol to ctx.out_protocol p_ctx.protocol = p_ctx.outprot_ctx _cb_deferred(None, request, p_ctx, others, resource, cb=False) p_ctx.fire_event('method_redirect') except Exception as e: logger_server.exception(e) p_ctx.out_error = Fault('Server', get_fault_string_from_exception(e)) p_ctx.fire_event('method_redirect_exception') elif ret.check(Fault): p_ctx.out_error = ret.value ret = resource.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) p_ctx.fire_event('method_exception_object') request.write(ret) else: p_ctx.out_error = InternalError(ret.value) logger.error(ret.getTraceback()) ret = resource.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) p_ctx.fire_event('method_exception_object') request.write(ret) request.finish()
def _wrap(*args, **kwargs): self = args[0] try: retval = f(*args, **kwargs) self.session.expunge_all() return retval except NoResultFound: raise ResourceNotFoundError(self.ctx.in_object) except Fault as e: log.err() raise except Exception as e: log.err() # This should not happen! Let the team know via email! email_exception(EXCEPTION_ADDRESS) raise InternalError(e)
def _cb_deferred(self, ret, p_ctx, others, nowrap=False): # this means callback is not invoked directly instead of as part of a # deferred chain if not nowrap: # if there is one return value or the output is bare (which means # there can't be anything other than 1 return value case) use the # enclosing list. otherwise, the return value is a tuple anyway, so # leave it be. if p_ctx.descriptor.is_out_bare(): p_ctx.out_object = [ret] else: if len(p_ctx.descriptor.out_message._type_info) > 1: p_ctx.out_object = ret else: p_ctx.out_object = [ret] if p_ctx.oob_ctx is not None: assert isinstance(p_ctx.oob_ctx.d, Deferred) p_ctx.oob_ctx.d.callback(p_ctx.out_object) return try: self.spyne_tpt.get_out_string(p_ctx) self.spyne_tpt.pack(p_ctx) out_string = b''.join(p_ctx.out_string) p_ctx.transport.resp_length = len(out_string) self.enqueue_outresp_data(id(p_ctx), out_string) except Exception as e: logger.exception(e) logger.error("%r", p_ctx) self.handle_error(p_ctx, others, InternalError(e)) finally: p_ctx.close() process_contexts(self.spyne_tpt, others, p_ctx)
def _cb_deferred(retval, prot, p_ctx, others, nowrap=False): if len(p_ctx.descriptor.out_message._type_info) > 1 or nowrap: p_ctx.out_object = retval else: p_ctx.out_object = [retval] try: prot._transport.get_out_string(p_ctx) prot._transport.pack(p_ctx) out_string = ''.join(p_ctx.out_string) prot.transport.write(out_string) except Exception as e: logger.exception(e) prot.handle_error(p_ctx, others, InternalError(e)) finally: p_ctx.close() process_contexts(prot._transport, others, p_ctx)
def process_contexts(self, contexts): p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error) self.get_in_object(p_ctx) if p_ctx.in_error: logger.error(p_ctx.in_error) return self.handle_error(p_ctx, others, p_ctx.in_error) self.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_error(p_ctx, others, p_ctx.out_error) try: self.get_out_string(p_ctx) except Exception as e: logger.exception(e) contexts.out_error = InternalError("Serialization Error.") return self.handle_error(contexts, others, contexts.out_error)
def _cb_deferred(ret, prot, p_ctx, others, nowrap=False): if len(p_ctx.descriptor.out_message._type_info) > 1 or nowrap: p_ctx.out_object = ret else: p_ctx.out_object = [ret] try: prot.spyne_tpt.get_out_string(p_ctx) prot.spyne_tpt.pack(p_ctx) out_string = b''.join(p_ctx.out_string) p_ctx.transport.resp_length = len(out_string) prot.enqueue_outresp_data(id(p_ctx), out_string) except Exception as e: logger.exception(e) prot.handle_error(p_ctx, others, InternalError(e)) finally: p_ctx.close() process_contexts(prot.spyne_tpt, others, p_ctx)