reidiculous-actionwebservice 3.0.3

data/lib/action_web_service/soap/marshal.rb

@@ -0,0 +1,59 @@
+# SOAP4R - Marshalling/Unmarshalling Ruby's object using SOAP Encoding.
+# Copyright (C) 2001, 2003  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/mapping"
+require "soap/processor"
+
+
+module SOAP
+
+
+module Marshal
+  # Trying xsd:dateTime data to be recovered as aTime.
+  MarshalMappingRegistry = Mapping::Registry.new(
+    :allow_original_mapping => true)
+  MarshalMappingRegistry.add(
+    Time,
+    ::SOAP::SOAPDateTime,
+    ::SOAP::Mapping::Registry::DateTimeFactory
+  )
+
+  class << self
+  public
+    def dump(obj, io = nil)
+      marshal(obj, MarshalMappingRegistry, io)
+    end
+
+    def load(stream)
+      unmarshal(stream, MarshalMappingRegistry)
+    end
+
+    def marshal(obj, mapping_registry = MarshalMappingRegistry, io = nil)
+      elename = Mapping.name2elename(obj.class.to_s)
+      soap_obj = Mapping.obj2soap(obj, mapping_registry)
+      body = SOAPBody.new
+      body.add(elename, soap_obj)
+      env = SOAPEnvelope.new(nil, body)
+      SOAP::Processor.marshal(env, {}, io)
+    end
+
+    def unmarshal(stream, mapping_registry = MarshalMappingRegistry)
+      env = SOAP::Processor.unmarshal(stream)
+      if env.nil?
+	raise ArgumentError.new("Illegal SOAP marshal format.")
+      end
+      Mapping.soap2obj(env.body.root_node, mapping_registry)
+    end
+  end
+end
+
+
+end
+
+
+SOAPMarshal = SOAP::Marshal

data/lib/action_web_service/soap/mimemessage.rb

