soap4r 1.5.5.20061022 → 1.5.6

data/lib/soap/rpc/proxy.rb

@@ -1,5 +1,5 @@
 # SOAP4R - RPC Proxy library.
-# Copyright (C) 2000, 2003-2006  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 
 # This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
 # redistribute it and/or modify it under the same terms of Ruby's license;
@@ -12,6 +12,8 @@ require 'soap/mapping'
 require 'soap/mapping/literalregistry'
 require 'soap/rpc/rpc'
 require 'soap/rpc/element'
+require 'soap/header/handlerset'
+require 'soap/filter'
 require 'soap/streamHandler'
 require 'soap/mimemessage'
 
@@ -32,6 +34,7 @@ public
   attr_accessor :generate_explicit_type
   attr_accessor :return_response_as_xml
   attr_reader :headerhandler
+  attr_reader :filterchain
   attr_reader :streamhandler
 
   attr_accessor :mapping_registry
@@ -54,6 +57,7 @@ public
     @generate_explicit_type = true
     @return_response_as_xml = false
     @headerhandler = Header::HandlerSet.new
+    @filterchain = Filter::FilterChain.new
     @mapping_registry = nil
     @literal_mapping_registry = ::SOAP::Mapping::LiteralRegistry.new
   end
@@ -84,20 +88,14 @@ public
   end
 
   def add_rpc_operation(qname, soapaction, name, param_def, opt = {})
+    ensure_styleuse_option(opt, :rpc, :encoded)
     opt[:request_qname] = qname
-    opt[:request_style] ||= :rpc
-    opt[:response_style] ||= :rpc
-    opt[:request_use] ||= :encoded
-    opt[:response_use] ||= :encoded
     op = Operation.new(soapaction, param_def, opt)
     assign_operation(name, qname, soapaction, op)
   end
 
   def add_document_operation(soapaction, name, param_def, opt = {})
-    opt[:request_style] ||= :document
-    opt[:response_style] ||= :document
-    opt[:request_use] ||= :literal
-    opt[:response_use] ||= :literal
+    ensure_styleuse_option(opt, :document, :literal)
     op = Operation.new(soapaction, param_def, opt)
     assign_operation(name, nil, soapaction, op)
   end
@@ -142,6 +140,9 @@ public
       :attributeformdefault => op_info.attributeformdefault
     )
     env = route(req_header, req_body, reqopt, resopt)
+    if op_info.response_use.nil?
+      return nil
+    end
     raise EmptyResponseError unless env
     receive_headers(env.header)
     begin
@@ -190,6 +191,17 @@ public
 
 private
 
+  def ensure_styleuse_option(opt, style, use)
+    if opt[:request_style] || opt[:response_style] || opt[:request_use] || opt[:response_use]
+      # do not edit
+    else
+      opt[:request_style] ||= style
+      opt[:response_style] ||= style
+      opt[:request_use] ||= use
+      opt[:response_use] ||= use
+    end
+  end
+
   def initialize_streamhandler(options)
     value = options["streamhandler"]
     if value and !value.empty?
@@ -223,29 +235,30 @@ private
   end
 
   def create_request_header
-    headers = @headerhandler.on_outbound
-    if headers.empty?
-      nil
-    else
-      h = ::SOAP::SOAPHeader.new
-      headers.each do |header|
-        h.add(header.elename.name, header)
-      end
-      h
+    header = ::SOAP::SOAPHeader.new
+    items = @headerhandler.on_outbound(header)
+    items.each do |item|
+      header.add(item.elename.name, item)
     end
+    header
   end
 
-  def receive_headers(headers)
-    @headerhandler.on_inbound(headers) if headers
+  def receive_headers(header)
+    @headerhandler.on_inbound(header) if header
   end
 
   def marshal(env, opt)
+    @filterchain.each do |filter|
+      env = filter.on_outbound(env, opt)
+      break unless env
+    end
     send_string = Processor.marshal(env, opt)
     StreamHandler::ConnectionData.new(send_string)
   end
 
   def unmarshal(conn_data, opt)
     contenttype = conn_data.receive_contenttype
