soap4r-sgonyea 1.5.9

data/lib/soap/rpc/rpc.rb

@@ -0,0 +1,26 @@
+# encoding: ASCII-8BIT
+# SOAP4R - RPC utility.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+module SOAP
+
+
+module RPC
+  ServerException = Mapping::MappedException
+
+  def self.defined_methods(obj)
+    if obj.is_a?(Module)
+      obj.methods - Module.methods
+    else
+      obj.methods - Object.instance_methods(true)
+    end
+  end
+end
+
+
+end

data/lib/soap/rpc/soaplet.rb

@@ -0,0 +1,201 @@
+# encoding: ASCII-8BIT
+# SOAP4R - SOAP handler servlet for WEBrick
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'webrick/httpservlet/abstract'
+require 'webrick/httpstatus'
+require 'soap/rpc/router'
+require 'soap/streamHandler'
+begin
+  require 'stringio'
+  require 'zlib'
+rescue LoadError
+  warn("Loading stringio or zlib failed.  No gzipped response supported.") if $DEBUG
+end
+
+
+warn("Overriding WEBrick::Log#debug") if $DEBUG
+require 'webrick/log'
+module WEBrick
+  class Log < BasicLog
+    alias __debug debug
+    def debug(msg = nil)
+      if block_given? and msg.nil?
+        __debug(yield)
+      else
+        __debug(msg)
+      end
+    end
+  end
+end
+
+
+module SOAP
+module RPC
+
+
+class SOAPlet < WEBrick::HTTPServlet::AbstractServlet
+public
+  attr_reader :options
+  attr_accessor :authenticator
+
+  def initialize(router = nil)
+    @router = router || ::SOAP::RPC::Router.new(self.class.name)
+    @options = {}
+    @authenticator = nil
+    @config = {}
+  end
+
+  def allow_content_encoding_gzip=(allow)
+    @options[:allow_content_encoding_gzip] = allow
+  end
+
+  ###
+  ## Servlet interfaces for WEBrick.
+  #
+  def get_instance(config, *options)
+    @config = config
+    self
+  end
+
+  def require_path_info?
+    false
+  end
+
+  def do_GET(req, res)
+    res.header['Allow'] = 'POST'
+    raise WEBrick::HTTPStatus::MethodNotAllowed, "GET request not allowed"
+  end
+
+  def do_POST(req, res)
+    logger.debug { "SOAP request: " + req.body } if logger
+    if @authenticator
+      @authenticator.authenticate(req, res)
+      # you can check authenticated user with SOAP::RPC::SOAPlet.user
+    end
+    begin
+      conn_data = ::SOAP::StreamHandler::ConnectionData.new
+      setup_req(conn_data, req)
+      @router.external_ces = @options[:external_ces]
+      Mapping.protect_threadvars(:SOAPlet) do
+        SOAPlet.user = req.user
+        SOAPlet.cookies = req.cookies
+        conn_data = @router.route(conn_data)
+        setup_res(conn_data, req, res)
+      end
+    rescue Exception => e
+      conn_data = @router.create_fault_response(e)
+      res.status = WEBrick::HTTPStatus::RC_INTERNAL_SERVER_ERROR
+      res.body = conn_data.send_string
+      res['content-type'] = conn_data.send_contenttype || "text/xml"
+    end
+    if res.body.is_a?(IO)
+      res.chunked = true
+      logger.debug { "SOAP response: (chunked response not logged)" } if logger
+    else
+      logger.debug { "SOAP response: " + res.body } if logger
+    end
+  end
+
+  def self.cookies
+    get_variable(:Cookies)
+  end
+
+  def self.cookies=(cookies)
+    set_variable(:Cookies, cookies)
+  end
+
+  def self.user
+    get_variable(:User)
+  end
+
+  def self.user=(user)
+    set_variable(:User, user)
+  end
+
+private
+
+  def self.get_variable(name)
+    if var = Thread.current[:SOAPlet]
+      var[name]
+    else
+      nil
+    end
+  end
+
+  def self.set_variable(name, value)
+    var = Thread.current[:SOAPlet] ||= {}
+    var[name] = value
+  end
+
+  def logger
+    @config[:Logger]
+  end
+
+  def setup_req(conn_data, req)
+    conn_data.receive_string = req.body
+    conn_data.receive_contenttype = req['content-type']
+    conn_data.soapaction = parse_soapaction(req.meta_vars['HTTP_SOAPACTION'])
+  end
+
+  def setup_res(conn_data, req, res)
+    res['content-type'] = conn_data.send_contenttype
+    cookies = SOAPlet.cookies
+    unless cookies.empty?
+      res['set-cookie'] = cookies.collect { |cookie| cookie.to_s }
+    end
+    if conn_data.is_nocontent
+      res.status = WEBrick::HTTPStatus::RC_ACCEPTED
+      res.body = ''
+      return
+    end
+    if conn_data.is_fault
+      res.status = WEBrick::HTTPStatus::RC_INTERNAL_SERVER_ERROR
+    end
+    if outstring = encode_gzip(req, conn_data.send_string)
+      res['content-encoding'] = 'gzip'
+      res['content-length'] = outstring.size
+      res.body = outstring
+    else
+      res.body = conn_data.send_string
+    end
+  end
+
+  def parse_soapaction(soapaction)
+    if !soapaction.nil? and !soapaction.empty?
+      if /^"(.+)"$/ =~ soapaction
+        return $1
+      end
+    end
+    nil
+  end
+
+  def encode_gzip(req, outstring)
+    unless encode_gzip?(req)
+      return nil
+    end
+    begin
+      ostream = StringIO.new
+      gz = Zlib::GzipWriter.new(ostream)
+      gz.write(outstring)
+      ostream.string
+    ensure
+      gz.close
+    end
+  end
+
+  def encode_gzip?(req)
+    @options[:allow_content_encoding_gzip] and defined?(::Zlib) and
+      req['accept-encoding'] and
+      req['accept-encoding'].split(/,\s*/).include?('gzip')
+  end
+end
+
+
+end
+end

