soap4r-middleware-192 0.8.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in soap4r-middleware.gemspec
+gemspec

data/README.md

@@ -0,0 +1,61 @@
+Soap4r Rack Middleware
+======================
+
+This small library provides a Rack Middleware interface to exposing
+Soap4r server endpoints. This is a lightweight alternative to using
+ActionWebService for exposing SOAP in a Rails application, as well as
+allowing SOAP endpoints in any other Rack-based application. It's been
+tested with Rails 2.3.x, but should work fine in Rails 3 as well.
+
+Install
+-------
+
+    $ gem install soap4r-middleware
+
+Usage
+-----
+
+First, get yourself some Soap4r endpoint code. The easiest way to do
+this is to generate it from a WSDL file. Details are in the Soap4r
+documentation, or see http://dev.ctor.org/soap4r/wiki/HowtouseWSDL4R ,
+but basically:
+
+    $ wsdl2ruby.rb --wsdl /path/to/definiton.wsdl --type server
+
+You'll get some generated files. One of them will be named
+like `*APIService.rb`, near the bottom will be a class of the same name.
+To enable middleware functionality, you want to copy this class'
+initialization code into a new class that subclasses `Soap4r::Middleware::Base`, and replace the initialize method with a block passed to `setup`. For instance:
+
+    gem 'soap4r-middleware' # or use Bundler
+    require 'soap4r-middleware'
+
+    class MyAPIMiddleware < Soap4r::Middleware::Base
+      setup do
+        self.endpoint = %r{^/url/to/soap/endpoint/}
+        servant MyAPIPort.new
+        MyAPIPort::Methods.each do |definitions|
+          opt = definitions.last
+          if opt[:request_style] == :document
+            @router.add_document_operation(servant, *definitions)
+          else
+            @router.add_rpc_operation(servant, *definitions)
+          end
+        end
+        self.mapping_registry = UrnMyAPIMappingRegistry::EncodedRegistry
+        self.literal_mapping_registry = UrnMyAPIMappingRegistry::LiteralRegistry
+      end
+    end
+
+Then use this middleware anywhere you'd use a Rack middleware. It
+doubles as a Rack application as well, so you can host it directly using
+`run MyAPIMiddleware.new` in your `rackup.ru` file.
+
+### TODO
+
+I guess I could wrap `wsdl2ruby.rb` and make this automatic.
+
+### Wait, This is For Seriously??
+
+Sometimes you just gotta SOAP. Might as well make it suck as little as
+possible.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/soap4r-middleware.rb