+    xml = nil
     if /#{MIMEMessage::MultipartContentType}/i =~ contenttype
       opt[:external_content] = {}
       mime = MIMEMessage.parse("Content-Type: " + contenttype,
@@ -258,17 +271,19 @@ private
       end
       opt[:charset] = @mandatorycharset ||
 	StreamHandler.parse_media_type(mime.root.headers['content-type'].str)
-      env = Processor.unmarshal(mime.root.content, opt)
-      if @return_response_as_xml
-        opt[:response_as_xml] = mime.root.content
-      end
+      xml = mime.root.content
     else
       opt[:charset] = @mandatorycharset ||
 	::SOAP::StreamHandler.parse_media_type(contenttype)
-      env = Processor.unmarshal(conn_data.receive_string, opt)
-      if @return_response_as_xml
-        opt[:response_as_xml] = conn_data.receive_string
-      end
+      xml = conn_data.receive_string
+    end
+    @filterchain.reverse_each do |filter|
+      xml = filter.on_inbound(xml, opt)
+      break unless xml
+    end
+    env = Processor.unmarshal(xml, opt)
+    if @return_response_as_xml
+      opt[:response_as_xml] = xml
     end
     unless env.is_a?(::SOAP::SOAPEnvelope)
       raise ResponseFormatError.new("response is not a SOAP envelope: #{env}")
@@ -430,8 +445,9 @@ private
       end
     end
 
+    # nil means oneway
     def check_use(use)
-      unless [:encoded, :literal].include?(use)
+      unless [:encoded, :literal, nil].include?(use)
         raise MethodDefinitionError.new("unknown use: #{use}")
       end
     end
@@ -455,8 +471,12 @@ private
     def request_rpc_enc(values, mapping_registry, opt)
       method = @rpc_method_factory.dup
       names = method.input_params
-      obj = create_request_obj(names, values)
-      soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname, opt)
+      types = method.input_param_types
+      ary = Mapping.objs2soap(values, mapping_registry, types, opt)
+      soap = {}
+      0.upto(ary.length - 1) do |idx|
+        soap[names[idx]] = ary[idx]
+      end
       method.set_param(soap)
       method
     end
@@ -545,16 +565,6 @@ private
         Mapping.soap2obj(value, mapping_registry)
       }
     end
-
-    def create_request_obj(names, params)
-      o = Object.new
-      idx = 0
-      while idx < params.length
-        o.instance_variable_set('@' + names[idx], params[idx])
-        idx += 1
-      end
-      o
-    end
   end
 end
 

data/lib/soap/rpc/router.rb

@@ -1,5 +1,5 @@
 # SOAP4R - RPC Routing library
-# Copyright (C) 2001, 2002, 2004-2006  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 
 # This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
 # redistribute it and/or modify it under the same terms of Ruby's license;
@@ -12,6 +12,8 @@ require 'soap/mapping'
 require 'soap/mapping/literalregistry'
 require 'soap/rpc/rpc'
 require 'soap/rpc/element'
+require 'soap/header/handlerset'
+require 'soap/filter'
 require 'soap/streamHandler'
 require 'soap/mimemessage'
 require 'soap/header/handlerset'
@@ -29,6 +31,7 @@ class Router
   attr_accessor :literal_mapping_registry
   attr_accessor :generate_explicit_type
   attr_accessor :external_ces
+  attr_reader :filterchain
 
   def initialize(actor)
     @actor = actor
@@ -40,6 +43,7 @@ class Router
     @operation_by_soapaction = {}
     @operation_by_qname = {}
     @headerhandlerfactory = []
+    @filterchain = Filter::FilterChain.new
   end
 
   ###
@@ -167,23 +171,38 @@ class Router
       soap_response =
         op.call(env.body, @mapping_registry, @literal_mapping_registry,
           create_mapping_opt)
+      conn_data.is_fault = true if soap_response.is_a?(SOAPFault)
       default_encodingstyle = op.response_default_encodingstyle
-    rescue Exception
-      soap_response = fault($!)
+    rescue Exception => e
+      # If a wsdl fault was raised by service, the fault declaration details
+      # is kept in wsdl_fault. Otherwise (exception is a program fault)
+      # wsdl_fault is nil
+      wsdl_fault_details = op.faults && op.faults[e.class.name]
+      soap_response = fault(e, wsdl_fault_details)
+      conn_data.is_fault = true
       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)
+    if op.response_use.nil?
+      conn_data.send_string = ''
+      conn_data.is_nocontent = true
+      conn_data
+    else
+      body = SOAPBody.new(soap_response, conn_data.is_fault)
+      env = SOAPEnvelope.new(header, body)
+      marshal(conn_data, env, default_encodingstyle)
+    end
   end
 
   # Create fault response string.
   def create_fault_response(e)
-    env = SOAPEnvelope.new(SOAPHeader.new, SOAPBody.new(fault(e)))
+    env = SOAPEnvelope.new(SOAPHeader.new, SOAPBody.new(fault(e, nil), true))
     opt = {}
     opt[:external_content] = nil
+    @filterchain.reverse_each do |filter|
+      env = filter.on_outbound(env, opt)
+      break unless env
+    end
     response_string = Processor.marshal(env, opt)
     conn_data = StreamHandler::ConnectionData.new(response_string)
     conn_data.is_fault = true
@@ -213,10 +232,14 @@ private
   end
 
   def ensure_styleuse_option(opt, style, use)