data/lib/soap/rpc/standaloneServer.rb

@@ -0,0 +1,44 @@
+# encoding: ASCII-8BIT
+# SOAP4R - WEBrick Server
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/rpc/httpserver'
+
+
+module SOAP
+module RPC
+
+
+class StandaloneServer < HTTPServer
+  def initialize(appname, default_namespace, host = "0.0.0.0", port = 8080)
+    @appname = appname
+    @default_namespace = default_namespace
+    @host = host
+    @port = port
+    super(create_config)
+  end
+
+  alias add_servant add_rpc_servant
+  alias add_headerhandler add_rpc_headerhandler
+
+private
+
+  def create_config
+    {
+      :BindAddress => @host,
+      :Port => @port,
+      :AccessLog => [],
+      :SOAPDefaultNamespace => @default_namespace,
+      :SOAPHTTPServerApplicationName => @appname,
+    }
+  end
+end
+
+
+end
+end

data/lib/soap/soap.rb

@@ -0,0 +1,154 @@
+# encoding: ASCII-8BIT
+# soap/soap.rb: SOAP4R - Base definitions.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'xsd/qname'
+require 'xsd/charset'
+require 'soap/nestedexception'
+require 'soap/version'
+
+
+module SOAP
+
+
+# VERSION = Version = SOAP::VERSION::STRING # '1.5.8-HEAD'
+Version = SOAP::VERSION::STRING # '1.5.8-HEAD'
+PropertyName = 'soap/property'
+
+EnvelopeNamespace = 'http://schemas.xmlsoap.org/soap/envelope/'
+EncodingNamespace = 'http://schemas.xmlsoap.org/soap/encoding/'
+LiteralNamespace = 'http://xml.apache.org/xml-soap/literalxml'
+
+NextActor = 'http://schemas.xmlsoap.org/soap/actor/next'
+
+EleEnvelope = 'Envelope'
+EleHeader = 'Header'
+EleBody = 'Body'
+EleFault = 'Fault'
+EleFaultString = 'faultstring'
+EleFaultActor = 'faultactor'
+EleFaultCode = 'faultcode'
+EleFaultDetail = 'detail'
+
+AttrMustUnderstand = 'mustUnderstand'
+AttrEncodingStyle = 'encodingStyle'
+AttrActor = 'actor'
+AttrRoot = 'root'
+AttrArrayType = 'arrayType'
+AttrOffset = 'offset'
+AttrPosition = 'position'
+AttrHref = 'href'
+AttrId = 'id'
+ValueArray = 'Array'
+
+EleEnvelopeName = XSD::QName.new(EnvelopeNamespace, EleEnvelope).freeze
+EleHeaderName = XSD::QName.new(EnvelopeNamespace, EleHeader).freeze
+EleBodyName = XSD::QName.new(EnvelopeNamespace, EleBody).freeze
+EleFaultName = XSD::QName.new(EnvelopeNamespace, EleFault).freeze
+EleFaultStringName = XSD::QName.new(nil, EleFaultString).freeze
+EleFaultActorName = XSD::QName.new(nil, EleFaultActor).freeze
+EleFaultCodeName = XSD::QName.new(nil, EleFaultCode).freeze
+EleFaultDetailName = XSD::QName.new(nil, EleFaultDetail).freeze
+AttrActorName = XSD::QName.new(EnvelopeNamespace, AttrActor).freeze
+AttrMustUnderstandName = XSD::QName.new(EnvelopeNamespace, AttrMustUnderstand).freeze
+AttrEncodingStyleName = XSD::QName.new(EnvelopeNamespace, AttrEncodingStyle).freeze
+AttrRootName = XSD::QName.new(EncodingNamespace, AttrRoot).freeze
+AttrArrayTypeName = XSD::QName.new(EncodingNamespace, AttrArrayType).freeze
+AttrOffsetName = XSD::QName.new(EncodingNamespace, AttrOffset).freeze
+AttrPositionName = XSD::QName.new(EncodingNamespace, AttrPosition).freeze
+AttrHrefName = XSD::QName.new(nil, AttrHref).freeze
+AttrIdName = XSD::QName.new(nil, AttrId).freeze
+ValueArrayName = XSD::QName.new(EncodingNamespace, ValueArray).freeze
+
+Base64Literal = 'base64'
+
+MediaType = 'text/xml'
+
+class Error < StandardError; include NestedException; end
+
+class StreamError < Error; end
+class HTTPStreamError < StreamError; end
+class PostUnavailableError < HTTPStreamError; end
+class MPostUnavailableError < HTTPStreamError; end
+
+class ArrayIndexOutOfBoundsError < Error; end
+class ArrayStoreError < Error; end
+
+class RPCRoutingError < Error; end
+class EmptyResponseError < Error; end
+class ResponseFormatError < Error; end
+
+class UnhandledMustUnderstandHeaderError < Error; end
+
+
+module FaultCode
+  VersionMismatch = XSD::QName.new(EnvelopeNamespace, 'VersionMismatch').freeze
+  MustUnderstand = XSD::QName.new(EnvelopeNamespace, 'MustUnderstand').freeze
+  Client = XSD::QName.new(EnvelopeNamespace, 'Client').freeze
+  Server = XSD::QName.new(EnvelopeNamespace, 'Server').freeze
+end
+
+
+class FaultError < Error
+  attr_reader :faultcode
+  attr_reader :faultstring
+  attr_reader :faultactor
+  attr_accessor :detail
+
+  def initialize(fault)
+    @faultcode = fault.faultcode
+    @faultstring = fault.faultstring
+    @faultactor = fault.faultactor
+    @detail = fault.detail
+    super(self.to_s)
+  end
+
+  def to_s
+    str = nil
+    if @faultstring and @faultstring.respond_to?('data')
+      str = @faultstring.data
+    end
+    str || '(No faultstring)'
+  end
+end
+
+
+module Env
+  def self.getenv(name)
+    ENV[name.downcase] || ENV[name.upcase]
+  end
+
+  is_cgi = !getenv('request_method').nil?
+  HTTP_PROXY = is_cgi ? getenv('cgi_http_proxy') : getenv('http_proxy')
+  NO_PROXY = getenv('no_proxy')
+end
+
+
+end
+
+
+unless Object.respond_to?(:instance_variable_get)
+  class Object
+    def instance_variable_get(ivarname)
+      instance_eval(ivarname)
+    end
+
+    def instance_variable_set(ivarname, value)
+      instance_eval("#{ivarname} = value")
+    end
+  end
+end
+
+
+unless Kernel.respond_to?(:warn)
+  module Kernel
+    def warn(msg)
+      STDERR.puts(msg + "\n") unless $VERBOSE.nil?
+    end
+  end
+end

