Class: SOAP::RPC::Router

Class | SOAP::RPC::Router
In: | soap/rpc/router.rb
Parent: | Object

### Methods

add_document_method add_document_operation add_document_request_operation add_headerhandler add_method add_request_headerhandler add_rpc_method add_rpc_operation add_rpc_request_operation add_rpc_request_servant add_rpc_servant add_servant create_fault_response new route

### Included Modules

SOAP

### Classes and Modules

Class SOAP::RPC::Router::ApplicationScopeOperation
Class SOAP::RPC::Router::Operation
Class SOAP::RPC::Router::RequestScopeOperation

### Attributes

actor | [R] |
external_ces | [RW] |
generate_explicit_type | [RW] |
literal_mapping_registry | [RW] |
mapping_registry | [RW] |

### Public Class methods

new(actor)

[Source]

    # File soap/rpc/router.rb, line 33
      def initialize(actor)
        @actor = actor
        @mapping_registry = nil
        @headerhandler = Header::HandlerSet.new
        @literal_mapping_registry = ::SOAP::Mapping::WSDLLiteralRegistry.new
        @generate_explicit_type = true
        @external_ces = nil
        @operation_by_soapaction = {}
        @operation_by_qname = {}
        @headerhandlerfactory = []
      end

### Public Instance methods

add_document_method(receiver, soapaction, name, param_def, opt = {})

Alias for add_document_operation

add_document_operation(receiver, soapaction, name, param_def, opt = {})

[Source]

    # File soap/rpc/router.rb, line 119
      def add_document_operation(receiver, soapaction, name, param_def, opt = {})
        #
        # adopt workaround for doc/lit wrapper method
        # (you should consider to simply use rpc/lit service)
        #
        #unless soapaction
        #  raise RPCRoutingError.new("soapaction is a must for document method")
        #end
        ensure_styleuse_option(opt, :document, :literal)
        op = ApplicationScopeOperation.new(soapaction, receiver, name, param_def,
          opt)
        if opt[:request_style] != :document
          raise RPCRoutingError.new("illegal request_style given")
        end
        assign_operation(soapaction, first_input_part_qname(param_def), op)
      end

add_document_request_operation(factory, soapaction, name, param_def, opt = {})

[Source]

    # File soap/rpc/router.rb, line 137
      def add_document_request_operation(factory, soapaction, name, param_def, opt = {})
        #
        # adopt workaround for doc/lit wrapper method
        # (you should consider to simply use rpc/lit service)
        #
        #unless soapaction
        #  raise RPCRoutingError.new("soapaction is a must for document method")
        #end
        ensure_styleuse_option(opt, :document, :literal)
        op = RequestScopeOperation.new(soapaction, receiver, name, param_def, opt)
        if opt[:request_style] != :document
          raise RPCRoutingError.new("illegal request_style given")
        end
        assign_operation(soapaction, first_input_part_qname(param_def), op)
      end

add_headerhandler(handler)

[Source]

    # File soap/rpc/router.rb, line 55
      def add_headerhandler(handler)
        @headerhandler.add(handler)
      end

add_method(receiver, qname, soapaction, name, param_def, opt = {})

Alias for add_rpc_operation

add_request_headerhandler(factory)

header handler interface

[Source]

    # File soap/rpc/router.rb, line 48
      def add_request_headerhandler(factory)
        unless factory.respond_to?(:create)
          raise TypeError.new("factory must respond to 'create'")
        end
        @headerhandlerfactory << factory
      end

add_rpc_method(receiver, qname, soapaction, name, param_def, opt = {})

Alias for add_rpc_operation

add_rpc_operation(receiver, qname, soapaction, name, param_def, opt = {})

operation definition interface

[Source]

    # File soap/rpc/router.rb, line 96
      def add_rpc_operation(receiver, qname, soapaction, name, param_def, opt = {})
        ensure_styleuse_option(opt, :rpc, :encoded)
        opt[:request_qname] = qname
        op = ApplicationScopeOperation.new(soapaction, receiver, name, param_def,
          opt)
        if opt[:request_style] != :rpc
          raise RPCRoutingError.new("illegal request_style given")
        end
        assign_operation(soapaction, qname, op)
      end