-    opt[:request_style] ||= style
-    opt[:response_style] ||= style
-    opt[:request_use] ||= use
-    opt[:response_use] ||= use
+    if opt[:request_style] || opt[:response_style] || opt[:request_use] || opt[:response_use]
+      # do not edit
+    else
+      opt[:request_style] ||= style
+      opt[:response_style] ||= style
+      opt[:request_use] ||= use
+      opt[:response_use] ||= use
+    end
   end
 
   def assign_operation(soapaction, qname, op)
@@ -251,23 +274,20 @@ private
   end
 
   def call_headers(headerhandler)
-    headers = headerhandler.on_outbound
-    if headers.empty?
-      nil
-    else
-      h = ::SOAP::SOAPHeader.new
-      headers.each do |header|
-        h.add(header.elename.name, header)
-      end
-      h
+    header = ::SOAP::SOAPHeader.new
+    items = headerhandler.on_outbound(header)
+    items.each do |item|
+      header.add(item.elename.name, item)
     end
+    header
   end
 
-  def receive_headers(headerhandler, headers)
-    headerhandler.on_inbound(headers) if headers
+  def receive_headers(headerhandler, header)
+    headerhandler.on_inbound(header) if header
   end
 
   def unmarshal(conn_data)
+    xml = nil
     opt = {}
     contenttype = conn_data.receive_contenttype
     if /#{MIMEMessage::MultipartContentType}/i =~ contenttype
@@ -282,11 +302,16 @@ private
       end
       opt[:charset] =
 	StreamHandler.parse_media_type(mime.root.headers['content-type'].str)
-      env = Processor.unmarshal(mime.root.content, opt)
+      xml = mime.root.content
     else
       opt[:charset] = ::SOAP::StreamHandler.parse_media_type(contenttype)
-      env = Processor.unmarshal(conn_data.receive_string, opt)
+      xml = conn_data.receive_string
     end
+    @filterchain.each do |filter|
+      xml = filter.on_inbound(xml, opt)
+      break unless xml
+    end
+    env = Processor.unmarshal(xml, opt)
     charset = opt[:charset]
     conn_data.send_contenttype = "text/xml; charset=\"#{charset}\""
     env
@@ -297,6 +322,10 @@ private
     opt[:external_content] = nil
     opt[:default_encodingstyle] = default_encodingstyle
     opt[:generate_explicit_type] = @generate_explicit_type
+    @filterchain.reverse_each do |filter|
+      env = filter.on_outbound(env, opt)
+      break unless env
+    end
     response_string = Processor.marshal(env, opt)
     conn_data.send_string = response_string
     if ext = opt[:external_content]
@@ -318,15 +347,36 @@ private
   end
 
   # Create fault response.
-  def fault(e)
+  def fault(e, wsdl_fault_details)
     if e.is_a?(UnhandledMustUnderstandHeaderError)
       faultcode = FaultCode::MustUnderstand
     else
       faultcode = FaultCode::Server
     end
-    detail = Mapping.obj2soap(Mapping::SOAPException.new(e),
-      @mapping_registry)
-    detail.elename ||= XSD::QName::EMPTY # for literal mappingregstry
+
+    # If the exception represents a WSDL fault, the fault element should
+    # be added as the SOAP fault <detail> element. If the exception is a
+    # normal program exception, it is wrapped inside a custom SOAP4R
+    # SOAP exception element.
+    detail = nil
+    if (wsdl_fault_details)
+      registry = wsdl_fault_details[:use] == "literal" ?
+        @literal_mapping_registry : @mapping_registry
+      faultQName = XSD::QName.new(
+        wsdl_fault_details[:ns], wsdl_fault_details[:name]
+      )
+      detail = Mapping.obj2soap(e, registry, faultQName)
+      # wrap fault element (SOAPFault swallows top-level element)
+      wrapper = SOAP::SOAPElement.new(faultQName)
+      wrapper.add(detail)
+      detail = wrapper
+    else
+      # Exception is a normal program exception. Wrap it.
+      detail = Mapping.obj2soap(Mapping::SOAPException.new(e),
+                                @mapping_registry)
+      detail.elename ||= XSD::QName::EMPTY # for literal mappingregstry
+    end
+
     SOAPFault.new(
       SOAPElement.new(nil, faultcode),
       SOAPString.new(e.to_s),
@@ -345,6 +395,7 @@ private
     attr_reader :response_style
     attr_reader :request_use
     attr_reader :response_use
+    attr_reader :faults
 
     def initialize(soapaction, name, param_def, opt)
       @soapaction = soapaction
@@ -353,6 +404,7 @@ private
       @response_style = opt[:response_style]
       @request_use = opt[:request_use]
       @response_use = opt[:response_use]
+      @faults = opt[:faults]
       check_style(@request_style)
       check_style(@response_style)
       check_use(@request_use)
@@ -405,6 +457,8 @@ private
       return result if result.is_a?(SOAPFault)
       if @response_style == :rpc
         response_rpc(result, mapping_registry, literal_mapping_registry, opt)
+      elsif @doc_response_qnames.empty?
+        # nothing to do
       else
         response_doc(result, mapping_registry, literal_mapping_registry, opt)
       end
@@ -469,7 +523,7 @@ private
         response_rpc_lit(result, literal_mapping_registry, opt)
       end
     end
-    
+
     def response_doc(result, mapping_registry, literal_mapping_registry, opt)
       if @doc_response_qnames.size == 0
         result = []
@@ -527,10 +581,10 @@ private
         end
         soap_response.set_outparam(outparams)
         soap_response.retval = Mapping.obj2soap(result[0], mapping_registry,
-          XSD::QName.new(nil, soap_response.elename), opt)
+          soap_response.elename, opt)
       else
         soap_response.retval = Mapping.obj2soap(result, mapping_registry,
-          XSD::QName.new(nil, soap_response.elename), opt)
+          soap_response.elename, opt)
       end
       soap_response
     end
