actionservice 0.2.100 → 0.2.102

data/lib/action_service/protocol/xmlrpc.rb

@@ -1,5 +1,6 @@
 require 'xmlrpc/parser'
 require 'xmlrpc/utils'
+require 'singleton'
 
 module ActionService
   module Protocol
@@ -10,86 +11,115 @@ module ActionService
       end
 
       class XmlRpcProtocol < AbstractProtocol
-        include XMLRPC::ParserWriterChooseMixin
+        private
+          class Helper
+            include Singleton
+            include XMLRPC::ParserWriterChooseMixin
+
+            def get_parser
+              parser()
+            end
+
+            def get_create
+              create()
+            end
+          end
+
+        public
 
-        def initialize(container_klass)
-          @container_klass = container_klass
-          @container_klass.write_inheritable_hash('default_system_exports', XmlRpcProtocol => method(:xmlrpc_default_system_handler))
+        def self.create_protocol_request(container_class, action_pack_request)
+          parser = Helper.instance.get_parser
+          service_name = action_pack_request.parameters['action']
+          methodname, params = parser.parseMethodCall(action_pack_request.raw_post)
+          protocol = XmlRpcProtocol.new(container_class)
+          content_type = action_pack_request.env['HTTP_CONTENT_TYPE']
+          content_type ||= 'text/xml'
+          request = ProtocolRequest.new(protocol,
+                                        action_pack_request.raw_post,
+                                        service_name.to_sym,
+                                        methodname,
+                                        content_type)
+          request.values = params
+          request
+        rescue
+          nil
         end
 
-        def unmarshal_request(request_info, export_info, strict=true)
-          expects = export_info[:expects]
-          params = request_info.protocol_info[:xmlrpc][:params]
-          if expects
-            expects = array_types(expects)
-            validate_types(request_info.public_method_name, expects, params, :in)
-            params
+        def initialize(container_class)
+          super(container_class)
+          container_class.write_inheritable_hash('default_system_exports', XmlRpcProtocol => method(:xmlrpc_default_system_handler))
+        end
+
+        def unmarshal_request(protocol_request)
+          values = protocol_request.values
+          signature = protocol_request.signature
+          if signature
+            signature = array_types(signature)
+            protocol_request.check_parameter_types(values, signature)
+            values
           else
-            strict ? [] : params
+            protocol_request.checked? ? [] : values
           end
         end
   
-        def marshal_response(request_info, export_info, return_value, strict=true)
-          returns = export_info[:returns]
-          if returns
-            returns = array_types(returns)
-            validate_types(request_info.public_method_name, returns, [return_value], :out)
-            raw_response = create().methodResponse(true, return_value)
+        def marshal_response(protocol_request, return_value)
+          create = Helper.instance.get_create
+          signature = protocol_request.return_signature
+          if signature
+            signature = array_types(signature)
+            protocol_request.check_parameter_types([return_value], signature)
+            return_value = fixup_values_for_return(return_value)
+            raw_response = create.methodResponse(true, return_value)
           else
             # XML-RPC doesn't have the concept of a void method, nor does it
             # support a nil return value, so return true if we would have returned
             # nil
-            if strict
-              raw_response = create().methodResponse(true, true)
+            if protocol_request.checked?
+              raw_response = create.methodResponse(true, true)
             else
               return_value = true if return_value.nil?
-              raw_response = create().methodResponse(true, return_value)
+              raw_response = create.methodResponse(true, return_value)
             end
           end
-          ServiceResponseInfo.new(raw_response, 'text/xml')
+          ProtocolResponse.new(self, raw_response, 'text/xml')
         end
   
         def marshal_exception(exception)
-          raw_response = create().methodResponse(false, exception)
-          ServiceResponseInfo.new(raw_response, 'text/xml')
-        end
-  
-        def request_info
-          @request_info
+          create = Helper.instance.get_create
+          raw_response = create.methodResponse(false, exception)
+          ProtocolResponse.new(self, raw_response, 'text/xml')
         end
   
-        def request_supported?(request)
-          begin
-            service_name = request.parameters['action']
-            methodname, params = parser().parseMethodCall(request.raw_post)
-            @request_info = ServiceRequestInfo.new(service_name,
-              methodname,
-              request.raw_post,
-              request.env['HTTP_CONTENT_TYPE'] || 'text/xml',
-              :xmlrpc => { :params => params })
-            true
-          rescue
-            false
-          end
-        end
-
         private
-          def xmlrpc_default_system_handler(name, service_klass, *args)
+          def xmlrpc_default_system_handler(name, service_class, *args)
             case name
             when 'system.listMethods'
               methods = []
