actionwebservice 0.5.0

data/lib/action_web_service/dispatcher/action_controller_dispatcher.rb

@@ -0,0 +1,299 @@
+module ActionWebService # :nodoc:
+  module Dispatcher # :nodoc:
+    module ActionController # :nodoc:
+      def self.append_features(base) # :nodoc:
+        super
+        base.class_eval do
+          class << self
+            alias_method :inherited_without_action_controller, :inherited
+          end
+          alias_method :before_direct_invoke_without_action_controller, :before_direct_invoke
+          alias_method :after_direct_invoke_without_action_controller, :after_direct_invoke
+        end
+        base.add_web_service_api_callback do |klass, api|
+          if klass.web_service_dispatching_mode == :direct
+            klass.class_eval <<-EOS
+              def api
+                controller_dispatch_web_service_request
+              end
+            EOS
+          end
+        end
+        base.add_web_service_definition_callback do |klass, name, info|
+          if klass.web_service_dispatching_mode == :delegated
+            klass.class_eval <<-EOS
+              def #{name}
+                controller_dispatch_web_service_request
+              end
+            EOS
+          end
+        end
+        base.extend(ClassMethods)
+        base.send(:include, ActionWebService::Dispatcher::ActionController::Invocation)
+      end
+
+      module ClassMethods # :nodoc:
+        def inherited(child)
+          inherited_without_action_controller(child)
+          child.send(:include, ActionWebService::Dispatcher::ActionController::WsdlGeneration)
+        end
+      end
+
+      module Invocation # :nodoc:
+        private
+          def controller_dispatch_web_service_request
+            request, response, elapsed, exception = dispatch_web_service_request(@request)
+            if response
+              begin
+                log_request(request)
+                log_error(exception) if exception && logger
+                log_response(response, elapsed)
+                response_options = { :type => response.content_type, :disposition => 'inline' }
+                send_data(response.raw_body, response_options)
+              rescue Exception => e
+                log_error(e) unless logger.nil?
+                render_text("Internal protocol error", "500 Internal Server Error")
+              end
+            else
+              logger.error("No response available") unless logger.nil?
+              render_text("Internal protocol error", "500 Internal Server Error")
+            end
+          end
+
+          def before_direct_invoke(request)
+            before_direct_invoke_without_action_controller(request)
+            @params ||= {}
+            signature = request.signature
+            if signature && (expects = request.signature[:expects])
+              (0..(@method_params.size-1)).each do |i|
+                if expects[i].is_a?(Hash)
+                  @params[expects[i].keys[0].to_s] = @method_params[i]
+                else
+                  @params['param%d' % i] = @method_params[i]
+                end
+              end
+            end
+            @params['action'] = request.method_name.to_s
+            @session ||= {}
+            @assigns ||= {}
+            return nil if before_action == false
+            true
+          end
+
+          def after_direct_invoke(request)
+            after_direct_invoke_without_action_controller(request)
+            after_action
+          end
+
+          def log_request(request)
+            unless logger.nil? || request.nil?
+              logger.debug("\nWeb Service Request:")
+              indented = request.raw_body.split(/\n/).map{|x| "  #{x}"}.join("\n")
+              logger.debug(indented)
+            end
+          end
+
+          def log_response(response, elapsed)
+            unless logger.nil? || response.nil?
+              logger.debug("\nWeb Service Response (%f):" % elapsed)
+              indented = response.raw_body.split(/\n/).map{|x| "  #{x}"}.join("\n")
+              logger.debug(indented)
+            end
+          end
+
+          unless method_defined?(:logger)
+            def logger; @logger; end
+          end
+      end
+
+      module WsdlGeneration # :nodoc:
+        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 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
+        end
+
+        private
+          def to_wsdl(container, uri, soap_action_base)
+            wsdl = ""
+  
+            web_service_dispatching_mode = container.web_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, api, api_methods|
+              services[name] = [api, api_methods]
+            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?(ActionWebService::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
+                      when mapping.is_a?(ActionWebService::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
+                    end
+                  end
+                end
+              end
+  
+              services.each do |service_name, service_values|
+                service_api, api_methods = service_values
+                # Parameter list message definitions
+                api_methods.each do |method_name, method_signature|
+                  gen = lambda do |msg_name, direction|
+                    xm.message('name' => msg_name) do
+                      sym = nil
+                      if direction == :out
+                        if method_signature[:returns]
+                          xm.part('name' => 'return', 'type' => method_signature[:returns][0].qualified_type_name)
+                        end
+                      else
+                        mapping_list = method_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
+                    end
+                  end
+                  public_name = service_api.public_api_method_name(method_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
+                  api_methods.each do |method_name, method_signature|
+                    public_name = service_api.public_api_method_name(method_name)
+                    xm.operation('name' => public_name) do
+                      xm.input('message' => "typens:#{public_name}")
+                      xm.output('message' => "typens:#{public_name}Response")
+                    end
+                  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)
+                  api_methods.each do |method_name, method_signature|
+                    public_name = service_api.public_api_method_name(method_name)
+                    xm.operation('name' => public_name) do
+                      case web_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
+  
+              # Define the service
+              xm.service('name' => "#{wsdl_service_name}Service") do
+                services.each do |service_name, service_values|
+                  port_name = port_name_for(wsdl_service_name, service_name)
+                  binding_name = binding_name_for(wsdl_service_name,  service_name)
+                  case web_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
+
+          def port_name_for(wsdl_service_name, service_name)
+            "#{wsdl_service_name}#{service_name.to_s.camelize}Port"
+          end
+
+          def binding_name_for(wsdl_service_name, service_name)
+            "#{wsdl_service_name}#{service_name.to_s.camelize}Binding"
+          end
+      end
+    end
+  end
+end

data/lib/action_web_service/invocation.rb

@@ -0,0 +1,205 @@
+module ActionWebService # :nodoc:
+  module Invocation # :nodoc:
+    class InvocationError < ActionWebService::ActionWebServiceError # :nodoc:
+    end
+
+    def self.append_features(base) # :nodoc:
+      super
+      base.extend(ClassMethods)
+      base.send(:include, ActionWebService::Invocation::InstanceMethods)
+    end
+
+    # Invocation interceptors provide a means to execute custom code before
+    # and after method invocations on ActionWebService::Base objects.
+    #
+    # When running in _Direct_ dispatching mode, ActionController filters
+    # should be used for this functionality instead.
+    #
+    # The semantics of invocation interceptors are the same as ActionController
+    # filters, and accept the same parameters and options.
+    #
+    # A _before_ interceptor can also cancel execution by returning +false+,
+    # or returning a <tt>[false, "cancel reason"]</tt> array if it wishes to supply
+    # a reason for canceling the request.
+    #
+    # === Example
+    #
+    #   class CustomService < ActionWebService::Base
+    #     before_invocation :intercept_add, :only => [:add]
+    #
+    #     def add(a, b)
+    #       a + b
+    #     end
+    #
+    #     private
+    #       def intercept_add
+    #         return [false, "permission denied"] # cancel it
+    #       end
+    #   end
+    #
+    # Options:
+    # [<tt>:except</tt>]  A list of methods for which the interceptor will NOT be called
+    # [<tt>:only</tt>]    A list of methods for which the interceptor WILL be called
+    module ClassMethods
+      # Appends the given +interceptors+ to be called
+      # _before_ method invocation.
+      def append_before_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        append_interceptors_to_chain("before", interceptors)
+      end
+
+      # Prepends the given +interceptors+ to be called
+      # _before_ method invocation.
+      def prepend_before_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        prepend_interceptors_to_chain("before", interceptors)
+      end
+
+      alias :before_invocation :append_before_invocation
+
+      # Appends the given +interceptors+ to be called
+      # _after_ method invocation.
+      def append_after_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        append_interceptors_to_chain("after", interceptors)
+      end
+
+      # Prepends the given +interceptors+ to be called
+      # _after_ method invocation.
+      def prepend_after_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        prepend_interceptors_to_chain("after", interceptors)
+      end
+
+      alias :after_invocation :append_after_invocation
+
+      def before_invocation_interceptors # :nodoc:
+        read_inheritable_attribute("before_invocation_interceptors")
+      end
+
+      def after_invocation_interceptors # :nodoc:
+        read_inheritable_attribute("after_invocation_interceptors")
+      end
+
+      def included_intercepted_methods # :nodoc:
+        read_inheritable_attribute("included_intercepted_methods") || {}
+      end
+      
+      def excluded_intercepted_methods # :nodoc:
+        read_inheritable_attribute("excluded_intercepted_methods") || {}
+      end
+
+      private
+        def append_interceptors_to_chain(condition, interceptors)
+          write_inheritable_array("#{condition}_invocation_interceptors", interceptors)
+        end
+
+        def prepend_interceptors_to_chain(condition, interceptors)
+          interceptors = interceptors + read_inheritable_attribute("#{condition}_invocation_interceptors")
+          write_inheritable_attribute("#{condition}_invocation_interceptors", interceptors)
+        end
+
+        def extract_conditions!(interceptors)
+          return nil unless interceptors.last.is_a? Hash
+          interceptors.pop
+        end
+
+        def add_interception_conditions(interceptors, conditions)
+          return unless conditions
+          included, excluded = conditions[:only], conditions[:except]
+          write_inheritable_hash("included_intercepted_methods", condition_hash(interceptors, included)) && return if included
+          write_inheritable_hash("excluded_intercepted_methods", condition_hash(interceptors, excluded)) if excluded
+        end
+
+        def condition_hash(interceptors, *methods)
+          interceptors.inject({}) {|hash, interceptor| hash.merge(interceptor => methods.flatten.map {|method| method.to_s})}
+        end
+    end
+
+    module InstanceMethods # :nodoc:
+      def self.append_features(base)
+        super
+        base.class_eval do
+          alias_method :perform_invocation_without_interception, :perform_invocation
+          alias_method :perform_invocation, :perform_invocation_with_interception
+        end
+      end
+
+      def perform_invocation_with_interception(method_name, params, &block)
+        return if before_invocation(method_name, params, &block) == false
+        return_value = perform_invocation_without_interception(method_name, params)
+        after_invocation(method_name, params, return_value)
+        return_value
+      end
+
+      def perform_invocation(method_name, params)
+        send(method_name, *params)
+      end
+
+      def before_invocation(name, args, &block)
+        call_interceptors(self.class.before_invocation_interceptors, [name, args], &block)
+      end
+
+      def after_invocation(name, args, result)
+        call_interceptors(self.class.after_invocation_interceptors, [name, args, result])
+      end
+
+      private
+
+        def call_interceptors(interceptors, interceptor_args, &block)
+          if interceptors and not interceptors.empty?
+            interceptors.each do |interceptor|
+              next if method_exempted?(interceptor, interceptor_args[0].to_s)
+              result = case
+                when interceptor.is_a?(Symbol)
+                  self.send(interceptor, *interceptor_args)
+                when interceptor_block?(interceptor)
+                  interceptor.call(self, *interceptor_args)
+                when interceptor_class?(interceptor)
+                  interceptor.intercept(self, *interceptor_args)
+                else
+                  raise(
+                    InvocationError,
+                    "Interceptors need to be either a symbol, proc/method, or a class implementing a static intercept method"
+                  )
+              end
+              reason = nil
+              if result.is_a?(Array)
+                reason = result[1] if result[1]
+                result = result[0]
+              end
+              if result == false
+                block.call(reason) if block && reason
+                return false
+              end
+            end
+          end
+        end
+
+        def interceptor_block?(interceptor)
+          interceptor.respond_to?("call") && (interceptor.arity == 3 || interceptor.arity == -1)
+        end
+        
+        def interceptor_class?(interceptor)
+          interceptor.respond_to?("intercept")
+        end
+
+        def method_exempted?(interceptor, method_name)
+          case
+            when self.class.included_intercepted_methods[interceptor]
+              !self.class.included_intercepted_methods[interceptor].include?(method_name)
+            when self.class.excluded_intercepted_methods[interceptor] 
+              self.class.excluded_intercepted_methods[interceptor].include?(method_name)
+          end
+        end
+    end
+  end
+end