From 29c5ab0b77feaf975d83ab340d7194c9c4dffc9d Mon Sep 17 00:00:00 2001 From: nahi Date: Thu, 15 Sep 2005 14:33:53 +0000 Subject: * lib/{soap,wsdl,xsd}, test/{soap,wsdl,xsd}: imported soap4r/1.5.5. #nnn is a ticket number at http://dev.ctor.org/soap4r * SOAP * allow to configure an envelope namespace of SOAP request. (#124) TemporaryNamespace = 'http://www.w3.org/2003/05/soap-envelope' @client.options["soap.envelope.requestnamespace"] = TemporaryNamespace @client.options["soap.envelope.responsenamespace"] = TemporaryNamespace @client.do_proc(...) * let SOAP request XML indent space configuable. see "soap.envelope.no_indent" option. (#130) * let external CES configuable. ex. client["soap.mapping.external_ces"] = 'SJIS'. $KCODE is used by default. (#133) external CES ::= CES used in Ruby object of client and server internal CES ::= CES used in SOAP/OM * add iso-8859-1 external CES support. (#106) * fixed illegal 'qualified' handling of elements. it caused ASP.NET inteoperability problem. (#144) * added 'soap.envelope.use_numeric_character_reference' (boolean) option to let query XML use numeric character reference in XML, not plain UTF-8 character. !GoogleSearch server seems to not allow plain UTF-8 character since 2005-08-15 update. (#147) * SOAP::Header::SimpleHeader (de)serialization throws an exception on !SimpleHeader.on_(in|out)bound when header is a String. so we could not use a simple single element headerItem. fixed. thanks to emil. (#129) * out parameter of rpc operation did not work. (#132) * follow HTTP redirect only if using http-access2. (#125) (#145) * add a workaround for importing an WSDL whose path begins with drive letter. (#115) * WSDL * SOAP Data which is defined as a simpletype was not mapped correctly to Ruby obj when using wsdl2ruby.rb generated classdef file. (#123) * rpc/literal support. (#118) * re-implemented local element qualify/unqualify control. handles elementFormDefault and form in WSDL. (#119) * Array of an element which has simpleType causes a crash. (#128) * prarmeterOrder may not contain return part so it can be shorter than parts size. Thanks to Hugh. (#139) * Samples * added !BasicAuth client sample. (#117) * added Base64 client/server sample. * added Flickr SOAP interface client sample. (#122) * added !SalesForce client sample. (#135) * updated Thawte CA certificate for !GoogleAdWords sample. * updated a client script with the newer version made by Johan. thanks! * shortened long file names. (#120) * fixed typo in authheader sample. (#129) * updated deprecated method usage. (#138) git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@9169 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- lib/soap/rpc/driver.rb | 2 +- lib/soap/rpc/element.rb | 18 +++--- lib/soap/rpc/proxy.rb | 154 ++++++++++++++++++++++++++++++++++-------------- lib/soap/rpc/router.rb | 104 +++++++++++++++++++------------- 4 files changed, 183 insertions(+), 95 deletions(-) (limited to 'lib/soap/rpc') diff --git a/lib/soap/rpc/driver.rb b/lib/soap/rpc/driver.rb index 096a54f01a..0fb4e82488 100644 --- a/lib/soap/rpc/driver.rb +++ b/lib/soap/rpc/driver.rb @@ -205,7 +205,7 @@ private opt.add_hook("protocol.wiredump_file_base") do |key, value| @wiredump_file_base = value end - opt["protocol.http.charset"] ||= XSD::Charset.encoding_label + opt["protocol.http.charset"] ||= XSD::Charset.xml_encoding_label opt["protocol.http.proxy"] ||= Env::HTTP_PROXY opt["protocol.http.no_proxy"] ||= Env::NO_PROXY opt diff --git a/lib/soap/rpc/element.rb b/lib/soap/rpc/element.rb index e6cae2f7e0..c224b03d0d 100644 --- a/lib/soap/rpc/element.rb +++ b/lib/soap/rpc/element.rb @@ -20,21 +20,25 @@ class SOAPBody < SOAPStruct end def response + root = root_node if !@is_fault - if void? + if root.nil? nil + elsif root.is_a?(SOAPBasetype) + root else # Initial element is [retval]. - root_node[0] + root[0] end else - root_node + root end end def outparams - if !@is_fault and !void? - op = root_node[1..-1] + root = root_node + if !@is_fault and !root.nil? and !root.is_a?(SOAPBasetype) + op = root[1..-1] op = nil if op && op.empty? op else @@ -42,10 +46,6 @@ class SOAPBody < SOAPStruct end end - def void? - root_node.nil? - end - def fault if @is_fault self['fault'] diff --git a/lib/soap/rpc/proxy.rb b/lib/soap/rpc/proxy.rb index b9d80541af..7dfda62006 100644 --- a/lib/soap/rpc/proxy.rb +++ b/lib/soap/rpc/proxy.rb @@ -92,6 +92,14 @@ public opt[:response_style] ||= :document opt[:request_use] ||= :literal opt[:response_use] ||= :literal + # default values of these values are unqualified in XML Schema. + # set true for backward compatibility. + unless opt.key?(:elementformdefault) + opt[:elementformdefault] = true + end + unless opt.key?(:attributeformdefault) + opt[:attributeformdefault] = true + end @operation[name] = Operation.new(soapaction, param_def, opt) end @@ -101,7 +109,7 @@ public alias add_document_method add_document_operation def invoke(req_header, req_body, opt = nil) - opt ||= create_options + opt ||= create_encoding_opt route(req_header, req_body, opt, opt) end @@ -109,15 +117,27 @@ public unless op_info = @operation[name] raise MethodDefinitionError, "method: #{name} not defined" end + mapping_opt = create_mapping_opt req_header = create_request_header req_body = SOAPBody.new( - op_info.request_body(params, @mapping_registry, @literal_mapping_registry) + op_info.request_body(params, @mapping_registry, + @literal_mapping_registry, mapping_opt) ) - reqopt = create_options({ + reqopt = create_encoding_opt( :soapaction => op_info.soapaction || @soapaction, - :default_encodingstyle => op_info.request_default_encodingstyle}) - resopt = create_options({ - :default_encodingstyle => op_info.response_default_encodingstyle}) + :envelopenamespace => @options["soap.envelope.requestnamespace"], + :default_encodingstyle => + @default_encodingstyle || op_info.request_default_encodingstyle, + :elementformdefault => op_info.elementformdefault, + :attributeformdefault => op_info.attributeformdefault + ) + resopt = create_encoding_opt( + :envelopenamespace => @options["soap.envelope.responsenamespace"], + :default_encodingstyle => + @default_encodingstyle || op_info.response_default_encodingstyle, + :elementformdefault => op_info.elementformdefault, + :attributeformdefault => op_info.attributeformdefault + ) env = route(req_header, req_body, reqopt, resopt) raise EmptyResponseError unless env receive_headers(env.header) @@ -126,11 +146,15 @@ public rescue ::SOAP::FaultError => e op_info.raise_fault(e, @mapping_registry, @literal_mapping_registry) end - op_info.response_obj(env.body, @mapping_registry, @literal_mapping_registry) + op_info.response_obj(env.body, @mapping_registry, + @literal_mapping_registry, mapping_opt) end def route(req_header, req_body, reqopt, resopt) - req_env = SOAPEnvelope.new(req_header, req_body) + req_env = ::SOAP::SOAPEnvelope.new(req_header, req_body) + unless reqopt[:envelopenamespace].nil? + set_envelopenamespace(req_env, reqopt[:envelopenamespace]) + end reqopt[:external_content] = nil conn_data = marshal(req_env, reqopt) if ext = reqopt[:external_content] @@ -159,6 +183,16 @@ public private + def set_envelopenamespace(env, namespace) + env.elename = XSD::QName.new(namespace, env.elename.name) + if env.header + env.header.elename = XSD::QName.new(namespace, env.header.elename.name) + end + if env.body + env.body.elename = XSD::QName.new(namespace, env.body.elename.name) + end + end + def create_request_header headers = @headerhandler.on_outbound if headers.empty? @@ -201,6 +235,10 @@ private ::SOAP::StreamHandler.parse_media_type(contenttype) env = Processor.unmarshal(conn_data.receive_string, opt) end + unless env.is_a?(::SOAP::SOAPEnvelope) + raise ResponseFormatError.new( + "response is not a SOAP envelope: #{conn_data.receive_string}") + end env end @@ -212,11 +250,22 @@ private header end - def create_options(hash = nil) + def create_encoding_opt(hash = nil) opt = {} opt[:default_encodingstyle] = @default_encodingstyle opt[:allow_unqualified_element] = @allow_unqualified_element opt[:generate_explicit_type] = @generate_explicit_type + opt[:no_indent] = @options["soap.envelope.no_indent"] + opt[:use_numeric_character_reference] = + @options["soap.envelope.use_numeric_character_reference"] + opt.update(hash) if hash + opt + end + + def create_mapping_opt(hash = nil) + opt = { + :external_ces => @options["soap.mapping.external_ces"] + } opt.update(hash) if hash opt end @@ -227,6 +276,8 @@ private attr_reader :response_style attr_reader :request_use attr_reader :response_use + attr_reader :elementformdefault + attr_reader :attributeformdefault def initialize(soapaction, param_def, opt) @soapaction = soapaction @@ -234,6 +285,9 @@ private @response_style = opt[:response_style] @request_use = opt[:request_use] @response_use = opt[:response_use] + # set nil(unqualified) by default + @elementformdefault = opt[:elementformdefault] + @attributeformdefault = opt[:attributeformdefault] check_style(@request_style) check_style(@response_style) check_use(@request_use) @@ -247,17 +301,22 @@ private RPC::SOAPMethodRequest.new(@rpc_request_qname, param_def, @soapaction) else @doc_request_qnames = [] + @doc_request_qualified = [] @doc_response_qnames = [] - param_def.each do |inout, paramname, typeinfo| + @doc_response_qualified = [] + param_def.each do |inout, paramname, typeinfo, eleinfo| klass_not_used, nsdef, namedef = typeinfo + qualified = eleinfo if namedef.nil? raise MethodDefinitionError.new("qname must be given") end case inout when SOAPMethod::IN @doc_request_qnames << XSD::QName.new(nsdef, namedef) + @doc_request_qualified << qualified when SOAPMethod::OUT @doc_response_qnames << XSD::QName.new(nsdef, namedef) + @doc_response_qualified << qualified else raise MethodDefinitionError.new( "illegal inout definition for document style: #{inout}") @@ -274,19 +333,19 @@ private (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace end - def request_body(values, mapping_registry, literal_mapping_registry) + def request_body(values, mapping_registry, literal_mapping_registry, opt) if @request_style == :rpc - request_rpc(values, mapping_registry, literal_mapping_registry) + request_rpc(values, mapping_registry, literal_mapping_registry, opt) else - request_doc(values, mapping_registry, literal_mapping_registry) + request_doc(values, mapping_registry, literal_mapping_registry, opt) end end - def response_obj(body, mapping_registry, literal_mapping_registry) + def response_obj(body, mapping_registry, literal_mapping_registry, opt) if @response_style == :rpc - response_rpc(body, mapping_registry, literal_mapping_registry) + response_rpc(body, mapping_registry, literal_mapping_registry, opt) else - response_doc(body, mapping_registry, literal_mapping_registry) + response_doc(body, mapping_registry, literal_mapping_registry, opt) end end @@ -312,86 +371,89 @@ private end end - def request_rpc(values, mapping_registry, literal_mapping_registry) + def request_rpc(values, mapping_registry, literal_mapping_registry, opt) if @request_use == :encoded - request_rpc_enc(values, mapping_registry) + request_rpc_enc(values, mapping_registry, opt) else - request_rpc_lit(values, literal_mapping_registry) + request_rpc_lit(values, literal_mapping_registry, opt) end end - def request_doc(values, mapping_registry, literal_mapping_registry) + def request_doc(values, mapping_registry, literal_mapping_registry, opt) if @request_use == :encoded - request_doc_enc(values, mapping_registry) + request_doc_enc(values, mapping_registry, opt) else - request_doc_lit(values, literal_mapping_registry) + request_doc_lit(values, literal_mapping_registry, opt) end end - def request_rpc_enc(values, mapping_registry) + 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) + soap = Mapping.obj2soap(obj, mapping_registry, @rpc_request_qname, opt) method.set_param(soap) method end - def request_rpc_lit(values, mapping_registry) + def request_rpc_lit(values, mapping_registry, opt) method = @rpc_method_factory.dup params = {} idx = 0 method.input_params.each do |name| params[name] = Mapping.obj2soap(values[idx], mapping_registry, - XSD::QName.new(nil, name)) + XSD::QName.new(nil, name), opt) idx += 1 end method.set_param(params) method end - def request_doc_enc(values, mapping_registry) + def request_doc_enc(values, mapping_registry, opt) (0...values.size).collect { |idx| - ele = Mapping.obj2soap(values[idx], mapping_registry) + ele = Mapping.obj2soap(values[idx], mapping_registry, nil, opt) ele.elename = @doc_request_qnames[idx] ele } end - def request_doc_lit(values, mapping_registry) + def request_doc_lit(values, mapping_registry, opt) (0...values.size).collect { |idx| ele = Mapping.obj2soap(values[idx], mapping_registry, - @doc_request_qnames[idx]) + @doc_request_qnames[idx], opt) ele.encodingstyle = LiteralNamespace + if ele.respond_to?(:qualified) + ele.qualified = @doc_request_qualified[idx] + end ele } end - def response_rpc(body, mapping_registry, literal_mapping_registry) + def response_rpc(body, mapping_registry, literal_mapping_registry, opt) if @response_use == :encoded - response_rpc_enc(body, mapping_registry) + response_rpc_enc(body, mapping_registry, opt) else - response_rpc_lit(body, literal_mapping_registry) + response_rpc_lit(body, literal_mapping_registry, opt) end end - def response_doc(body, mapping_registry, literal_mapping_registry) + def response_doc(body, mapping_registry, literal_mapping_registry, opt) if @response_use == :encoded - return *response_doc_enc(body, mapping_registry) + return *response_doc_enc(body, mapping_registry, opt) else - return *response_doc_lit(body, literal_mapping_registry) + return *response_doc_lit(body, literal_mapping_registry, opt) end end - def response_rpc_enc(body, mapping_registry) + def response_rpc_enc(body, mapping_registry, opt) ret = nil if body.response ret = Mapping.soap2obj(body.response, mapping_registry, - @rpc_method_factory.retval_class_name) + @rpc_method_factory.retval_class_name, opt) end if body.outparams outparams = body.outparams.collect { |outparam| - Mapping.soap2obj(outparam, mapping_regisry) + Mapping.soap2obj(outparam, mapping_registry, nil, opt) } [ret].concat(outparams) else @@ -399,20 +461,20 @@ private end end - def response_rpc_lit(body, mapping_registry) + def response_rpc_lit(body, mapping_registry, opt) body.root_node.collect { |key, value| Mapping.soap2obj(value, mapping_registry, - @rpc_method_factory.retval_class_name) + @rpc_method_factory.retval_class_name, opt) } end - def response_doc_enc(body, mapping_registry) + def response_doc_enc(body, mapping_registry, opt) body.collect { |key, value| - Mapping.soap2obj(value, mapping_registry) + Mapping.soap2obj(value, mapping_registry, nil, opt) } end - def response_doc_lit(body, mapping_registry) + def response_doc_lit(body, mapping_registry, opt) body.collect { |key, value| Mapping.soap2obj(value, mapping_registry) } @@ -420,8 +482,10 @@ private def create_request_obj(names, params) o = Object.new - for idx in 0 ... params.length + idx = 0 + while idx < params.length o.instance_variable_set('@' + names[idx], params[idx]) + idx += 1 end o end diff --git a/lib/soap/rpc/router.rb b/lib/soap/rpc/router.rb index 1d11bc17dc..71c6eb625b 100644 --- a/lib/soap/rpc/router.rb +++ b/lib/soap/rpc/router.rb @@ -28,6 +28,7 @@ class Router attr_accessor :mapping_registry attr_accessor :literal_mapping_registry attr_accessor :generate_explicit_type + attr_accessor :external_ces def initialize(actor) @actor = actor @@ -35,6 +36,7 @@ class Router @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 = [] @@ -163,7 +165,8 @@ class Router soap_response = default_encodingstyle = nil begin soap_response = - op.call(env.body, @mapping_registry, @literal_mapping_registry) + op.call(env.body, @mapping_registry, @literal_mapping_registry, + create_mapping_opt) default_encodingstyle = op.response_default_encodingstyle rescue Exception soap_response = fault($!) @@ -240,7 +243,8 @@ private return op end if soapaction - raise RPCRoutingError.new("operation: #{soapaction} not supported") + raise RPCRoutingError.new( + "operation: #{soapaction} #{qname} not supported") else raise RPCRoutingError.new("operation: #{qname} not supported") end @@ -323,6 +327,10 @@ private Mapping.obj2soap(detail, @mapping_registry)) end + def create_mapping_opt + { :external_ces => @external_ces } + end + class Operation attr_reader :name attr_reader :soapaction @@ -349,14 +357,19 @@ private @rpc_response_qname = opt[:response_qname] else @doc_request_qnames = [] + @doc_request_qualified = [] @doc_response_qnames = [] - param_def.each do |inout, paramname, typeinfo| + @doc_response_qualified = [] + param_def.each do |inout, paramname, typeinfo, eleinfo| klass, nsdef, namedef = typeinfo + qualified = eleinfo case inout when SOAPMethod::IN @doc_request_qnames << XSD::QName.new(nsdef, namedef) + @doc_request_qualified << qualified when SOAPMethod::OUT @doc_response_qnames << XSD::QName.new(nsdef, namedef) + @doc_response_qualified << qualified else raise ArgumentError.new( "illegal inout definition for document style: #{inout}") @@ -373,18 +386,20 @@ private (@response_use == :encoded) ? EncodingNamespace : LiteralNamespace end - def call(body, mapping_registry, literal_mapping_registry) + def call(body, mapping_registry, literal_mapping_registry, opt) if @request_style == :rpc - values = request_rpc(body, mapping_registry, literal_mapping_registry) + values = request_rpc(body, mapping_registry, literal_mapping_registry, + opt) else - values = request_document(body, mapping_registry, literal_mapping_registry) + values = request_document(body, mapping_registry, + literal_mapping_registry, opt) end result = receiver.method(@name.intern).call(*values) return result if result.is_a?(SOAPFault) if @response_style == :rpc - response_rpc(result, mapping_registry, literal_mapping_registry) + response_rpc(result, mapping_registry, literal_mapping_registry, opt) else - response_doc(result, mapping_registry, literal_mapping_registry) + response_doc(result, mapping_registry, literal_mapping_registry, opt) end end @@ -394,61 +409,61 @@ private raise NotImplementedError.new('must be defined in derived class') end - def request_rpc(body, mapping_registry, literal_mapping_registry) + def request_rpc(body, mapping_registry, literal_mapping_registry, opt) request = body.request unless request.is_a?(SOAPStruct) raise RPCRoutingError.new("not an RPC style") end if @request_use == :encoded - request_rpc_enc(request, mapping_registry) + request_rpc_enc(request, mapping_registry, opt) else - request_rpc_lit(request, literal_mapping_registry) + request_rpc_lit(request, literal_mapping_registry, opt) end end - def request_document(body, mapping_registry, literal_mapping_registry) + def request_document(body, mapping_registry, literal_mapping_registry, opt) # ToDo: compare names with @doc_request_qnames if @request_use == :encoded - request_doc_enc(body, mapping_registry) + request_doc_enc(body, mapping_registry, opt) else - request_doc_lit(body, literal_mapping_registry) + request_doc_lit(body, literal_mapping_registry, opt) end end - def request_rpc_enc(request, mapping_registry) - param = Mapping.soap2obj(request, mapping_registry) + def request_rpc_enc(request, mapping_registry, opt) + param = Mapping.soap2obj(request, mapping_registry, nil, opt) request.collect { |key, value| param[key] } end - def request_rpc_lit(request, mapping_registry) + def request_rpc_lit(request, mapping_registry, opt) request.collect { |key, value| - Mapping.soap2obj(value, mapping_registry) + Mapping.soap2obj(value, mapping_registry, nil, opt) } end - def request_doc_enc(body, mapping_registry) + def request_doc_enc(body, mapping_registry, opt) body.collect { |key, value| - Mapping.soap2obj(value, mapping_registry) + Mapping.soap2obj(value, mapping_registry, nil, opt) } end - def request_doc_lit(body, mapping_registry) + def request_doc_lit(body, mapping_registry, opt) body.collect { |key, value| - Mapping.soap2obj(value, mapping_registry) + Mapping.soap2obj(value, mapping_registry, nil, opt) } end - def response_rpc(result, mapping_registry, literal_mapping_registry) + def response_rpc(result, mapping_registry, literal_mapping_registry, opt) if @response_use == :encoded - response_rpc_enc(result, mapping_registry) + response_rpc_enc(result, mapping_registry, opt) else - response_rpc_lit(result, literal_mapping_registry) + response_rpc_lit(result, literal_mapping_registry, opt) end end - def response_doc(result, mapping_registry, literal_mapping_registry) + def response_doc(result, mapping_registry, literal_mapping_registry, opt) if @doc_response_qnames.size == 1 and !result.is_a?(Array) result = [result] end @@ -457,13 +472,13 @@ private "but #{result.size} given" end if @response_use == :encoded - response_doc_enc(result, mapping_registry) + response_doc_enc(result, mapping_registry, opt) else - response_doc_lit(result, literal_mapping_registry) + response_doc_lit(result, literal_mapping_registry, opt) end end - def response_rpc_enc(result, mapping_registry) + def response_rpc_enc(result, mapping_registry, opt) soap_response = @rpc_method_factory.create_method_response(@rpc_response_qname) if soap_response.have_outparam? @@ -473,18 +488,21 @@ private outparams = {} i = 1 soap_response.output_params.each do |outparam| - outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry) + outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry, + nil, opt) i += 1 end soap_response.set_outparam(outparams) - soap_response.retval = Mapping.obj2soap(result[0], mapping_registry) + soap_response.retval = Mapping.obj2soap(result[0], mapping_registry, + nil, opt) else - soap_response.retval = Mapping.obj2soap(result, mapping_registry) + soap_response.retval = Mapping.obj2soap(result, mapping_registry, nil, + opt) end soap_response end - def response_rpc_lit(result, mapping_registry) + def response_rpc_lit(result, mapping_registry, opt) soap_response = @rpc_method_factory.create_method_response(@rpc_response_qname) if soap_response.have_outparam? @@ -495,30 +513,36 @@ private i = 1 soap_response.output_params.each do |outparam| outparams[outparam] = Mapping.obj2soap(result[i], mapping_registry, - XSD::QName.new(nil, outparam)) + XSD::QName.new(nil, outparam), opt) i += 1 end soap_response.set_outparam(outparams) soap_response.retval = Mapping.obj2soap(result[0], mapping_registry, - XSD::QName.new(nil, soap_response.elename)) + XSD::QName.new(nil, soap_response.elename), opt) else soap_response.retval = Mapping.obj2soap(result, mapping_registry, - XSD::QName.new(nil, soap_response.elename)) + XSD::QName.new(nil, soap_response.elename), opt) end soap_response end - def response_doc_enc(result, mapping_registry) + def response_doc_enc(result, mapping_registry, opt) (0...result.size).collect { |idx| - ele = Mapping.obj2soap(result[idx], mapping_registry) + ele = Mapping.obj2soap(result[idx], mapping_registry, nil, opt) ele.elename = @doc_response_qnames[idx] ele } end - def response_doc_lit(result, mapping_registry) + def response_doc_lit(result, mapping_registry, opt) (0...result.size).collect { |idx| - mapping_registry.obj2soap(result[idx], @doc_response_qnames[idx]) + ele = Mapping.obj2soap(result[idx], mapping_registry, + @doc_response_qnames[idx]) + ele.encodingstyle = LiteralNamespace + if ele.respond_to?(:qualified) + ele.qualified = @doc_response_qualified[idx] + end + ele } end -- cgit v1.2.3