-              service_klass.exports.each do |name, info|
-                methods << service_klass.public_export_name(name)
+              service_class.exports.each do |name, info|
+                methods << service_class.public_export_name(name)
               end
               methods.sort
             else
-              raise SystemExportNotHandledError
+              throw :try_default_export
             end
           end
 
           def array_types(signature)
             signature.map{|x| x.is_a?(Array) ? Array : x}
           end
+
+          def fixup_values_for_return(return_value)
+            if return_value.is_a?(Array)
+              (1..return_value.size).each do |i|
+                return_value[i-1] = fixup_values_for_return(return_value[i-1])
+              end
+            else
+              if return_value.is_a?(ActiveRecord::Base)
+                return_value = return_value.instance_variable_get('@attributes')
+              end
+            end
+            return_value
+          end
       end
 
     end

data/lib/action_service/router/action_controller.rb

@@ -2,12 +2,23 @@ module ActionService
   module Router
     module ActionController
       def self.append_features(base)
+        base.add_export_definition_callback do |klass, export_name, export_info|
+          if klass.service_dispatching_mode == :direct && !klass.method_defined?(:api)
+            klass.class_eval <<-EOS
+              def api
+                process_action_service_request
+              end
+            EOS
+          end
+        end
         base.add_service_definition_callback do |klass, name, info|
-          klass.class_eval <<-EOF
-            def #{name}
-              process_action_service_request
-            end
-          EOF
+          if klass.service_dispatching_mode == :delegated
+            klass.class_eval <<-EOS
+              def #{name}
+                process_action_service_request
+              end
+            EOS
+          end
         end
         base.send(:include, ActionService::Router::ActionController::InstanceMethods)
       end
@@ -15,54 +26,55 @@ module ActionService
       module InstanceMethods
         private
           def process_action_service_request
-            protocol = nil
-            request_info = nil
+            protocol_request = nil
             begin
-              protocol = probe_request_protocol(self.request)
-              request_info = protocol.request_info
-              if request_info
-                log_request request_info
-                response_info = dispatch_service_invocation_request(protocol, request_info)
-                log_response response_info
+              protocol_request = probe_request_protocol(self.request)
+              if protocol_request
+                log_request(protocol_request)
+                protocol_response = dispatch_service_request(protocol_request)
+                log_response(protocol_request)
                 response_options = {
-                  :type        => response_info.content_type,
+                  :type        => protocol_response.content_type,
                   :disposition => 'inline'
                 }
-                send_data(response_info.raw_body, response_options)
+                send_data(protocol_response.raw_body, response_options)
               else
                 logger.fatal "Invalid Action Service service or method requested"
-                render_text '', "500 Invalid service/method"
+                render_text 'Internal protocol error', "500 Invalid service/method"
               end
             rescue Exception => e
               log_error e unless logger.nil?
-              service_object = service_object(request_info.service_name)
+              service_object = service_object(protocol_request.service_name) rescue nil
               exc_response = nil
-              if service_object.class.report_exceptions
-                exc_response_info = protocol.marshal_exception(e) rescue nil
+              if service_object && service_object.class.report_exceptions
+                exc_response = protocol_request.protocol.marshal_exception(e) rescue nil
               end
-              if exc_response_info
+              if exc_response
                 response_options = {
-                  :type        => exc_response_info.content_type,
+                  :type        => exc_response.content_type,
                   :disposition => 'inline'
                 }
-                send_data(exc_response_info.raw_body, response_options)
+                send_data(exc_response.raw_body, response_options)
               else
-                render_text '', "500 #{e.message}"
+                render_text 'Internal protocol error', "500 #{e.message}"
               end
             end
           end
 
-          def log_request(request_info)
+          def log_request(protocol_request)
             unless logger.nil?
-              logger.info "\nRaw Action Service Request:"
-              logger.info request_info.raw_body
+              service_name = protocol_request.service_name
+              method_name = protocol_request.public_method_name
+              logger.info "\nProcessing Action Service Request: #{service_name}##{method_name}"
+              logger.info "Raw Request Body:"
+              logger.info protocol_request.raw_body
             end
           end
 
-          def log_response(response_info)
+          def log_response(protocol_response)
             unless logger.nil?
-              logger.info "\nRaw Action Service Response:"
-              logger.info response_info.raw_body
+              logger.info "\nRaw Response Body:"
+              logger.info protocol_response.raw_body
             end
           end
       end

data/lib/action_service/router/wsdl.rb

@@ -2,155 +2,190 @@ module ActionService
   module Router
     module Wsdl
       def self.append_features(base)
