api_bomb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 73ddb47d82a289fdcb31bdc0416cb4a9cf2ad9d1
+  data.tar.gz: 4e3a67a97ef22c4d09f386dc43b799145e9f2022
+SHA512:
+  metadata.gz: 9dc76d94c2f5a75d15058100e5ce9f4f66d3b1d1ef62cbedc436b326fe4f37cc02e0535cc767c5d98b2c503b2d106f747eba1e81ff023fdbe80f42b35b86bfb9
+  data.tar.gz: a1493c33637c339c0d4e49c51b70f248dd1e2c746fff81b2fd25e5b6dbf32f753d32223b8559a662b897f6f8775e1602160ad232ffa090d6d02c08ec16a29b70

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in api_bomb.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Filippos Vasilakis
+
+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.md

@@ -0,0 +1,229 @@
+# ApiBomb
+After investigating all ruby gems and commercial services for testing my API performance,
+I figured out that none of those was easy to use. Most of them were not built with
+APIs in mind, were difficult to create a simple test, even more tricky to add
+more sophisticated requests and paid services didn't work for localhost.
+
+All failed to my request: test and measure my API performance without spending
+too much time in this shit.
+
+So I built my own gem.
+Started as a funny gist, ended up as a fully fledged gem.
+
+ApiBomb will allow you to test how much your API can take. It will start firing
+as many requests as you want for any timespan you want, all of them fully customizable.
+
+Are you ready to defend your API?
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'api_bomb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install api_bomb
+
+## Usage
+First you need to define the global settings.
+Usually in the global settings hash you just want to define the most common settings.
+
+```ruby
+options = {
+  fronts: 4, #concurrent users
+  duration: 60, #seconds
+  base_url: 'http://localhost:3000/api/v1', #base url
+  options: { #this hash is overriden for each path that has its own options
+    headers: { #various headers, like session token etc
+      'Session-Token' => SESSION_TOKEN,
+      'Connection' => 'close',
+      'Content-Type' => 'application/json'
+    },
+    params: { #GET params
+    },
+    json: { #POST/PUT/PATCH HTTP body params
+    }
+  },
+}
+```
+Options keys (like headers, params, json etc) can be overrided later, if needed, per path.
+Oh btw those options are passed straight to [http](https://github.com/httprb/http) which
+means you can do anything this gem provides :)
+
+### Simple mode
+###### You want to test how many GET rpm an endpoint can hold?
+```ruby
+path = 'videos'
+ApiBomb::War.new(options.merge({path: path})).start!
+```
+This will fire tons of requests in the `http://localhost:3000/api/v1/videos`
+using the headers from the global settings for 60 seconds. 4 concurrent users
+means that they will always be 4 requests pending from the client perspective.
+As soon as one is served, a new one will be fired. Once the test duration is
+elapsed it will report back to you:
+
+```ruby
+Elapsed time: 60
+Concurrency: 4 threads
+Number of requests: 298
+Requests per second: 4
+Requests per minute: 298.0
+Average response time: 0.6628006505031939
+Standard deviation: 0.2957473991283155
+Percentile 90th: 1.0887710852002783
+Percentile 95th: 1.154147314250258
+Percentile 99th: 1.5413802972278787
+Server status stats: [{"2xx"=>298}]
+```
+You can also inject your logger in the global options.
+
+
+###### You want to test how many GET rpm a sequence of endpoints can hold? It will run
+a separate benchmark for each of your endpoints.
+```ruby
+paths = ['videos', 'users', 'comments']
+ApiBomb::War.new(options.merge({paths: paths})).start!
+```
+This will fire tons of requests like in the previous example,
+first in `http://localhost:3000/api/v1/videos`
+then in `http://localhost:3000/api/v1/users` and finally in
+`http://localhost:3000/api/v1/comments`
+
+###### You want to test a POST endpoint? Then you can the slightly more advanced API:
+```ruby
+video_params = { title: 'A new video!', description: 'a new description!', user_id: 1}
+paths = {path: 'videos', action: :post, options: { json: video_params}}
+ApiBomb::War.new(options.merge({paths: paths})).start!
+```
+
+###### You want to test dynamic endpoints?
+```ruby
+paths = {path: Proc.new{ "videos/#{1.upto(10000).to_a.sample}" } #default action is :get
+ApiBomb::War.new(options.merge({paths: paths})).start!
+```
+You can add lambdas or (preferrably) procs in any value of the options hash and
+path.
+
+It should be noted that using lambdas/procs, it's almost endless of what you can do.
+You could use FactoryGirl or whatever to get dynamic attributes when creating/updating
+a resource in your API. **Be sure to watch out though, that constants and classes have already
+been initialized because most of such gems do lazy initialization.**
+
+###### You want to test a sequence of endpoints with dynamic params? It will run a separate
+benchmark for each one in the array.
+```ruby
+paths = [ #get http method is used by default
+  {
+    path: 'videos',
+    params: { per_page: Proc.new{ 1.upto(10).to_a.sample } } #you can have a proc in a specific param only
+  },
+  {
+    path: 'videos',
+    params: { per_page: Proc.new{ 1.upto(10).to_a.sample } } #you can have a proc in a specific param only
+  },
+  {
+    path: 'videos',
+    params: { per_page: Proc.new{ 1.upto(10).to_a.sample } } #you can have a proc in a specific param only
+  },
+  {
+    path: 'videos',
+    params: { per_page: Proc.new{ 1.upto(10).to_a.sample } } #you can have a proc in a specific param only
+  },
+]
+```
+
+###### You want to test dynamic endpoints with dynamic params?
+```ruby
+paths = {
+  path: Proc.new{ ['videos', 'users', 'comments', 'likes'].sample,
+  action: :get,
+  params: Proc.new{ {per_page: 1.upto(10).to_a.sample} }
+}
+ApiBomb::War.new(options.merge({paths: paths})).start!
+```
+
+This is also equivelent to the previous:
+```ruby
+paths = {
+  path: Proc.new{ ['videos', 'users', 'comments', 'likes'].sample,
+  action: :get,
+  params: { per_page: Proc.new{ 1.upto(10).to_a.sample } } #you can have a proc in a specific param only
+}
+ApiBomb::War.new(options.merge({paths: paths})).start!
+```
+
+###### You want to test different endpoints with each having different probability to be requested?
+The dynamic nature is up to you. But for your convinience we have created a special
+class that can be used if you want to test random paths using a probability/weight.
+So if you want for bombard 'videos' path 3 times more than comments and comments path 3 times
+more users path (so videos will be bombarded 9 times more than users path) in a war (test):
+
+```ruby
+paths = ApiBomb::Path::Weighted.new({
+  {path: 'videos'} => 9,
+  {path: 'comments'} => 3,
+  {path: 'users'} => 1,
+})
+
+ApiBomb::War.new(options.merge({paths: paths})).start!
+```
+
+or a more spophisticated:
+```ruby
+paths = ApiBomb::Path::Weighted.new({
+  {path: 'videos', action: :get, options: { params: {per_page: 1}}} => 20,
+  {path: 'videos', action: :get, options: {
+    params: { per_page: Proc.new{ 1.upto(10).to_a.sample } }
+  }} => 10,
+  {path: Proc.new{ "videos/#{video_ids.sample}" }, action: :get} => 70,
+  {path: Proc.new{ "users/#{user_ids.sample}" }, action: :get} => 60,
+})
+
+ApiBomb::War.new(options.merge({paths: paths})).start!
+```
+
+`Weighted` path uses [Pickup](https://github.com/fl00r/pickup) gem underneath.
+
+## Advanced
+You can have lambdas/procs in any hash value (or key for `Weighted` paths).
+Internally `Path::Single`, `Path::Sequence` and `Path::Weighted` classes are
+used everywhere, which you can also use
+but I have ommitted them from the examples for the sake of simplicity (and added
+a builder that figures out what you actually want).
+
+You can also create your own Path structure. It only needs to respond to pick
+method which must return a Path::Single object with all the necessary attributes.
+
+Furthermore, if you like, you can override the default strategy. You might want to
+dispatch a new request depending on the response of the previous request. Take
+a look on `lib/api_bomb/strategies.rb`
+
+On the global settings hash, you can also specify the number of requests you want
+to send (which will override the duration unless Timeout exception kicks in first).
+It's not very well tested and should be used mostly for debugging (requests: 1)
+
+## Best practices
+* When starting optimizing, be sure that you test the performance of your API and
+not of your webserver. For instance, you might fire 2 concurrent users in an
+endpoint which will result in 300 req/min. Then you might fire 20 concurrent users
+which could result in 450 req/min. Does it mean that your API is faster? Probably 
+not because your response time must have went > 1 sec which sucks.
+
+That's why other statistics are included apart from req/min.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/vasilakisfil/api_bomb/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/api_bomb.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'api_bomb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "api_bomb"
+  spec.version       = ApiBomb::VERSION
+  spec.authors       = ["Filippos Vasilakis"]
+  spec.email         = ["vasilakisfil@gmail.com"]
+
+  if spec.respond_to?(:metadata)
+  end
+
+  spec.summary       = %q{Simple gem that allows you to test/measure your API performance.}
+  spec.description   = %q{Simple gem that allows you to test/measure your API performance.}
+  spec.homepage      = "https://github.com/vasilakisfil/api_bomb"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "celluloid", "~> 0.17"
+  spec.add_dependency "http", "~> 0.9"
+  spec.add_dependency "pickup", "~> 0.0.11"
+  spec.add_dependency "descriptive_statistics", "~> 2.5"
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "api_bomb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/api_bomb/army.rb

@@ -0,0 +1,12 @@
+class ApiBomb::Army
+  attr_reader :fighters
+
+  def initialize(fighters:)
+    @fighters = fighters
+  end
+
+  def send_fighter
+    @fighters.future.fire
+  end
+  alias_method :send_new_fighter, :send_fighter
+end

data/lib/api_bomb/commander.rb

@@ -0,0 +1,67 @@
+class ApiBomb::Commander
+  include ApiBomb::Strategy::Naive
+
+  attr_reader :army, :fronts, :duration, :signaler, :logger, :requests
+
+  def initialize(army:, fronts: 1, duration: 10, logger: Logger.new(STDOUT), requests: nil)
+    @duration = duration
+    @army = army
+    @fighters = []
+    @statuses = []
+    @hold_times = []
+    @fronts = fronts
+    @logger = logger
+    @requests = requests
+  end
+
+  def start_attack!
+    begin
+      #I know that Timeout is really bad
+      #but literarly there is no other generic way doing this
+      #Fortunately we only do requests to an API so it shouldn't affect us
+      logger.info "Starts firing requests"
+      Timeout::timeout(duration) {
+        attack
+      }
+    rescue Timeout::Error
+      logger.info "Ceasefire!"
+    end
+
+    report_attack_result
+  end
+
+private
+  def report_attack_result
+    logger.info "Elapsed time: #{attack_result[:duration]}"
+    logger.info "Concurrency: #{attack_result[:fronts]} threads"
+    logger.info "Number of requests: #{attack_result[:requests]}"
+    logger.info "Requests per second: #{attack_result[:rps]}"
+    logger.info "Requests per minute: #{attack_result[:rpm]}"
+    logger.info "Average response time: #{attack_result[:average_rt]}"
+    logger.info "Standard deviation: #{attack_result[:sd_rq_time]}"
+    logger.info "Percentile 90th: #{attack_result[:percentile_90]}"
+    logger.info "Percentile 95th: #{attack_result[:percentile_95]}"
+    logger.info "Percentile 99th: #{attack_result[:percentile_99]}"
+    logger.info "Server status stats: #{attack_result[:server_status_stats]}"
+  end
+
+  def attack_result
+    {
+      duration: duration,
+      fronts: @fronts,
+      requests: @signaler.fighters_lost,
+      rps: @signaler.fighters_lost / duration,
+      rpm: @signaler.fighters_lost / (duration/60.0),
+      average_rt: @signaler.mean_hold_time,
+      sd_rq_time: @signaler.sd_time,
+      percentile_90: @signaler.percentile(90),
+      percentile_95: @signaler.percentile(95),
+      percentile_99: @signaler.percentile(99),
+      server_status_stats: @signaler.server_status_stats
+    }
+  end
+
+  def signaler
+    @signaler ||= ApiBomb::Signaler.new
+  end
+end

data/lib/api_bomb/fighter.rb

@@ -0,0 +1,27 @@
+class ApiBomb::Fighter
+  include Celluloid
+
+  attr_reader :paths, :options, :base_url
+
+  def initialize(paths: nil, base_url: nil, options: {})
+    @base_url = base_url
+    @options = options
+    @paths = paths
+  end
+
+  def fire
+    route = @paths.pick
+
+    url = URI::join(base_url, route.path)
+    response = nil
+    hold_time = Benchmark.measure do
+      response = HTTP.send(
+        route.action,
+        url,
+        ApiBomb::LambdaHash.hasharize(options.merge(route.options))
+      )
+    end
+
+    return OpenStruct.new(response: response, hold_time: hold_time.real)
+  end
+end

data/lib/api_bomb/lambda_hash.rb

@@ -0,0 +1,41 @@
+#values can respond to call making them dynamic
+class ApiBomb::LambdaHash < SimpleDelegator
+  def self.hasharize(hash)
+    hash_call = self.new(hash)
+    h = {}
+    hash_call.each do |v, k|
+      h[v] = hash_call[v]
+      if h[v].is_a? self
+        h[v] = self.hasharize(h[v])
+      end
+    end
+
+    return h
+  end
+
+  def is_lambda?
+    self.each do |k,v|
+      if self[k].is_a? self.class
+        return self[k].is_lambda?
+      else
+        if self.real[k].respond_to? :call
+          return true
+        else
+          return false
+        end
+      end
+    end
+  end
+
+  def [](key)
+    value = self.__getobj__[key]
+    value = value.call if value.respond_to? :call
+    value =  self.class.new(value) if value.is_a? Hash
+
+    return value
+  end
+
+  def real
+    self.__getobj__
+  end
+end

data/lib/api_bomb/path.rb

@@ -0,0 +1,90 @@
+module ApiBomb::Path
+  class Sequence
+    include Enumerable
+    extend Forwardable
+    def_delegators :@paths, :each, :<<
+
+    attr_reader :paths
+    def initialize(paths)
+      @paths = paths
+    end
+
+    def pick
+      return paths.sample
+    end
+  end
+
+  class Single
+    HTTP_METHODS = [:get, :post, :put, :patch, :delete, :head].freeze
+
+    def initialize(path:, action: :get, options: {})
+      @path = path
+      @action = action
+      @action = :get if not HTTP_METHODS.include?(action.downcase.to_sym)
+      @options = ApiBomb::LambdaHash.new(options)
+    end
+
+    def pick
+      return self
+    end
+
+    def report(base_url)
+      path_report(base_url) + params_report
+    end
+
+    def path_report(base_url = '')
+      base_url = options[:base_url] if options[:base_url]
+
+      if @path.respond_to? :call
+        "testing random paths like #{action.to_s.upcase} #{URI::join(base_url, path)}"
+      else
+        "testing path #{action.to_s.upcase} #{URI::join(base_url, path)}"
+      end
+    end
+
+    def params_report
+      if options.is_lambda?
+        " with random params like: #{ApiBomb::LambdaHash.hasharize(options)[:params]}"
+      else
+        " with params: #{options[:params]}"
+      end
+    end
+
+    def path
+      return @path.call if @path.respond_to? :call
+      return @path
+    end
+
+    def action
+      return @action.call if @action.respond_to? :call
+      return @action
+    end
+
+    def options
+      @options
+    end
+  end
+
+  class Weighted
+    attr_reader :weighted_paths, :paths
+    def initialize(paths)
+      @weighted_paths = Pickup.new(paths)
+      @paths = paths
+    end
+
+    def pick
+      Single.new(@weighted_paths.pick)
+    end
+
+    def report
+      sum = paths.values.sum
+
+      str =  "Load generation over random (weighted) urls \n"
+      paths.sort_by {|_key, value| value}.to_h.each do |path, weight|
+        str += "#{path} with probability #{weight/sum} \n"
+      end
+
+      return str
+    end
+  end
+end

data/lib/api_bomb/signaler.rb

@@ -0,0 +1,39 @@
+class ApiBomb::Signaler
+  attr_reader :hold_times, :statuses
+
+  def initialize
+    @statuses = []
+    @hold_times = []
+  end
+
+  def report(fighter)
+    @statuses << fighter.value.response.status
+    @hold_times << fighter.value.hold_time
+  end
+
+  def fighters_lost
+    hold_times.count
+  end
+
+  def mean_hold_time
+    hold_times.mean
+  end
+
+  def sd_time
+    hold_times.standard_deviation
+  end
+
+  def percentile(value)
+    hold_times.percentile(value)
+  end
+
+  def server_errors
+    @statuses.select{|s| s >= 500}.count
+  end
+
+  def server_status_stats
+    @server_status_stats ||= @statuses.group_by{|status|
+      status.to_i.to_s.chop.chop.insert(-1, 'xx')
+    }.map{|s| {s.first => s.last.count}}
+  end
+end

data/lib/api_bomb/strategy.rb

@@ -0,0 +1,35 @@
+module ApiBomb::Strategy
+  module Naive
+    def attack
+      if requests
+        attack_in_requests
+      else
+        attack_in_time
+      end
+    end
+
+    def attack_in_time
+      fronts.times do |i|
+        @fighters << @army.send_fighter
+      end
+
+      while (@fighters.length > 0) do
+        signaler.report(@fighters[0])
+        @fighters.shift
+
+        @fighters << @army.send_new_fighter
+      end
+    end
+
+    def attack_in_requests
+      requests.times do |i|
+        @fighters << @army.send_fighter
+      end
+
+      while (@fighters.length > 0) do
+        signaler.report(@fighters[0])
+        @fighters.shift
+      end
+    end
+  end
+end

data/lib/api_bomb/version.rb

@@ -0,0 +1,3 @@
+module ApiBomb
+  VERSION = "0.1.0"
+end

data/lib/api_bomb.rb

@@ -0,0 +1,101 @@
+require_relative "api_bomb/version"
+require "benchmark"
+require 'celluloid/current'
+require 'http'
+require 'pickup'
+require 'pry'
+require 'descriptive_statistics'
+require 'descriptive_statistics/safe'
+require 'forwardable'
+
+require_relative 'api_bomb/lambda_hash'
+require_relative 'api_bomb/strategy'
+require_relative 'api_bomb/path'
+
+module ApiBomb
+  class War
+    attr_reader :fronts, :duration, :paths, :options, :base_url, :logger,
+      :requests
+    #alias_method :path, :paths
+
+    def initialize(opts = {})
+      @fronts = opts[:fronts] || 2
+      @duration = opts[:duration] || 10
+      @paths = opts[:paths]
+      @paths = (opts[:path] || '') if @paths.blank?
+      @options = LambdaHash.new(opts[:options] || {})
+      @base_url = opts[:base_url] || ''
+      @logger = opts[:logger] || Logger.new(STDOUT)
+      @requests = opts[:requests]
+      build_paths
+    end
+
+    def build_paths
+      case @paths
+      when String
+        @paths = Path::Single.new(path: @paths)
+      when Array
+        tmp_paths = []
+        @paths.each do |path|
+          if path.is_a? Hash
+            tmp_paths << Path::Single.new(path)
+          elsif path.is_a? String
+            tmp_paths << Path::Single.new(path: path)
+          else
+            raise 'Unknown path structure'
+          end
+        end
+        @paths = Path::Sequence.new(tmp_paths)
+      when Hash
+        @paths = Path::Single.new(@paths)
+      when Path::Single, Path::Sequence, Path::Weighted
+      else
+        raise 'Unknown path structure'
+      end
+    end
+
+    def start!
+      case paths
+      when Path::Single
+        @logger.info("#{paths.report(base_url)}, duration: #{duration} sec")
+        start_attack!(paths)
+      when Path::Sequence
+        paths.each do |path|
+          @logger.info("#{path.report(base_url)}, duration: #{duration} sec")
+          start_attack!(path)
+        end
+      when Path::Weighted
+        @logger.info(paths.report)
+        start_attack!(paths)
+      end
+    end
+
+    def dereference_path(path)
+      return path.call if path.respond_to? :call
+      return path[:path] if path.respond_to? :[] && path[:path] != nil
+      path
+    end
+
+    def start_attack!(testing_paths)
+      Commander.new(
+        fronts: fronts,
+        duration: duration,
+        army: Army.new(
+          fighters: Fighter.pool(
+            size: 2*fronts, args: [
+              paths: testing_paths, base_url: base_url, options: options
+            ]
+          )
+        ),
+        logger: logger,
+        requests: requests
+      ).start_attack!
+    end
+  end
+
+end
+
+require_relative 'api_bomb/army'
+require_relative 'api_bomb/fighter'
+require_relative 'api_bomb/commander'
+require_relative 'api_bomb/signaler'

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: api_bomb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Filippos Vasilakis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: celluloid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: pickup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.11
+- !ruby/object:Gem::Dependency
+  name: descriptive_statistics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Simple gem that allows you to test/measure your API performance.
+email:
+- vasilakisfil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- api_bomb.gemspec
+- bin/console
+- bin/setup
+- lib/api_bomb.rb
+- lib/api_bomb/army.rb
+- lib/api_bomb/commander.rb
+- lib/api_bomb/fighter.rb
+- lib/api_bomb/lambda_hash.rb
+- lib/api_bomb/path.rb
+- lib/api_bomb/signaler.rb
+- lib/api_bomb/strategy.rb
+- lib/api_bomb/version.rb
+homepage: https://github.com/vasilakisfil/api_bomb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simple gem that allows you to test/measure your API performance.
+test_files: []