def handle_rpc(self, request): initial_ctx = HttpMethodContext(self.http_transport, request, self.http_transport.app.out_protocol.mime_type) initial_ctx.in_string = [request.content.getvalue()] contexts = self.http_transport.generate_contexts(initial_ctx) p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_in_object(p_ctx) if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_error(p_ctx, others, p_ctx.out_error, request) self.http_transport.get_out_string(p_ctx) process_contexts(self.http_transport, others, p_ctx) def _cb_request_finished(request): request.finish() producer = _Producer(p_ctx.out_string, request) producer.deferred.addErrback(err).addCallback(_cb_request_finished) request.registerProducer(producer, False) return NOT_DONE_YET
def handle_rpc(self, request): initial_ctx = HttpMethodContext(self.http_transport, request, self.http_transport.app.out_protocol.mime_type) initial_ctx.in_string = [request.content.getvalue()] contexts = self.http_transport.generate_contexts(initial_ctx) p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_in_object(p_ctx) if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_error(p_ctx, others, p_ctx.out_error, request) def _cb_request_finished(request): request.finish() p_ctx.close() def _eb_request_finished(request): err(request) p_ctx.close() def _cb_deferred(retval, request): if len(p_ctx.descriptor.out_message._type_info) <= 1: p_ctx.out_object = [retval] else: p_ctx.out_object = retval self.http_transport.get_out_string(p_ctx) process_contexts(self.http_transport, others, p_ctx) producer = _Producer(p_ctx.out_string, request) producer.deferred.addCallbacks(_cb_request_finished, _eb_request_finished) request.registerProducer(producer, False) def _eb_deferred(retval, request): p_ctx.out_error = retval return self.handle_error(p_ctx, others, p_ctx.out_error, request) ret = p_ctx.out_object[0] if isinstance(ret, Deferred): ret.addCallback(_cb_deferred, request) ret.addErrback(_eb_deferred, request) else: _cb_deferred(request) return NOT_DONE_YET
def get_contexts(self, request): """Generate contexts for rpc request. :param request: Django HttpRequest instance. :returns: generated contexts """ initial_ctx = HttpMethodContext(self, request, self.app.out_protocol.mime_type) initial_ctx.in_string = [request.body] return self.generate_contexts(initial_ctx)
def get_contexts(self, request): """Generate contexts for rpc request. :param response: Django HttpRequest instance. :returns: generated contexts """ initial_ctx = HttpMethodContext(self, request, self.app.out_protocol.mime_type) initial_ctx.in_string = request.body in_string_charset = request.encoding or settings.DEFAULT_CHARSET return self.generate_contexts(initial_ctx, in_string_charset)
def get_contexts(self, request): """Generate contexts for rpc request. :param request: Django HttpRequest instance. :returns: generated contexts """ initial_ctx = HttpMethodContext(self, request, self.app.out_protocol.mime_type) initial_ctx.in_string = request.body in_string_charset = request.encoding or settings.DEFAULT_CHARSET return self.generate_contexts(initial_ctx, in_string_charset)
def __handle_wsdl_request(self, request): ctx = HttpMethodContext(self.http_transport, request, "text/xml; charset=utf-8") url = _reconstruct_url(request) try: ctx.transport.wsdl = self._wsdl if ctx.transport.wsdl is None: from spyne.interface.wsdl.wsdl11 import Wsdl11 wsdl = Wsdl11(self.http_transport.app.interface) wsdl.build_interface_document(url) self._wsdl = ctx.transport.wsdl = wsdl.get_interface_document() assert ctx.transport.wsdl != None self.http_transport.event_manager.fire_event('wsdl', ctx) for k, v in ctx.transport.resp_headers.items(): if isinstance(v, (list, tuple)): for v2 in v: request.setHeader(k, v2) else: request.setHeader(k, v) return ctx.transport.wsdl except Exception, e: ctx.transport.wsdl_error = e self.http_transport.event_manager.fire_event('wsdl_exception', ctx) raise
def __handle_wsdl_request(self, request): ctx = HttpMethodContext(self.http_transport, request, "text/xml; charset=utf-8") url = _reconstruct_url(request) if self.http_transport.doc.wsdl11 is None: return HTTP_404 if self._wsdl is None: self._wsdl = self.http_transport.doc.wsdl11.get_interface_document( ) ctx.transport.wsdl = self._wsdl try: if self._wsdl is None: self.http_transport.doc.wsdl11.build_interface_document(url) ctx.transport.wsdl = self._wsdl = \ self.http_transport.doc.wsdl11.get_interface_document() assert ctx.transport.wsdl is not None self.http_transport.event_manager.fire_event('wsdl', ctx) return ctx.transport.wsdl except Exception, e: ctx.transport.wsdl_error = e self.http_transport.event_manager.fire_event('wsdl_exception', ctx) raise
def handle_wsdl(self, request, *args, **kwargs): """Return services WSDL.""" ctx = HttpMethodContext(self, request, 'text/xml; charset=utf-8') if self.doc.wsdl11 is None: raise Http404('WSDL is not available') if self._wsdl is None: # Interface document building is not thread safe so we don't use # server interface document shared between threads. Instead we # create and build interface documents in current thread. This # section can be safely repeated in another concurrent thread. doc = AllYourInterfaceDocuments(self.app.interface) doc.wsdl11.build_interface_document(request.build_absolute_uri()) wsdl = doc.wsdl11.get_interface_document() if self._cache_wsdl: self._wsdl = wsdl else: wsdl = self._wsdl ctx.transport.wsdl = wsdl response = HttpResponse(ctx.transport.wsdl) return self.response(response, ctx, ())
def handle_rpc(self, request): initial_ctx = HttpMethodContext( self.http_transport, request, self.http_transport.app.out_protocol.mime_type) initial_ctx.in_string = [request.content.getvalue()] contexts = self.http_transport.generate_contexts(initial_ctx) p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_in_object(p_ctx) if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_error(p_ctx, others, p_ctx.out_error, request) self.http_transport.get_out_string(p_ctx) process_contexts(self.http_transport, others, p_ctx) def _cb_request_finished(request): request.finish() p_ctx.close() def _eb_request_finished(request): err(request) p_ctx.close() producer = _Producer(p_ctx.out_string, request) producer.deferred.addErrback(_eb_request_finished).addCallback( _cb_request_finished) request.registerProducer(producer, False) return NOT_DONE_YET
def handle_wsdl(self, request, *args, **kwargs): """Return services WSDL.""" ctx = HttpMethodContext(self, request, "text/xml; charset=utf-8") if self.doc.wsdl11 is None: raise Http404("WSDL is not available") if self._wsdl is None: # Interface document building is not thread safe so we don't use # server interface document shared between threads. Instead we # create and build interface documents in current thread. This # section can be safely repeated in another concurrent thread. doc = AllYourInterfaceDocuments(self.app.interface) doc.wsdl11.build_interface_document(request.build_absolute_uri()) self._wsdl = doc.wsdl11.get_interface_document() ctx.transport.wsdl = self._wsdl ctx.close() response = HttpResponse(ctx.transport.wsdl) return self.response(response, ctx, ())
def __init__(self, transport, req_env, content_type): HttpMethodContext.__init__(self, transport, req_env, content_type) self.transport = WsgiTransportContext(transport, req_env, content_type) """Holds the WSGI-specific information"""
def handle_rpc(self, request): initial_ctx = HttpMethodContext( self.http_transport, request, self.http_transport.app.out_protocol.mime_type) initial_ctx.in_string = [request.content.getvalue()] contexts = self.http_transport.generate_contexts(initial_ctx) p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_rpc_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_in_object(p_ctx) if p_ctx.in_error: return self.handle_rpc_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) def _cb_request_finished(request): request.finish() p_ctx.close() def _eb_request_finished(request): err(request) p_ctx.close() request.finish() def _cb_deferred(retval, request, cb=True): if cb and len(p_ctx.descriptor.out_message._type_info) <= 1: p_ctx.out_object = [retval] else: p_ctx.out_object = retval self.http_transport.get_out_string(p_ctx) process_contexts(self.http_transport, others, p_ctx) producer = _Producer(p_ctx.out_string, request) producer.deferred.addCallbacks(_cb_request_finished, _eb_request_finished) request.registerProducer(producer, False) def _eb_deferred(retval, request): p_ctx.out_error = retval.value if not issubclass(retval.type, Fault): retval.printTraceback() p_ctx.out_error = InternalError(retval.value) ret = self.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) request.write(ret) request.finish() ret = p_ctx.out_object[0] if isinstance(ret, Deferred): ret.addCallback(_cb_deferred, request) ret.addErrback(_eb_deferred, request) elif isinstance(ret, PushBase): gen = self.http_transport.get_out_string(p_ctx) assert isgenerator(gen), "It looks like this protocol is not " \ "async-compliant yet." def _cb_push(): process_contexts(self.http_transport, others, p_ctx) producer = _Producer(p_ctx.out_string, request) producer.deferred.addCallbacks(_cb_request_finished, _eb_request_finished) request.registerProducer(producer, False) ret.init(p_ctx, request, gen, _cb_push, None) else: _cb_deferred(p_ctx.out_object, request, cb=False) return NOT_DONE_YET
def handle_rpc(self, request): initial_ctx = HttpMethodContext(self.http_transport, request, self.http_transport.app.out_protocol.mime_type) initial_ctx.in_string = [request.content.getvalue()] contexts = self.http_transport.generate_contexts(initial_ctx) p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_rpc_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_in_object(p_ctx) if p_ctx.in_error: return self.handle_rpc_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) def _cb_request_finished(request): request.finish() p_ctx.close() def _eb_request_finished(request): err(request) p_ctx.close() request.finish() def _cb_deferred(retval, request, cb=True): if cb and len(p_ctx.descriptor.out_message._type_info) <= 1: p_ctx.out_object = [retval] else: p_ctx.out_object = retval self.http_transport.get_out_string(p_ctx) process_contexts(self.http_transport, others, p_ctx) producer = _Producer(p_ctx.out_string, request) producer.deferred.addCallbacks(_cb_request_finished, _eb_request_finished) request.registerProducer(producer, False) def _eb_deferred(retval, request): p_ctx.out_error = retval.value if not issubclass(retval.type, Fault): retval.printTraceback() p_ctx.out_error = InternalError(retval.value) ret = self.handle_rpc_error(p_ctx, others, p_ctx.out_error, request) request.write(ret) request.finish() ret = p_ctx.out_object[0] if isinstance(ret, Deferred): ret.addCallback(_cb_deferred, request) ret.addErrback(_eb_deferred, request) elif isinstance(ret, PushBase): gen = self.http_transport.get_out_string(p_ctx) assert isgenerator(gen), "It looks like this protocol is not " \ "async-compliant yet." def _cb_push(): process_contexts(self.http_transport, others, p_ctx) producer = _Producer(p_ctx.out_string, request) producer.deferred.addCallbacks(_cb_request_finished, _eb_request_finished) request.registerProducer(producer, False) ret.init(p_ctx, request, gen, _cb_push, None) else: _cb_deferred(p_ctx.out_object, request, cb=False) return NOT_DONE_YET
def handle_rpc(self, request): initial_ctx = HttpMethodContext( self.http_transport, request, self.http_transport.app.out_protocol.mime_type) initial_ctx.in_string = [request.content.getvalue()] contexts = self.http_transport.generate_contexts(initial_ctx) p_ctx, others = contexts[0], contexts[1:] if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_in_object(p_ctx) if p_ctx.in_error: return self.handle_error(p_ctx, others, p_ctx.in_error, request) else: self.http_transport.get_out_object(p_ctx) if p_ctx.out_error: return self.handle_error(p_ctx, others, p_ctx.out_error, request) def _cb_request_finished(request): request.finish() p_ctx.close() def _eb_request_finished(request): err(request) p_ctx.close() def _cb_deferred(retval, request): if len(p_ctx.descriptor.out_message._type_info) <= 1: p_ctx.out_object = [retval] else: p_ctx.out_object = retval self.http_transport.get_out_string(p_ctx) process_contexts(self.http_transport, others, p_ctx) producer = _Producer(p_ctx.out_string, request) producer.deferred.addCallbacks(_cb_request_finished, _eb_request_finished) request.registerProducer(producer, False) def _eb_deferred(retval, request): p_ctx.out_error = retval return self.handle_error(p_ctx, others, p_ctx.out_error, request) ret = p_ctx.out_object[0] if isinstance(ret, Deferred): ret.addCallback(_cb_deferred, request) ret.addErrback(_eb_deferred, request) else: _cb_deferred(request) return NOT_DONE_YET