data/lib/soap/streamHandler.rb

@@ -0,0 +1,302 @@
+# encoding: ASCII-8BIT
+# SOAP4R - Stream handler.
+# Copyright (C) 2000-2007  NAKAMURA, Hiroshi <nahi@ruby-lang.org>.
+
+# This program is copyrighted free software by NAKAMURA, Hiroshi.  You can
+# redistribute it and/or modify it under the same terms of Ruby's license;
+# either the dual license version in 2003, or any later version.
+
+
+require 'soap/soap'
+require 'soap/httpconfigloader'
+require 'soap/filter/filterchain'
+begin
+  require 'stringio'
+  require 'zlib'
+rescue LoadError
+  warn("Loading stringio or zlib failed.  No gzipped response support.") if $DEBUG
+end
+
+
+module SOAP
+
+
+class StreamHandler
+  RUBY_VERSION_STRING = "ruby #{ RUBY_VERSION } (#{ RUBY_RELEASE_DATE }) [#{ RUBY_PLATFORM }]"
+
+  attr_reader :filterchain
+
+  class ConnectionData
+    attr_accessor :send_string
+    attr_accessor :send_contenttype
+    attr_accessor :receive_string
+    attr_accessor :receive_contenttype
+    attr_accessor :is_fault
+    attr_accessor :is_nocontent
+    attr_accessor :soapaction
+
+    def initialize(send_string = nil)
+      @send_string = send_string
+      @send_contenttype = nil
+      @receive_string = nil
+      @receive_contenttype = nil
+      @is_fault = false
+      @is_nocontent = false
+      @soapaction = nil
+    end
+  end
+
+  def initialize
+    @filterchain = Filter::FilterChain.new
+  end
+
+  def self.parse_media_type(str)
+    if /^#{ MediaType }(?:\s*;\s*charset=([^"]+|"[^"]+"))?$/i !~ str
+      return nil
+    end
+    charset = $1
+    charset.gsub!(/"/, '') if charset
+    charset || 'us-ascii'
+  end
+
+  def self.create_media_type(charset)
+    "#{ MediaType }; charset=#{ charset }"
+  end
+
+  def send(url, conn_data, soapaction = nil, charset = nil)
+    # send a ConnectionData to specified url.
+    # return value is a ConnectionData with receive_* property filled.
+    # You can fill values of given conn_data and return it.
+  end
+
+  def reset(url = nil)
+    # for initializing connection status if needed.
+    # return value is not expected.
+  end
+
+  def set_wiredump_file_base(wiredump_file_base)
+    # for logging.  return value is not expected.
+    # Override it when you want.
+    raise NotImplementedError
+  end
+
+  def test_loopback_response
+    # for loopback testing.  see HTTPStreamHandler for more detail.
+    # return value is an Array of loopback responses.
+    # Override it when you want.
+    raise NotImplementedError
+  end
+end
+
+
+class HTTPStreamHandler < StreamHandler
+  include SOAP
+
+  begin
+    require 'httpclient'
+    Client = HTTPClient
+    RETRYABLE = true
+  rescue LoadError
+    begin
+      require 'http-access2'
+      if HTTPAccess2::VERSION < "2.0"
+        raise LoadError.new("http-access/2.0 or later is required.")
+      end
+      Client = HTTPAccess2::Client
+      RETRYABLE = true
+    rescue LoadError
+      warn("Loading http-access2 failed.  Net/http is used.") if $DEBUG
+      require 'soap/netHttpClient'
+      Client = SOAP::NetHttpClient
+      RETRYABLE = false
+    end
+  end
+
+  class HttpPostRequestFilter
+    def initialize(filterchain)
+      @filterchain = filterchain
+    end
+
+    def filter_request(req)
+      @filterchain.each do |filter|
+        filter.on_http_outbound(req)
+      end
+    end
+
+    def filter_response(req, res)
+      @filterchain.each do |filter|
+        filter.on_http_inbound(req, res)
+      end
+    end
+  end
+
+public
+  
+  attr_reader :client
+  attr_accessor :wiredump_file_base
+  
+  MAX_RETRY_COUNT = 10       	# [times]
+
+  def self.create(options)
+    new(options)
+  end
+
+  def initialize(options)
+    super()
+    @client = Client.new(nil, "RUBYJEDI-SOAP4R/#{ Version }")
+    if @client.respond_to?(:request_filter)
+      @client.request_filter << HttpPostRequestFilter.new(@filterchain)
+    end
+    @wiredump_file_base = nil
+    @charset = @wiredump_dev = nil
+    @options = options
+    set_options
+    @client.debug_dev = @wiredump_dev
+    @cookie_store = nil
+    @accept_encoding_gzip = false
+  end
+
+  def test_loopback_response
+    @client.test_loopback_response
+  end
+
+  def accept_encoding_gzip=(allow)
+    @accept_encoding_gzip = allow
+  end
+
+  def inspect
+    "#<#{self.class}>"
+  end
+
+  def send(url, conn_data, charset = @charset)
+    conn_data = send_post(url, conn_data, charset)
+    @client.save_cookie_store if @cookie_store
+    conn_data
+  end
+
+  def reset(url = nil)
+    if url.nil?
+      @client.reset_all
+    else
+      @client.reset(url)
+    end
+    @client.save_cookie_store if @cookie_store
+  end
+
+private
+
+  def set_options
+    @options["http"] ||= ::SOAP::Property.new
+    HTTPConfigLoader.set_options(@client, @options["http"])
+    @charset = @options["http.charset"] || XSD::Charset.xml_encoding_label
+    @options.add_hook("http.charset") do |key, value|
+      @charset = value
+    end
+    @wiredump_dev = @options["http.wiredump_dev"]
+    @options.add_hook("http.wiredump_dev") do |key, value|
+      @wiredump_dev = value
+      @client.debug_dev = @wiredump_dev
+    end
+    set_cookie_store_file(@options["http.cookie_store_file"])
+    @options.add_hook("http.cookie_store_file") do |key, value|
+      set_cookie_store_file(value)
+    end
+    ssl_config = @options["http.ssl_config"]
+    basic_auth = @options["http.basic_auth"]
+    auth = @options["http.auth"]
+    @options["http"].lock(true)
+    ssl_config.unlock
+    basic_auth.unlock
+    auth.unlock
+  end
+
+  def set_cookie_store_file(value)
+    value = nil if value and value.empty?
+    @cookie_store = value
+    @client.set_cookie_store(@cookie_store) if @cookie_store
+  end
+
+  def send_post(url, conn_data, charset)
+    conn_data.send_contenttype ||= StreamHandler.create_media_type(charset)
+
+    if @wiredump_file_base
+      filename = @wiredump_file_base + '_request.xml'
+      f = File.open(filename, "w")
+      f << conn_data.send_string
+      f.close
+    end
+
+    extheader = {}
+    extheader['Content-Type'] = conn_data.send_contenttype
+    extheader['SOAPAction'] = "\"#{ conn_data.soapaction }\""
+    extheader['Accept-Encoding'] = 'gzip' if send_accept_encoding_gzip?
+    send_string = conn_data.send_string
+    @wiredump_dev << "Wire dump:\n\n" if @wiredump_dev
+    begin
+      retry_count = 0
+      while true
+        res = @client.post(url, send_string, extheader)
+        if RETRYABLE and HTTP::Status.redirect?(res.status)
+          retry_count += 1
+          if retry_count >= MAX_RETRY_COUNT
+            raise HTTPStreamError.new("redirect count exceeded")
+          end
+          url = res.header["location"][0]
+          puts "redirected to #{url}" if $DEBUG
+        else
+          break
+        end
+      end
+    rescue
+      @client.reset(url)
+      raise
+    end
+    @wiredump_dev << "\n\n" if @wiredump_dev
+    receive_string = res.content
+    if @wiredump_file_base
+      filename = @wiredump_file_base + '_response.xml'
+      f = File.open(filename, "w")
+      f << receive_string
+      f.close
+    end
+    case res.status
+    when 405
+      raise PostUnavailableError.new("#{ res.status }: #{ res.reason }")
+    when 200, 202, 500
+      # Nothing to do.  202 is for oneway service.
+    else
+      raise HTTPStreamError.new("#{ res.status }: #{ res.reason }")
+    end
+
+    # decode gzipped content, if we know it's there from the headers
+    if res.respond_to?(:header) and !res.header['content-encoding'].empty? and
+        res.header['content-encoding'][0].downcase == 'gzip'
+      receive_string = decode_gzip(receive_string)
+    # otherwise check for the gzip header
+    elsif @accept_encoding_gzip && receive_string[0..1] == "\x1f\x8b"
+      receive_string = decode_gzip(receive_string)
+    end
+    conn_data.receive_string = receive_string
+    conn_data.receive_contenttype = res.contenttype
+    conn_data
+  end
+
+  def send_accept_encoding_gzip?
+    @accept_encoding_gzip and defined?(::Zlib)
+  end
+
+  def decode_gzip(instring)
+    unless send_accept_encoding_gzip?
+      raise HTTPStreamError.new("Gzipped response content.")
+    end
+    begin
+      gz = Zlib::GzipReader.new(StringIO.new(instring))
+      gz.read
+    ensure
+      gz.close
+    end
+  end
+end
+
+
+end