celluloid-benchmark 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: 5ac0f4600f16c3bc2f95f799c1ddff901c800724
-  data.tar.gz: d1cca2df8282bcdf0878bfdee906c970fed73e6e
+  metadata.gz: c2f324f0d80da8c02cbf069d16c6d9149ec54a78
+  data.tar.gz: 4cf506f01001f0f1c4deaedd9c63370c2126e7b6
 SHA512: 
-  metadata.gz: 08d614ea74ed9612c1cde83fec51c6aaa720f49207975273f6142ca80d170ca82722b3543cea887de6815158955357225f640f2714dc8efe8c9077149f9032cd
-  data.tar.gz: 771aff0b9208297a0c2f483a43874c88086769a4f2b267ed4749856241024ed164cc2ed4503ff2ce1fa843498d807e9b5076e67cfbec6150062a90ccc3fcb9d0
+  metadata.gz: c77eb8790651fa84cc0aef9fe3f836a866babe4c82f46761148136d2613f476296c856d472d1f6163b3434c2e1031e32a7282902146b419be975114dbe9a9081
+  data.tar.gz: 723c251d7190fd5746f665ac53cd00979b310cba9d75935ec8c4f7b86ac9fe15b4fb1cce137f7d93b26a5683f49857e0dabacf6fbd0c9d70b05f8c16edfc3645

data/README.md

@@ -8,7 +8,7 @@ Getting Started
     gem install celluloid-benchmark
     echo "benchmark :home_page, 1
     get 'https://github.com/scottwillson/celluloid-benchmark'" > session.rb
-    celluloid-benchmark session.rb 1
+    celluloid-benchmark -d 1
 
 Congrats! You just load-tested the project's Github page.
 
@@ -64,8 +64,12 @@ JSON requests (e.g., a mobile app API)
     { "Content-Type" => "application/json" }
   )
 
+Options
+-------
+    celluloid-benchmark --help
+
 Test data
