kronk 1.7.8 → 1.8.0

data/lib/kronk/constants.rb

@@ -1,19 +1,19 @@
 class Kronk
 
   # Generic Request exception.
-  class Exception < ::Exception; end
+  class Error < ::StandardError; end
 
   # Raised when parsing fails.
-  class ParserError < Exception; end
+  class ParserError < Error; end
 
   # Raised when the URI was not resolvable.
-  class NotFoundError < Exception; end
+  class NotFoundError < Error; end
 
   # Raised when HTTP times out.
-  class TimeoutError < Exception; end
+  class TimeoutError < Error; end
 
   # Raised when a missing (but non-mandatory) dependency can't be loaded.
-  class MissingDependency < Exception; end
+  class MissingDependency < Error; end
 
 
   # Config directory.
@@ -80,7 +80,6 @@ class Kronk
 
   # Default config to use.
   DEFAULT_CONFIG = {
-    :async          => 'auto',
     :content_types  => DEFAULT_CONTENT_TYPES.dup,
     :cache_file     => DEFAULT_CACHE_FILE,
     :context        => 3,

data/lib/kronk/diff.rb

@@ -96,6 +96,7 @@ class Kronk
           @meta.last[0] = str1.meta[0] if str1.respond_to?(:meta)
           @meta.last[1] = str2.meta[0] if str2.respond_to?(:meta)
         end
+
         diff_ary.concat arr1[c[1], c[0]]
 
         last_i1 = c[1] + c[0]
@@ -161,8 +162,7 @@ class Kronk
 
       arr2_map = {}
       arr2.each_with_index do |line, j|
-        arr2_map[line] ||= []
-        arr2_map[line] << j
+        (arr2_map[line] ||= []) << j
       end
 
       arr1.each_with_index do |line, i|
@@ -184,14 +184,7 @@ class Kronk
           end
 
           len = j - start_j
-
-          sequences[len] ||= []
-          sequences[len] << [len, i, start_j]
-
-          if len > 1
-            sequences[len-1] ||= []
-            sequences[len-1] << [(len-1), i, start_j]
-          end
+          (sequences[len] ||= []) << [len, i, start_j]
         end
       end
 
@@ -239,11 +232,17 @@ class Kronk
 
     private
 
-    def yield_sequences sequences, dist=0, &block # :nodoc:
-      while sequences.length > dist
+    def yield_sequences sequences, &block # :nodoc:
+      while sequences.length > 0
         item = sequences.pop
         next unless item
-        item.each(&block)
+        item.each do |seq|
+          resp = yield seq
+          if !resp && seq[0] > 1
+            seq[0] = seq[0] - 1
+            (sequences[seq[0]] ||= []) << seq
+          end
+        end
       end
     end
   end

data/lib/kronk/diff/output.rb

@@ -127,7 +127,7 @@ class Kronk::Diff
       Kronk.find_const name
 
     rescue NameError
-      raise Kronk::Exception, "No such formatter: #{name.inspect}"
+      raise Kronk::Error, "No such formatter: #{name.inspect}"
     end
 
 

data/lib/kronk/http.rb

@@ -0,0 +1,105 @@
+class Kronk
+
+  class HTTPBadResponse < Net::HTTPBadResponse; end
+
+  ##
+  # Wrapper for Net::HTTP
+
+  class HTTP < Net::HTTP
+
+    def request(req, body=nil, opts={}, &block)  # :yield: +response+
+      unless started?
+        start {
+          req['connection'] ||= 'close'
+          return request(req, body, &block)
+        }
+      end
+      if proxy_user()
+        req.proxy_basic_auth proxy_user(), proxy_pass() unless use_ssl?
+      end
+      req.set_body_internal body
+      res = transport_request(req, true, opts, &block)
+      if sspi_auth?(res)
+        sspi_auth(req)
+        res = transport_request(req, true, opts, &block)
+      end
+      res
+    end
+
+
+    private
+
+    def transport_request(req, allow_retry=true, opts={})
+      # Check if previous request was made on same socket and needs
+      # to be completed before we can read the new response.
+      if Kronk::BufferedIO === @socket && !@socket.response.read?
+        @socket.response.body
+      end
+
+      begin_transport req
+      req.exec @socket, @curr_http_version, edit_path(req.path)
+
+      begin
+        opts[:timeout] ||= @socket.read_timeout
+        res = Kronk::Response.new(@socket.io, opts)
+      end while kronk_resp_type(res) == Net::HTTPContinue
+
+      if res.headless?
+        raise HTTPBadResponse, "Invalid HTTP response" unless allow_retry
+        @socket.io.close
+        res = transport_request(req, false, opts)
+      end
+
+      @socket = res.io
+
+      res.body {|chunk|
+        yield res, chunk
+      } if block_given?
+
+      end_transport req, res
+      res
+
+    rescue => exception
+      D "Conn close because of error #{exception}"
+      @socket.close if @socket and not @socket.closed?
+      raise exception
+    end
+
+
+    def end_transport(req, res)
+      @curr_http_version = res.http_version
+      if @socket.closed?
+        D 'Conn socket closed'
+      elsif keep_alive?(req, res)
+        D 'Conn keep-alive'
+      elsif not res.body and @close_on_empty_response
+        D 'Conn close'
+        @socket.close
+      else
+        D 'Conn close'
+        @socket.close
+      end
+    end
+
+
+    def sspi_auth?(res)
+      return false unless @sspi_enabled
+      if kronk_resp_type(res) == HTTPProxyAuthenticationRequired and
+          proxy? and res["Proxy-Authenticate"].include?("Negotiate")
+        begin
+          require 'win32/sspi'
+          true
+        rescue LoadError
+          false
+        end
+      else
+        false
+      end
+    end
+
+
+    def kronk_resp_type res
+      Net::HTTPResponse::CODE_TO_OBJ[res.code]
+    end
+  end
+end

data/lib/kronk/player.rb

@@ -2,46 +2,70 @@ class Kronk
 
   ##
   # The Player class is used for running multiple requests and comparisons and
-  # providing useful output through Player::Output classes.
-  # Kronk includes a Suite (test-like) output, a Stream (chunked) output,
+  # providing useful output through inherited Player classes.
+  # Kronk includes a Suite (test-like), a Stream (chunked),
   # and a Benchmark output.
 
   class Player < QueueRunner
 
-    attr_accessor :input, :output
+    ##
+    # Instantiate a new type of player, typically :suite, :stream, or
+    # :benchmark.
+
+    def self.new_type type, opts={}
+      klass =
+        case type.to_s
+        when /^(Player::)?benchmark$/i then Benchmark
+        when /^(Player::)?stream$/i    then Stream
+        when /^(Player::)?suite$/i     then Suite
+        when /^(Player::)?tsv$/i       then TSV
+        else
+          Kronk.find_const type.to_s
+        end
+
+      klass.new opts
+    end
+
+
+
+    attr_accessor :input, :qps, :concurrency, :mutex
 
     ##
     # Create a new Player for batch diff or response validation.
     # Supported options are:
     # :io:: IO - The IO instance to read from
-    # :output:: Class - The output class to use (see Player::Output)
     # :parser:: Class - The IO parser to use.
+    # :concurrency:: Fixnum - Maximum number of concurrent items to process
+    # :qps::  Fixnum - Number of queries to process per second
 
     def initialize opts={}
       super
-      self.output_from opts[:output] || Suite
+
+      @concurrency = opts[:concurrency]
+      @concurrency = 1 if !@concurrency || @concurrency <= 0
+      @qps         = opts[:qps]
 
       @input      = InputReader.new opts[:io], opts[:parser]
-      @use_output = true
       @last_req   = nil
+      @mutex      = Mutex.new
 
       @on_input   = Proc.new do
         stop_input! if !@number && @input.eof?
         @last_req = @input.get_next || @queue.last || @last_req || {}
       end
 
-      @on_result  = Proc.new do |kronk, err, mutex|
-        err ? @output.error(err, kronk, mutex) :
-              @output.result(kronk, mutex)
-      end
-
       on(:input, &@on_input)
       on(:interrupt){
-        @output.completed if @use_output
+        interrupt and return if respond_to?(:interrupt)
+        complete if respond_to?(:complete)
         exit 2
       }
-      on(:start){ @output.start if @use_output }
-      on(:complete){ @output.completed if @use_output }
+      on(:start){
+        start if respond_to?(:start)
+      }
+      on(:complete){
+        complete if respond_to?(:complete)
+      }
     end
 
 
@@ -58,26 +82,6 @@ class Kronk
     end
 
 
-    ##
-    # The kind of output to use. Typically Player::Suite or Player::Stream.
-    # Takes an output class or a string that represents a class constant.
-
-    def output_from new_output
-      return @output = new_output.new(self) if Class === new_output
-
-      klass =
-        case new_output.to_s
-        when /^(Player::)?benchmark$/i then Benchmark
-        when /^(Player::)?stream$/i    then Stream
-        when /^(Player::)?suite$/i     then Suite
-        else
-          Kronk.find_const new_output
-        end
-
-      @output = klass.new self if klass
-    end
-
-
     ##
     # Process the queue to compare two uris.
     # If options are given, they are merged into every request.
@@ -85,10 +89,10 @@ class Kronk
     def compare uri1, uri2, opts={}, &block
       return Cmd.compare uri1, uri2, @queue.shift.merge(opts) if single_request?
 
-      method = self.class.async ? :process_one_async : :process_one
+      on(:result){|(kronk, err)| trigger_result(kronk, err, &block) }
 
-      run do |kronk_opts, mutex|
-        send method, kronk_opts.merge(opts), 'compare', uri1, uri2, &block
+      run opts do |kronk|
+        kronk.compare uri1, uri2
       end
     end
 
@@ -100,55 +104,37 @@ class Kronk
     def request uri, opts={}, &block
       return Cmd.request uri, @queue.shift.merge(opts) if single_request?
 
-      method = self.class.async ? :process_one_async : :process_one
+      on(:result){|(kronk, err)| trigger_result(kronk, err, &block) }
 
-      run do |kronk_opts, mutex|
-        send method, kronk_opts.merge(opts), 'request', uri, &block
+      run opts do |kronk|
+        kronk.request uri
       end
     end
 
 
     ##
-    # Run a single compare or request and call the Output#result or
-    # Output#error method.
-    #
-    # If given a block, will yield the Kronk instance and error. If
-    # a third argument is given, mutex will also be passed and the
-    # block won't be called from a mutex lock.
-    #
-    # Returns the result of the block or of the called Output method.
+    # Similar to QueueRunner#run but yields a Kronk instance.
 
-    def process_one opts={}, *args, &block
-      err   = nil
-      kronk = Kronk.new opts
-
-      begin
-        kronk.send(*args)
-      rescue *Kronk::Cmd::RESCUABLE => e
-        err = e
+    def run opts={}
+      if @qps
+        method = :periodically
+        arg    = 1.0 / @qps.to_f
+      else
+        method = :concurrently
+        arg    = @concurrency
       end
 
-      trigger_result kronk, err, &block
-    end
+      send method, arg do |kronk_opts|
+        err = nil
+        kronk = Kronk.new kronk_opts.merge(opts)
 
+        begin
+          yield kronk
+        rescue *Kronk::Cmd::RESCUABLE => e
+          err = e
+        end
 
-    ##
-    # Run a single compare or request and call the Output#result or
-    # Output#error method using EventMachine.
-    #
-    # If given a block, will yield the Kronk instance and error. If
-    # a third argument is given, mutex will also be passed and the
-    # block won't be called from a mutex lock.
-    #
-    # Returns either a EM::MultiRequest or an EM::Connection handler.
-
-    def process_one_async opts={}, *args, &block
-      kronk  = Kronk.new opts
-      method = args.shift.to_s + '_async'
-
-      kronk.send(method, *args) do |obj, err|
-        raise err if err && !Kronk::Cmd::RESCUABLE.find{|eclass| eclass === err}
-        trigger_result kronk, err, &block
+        [kronk, err]
       end
     end
 
@@ -157,14 +143,20 @@ class Kronk
     # Trigger a single kronk result callback.
 
     def trigger_result kronk, err, &block
-      block ||= @on_result
-
-      if block.arity > 2 || block.arity < 0
-        block.call kronk, err, @mutex
-      else
-        @mutex.synchronize do
-          block.call kronk, err
+      if block_given?
+        if block.arity > 2 || block.arity < 0
+          block.call kronk, err, @mutex
+        else
+          @mutex.synchronize do
+            block.call kronk, err
+          end
         end
+
+      elsif err && respond_to?(:error)
+        error err, kronk
+
+      elsif respond_to?(:result)
+        result kronk
       end
     end
 

data/lib/kronk/player/benchmark.rb

@@ -13,18 +13,21 @@ class Kronk
   # * Percentage of requests within a certain time
   # * Slowest endpoints
 
-  class Player::Benchmark < Player::Output
+  class Player::Benchmark < Player
 
     class ResultSet
 
+      attr_accessor :total_time
+
       attr_reader :byterate, :count, :fastest, :precision,
-                  :slowest, :total_bytes
+                  :slowest, :total_bytes, :err_count
 
-      def initialize start_time
-        @times = Hash.new(0)
-        @count = 0
-        @r5XX  = 0
-        @r4XX  = 0
+      def initialize
+        @times     = Hash.new(0)
+        @count     = 0
+        @r5XX      = 0
+        @r4XX      = 0
+        @err_count = 0
 
         @precision = 3
 
@@ -36,7 +39,6 @@ class Kronk
         @total_bytes = 0
         @byterate    = 0
 
-        @start_time = start_time
         @total_time = 0
       end
 
@@ -58,8 +60,6 @@ class Kronk
         @total_bytes += resp.raw.bytes.count
 
         @byterate = (@byterate * (@count-1) + resp.byterate) / @count
-
-        @total_time = (Time.now - @start_time).to_f
       end
 
 
@@ -147,9 +147,11 @@ class Kronk
 
       def to_s
         out = <<-STR
+
 Completed:     #{@count}
 400s:          #{@r4XX}
 500s:          #{@r5XX}
+Errors:        #{@err_count}
 Req/Sec:       #{self.req_per_sec}
 Total Bytes:   #{@total_bytes}
 Transfer Rate: #{self.transfer_rate} Kbytes/sec
@@ -175,7 +177,7 @@ Request Percentages (ms)
 
         unless slowest_reqs.empty?
           out << "
-Avg. Slowest Requests (ms, #)
+Avg. Slowest Requests (ms, count)
 #{slowest_reqs.map{|arr| "  #{arr[1].inspect}  #{arr[0]}"}.join "\n" }"
         end
 
@@ -184,44 +186,39 @@ Avg. Slowest Requests (ms, #)
     end
 
 
-    def initialize player
-      @player  = player
-      @results = []
-      @count   = 0
-
-      @div = nil
-      @div = @player.number / 10 if @player.number
-      @div = 100 if !@div || @div < 10
-    end
-
-
     def start
+      @res_count = 0
+      @results   = []
+      @div       = @number / 10 if @number
+      @div       = 100 if !@div || @div < 10
       puts "Benchmarking..."
-      super
     end
 
 
-    def result kronk, mutex
-      kronk.responses.each_with_index do |resp, i|
-        mutex.synchronize do
-          @count += 1
-          @results[i] ||= ResultSet.new(@start_time)
+    def result kronk
+      @mutex.synchronize do
+        kronk.responses.each_with_index do |resp, i|
+          @results[i] ||= ResultSet.new
           @results[i].add_result resp
-
-          puts "#{@count} requests" if @count % @div == 0
         end
+
+        @res_count += 1
+        puts "#{@res_count} requests" if @res_count % @div == 0
       end
     end
 
 
-    def error err, kronk, mutex
-      mutex.synchronize do
-        @count += 1
+    def error err, kronk
+      @mutex.synchronize do
+        @res_count += 1
+        @results.each do |res|
+          res.err_count += 1
+        end
       end
     end
 
 
-    def completed
+    def complete
       puts "Finished!"
 
       render_head
@@ -232,6 +229,8 @@ Avg. Slowest Requests (ms, #)
 
 
     def render_body
+      @results.each{|res| res.total_time = @stop_time - @start_time }
+
       if @results.length > 1
         puts Diff.new(@results[0].to_s, @results[1].to_s).formatted
       else
@@ -245,7 +244,7 @@ Avg. Slowest Requests (ms, #)
 
 Benchmark Time:      #{(Time.now - @start_time).to_f} sec
 Number of Requests:  #{@count}
-Concurrency:         #{@player.concurrency}
+Concurrency:         #{@qps ? "#{@qps} qps" : @concurrency}
       STR
     end
   end