Esempio n. 1
0
    def _fault_to_doc(self, inst, cls=None):
        if cls is None:
            cls = Fault

        if self.complex_as is list:
            return [cls.to_list(inst.__class__, inst, self)]

        elif self.complex_as is tuple:
            fault_as_list = [Fault.to_list(inst.__class__, inst, self)]
            return tuple(fault_as_list)

        else:
            return [Fault.to_dict(inst.__class__, inst, self)]
Esempio n. 2
0
    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, (k, v) in enumerate(out_type_info.items()):
                attr_name = k
                out_instance._safe_set(attr_name, ctx.out_object[i], v)

            ctx.out_document = self._object_to_doc(out_type, out_instance),

            self.event_manager.fire_event('after_serialize', ctx)
Esempio n. 3
0
    def decompose_incoming_envelope(self, ctx, message):
        """Sets ``ctx.in_body_doc``, ``ctx.in_header_doc`` and
        ``ctx.method_request_string`` using ``ctx.in_document``.
        """

        assert message in (ProtocolBase.REQUEST, ProtocolBase.RESPONSE)

        # set ctx.in_header
        ctx.transport.in_header_doc = None  # use an rpc protocol if you want headers.

        doc = ctx.in_document

        ctx.in_header_doc = None
        ctx.in_body_doc = doc

        if len(doc) == 0:
            raise Fault("Client", "Empty request")

        logger.debug('\theader : %r' % (ctx.in_header_doc))
        logger.debug('\tbody   : %r' % (ctx.in_body_doc))

        if not isinstance(doc, dict) or len(doc) != 1:
            raise ValidationError("Need a dictionary with exactly one key "
                                  "as method name.")

        mrs, = doc.keys()
        ctx.method_request_string = '{%s}%s' % (self.app.interface.get_tns(),
                                                mrs)
Esempio n. 4
0
    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, (k, v) in enumerate(out_type_info.items()):
                attr_name = k
                out_instance._safe_set(attr_name, ctx.out_object[i], v)

            ctx.out_document = self._object_to_doc(out_type, out_instance),

            self.event_manager.fire_event('after_serialize', ctx)
Esempio n. 5
0
    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)
            ]
            return

        # 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

        else:
            assert False

        if out_type is None:
            return

        # assign raw result to its wrapper, result_message
        if ctx.descriptor.is_out_bare():
            out_instance, = ctx.out_object

        else:
            out_type_info = out_type.get_flat_type_info(out_type)

            # instantiate the result message
            out_instance = out_type()

            for i, (k, v) in enumerate(out_type_info.items()):
                attrs = self.get_cls_attrs(v)
                out_instance._safe_set(k, ctx.out_object[i], v, attrs)

        ctx.out_document = self._object_to_doc(out_type, out_instance, set()),

        logger.debug("Retval: %r", ctx.out_document)
        self.event_manager.fire_event('after_serialize', ctx)
Esempio n. 6
0
File: hier.py Progetto: plq/spyne
    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)]
            return

        # 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

        else:
            assert False

        if out_type is None:
            return

        # assign raw result to its wrapper, result_message
        if ctx.descriptor.is_out_bare():
            out_instance, = ctx.out_object

        else:
            out_type_info = out_type.get_flat_type_info(out_type)

            # instantiate the result message
            out_instance = out_type()

            for i, (k, v) in enumerate(out_type_info.items()):
                attrs = self.get_cls_attrs(v)
                out_instance._safe_set(k, ctx.out_object[i], v, attrs)

        ctx.out_document = self._object_to_doc(out_type, out_instance, set()),

        logger.debug("Retval: %r", ctx.out_document)
        self.event_manager.fire_event('after_serialize', ctx)
Esempio n. 7
0
    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 = Fault('Server', "Internal serialization Error.")
            return self.handle_error(contexts, others, contexts.out_error)
Esempio n. 8
0
 def test_fault_detail_as_dict(self):
     elt = get_object_as_xml(Fault(detail={"this": "that"}), Fault)
     eltstr = etree.tostring(elt)
     print(eltstr)
     assert b'<detail><this>that</this></detail>' in eltstr
Esempio n. 9
0
File: log.py Progetto: tunks/spyne
 def client_fault(ctx):
     raise Fault("Client", "zzzz...")
Esempio n. 10
0
File: log.py Progetto: tunks/spyne
 def server_fault(ctx):
     raise Fault("Server", "boo and you know it!")
Esempio n. 11
0
 def __init__(self, faultstring):
     Fault.__init__(self, 'Client.SchemaValidationError', faultstring)