-        base.extend(ClassMethods)
         base.send(:include, ActionService::Router::Wsdl::InstanceMethods)
       end
 
-      module ClassMethods
+      module InstanceMethods
         XsdNs             = 'http://www.w3.org/2001/XMLSchema'
         WsdlNs            = 'http://schemas.xmlsoap.org/wsdl/'
         SoapNs            = 'http://schemas.xmlsoap.org/wsdl/soap/'
         SoapEncodingNs    = 'http://schemas.xmlsoap.org/soap/encoding/'
         SoapHttpTransport = 'http://schemas.xmlsoap.org/soap/http'
 
-        def to_wsdl(container, uri, soap_action_base)
-          wsdl = ""
-
-          namespace = container.class.soap_mapper.custom_namespace
-          wsdl_service_name = namespace.split(/:/)[1]
-
-          mapper = ActionService::Protocol::Soap::SoapMapper.new(namespace)
-          services = {}
-          mapper.map_container_services(container) do |name, klass, exports|
-            services[name] = [klass, exports]
+        def wsdl
+          case @request.method
+          when :get
+            begin
+              host_name = @request.env['HTTP_HOST']||@request.env['SERVER_NAME']
+              uri = "http://#{host_name}/#{controller_name}/"
+              soap_action_base = "/#{controller_name}"
+              xml = to_wsdl(self, uri, soap_action_base)
+              send_data(xml, :type => 'text/xml', :disposition => 'inline')
+            rescue Exception => e
+              log_error e unless logger.nil?
+              render_text('', "500 #{e.message}")
+            end
+          when :post
+            render_text('', "500 POST not supported")
           end
-          custom_types = mapper.custom_types
-
-
-          xm = Builder::XmlMarkup.new(:target => wsdl, :indent => 2)
-          xm.instruct!
-
-          xm.definitions('name' => wsdl_service_name,
-                         'targetNamespace' => namespace,
-                         'xmlns:typens'    => namespace,
-                         'xmlns:xsd'       => XsdNs,
-                         'xmlns:soap'      => SoapNs,
-                         'xmlns:soapenc'   => SoapEncodingNs,
-                         'xmlns:wsdl'      => WsdlNs,
-                         'xmlns'           => WsdlNs) do
+        end
 
-            # Custom type XSD generation
-            if custom_types.size > 0
-              xm.types do
-                xm.xsd(:schema, 'xmlns' => XsdNs, 'targetNamespace' => namespace) do
-                  custom_types.each do |klass, mapping|
-                    case
-                    when mapping.is_a?(ActionService::Protocol::Soap::SoapArrayMapping)
-                      xm.xsd(:complexType, 'name' => mapping.type_name) do
-                        xm.xsd(:complexContent) do
-                          xm.xsd(:restriction, 'base' => 'soapenc:Array') do
-                            xm.xsd(:attribute, 'ref' => 'soapenc:arrayType',
-                                               'wsdl:arrayType' => mapping.element_mapping.qualified_type_name + '[]')
+        private
+          def to_wsdl(container, uri, soap_action_base)
+            wsdl = ""
+  
+            service_dispatching_mode = container.service_dispatching_mode
+            mapper = container.class.soap_mapper
+            namespace = mapper.custom_namespace
+            wsdl_service_name = namespace.split(/:/)[1]
+  
+            services = {}
+            mapper.map_container_services(container) do |name, klass, exports|
+              services[name] = [klass, exports]
+            end
+            custom_types = mapper.custom_types
+  
+  
+            xm = Builder::XmlMarkup.new(:target => wsdl, :indent => 2)
+            xm.instruct!
+  
+            xm.definitions('name' => wsdl_service_name,
+                           'targetNamespace' => namespace,
+                           'xmlns:typens'    => namespace,
+                           'xmlns:xsd'       => XsdNs,
+                           'xmlns:soap'      => SoapNs,
+                           'xmlns:soapenc'   => SoapEncodingNs,
+                           'xmlns:wsdl'      => WsdlNs,
+                           'xmlns'           => WsdlNs) do
+  
+              # Custom type XSD generation
+              if custom_types.size > 0
+                xm.types do
+                  xm.xsd(:schema, 'xmlns' => XsdNs, 'targetNamespace' => namespace) do
+                    custom_types.each do |klass, mapping|
+                      case
+                      when mapping.is_a?(ActionService::Protocol::Soap::SoapArrayMapping)
+                        xm.xsd(:complexType, 'name' => mapping.type_name) do
+                          xm.xsd(:complexContent) do
+                            xm.xsd(:restriction, 'base' => 'soapenc:Array') do
+                              xm.xsd(:attribute, 'ref' => 'soapenc:arrayType',
+                                                 'wsdl:arrayType' => mapping.element_mapping.qualified_type_name + '[]')
+                            end
                           end
                         end
