From aaea48fe9826b9e5d2d5b92795a297b8f238c58d Mon Sep 17 00:00:00 2001 From: Leon Breedt Date: Sat, 2 Apr 2005 21:03:36 +0000 Subject: * collapse 'ws' back into protocols, it just added complexity and indirection, and was hard to extend. * extract casting into seperate support file * ensure casting always does the right thing for return values, should fix interoperability issues with Ecto and possibly other XML-RPC clients * add functional unit tests for scaffolding * represent signature items with classes instead of symbols/Class objects, much more flexible * tweak logging to always show casted versions of parameters and return values, if possible. git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@1072 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- .../lib/action_web_service/dispatcher/abstract.rb | 40 +++++++------- .../dispatcher/action_controller_dispatcher.rb | 63 +++++++++++----------- 2 files changed, 53 insertions(+), 50 deletions(-) (limited to 'actionwebservice/lib/action_web_service/dispatcher') diff --git a/actionwebservice/lib/action_web_service/dispatcher/abstract.rb b/actionwebservice/lib/action_web_service/dispatcher/abstract.rb index 69c3b9de3b..975120212f 100644 --- a/actionwebservice/lib/action_web_service/dispatcher/abstract.rb +++ b/actionwebservice/lib/action_web_service/dispatcher/abstract.rb @@ -12,14 +12,6 @@ module ActionWebService # :nodoc: base.send(:include, ActionWebService::Dispatcher::InstanceMethods) end - def self.layered_service_name(public_method_name) # :nodoc: - if public_method_name =~ /^([^\.]+)\.(.*)$/ - $1 - else - nil - end - end - module InstanceMethods # :nodoc: private def invoke_web_service_request(protocol_request) @@ -40,13 +32,7 @@ module ActionWebService # :nodoc: else return_value = self.__send__(invocation.api_method.name) end - if invocation.api.has_api_method?(invocation.api_method.name) - api_method = invocation.api_method - else - api_method = invocation.api_method.dup - api_method.instance_eval{ @returns = [ return_value.class ] } - end - invocation.protocol.marshal_response(api_method, return_value) + web_service_create_response(invocation.protocol, invocation.api, invocation.api_method, return_value) end def web_service_delegated_invoke(invocation) @@ -57,7 +43,7 @@ module ActionWebService # :nodoc: if cancellation_reason raise(DispatcherError, "request canceled: #{cancellation_reason}") end - invocation.protocol.marshal_response(invocation.api_method, return_value) + web_service_create_response(invocation.protocol, invocation.api, invocation.api_method, return_value) end def web_service_invocation(request) @@ -79,6 +65,7 @@ module ActionWebService # :nodoc: invocation.service = web_service_object(invocation.service_name) invocation.api = invocation.service.class.web_service_api end + invocation.protocol.register_api(invocation.api) request.api = invocation.api if invocation.api.has_public_api_method?(public_method_name) invocation.api_method = invocation.api.public_api_method_instance(public_method_name) @@ -89,15 +76,20 @@ module ActionWebService # :nodoc: invocation.api_method = invocation.api.default_api_method_instance end end + if invocation.service.nil? + raise(DispatcherError, "no service available for service name #{invocation.service_name}") + end unless invocation.service.respond_to?(invocation.api_method.name) - raise(DispatcherError, "no such method '#{public_method_name}' on API #{invocation.api} (#{invocation.api_method.name})") + raise(DispatcherError, "no such method '#{public_method_name}' on API #{invocation.api} (#{invocation.api_method.name})") end request.api_method = invocation.api_method begin - invocation.method_ordered_params = invocation.api_method.cast_expects_ws2ruby(request.protocol.marshaler, request.method_params) + invocation.method_ordered_params = invocation.api_method.cast_expects(request.method_params.dup) rescue - invocation.method_ordered_params = request.method_params.map{ |x| x.value } + logger.warn "Casting of method parameters failed" unless logger.nil? + invocation.method_ordered_params = request.method_params end + request.method_params = invocation.method_ordered_params invocation.method_named_params = {} invocation.api_method.param_names.inject(0) do |m, n| invocation.method_named_params[n] = invocation.method_ordered_params[m] @@ -106,6 +98,16 @@ module ActionWebService # :nodoc: invocation end + def web_service_create_response(protocol, api, api_method, return_value) + if api.has_api_method?(api_method.name) + return_type = api_method.returns ? api_method.returns[0] : nil + return_value = api_method.cast_returns(return_value) + else + return_type = ActionWebService::SignatureTypes.canonical_signature_entry(return_value.class, 0) + end + protocol.encode_response(api_method.public_name + 'Response', return_value, return_type) + end + class Invocation # :nodoc: attr_accessor :protocol attr_accessor :service_name diff --git a/actionwebservice/lib/action_web_service/dispatcher/action_controller_dispatcher.rb b/actionwebservice/lib/action_web_service/dispatcher/action_controller_dispatcher.rb index 0140039c49..a4659e5183 100644 --- a/actionwebservice/lib/action_web_service/dispatcher/action_controller_dispatcher.rb +++ b/actionwebservice/lib/action_web_service/dispatcher/action_controller_dispatcher.rb @@ -45,7 +45,6 @@ module ActionWebService # :nodoc: exception = e end if request - log_request(request, @request.raw_post) response = nil exception = nil bm = Benchmark.measure do @@ -55,6 +54,7 @@ module ActionWebService # :nodoc: exception = e end end + log_request(request, @request.raw_post) if exception log_error(exception) unless logger.nil? send_web_service_error_response(request, exception) @@ -82,10 +82,10 @@ module ActionWebService # :nodoc: unless self.class.web_service_exception_reporting exception = DispatcherError.new("Internal server error (exception raised)") end - api_method = request.api_method ? request.api_method.dup : nil - api_method ||= request.api.dummy_api_method_instance(request.method_name) - api_method.instance_eval{ @returns = [ exception.class ] } - response = request.protocol.marshal_response(api_method, exception) + api_method = request.api_method + public_method_name = api_method ? api_method.public_name : request.method_name + return_type = ActionWebService::SignatureTypes.canonical_signature_entry(Exception, 0) + response = request.protocol.encode_response(public_method_name + 'Response', exception, return_type) send_web_service_response(response) else if self.class.web_service_exception_reporting @@ -118,7 +118,14 @@ module ActionWebService # :nodoc: def log_request(request, body) unless logger.nil? name = request.method_name - params = request.method_params.map{|x| "#{x.info.name}=>#{x.value.inspect}"} + api_method = request.api_method + params = request.method_params + if api_method && api_method.expects + i = 0 + params = api_method.expects.map{ |type| param = "#{type.name}=>#{params[i].inspect}"; i+= 1; param } + else + params = params.map{ |param| param.inspect } + end service = request.service_name logger.debug("\nWeb Service Request: #{name}(#{params.join(", ")}) Entrypoint: #{service}") logger.debug(indent(body)) @@ -127,7 +134,8 @@ module ActionWebService # :nodoc: def log_response(response, elapsed=nil) unless logger.nil? - logger.debug("\nWeb Service Response" + (elapsed ? " (%f):" % elapsed : ":")) + elapsed = (elapsed ? " (%f):" % elapsed : ":") + logger.debug("\nWeb Service Response" + elapsed + " => #{response.return_value.inspect}") logger.debug(indent(response.body)) end end @@ -171,7 +179,7 @@ module ActionWebService # :nodoc: namespace = 'urn:ActionWebService' soap_action_base = "/#{controller_name}" - marshaler = WS::Marshaling::SoapMarshaler.new(namespace) + marshaler = ActionWebService::Protocol::Soap::SoapMarshaler.new(namespace) apis = {} case dispatching_mode when :direct @@ -208,7 +216,7 @@ module ActionWebService # :nodoc: xm.xsd(:schema, 'xmlns' => XsdNs, 'targetNamespace' => namespace) do custom_types.each do |binding| case - when binding.is_typed_array? + when binding.type.array? xm.xsd(:complexType, 'name' => binding.type_name) do xm.xsd(:complexContent) do xm.xsd(:restriction, 'base' => 'soapenc:Array') do @@ -217,11 +225,11 @@ module ActionWebService # :nodoc: end end end - when binding.is_typed_struct? + when binding.type.structured? xm.xsd(:complexType, 'name' => binding.type_name) do xm.xsd(:all) do - binding.each_member do |name, spec| - b = marshaler.register_type(spec) + binding.type.each_member do |name, type| + b = marshaler.register_type(type) xm.xsd(:element, 'name' => name, 'type' => b.qualified_type_name('typens')) end end @@ -249,14 +257,8 @@ module ActionWebService # :nodoc: expects = method.expects i = 1 expects.each do |type| - if type.is_a?(Hash) - param_name = type.keys.shift - type = type.values.shift - else - param_name = "param#{i}" - end binding = marshaler.register_type(type) - xm.part('name' => param_name, 'type' => binding.qualified_type_name('typens')) + xm.part('name' => type.name, 'type' => binding.qualified_type_name('typens')) i += 1 end if expects end @@ -340,7 +342,9 @@ module ActionWebService # :nodoc: def register_api(api, marshaler) bindings = {} traverse_custom_types(api, marshaler) do |binding| - bindings[binding] = nil unless bindings.has_key?(binding.type_class) + bindings[binding] = nil unless bindings.has_key?(binding) + element_binding = binding.element_binding + bindings[binding.element_binding] = nil if element_binding && !bindings.has_key?(element_binding) end bindings.keys end @@ -348,21 +352,18 @@ module ActionWebService # :nodoc: def traverse_custom_types(api, marshaler, &block) api.api_methods.each do |name, method| expects, returns = method.expects, method.returns - expects.each{|x| traverse_custom_type_spec(marshaler, x, &block)} if expects - returns.each{|x| traverse_custom_type_spec(marshaler, x, &block)} if returns + expects.each{ |type| traverse_type(marshaler, type, &block) if type.custom? } if expects + returns.each{ |type| traverse_type(marshaler, type, &block) if type.custom? } if returns end end - def traverse_custom_type_spec(marshaler, spec, &block) - binding = marshaler.register_type(spec) - if binding.is_typed_struct? - binding.each_member do |name, member_spec| - traverse_custom_type_spec(marshaler, member_spec, &block) - end - elsif binding.is_typed_array? - traverse_custom_type_spec(marshaler, binding.element_binding.type_class, &block) + def traverse_type(marshaler, type, &block) + yield marshaler.register_type(type) + if type.array? + yield marshaler.register_type(type.element_type) + type = type.element_type end - yield binding + type.each_member{ |name, type| traverse_type(marshaler, type, &block) } if type.structured? end end end -- cgit v1.2.3