zombees 0.0.1

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+aws_config.yml
+
+#VIM
+*.swp
+*.swo

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format sunny
+--require emoji-rspec

data/.ruby-gemset

@@ -0,0 +1 @@
+tourfleet

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p392

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+    - "1.9.3"
+script: 'bundle exec rake run_all_specs'

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/Gemfile.lock

@@ -0,0 +1,104 @@
+PATH
+  remote: .
+  specs:
+    zombees (0.0.1)
+      celluloid (~> 0.13.0)
+      celluloid-pmap
+      colorize
+      fog (~> 1.8.0)
+      net-ssh (~> 2.5.0)
+      yell
+
+GEM
+  specs:
+    builder (3.2.0)
+    celluloid (0.13.0)
+      timers (>= 1.0.0)
+    celluloid-pmap (0.1.0)
+      celluloid (~> 0.12)
+    coderay (1.0.9)
+    colorize (0.5.8)
+    coveralls (0.6.7)
+      colorize
+      multi_json (~> 1.3)
+      rest-client
+      simplecov (>= 0.7)
+      thor
+    diff-lcs (1.2.3)
+    emoji-rspec (1.0.0)
+      rspec (~> 2.10)
+    excon (0.22.1)
+    ffi (1.8.1)
+    fog (1.8.0)
+      builder
+      excon (~> 0.14)
+      formatador (~> 0.2.0)
+      mime-types
+      multi_json (~> 1.0)
+      net-scp (~> 1.0.4)
+      net-ssh (>= 2.1.3)
+      nokogiri (~> 1.5.0)
+      ruby-hmac
+    formatador (0.2.4)
+    guard (1.8.0)
+      formatador (>= 0.2.4)
+      listen (>= 1.0.0)
+      lumberjack (>= 1.0.2)
+      pry (>= 0.9.10)
+      thor (>= 0.14.6)
+    guard-rspec (2.6.0)
+      guard (>= 1.8)
+      rspec (~> 2.13)
+    listen (1.0.3)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      rb-kqueue (>= 0.2)
+    lumberjack (1.0.3)
+    method_source (0.8.1)
+    mime-types (1.23)
+    multi_json (1.7.2)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-ssh (2.5.2)
+    nokogiri (1.5.9)
+    pry (0.9.12.1)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rake (10.0.4)
+    rb-fsevent (0.9.3)
+    rb-inotify (0.9.0)
+      ffi (>= 0.5.0)
+    rb-kqueue (0.2.0)
+      ffi (>= 0.5.0)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    ruby-hmac (0.4.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.4.4)
+    thor (0.18.1)
+    timers (1.1.0)
+    yell (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  coveralls
+  emoji-rspec
+  guard-rspec
+  rake
+  rspec
+  zombees!

data/Guardfile

@@ -0,0 +1,24 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/README.md

@@ -0,0 +1,51 @@
+[![Build Status](https://travis-ci.org/zombees/zombees.png?branch=master)](https://travis-ci.org/zombees/zombees)
+[![Code Climate](https://codeclimate.com/github/zombees/zombees.png)](https://codeclimate.com/github/zombees/zombees)
+[![Coverage Status](https://coveralls.io/repos/zombees/zombees/badge.png?branch=master)](https://coveralls.io/r/zombees/zombees?branch=master)
+
+![logo](https://raw.github.com/zombees/zombees/master/zombee.png)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'zombees'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zombees
+
+## Example usage
+
+```ruby
+# ab_adapter_example.rb
+require 'yaml'
+require 'zombees'
+require 'zombees/ab_adapter'
+
+aws_config = YAML.load_file('aws_config.yml').symbolize_keys!
+
+adapter = Zombees::AbAdapter.new requests: 10, concurrency: 10, url: TEST_URL
+result = Zombees::Queen.new(config: aws_config, worker_count: 2, command: adapter).run
+puts result.inspect
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+TODO
+------------
+- Simple  CLI
+- Verbose mode
+- Adapters for different command to run
+  - Siege
+  - Tourbus

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+task :push => :run_all_specs do
+   puts "Pushing real good"
+   Rake.sh 'git push origin master'
+end
+
+task :run_all_specs => :spec do
+   Rake.sh 'bundle exec rspec --tag @integration'
+end
+
+desc 'Run all specs with code coverage'
+task :coverage do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task['spec'].execute
+  Rake::Task['run_all_specs'].execute
+end

data/ab_adapter_example.rb

@@ -0,0 +1,10 @@
+require 'yaml'
+require 'zombees'
+require 'zombees/ab_adapter'
+
+aws_config = YAML.load_file('aws_config.yml').symbolize_keys!
+
+url = URL_TO_TEST
+adapter = Zombees::AbAdapter.new requests: 10, concurrency: 10, url: "#{url}/"
+result = Zombees::Queen.new(config: aws_config, worker_count: 2, command: adapter).run
+puts result.inspect

data/lib/zombees/ab_adapter.rb

@@ -0,0 +1,119 @@
+module Zombees
+  class AbAdapter
+    attr_reader :config
+    attr_writer :command_source
+    attr_writer :preparer_source
+    attr_writer :parser_source
+    def initialize(config={})
+      @config = config
+    end
+
+    def command_source; @command_source ||= Command.public_method(:new) end 
+    def preparer_source; @preparer_source ||= Preparer.new end
+    def parser_source(output_of_commands); @parser_source ||= Parser.new(output_of_commands) end
+    private :command_source, :preparer_source, :parser_source
+
+    def prepare(worker)
+      preparer_source.prepare(worker)
+    end
+
+    def run(worker)
+      command_source.call(config).run(worker)
+    end
+
+    def parse(output_of_commands)
+      parser_source(output_of_commands).parse
+    end
+
+    def aggregate(output_of_commands)
+      parse_result = parse(output_of_commands)
+      Aggregator.new(parse_result).aggregate
+    end
+
+    class Preparer
+      def prepare(worker)
+        worker.run_command('sudo apt-get -y update && sudo apt-get -y install apache2-utils')
+      end
+    end
+
+    class Command
+      attr_reader :requests, :concurrency, :url, :ab_options
+
+      def initialize(options={})
+        options = default.merge(options)
+        @requests    = options[:requests]
+        @concurrency = options[:concurrency]
+        @url         = options[:url]
+        @ab_options  = options[:ab_options]
+      end
+
+      def default
+        {}
+      end
+
+      def run(worker)
+        worker.run_command(command)
+      end
+
+      def command
+        "ab -r -n #{requests} -c #{concurrency} " +
+        %Q{-C "sessionid=fake" #{ab_options} "#{url}"}
+      end
+    end
+
+    class Aggregator
+      attr_reader :parsed_results
+      def initialize(parsed_results)
+        @parsed_results = parsed_results
+      end
+
+      def sum(key)
+        values = parsed_results.map { |res| res[key] }.compact
+        values.inject(:+)
+      end
+
+      def average(key)
+        values = parsed_results.map { |res| res[key] }.compact
+        if total_values = values.inject(:+)
+          total_values / values.count
+        end
+      end
+
+      def hash_result(key, aggregator)
+        value = self.send(aggregator, key)
+        value ? {key => value} : {}
+      end
+
+      def aggregate
+        {}.tap do |result|
+          result.merge! hash_result(:complete_requests, :sum)
+          result.merge! hash_result(:failed_requests, :sum)
+          result.merge! hash_result(:time_per_request, :average)
+        end
+      end
+    end
+
+    class Parser
+      attr_reader :command_results
+      def initialize(command_results)
+        @command_results = command_results
+      end
+
+      def parse
+        command_results.flatten.map do |command|
+          self.class.parse(command.stdout)
+        end
+      end
+
+      def self.parse(output)
+        output.each_line.each_with_object({}) do |line, data|
+          key, value = line.strip.split(/\s*:\s*/)
+          if key
+            key += " concurrent" if value =~ /concurrent/
+            data[key.downcase.gsub(/\s+/, '_').to_sym] = value.to_f
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zombees/connection.rb

@@ -0,0 +1,16 @@
+require 'fog'
+module Zombees
+  class Connection
+    extend Forwardable
+    def_delegator :@connection, :servers
+
+    def self.import_key_pair(config)
+      connection = Fog::Compute.new(config)
+      connection.import_key_pair(:fog_default, IO.read('tourfleet.pub')) if connection.key_pairs.get(:fog_default).nil?
+    end
+    def initialize(config)
+      @connection = Fog::Compute.new(config)
+    end
+
+  end
+end

data/lib/zombees/honey_comb.rb

@@ -0,0 +1,22 @@
+require 'zombees/worker'
+require 'zombees/connection'
+require 'thread'
+
+module Zombees
+  class HoneyComb
+    attr_reader :config
+
+    def worker
+      Worker.new(connection)
+    end
+
+    def initialize(config)
+      @config = config
+      Connection.import_key_pair(config)
+    end
+
+    def connection
+      Connection.new(config)
+    end
+  end
+end

data/lib/zombees/queen.rb

@@ -0,0 +1,38 @@
+require 'yaml'
+require 'zombees/worker'
+require 'zombees/swarm'
+require 'zombees/honey_comb'
+require 'yell'
+
+module Zombees
+  class Queen
+    include Yell::Loggable
+    attr_reader :config, :worker_count, :command, :swarm
+    attr_writer :swarm_source
+
+    def initialize(options = {})
+      @config = options.fetch(:config)
+      @worker_count = options.fetch(:worker_count)
+      @command = options.fetch(:command)
+      @swarm = options[:swarm]
+    end
+
+    def run
+      logger.info "A swarm of zombie bees gathers..."
+      swarm.run
+    end
+
+    def swarm
+      swarm_source.call(SwarmOptions.new(
+                        worker_count: worker_count,
+                  command: command,
+                  honey_comb: HoneyComb.new(config)))
+    end
+
+    def swarm_source
+      @swarm_source ||= Swarm.public_method(:new)
+    end
+
+  end
+end
+

data/lib/zombees/swarm.rb

@@ -0,0 +1,59 @@
+require 'celluloid'
+require 'celluloid/pmap'
+require 'yell'
+require 'zombees/swarm_options'
+require 'forwardable'
+
+module Zombees
+  class Swarm
+    attr_reader :worker_count, :command, :honey_comb
+    include Yell::Loggable
+    extend Forwardable
+
+    def initialize(options, population=nil)
+      @worker_count = options.worker_count
+      @adapter = options.command
+      @honey_comb = options.honey_comb
+      @population = population
+    end
+
+    def breed
+      logger.info "Resurrecting the bees population of #{worker_count}"
+      @population ||= worker_count.downto(1).pmap do |index|
+        worker = honey_comb.worker
+        begin 
+          logger.info "Bee #{ index } is getting ready to fight"
+          worker.bootstrap.tap { |w| @adapter.prepare(w) }
+        rescue => e
+          logger.error "ARGH! Bee #{ index } stayed dead: #{e.inspect}"
+          worker.shutdown(e)
+        end
+        worker
+      end
+
+    end
+
+    def population
+      breed
+    end
+
+    def run
+      logger.info "The swarm lurches toward the target..."
+      results = population.pmap do |worker|
+        begin
+          logger.info "A zombie bee is attacking the target!"
+          @adapter.run(worker)
+        rescue => e
+          logger.error "A zombie bee can't reach the brains due to #{e.message}"
+          logger.debug e.backtrace
+        ensure
+          logger.info "A zombie bee is full of brains... Going back to the grave"
+          #logger.debug "worker: #{ worker.object_id } server: #{ worker.server.inspect }"
+          worker.shutdown
+        end
+      end
+      logger.info "Digesting acquired brains"
+      @adapter.aggregate(results)
+    end
+  end
+end

data/lib/zombees/swarm_options.rb

@@ -0,0 +1,18 @@
+class SwarmOptions
+  attr_reader :options
+  def initialize(options)
+    @options = options
+  end
+
+  def worker_count
+    options[:worker_count]
+  end
+
+  def command
+    options[:command]
+  end
+
+  def honey_comb
+    options[:honey_comb]
+  end
+end

data/lib/zombees/version.rb

@@ -0,0 +1,3 @@
+module Zombees
+  VERSION = "0.0.1"
+end

data/lib/zombees/worker.rb

@@ -0,0 +1,45 @@
+require 'forwardable'
+require 'celluloid'
+require 'celluloid/pmap'
+require 'zombees/connection'
+require 'fog'
+require 'yell'
+
+module Zombees
+  class Worker
+    include Celluloid
+    include Yell::Loggable
+    attr_reader :config
+    attr_reader :server
+    extend Forwardable
+    def_delegator :@server, :ready?
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def bootstrap
+      @server = @connection.servers.bootstrap(
+        private_key_path:  'tourfleet',
+        key_name:          :fog_default,
+        username:          'ubuntu'
+      )
+
+      @server.wait_for { ready? }
+      self
+    end
+
+    def run_command(command)
+      result = @server.ssh(command)
+      result
+    end
+
+    def shutdown
+      if @server && @server.ready?
+        @server.destroy
+      else
+        logger.error "zombie bee is too badly damaged to get to the graveyard"
+      end
+    end
+  end
+end

data/lib/zombees.rb

@@ -0,0 +1,3 @@
+require 'yell'
+Yell.new $stdout, name: Object
+require 'zombees/queen'

data/spec/fixtures/ab.txt

@@ -0,0 +1,45 @@
+This is ApacheBench, Version 2.3 <$Revision: 655654 $>
+Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
+Licensed to The Apache Software Foundation, http://www.apache.org/
+
+Benchmarking www.google.com (be patient)...Send request failed!
+..done
+
+
+Server Software:        gws
+Server Hostname:        www.google.com
+Server Port:            80
+
+Document Path:          /
+Document Length:        10740 bytes
+
+Concurrency Level:      10
+Time taken for tests:   0.083 seconds
+Complete requests:      10
+Failed requests:        11
+   (Connect: 0, Receive: 3, Length: 8, Exceptions: 0)
+Write errors:           1
+Total transferred:      103128 bytes
+HTML transferred:       96504 bytes
+Requests per second:    120.06 [#/sec] (mean)
+Time per request:       83.295 [ms] (mean)
+Time per request:       8.329 [ms] (mean, across all concurrent requests)
+Transfer rate:          1209.09 [Kbytes/sec] received
+
+Connection Times (ms)
+              min  mean[+/-sd] median   max
+Connect:       13   16   9.2     13      42
+Processing:    40   67   9.4     70      70
+Waiting:        0   63  22.0     69      70
+Total:         82   83   0.2     83      83
+
+Percentage of the requests served within a certain time (ms)
+  50%     83
+  66%     83
+  75%     83
+  80%     83
+  90%     83
+  95%     83
+  98%     83
+  99%     83
+ 100%     83 (longest request)

data/spec/integration/running_a_server_swarm_spec.rb

@@ -0,0 +1,24 @@
+require 'integration_spec_helper'
+require 'zombees'
+require 'zombees/ab_adapter'
+
+describe 'Running 3 servers', integration: true do
+  let(:config) {{ provider: 'AWS', aws_access_key_id: 'foo', aws_secret_access_key: 'bar' }}
+
+  class Fog::SSH::Mock
+    alias_method :original_run, :run
+
+    def run(commands, &blk)
+      Array(commands).map do |command|
+        result = Fog::SSH::Result.new(command)
+      end
+    end
+  end
+
+  it 'runs a command in parallel on all servers when they are ready' do
+    queen = Zombees::Queen.new(worker_count: 3, command: Zombees::AbAdapter.new, config: config)
+    queen.run
+  end
+end
+
+