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 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 __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_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
