actionwebservice 0.6.2 → 0.7.0

data/lib/action_web_service/casting.rb

@@ -0,0 +1,111 @@
+require 'time'
+require 'date'
+
+module ActionWebService # :nodoc:
+  module Casting # :nodoc:
+    class CastingError < ActionWebServiceError # :nodoc:
+    end
+
+    # Performs casting of arbitrary values into the correct types for the signature
+    class BaseCaster
+      def initialize(api_method)
+        @api_method = api_method
+      end
+
+      # Coerces the parameters in +params+ (an Enumerable) into the types
+      # this method expects
+      def cast_expects(params)
+        self.class.cast_expects(@api_method, params)
+      end
+
+      # Coerces the given +return_value+ into the the type returned by this
+      # method
+      def cast_returns(return_value)
+        self.class.cast_returns(@api_method, return_value)
+      end
+
+      class << self
+        include ActionWebService::SignatureTypes
+
+        def cast_expects(api_method, params) # :nodoc:
+          return [] if api_method.expects.nil?
+          api_method.expects.zip(params).map{ |type, param| cast(param, type) }
+        end
+
+        def cast_returns(api_method, return_value) # :nodoc:
+          return nil if api_method.returns.nil?
+          cast(return_value, api_method.returns[0])
+        end
+
+        def cast(value, signature_type) # :nodoc:
+          return value if signature_type.nil? # signature.length != params.length
+          unless signature_type.array? || signature_type.structured?
+            return value if canonical_type(value.class) == signature_type.type
+          end
+          if signature_type.array?
+            unless value.respond_to?(:entries) && !value.is_a?(String)
+              raise CastingError, "Don't know how to cast #{value.class} into #{signature_type.type.inspect}"
+            end
+            value.entries.map do |entry|
+              cast(entry, signature_type.element_type)
+            end
+          elsif signature_type.structured?
+            cast_to_structured_type(value, signature_type)
+          elsif !signature_type.custom?
+            cast_base_type(value, signature_type)
+          end
+        end
+
+        def cast_base_type(value, signature_type) # :nodoc:
+          case signature_type.type
+          when :int
+            Integer(value)
+          when :string
+            value.to_s
+          when :bool
+            return false if value.nil?
+            return value if value == true || value == false
+            case value.to_s.downcase
+            when '1', 'true', 'y', 'yes'
+              true
+            when '0', 'false', 'n', 'no'
+              false
+            else
+              raise CastingError, "Don't know how to cast #{value.class} into Boolean"
+            end
+          when :float
+            Float(value)
+          when :time
+            Time.parse(value.to_s)
+          when :date
+            Date.parse(value.to_s)
+          when :datetime
+            DateTime.parse(value.to_s)
+          end
+        end
+
+        def cast_to_structured_type(value, signature_type) # :nodoc:
+          obj = nil
+          obj = value if canonical_type(value.class) == canonical_type(signature_type.type)
+          obj ||= signature_type.type_class.new
+          if value.respond_to?(:each_pair)
+            klass = signature_type.type_class
+            value.each_pair do |name, val|
+              type = klass.respond_to?(:member_type) ? klass.member_type(name) : nil
+              val = cast(val, type) if type
+              obj.__send__("#{name}=", val) if obj.respond_to?(name)
+            end
+          elsif value.respond_to?(:attributes)
+            signature_type.each_member do |name, type|
+              val = value.__send__(name)
+              obj.__send__("#{name}=", cast(val, type)) if obj.respond_to?(name)
+            end
+          else
+            raise CastingError, "Don't know how to cast #{value.class} to #{signature_type.type_class}"
+          end
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/action_web_service/client/soap_client.rb

@@ -46,8 +46,7 @@ module ActionWebService # :nodoc:
         @type_namespace = options[:type_namespace] || 'urn:ActionWebService'
         @method_namespace = options[:method_namespace] || 'urn:ActionWebService'
         @driver_options = options[:driver_options] || {}
-        @marshaler = WS::Marshaling::SoapMarshaler.new @type_namespace
-        @encoder = WS::Encoding::SoapRpcEncoding.new @method_namespace
+        @protocol = ActionWebService::Protocol::Soap::SoapProtocol.new
         @soap_action_base = options[:soap_action_base]
         @soap_action_base ||= URI.parse(endpoint_uri).path
         @driver = create_soap_rpc_driver(api, endpoint_uri)
@@ -58,7 +57,10 @@ module ActionWebService # :nodoc:
 
       protected
         def perform_invocation(method_name, args)
