kronk 1.8.7 → 1.9.0

data/lib/kronk/multipart.rb

@@ -0,0 +1,82 @@
+class Kronk
+
+  ##
+  # Builder for the body of a multipart request.
+
+  class Multipart
+
+    # An array of parts for the multipart body.
+    attr_reader :parts
+
+    # The separator used between parts.
+    attr_reader :boundary
+
+
+    def initialize boundary
+      @boundary = boundary
+      @parts    = []
+    end
+
+
+    ##
+    # Add a new part to the body.
+
+    def add name, value, headers=nil
+      headers ||= {}
+
+      headers['content-disposition'] = "form-data; name=\"#{name}\""
+
+      if value.respond_to?(:path)
+        headers['content-disposition'] <<
+          "; filename=\"#{File.basename value.path}\""
+
+        headers['Content-Type'] ||= MIME::Types.of(value.path)[0]
+        headers['Content-Type'] &&= headers['Content-Type'].to_s
+      end
+
+      if value.respond_to?(:read)
+        headers['Content-Type']              ||= "application/octet-stream"
+        headers['Content-Transfer-Encoding'] ||= 'binary'
+      end
+
+      parts << [headers, value]
+    end
+
+
+    ##
+    # Convert the instance into a MultipartIO instance.
+
+    def to_io
+      io   = Kronk::MultipartIO.new
+      buff = ""
+
+      parts.each do |(headers, value)|
+        buff << "--#{@boundary}\r\n"
+        buff << "content-disposition: #{headers['content-disposition']}\r\n"
+
+        headers.each do |hname, hvalue|
+          next if hname == 'content-disposition'
+          hvalue = hvalue.to_s.inspect if hvalue.to_s.index ":"
+          buff << "#{hname}: #{hvalue}\r\n"
+        end
+
+        buff << "\r\n"
+
+        if value.respond_to?(:read)
+          io.add buff.dup
+          io.add value
+          buff.replace ""
+        else
+          buff << value.to_s
+        end
+
+        buff << "\r\n"
+      end
+
+      buff << "--#{@boundary}--"
+      io.add buff
+
+      io
+    end
+  end
+end

data/lib/kronk/multipart_io.rb

@@ -0,0 +1,88 @@
+class Kronk
+
+  class MultipartIO
+
+    attr_reader :parts, :curr_part
+
+    def initialize *parts
+      @parts     = []
+      @curr_part = 0
+
+      parts.each do |part|
+        add part
+      end
+    end
+
+
+    def add part
+      if String === part
+        @parts << StringIO.new(part)
+
+      elsif part.respond_to?(:read)
+        @parts << part
+
+      else
+        raise ArgumentError, "Invalid part #{part.inspect}"
+      end
+
+      @curr_part ||= @parts.length - 1
+      @parts.last
+    end
+
+
+    def close
+      @parts.each(&:close)
+      nil
+    end
+
+
+    def read bytes=nil
+      return read_all if bytes.nil?
+      return if @parts.empty? || eof?
+
+      buff = ""
+
+      until @curr_part.nil?
+        bytes = bytes - buff.bytes.count
+        buff << @parts[@curr_part].read(bytes).to_s
+        break if buff.bytes.count >= bytes
+
+        @curr_part += 1
+        @curr_part = nil if @curr_part >= @parts.length
+      end
+
+      return if buff.empty?
+      buff
+    end
+
+
+    def read_all
+      return "" if eof?
+
+      out = @parts[@curr_part..-1].inject("") do |out, curr|
+        @curr_part += 1
+        out << curr.read
+      end
+
+      @curr_part = nil
+      out
+    end
+
+
+    def eof?
+      @curr_part.nil?
+    end
+
+
+    def size
+      total = 0
+
+      @parts.each do |part|
+        return nil unless part.respond_to?(:size) && part.size
+        total += part.size
+      end
+
+      total
+    end
+  end
+end

data/lib/kronk/player.rb

@@ -16,6 +16,7 @@ class Kronk
       klass =
         case type.to_s
         when /^(Player::)?benchmark$/i then Benchmark
+        when /^(Player::)?download$/i  then Download
         when /^(Player::)?stream$/i    then Stream
         when /^(Player::)?suite$/i     then Suite
         when /^(Player::)?tsv$/i       then TSV