@@ -560,8 +614,9 @@ private
       end
     end
 
+    # nil means oneway
     def check_use(use)
-      unless [:encoded, :literal].include?(use)
+      unless [:encoded, :literal, nil].include?(use)
         raise ArgumentError.new("unknown use: #{use}")
       end
     end

data/lib/soap/rpc/rpc.rb

@@ -1,5 +1,5 @@
 # SOAP4R - RPC utility.
-# Copyright (C) 2003  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 
 # This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
 # redistribute it and/or modify it under the same terms of Ruby's license;

data/lib/soap/rpc/soaplet.rb

@@ -1,5 +1,5 @@
 # SOAP4R - SOAP handler servlet for WEBrick
-# Copyright (C) 2001-2005  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
 
 # This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
 # redistribute it and/or modify it under the same terms of Ruby's license;
@@ -41,10 +41,12 @@ module RPC
 class SOAPlet < WEBrick::HTTPServlet::AbstractServlet
 public
   attr_reader :options
+  attr_accessor :authenticator
 
   def initialize(router = nil)
     @router = router || ::SOAP::RPC::Router.new(self.class.name)
     @options = {}
+    @authenticator = nil
     @config = {}
   end
 
@@ -81,12 +83,20 @@ public
 
   def do_POST(req, res)
     logger.debug { "SOAP request: " + req.body } if logger
+    if @authenticator
+      @authenticator.authenticate(req, res)
+      # you can check authenticated user with SOAP::RPC::SOAPlet.user
+    end
     begin
       conn_data = ::SOAP::StreamHandler::ConnectionData.new
       setup_req(conn_data, req)
       @router.external_ces = @options[:external_ces]
-      conn_data = @router.route(conn_data)
-      setup_res(conn_data, req, res)
+      Mapping.protect_threadvars(:SOAPlet) do
+        SOAPlet.user = req.user
+        SOAPlet.cookies = req.cookies
+        conn_data = @router.route(conn_data)
+        setup_res(conn_data, req, res)
+      end
     rescue Exception => e
       conn_data = @router.create_fault_response(e)
       res.status = WEBrick::HTTPStatus::RC_INTERNAL_SERVER_ERROR
@@ -101,8 +111,37 @@ public
     end
   end
 
+  def self.cookies
+    get_variable(:Cookies)
+  end
+
+  def self.cookies=(cookies)
+    set_variable(:Cookies, cookies)
+  end
+
+  def self.user
+    get_variable(:User)
+  end
+
+  def self.user=(user)
+    set_variable(:User, user)
+  end
+
 private
 
+  def self.get_variable(name)
+    if var = Thread.current[:SOAPlet]
+      var[name]
+    else
+      nil
+    end
+  end
+
+  def self.set_variable(name, value)
+    var = Thread.current[:SOAPlet] ||= {}
+    var[name] = value
+  end
+
   def logger
     @config[:Logger]
   end
@@ -115,6 +154,15 @@ private
 
   def setup_res(conn_data, req, res)
     res['content-type'] = conn_data.send_contenttype
+    cookies = SOAPlet.cookies
+    unless cookies.empty?
+      res['set-cookie'] = cookies.collect { |cookie| cookie.to_s }
+    end
+    if conn_data.is_nocontent
+      res.status = WEBrick::HTTPStatus::RC_ACCEPTED
+      res.body = ''
+      return
+    end
     if conn_data.is_fault
       res.status = WEBrick::HTTPStatus::RC_INTERNAL_SERVER_ERROR
     end