kronk 1.8.7 → 1.9.0

data/lib/kronk/player/suite.rb

@@ -15,7 +15,7 @@ class Kronk
           @stop_time = Time.now
           @mutex.synchronize do
             render
-            $stdout.puts "Elapsed:  #{(Time.now - @start_time).round 3}s"
+            $stdout.puts "Elapsed:       #{(Time.now - @start_time).round 3}s"
 
             req = @current.responses[-1].request ||
                   @current.responses[0].request  if @current
@@ -24,7 +24,8 @@ class Kronk
               meth = req.http_method
               path = req.uri.request_uri
               time = req.response.time.round 3
-              $stdout.puts "Current Req: #{meth} #{path} (#{time}s)"
+              $stdout.puts "Current Conns: #{Kronk::HTTP.conn_count}"
+              $stdout.puts "Current Req:   #{meth} #{path} (#{time}s)"
             end
           end
         end
@@ -40,8 +41,11 @@ class Kronk
           text   = diff_text kronk if status == "F"
           time   =
             (kronk.responses[0].time.to_f + kronk.responses[1].time.to_f) / 2
+          ctime  =
+            (kronk.responses[0].conn_time.to_f +
+              kronk.responses[1].conn_time.to_f) / 2
 
-          [status, time, text]
+          [status, time, ctime, text]
 
         elsif kronk.response
           begin
@@ -54,7 +58,7 @@ class Kronk
 
           status = "F"             if !kronk.response.success?
           text   = resp_text kronk if status == "F"
-          [status, kronk.response.time, text]
+          [status, kronk.response.time, kronk.response.conn_time, text]
         end
 
       @mutex.synchronize do
@@ -69,7 +73,7 @@ class Kronk
 
     def error err, kronk=nil
       status = "E"
-      result = [status, 0, error_text(err, kronk)]
+      result = [status, 0, 0, error_text(err, kronk)]
       @mutex.synchronize{ @results << result }
 
       $stdout << status
@@ -87,15 +91,17 @@ class Kronk
     def render
       player_time   = @stop_time - @start_time
       total_time    = 0
+      total_ctime   = 0
       bad_count     = 0
       failure_count = 0
       error_count   = 0
       err_buffer    = ""
 
-      @results.each do |(status, time, text)|
+      @results.each do |(status, time, ctime, text)|
         case status
         when "F"
           total_time    += time.to_f
+          total_ctime   += ctime.to_f
           bad_count     += 1
           failure_count += 1
           err_buffer << "\n  #{bad_count}) Failure:\n#{text}"
@@ -106,24 +112,30 @@ class Kronk
           err_buffer << "\n  #{bad_count}) Error:\n#{text}"
 
         else
-          total_time += time.to_f
+          total_time  += time.to_f
+          total_ctime += ctime.to_f
         end
       end
 
       non_error_count = @results.length - error_count
 
-      avg_time = non_error_count > 0 ?
+      avg_time  = non_error_count > 0 ?
                   ((total_time / non_error_count)* 1000).round(3)  : "n/a "
 
-      avg_qps  = non_error_count > 0 ?
+      avg_ctime = non_error_count > 0 ?
+                  ((total_ctime / non_error_count)* 1000).round(3)  : "n/a "
+
+      avg_qps   = non_error_count > 0 ?
                   (non_error_count / player_time).round(3) : "n/a"
 
       $stderr.puts err_buffer unless err_buffer.empty?
       $stdout.puts "\n#{@results.length} cases, " +
                    "#{failure_count} failures, #{error_count} errors"
 
-      $stdout.puts "Avg Time: #{avg_time}ms"
-      $stdout.puts "Avg QPS:  #{avg_qps}"
+      $stdout.puts "Total Conns:   #{Kronk::HTTP.total_conn}"
+      $stdout.puts "Avg Conn Time: #{avg_ctime}ms"
+      $stdout.puts "Avg Time:      #{avg_time}ms"
+      $stdout.puts "Avg QPS:       #{avg_qps}"
 
       return bad_count == 0
     end

data/lib/kronk/request.rb

@@ -13,17 +13,18 @@ class Kronk
     REQUEST_LINE_MATCHER =
  %r{(?:^|[\s'"])(?:([a-z]+)\s)?(?:(https?://[^/]+)(/[^\s'";]*)?|(/[^\s'";]*))}i
 
+
     ##
     # Creates a query string from data.
 
-    def self.build_query data, param=nil
+    def self.build_query data, param=nil, &block
       return data.to_s unless param || Hash === data
 
       case data
       when Array
         out = data.map do |value|
           key = "#{param}[]"
-          build_query value, key
+          build_query value, key, &block
         end
 
         out.join "&"
@@ -31,12 +32,13 @@ class Kronk
       when Hash
         out = data.map do |key, value|
           key = param.nil? ? key : "#{param}[#{key}]"
-          build_query value, key
+          build_query value, key, &block
         end
 
         out.join "&"
 
       else
+        yield param.to_s, data if block_given?
         "#{param}=#{data}"
       end
     end
