merged the changes for the upcoming 0.6.0:

seperate out protocol marshaling into a small 'ws' library in vendor, so that
AWS itself only does integration with ActionPack, and so we can keep protocol
specific code in AWS proper to a minimum. refactor unit tests to get 95%
code coverage (for a baseline).

be far more relaxed about the types given to us by the remote side, don't do
any poor man's type checking, just try to cast and marshal to the correct types if
possible, and if not, return what they gave us anyway. this should make interoperating
with fuzzy XML-RPC clients easier.

if exception reporting is turned on, do best-effort error responses, so that
we can avoid "Internal protocol error" with no details if there is a bug in
AWS itself.

also perform extensive cleanups on AWS proper.


git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@800 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

1 files changed, 35 insertions, 461 deletions

diff --git a/actionwebservice/lib/action_web_service/protocol/soap_protocol.rb b/actionwebservice/lib/action_web_service/protocol/soap_protocol.rb
index 3c527fea93..f2e761f431 100644
--- a/actionwebservice/lib/action_web_service/protocol/soap_protocol.rb
+++ b/actionwebservice/lib/action_web_service/protocol/soap_protocol.rb
@@ -1,127 +1,49 @@
-require 'soap/processor'
-require 'soap/mapping'
-require 'soap/rpc/element'
-require 'xsd/datatypes'
-require 'xsd/ns'
-require 'singleton'
-
-module ActionWebService # :nodoc:
-  module Protocol # :nodoc:
-    module Soap # :nodoc:
-      class ProtocolError < ActionWebService::ActionWebServiceError # :nodoc:
-      end
-
-      def self.append_features(base) # :nodoc:
-        super
-        base.register_protocol(HeaderAndBody, SoapProtocol)
-        base.extend(ClassMethods)
-        base.wsdl_service_name('ActionWebService')
-      end
-
-      module ClassMethods
-        # Specifies the WSDL service name to use when generating WSDL. Highly
-        # recommended that you set this value, or code generators may generate
-        # classes with very generic names.
-        #
-        # === Example
-        #   class MyController < ActionController::Base
-        #     wsdl_service_name 'MyService'
-        #   end
-        def wsdl_service_name(name)
-          write_inheritable_attribute("soap_mapper", SoapMapper.new("urn:#{name}"))
-        end
-
-        def soap_mapper # :nodoc:
-          read_inheritable_attribute("soap_mapper")
-        end
+module ActionWebService
+  module Protocol
+    module Soap
+      def self.included(base)
+        base.register_protocol(SoapProtocol)
+        base.class_inheritable_option(:wsdl_service_name)
       end
-
-      class SoapProtocol < AbstractProtocol # :nodoc:
-        attr :mapper
-
-        def initialize(mapper)
-          @mapper = mapper
-        end
-
-        def self.create_protocol_request(container_class, action_pack_request)
-          soap_action = extract_soap_action(action_pack_request)
-          return nil unless soap_action
-          service_name = action_pack_request.parameters['action']
-          public_method_name = soap_action.gsub(/^[\/]+/, '').split(/[\/]+/)[-1]
-          content_type = action_pack_request.env['HTTP_CONTENT_TYPE']
-          content_type ||= 'text/xml'
-          protocol = SoapProtocol.new(container_class.soap_mapper)
-          ProtocolRequest.new(protocol,
-                              action_pack_request.raw_post,
-                              service_name.to_sym,
-                              public_method_name,
-                              content_type)
-        end
-
-        def self.create_protocol_client(api, protocol_name, endpoint_uri, options)
-          return nil unless protocol_name.to_s.downcase.to_sym == :soap
-          ActionWebService::Client::Soap.new(api, endpoint_uri, options)
-        end
-
-        def unmarshal_request(protocol_request)
-          unmarshal = lambda do
-            envelope = SOAP::Processor.unmarshal(protocol_request.raw_body)
-            request = envelope.body.request
-            values = request.collect{|k, v| request[k]}
-            soap_to_ruby_array(values)
-          end
-          signature = protocol_request.signature
-          if signature
-            map_signature_types(signature)
-            values = unmarshal.call
-            signature = signature.map{|x|mapper.lookup(x).ruby_klass}
-            protocol_request.check_parameter_types(values, signature)
-            values
+      
+      class SoapProtocol
+        def initialize
+          @encoder = WS::Encoding::SoapRpcEncoding.new
+          @marshaler = WS::Marshaling::SoapMarshaler.new
+        end
+
+        def unmarshal_request(ap_request)
+          return nil unless has_valid_soap_action?(ap_request)
+          method_name, params = @encoder.decode_rpc_call(ap_request.raw_post)
+          params = params.map{|x| @marshaler.unmarshal(x)}
+          service_name = ap_request.parameters['action']
+          Request.new(self, method_name, params, service_name)
+        end
+
+        def marshal_response(method_name, return_value, signature_type)
+          if !return_value.nil? && signature_type
+            type_binding = @marshaler.register_type(signature_type)
+            info = WS::ParamInfo.create(signature_type, 0, type_binding)
+            return_value = @marshaler.marshal(WS::Param.new(return_value, info))
           else
