xmlrpc-streaming 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+	gem "rspec", "~> 2.3.0"
+	gem "bundler", "~> 1.0.0"
+	gem "jeweler", "~> 1.6.4"
+	gem "libxml4r"
+	gem "nokogiri"
+end

data/Gemfile.lock

@@ -0,0 +1,35 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    libxml-ruby (2.2.2)
+    libxml-ruby (2.2.2-x86-mingw32)
+    libxml4r (0.2.6)
+      libxml-ruby (>= 1.1.3)
+    nokogiri (1.5.0)
+    nokogiri (1.5.0-x86-mingw32)
+    rake (0.9.2.2)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  libxml4r
+  nokogiri
+  rspec (~> 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Sal Scotto
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,35 @@
+= xmlrpc-streaming
+
+This package will enhance the built-in XMLRPC client to ruby
+It changes the following:
+* Base64 now accepts an IO object to its constructor
+* The XMLRPC request will now be streamed to the server. This
+  will be a little faster and generate much less garbage. It should
+  also fix issues where large Base64 objects sent to the server can cause out of memory errors
+* Base64 now has a to_io methods that will give access to the underlying data as a IO object
+  note: this is the raw data.
+* set_writer will be ignored if this module has been loaded.
+* the parser will now try the following, nokogiri, libxml and finally fallback to REML
+* This module can be used completely transparently, just require the lib and nothing else needs done
+
+== Usage
+
+require 'xmlrpc-streaming'
+
+.. Normal XMLRPC Code here
+
+== Contributing to xmlrpc-streaming
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Sal Scotto. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "xmlrpc-streaming"
+  gem.homepage = "http://github.com/washu/xmlrpc-streaming"
+  gem.license = "MIT"
+  gem.summary = %Q{Xmlrpc client that uses streaming for binary data}
+  gem.description = %Q{The built in xmlrpc client doesnt handle large binary data well, this client addresses the problem}
+  gem.email = "sal.scotto@gmail.com"
+  gem.authors = ["Sal Scotto"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "xmlrpc-streaming #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/stream_parser_mixin.rb

@@ -0,0 +1,261 @@
+require 'xmlrpc/parser'
+
+module XMLRPC
+  module StreamParserMixin2
+    attr_reader :params
+    attr_reader :method_name
+    attr_reader :fault
+    attr_accessor :use_streams
+    def initialize(*a)
+      super(*a)
+      @params = []
+      @values = []
+      @val_stack = []
+
+      @names = []
+      @name = []
+
+      @structs = []
+      @struct = {}
+
+      @method_name = nil
+      @fault = nil
+
+      @data = nil
+      @working_tag = nil
+    end
+
+    def startElement(name, attrs=[])
+      @data = nil
+      case name
+      when "value"
+        @value = nil
+      when "nil"
+        raise "wrong/unknown XML-RPC type 'nil'" unless Config::ENABLE_NIL_PARSER
+        @value = :nil
+      when "array"
+        @val_stack << @values
+        @values = []
+      when "struct"
+        @names << @name
+        @name = []
+        @structs << @struct
+        @struct = {}
+      end
+      @working_tag = name
+    end
+
+    def endElement(name)
+      @data ||= ""
+      if name.eql?("base64") and @use_streams
+        # Decode the file data into a new temp file and set the response as a stream
+        # the caller will get an IO Object as a result. Only do this if we flagged ourselves
+        # as 'recevied an io stream'
+      elsif name.eql?("base64") and not @use_streams
+        @data = Convert.base64(@data)
+      end  
+      case name
+      when "string"
+        @value = @data
+      when "i4", "int"
+        @value = Convert.int(@data)
+      when "boolean"
+        @value = Convert.boolean(@data)
+      when "double"
+        @value = Convert.double(@data)
+      when "dateTime.iso8601"
+        @value = Convert.dateTime(@data)
+      when "base64"
+        @value = @data
+      when "value"
+        @value = @data if @value.nil?
+        @values << (@value == :nil ? nil : @value)
+      when "array"
+        @value = @values
+        @values = @val_stack.pop
+      when "struct"
+        @value = Convert.struct(@struct)
+
+        @name = @names.pop
+        @struct = @structs.pop
+      when "name"
+        @name[0] = @data
+      when "member"
+        @struct[@name[0]] = @values.pop
+
+      when "param"
+        @params << @values[0]
+        @values = []
+
+      when "fault"
+        @fault = Convert.fault(@values[0])
+
+      when "methodName"
+        @method_name = @data
+      end
+
+      @data = nil
+    end
+
+    def character(data)
+      if @data
+        @data << data
+      else
+        if @working_tag.eql?("base64")
+          @data = Tempfile.new('xmlrpc-stream-base64-data')
+          @data.binmode
+        else
+          @data = data
+        end
+      end
+    end
+  end # module StreamParserMixin
+  
+  module XMLParser
+    class AbstractStreamParser2
+      def use_streams=(arg)
+        @use_streams = arg
+      end
+      def parseMethodResponse(str)
+        parser = @parser_class.new
+        parser.user_streams = @use_streams
+        parser.parse(str)
+        raise "No valid method response!" if parser.method_name != nil
+        if parser.fault != nil
+          # is a fault structure
+          [false, parser.fault]
+        else
+          # is a normal return value
+          raise "Missing return value!" if parser.params.size == 0
+          raise "Too many return values. Only one allowed!" if parser.params.size > 1
+          [true, parser.params[0]]
+        end
+      end
+
+      def parseMethodCall(str)
+        parser = @parser_class.new
+        parser.user_streams = @use_streams
+        parser.parse(str)
+        raise "No valid method call - missing method name!" if parser.method_name.nil?
+        [parser.method_name, parser.params]
+      end
+    end
+  end
+  
+  module XMLParser
+    class NokogiriStreamParser < AbstractStreamParser2
+      def initialize
+        require 'nokogiri'        
+        @parser_class = Class.new(Nokogiri::XML::SAX::Document) do
+          include StreamParserMixin2
+          alias :cdata_block :character
+          alias :characters :character
+          alias :end_element :endElement
+          def start_element(name,attrs)
+            startElement(name)
+          end
+          def start_element_namespace(name, attrs = nil, prefix = nil, uri = nil, ns = nil)
+            startElement(name)
+          end
+          def end_element_namespace(name, prefix = nil, uri = nil) 
+            endElement(name)
+          end
+          def method_missing(*a)
+          end
+          def parse(str)
+            parser = Nokogiri::XML::SAX::Parser.new(self)
+            parser.parse(str)
+          end
+        end
+      end
+    end
+  end
+  
+  module XMLParser
+    class LibXmlStreamParser < AbstractStreamParser2
+      def initialize()
+        require "libxml"
+        @parser_class = StreamCallback
+      end
+      class StreamCallback
+        include StreamParserMixin2
+        Entities = {
+          "lt"   => "<",
+          "gt"   => ">",
+          "amp"  => "&",
+          "quot" => '"',
+          "apos" => "'"
+        }
+        
+        def on_cdata_block(cdata) 
+          character(cdata)
+        end
+        
+        def on_characters(chars)
+          character(chars)
+        end
+                
+        def on_reference (name) 
+          str = Entities[name]
+          if str
+            character(str)
+          else
+            raise "Unknown Entity"
+          end
+        end
+        
+        def on_start_element_ns (name, attributes, prefix, uri, namespaces) 
+          startElement(name)
+        end
+
+        def on_end_element_ns(name, prefix, uri)
+          endElement(name)
+        end         
+        
+        def method_missing(*a)
+        end
+
+        def parse(str)
+          parser = LibXML::XML::SaxParser.io(str)
+          parser.extend(LibXML::XML::SaxParser::Callbacks)
+          parser.callbacks = self
+          parser.parse
+        end
+      end
+    end
+  end
+  
+  module XMLParser
+    class REXMLStreamParser2 < AbstractStreamParser2
+      def initialize()
+        require "rexml/document"
+        @parser_class = StreamListener
+      end
+      class StreamListener
+        include StreamParserMixin2
+
+        alias :tag_start :startElement
+        alias :tag_end :endElement
+        alias :text :character
+        alias :cdata :character
+
+        def method_missing(*a)
+          # ignore
+        end
+        
+        def parse(str)
+          parser = REXML::Document.parse_stream(str, self)
+        end
+      end
+    end
+  end
+  module XMLParser
+    def self.parser_instance(klass)
+      begin
+        klass.new
+      rescue LoadError => e
+        puts e
+      end
+    end
+  end
+end

data/lib/stream_writer.rb

@@ -0,0 +1,168 @@
+#
+# Stream Writer, will write out the XMLRPC data to an IO object
+#
+
+module XMLRPC
+    class StreamWriter
+        
+        WRITE_BUFFER_SIZE = 33972
+        # Create a write with a given IO
+        def initialize(io)
+          @io = io
+        end
+        def has_streams?
+          @had_a_stream ||= false
+          @had_a_stream
+        end
+        def methodCall(name, *params)
+          @io << '<?xml version="1.0" ?><methodCall><methodName>'
+          @io << name
+          @io << '</methodName><params>'
+          params.each do |param|
+            @io << "<param>"
+            conv2value(param)
+            @io << "</param>"
+          end
+          @io << '</params></methodCall>'
+        end
+        
+        
+        private
+        
+        # escape some text
+        def text(txt)
+          cleaned = txt.dup
+          cleaned.gsub!(/&/, '&amp;')
+          cleaned.gsub!(/</, '&lt;')
+          cleaned.gsub!(/>/, '&gt;')
+          cleaned
+        end
+        
+        # write a tag with value tags around it
+        def write_tag(tag,value)
+          @io << "<value><#{tag}>#{text(value)}</#{tag}></value>"
+        end
+                
+        # write teh tag directly without the value tags
+        def write_elem(tag, value)
+          @io << "<#{tag}>#{text(value)}</#{tag}>"
+        end
+                
+        def write_with_children(tag,sub = nil)
+          @io << "<value><#{tag}>"
+          @io<< "<#{sub}>" if sub
+          yield if block_given?
+          @io<< "</#{sub}>" if sub
+          @io << "</#{tag}></value>" 
+        end
+        
+        # write base64 data to the output stream
+        def write_base64(data_stream)
+          write_with_children "base64" do
+            while (buf = data_stream.read(WRITE_BUFFER_SIZE)) != nil do
+              @io << [buf].pack('m').chop
+            end
+          end
+        end
+        
+        def conv2value(param)
+            case param
+            when Fixnum, Bignum
+              # XML-RPC's int is 32bit int, and Fixnum also may be beyond 32bit
+              if Config::ENABLE_BIGINT
+                write_tag "i4",param.to_s
+              else
+                if param >= -(2**31) and param <= (2**31-1)
+                  write_tag "i4", param.to_s
+                else
+                  raise "Bignum is too big! Must be signed 32-bit integer!"
+                end
+              end
+            when TrueClass, FalseClass
+              write_tag "boolean", param ? "1" : "0"
+
+            when Symbol
+              write_tag "string", param.to_s
+
+            when String
+              write_tag "string", param
+
+            when NilClass
+              @io << "<nil/>" if Config::ENABLE_NIL_CREATE
+              raise "Wrong type NilClass. Not allowed!" unless Config::ENABLE_NIL_CREATE
+
+            when Float
+              write_tag "double", param.to_s
+
+            when Struct
+              write_with_children "struct" do
+                param.members.each do |key|
+                  value = param[key]
+                  @io << "<member>"
+                  write_elem("name",key.to_s)
+                  con2value(value)
+                  @io << "</member>"
+                end
+              end
+
+            when Hash
+              write_with_children "struct" do
+                param.each do |key, value|
+                  @io << "<member>"
+                  write_elem("name", key.to_s)
+                  conv2value(value)
+                  @io << "</member>"
+                end
+              end
+
+            when Array
+              write_with_children "array","data" do
+                param.each do |elem|
+                  conv2value(elem)
+                end
+              end
+
+            when Time, Date, ::DateTime
+              write_tag "dateTime.iso8601", param.strftime("%Y%m%dT%H:%M:%S")
+
+            when XMLRPC::DateTime
+              write_tag "dateTime.iso8601",format("%.4d%02d%02dT%02d:%02d:%02d", *param.to_a)
+
+            when XMLRPC::Base64
+              write_base64(param.to_io)
+              
+            when IO, respond_to?(:read)
+              @had_a_stream = true
+              write_base64(param)
+
+            else
+              if XMLRPC::Config::ENABLE_MARSHALLING and param.class.included_modules.include? XMLRPC::Marshallable
+                # convert Ruby object into Hash
+                ret = {"___class___" => param.class.name}
+                param.instance_variables.each  do |v|
+                  name = v[1..-1]
+                  val = param.instance_variable_get(v)
+
+                  if val.nil?
+                    ret[name] = val if XLMRPC::Config::ENABLE_NIL_CREATE
+                  else
+                    ret[name] = val
+                  end
+                end
+                return conv2value(ret)
+              else
+                ok, pa = wrong_type(param)
+                if ok
+                  return conv2value(pa)
+                else
+                  raise "Wrong type!"
+                end
+              end
+            end
+        end
+
+        def wrong_type(value)
+          false
+        end
+    end
+end

data/lib/xmlrpc-streaming.rb

@@ -0,0 +1,256 @@
+=begin
+= xmlrpc-streaming.rb
+Copyright (C) 2011 by Sal Scotto (sal.scotto@gmail.com)
+Released under the same terms of  license as Ruby.
+
+== XMLRPC::Client License
+We override several key methods of the original XMLRPC::Client by Michael Neumann
+Copyright (C) 2001, 2002, 2003 by Michael Neumann (mneumann@ntecs.de)
+Released under the same terms of  license as Ruby.
+
+== Description
+This class extends a few key methods of the XMLRPC::Client library 
+it treats base64 data differently. It allows you pass in any object
+that supports a #read(bytes) method to be used instead of having to provide a
+base64 encoded string for binary data. The problem it is trying to solve
+is the case of sending a large binary blob over xmlrpc, which consumes large
+amounts of ram to not only encoded and represent, but also to decode.
+To use transparently. Please NOTE, we this module overwrite ignores the parser
+settings in the config. We first try Nokogiri, if that isnt available we then
+try LibXML, if that fails we fallback to REML. In any case we only
+use StreamingParsers
+
+require 'xmlrpc/client'
+require 'xmlrpc-streaming'
+
+== Instance Methods
+--- XMLRPC::Client#set_debug( output_stream)
+    Invokes the call with debug output sent to the provided stream
+
+== Differences
+Any place you would normally get or send an XMLRPC::Base64 object
+you can instead subsitute an object that supports #read(bytes) in it places
+=end
+
+
+require 'stringio'
+require 'rbconfig'
+require 'xmlrpc/base64'
+require 'xmlrpc/client'
+require 'tempfile'
+require 'stream_writer'
+require 'stream_parser_mixin'
+
+# Add a to_io method to existing base64 class
+module XMLRPC
+  class Base64
+    
+    def initialize(str, state = :dec)
+      @state = state
+      @str = nil
+      @stream = false
+      case state
+      when :enc
+        if str.respond_to?(:read)
+          @str = str
+          @stream = true
+        else
+          @str = XMLRPC::Base64.decode(str)
+        end
+      when :dec
+        @str = str
+        if str.respond_to?(:read)
+          @stream = true
+        end        
+      else
+        raise ArgumentError, "wrong argument; either :enc or :dec"
+      end
+    end
+    
+    # Create an IO stream out of the data if it isnt a stream already
+    # side effect: will call rewind on the stream if it is rewindable
+    def to_io
+      if @stream
+        if @str.respond_to?(:rewind)
+          @str.rewind
+        end
+        @str
+      else
+        StringIO.new(@str)
+      end
+    end
+    
+    # Get the decoded string
+    # if theunderlying string is a stream it will rewind before the call
+    def decoded
+      if @stream
+        if @str.respond_to?(:rewind)
+          @str.rewind
+        end
+        @str.read
+      else
+        @str
+      end
+    end
+    
+    # Get the encoded string
+    # if the underlying string is a stream will call rewind first
+    def encoded
+      if @stream
+        if @str.respond_to?(:rewind)
+          @str.rewind
+        end
+        Base64.encode(@str.read)
+      else
+        Base64.encode(@str)
+      end
+    end
+  end
+end
+
+module XMLRPC
+  class Client
+    
+=begin
+    set_debug_stream stream
+    will enable HTTP debuggin to the passed in stream
+=end
+    def set_debug_stream(stream)
+      @debug_stream = stream
+    end
+    
+    def call2_async(method, *args)
+      data = do_rpc(true,method,*args)
+      parser().parseMethodResponse(data)
+    end
+    
+    def call2(method, *args)
+      data = do_rpc(false,method,*args)
+      parser().parseMethodResponse(data)
+    end
+    
+    private
+    
+    # Stream our Request over to the server and save the results in a tempfile
+    def post_request(client,path,header,request_file,sink)
+      # Post via stream
+      req = Net::HTTP::Post.new(path,header)
+      req.body_stream = request_file
+      sink.binmode
+      resp = client.request(req) do |res|
+        res.read_body do |b|
+          sink.write(b)
+        end
+        sink.rewind
+        sink.size
+        sink
+      end
+      resp
+    end
+    
+    def do_rpc(async,method,*args)
+      header = {
+       "User-Agent"     =>  USER_AGENT,
+       "Content-Type"   => "text/xml; charset=utf-8",
+       "Connection"     => (async ? "close" : "keep-alive")
+      }
+      header["Cookie"] = @cookie        if @cookie
+      header.update(@http_header_extra) if @http_header_extra
+      if @auth != nil
+        # add authorization header
+        header["Authorization"] = @auth
+      end
+      resp = nil
+      @http_last_response = nil
+
+      # Construct the request data
+      request_message = Tempfile.new('xmlrpc-stream-request')
+      data = Tempfile.new("xmlrpc-response-body")
+      # Use the streamwrite to write the temp file
+      writer = StreamWriter.new(request_message)
+      writer.methodCall(method,*args)
+      libxmlparser = nil
+	  unless RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ 	  
+		libxmlparser = XMLRPC::XMLParser.parser_instance XMLRPC::XMLParser::LibXmlStreamParser
+	  end
+      nokogiri = XMLRPC::XMLParser.parser_instance XMLRPC::XMLParser::NokogiriStreamParser
+      if nokogiri
+        set_parser(nokogiri)
+      elsif libxmlparser
+        set_parser(libxmlparser)
+      else # couldnt load one of the other parser so use REXML
+        set_parser(XMLParser::REXMLStreamParser2.new)
+      end
+      @parser.use_streams = writer.has_streams?
+      request_message.close
+      content_length = request_message.size
+      request_message.open
+      # get the data size of the request
+      header["Content-Length"] = content_length.to_s
+
+      # temp garbage will grow but GC will handle it over the course of 
+      # the download/upload so you shouldnt get alocation errors with big files
+
+      resp = nil
+      if async
+        # use a new HTTP object for each call
+        Net::HTTP.version_1_2
+        http = Net::HTTP.new(@host, @port, @proxy_host, @proxy_port)
+        http.use_ssl = @use_ssl if @use_ssl
+        http.read_timeout = @timeout
+        http.open_timeout = @timeout
+        http.set_debug_output @debug_stream if @debug_stream
+        http.start {
+          resp = post_request(http,@path,header,request_message,data)
+        }
+      else
+        @http.set_debug_output @debug_stream if @debug_stream
+        @http.start if not @http.started?
+        resp = post_request(@http,@path,header,request_message,data)
+      end
+      
+
+      @http_last_response = resp
+      
+      if resp.code == "401"
+        # Authorization Required
+        data.unlink
+        raise "Authorization failed.\nHTTP-Error: #{resp.code} #{resp.message}"
+      elsif resp.code[0,1] != "2"
+        data.unlink
+        raise "HTTP-Error: #{resp.code} #{resp.message}"
+      end
+      
+      ct = parse_content_type(resp["Content-Type"]).first
+      # Some implmentations return application/xml, for faults so lets allow 
+      # them for poor implmentations of servers
+      if ct !~ /\/xml$/
+        data.unlink
+        raise "Wrong content-type (received '#{ct}' but expected 'text/xml') *Use set_debug_stream for details"
+      end
+      
+      expected = resp["Content-Length"] || "<unknown>"
+      if data.nil? or data.size == 0
+        s = data.size
+        data.unlink
+        raise "Wrong size. Was #{s}, should be #{expected} #{data.read}"
+      elsif expected != "<unknown>" and expected.to_i != data.size and resp["Transfer-Encoding"].nil?
+        s = data.size
+		data.unlink
+		raise "Wrong size. Was #{s}, should be #{expected} #{data.read}"
+      end
+      
+      # Copy any cookies sent
+      set_cookies = resp.get_fields("Set-Cookie")
+      if set_cookies and !set_cookies.empty?
+        require 'webrick/cookie'
+        @cookie = set_cookies.collect do |set_cookie|
+          cookie = WEBrick::Cookie.parse_set_cookie(set_cookie)
+          WEBrick::Cookie.new(cookie.name, cookie.value).to_s
+        end.join("; ")
+      end
+      # Return the TempFile
+      return data
+    end
+  end  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'xmlrpc-streaming'
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec::Matchers.define :answer_to do |method|
+  match do |obj|
+    obj.respond_to?(method)
+  end
+end
+  
+RSpec.configure do |config| 
+  
+end

data/spec/xmlrpc-streaming_spec.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "XmlrpcStreaming" do
+  
+  it "should create an instance with has values" do
+    client = XMLRPC::Client.new2 "http://me@test.com/RPC2"
+    client.user.should == "me"
+  end
+  
+  it "should send a body async" do
+    client = XMLRPC::Client.new2 "http://time.xmlrpc.com/RPC2"
+    proxy = client.proxy_async("currentTime")
+    t = proxy.getCurrentTime.to_time
+    t.should_not  == Time.now
+  end
+  it "should send a body sync" do
+    client = XMLRPC::Client.new2 "http://time.xmlrpc.com/RPC2"
+    proxy = client.proxy("currentTime")
+    proxy.getCurrentTime.to_time.should_not == Time.now
+  end
+  
+  it "should add a to_io method to base64 class" do
+    base64 = XMLRPC::Base64.new("dkjfkdjhfkdjhfkdhfkjdhkj")
+    base64.to_io.should answer_to(:read)
+  end
+  
+  it "should add a base64 initializer that handles IO objects" do
+    base64 = XMLRPC::Base64.new(File.open(File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')))
+    base64.should_not be_nil
+  end
+  
+  it "should set base64 to_io to return an IO object when given one" do
+    base64 = XMLRPC::Base64.new(File.open(File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb')))
+    base64.to_io.should be_kind_of(IO)
+  end
+  
+  it "should call wordpress for testing" do
+    client = XMLRPC::Client.new2 "http://salsxmltest.wordpress.com/xmlrpc.php"
+    m = client.call "wp.getUsersBlogs", "washu214", "abc123", File.open(File.expand_path(File.dirname(__FILE__) + '/spec_helper.rb'))
+    m.should_not be_empty
+  end
+  
+  it "should upload a base64 object to wordpress" do
+    pending("Create a blog post with a large image")
+    #blogid 28060656
+    #https://salsxmltest.wordpress.com/xmlrpc.php
+  end
+
+  it "should encode data the same as the original encoder" do
+    creater = XMLRPC::Create.new
+    io_block = ''
+    streamer = XMLRPC::StreamWriter.new io_block
+    doc = creater.methodCall "test", [1,2,3], { :key=> 1, :d => 'v', :x => ['a','b'] }
+    # Strip the \n off of the document
+    doc.chop!
+    streamer.methodCall "test", [1,2,3], { :key=> 1, :d => 'v', :x => ['a','b'] }
+    io_block.should == doc
+  end
+
+  it "should encode data the same as the original with a time object" do
+    creater = XMLRPC::Create.new
+    io_block = ''
+    streamer = XMLRPC::StreamWriter.new io_block
+    doc = creater.methodCall "test", Time.now
+    # Strip the \n off of the document
+    doc.chop!
+    streamer.methodCall "test", Time.now
+    io_block.should == doc
+  end
+
+  it "should encode data the same as the original with a Date object" do
+    creater = XMLRPC::Create.new
+    io_block = ''
+    streamer = XMLRPC::StreamWriter.new io_block
+    doc = creater.methodCall "test", Date.today
+    # Strip the \n off of the document
+    doc.chop!
+    streamer.methodCall "test", Date.today
+    io_block.should == doc
+  end
+
+  it "should encode data the same as the original with a Marshalable object" do
+    klass = Class.new do
+      include XMLRPC::Marshallable
+      attr_accessor :name, :date
+    end
+    Object.const_set 'Testable', klass
+    creater = XMLRPC::Create.new
+    io_block = ''
+    streamer = XMLRPC::StreamWriter.new io_block
+    doc = creater.methodCall "test", Testable.new
+    # Strip the \n off of the document
+    doc.chop!
+    streamer.methodCall "test", Testable.new
+    io_block.should == doc
+  end
+
+  it "should encode data the same as the original with a Base64 object" do
+    creater = XMLRPC::Create.new
+    io_block = ''
+    b64 = XMLRPC::Base64.new 'testing junk'
+    streamer = XMLRPC::StreamWriter.new io_block
+    doc = creater.methodCall "test", b64
+    # Strip the \n out as the original will include a \n after a base64 object
+    doc.gsub!(/\n/,'')
+    streamer.methodCall "test", b64
+    io_block.should == doc
+  end  
+
+  it "should encode data the same as the original with a Base64 object" do
+    creater = XMLRPC::Create.new
+    io_block = ''
+    b64 = XMLRPC::Base64.new StringIO.new 'testing junk'
+    streamer = XMLRPC::StreamWriter.new io_block
+    doc = creater.methodCall "test", b64
+    # Strip the \n out as the original will include a \n after a base64 object
+    doc.gsub!(/\n/,'')
+    streamer.methodCall "test", b64
+    io_block.should == doc
+  end  
+  
+  it "should upload a large binary object and not run out of memory" do
+    pending("add large file upload test")
+  end
+  
+end

data/xmlrpc-streaming.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{xmlrpc-streaming}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Sal Scotto"]
+  s.date = %q{2011-11-15}
+  s.description = %q{The built in xmlrpc client doesnt handle large binary data well, this client addresses the problem}
+  s.email = %q{sal.scotto@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/stream_parser_mixin.rb",
+    "lib/stream_writer.rb",
+    "lib/xmlrpc-streaming.rb",
+    "spec/spec_helper.rb",
+    "spec/xmlrpc-streaming_spec.rb",
+    "xmlrpc-streaming.gemspec"
+  ]
+  s.homepage = %q{http://github.com/washu/xmlrpc-streaming}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.7.2}
+  s.summary = %q{Xmlrpc client that uses streaming for binary data}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_development_dependency(%q<libxml4r>, [">= 0"])
+      s.add_development_dependency(%q<nokogiri>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+      s.add_dependency(%q<libxml4r>, [">= 0"])
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    s.add_dependency(%q<libxml4r>, [">= 0"])
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: xmlrpc-streaming
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Sal Scotto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &24667536 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *24667536
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &24667200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *24667200
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &24666864 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *24666864
+- !ruby/object:Gem::Dependency
+  name: libxml4r
+  requirement: &24666564 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *24666564
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &24666264 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *24666264
+description: The built in xmlrpc client doesnt handle large binary data well, this
+  client addresses the problem
+email: sal.scotto@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/stream_parser_mixin.rb
+- lib/stream_writer.rb
+- lib/xmlrpc-streaming.rb
+- spec/spec_helper.rb
+- spec/xmlrpc-streaming_spec.rb
+- xmlrpc-streaming.gemspec
+homepage: http://github.com/washu/xmlrpc-streaming
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -927155007
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Xmlrpc client that uses streaming for binary data
+test_files: []