def handle_rpc(self, req_env, start_response):
initial_ctx = WsgiMethodContext(self, req_env,
self.app.out_protocol.mime_type)
self.event_manager.fire_event('wsgi_call', initial_ctx)
initial_ctx.in_string, in_string_charset = \
self.__reconstruct_wsgi_request(req_env)
contexts = self.generate_contexts(initial_ctx, in_string_charset)
p_ctx, others = contexts[0], contexts[1:]
# TODO: rate limiting
p_ctx.active = True
if p_ctx.in_error:
return self.handle_error(p_ctx, others, p_ctx.in_error,
start_response)
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,
start_response)
self.get_out_object(p_ctx)
if p_ctx.out_error:
return self.handle_error(p_ctx, others, p_ctx.out_error,
start_response)
assert p_ctx.out_object is not None
g = next(iter(p_ctx.out_object))
is_generator = len(p_ctx.out_object) == 1 and isgenerator(g)
# if the out_object is a generator function, this hack makes the user
# code run until first yield, which lets it set response headers and
# whatnot before calling start_response. It's important to run this
# here before serialization as the user function can also set output
# protocol. Is there a better way?
if is_generator:
first_obj = next(g)
p_ctx.out_object = ( chain((first_obj,), g), )
if p_ctx.transport.resp_code is None:
p_ctx.transport.resp_code = HTTP_200
try:
self.get_out_string(p_ctx)
except Exception as e:
logger.exception(e)
p_ctx.out_error = Fault('Server', get_fault_string_from_exception(e))
return self.handle_error(p_ctx, others, p_ctx.out_error,
start_response)
if isinstance(p_ctx.out_protocol, HttpRpc) and \
p_ctx.out_header_doc is not None:
p_ctx.transport.resp_headers.update(p_ctx.out_header_doc)
if p_ctx.descriptor and p_ctx.descriptor.mtom:
# when there is more than one return type, the result is
# encapsulated inside a list. when there's just one, the result
# is returned in a non-encapsulated form. the apply_mtom always
# expects the objects to be inside an iterable, hence the
# following test.
out_type_info = p_ctx.descriptor.out_message._type_info
if len(out_type_info) == 1:
p_ctx.out_object = [p_ctx.out_object]
p_ctx.transport.resp_headers, p_ctx.out_string = apply_mtom(
p_ctx.transport.resp_headers, p_ctx.out_string,
p_ctx.descriptor.out_message._type_info.values(),
p_ctx.out_object,
)
self.event_manager.fire_event('wsgi_return', p_ctx)
if self.chunked:
# the user has not set a content-length, so we delete it as the
# input is just an iterable.
if 'Content-Length' in p_ctx.transport.resp_headers:
del p_ctx.transport.resp_headers['Content-Length']
else:
p_ctx.out_string = [''.join(p_ctx.out_string)]
try:
len(p_ctx.out_string)
p_ctx.transport.resp_headers['Content-Length'] = \
str(sum([len(a) for a in p_ctx.out_string]))
except TypeError:
pass
start_response(p_ctx.transport.resp_code,
_gen_http_headers(p_ctx.transport.resp_headers))
retval = chain(p_ctx.out_string, self.__finalize(p_ctx))
try:
process_contexts(self, others, p_ctx, error=None)
except Exception as e:
# Report but ignore any exceptions from auxiliary methods.
logger.exception(e)
return retval
def handle_rpc(self, req_env, start_response):
initial_ctx = WsgiMethodContext(self, req_env,
self.app.out_protocol.mime_type)
self.event_manager.fire_event('wsgi_call', initial_ctx)
initial_ctx.in_string, in_string_charset = \
self.__reconstruct_wsgi_request(req_env)
contexts = self.generate_contexts(initial_ctx, in_string_charset)
p_ctx, others = contexts[0], contexts[1:]
# TODO: rate limiting
p_ctx.active = True
if p_ctx.in_error:
return self.handle_error(p_ctx, others, p_ctx.in_error,
start_response)
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,
start_response)
self.get_out_object(p_ctx)
if p_ctx.out_error:
return self.handle_error(p_ctx, others, p_ctx.out_error,
start_response)
assert p_ctx.out_object is not None
g = next(iter(p_ctx.out_object))
is_generator = len(p_ctx.out_object) == 1 and isgenerator(g)
# if the out_object is a generator function, this hack makes the user
# code run until first yield, which lets it set response headers and
# whatnot before calling start_response. It's important to run this
# here before serialization as the user function can also set output
# protocol. Is there a better way?
if is_generator:
first_obj = next(g)
p_ctx.out_object = (chain((first_obj, ), g), )
if p_ctx.transport.resp_code is None:
p_ctx.transport.resp_code = HTTP_200
try:
self.get_out_string(p_ctx)
except Exception as e:
logger.exception(e)
p_ctx.out_error = Fault('Server',
get_fault_string_from_exception(e))
return self.handle_error(p_ctx, others, p_ctx.out_error,
start_response)
if isinstance(p_ctx.out_protocol, HttpRpc) and \
p_ctx.out_header_doc is not None:
p_ctx.transport.resp_headers.update(p_ctx.out_header_doc)
if p_ctx.descriptor and p_ctx.descriptor.mtom:
# when there is more than one return type, the result is
# encapsulated inside a list. when there's just one, the result
# is returned in a non-encapsulated form. the apply_mtom always
# expects the objects to be inside an iterable, hence the
# following test.
out_type_info = p_ctx.descriptor.out_message._type_info
if len(out_type_info) == 1:
p_ctx.out_object = [p_ctx.out_object]
p_ctx.transport.resp_headers, p_ctx.out_string = apply_mtom(
p_ctx.transport.resp_headers,
p_ctx.out_string,
p_ctx.descriptor.out_message._type_info.values(),
p_ctx.out_object,
)
self.event_manager.fire_event('wsgi_return', p_ctx)
if self.chunked:
# the user has not set a content-length, so we delete it as the
# input is just an iterable.
if 'Content-Length' in p_ctx.transport.resp_headers:
del p_ctx.transport.resp_headers['Content-Length']
else:
p_ctx.out_string = [''.join(p_ctx.out_string)]
try:
len(p_ctx.out_string)
p_ctx.transport.resp_headers['Content-Length'] = \
str(sum([len(a) for a in p_ctx.out_string]))
except TypeError:
pass
start_response(p_ctx.transport.resp_code,
_gen_http_headers(p_ctx.transport.resp_headers))
retval = chain(p_ctx.out_string, self.__finalize(p_ctx))
try:
process_contexts(self, others, p_ctx, error=None)
except Exception as e:
# Report but ignore any exceptions from auxiliary methods.
logger.exception(e)
return retval
p_ctx.out_header_doc is not None:
p_ctx.transport.resp_headers.update(p_ctx.out_header_doc)
if p_ctx.descriptor and p_ctx.descriptor.mtom:
# when there is more than one return type, the result is
# encapsulated inside a list. when there's just one, the result
# is returned in a non-encapsulated form. the apply_mtom always
# expects the objects to be inside an iterable, hence the
# following test.
out_type_info = p_ctx.descriptor.out_message._type_info
if len(out_type_info) == 1:
out_object = [out_object]
p_ctx.transport.resp_headers, p_ctx.out_string = apply_mtom(
p_ctx.transport.resp_headers, p_ctx.out_string,
p_ctx.descriptor.out_message._type_info.values(),
out_object
)
self.event_manager.fire_event('wsgi_return', p_ctx)
if self.chunked:
# the user has not set a content-length, so we delete it as the
# input is just an iterable.
if 'Content-Length' in p_ctx.transport.resp_headers:
del p_ctx.transport.resp_headers['Content-Length']
else:
p_ctx.out_string = [''.join(p_ctx.out_string)]
# if the out_string is a generator function, this hack lets the user
# code run until first yield, which lets it set response headers and
def handle_rpc(self, req_env, start_response):
initial_ctx = WsgiMethodContext(self, req_env,
self.app.out_protocol.mime_type)
# implementation hook
self.event_manager.fire_event('wsgi_call', initial_ctx)
initial_ctx.in_string, in_string_charset = \
self.__reconstruct_wsgi_request(req_env)
contexts = self.generate_contexts(initial_ctx, in_string_charset)
p_ctx, others = contexts[0], contexts[1:]
if p_ctx.in_error:
return self.handle_error(p_ctx, others, p_ctx.in_error,
start_response)
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,
start_response)
self.get_out_object(p_ctx)
if p_ctx.out_error:
return self.handle_error(p_ctx, others, p_ctx.out_error,
start_response)
if p_ctx.transport.resp_code is None:
p_ctx.transport.resp_code = HTTP_200
self.get_out_string(p_ctx)
if isinstance(self.app.out_protocol, HttpRpc) and \
p_ctx.out_header_doc is not None:
p_ctx.transport.resp_headers.update(p_ctx.out_header_doc)
if p_ctx.descriptor and p_ctx.descriptor.mtom:
# when there is more than one return type, the result is
# encapsulated inside a list. when there's just one, the result
# is returned in a non-encapsulated form. the apply_mtom always
# expects the objects to be inside an iterable, hence the
# following test.
out_type_info = p_ctx.descriptor.out_message._type_info
if len(out_type_info) == 1:
out_object = [out_object]
p_ctx.transport.resp_headers, p_ctx.out_string = apply_mtom(
p_ctx.transport.resp_headers, p_ctx.out_string,
p_ctx.descriptor.out_message._type_info.values(), out_object)
# implementation hook
self.event_manager.fire_event('wsgi_return', p_ctx)
if self.chunked:
# the client has not set a content-length, so we delete it as the
# input is just an iterable.
if 'Content-Length' in p_ctx.transport.resp_headers:
del p_ctx.transport.resp_headers['Content-Length']
else:
p_ctx.out_string = [''.join(p_ctx.out_string)]
# if the out_string is a generator function, this hack lets the user
# code run until first yield, which lets it set response headers and
# whatnot before calling start_response. Is there a better way?
try:
len(p_ctx.out_string) # generator?
# nope
p_ctx.transport.resp_headers['Content-Length'] = \
str(sum([len(a) for a in p_ctx.out_string]))
start_response(p_ctx.transport.resp_code,
_gen_http_headers(p_ctx.transport.resp_headers))
retval = itertools.chain(p_ctx.out_string, self.__finalize(p_ctx))
except TypeError:
retval_iter = iter(p_ctx.out_string)
try:
first_chunk = retval_iter.next()
except StopIteration:
first_chunk = ''
start_response(p_ctx.transport.resp_code,
_gen_http_headers(p_ctx.transport.resp_headers))
retval = itertools.chain([first_chunk], retval_iter,
self.__finalize(p_ctx))
try:
process_contexts(self, others, p_ctx, error=None)
except Exception, e:
# Report but ignore any exceptions from auxiliary methods.
logger.exception(e)
p_ctx.out_header_doc is not None:
p_ctx.transport.resp_headers.update(p_ctx.out_header_doc)
if p_ctx.descriptor and p_ctx.descriptor.mtom:
# when there is more than one return type, the result is
# encapsulated inside a list. when there's just one, the result
# is returned in a non-encapsulated form. the apply_mtom always
# expects the objects to be inside an iterable, hence the
# following test.
out_type_info = p_ctx.descriptor.out_message._type_info
if len(out_type_info) == 1:
out_object = [out_object]
p_ctx.transport.resp_headers, p_ctx.out_string = apply_mtom(
p_ctx.transport.resp_headers, p_ctx.out_string,
p_ctx.descriptor.out_message._type_info.values(),
out_object
)
self.event_manager.fire_event('wsgi_return', p_ctx)
if self.chunked:
# the client has not set a content-length, so we delete it as the
# input is just an iterable.
if 'Content-Length' in p_ctx.transport.resp_headers:
del p_ctx.transport.resp_headers['Content-Length']
else:
p_ctx.out_string = [''.join(p_ctx.out_string)]
# if the out_string is a generator function, this hack lets the user
# code run until first yield, which lets it set response headers and
def handle_rpc(self, req_env, start_response):
initial_ctx = WsgiMethodContext(self, req_env,
self.app.out_protocol.mime_type)
# implementation hook
self.event_manager.fire_event('wsgi_call', initial_ctx)
initial_ctx.in_string, in_string_charset = \
self.__reconstruct_wsgi_request(req_env)
contexts = self.generate_contexts(initial_ctx, in_string_charset)
p_ctx, others = contexts[0], contexts[1:]
if p_ctx.in_error:
return self.handle_error(p_ctx, others, p_ctx.in_error, start_response)
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, start_response)
self.get_out_object(p_ctx)
if p_ctx.out_error:
return self.handle_error(p_ctx, others, p_ctx.out_error, start_response)
if p_ctx.transport.resp_code is None:
p_ctx.transport.resp_code = HTTP_200
self.get_out_string(p_ctx)
if p_ctx.descriptor and p_ctx.descriptor.mtom:
# when there is more than one return type, the result is
# encapsulated inside a list. when there's just one, the result
# is returned in a non-encapsulated form. the apply_mtom always
# expects the objects to be inside an iterable, hence the
# following test.
out_type_info = p_ctx.descriptor.out_message._type_info
if len(out_type_info) == 1:
out_object = [out_object]
p_ctx.transport.resp_headers, p_ctx.out_string = apply_mtom(
p_ctx.transport.resp_headers, p_ctx.out_string,
p_ctx.descriptor.out_message._type_info.values(),
out_object
)
# implementation hook
self.event_manager.fire_event('wsgi_return', p_ctx)
# the client has not set a content-length, so we delete it as the input
# is just an iterable.
if self.chunked:
if 'Content-Length' in p_ctx.transport.resp_headers:
del p_ctx.transport.resp_headers['Content-Length']
else:
p_ctx.out_string = [''.join(p_ctx.out_string)]
# if the out_string is a generator function, this hack lets the user
# code run until first yield, which lets it set response headers and
# whatnot beforce calling start_response. yes it causes an additional
# copy of the first fragment of the response to be made, but if you know
# a better way of having generator functions execute until first yield,
# just let us know.
try:
len(p_ctx.out_string) # iterator?
# nope
p_ctx.transport.resp_headers['Content-Length'] = \
str(sum([len(a) for a in p_ctx.out_string]))
start_response(p_ctx.transport.resp_code,
p_ctx.transport.resp_headers.items())
retval = p_ctx.out_string
except TypeError:
retval_iter = iter(p_ctx.out_string)
retval = retval_iter.next()
start_response(p_ctx.transport.resp_code,
p_ctx.transport.resp_headers.items())
retval = itertools.chain([retval], retval_iter)
try:
process_contexts(self, others, p_ctx, error=None)
except Exception, e:
# Report but ignore any exceptions from auxiliary methods.
logger.exception(e)
