def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
if ctx.out_error is not None:
ctx.out_document = [Fault.to_dict(ctx.out_error.__class__,
ctx.out_error)]
else:
# get the result message
if message is self.REQUEST:
out_type = ctx.descriptor.in_message
elif message is self.RESPONSE:
out_type = ctx.descriptor.out_message
if out_type is None:
return
out_type_info = out_type._type_info
# instantiate the result message
out_instance = out_type()
# assign raw result to its wrapper, result_message
for i in range(len(out_type_info)):
attr_name = out_type_info.keys()[i]
setattr(out_instance, attr_name, ctx.out_object[i])
ctx.out_document = self._object_to_doc(out_type, out_instance),
self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
if ctx.out_error is not None:
ctx.out_document = [
Fault.to_dict(ctx.out_error.__class__, ctx.out_error)
]
else:
# get the result message
if message is self.REQUEST:
out_type = ctx.descriptor.in_message
elif message is self.RESPONSE:
out_type = ctx.descriptor.out_message
if out_type is None:
return
out_type_info = out_type._type_info
# instantiate the result message
out_instance = out_type()
# assign raw result to its wrapper, result_message
for i in range(len(out_type_info)):
attr_name = out_type_info.keys()[i]
setattr(out_instance, attr_name, ctx.out_object[i])
ctx.out_document = self._object_to_doc(out_type, out_instance),
self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
if ctx.out_error is not None:
ctx.out_document = [[
MessagePackRpc.MSGPACK_RESPONSE, 0,
Fault.to_dict(ctx.out_error.__class__, ctx.out_error)
]]
return
# get the result message
if message is self.REQUEST:
out_type = ctx.descriptor.in_message
msgtype = MessagePackRpc.MSGPACK_REQUEST
method_name_or_error = ctx.descriptor.operation_name
elif message is self.RESPONSE:
out_type = ctx.descriptor.out_message
msgtype = MessagePackRpc.MSGPACK_RESPONSE
method_name_or_error = None
else:
raise Exception("what?")
if out_type is None:
return
out_type_info = out_type._type_info
# instantiate the result message
out_instance = out_type()
# assign raw result to its wrapper, result_message
for i, (k, v) in enumerate(out_type_info.items()):
attr_name = k
out_instance._safe_set(attr_name, ctx.out_object[i], v)
# transform the results into a dict:
if out_type.Attributes.max_occurs > 1:
params = (self._to_dict_value(out_type, inst)
for inst in out_instance)
else:
params = self._to_dict_value(out_type, out_instance)
ctx.out_document = [[msgtype, 0, method_name_or_error, params]]
self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
if ctx.out_error is not None:
ctx.out_document = [
[MessagePackRpc.MSGPACK_RESPONSE, 0,
Fault.to_dict(ctx.out_error.__class__, ctx.out_error)]
]
return
# get the result message
if message is self.REQUEST:
out_type = ctx.descriptor.in_message
msgtype = MessagePackRpc.MSGPACK_REQUEST
method_name_or_error = ctx.descriptor.operation_name
elif message is self.RESPONSE:
out_type = ctx.descriptor.out_message
msgtype = MessagePackRpc.MSGPACK_RESPONSE
method_name_or_error = None
else:
raise Exception("what?")
if out_type is None:
return
out_type_info = out_type._type_info
# instantiate the result message
out_instance = out_type()
# assign raw result to its wrapper, result_message
for i, (k, v) in enumerate(out_type_info.items()):
attr_name = k
out_instance._safe_set(attr_name, ctx.out_object[i], v)
# transform the results into a dict:
if out_type.Attributes.max_occurs > 1:
params = (self._to_dict_value(out_type, inst, set())
for inst in out_instance)
else:
params = self._to_dict_value(out_type, out_instance, set())
ctx.out_document = [[msgtype, 0, method_name_or_error, params]]
self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
if ctx.out_error is not None:
ctx.out_document = [
MessagePackRpc.MSGPACK_RESPONSE, 0,
Fault.to_dict(ctx.out_error.__class__, ctx.out_error)
]
else:
# get the result message
if message is self.REQUEST:
out_type = ctx.descriptor.in_message
elif message is self.RESPONSE:
out_type = ctx.descriptor.out_message
if out_type is None:
return
out_type_info = out_type._type_info
# instantiate the result message
out_instance = out_type()
# assign raw result to its wrapper, result_message
for i in range(len(out_type_info)):
attr_name = out_type_info.keys()[i]
setattr(out_instance, attr_name, ctx.out_object[i])
# transform the results into a dict:
if out_type.Attributes.max_occurs > 1:
ctx.out_document = [[
MessagePackRpc.MSGPACK_RESPONSE, 0, None,
(self._to_value(out_type, inst) for inst in out_instance)
]]
else:
ctx.out_document = [[
MessagePackRpc.MSGPACK_RESPONSE,
0,
None,
self._to_value(out_type, out_instance),
]]
self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
if ctx.out_error is not None:
ctx.out_document = [MessagePackRpc.MSGPACK_RESPONSE, 0,
Fault.to_dict(ctx.out_error.__class__, ctx.out_error)]
else:
# get the result message
if message is self.REQUEST:
out_type = ctx.descriptor.in_message
elif message is self.RESPONSE:
out_type = ctx.descriptor.out_message
if out_type is None:
return
out_type_info = out_type._type_info
# instantiate the result message
out_instance = out_type()
# assign raw result to its wrapper, result_message
for i in range(len(out_type_info)):
attr_name = out_type_info.keys()[i]
setattr(out_instance, attr_name, ctx.out_object[i])
# transform the results into a dict:
if out_type.Attributes.max_occurs > 1:
ctx.out_document = [[MessagePackRpc.MSGPACK_RESPONSE, 0, None,
(self._to_value(out_type, inst)
for inst in out_instance)
]]
else:
ctx.out_document = [[MessagePackRpc.MSGPACK_RESPONSE, 0, None,
self._to_value(out_type, out_instance),
]]
self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
ctx.out_document = {
"ver": self.version,
}
if ctx.out_error is not None:
ctx.out_document[self.FAULT] = Fault.to_dict(Fault, ctx.out_error)
else:
if message is self.REQUEST:
header_message_class = ctx.descriptor.in_header
body_message_class = ctx.descriptor.in_message
elif message is self.RESPONSE:
header_message_class = ctx.descriptor.out_header
body_message_class = ctx.descriptor.out_message
# assign raw result to its wrapper, result_message
out_type_info = body_message_class._type_info
out_object = body_message_class()
bm_attrs = self.get_cls_attrs(body_message_class)
keys = iter(out_type_info)
values = iter(ctx.out_object)
while True:
try:
k = next(keys)
except StopIteration:
break
try:
v = next(values)
except StopIteration:
v = None
out_object._safe_set(k, v, body_message_class, bm_attrs)
ctx.out_document[self.BODY] = ctx.out_body_doc = \
self._object_to_doc(body_message_class, out_object)
# header
if ctx.out_header is not None and header_message_class is not None:
if isinstance(ctx.out_header, (list, tuple)):
out_headers = ctx.out_header
else:
out_headers = (ctx.out_header,)
ctx.out_header_doc = out_header_doc = []
for header_class, out_header in zip(header_message_class,
out_headers):
out_header_doc.append(self._object_to_doc(header_class,
out_header))
if len(out_header_doc) > 1:
ctx.out_document[self.HEAD] = out_header_doc
else:
ctx.out_document[self.HEAD] = out_header_doc[0]
self.event_manager.fire_event('after_serialize', ctx)
def serialize(self, ctx, message):
assert message in (self.REQUEST, self.RESPONSE)
self.event_manager.fire_event('before_serialize', ctx)
# construct the soap response, and serialize it
nsmap = self.app.interface.nsmap
ctx.out_document = {
"ver": self.version,
}
if ctx.out_error is not None:
ctx.out_document[self.FAULT] = Fault.to_dict(Fault, ctx.out_error)
else:
if message is self.REQUEST:
header_message_class = ctx.descriptor.in_header
body_message_class = ctx.descriptor.in_message
elif message is self.RESPONSE:
header_message_class = ctx.descriptor.out_header
body_message_class = ctx.descriptor.out_message
# assign raw result to its wrapper, result_message
out_type_info = body_message_class._type_info
out_object = body_message_class()
keys = iter(out_type_info)
values = iter(ctx.out_object)
while True:
try:
k = keys.next()
except StopIteration:
break
try:
v = values.next()
except StopIteration:
v = None
setattr(out_object, k, v)
ctx.out_document[self.BODY] = ctx.out_body_doc = \
self._object_to_doc(body_message_class, out_object)
# header
if ctx.out_header is not None and header_message_class is not None:
if isinstance(ctx.out_header, (list, tuple)):
out_headers = ctx.out_header
else:
out_headers = (ctx.out_header,)
ctx.out_header_doc = out_header_doc = []
for header_class, out_header in zip(header_message_class,
out_headers):
out_header_doc.append(self._object_to_doc(header_class,
out_header))
if len(out_header_doc) > 1:
ctx.out_document[self.HEAD] = out_header_doc
else:
ctx.out_document[self.HEAD] = out_header_doc[0]
self.event_manager.fire_event('after_serialize', ctx)