@@ -193,7 +195,11 @@ class Kronk
 
 
     class << self
-      %w{get post put delete trace head options}.each do |name|
+      # The boundary to use for multipart requests; default: AaB03x
+      attr_accessor :multipart_boundary
+
+
+      %w{GET POST PUT PATCH DELETE TRACE HEAD OPTIONS}.each do |name|
         class_eval <<-"END"
           def #{name} uri, opts={}, &block
             opts[:http_method] = "#{name}"
@@ -203,10 +209,12 @@ class Kronk
       end
     end
 
+    self.multipart_boundary = 'AaB03x'
+
 
     attr_accessor :headers, :proxy, :response, :timeout
 
-    attr_reader :body, :http_method, :uri, :use_cookies
+    attr_reader :body, :http_method, :proxy, :uri, :use_cookies
 
     ##
     # Build an http request to the given uri and return a Response instance.
@@ -231,7 +239,6 @@ class Kronk
       @connection = nil
       @response   = nil
       @body       = nil
-      @_req       = nil
 
       @headers = opts[:headers] || {}
 
@@ -241,18 +248,24 @@ class Kronk
       ].flatten.compact.uniq.join(",")
       @headers.delete "Accept-Encoding" if @headers["Accept-Encoding"].empty?
 
+      @headers['Connection'] ||= 'Keep-Alive'
+
       @timeout = opts[:timeout] || Kronk.config[:timeout]
 
       @uri = self.class.build_uri uri, opts
 
-      @proxy = opts[:proxy] || {}
-      @proxy = {:host => @proxy} unless Hash === @proxy
-
+      self.proxy = opts[:proxy]
 
       if opts[:file]
-        self.body = File.open(opts[:file], 'rb')
+        self.body = opts[:file].respond_to?(:read) ?
+                      opts[:file] : File.open(opts[:file], 'rb')
+
+      elsif opts[:form_upload]
+        self.body = build_multipart opts
+
       elsif opts[:form]
         self.form_data = opts[:form]
+
       elsif opts[:data]
         self.body = opts[:data]
       end
@@ -284,54 +297,47 @@ class Kronk
 
 
     ##
-    # Assign request body. Supports String, Hash, and IO.
+    # Assign request body. Supports String, Hash, and IO. Will attempt to
+    # correctly assing the Content-Type and Transfer-Encoding headers.
 
     def body= data
-      case data
-      when Hash
-        self.form_data = data
+      if data.respond_to?(:read) || Kronk::Multipart === data
+        ctype = "application/binary"
 
-      when String
-        dont_chunk!
-        @body = data
+        if data.respond_to?(:path)
+          types = MIME::Types.of File.extname(data.path.to_s)[1..-1].to_s
+          ctype = types[0].to_s unless types.empty?
 
-      else
-        if data.respond_to?(:read)
-          ext   = File.extname(data.path.to_s)[1..-1] if data.respond_to?(:path)
-          ext ||= "binary"
+        elsif Kronk::Multipart === data
+          ctype = "multipart/form-data, boundary=#{data.boundary}"
+        end
 
-          @headers['Content-Type'] = "application/#{ext}"
+        @headers['Content-Type'] = ctype
 
-          @body = data
-        else
-          dont_chunk!
-          @body = data.to_s
-        end
-      end
+        @body = data
+
+      elsif Hash === data
+        self.form_data = data
 
-      @headers['Content-Length'] = @body.size.to_s if @body.respond_to?(:size)
-      @headers['Transfer-Encoding'] = 'chunked' if !@headers['Content-Length']
+      else
+        @body = data.to_s
+      end
 
       @body
     end
 
 
     ##
-    # Reference to the HTTP connection instance.
+    # Retrieve or create an HTTP connection instance.
 
     def connection
-      return @connection if @connection
-      http_class = http_proxy @proxy[:host], @proxy
+      conn = Kronk::HTTP.new @uri.host, @uri.port,
+               :proxy => self.proxy,
+               :ssl   => !!(@uri.scheme =~ /^https$/)
 
-      @connection = http_class.new @uri.host, @uri.port
-      @connection.open_timeout = @connection.read_timeout = @timeout if @timeout
+      conn.open_timeout = conn.read_timeout = @timeout if @timeout
 
-      if @uri.scheme =~ /^https$/
-        require 'net/https'
-        @connection.use_ssl = true
-      end
-
-      @connection
+      conn
     end
 
 
@@ -347,12 +353,28 @@ class Kronk
     # Assigns body of the request with form headers.
 
     def form_data= data
-      dont_chunk!
       @headers['Content-Type'] = "application/x-www-form-urlencoded"
       @body = self.class.build_query data
     end
 
 
+    ##
+    # Assign proxy options.
+
+    def proxy= prox_opts
+      @proxy = {}
+
+      if prox_opts && !prox_opts.empty?
+        @proxy = prox_opts
+        @proxy = {:host => @proxy.to_s} unless Hash === @proxy
+        @proxy[:host], port = @proxy[:host].split ":"
+        @proxy[:port] ||= port || 8080
+      end
+
+      @proxy
+    end
+
+
     ##
     # Assigns the http method.
 