-                      end
-                    when mapping.is_a?(ActionService::Protocol::Soap::SoapMapping)
-                      xm.xsd(:complexType, 'name' => mapping.type_name) do
-                        xm.xsd(:all) do
-                          mapping.each_attribute do |name, type_name|
-                            xm.xsd(:element, 'name' => name, 'type' => type_name)
+                      when mapping.is_a?(ActionService::Protocol::Soap::SoapMapping)
+                        xm.xsd(:complexType, 'name' => mapping.type_name) do
+                          xm.xsd(:all) do
+                            mapping.each_attribute do |name, type_name|
+                              xm.xsd(:element, 'name' => name, 'type' => type_name)
+                            end
                           end
                         end
+                      else
+                        raise(WsdlError, "unsupported mapping type #{mapping.class.name}")
                       end
-                    else
-                      raise(WsdlError, "unsupported mapping type #{mapping.class.name}")
                     end
                   end
                 end
               end
-            end
-
-            services.each do |service_name, service_values|
-              service_klass, service_exports = service_values
-              # Parameter list message definitions
-              service_exports.each do |export_name, export_signature|
-                gen = lambda do |msg_name, direction|
-                  xm.message('name' => msg_name) do
-                    sym = nil
-                    if direction == :out
-                      if export_signature[:returns]
-                        xm.part('name' => 'return', 'type' => export_signature[:returns][0].qualified_type_name)
+  
+              services.each do |service_name, service_values|
+                service_klass, service_exports = service_values
+                # Parameter list message definitions
+                service_exports.each do |export_name, export_signature|
+                  gen = lambda do |msg_name, direction|
+                    xm.message('name' => msg_name) do
+                      sym = nil
+                      if direction == :out
+                        if export_signature[:returns]
+                          xm.part('name' => 'return', 'type' => export_signature[:returns][0].qualified_type_name)
+                        end
+                      else
+                        mapping_list = export_signature[:expects]
+                        i = 1
+                        mapping_list.each do |mapping|
+                          if mapping.is_a?(Hash)
+                            param_name = mapping.keys.shift
+                            mapping = mapping.values.shift
+                          else
+                            param_name = "param#{i}"
+                          end
+                          xm.part('name' => param_name, 'type' => mapping.qualified_type_name)
+                          i += 1
+                        end if mapping_list
                       end
-                    else
-                      mapping_list = export_signature[:expects]
-                      i = 1
-                      mapping_list.each do |mapping|
-                        xm.part('name' => "param#{i}", 'type' => mapping.qualified_type_name)
-                        i += 1
-                      end if mapping_list
                     end
                   end
-                end
-                public_name = service_klass.public_export_name(export_name)
-                gen.call(public_name, :in)
-                gen.call("#{public_name}Response", :out)
-              end
-
-              # Declare the port
-              port_name = port_name_for(wsdl_service_name, service_name)
-              xm.portType('name' => port_name) do
-                service_exports.each do |export_name, export_signature|
                   public_name = service_klass.public_export_name(export_name)
-                  xm.operation('name' => public_name) do
-                    xm.input('message' => "typens:#{public_name}")
-                    xm.output('message' => "typens:#{public_name}Response")
-                  end
+                  gen.call(public_name, :in)
+                  gen.call("#{public_name}Response", :out)
                 end
-              end
-
-              # Bind the port to SOAP
-              binding_name = binding_name_for(wsdl_service_name, service_name)
-              xm.binding('name' => binding_name, 'type' => "typens:#{port_name}") do
-                xm.soap(:binding, 'style' => 'rpc', 'transport' => SoapHttpTransport)
-                service_exports.each do |export_name, export_signature|
-                  public_name = service_klass.public_export_name(export_name)
-                  xm.operation('name' => public_name) do
-                    soap_action = soap_action_base \
-                                + "/" + service_name.to_s \
-                                + "/" + public_name
-                    xm.soap(:operation, 'soapAction' => soap_action)
-                    xm.input do
-                      xm.soap(:body,
-                              'use'           => 'encoded',
-                              'namespace'     => namespace,
-                              'encodingStyle' => SoapEncodingNs)
+  
+                # Declare the port
+                port_name = port_name_for(wsdl_service_name, service_name)
+                xm.portType('name' => port_name) do
+                  service_exports.each do |export_name, export_signature|
+                    public_name = service_klass.public_export_name(export_name)
+                    xm.operation('name' => public_name) do
+                      xm.input('message' => "typens:#{public_name}")
+                      xm.output('message' => "typens:#{public_name}Response")
                     end