-          @driver.send(method_name, *args)
+          method = @api.api_methods[method_name.to_sym]
+          args = method.cast_expects(args.dup) rescue args
+          return_value = @driver.send(method_name, *args)
+          method.cast_returns(return_value.dup) rescue return_value
         end
 
         def soap_action(method_name)
@@ -67,48 +69,30 @@ module ActionWebService # :nodoc:
 
       private
         def create_soap_rpc_driver(api, endpoint_uri)
-          register_api(@marshaler, api)
+          @protocol.register_api(api)
           driver = SoapDriver.new(endpoint_uri, nil)
-          driver.mapping_registry = @marshaler.registry
-          api.api_methods.each do |name, info|
-            public_name = api.public_api_method_name(name)
-            qname = XSD::QName.new(@method_namespace, public_name)
-            action = soap_action(public_name)
-            expects = info[:expects]
-            returns = info[:returns]
+          driver.mapping_registry = @protocol.marshaler.registry
+          api.api_methods.each do |name, method|
+            qname = XSD::QName.new(@method_namespace, method.public_name)
+            action = soap_action(method.public_name)
+            expects = method.expects
+            returns = method.returns
             param_def = []
-            i = 0
             if expects
-              expects.each do |spec|
-                param_name = spec.is_a?(Hash) ? spec.keys[0].to_s : "param#{i}"
-                type_binding = @marshaler.register_type(spec)
-                param_def << ['in', param_name, type_binding.mapping]
-                i += 1
+              expects.each do |type|
+                type_binding = @protocol.marshaler.lookup_type(type)
+                param_def << ['in', type.name, type_binding.mapping]
               end
             end
             if returns
-              type_binding = @marshaler.register_type(returns[0])
+              type_binding = @protocol.marshaler.lookup_type(returns[0])
               param_def << ['retval', 'return', type_binding.mapping]
             end
-            driver.add_method(qname, action, name.to_s, param_def)
+            driver.add_method(qname, action, method.name.to_s, param_def)
           end
           driver
         end
 
-        def register_api(marshaler, api)
-          type_bindings = []
-          api.api_methods.each do |name, info|
-            expects, returns = info[:expects], info[:returns]
-            if expects
-              expects.each{|type| type_bindings << marshaler.register_type(type)}
-            end
-            if returns
-              returns.each{|type| type_bindings << marshaler.register_type(type)}
-            end
-          end
-          type_bindings
-        end
-
         class SoapDriver < SOAP::RPC::Driver # :nodoc:
           def add_method(qname, soapaction, name, param_def)
             @proxy.add_rpc_method(qname, soapaction, name, param_def)

data/lib/action_web_service/client/xmlrpc_client.rb

@@ -30,47 +30,23 @@ module ActionWebService # :nodoc:
       def initialize(api, endpoint_uri, options={})
         @api = api
         @handler_name = options[:handler_name]
+        @protocol = ActionWebService::Protocol::XmlRpc::XmlRpcProtocol.new
         @client = XMLRPC::Client.new2(endpoint_uri, options[:proxy], options[:timeout])
-        @marshaler = WS::Marshaling::XmlRpcMarshaler.new
       end
 
       protected
         def perform_invocation(method_name, args)
-          args = transform_outgoing_method_params(method_name, args)
-          ok, return_value = @client.call2(public_name(method_name), *args)
-          return transform_return_value(method_name, return_value) if ok
-          raise(ClientError, "#{return_value.faultCode}: #{return_value.faultString}")
-        end
-
-        def transform_outgoing_method_params(method_name, params)
-          info = @api.api_methods[method_name.to_sym]
-          expects = info[:expects]
-          expects_length = expects.nil?? 0 : expects.length
-          if expects_length != params.length
-            raise(ClientError, "API declares #{public_name(method_name)} to accept " +
-                               "#{expects_length} parameters, but #{params.length} parameters " + 
-                               "were supplied")
+          method = @api.api_methods[method_name.to_sym]
+          if method.expects && method.expects.length != args.length
+            raise(ArgumentError, "#{method.public_name}: wrong number of arguments (#{args.length} for #{method.expects.length})")
           end
-          params = params.dup
-          if expects_length > 0
-            i = 0
-            expects.each do |spec|
-              type_binding = @marshaler.register_type(spec)
-              info = WS::ParamInfo.create(spec, type_binding, i)
-              params[i] = @marshaler.marshal(WS::Param.new(params[i], info))
-              i += 1
-            end
+          args = method.cast_expects(args.dup) rescue args
+          if method.expects
+            method.expects.each_with_index{ |type, i| args[i] = @protocol.value_to_xmlrpc_wire_format(args[i], type) }
           end