@@ -422,18 +444,17 @@ class Kronk
     # Options are passed directly to the Kronk::Response constructor.
 
     def retrieve opts={}, &block
-      start_time = nil
-      opts = opts.merge :request => self
+      start_time = Time.now
 
-      @response = connection.start do |http|
-        start_time = Time.now
-        res = http.request http_request, nil, opts, &block
-        res.body # make sure to read the full body from io
-        res.time    = Time.now - start_time
-        res.request = self
-        res
+      @response = stream opts
+
+      if block_given?
+        block = lambda{|chunk| yield @response, chunk }
       end
 
+      @response.body(&block) # make sure to read the full body from io
+      @response.time = Time.now - start_time - @response.conn_time
+
       @response
     end
 
@@ -448,12 +469,26 @@ class Kronk
     #   request.connection.finish
 
     def stream opts={}
-      opts = opts.merge :request => self
-      http = connection.started? ? connection : connection.start
-      @response = http.request http_request, @body, opts
-      @response.request = self
+      retried = false
 
-      @response
+      begin
+        start_time = Time.now
+        conn = connection
+        conn.start unless conn.started?
+        conn_time  = Time.now - start_time
+
+        @response           = conn.request http_request, nil, opts
+        @response.conn_time = conn_time
+        @response.request   = self
+
+        @response
+
+      rescue EOFError, Errno::EPIPE
+        raise if retried
+        @connection = nil
+        retried = true
+        retry
+      end
     end
 
 
@@ -472,8 +507,8 @@ class Kronk
 
       hash[:auth]    = @auth if @auth
       hash[:data]    = @body if @body
-      hash[:headers] = @headers unless @headers.empty?
-      hash[:proxy]   = @proxy   unless @proxy.empty?
+      hash[:headers] = @headers   unless @headers.empty?
+      hash[:proxy]   = self.proxy unless self.proxy.empty?
 
       hash
     end
@@ -481,6 +516,8 @@ class Kronk
 
     ##
     # Returns the raw HTTP request String.
+    # Warning: If the body is an IO instance or a Multipart instance,
+    # the full input will be read.
 
     def to_s
       out = "#{@http_method} #{@uri.request_uri} HTTP/1.1\r\n"
@@ -491,7 +528,14 @@ class Kronk
       end
 
       out << "\r\n"
-      out << @body.to_s
+
+      if @body.respond_to?(:read)
+        out << @body.read
+      elsif Kronk::Multipart === @body
+        out << @body.to_io.read
+      else
+        out << @body.to_s
+      end
     end
 
 
@@ -512,37 +556,60 @@ class Kronk
       req.basic_auth @auth[:username], @auth[:password] if
         @auth && @auth[:username]
 
-      @body.respond_to?(:read) ? req.body_stream = @body : req.body = @body
+      # Stream Multipart
+      if Kronk::Multipart === @body
+        req.body_stream = @body.to_io
+
+      # Stream IO
+      elsif @body.respond_to?(:read)
+        req.body_stream = @body
+
+      else
+        req.body = @body
+      end
+
+      b = req.body || req.body_stream
+
+      if b.respond_to?(:bytesize)
+        req['Content-Length'] = b.bytesize.to_s
+      elsif b.respond_to?(:size) && b.size
+        req['Content-Length'] = b.size.to_s
+      elsif b.nil?
+        req['Content-Length'] = "0"
+      end
+
+      req['Transfer-Encoding'] = 'chunked' if !req['Content-Length']
 
       req
     end
 
 
-    ##
-    # Assign the use of a proxy.
-    # The proxy_opts arg can be a uri String or a Hash with the :address key
-    # and optional :username and :password keys.
+    private
 
-    def http_proxy addr, opts={}
-      return Kronk::HTTP unless addr
 
-      host, port = addr.split ":"
-      port ||= opts[:port] || 8080
+    QUERY_SCANNER = /(?:^|&)([^=&]+)(?:=([^&]+))?/
 
-      user = opts[:username]
-      pass = opts[:password]
+    def build_multipart opts
+      multi = Kronk::Multipart.new self.class.multipart_boundary
 
-      Kronk::Cmd.verbose "Using proxy #{addr}\n" if host && defined?(Cmd)
+      process_query_or_hash(opts[:form]){|name, value| multi.add name, value }
 
-      Kronk::HTTP::Proxy host, port, user, pass
-    end
+      process_query_or_hash(opts[:form_upload]) do |name, value|
+        value = File.open(value, 'rb') unless
+          value.respond_to?(:read)
+        multi.add name, value
+      end
 
-    private
+      multi
+    end
 
 
-    def dont_chunk!
-      @headers.delete('Transfer-Encoding') if
-        @headers['Transfer-Encoding'].to_s.downcase == 'chunked'
+    def process_query_or_hash qr, &block
+      if Hash === qr
+        self.class.build_query(qr){|name, value| yield name, value }
+      else
+        qr.to_s.scan(QUERY_SCANNER){|(name, value)| yield name, value }
+      end
     end