-            if protocol_request.checked?
-              []
-            else
-              unmarshal.call
-            end
+            return_value = nil
           end
+          body = @encoder.encode_rpc_response(method_name, return_value)
+          Response.new(body, 'text/xml')
         end
 
-        def marshal_response(protocol_request, return_value)
-          marshal = lambda do |signature|
-            mapping = mapper.lookup(signature[0])
-            return_value = fixup_array_types(mapping, return_value)
-            signature = signature.map{|x|mapper.lookup(x).ruby_klass}
-            protocol_request.check_parameter_types([return_value], signature)
-            param_def = [['retval', 'return', mapping.registry_mapping]]
-            [param_def, ruby_to_soap(return_value)]
-          end
-          signature = protocol_request.return_signature
-          param_def = nil
-          if signature
-            param_def, return_value = marshal.call(signature)
-          else
-            if protocol_request.checked?
-              param_def, return_value = nil, nil
-            else
-              param_def, return_value = marshal.call([return_value.class])
-            end
-          end
-          qname = XSD::QName.new(mapper.custom_namespace,
-                                 protocol_request.public_method_name)
-          response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
-          response.retval = return_value unless return_value.nil?
-          ProtocolResponse.new(self, create_response(response), 'text/xml')
+        def register_signature_type(spec)
+          @marshaler.register_type(spec)
         end
 
-        def marshal_exception(exc)
-          ProtocolResponse.new(self, create_exception_response(exc), 'text/xml')
+        def protocol_client(api, protocol_name, endpoint_uri, options)
+          return nil unless protocol_name == :soap
+          ActionWebService::Client::Soap.new(api, endpoint_uri, options)
         end
 
         private
-          def self.extract_soap_action(request)
+          def has_valid_soap_action?(request)
             return nil unless request.method == :post