-                    xm.output do
-                      xm.soap(:body,
-                              'use'           => 'encoded',
-                              'namespace'     => namespace,
-                              'encodingStyle' => SoapEncodingNs)
+                  end
+                end
+  
+                # Bind the port to SOAP
+                binding_name = binding_name_for(wsdl_service_name, service_name)
+                xm.binding('name' => binding_name, 'type' => "typens:#{port_name}") do
+                  xm.soap(:binding, 'style' => 'rpc', 'transport' => SoapHttpTransport)
+                  service_exports.each do |export_name, export_signature|
+                    public_name = service_klass.public_export_name(export_name)
+                    xm.operation('name' => public_name) do
+                      case service_dispatching_mode
+                      when :direct
+                        soap_action = soap_action_base + "/api/" + public_name
+                      when :delegated
+                        soap_action = soap_action_base \
+                                    + "/" + service_name.to_s \
+                                    + "/" + public_name
+                      end
+                      xm.soap(:operation, 'soapAction' => soap_action)
+                      xm.input do
+                        xm.soap(:body,
+                                'use'           => 'encoded',
+                                'namespace'     => namespace,
+                                'encodingStyle' => SoapEncodingNs)
+                      end
+                      xm.output do
+                        xm.soap(:body,
+                                'use'           => 'encoded',
+                                'namespace'     => namespace,
+                                'encodingStyle' => SoapEncodingNs)
+                      end
                     end
                   end
                 end
               end
-            end
-
-            # Define the service
-            xm.service('name' => "#{wsdl_service_name}Service") do
-              services.each do |service_name, service_values|
-                service_klass, service_exports = service_values
-                port_name = port_name_for(wsdl_service_name, service_name)
-                binding_name = binding_name_for(wsdl_service_name,  service_name)
-                xm.port('name' => port_name, 'binding' => "typens:#{binding_name}") do
-                  xm.soap(:address, 'location' => "#{uri}#{service_name.to_s}")
+  
+              # Define the service
+              xm.service('name' => "#{wsdl_service_name}Service") do
+                services.each do |service_name, service_values|
+                  service_klass, service_exports = service_values
+                  port_name = port_name_for(wsdl_service_name, service_name)
+                  binding_name = binding_name_for(wsdl_service_name,  service_name)
+                  case service_dispatching_mode
+                  when :direct
+                    binding_target = 'api'
+                  when :delegated
+                    binding_target = service_name.to_s
+                  end
+                  xm.port('name' => port_name, 'binding' => "typens:#{binding_name}") do
+                    xm.soap(:address, 'location' => "#{uri}#{binding_target}")
+                  end
                 end
               end
             end
           end
-        end
 
-        private
           def port_name_for(wsdl_service_name, service_name)
             "#{wsdl_service_name}#{Inflector.camelize(service_name.to_s)}Port"
           end
@@ -159,24 +194,6 @@ module ActionService
             "#{wsdl_service_name}#{Inflector.camelize(service_name.to_s)}Binding"
           end
       end
-
-      module InstanceMethods
-        def wsdl
-          case @request.method
-          when :get
-            begin
-              uri = "http://#{@request.env['HTTP_HOST']||@request.env['SERVER_NAME']}/#{controller_name}/"
-              soap_action_base = "/#{controller_name}"
-              xml = self.class.to_wsdl(self, uri, soap_action_base)
-              send_data(xml, :type => 'text/xml', :disposition => 'inline')
-            rescue Exception => e
-              render_text('', "500 #{e.message}")
-            end
-          when :post
-            render_text('', "500 POST not supported")
-          end
-        end
-      end
     end
   end
 end

data/lib/action_service.rb

@@ -23,14 +23,17 @@
 
 begin
   require 'action_controller'
+  require 'active_record'
 rescue LoadError
   require 'rubygems'
   require_gem 'actionpack', '>= 1.4.0'
+  require_gem 'activerecord', '>= 1.6.0'
 end
 
 $:.unshift(File.dirname(__FILE__))
 
 require 'action_service/base'
+require 'action_service/exporting'
 require 'action_service/invocation'
 require 'action_service/struct'
 require 'action_service/container'
@@ -38,10 +41,12 @@ require 'action_service/protocol'
 require 'action_service/router'
 
 ActionService::Base.class_eval do
+  include ActionService::Exporting
   include ActionService::Invocation
 end
 
 ActionController::Base.class_eval do
+  include ActionService::Exporting
   include ActionService::Container
   include ActionService::Protocol::Registry
   include ActionService::Protocol::Soap