@@ -0,0 +1,179 @@
+require 'soap/rpc/router'
+
+module Soap4r
+  module Middleware
+    include SOAP
+
+    def self.included(klass)
+      klass.send(:extend, ::Soap4r::Middleware::ClassMethods)
+    end
+
+    def initialize(app = nil)
+      @app = app
+    end
+
+    def call(env)
+      if env['PATH_INFO'].match(self.class.endpoint)
+        handle(env)
+      else
+        # we can act as both a middleware and an app
+        @app ?
+          @app.call(env) :
+          ( return 404, { "Content-Type" => "text/plain" }, ["404 - Not Found"] )
+      end
+    end
+
+    def handle(env)
+      # yeah, all soap calls are over POST
+      if env['REQUEST_METHOD'] != 'POST'
+        return 405, { 
+          'Allow' => 'POST',
+          'Content-Type' => 'text/plain' }, ["405 - Method Not Allowed"]
+      end
+
+      conn_data = ::SOAP::StreamHandler::ConnectionData.new
+      setup_request(conn_data, env)
+      conn_data = self.class.router.route(conn_data)
+      status, headers, body = setup_response(conn_data, env)
+      [ status, headers, body ]
+    rescue
+      raise # TODO -- do we 500 right here, or let the exception bubble up?
+    end
+
+    def setup_request(conn_data, env)
+      # TODO: we're reading the whole input here, which kind of stinks if rack is
+      # reading from the client on demand. We can't just pass in the rack input
+      # object, since REXML needs an IO that responds to :eof? -- we'd need a
+      # wrapper IO-like object.
+      conn_data.receive_string = env['rack.input'].read
+      conn_data.receive_contenttype = env['CONTENT_TYPE']
+      conn_data.soapaction = parse_soapaction(env['HTTP_SOAPAction'])
+    end
+
+    def setup_response(conn_data, env)
+      status = 200
+      headers = {}
+      body = []
+      headers['content-type'] = conn_data.send_contenttype
+      # TODO: cookies?
+      if conn_data.is_nocontent
+        status = 202 # ACCEPTED
+      elsif conn_data.is_fault
+        # rather than sending the 500 here, let's bubble up the exception so the
+        # parent application can do with it what it will. The only downside is
+        # soap4r has already converted the exception into a soap response body at
+        # this point, which isn't what we want at all.
+        # maybe someday i'll re-parse the response or something. but not today.
+        raise conn_data.send_string
+      else
+        body << conn_data.send_string
+      end
+      return status, headers, body
+    end
+
+    def parse_soapaction(soapaction)
+      if !soapaction.nil? and !soapaction.empty?
+        if /\A"(.+)"\z/ =~ soapaction
+          return $1
+        end
+      end
+      nil
+    end
+
+    module ClassMethods
+      def setup
+        @router = ::SOAP::RPC::Router.new(self.class.name)
+        yield self
+      end
+
+      def router
+        @router
+      end
+
+      def endpoint=(regex)
+        @endpoint = regex
+      end
+
+      def endpoint
+        @endpoint
+      end
+
+      # SOAP interface
+
+      def mapping_registry
+        router.mapping_registry
+      end
+
+      def mapping_registry=(mapping_registry)
+        router.mapping_registry = mapping_registry
+      end
+
+      def literal_mapping_registry
+        router.literal_mapping_registry
+      end
+
+      def literal_mapping_registry=(literal_mapping_registry)
+        router.literal_mapping_registry = literal_mapping_registry
+      end
+
+      def generate_explicit_type
+        router.generate_explicit_type
+      end
+
+      def generate_explicit_type=(generate_explicit_type)
+        router.generate_explicit_type = generate_explicit_type
+      end
+
+      # servant entry interface
+
+      def add_rpc_servant(obj, namespace = self.default_namespace)
+        router.add_rpc_servant(obj, namespace)
+      end
+      alias add_servant add_rpc_servant
+
+      def add_headerhandler(obj)
+        router.add_headerhandler(obj)
+      end
+      alias add_rpc_headerhandler add_headerhandler
+
+      def filterchain
+        router.filterchain
+      end
+
+      # method entry interface
+
+      def add_rpc_method(obj, name, *param)
+        add_rpc_method_with_namespace_as(default_namespace, obj, name, name, *param)
+      end
+      alias add_method add_rpc_method
+
+      def add_rpc_method_as(obj, name, name_as, *param)
+        add_rpc_method_with_namespace_as(default_namespace, obj, name, name_as, *param)
+      end
+      alias add_method_as add_rpc_method_as
+
+      def add_rpc_method_with_namespace(namespace, obj, name, *param)
+        add_rpc_method_with_namespace_as(namespace, obj, name, name, *param)
+      end
+      alias add_method_with_namespace add_rpc_method_with_namespace
+
+      def add_rpc_method_with_namespace_as(namespace, obj, name, name_as, *param)
+        qname = XSD::QName.new(namespace, name_as)
+        soapaction = nil
+        param_def = SOAPMethod.derive_rpc_param_def(obj, name, *param)
+        router.add_rpc_operation(obj, qname, soapaction, name, param_def)
+      end
+      alias add_method_with_namespace_as add_rpc_method_with_namespace_as
+
+      def add_rpc_operation(receiver, qname, soapaction, name, param_def, opt = {})
+        router.add_rpc_operation(receiver, qname, soapaction, name, param_def, opt)
+      end
+
+      def add_document_operation(receiver, soapaction, name, param_def, opt = {})
+        router.add_document_operation(receiver, soapaction, name, param_def, opt)
+      end
+    end # ClassMethods
+  end
+end
+
+require 'soap4r-middleware/base'

data/lib/soap4r-middleware/base.rb

@@ -0,0 +1,3 @@
+class Soap4r::Middleware::Base
+  include ::Soap4r::Middleware
+end

data/lib/soap4r-middleware/version.rb

@@ -0,0 +1,5 @@
+module Soap4r
+  module Middleware
+    VERSION = "0.8.2"
+  end
+end

data/soap4r-middleware.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "soap4r-middleware/version"
+
+Gem::Specification.new do |s|
+  s.name        = "soap4r-middleware-192"
+  s.version     = Soap4r::Middleware::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Brian Palmer"]
+  s.email       = ["brian@codekitchen.net"]
+  s.homepage    = "https://www.github.com/codekitchen/soap4r-middleware"
+  s.summary     = %q{Provides a Rack middleware for exposing SOAP server endpoints}
+  s.description = %q{Sometimes, you just gotta SOAP.}
+
+  s.rubyforge_project = "soap4r-middleware"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rubyjedi-soap4r', '~> 1.5'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: soap4r-middleware-192
+version: !ruby/object:Gem::Version
+  version: 0.8.2
+  prerelease: 
+platform: ruby
+authors:
+- Brian Palmer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-06 00:00:00.000000000 +04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubyjedi-soap4r
+  requirement: &15804500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: *15804500
+description: Sometimes, you just gotta SOAP.
+email:
+- brian@codekitchen.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/soap4r-middleware.rb
+- lib/soap4r-middleware/base.rb
+- lib/soap4r-middleware/version.rb
+- soap4r-middleware.gemspec
+has_rdoc: true
+homepage: https://www.github.com/codekitchen/soap4r-middleware
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: soap4r-middleware
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Provides a Rack middleware for exposing SOAP server endpoints
+test_files: []