-          params
-        end
-
-        def transform_return_value(method_name, return_value)
-          info = @api.api_methods[method_name.to_sym]
-          return true unless returns = info[:returns]
-          type_binding = @marshaler.register_type(returns[0])
-          info = WS::ParamInfo.create(returns[0], type_binding, 0)
-          info.name = 'return'
-          @marshaler.transform_inbound(WS::Param.new(return_value, info))
+          ok, return_value = @client.call2(public_name(method_name), *args)
+          return (method.cast_returns(return_value.dup) rescue return_value) if ok
+          raise(ClientError, "#{return_value.faultCode}: #{return_value.faultString}")
         end
 
         def public_name(method_name)

data/lib/action_web_service/container/delegated_container.rb

@@ -79,7 +79,7 @@ module ActionWebService # :nodoc:
             raise(ContainerError, "no such web service '#{web_service_name}'")
           end
           service = info[:block]
-          service ? instance_eval(&service) : info[:object]
+          service ? self.instance_eval(&service) : info[:object]
         end
       end
     end

data/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)
@@ -34,30 +26,24 @@ module ActionWebService # :nodoc:
       
         def web_service_direct_invoke(invocation)
           @method_params = invocation.method_ordered_params
-          arity = method(invocation.api_method_name).arity rescue 0
+          arity = method(invocation.api_method.name).arity rescue 0
           if arity < 0 || arity > 0
-            return_value = self.__send__(invocation.api_method_name, *@method_params)
+            return_value = self.__send__(invocation.api_method.name, *@method_params)
           else
-            return_value = self.__send__(invocation.api_method_name)
+            return_value = self.__send__(invocation.api_method.name)
           end
-          if invocation.api.has_api_method?(invocation.api_method_name)
-            returns = invocation.returns ? invocation.returns[0] : nil
-          else
-            returns = return_value.class
-          end
-          invocation.protocol.marshal_response(invocation.public_method_name, return_value, returns)
+          web_service_create_response(invocation.protocol, invocation.api, invocation.api_method, return_value)
         end
 
         def web_service_delegated_invoke(invocation)
           cancellation_reason = nil
-          return_value = invocation.service.perform_invocation(invocation.api_method_name, invocation.method_ordered_params) do |x|
+          return_value = invocation.service.perform_invocation(invocation.api_method.name, invocation.method_ordered_params) do |x|
             cancellation_reason = x
           end
           if cancellation_reason
             raise(DispatcherError, "request canceled: #{cancellation_reason}")
           end
-          returns = invocation.returns ? invocation.returns[0] : nil
-          invocation.protocol.marshal_response(invocation.public_method_name, return_value, returns)
+          web_service_create_response(invocation.protocol, invocation.api, invocation.api_method, return_value)
         end
 
         def web_service_invocation(request)
@@ -66,86 +52,80 @@ module ActionWebService # :nodoc:
           invocation.protocol = request.protocol
           invocation.service_name = request.service_name
           if web_service_dispatching_mode == :layered
-            if request.method_name =~ /^([^\.]+)\.(.*)$/
-              public_method_name = $2
-              invocation.service_name = $1
+            case invocation.protocol
+            when Protocol::Soap::SoapProtocol
+              soap_action = request.protocol_options[:soap_action]
+              if soap_action && soap_action =~ /^\/\w+\/(\w+)\//
+                invocation.service_name = $1
+              end
+            when Protocol::XmlRpc::XmlRpcProtocol
+              if request.method_name =~ /^([^\.]+)\.(.*)$/
+                public_method_name = $2
+                invocation.service_name = $1
+              end
             end
           end
-          invocation.public_method_name = public_method_name
           case web_service_dispatching_mode
           when :direct
             invocation.api = self.class.web_service_api
             invocation.service = self
           when :delegated, :layered
-            invocation.service = web_service_object(invocation.service_name) rescue nil
-            unless invocation.service
-              raise(DispatcherError, "service #{invocation.service_name} not available")
-            end
+            invocation.service = web_service_object(invocation.service_name)
             invocation.api = invocation.service.class.web_service_api
           end
+          if invocation.api.nil?
+            raise(DispatcherError, "no API attached to #{invocation.service.class}")
+          end
+          invocation.protocol.register_api(invocation.api)
+          request.api = invocation.api
           if invocation.api.has_public_api_method?(public_method_name)
-            invocation.api_method_name = invocation.api.api_method_name(public_method_name)
+            invocation.api_method = invocation.api.public_api_method_instance(public_method_name)
           else
             if invocation.api.default_api_method.nil?
               raise(DispatcherError, "no such method '#{public_method_name}' on API #{invocation.api}")
             else