@@ -58,7 +59,6 @@ class Kronk
       on(:interrupt){
         interrupt and return if respond_to?(:interrupt)
         complete if respond_to?(:complete)
-        kill
         exit 2
       }
       on(:start){

data/lib/kronk/player/benchmark.rb

@@ -17,16 +17,17 @@ class Kronk
 
     class ResultSet
 
-      attr_accessor :total_time
+      attr_accessor :total_time, :err_count
 
       attr_reader :byterate, :count, :fastest, :precision,
-                  :slowest, :total_bytes, :err_count
+                  :slowest, :total_bytes
 
       def initialize
         @times     = Hash.new(0)
         @count     = 0
         @r5XX      = 0
         @r4XX      = 0
+        @r3XX      = 0
         @err_count = 0
 
         @precision = 3
@@ -49,15 +50,18 @@ class Kronk
         @times[time] += 1
         @count += 1
 
-        @r5XX += 1 if resp.code =~ /^5\d\d$/
-        @r4XX += 1 if resp.code =~ /^4\d\d$/
+        case resp.code[0, 1]
+        when "5" then @r5XX += 1
+        when "4" then @r4XX += 1
+        when "3" then @r3XX += 1
+        end
 
         @slowest = time if !@slowest || @slowest < time
         @fastest = time if !@fastest || @fastest > time
 
         log_req resp.request, time if resp.request
 
-        @total_bytes += resp.raw.bytes.count
+        @total_bytes += resp.total_bytes
 
         @byterate = (@byterate * (@count-1) + resp.byterate) / @count
       end
@@ -68,7 +72,6 @@ class Kronk
         uri.query = nil
         uri = "#{req.http_method} #{uri.to_s}"
 
-        # TODO: Keep the number in @paths to 10.
         @paths[uri] ||= [0, 0]
         pcount = @paths[uri][1] + 1
         @paths[uri][0] = (@paths[uri][0] * @paths[uri][1] + time) / pcount
@@ -78,6 +81,7 @@ class Kronk
 
 
       def deviation
+        return 0 if @count == 0
         return @deviation if @deviation
 
         mdiff = @times.to_a.inject(0) do |sum, (time, count)|
@@ -89,11 +93,13 @@ class Kronk
 
 
       def mean
+        return 0 if @count == 0
         @mean ||= (self.sum / @count).round @precision
       end
 
 
       def median
+        return 0 if @count == 0
         @median ||= ((@slowest + @fastest) / 2).round @precision
       end
 
@@ -127,6 +133,7 @@ class Kronk
 
 
       def req_per_sec
+        return 0 if @count == 0
         (@count / @total_time).round @precision
       end
 
@@ -146,10 +153,23 @@ class Kronk
       end
 
 
+      def clear_caches
+        @percentages  = nil
+        @slowest_reqs = nil
+        @sum          = nil
+        @mean         = nil
+        @median       = nil
+        @deviation    = nil
+      end
+
+
       def to_s
+        clear_caches
+
         out = <<-STR
 
 Completed:     #{@count}
+300s:          #{@r3XX}
 400s:          #{@r4XX}
 500s:          #{@r5XX}
 Errors:        #{@err_count}
@@ -158,11 +178,11 @@ Total Bytes:   #{@total_bytes}
 Transfer Rate: #{self.transfer_rate} Kbytes/sec
 
 Connection Times (ms)
-  Min:       #{self.fastest}
+  Min:       #{self.fastest || 0}
   Mean:      #{self.mean}
   [+/-sd]:   #{self.deviation}
   Median:    #{self.median}
-  Max:       #{self.slowest}
+  Max:       #{self.slowest || 0}
 
 Request Percentages (ms)
    50%    #{self.percentages[50]}
@@ -188,11 +208,15 @@ Avg. Slowest Requests (ms, count)
 
 
     def start
-      @res_count = 0
-      @results   = []
-      @div       = @number / 10 if @number
-      @div       = 100 if !@div || @div < 10
-      puts "Benchmarking..."
+      @interactive = $stdout.isatty
+      @res_count   = 0
+      @results     = [ResultSet.new]
+      @div         = @number / 10 if @number
+      @div         = 100 if !@div || @div < 10
+      @last_print  = Time.now
+      @line_count  = 0
+
+      puts "Benchmarking..." unless @interactive
     end
 
 
@@ -204,11 +228,21 @@ Avg. Slowest Requests (ms, count)
         end
 
         @res_count += 1
-        puts "#{@res_count} requests" if @res_count % @div == 0
+
+        if @interactive
+          render if Time.now - @last_print > 0.5
+        else
+          puts "#{@res_count} requests" if @res_count % @div == 0
+        end
       end
     end
 
 
+    def clear_screen
+      $stdout.print "\e[2K\e[1A" * @line_count
+    end
+
+
     def error err, kronk
       @mutex.synchronize do
         @res_count += 1
@@ -220,32 +254,43 @@ Avg. Slowest Requests (ms, count)
 
 
     def complete
-      puts "Finished!"
-
-      render_head
-      render_body
+      puts "Finished!" unless @interactive
 
+      render
       true
     end
 
 
-    def render_body
-      @results.each{|res| res.total_time = @stop_time - @start_time }
+    def render
+      clear_screen if @interactive
+      out = "#{head}#{body}\n"
+      @line_count = out.to_s.split("\n").length
+      @last_print = Time.now
+      $stdout.print out
+      $stdout.flush
+    end
+
+
+    def body
+      @results.each{|res| res.total_time = Time.now - @start_time }
 
       if @results.length > 1
-        puts Diff.new(@results[0].to_s, @results[1].to_s).formatted
+        Diff.new(@results[0].to_s, @results[1].to_s, :context => false).
+          formatted
       else
-        puts @results.first.to_s
+        @results.first.to_s
       end
     end
 
 
-    def render_head
-      puts <<-STR
+    def head
+      <<-STR
 
 Benchmark Time:      #{(Time.now - @start_time).to_f} sec
 Number of Requests:  #{@count}
 Concurrency:         #{@qps ? "#{@qps} qps" : @concurrency}
+#{"Current Connections: #{Kronk::HTTP.conn_count}\n" if @interactive}\
+Total Connections:   #{Kronk::HTTP.total_conn}
       STR
     end
   end

data/lib/kronk/player/download.rb

@@ -0,0 +1,87 @@
+class Kronk
+
+  ##
+  # Outputs Player results as a list of files.
+  #
+  #   player = Player::Download.new :dir => "foo/bar"
+  #
+  # Note: This output class will not render errors.
+
+  class Player::Download < Player
+
+    # Directory to write the files to.
+    attr_accessor :dir
+
+    def initialize opts={}
+      super
+
+      @counter = 0
+      @counter_mutex = Mutex.new
+
+      require 'fileutils'
+
+      default_dir = File.join Dir.pwd, "kronk-#{Time.now.to_i}"
+      @dir        = File.expand_path(opts[:dir] || default_dir)
+
+      FileUtils.mkdir_p @dir
+    end
+
+
+    def result kronk
+      output, name, ext =
+        if kronk.diff
+          name = make_name kronk.responses[0].uri
+          name = "#{name}-#{make_name kronk.responses[1].uri}"
+          [kronk.diff.formatted, name, "diff"]
+
+        elsif kronk.response
+          name = make_name kronk.response.uri
+          [kronk.response.stringify, name, ext_for(kronk.response)]
+        end
+
+      return unless output && !output.empty?
+
+      filename = nil
+
+      @counter_mutex.synchronize do
+        @counter += 1
+        filename = File.join(@dir, "#{@counter}-#{name}.#{ext}")
+      end
+
+      File.open(filename, "w"){|file| file.write output}
+
+      @mutex.synchronize do
+        $stdout.puts filename
+      end
+    end
+
+
+    def make_name uri
+      return unless uri
+      parts = uri.path.to_s.sub(%r{^/}, "").split("/")
+      parts = parts[-2..-1] || parts
+      parts.join("-").sub(%r{[?.].*$}, "")
+    end
+
+
+    def ext_for resp
+      if will_parse(resp)
+        Kronk.config[:render_lang].to_s == "ruby" ? "rb" : "json"
+
+      elsif resp.stringify_opts[:show_headers]
+        "http"
+
+      else
+        resp.ext
+      end
+    end
+
+
+    def will_parse resp
+      (resp.parser || resp.stringify_opts[:parser] ||
+       (resp.stringify_opts[:no_body] && resp.stringify_opts[:show_headers])) &&
+        !resp.stringify_opts[:raw]
+    end
+  end
+end
+