----------
+=========
 Because test scenarios are plain Ruby, you can drive tests in many different ways. The
 [Faker gem](http://rubydoc.info/github/stympy/faker/master/frames) is handy
 for random, realistic test data:
@@ -87,7 +91,7 @@ Celluloid Benchmark can also pull random test data from CSV files. For example:
 `random_data(:post_zone)` pulls a random line from tmp/data/post_zones.csv
 
 Extending session DSL
----------------------
+=====================
 The DSL is simple and will change in early releases. To add custom DSL methods, add methods to Visitor
     module CelluloidBenchmark
       class Visitor

data/bin/celluloid-benchmark

@@ -1,15 +1,20 @@
 #! /usr/bin/env ruby
 
-require_relative "../lib/celluloid_benchmark"
+require "slop"
 
-session_path = File.expand_path(ARGV[0])
+opts = Slop.parse(help: true) do
+  banner "Usage: celluloid-benchmark [options]"
 
-duration = (ARGV[1] || 20).to_i
-if duration == 0
-  duration = 20
+  on "d", "duration", "Start new visitors for :duration seconds. Default: 20.", argument: :optional
+  on "s", "session", "Session file path. Default: session.rb.", argument: :optional
+  on "t", "target", "Target server/environment, site. Default: local.", argument: :optional
+  on "v", "visitors", "Number of concurrent visitors. Default: CPU cores - 2 (minimum 1).", argument: :optional
 end
 
-benchmark_run = CelluloidBenchmark::Runner.run session_path, duration, ARGV[2] && ARGV[2].to_i
+require_relative "../lib/celluloid_benchmark"
+require_relative "../lib/celluloid_benchmark/visitor"
+
+benchmark_run = CelluloidBenchmark::Runner.run opts.to_hash
 
 p benchmark_run
 puts

data/lib/celluloid_benchmark/runner.rb

@@ -1,5 +1,6 @@
 require "celluloid"
 require_relative "session"
+require_relative "target"
 require_relative "visitor_group"
 
 Celluloid.logger = nil
@@ -7,44 +8,45 @@ Celluloid.logger = nil
 module CelluloidBenchmark
   # Run a scenario in several Visitors and return a BenchmarkRun
   class Runner
-    def self.run(session_path, duration = 20, visitors = nil)
-      raise("session_path is required") unless session_path
-      raise("'#{session_path}' does not exist") unless File.exists?(session_path)
+    def self.run(args)
+      session  =  args[:session]  || "session.rb"
+      visitors =  args[:visitors] || visitors_count(args[:visitors])
+      duration = (args[:duration] || 20).to_f
+      target   =  args[:target]
 
-      require session_path
+      require File.expand_path(session)
 
       VisitorGroup.run!
-      set_visitor_pool_size visitors
-      visitors = visitors_count(visitors)
 
+      visitors = visitors_count(visitors)
       benchmark_run = Celluloid::Actor[:benchmark_run]
       benchmark_run.visitors = visitors
 
       benchmark_run.mark_start
-      futures = run_sessions(benchmark_run, duration, visitors)
+      futures = run_sessions(benchmark_run, duration, visitors, Target.new_from_key(target))
       futures.map(&:value)
+
       benchmark_run.mark_end
 
       benchmark_run
     end
 
-    def self.run_sessions(benchmark_run, duration, visitors)
+    def self.run_sessions(benchmark_run, duration, visitors, target)
       pool = Celluloid::Actor[:visitor_pool]
       futures = []
       visitors.times do
-        futures << pool.future.run_session(benchmark_run, duration)
+        futures << pool.future.run_session(benchmark_run, duration, target)
       end
       futures
     end
 
-    def self.set_visitor_pool_size(size)
-      if size && size.to_i > 0
-        Visitor.pool.size = size.to_i + 2
+    def self.visitors_count(count)
+      if count
+        count = count.to_i
+      else
+        count = Visitor.pool.size - 2
       end
-    end
 
-    def self.visitors_count(count)
-      count = count || (Visitor.pool.size - 2)
       if count > 1
         count
       else

data/lib/celluloid_benchmark/target.rb

@@ -0,0 +1,45 @@
+module CelluloidBenchmark
+  class Target
+    attr_reader :http_auth_password
+    attr_reader :http_auth_username
+    attr_reader :key
+    attr_reader :uri
+
+    def self.new_from_key(key, config_file_path = nil)
+      if key.nil? && config_file_path.nil?
+        return default_target
+      end
+
+      key ||= "local"
+      config_file_path ||= "config/targets.yml"
+
+      configs = YAML.load_file(config_file_path)
+      config = configs[key]
+
+      unless config
+        raise ArgumentError, "No target for '#{key}'"
+      end
+
+      if config["http_auth"]
+        Target.new(key, config["uri"], config["http_auth"]["username"], config["http_auth"]["password"])
+      else
+        Target.new(key, config["uri"])
+      end
+    end
+
+    def self.default_target
+      Target.new("local", "http://localhost")
+    end
+
+    def initialize(key, uri, http_auth_username = nil, http_auth_password = nil)
+      @http_auth_password = http_auth_password
+      @http_auth_username = http_auth_username
+      @key = key
+      @uri = uri
+    end
+
+    def http_auth?
+      http_auth_username && http_auth_password
+    end
+  end
+end

data/lib/celluloid_benchmark/version.rb

@@ -1,3 +1,3 @@
 module CelluloidBenchmark
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

data/lib/celluloid_benchmark/visitor.rb

@@ -20,9 +20,11 @@ module CelluloidBenchmark
     attr_accessor :current_request_threshold
     attr_accessor :request_start_time
     attr_accessor :request_end_time
+    attr_reader :target
 
-    def run_session(benchmark_run, duration)
+    def run_session(benchmark_run, duration, target = nil)
       @benchmark_run = benchmark_run
+      @target = target
 
       elapsed_time = 0
       started_at = benchmark_run.started_at

data/lib/celluloid_benchmark/visitor_group.rb

@@ -6,6 +6,6 @@ module CelluloidBenchmark
   # Supervised Actor pool of Visitors
   class VisitorGroup < Celluloid::SupervisionGroup
     supervise BenchmarkRun, as: :benchmark_run
-    pool Visitor, as: :visitor_pool, size: 4
+    pool Visitor, as: :visitor_pool
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: celluloid-benchmark
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors: 
 - Scott Willson
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-06-20 00:00:00 Z
+date: 2014-06-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: celluloid
@@ -62,6 +62,14 @@ dependencies:
         version: "1.25"
   type: :runtime
   version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: slop
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id006
+  type: :runtime
+  version_requirements: *id007
 description: |-
   Celluloid Benchmark realistically load tests websites. Write expressive, concise load tests in Ruby. Use Rubinius and Celluloid
   forpec high concurrency. Use Mechanize for a realistic (albeit non-JavaScript) browser client.
@@ -82,6 +90,7 @@ files:
 - lib/celluloid_benchmark/data_sources.rb
 - lib/celluloid_benchmark/runner.rb
 - lib/celluloid_benchmark/session.rb
+- lib/celluloid_benchmark/target.rb
 - lib/celluloid_benchmark/version.rb
 - lib/celluloid_benchmark/visitor.rb
 - lib/celluloid_benchmark/visitor_group.rb