-              invocation.api_method_name = invocation.api.default_api_method.to_s.to_sym
+              invocation.api_method = invocation.api.default_api_method_instance
             end
           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})")
+          if invocation.service.nil?
+            raise(DispatcherError, "no service available for service name #{invocation.service_name}")
           end
-          info = invocation.api.api_methods[invocation.api_method_name]
-          invocation.expects = info ? info[:expects] : nil
-          invocation.returns = info ? info[:returns] : nil
-          if invocation.expects
-            i = 0
-            invocation.method_ordered_params = request.method_params.map do |param|
-              if invocation.protocol.is_a?(Protocol::XmlRpc::XmlRpcProtocol)
-                marshaler = invocation.protocol.marshaler
-                decoded_param = WS::Encoding::XmlRpcDecodedParam.new(param.info.name, param.value)
-                marshaled_param = marshaler.typed_unmarshal(decoded_param, invocation.expects[i]) rescue nil
-                param = marshaled_param ? marshaled_param : param
-              end
-              i += 1
-              param.value
-            end
-            i = 0
-            params = []
-            invocation.expects.each do |spec|
-              type_binding = invocation.protocol.register_signature_type(spec)
-              info = WS::ParamInfo.create(spec, type_binding, i)
-              params << WS::Param.new(invocation.method_ordered_params[i], info)
-              i += 1
-            end
-            invocation.method_ws_params = params
-            invocation.method_named_params = {}
-            invocation.method_ws_params.each do |param|
-              invocation.method_named_params[param.info.name] = param.value
-            end
-          else
-            invocation.method_ordered_params = []
-            invocation.method_named_params = {}
+          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})")
           end
-          if invocation.returns
-            invocation.returns.each do |spec|
-              invocation.protocol.register_signature_type(spec)
-            end
+          request.api_method = invocation.api_method
+          begin
+            invocation.method_ordered_params = invocation.api_method.cast_expects(request.method_params.dup)
+          rescue
+            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]
+            m + 1
           end
           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
           attr_accessor :api
-          attr_accessor :public_method_name
-          attr_accessor :api_method_name
+          attr_accessor :api_method
           attr_accessor :method_ordered_params
           attr_accessor :method_named_params
-          attr_accessor :method_ws_params
-          attr_accessor :expects
-          attr_accessor :returns
           attr_accessor :service
         end
     end

data/lib/action_web_service/dispatcher/action_controller_dispatcher.rb

@@ -38,9 +38,13 @@ module ActionWebService # :nodoc:
       module InstanceMethods # :nodoc:
         private
           def dispatch_web_service_request
-            request = discover_web_service_request(@request)
+            exception = nil
+            begin
+              request = discover_web_service_request(@request)
+            rescue Exception => e
+              exception = e
+            end
             if request
-              log_request(request, @request.raw_post)
               response = nil
               exception = nil
               bm = Benchmark.measure do
@@ -50,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)
@@ -57,7 +62,8 @@ module ActionWebService # :nodoc:
                 send_web_service_response(response, bm.real)
               end
             else
-              exception = DispatcherError.new("Malformed SOAP or XML-RPC protocol message")
+              exception ||= DispatcherError.new("Malformed SOAP or XML-RPC protocol message")
+              log_error(exception) unless logger.nil?
               send_web_service_error_response(request, exception)
             end
           rescue Exception => e
@@ -76,15 +82,20 @@ module ActionWebService # :nodoc:
               unless self.class.web_service_exception_reporting
                 exception = DispatcherError.new("Internal server error (exception raised)")
               end
-              response = request.protocol.marshal_response(request.method_name, exception, exception.class)
+              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
                 message = exception.message
+                backtrace = "\nBacktrace:\n#{exception.backtrace.join("\n")}"
               else
                 message = "Exception raised"
+                backtrace = ""
               end
-              render_text("Internal protocol error: #{message}", "500 #{message}")
+              render_text("Internal protocol error: #{message}#{backtrace}", "500 Internal Protocol Error")
             end
           end
 
@@ -95,7 +106,7 @@ module ActionWebService # :nodoc:
             end
             @session ||= {}
             @assigns ||= {}
-            @params['action'] = invocation.api_method_name.to_s
+            @params['action'] = invocation.api_method.name.to_s
             if before_action == false
               raise(DispatcherError, "Method filtered")
             end
