soap4r-middleware 0.8.0

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/base.rb

@@ -0,0 +1,171 @@
+class Soap4r::Middleware::Base
+  include SOAP
+
+  def self.setup
+    raise("Please subclass first") if self == Soap4r::Middleware::Base
+    @router = ::SOAP::RPC::Router.new(self.class.name)
+    yield self
+    self
+  end
+
+  def self.router
+    @router
+  end
+
+  def self.endpoint=(regex)
+    @endpoint = regex
+  end
+
+  def self.endpoint
+    @endpoint
+  end
+
+  def initialize(app = nil)
+    @app = app
+    @endpoint = self.class.endpoint
+    unless @endpoint.is_a?(Regexp)
+      raise ArgumentError, "Endpoint has not been defined"
+    end
+  end
+
+  def call(env)
+    if env['PATH_INFO'].match(@endpoint)
+      handle(env)
+    else
+      # we can act as both a middleware and an app
+      @app ?
+        @app.call(env) :
+        [ 404, { "Content-Type" => "text/html" }, "Not Found" ]
+    end
+  end
+
+  def handle(env)
+    # yeah, all soap calls are over POST
+    if env['REQUEST_METHOD'] != 'POST'
+      return 405, { 'Content-Length' => '0',
+                    'Allow' => 'POST',
+                    'Content-Type' => 'text/plain' }, []
+    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
+      status = 500 # INTERNAL_SERVER_ERROR
+    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
+
+  class << self
+
+    # 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 # class << self
+end

data/lib/soap4r-middleware/version.rb

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

data/lib/soap4r-middleware.rb

@@ -0,0 +1,8 @@
+require 'soap/rpc/router'
+
+module Soap4r
+  module Middleware
+  end
+end
+
+require 'soap4r-middleware/base'

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"
+  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 'soap4r', '~> 1.5'
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: soap4r-middleware
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: false
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Brian Palmer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-08 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: soap4r
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 1
+        - 5
+        version: "1.5"
+  type: :runtime
+  version_requirements: *id001
+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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: soap4r-middleware
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides a Rack middleware for exposing SOAP server endpoints
+test_files: []
+