-            content_type = request.env['HTTP_CONTENT_TYPE'] || 'text/xml'
-            return nil unless content_type
             soap_action = request.env['HTTP_SOAPACTION']
             return nil unless soap_action
             soap_action.gsub!(/^"/, '')
@@ -130,355 +52,7 @@ module ActionWebService # :nodoc:
             return nil if soap_action.empty?
             soap_action
           end
-
-          def fixup_array_types(mapping, obj)
-            mapping.each_attribute do |name, type, attr_mapping|
-              if attr_mapping.custom_type?
-                attr_obj = obj.send(name)
-                new_obj = fixup_array_types(attr_mapping, attr_obj)
-                obj.send("#{name}=", new_obj) unless new_obj.equal?(attr_obj)
-              end
-            end
-            if mapping.is_a?(SoapArrayMapping)
-              obj = mapping.ruby_klass.new(obj)
-              # man, this is going to be slow for big arrays :(
-              (1..obj.size).each do |i|
-                i -= 1
-                obj[i] = fixup_array_types(mapping.element_mapping, obj[i])
-              end
-            else
-              if !mapping.generated_klass.nil? && mapping.generated_klass.respond_to?(:members)
-                # have to map the publically visible structure of the class
-                new_obj = mapping.generated_klass.new
-                mapping.generated_klass.members.each do |name, klass|
-                  new_obj.send("#{name}=", obj.send(name))
-                end
-                obj = new_obj
-              end
-            end
-            obj
-          end
-
-          def map_signature_types(types)
-            types.collect{|type| mapper.map(type)}
-          end
-
-          def create_response(body)
-            header = SOAP::SOAPHeader.new
-            body = SOAP::SOAPBody.new(body)
-            envelope = SOAP::SOAPEnvelope.new(header, body)
-            SOAP::Processor.marshal(envelope)
-          end
-  
-          def create_exception_response(exc)
-            detail = SOAP::Mapping::SOAPException.new(exc)
-            body = SOAP::SOAPFault.new(
-              SOAP::SOAPString.new('Server'),
-              SOAP::SOAPString.new(exc.to_s),
-              SOAP::SOAPString.new(self.class.name),
-              SOAP::Mapping.obj2soap(detail))
-            create_response(body)
-          end
-
-          def ruby_to_soap(obj)
-            SOAP::Mapping.obj2soap(obj, mapper.registry)
-          end
-
-          def soap_to_ruby(obj)
-            SOAP::Mapping.soap2obj(obj, mapper.registry)
-          end
-
-          def soap_to_ruby_array(array)
-            array.map{|x| soap_to_ruby(x)}
-          end
-      end
-
-      class SoapMapper # :nodoc:
-        attr :registry
-        attr :custom_namespace
-        attr :custom_types
-
-        def initialize(custom_namespace)
-          @custom_namespace = custom_namespace
-          @registry = SOAP::Mapping::Registry.new
-          @klass2map = {}
-          @custom_types = {}
-          @ar2klass = {}
         end
-
-        def lookup(klass)
-          lookup_klass = klass.is_a?(Array) ? klass[0] : klass
-          generated_klass = nil
-          unless lookup_klass.respond_to?(:ancestors)
-            raise(ProtocolError, "expected parameter type definition to be a Class")
-          end
-          if lookup_klass.ancestors.include?(ActiveRecord::Base)
-            generated_klass = @ar2klass.has_key?(klass) ? @ar2klass[klass] : nil
-            klass = generated_klass if generated_klass
-          end
-          return @klass2map[klass] if @klass2map.has_key?(klass)
-  
-          custom_type = false
-  
-          ruby_klass = select_class(lookup_klass)
-          generated_klass = @ar2klass[lookup_klass] if @ar2klass.has_key?(lookup_klass)
-          type_name = ruby_klass.name
-  
-          # Array signatures generate a double-mapping and require generation
-          # of an Array subclass to represent the mapping in the SOAP
-          # registry
-          array_klass = nil
-          if klass.is_a?(Array)
-            array_klass = Class.new(Array) do
-              module_eval <<-END
-              def self.name
-                "#{type_name}Array"
-              end
-              END
-            end
-          end
-  
-          mapping = @registry.find_mapped_soap_class(ruby_klass) rescue nil
-          unless mapping
-            # Custom structured type, generate a mapping
-            info = { :type => XSD::QName.new(@custom_namespace, type_name) }
-            @registry.add(ruby_klass,
-                          SOAP::SOAPStruct, 
-                          SOAP::Mapping::Registry::TypedStructFactory,
-                          info)
-            mapping = ensure_mapped(ruby_klass)
-            custom_type = true
-          end
-  
-          array_mapping = nil
-          if array_klass
-            # Typed array always requires a custom type. The info of the array
-            # is the info of its element type (in mapping[2]), falling back
-            # to SOAP base types.
-            info = mapping[2]
-            info ||= {}
-            info[:type] ||= soap_base_type_qname(mapping[0])
-            @registry.add(array_klass,
-                          SOAP::SOAPArray,
-                          SOAP::Mapping::Registry::TypedArrayFactory,
-                          info)
-            array_mapping = ensure_mapped(array_klass)
-          end
-  
-          if array_mapping
-            @klass2map[ruby_klass] = SoapMapping.new(self,
-                                                     type_name,
-                                                     ruby_klass,
-                                                     generated_klass,
-                                                     mapping[0],
-                                                     mapping,
-                                                     custom_type)
-            @klass2map[klass] = SoapArrayMapping.new(self,
-                                                     type_name,
-                                                     array_klass,
-                                                     array_mapping[0],
-                                                     array_mapping,
-                                                     @klass2map[ruby_klass])
-            @custom_types[klass] = @klass2map[klass]
-            @custom_types[ruby_klass] = @klass2map[ruby_klass] if custom_type
-          else
-            @klass2map[klass] = SoapMapping.new(self,
-                                                type_name,
-                                                ruby_klass,
-                                                generated_klass,
-                                                mapping[0],
-                                                mapping,
-                                                custom_type)
-            @custom_types[klass] = @klass2map[klass] if custom_type
-          end
-  
-          @klass2map[klass]
-        end
-        alias :map :lookup
-        
-        def map_container_services(container, &block)
-          dispatching_mode = container.web_service_dispatching_mode
-          web_services = nil
-          case dispatching_mode
-          when :direct
-            api = container.class.web_service_api
-            if container.respond_to?(:controller_class_name)
-              web_service_name = container.controller_class_name.sub(/Controller$/, '').underscore
-            else
-              web_service_name = container.class.name.demodulize.underscore
-            end
-            web_services = { web_service_name => api }
-          when :delegated
-            web_services = {}
-            container.class.web_services.each do |web_service_name, web_service_info|
-              begin
-                object = container.web_service_object(web_service_name)
-              rescue Exception => e
-                raise(ProtocolError, "failed to retrieve web service object for web service '#{web_service_name}': #{e.message}")
-              end
-              web_services[web_service_name] = object.class.web_service_api
-            end
-          end
-          web_services.each do |web_service_name, api|
-            if api.nil?
-              raise(ProtocolError, "no web service API set while in :#{dispatching_mode} mode")
-            end
-            map_api(api) do |api_methods|
-              yield web_service_name, api, api_methods if block_given?
-            end
-          end
-        end
-
-        def map_api(api, &block)
-          lookup_proc = lambda do |klass|
-            mapping = lookup(klass)
-            custom_mapping = nil
-            if mapping.respond_to?(:element_mapping)
-              custom_mapping = mapping.element_mapping
-            else
-              custom_mapping = mapping
-            end
-            if custom_mapping && custom_mapping.custom_type?
-              # What gives? This is required so that structure types
-              # referenced only by structures (and not signatures) still
-              # have a custom type mapping in the registry (needed for WSDL
-              # generation).
-              custom_mapping.each_attribute{}
-            end
-            mapping 
-          end
-          api_methods = block.nil?? nil : {}
-          api.api_methods.each do |method_name, method_info|
-            expects = method_info[:expects]
-            expects_signature = nil
-            if expects
-              expects_signature = block ? [] : nil
-              expects.each do |klass|
-                lookup_klass = nil
-                if klass.is_a?(Hash)
-                  lookup_klass = lookup_proc.call(klass.values[0])
-                  expects_signature << {klass.keys[0]=>lookup_klass} if block
-                else
-                  lookup_klass = lookup_proc.call(klass)
-                  expects_signature << lookup_klass if block
-                end
-              end
-            end
-            returns = method_info[:returns]
-            returns_signature = returns ? returns.map{|klass| lookup_proc.call(klass)} : nil
-            if block
-              api_methods[method_name] = {
-                :expects => expects_signature,
-                :returns => returns_signature
-              }
-            end
-          end
-          yield api_methods if block
-        end
-
-        private
-          def select_class(klass)
-            return Integer if klass == Fixnum
-            if klass.ancestors.include?(ActiveRecord::Base)
-              new_klass = Class.new(ActionWebService::Struct)
-              new_klass.class_eval <<-EOS
-                def self.name
-                  "#{klass.name}"
-                end
-              EOS
-              klass.columns.each do |column|
-                next if column.klass.nil?
-                new_klass.send(:member, column.name.to_sym, column.klass)
-              end
-              @ar2klass[klass] = new_klass
-              return new_klass
-            end
-            klass
-          end
-
-          def ensure_mapped(klass)
-            mapping = @registry.find_mapped_soap_class(klass) rescue nil
-            raise(ProtocolError, "failed to register #{klass.name}") unless mapping
-            mapping
-          end
-
-          def soap_base_type_qname(base_type)
-            xsd_type = base_type.ancestors.find{|c| c.const_defined? 'Type'}
-            xsd_type ? xsd_type.const_get('Type') : XSD::XSDAnySimpleType::Type
-          end
-      end
-
-      class SoapMapping # :nodoc:
-        attr :ruby_klass
-        attr :generated_klass
-        attr :soap_klass
-        attr :registry_mapping
-  
-        def initialize(mapper, type_name, ruby_klass, generated_klass, soap_klass, registry_mapping,
-                       custom_type=false)
-          @mapper = mapper
-          @type_name = type_name
-          @ruby_klass = ruby_klass
-          @generated_klass = generated_klass
-          @soap_klass = soap_klass
-          @registry_mapping = registry_mapping
-          @custom_type = custom_type
-        end
-  
-        def type_name
-          @type_name
-        end
-  
-        def custom_type?
-          @custom_type
-        end
-  
-        def qualified_type_name
-          name = type_name
-          if custom_type?
-            "typens:#{name}"
-          else
-            xsd_type_for(@soap_klass)
-          end
-        end
-  
-        def each_attribute(&block)
-          if @ruby_klass.respond_to?(:members)
-            @ruby_klass.members.each do |name, klass|
-              name = name.to_s
-              mapping = @mapper.lookup(klass)
-              yield name, mapping.qualified_type_name, mapping
-            end
-          end
-        end
-
-        def is_xsd_type?(klass)
-          klass.ancestors.include?(XSD::NSDBase)
-        end
-  
-        def xsd_type_for(klass)
-          ns = XSD::NS.new
-          ns.assign(XSD::Namespace, SOAP::XSDNamespaceTag)
-          xsd_klass = klass.ancestors.find{|c| c.const_defined?('Type')}
-          return ns.name(XSD::AnyTypeName) unless xsd_klass
-          ns.name(xsd_klass.const_get('Type'))
-        end
-      end
-  
-      class SoapArrayMapping < SoapMapping # :nodoc:
-        attr :element_mapping
-  
-        def initialize(mapper, type_name, ruby_klass, soap_klass, registry_mapping, element_mapping)
-          super(mapper, type_name, ruby_klass, nil, soap_klass, registry_mapping, true)
-          @element_mapping = element_mapping
-        end
-  
-        def type_name
-          super + "Array"
-        end
-
-        def each_attribute(&block); end
-      end
     end
   end
 end