Changeset 1087

Timestamp:

12/01/03 14:22:39 (5 years ago)

Author:

nahi

Message:

* introduce soap/property for optional parameter. driver#options...?

Files:

• trunk/lib/soap/rpc/driver.rb (modified) (4 diffs)
• trunk/lib/soap/wsdlDriver.rb (modified) (5 diffs)

trunk/lib/soap/rpc/driver.rb

@@ -13 +13 @@
-require 'soap/rpc/element'
-require 'soap/streamHandler'
+require 'soap/property'
-
-
@@ -20 +21 @@
-
-class Driver
-public
-  class EmptyResponseError < Error; end
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-  def initialize(endpoint_url, namespace, soapaction = nil)
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-  end
-
-  def inspect
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-
-  def add_method(name, *params)
-
+ervant.s
-  end
-
-  def add_method_as(name, name_as, *params)
-
+ervant.s
-  end
-
@@ -117 +108 @@
-        SOAPMethod.create_param_def(params)
-      end
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-  def invoke(headers, body)
-
-
-
-
-
+
-  end
-
-  def call(name, *params)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-  end
-
@@ -169 +126 @@
-
-  def add_rpc_method_interface(name, param_def)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-  end
-end

trunk/lib/soap/wsdlDriver.rb

@@ -38 +38 @@
-  end
-
-, opt = {}
+
-    service = if servicename
-        @wsdl.service(XSD::QName.new(@wsdl.targetnamespace, servicename))
@@ -58 +58 @@
-      raise FactoryError.new("soap:address element not found in WSDL.")
-    end
-, opt
+
-  end
-
@@ -91 +91 @@
-  end
-
-
-logdev
+ions
+endpoint_url
-  __attr_proxy :mapping_registry, true          # for RPC unmarshal
-  __attr_proxy :wsdl_mapping_registry, true     # for RPC marshal
-  __attr_proxy :endpoint_url, true
-  __attr_proxy :wiredump_dev, true
-  __attr_proxy :wiredump_file_base, true
-  __attr_proxy :httpproxy, true
-  __attr_proxy :mandatorycharset, true          # force using charset
-
-  __attr_proxy :default_encodingstyle, true
-  __attr_proxy :allow_unqualified_element, true
-  __attr_proxy :generate_explicit_type, true
-
+  def httpproxy
+    @servant.options["client.streamhandler.http.proxy"]
+  end
+
+  def httpproxy=(httpproxy)
+    @servant.options["client.streamhandler.http.proxy"] = httpproxy
+  end
+
+  def mandatorycharset
+    @servant.options["client.streamhandler.mandatorycharset"]
+  end
+
+  def mandatorycharset=(mandatorycharset)
+    @servant.options["client.streamhandler.mandatorycharset"] = mandatorycharset
+  end
+
+  def wiredump_dev
+    @servant.options["client.streamhandler.wiredump_dev"]
+  end
+
+  def wiredump_dev=(wiredump_dev)
+    @servant.options["client.streamhandler.wiredump_dev"] = wiredump_dev
+  end
+
+  def wiredump_file_base
+    @servant.options["client.streamhandler.wiredump_file_base"]
+  end
+
+  def wiredump_file_base=(wiredump_file_base)
+    @servant.options["client.streamhandler.wiredump_file_base"] =
+      wiredump_file_base
+  end
+
+  def initialize(wsdl, port, logdev)
+    @servant = Servant__.new(self, wsdl, port, logdev)
+  end
+
+  def inspect
+    "#<#{self.class}:#{@servant.port.name}>"
+  end
+
-  def reset_stream
-reset_stream
+streamhandler.reset
-  end
-
@@ -116 +151 @@
-    include SOAP
-
-
+
+
-    attr_reader :port
-
-
+
-    attr_accessor :mapping_registry
-    attr_accessor :wsdl_mapping_registry
-    attr_reader :wiredump_dev
-    attr_reader :wiredump_file_base
-    attr_reader :httpproxy
-    attr_accessor :mandatorycharset
-
-    attr_accessor :default_encodingstyle
-    attr_accessor :allow_unqualified_element
-    attr_accessor :generate_explicit_type
+
+    def initialize(host, wsdl, port, logdev)
+      @host = host
+      @wsdl = wsdl
+      @port = port
+      @logdev = logdev
+
+      @options = ::SOAP::Property.new
+      set_options_hook
+      @mapping_registry = nil           # for rpc unmarshal
+      @wsdl_mapping_registry = nil      # for rpc marshal
+      @default_encodingstyle = EncodingNamespace
+      @allow_unqualified_element = true
+      @generate_explicit_type = false
+      @wiredump_file_base = nil
+      @mandatorycharset = nil
+
+      @wsdl_elements = @wsdl.collect_elements
+      @wsdl_types = @wsdl.collect_complextypes
+      @rpc_decode_typemap = @wsdl_types + @wsdl.soap_rpc_complextypes(port.find_binding)
+      @wsdl_mapping_registry = Mapping::WSDLRegistry.new(@rpc_decode_typemap)
+      @doc_mapper = Mapper.new(@wsdl_elements, @wsdl_types)
+
+      @streamhandler = HTTPPostStreamHandler.new(@port.soap_address.location,
+        ENV['http_proxy'] || ENV['HTTP_PROXY'], XSD::Charset.encoding_label)
+      @operations = {}
+      # Convert a map which key is QName, to a Hash which key is String.
+      @port.inputoperation_map.each do |op_name, op_info|
+        @operations[op_name.name] = op_info
+        add_method_interface(op_info)
+      end
+    end
+
+    def endpoint_url
+      @streamhandler.endpoint_url
+    end
+
+    def endpoint_url=(endpoint_url)
+      @streamhandler.endpoint_url = endpoint_url
+      @streamhandler.reset
+    end
+
+    def rpc_send(method_name, *params)
+      log(INFO) { "call: calling method '#{ method_name }'." }
+      log(DEBUG) { "call: parameters '#{ params.inspect }'." }
+
+      op_info = @operations[method_name]
+      parts_names = op_info.bodyparts.collect { |part| part.name }
+      obj = create_method_obj(parts_names, params)
+      method = Mapping.obj2soap(obj, @wsdl_mapping_registry, op_info.optype_name)
+      method.elename = op_info.op_name
+      method.type = XSD::QName.new      # Request should not be typed.
+      req_header = nil
+      req_body = SOAPBody.new(method)
+
+      if @wiredump_file_base
+        @streamhandler.wiredump_file_base =
+          @wiredump_file_base + '_' << method_name
+      end
+
+      begin
+        opt = create_options
+        opt[:decode_typemap] = @rpc_decode_typemap
+        res_header, res_body = invoke(req_header, req_body, op_info, opt)
+        if res_body.fault
+          raise SOAP::FaultError.new(res_body.fault)
+        end
+      rescue SOAP::FaultError => e
+        Mapping.fault2exception(e)
+      end
+
+      ret = res_body.response ?
+        Mapping.soap2obj(res_body.response, @mapping_registry) : nil
+
+      if res_body.outparams
+        outparams = res_body.outparams.collect { |outparam|
+          Mapping.soap2obj(outparam)
+        }
+        return [ret].concat(outparams)
+      else
+        return ret
+      end
+    end
+
+    # req_header: [[element, mustunderstand, encodingstyle(QName/String)], ...]
+    # req_body: SOAPBasetype/SOAPCompoundtype
+    def document_send(name, header_obj, body_obj)
+      log(INFO) { "document_send: sending document '#{ name }'." }
+      op_info = @operations[name]
+      req_header = header_from_obj(header_obj, op_info)
+      req_body = body_from_obj(body_obj, op_info)
+      opt = create_options
+      res_header, res_body = invoke(req_header, req_body, op_info, opt)
+      if res_body.fault
+        raise SOAP::FaultError.new(res_body.fault)
+      end
+      res_body_obj = res_body.response ?
+        Mapping.soap2obj(res_body.response, @mapping_registry) : nil
+      return res_header, res_body_obj
+    end
+
+  private
+
+    def create_method_obj(names, params)
+      o = Object.new
+      for idx in 0 ... params.length
+        o.instance_eval("@#{ names[idx] } = params[idx]")
+      end
+      o
+    end
+
+    def invoke(req_header, req_body, op_info, opt)
+      send_string = Processor.marshal(req_header, req_body, opt)
+      log(DEBUG) { "invoke: sending string #{ send_string }" }
+      data = @streamhandler.send(send_string, op_info.soapaction)
+      log(DEBUG) { "invoke: received string #{ data.receive_string }" }
+      if data.receive_string.empty?
+        return nil, nil
+      end
+      opt[:charset] = @mandatorycharset ||
+        StreamHandler.parse_media_type(data.receive_contenttype)
+      res_header, res_body = Processor.unmarshal(data.receive_string, opt)
+      return res_header, res_body
+    end
+
+    def header_from_obj(obj, op_info)
+      if obj.is_a?(SOAPHeader)
+        obj
+      elsif op_info.headerparts.empty?
+        if obj.nil?
+          nil
+        else
+          raise RuntimeError.new("No header definition in schema.")
+        end
+      elsif op_info.headerparts.size == 1
+        part = op_info.headerparts[0]
+        header = SOAPHeader.new()
+        header.add(headeritem_from_obj(obj, part.element || part.eletype))
+        header
+      else
+        header = SOAPHeader.new()
+        op_info.headerparts.each do |part|
+          child = obj[part.elename.name]
+          ele = headeritem_from_obj(child, part.element || part.eletype)
+          header.add(ele)
+        end
+        header
+      end
+    end
+
+    def headeritem_from_obj(obj, name)
+      if obj.nil?
+        SOAPElement.new(name)
+      elsif obj.is_a?(SOAPHeaderItem)
+        obj
+      else
+        @doc_mapper.obj2ele(obj, name)
+      end
+    end
+
+    def body_from_obj(obj, op_info)
+      if obj.is_a?(SOAPBody)
+        obj
+      elsif op_info.bodyparts.empty?
+        if obj.nil?
+          nil
+        else
+          raise RuntimeError.new("No body found in schema.")
+        end
+      elsif op_info.bodyparts.size == 1
+        part = op_info.bodyparts[0]
+        ele = bodyitem_from_obj(obj, part.element || part.type)
+        SOAPBody.new(ele)
+      else
+        body = SOAPBody.new
+        op_info.bodyparts.each do |part|
+          child = obj[part.elename.name]
+          ele = bodyitem_from_obj(child, part.element || part.type)
+          body.add(ele.elename.name, ele)
+        end
+        body
+      end
+    end
+
+    def bodyitem_from_obj(obj, name)
+      if obj.nil?
+        SOAPElement.new(name)
+      elsif obj.is_a?(SOAPElement)
+        obj
+      else
+        @doc_mapper.obj2ele(obj, name)
+      end
+    end
+
+    def add_method_interface(op_info)
+      case op_info.style
+      when :document
+        add_document_method_interface(op_info.op_name.name)
+      when :rpc
+        parts_names = op_info.bodyparts.collect { |part| part.name }
+        add_rpc_method_interface(op_info.op_name.name, parts_names)
+      else
+        raise RuntimeError.new("Unknown style: #{op_info.style}")
+      end
+    end
+
+    def add_document_method_interface(name)
+      @host.instance_eval <<-EOS
+        def #{ name }(headers, body)
+          @servant.document_send(#{ name.dump }, headers, body)
+        end
+      EOS
+    end
+
+    def add_rpc_method_interface(name, parts_names)
+      i = 0
+      param_names = parts_names.collect { |orgname| i += 1; "arg#{ i }" }
+      callparam = (param_names.collect { |pname| ", " + pname }).join
+      @host.instance_eval <<-EOS
+        def #{ name }(#{ param_names.join(", ") })
+          @servant.rpc_send(#{ name.dump }#{ callparam })
+        end
+      EOS
+    end
+
+    def create_options
+      opt = {}
+      opt[:default_encodingstyle] = @default_encodingstyle
+      opt[:allow_unqualified_element] = @allow_unqualified_element
+      opt[:generate_explicit_type] = @generate_explicit_type
+      opt
+    end
+
+    def log(sev)
+      @logdev.add(sev, nil, self.class) { yield } if @logdev
+    end
+
+    def set_options_hook
+      @options.add_hook("client.streamhandler.http.proxy") do |key, value|
+        @streamhandler.proxy = value
+        @streamhandler.reset
+      end
+      @options.add_hook("client.streamhandler.mandatorycharset") do |key, value|
+        @mandatorycharset = value
+      end
+      @options.add_hook("client.streamhandler.wiredump_dev") do |key, value|
+        @streamhandler.wiredump_dev = value
+        @streamhandler.reset
+      end
+      @options.add_hook("client.streamhandler.wiredump_file_base") do |key, value|
+        @wiredump_file_base = value
+      end
+    end
-
-    class Mapper
@@ -208 +491 @@
-      end
-    end
-
-    def initialize(host, wsdl, port, logdev, opt)
-      @host = host
-      @wsdl = wsdl
-      @port = port
-      @logdev = logdev
-      @opt = opt.dup
-      @mapping_registry = nil           # for rpc unmarshal
-      @wsdl_mapping_registry = nil      # for rpc marshal
-      @wiredump_dev = nil
-      @wiredump_file_base = nil
-      @mandatorycharset = nil
-
-      @wsdl_elements = @wsdl.collect_elements
-      @wsdl_types = @wsdl.collect_complextypes
-      @rpc_decode_typemap = @wsdl_types + @wsdl.soap_rpc_complextypes(port.find_binding)
-      @wsdl_mapping_registry = Mapping::WSDLRegistry.new(@rpc_decode_typemap)
-      @doc_mapper = Mapper.new(@wsdl_elements, @wsdl_types)
-      @default_encodingstyle = EncodingNamespace
-      @allow_unqualified_element = true
-      @generate_explicit_type = false
-
-      create_streamhandler(@port.soap_address.location,
-        ENV['http_proxy'] || ENV['HTTP_PROXY'])
-      @operations = {}
-      # Convert a map which key is QName, to a Hash which key is String.
-      @port.inputoperation_map.each do |op_name, op_info|
-        @operations[op_name.name] = op_info
-        add_method_interface(op_info)
-      end
-    end
-
-    def endpoint_url
-      @streamhandler.endpoint_url
-    end
-
-    def endpoint_url=(endpoint_url)
-      @streamhandler.endpoint_url = endpoint_url
-      @streamhandler.reset
-      log(DEBUG) { "endpoint_url=: set endpoint_url #{ endpoint_url }." }
-    end
-
-    def wiredump_dev=(dev)
-      @wiredump_dev = dev
-      @streamhandler.wiredump_dev = @wiredump_dev
-      @streamhandler.reset
-    end
-
-    def wiredump_file_base=(base)
-      @wiredump_file_base = base
-    end
-
-    def httpproxy=(httpproxy)
-      @streamhandler.proxy = httpproxy
-      @streamhandler.reset
-      log(DEBUG) { "httpproxy=: set httpproxy #{ httpproxy }." }
-    end
-
-    def reset_stream
-      @streamhandler.reset
-    end
-
-    def rpc_send(method_name, *params)
-      log(INFO) { "call: calling method '#{ method_name }'." }
-      log(DEBUG) { "call: parameters '#{ params.inspect }'." }
-
-      op_info = @operations[method_name]
-      parts_names = op_info.bodyparts.collect { |part| part.name }
-      obj = create_method_obj(parts_names, params)
-      method = Mapping.obj2soap(obj, @wsdl_mapping_registry, op_info.optype_name)
-      method.elename = op_info.op_name
-      method.type = XSD::QName.new      # Request should not be typed.
-      req_header = nil
-      req_body = SOAPBody.new(method)
-
-      if @wiredump_file_base
-        @streamhandler.wiredump_file_base =
-          @wiredump_file_base + '_' << method_name
-      end
-
-      begin
-        opt = create_options
-        opt[:decode_typemap] = @rpc_decode_typemap
-        res_header, res_body = invoke(req_header, req_body, op_info, opt)
-        if res_body.fault
-          raise SOAP::FaultError.new(res_body.fault)
-        end
-      rescue SOAP::FaultError => e
-        Mapping.fault2exception(e)
-      end
-
-      ret = res_body.response ?
-        Mapping.soap2obj(res_body.response, @mapping_registry) : nil
-
-      if res_body.outparams
-        outparams = res_body.outparams.collect { |outparam|
-          Mapping.soap2obj(outparam)
-        }
-        return [ret].concat(outparams)
-      else
-        return ret
-      end
-    end
-
-    # req_header: [[element, mustunderstand, encodingstyle(QName/String)], ...]
-    # req_body: SOAPBasetype/SOAPCompoundtype
-    def document_send(name, header_obj, body_obj)
-      log(INFO) { "document_send: sending document '#{ name }'." }
-      op_info = @operations[name]
-      req_header = header_from_obj(header_obj, op_info)
-      req_body = body_from_obj(body_obj, op_info)
-      opt = create_options
-      res_header, res_body = invoke(req_header, req_body, op_info, opt)
-      if res_body.fault
-        raise SOAP::FaultError.new(res_body.fault)
-      end
-      res_body_obj = res_body.response ?
-        Mapping.soap2obj(res_body.response, @mapping_registry) : nil
-      return res_header, res_body_obj
-    end
-
-  private
-
-    def create_streamhandler(endpoint_url, httpproxy)
-      @streamhandler = HTTPPostStreamHandler.new(endpoint_url, httpproxy,
-        XSD::Charset.encoding_label)
-      @streamhandler.wiredump_dev = @wiredump_dev
-    end
-
-    def create_method_obj(names, params)
-      o = Object.new
-      for idx in 0 ... params.length
-        o.instance_eval("@#{ names[idx] } = params[idx]")
-      end
-      o
-    end
-
-    def invoke(req_header, req_body, op_info, opt)
-      send_string = Processor.marshal(req_header, req_body, opt)
-      log(DEBUG) { "invoke: sending string #{ send_string }" }
-      data = @streamhandler.send(send_string, op_info.soapaction)
-      log(DEBUG) { "invoke: received string #{ data.receive_string }" }
-      if data.receive_string.empty?
-        return nil, nil
-      end
-      opt[:charset] = @mandatorycharset ||
-        StreamHandler.parse_media_type(data.receive_contenttype)
-      res_header, res_body = Processor.unmarshal(data.receive_string, opt)
-      return res_header, res_body
-    end
-
-    def header_from_obj(obj, op_info)
-      if obj.is_a?(SOAPHeader)
-        obj
-      elsif op_info.headerparts.empty?
-        if obj.nil?
-          nil
-        else
-          raise RuntimeError.new("No header definition in schema.")
-        end
-      elsif op_info.headerparts.size == 1
-        part = op_info.headerparts[0]
-        header = SOAPHeader.new()
-        header.add(headeritem_from_obj(obj, part.element || part.eletype))
-        header
-      else
-        header = SOAPHeader.new()
-        op_info.headerparts.each do |part|
-          child = obj[part.elename.name]
-          ele = headeritem_from_obj(child, part.element || part.eletype)
-          header.add(ele)
-        end
-        header
-      end
-    end
-
-    def headeritem_from_obj(obj, name)
-      if obj.nil?
-        SOAPElement.new(name)
-      elsif obj.is_a?(SOAPHeaderItem)
-        obj
-      else
-        @doc_mapper.obj2ele(obj, name)
-      end
-    end
-
-    def body_from_obj(obj, op_info)
-      if obj.is_a?(SOAPBody)
-        obj
-      elsif op_info.bodyparts.empty?
-        if obj.nil?
-          nil
-        else
-          raise RuntimeError.new("No body found in schema.")
-        end
-      elsif op_info.bodyparts.size == 1
-        part = op_info.bodyparts[0]
-        ele = bodyitem_from_obj(obj, part.element || part.type)
-        SOAPBody.new(ele)
-      else
-        body = SOAPBody.new
-        op_info.bodyparts.each do |part|
-          child = obj[part.elename.name]
-          ele = bodyitem_from_obj(child, part.element || part.type)
-          body.add(ele.elename.name, ele)
-        end
-        body
-      end
-    end
-
-    def bodyitem_from_obj(obj, name)
-      if obj.nil?
-        SOAPElement.new(name)
-      elsif obj.is_a?(SOAPElement)
-        obj
-      else
-        @doc_mapper.obj2ele(obj, name)
-      end
-    end
-
-    def add_method_interface(op_info)
-      case op_info.style
-      when :document
-        add_document_method_interface(op_info.op_name.name)
-      when :rpc
-        parts_names = op_info.bodyparts.collect { |part| part.name }
-        add_rpc_method_interface(op_info.op_name.name, parts_names)
-      else
-        raise RuntimeError.new("Unknown style: #{op_info.style}")
-      end
-    end
-
-    def add_document_method_interface(name)
-      @host.instance_eval <<-EOS
-        def #{ name }(headers, body)
-          @servant.document_send(#{ name.dump }, headers, body)
-        end
-      EOS
-    end
-
-    def add_rpc_method_interface(name, parts_names)
-      i = 0
-      param_names = parts_names.collect { |orgname| i += 1; "arg#{ i }" }
-      callparam_str = (param_names.collect { |pname| ", " + pname }).join
-      @host.instance_eval <<-EOS
-        def #{ name }(#{ param_names.join(", ") })
-          @servant.rpc_send(#{ name.dump }#{ callparam_str })
-        end
-      EOS
-    end
-
-    def create_options
-      opt = @opt.dup
-      opt[:default_encodingstyle] = @default_encodingstyle
-      opt[:allow_unqualified_element] = @allow_unqualified_element
-      opt[:generate_explicit_type] = @generate_explicit_type
-      opt
-    end
-
-    def log(sev)
-      @logdev.add(sev, nil, self.class) { yield } if @logdev
-    end
-  end
-
-  def initialize(wsdl, port, logdev, opt)
-    @servant = Servant__.new(self, wsdl, port, logdev, opt)
-  end
-
-  def inspect
-    "#<#{self.class}:#{@servant.port.name}>"
-  end
-end