add_rpc_request_operation(factory, qname, soapaction, name, param_def, opt = {})

[Source]

    # File soap/rpc/router.rb, line 109
      def add_rpc_request_operation(factory, qname, soapaction, name, param_def, opt = {})
        ensure_styleuse_option(opt, :rpc, :encoded)
        opt[:request_qname] = qname
        op = RequestScopeOperation.new(soapaction, factory, name, param_def, opt)
        if opt[:request_style] != :rpc
          raise RPCRoutingError.new("illegal request_style given")
        end
        assign_operation(soapaction, qname, op)
      end

add_rpc_request_servant(factory, namespace)

servant definition interface

[Source]

    # File soap/rpc/router.rb, line 62
      def add_rpc_request_servant(factory, namespace)
        unless factory.respond_to?(:create)
          raise TypeError.new("factory must respond to 'create'")
        end
        obj = factory.create        # a dummy instance for introspection
        ::SOAP::RPC.defined_methods(obj).each do |name|
          begin
            qname = XSD::QName.new(namespace, name)
            param_def = ::SOAP::RPC::SOAPMethod.derive_rpc_param_def(obj, name)
            opt = create_styleuse_option(:rpc, :encoded)
            add_rpc_request_operation(factory, qname, nil, name, param_def, opt)
          rescue SOAP::RPC::MethodDefinitionError => e
            p e if $DEBUG
          end
        end
      end

add_rpc_servant(obj, namespace)

[Source]

    # File soap/rpc/router.rb, line 79
      def add_rpc_servant(obj, namespace)
        ::SOAP::RPC.defined_methods(obj).each do |name|
          begin
            qname = XSD::QName.new(namespace, name)
            param_def = ::SOAP::RPC::SOAPMethod.derive_rpc_param_def(obj, name)
            opt = create_styleuse_option(:rpc, :encoded)
            add_rpc_operation(obj, qname, nil, name, param_def, opt)
          rescue SOAP::RPC::MethodDefinitionError => e
            p e if $DEBUG
          end
        end
      end

add_servant(obj, namespace)

Alias for add_rpc_servant

create_fault_response(e)

Create fault response string.

[Source]

    # File soap/rpc/router.rb, line 183
      def create_fault_response(e)
        env = SOAPEnvelope.new(SOAPHeader.new, SOAPBody.new(fault(e)))
        opt = {}
        opt[:external_content] = nil
        response_string = Processor.marshal(env, opt)
        conn_data = StreamHandler::ConnectionData.new(response_string)
        conn_data.is_fault = true
        if ext = opt[:external_content]
          mimeize(conn_data, ext)
        end
        conn_data
      end

route(conn_data)

[Source]

    # File soap/rpc/router.rb, line 153
      def route(conn_data)
        # we cannot set request_default_encodingsyle before parsing the content.
        env = unmarshal(conn_data)
        if env.nil?
          raise ArgumentError.new("illegal SOAP marshal format")
        end
        op = lookup_operation(conn_data.soapaction, env.body)
        headerhandler = @headerhandler.dup
        @headerhandlerfactory.each do |f|
          headerhandler.add(f.create)
        end
        receive_headers(headerhandler, env.header)
        soap_response = default_encodingstyle = nil
        begin
          soap_response =
            op.call(env.body, @mapping_registry, @literal_mapping_registry,
              create_mapping_opt)
          default_encodingstyle = op.response_default_encodingstyle
        rescue Exception
          soap_response = fault($!)
          default_encodingstyle = nil
        end
        conn_data.is_fault = true if soap_response.is_a?(SOAPFault)
        header = call_headers(headerhandler)
        body = SOAPBody.new(soap_response)
        env = SOAPEnvelope.new(header, body)
        marshal(conn_data, env, default_encodingstyle)
      end

[Validate]