@@ -0,0 +1,240 @@
+# SOAP4R - MIME Message implementation.
+# Copyright (C) 2002  Jamie Herre.
+
+# 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 'action_web_service/soap/attachment'
+
+
+module SOAP
+
+
+# Classes for MIME message handling.  Should be put somewhere else!
+# Tried using the 'tmail' module but found that I needed something
+# lighter in weight.
+
+
+class MIMEMessage
+  class MIMEMessageError < StandardError; end
+
+  MultipartContentType = 'multipart/\w+'
+
+  class Header
+    attr_accessor :str, :key, :root
+
+    def initialize
+      @attrs = {}
+    end
+
+    def [](key)
+      @attrs[key]
+    end
+
+    def []=(key, value)
+      @attrs[key] = value
+    end
+
+    def to_s
+      @key + ": " + @str
+    end
+  end
+
+  class Headers < Hash
+    def self.parse(str)
+      new.parse(str)
+    end
+
+    def parse(str)
+      header_cache = nil
+      str.each do |line|
+	case line
+	when /^\A[^\: \t]+:\s*.+$/
+	  parse_line(header_cache) if header_cache
+	  header_cache = line.sub(/\r?\n\z/, '')
+	when /^\A\s+(.*)$/
+	  # a continuous line at the beginning line crashes here.
+	  header_cache << line
+	else
+	  raise RuntimeError.new("unexpected header: #{line.inspect}")
+	end
+      end
+      parse_line(header_cache) if header_cache
+      self
+    end
+
+    def parse_line(line)
+      if /^\A([^\: \t]+):\s*(.+)\z/ =~ line
+    	header = parse_rhs($2.strip)
+	header.key = $1.strip
+	self[header.key.downcase] = header
+      else
+	raise RuntimeError.new("unexpected header line: #{line.inspect}")
+      end
+    end
+
+    def parse_rhs(str)
+      a = str.split(/;+\s+/)
+      header = Header.new
+      header.str = str
+      header.root = a.shift
+      a.each do |pair|
+	if pair =~ /(\w+)\s*=\s*"?([^"]+)"?/
+	  header[$1.downcase] = $2
+	else
+	  raise RuntimeError.new("unexpected header component: #{pair.inspect}")
+	end
+      end
+      header
+    end
+
+    def add(key, value)
+      if key != nil and value != nil
+	header = parse_rhs(value)
+	header.key = key
+	self[key.downcase] = header
+      end
+    end
+
+    def to_s
+      self.values.collect { |hdr|
+	hdr.to_s
+      }.join("\r\n")
+    end
+  end
+
+  class Part
+    attr_accessor :headers, :body
+
+    def initialize
+      @headers = Headers.new
+      @headers.add("Content-Transfer-Encoding", "8bit")
+      @body = nil
+      @contentid = nil
+    end
+
+    def self.parse(str)
+      new.parse(str)
+    end
+
+    def parse(str)
+      headers, body = str.split(/\r\n\r\n/s)
+      if headers != nil and body != nil
+	@headers = Headers.parse(headers)
+	@body = body.sub(/\r\n\z/, '')
+      else
+	raise RuntimeError.new("unexpected part: #{str.inspect}")
+      end
+      self
+    end
+
+    def contentid
+      if @contentid == nil and @headers.key?('content-id')
+	@contentid = @headers['content-id'].str
+	@contentid = $1 if @contentid =~ /^<(.+)>$/
+      end
+      @contentid
+    end
+
+    alias content body
+
+    def to_s
+      @headers.to_s + "\r\n\r\n" + @body
+    end
+  end
+
+  def initialize
+    @parts = []
+    @headers = Headers.new
+    @root = nil
+  end
+
+  def self.parse(head, str)
+    new.parse(head, str)
+  end
+
+  attr_reader :parts, :headers
+
+  def close
+    @headers.add(
+      "Content-Type",
+      "multipart/related; type=\"text/xml\"; boundary=\"#{boundary}\"; start=\"#{@parts[0].contentid}\""
+    )
+  end
+
+  def parse(head, str)
+    @headers = Headers.parse(head + "\r\n" + "From: jfh\r\n")
+    boundary = @headers['content-type']['boundary']
+    if boundary != nil
+      parts = str.split(/--#{Regexp.quote(boundary)}\s*(?:\r\n|--\r\n)/)
+      part = parts.shift	# preamble must be ignored.
+      @parts = parts.collect { |part| Part.parse(part) }
+    else
+      @parts = [Part.parse(str)]
+    end
+    if @parts.length < 1
+      raise MIMEMessageError.new("This message contains no valid parts!")
+    end
+    self
+  end
+
+  def root
+    if @root == nil
+      start = @headers['content-type']['start']
+      @root = (start && @parts.find { |prt| prt.contentid == start }) ||
+	@parts[0]
+    end
+    @root
+  end
+
+  def boundary
+    if @boundary == nil
+      @boundary = "----=Part_" + __id__.to_s + rand.to_s
+    end
+    @boundary
+  end
+
+  def add_part(content)
+    part = Part.new
+    part.headers.add("Content-Type",
+      "text/xml; charset=" + XSD::Charset.xml_encoding_label)
+    part.headers.add("Content-ID", Attachment.contentid(part))
+    part.body = content
+    @parts.unshift(part)
+  end
+
+  def add_attachment(attach)
+    part = Part.new
+    part.headers.add("Content-Type", attach.contenttype)
+    part.headers.add("Content-ID", attach.mime_contentid)
+    part.body = attach.content
+    @parts.unshift(part)
+  end
+
+  def has_parts?
+    (@parts.length > 0)
+  end
+
+  def headers_str
+    @headers.to_s
+  end
+
+  def content_str
+    str = ''
+    @parts.each do |prt|
+      str << "--" + boundary + "\r\n"
+      str << prt.to_s + "\r\n"
+    end
+    str << '--' + boundary + "--\r\n"
+    str
+  end
+
+  def to_s
+    str = headers_str + "\r\n\r\n" + content_str
+  end
+end
+
+
+end

data/lib/action_web_service/soap/netHttpClient.rb

@@ -0,0 +1,190 @@
+# SOAP4R - net/http wrapper
+# Copyright (C) 2003  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 'net/http'
+
+
+module SOAP
+
+
+class NetHttpClient
+
+  SSLEnabled = begin
+      require 'net/https'
+      true
+    rescue LoadError
+      false
+    end
+
+  attr_reader :proxy
+  attr_accessor :no_proxy
+  attr_accessor :debug_dev
+  attr_accessor :ssl_config		# ignored for now.
+  attr_accessor :protocol_version	# ignored for now.
+  attr_accessor :connect_timeout
+  attr_accessor :send_timeout           # ignored for now.
+  attr_accessor :receive_timeout
+
+  def initialize(proxy = nil, agent = nil)
+    @proxy = proxy ? URI.parse(proxy) : nil
+    @agent = agent
+    @debug_dev = nil
+    @session_manager = SessionManager.new
+    @no_proxy = @ssl_config = @protocol_version = nil
+    @connect_timeout = @send_timeout = @receive_timeout = nil
+  end
+
+  def test_loopback_response
+    raise NotImplementedError.new("not supported for now")
+  end
+  
+  def proxy=(proxy)
+    if proxy.nil?
+      @proxy = nil
+    else
+      if proxy.is_a?(URI)
+        @proxy = proxy
+      else
+        @proxy = URI.parse(proxy)
+      end
+      if @proxy.scheme == nil or @proxy.scheme.downcase != 'http' or
+	  @proxy.host == nil or @proxy.port == nil
+	raise ArgumentError.new("unsupported proxy `#{proxy}'")
+      end
+    end
+    reset_all
+    @proxy
+  end
+
+  def set_basic_auth(uri, user_id, passwd)
+    # net/http does not handle url.
+    @basic_auth = [user_id, passwd]
+    raise NotImplementedError.new("basic_auth is not supported under soap4r + net/http.")
+  end
+
+  def set_cookie_store(filename)
+    raise NotImplementedError.new
+  end
+
+  def save_cookie_store(filename)
+    raise NotImplementedError.new
+  end
+
+  def reset(url)
+    # no persistent connection.  ignored.
+  end
+
+  def reset_all
+    # no persistent connection.  ignored.
+  end
+
+  def post(url, req_body, header = {})
+    unless url.is_a?(URI)
+      url = URI.parse(url)
+    end
+    extra = header.dup
+    extra['User-Agent'] = @agent if @agent
+    res = start(url) { |http|
+      http.post(url.request_uri, req_body, extra)
+    }
+    Response.new(res)
+  end
+
+  def get_content(url, header = {})
+    unless url.is_a?(URI)
+      url = URI.parse(url)
+    end
+    extra = header.dup
+    extra['User-Agent'] = @agent if @agent
+    res = start(url) { |http|
+	http.get(url.request_uri, extra)
+      }
+    res.body
+  end
+
+private
+
+  def start(url)
+    http = create_connection(url)
+    response = nil
+    http.start { |worker|
+      response = yield(worker)
+      worker.finish
+    }
+    @debug_dev << response.body if @debug_dev
+    response
+  end
+
+  def create_connection(url)
+    proxy_host = proxy_port = nil
+    unless no_proxy?(url)
+      proxy_host = @proxy.host
+      proxy_port = @proxy.port
+    end
+    http = Net::HTTP::Proxy(proxy_host, proxy_port).new(url.host, url.port)
+    if http.respond_to?(:set_debug_output)
+      http.set_debug_output(@debug_dev)
+    end
+    http.open_timeout = @connect_timeout if @connect_timeout
+    http.read_timeout = @receive_timeout if @receive_timeout
+    case url
+    when URI::HTTPS
+      if SSLEnabled
+	http.use_ssl = true
+      else
+	raise RuntimeError.new("Cannot connect to #{url} (OpenSSL is not installed.)")
+      end
+    when URI::HTTP
+      # OK
+    else
+      raise RuntimeError.new("Cannot connect to #{url} (Not HTTP.)")
+    end
+    http
+  end
+
+  NO_PROXY_HOSTS = ['localhost']
+
+  def no_proxy?(uri)
+    if !@proxy or NO_PROXY_HOSTS.include?(uri.host)
+      return true
+    end
+    if @no_proxy
+      @no_proxy.scan(/([^:,]*)(?::(\d+))?/) do |host, port|
+  	if /(\A|\.)#{Regexp.quote(host)}\z/i =~ uri.host &&
+	    (!port || uri.port == port.to_i)
+	  return true
+	end
+      end
+    else
+      false
+    end
+  end
+
+  class SessionManager
+    attr_accessor :connect_timeout
+    attr_accessor :send_timeout
+    attr_accessor :receive_timeout
+  end
+
+  class Response
+    attr_reader :content
+    attr_reader :status
+    attr_reader :reason
+    attr_reader :contenttype
+
+    def initialize(res)
+      @status = res.code.to_i
+      @reason = res.message
+      @contenttype = res['content-type']
+      @content = res.body
+    end
+  end
+end
+
+
+end