@@ -107,7 +118,13 @@ 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
+                params = api_method.expects.zip(params).map{ |type, param| "#{type.name}=>#{param.inspect}" }
+              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))
@@ -116,7 +133,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
@@ -160,14 +178,14 @@ 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
               api = self.class.web_service_api
               web_service_name = controller_class_name.sub(/Controller$/, '').underscore
               apis[web_service_name] = [api, register_api(api, marshaler)]
-            when :delegated
+            when :delegated, :layered
               self.class.web_services.each do |web_service_name, info|
                 service = web_service_object(web_service_name)
                 api = service.class.web_service_api
@@ -197,7 +215,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
@@ -206,11 +224,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
@@ -224,34 +242,26 @@ module ActionWebService # :nodoc:
               # APIs
               apis.each do |api_name, values|
                 api = values[0]
-                api.api_methods.each do |name, info|
+                api.api_methods.each do |name, method|
                   gen = lambda do |msg_name, direction|
-                    xm.message('name' => msg_name) do
+                    xm.message('name' => message_name_for(api_name, msg_name)) do
                       sym = nil
                       if direction == :out
-                        returns = info[:returns]
+                        returns = method.returns
                         if returns
                           binding = marshaler.register_type(returns[0])
                           xm.part('name' => 'return', 'type' => binding.qualified_type_name('typens'))
                         end
                       else
-                        expects = info[:expects]
-                        i = 1
+                        expects = method.expects
                         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'))
-                          i += 1
+                          xm.part('name' => type.name, 'type' => binding.qualified_type_name('typens'))
                         end if expects
                       end
                     end
                   end
-                  public_name = api.public_api_method_name(name)
+                  public_name = method.public_name
                   gen.call(public_name, :in)
                   gen.call("#{public_name}Response", :out)
                 end
@@ -259,11 +269,10 @@ module ActionWebService # :nodoc:
                 # Port
                 port_name = port_name_for(global_service_name, api_name)
                 xm.portType('name' => port_name) do
-                  api.api_methods.each do |name, info|
-                    public_name = api.public_api_method_name(name)
-                    xm.operation('name' => public_name) do
-                      xm.input('message' => "typens:#{public_name}")
-                      xm.output('message' => "typens:#{public_name}Response")
+                  api.api_methods.each do |name, method|
+                    xm.operation('name' => method.public_name) do
+                      xm.input('message' => "typens:" + message_name_for(api_name, method.public_name))
+                      xm.output('message' => "typens:" + message_name_for(api_name, "#{method.public_name}Response"))
                     end
                   end
                 end
@@ -272,16 +281,15 @@ module ActionWebService # :nodoc:
                 binding_name = binding_name_for(global_service_name, api_name)
                 xm.binding('name' => binding_name, 'type' => "typens:#{port_name}") do
                   xm.soap(:binding, 'style' => 'rpc', 'transport' => SoapHttpTransport)
-                  api.api_methods.each do |name, info|
-                    public_name = api.public_api_method_name(name)
-                    xm.operation('name' => public_name) do
+                  api.api_methods.each do |name, method|
+                    xm.operation('name' => method.public_name) do
                       case web_service_dispatching_mode
-                      when :direct, :layered
-                        soap_action = soap_action_base + "/api/" + public_name
-                      when :delegated
+                      when :direct
+                        soap_action = soap_action_base + "/api/" + method.public_name
+                      when :delegated, :layered
                         soap_action = soap_action_base \
                                     + "/" + api_name.to_s \
-                                    + "/" + public_name
+                                    + "/" + method.public_name
                       end
                       xm.soap(:operation, 'soapAction' => soap_action)
                       xm.input do
@@ -307,7 +315,7 @@ module ActionWebService # :nodoc:
                   port_name = port_name_for(global_service_name, api_name)
                   binding_name = binding_name_for(global_service_name,  api_name)
                   case web_service_dispatching_mode
-                  when :direct
+                  when :direct, :layered
                     binding_target = 'api'
                   when :delegated
                     binding_target = api_name.to_s
@@ -328,32 +336,40 @@ module ActionWebService # :nodoc:
             "#{global_service}#{service.to_s.camelize}Binding"
           end
 
+          def message_name_for(api_name, message_name)
+            mode = web_service_dispatching_mode
+            if mode == :layered || mode == :delegated
+              api_name.to_s + '-' + message_name
+            else
+              message_name
+            end
+          end
+
           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
 
           def traverse_custom_types(api, marshaler, &block)
-            api.api_methods.each do |name, info|
-              expects, returns = info[:expects], info[: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
+            api.api_methods.each do |name, method|
+              expects, returns = method.expects, method.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