evilhornets 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2eb8b072d3546ff3b3252cec33ada70b49e7279
+  data.tar.gz: d8cad9948b5b5affda0e054f1ef594b17dc0770c
+SHA512:
+  metadata.gz: a8e5645179e857ab39824dcf742b81f75c9c4c67051a1ce6d027102ffaaab38ff983d9644ad9b73e990b8683715442a2426b1d99093e62b9e91a1d61c24b2973
+  data.tar.gz: 18d0774defbaed47e8b39a4e542cf1f628be92537747bd11d793188d3c9b4151f3290244ad3ed5e15ba82c63eaa8657e8ba8d8cb1ab6a9ca6b7713a33528657a

data/bin/hornet

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'hornet'
+options = Hornet.parse ARGV
+Hornet.go ARGV, options

data/lib/hornet.rb

@@ -0,0 +1,126 @@
+require 'optparse'
+require 'ostruct'
+require 'hornet/headquarter'
+
+Commands = {
+  'up'     => 'Spin up multiple EC2 micro instances to host bees.',
+  'attack' => 'Launch an attack against a target.',
+  'down'   => 'Terminate load testing servers.',
+  'scale'  => 'Adjust the number of load testing servers.',
+  'report' => 'Report the load testing result.',
+  'help'   => 'Print the help document.',
+}
+
+class Hornet
+
+  def self.parse(args)
+    command = args.first
+    options = OpenStruct.new
+    parser = OptionParser.new do |opt|
+
+      if ['--help', '-h', 'help'].include? command
+        print_help = ['--help', '-h', 'help'].include? command
+        command = 'help'
+      end
+      if not Commands.keys.include? command
+        opt.banner = "Usage: hornet (%s) [options]" % Commands.keys.join('|')
+      else
+        opt.banner = "Usage: hornet %s [options]" % command
+
+        if ['up', 'attack', 'scale'].include? command
+          opt.separator Commands[command]
+        end
+
+        # build options depends on command
+
+        if command == 'attack' or print_help
+          opt.separator 'attack:'
+          opt.on('-n', '--number [NUMBER]', 'Number of total attacks to launch (default: 1000).') do |value|
+            options.number = value
+          end
+          opt.on('-c', '--concurrent [CONCURRENT]', 'The number of concurrent connections to make to the target (default: 100).') do |value|
+            options.concurrent = value
+          end
+          opt.on('-b', '--bees [BEES]', 'Number of containers to create (default: 1).') do |value|
+            options.bees = value
+          end
+          opt.on('-u', '--url [URL]', 'URL of the target to attack.') do |value|
+            options.url = value
+          end
+        end
+
+        if command == 'up' or print_help
+          opt.separator 'up:'
+          opt.on('-r', '--region [REGION]', 'Region the server will be built (default: us-east-1d).') do |value|
+            options.region = value
+          end
+          opt.on('-n', '--number [NUMBER]', 'Number of servers to start (default: 1).') do |value|
+            options.number = value
+          end
+          opt.on('-u', '--username [USERNAME]', 'The ssh username name to use to connect to the servers (default: ubuntu).') do |value|
+            options.username = value
+          end
+          opt.on('-k', '--key [KEY]', 'The ssh key pair name to use to connect to the servers.') do |value|
+            options.key_name = value
+          end
+          opt.on('-i', '--image_id [IMAGE_ID]', 'The ID of the AMI.') do |value|
+            options.image_id = value
+          end
+        end
+
+        if command == 'scale' or print_help
+          opt.separator 'scale:'
+          opt.on('-n', '--number [NUMBER]', 'Number of servers to scale to (default: 1).') do |value|
+            options.number = value
+          end
+        end
+
+        opt.on('-h', '--help', 'Print this help document.') do |value|
+          abort parser.to_s
+        end
+      end
+
+    end
+
+    # don't parse anything if no command sepcified
+    if command.nil? or ['--help', '-h', 'help'].include? command
+      abort parser.to_s
+    end
+    parser.parse!
+    options
+  end
+
+  # validate options, abort if required options is missing
+  def self.validate_options(command, options)
+    ops = {}
+    begin
+      case command
+      when 'attack'
+        ops = {:number => 1000, :concurrent => 100, :bees => 1}.merge options.to_h
+        if not ops.has_key? :url
+          raise ArgumentError.new 'Missing argument: --url'
+        end
+      when 'up'
+        ops = {:region => 'us-east-1', :username => 'ubuntu', :number => 1, :image_id => 'ami-c3e997f9'}.merge options.to_h
+        if not ops.has_key? :key_name
+          raise ArgumentError.new 'Missing argument: --key'
+        end
+      when 'scale'
+        ops = {:number => 1}.merge options.to_h
+      end
+    rescue ArgumentError => msg
+      abort msg.to_s
+    end
+    OpenStruct.new ops
+  end
+
+  # move on to the next step.
+  def self.go(args, options)
+    command = args.first
+    if not command.nil?
+      options = Hornet.validate_options command, options
+      headquarter = Fleet::Headquarter.new(command, options.to_h)
+      headquarter.dispatch
+    end
+  end
+end

data/lib/hornet/fleet.rb

@@ -0,0 +1,74 @@
+module Fleet
+
+  Headlines = [
+    'Time taken for tests',
+    'Complete requests',
+    'Failed requests',
+    'Non-2xx responses',
+    'Total transferred',
+    'HTML transferred',
+    'Requests per second',
+    'Time per request',
+    'Transfer rate'
+  ]
+
+  def Fleet.print_report(result)
+    result.each do |key, value|
+      puts '%s: %s' % [key, value.join(' ')]
+    end
+  end
+
+  # merge all results together and with certain calculations
+  def Fleet.report(data)
+    result = {}
+
+    # hash
+    data.each_value do |entries|
+      entries.each do |key, value|
+
+        if result.has_key? key
+          result[key][0] << value.first.to_f
+        else
+          result[key] = value.size == 1 ? [[value.first.to_f]] : [[value.first.to_f], value.last]
+        end
+
+      end
+    end
+
+    # process the result data, e.g, sum and avg
+    result.each do |key, value|
+      #puts value.to_s
+      if ['Time taken for tests'].include? key
+        value[0] = value[0].sort.last
+      elsif ['Complete requests', 'Failed requests', 'Total transferred', 'HTML transferred', 'Non-2xx responses'].include? key
+        value[0] = value[0].inject{|sum, x| sum + x}
+      else
+        count = value[0].count
+        value[0] = (value[0].inject{|sum, x| sum + x} / count).round(2)
+      end
+      result[key] = value
+    end
+    result
+  end
+
+  def Fleet.parse_ab_data(data)
+    result = {}
+
+    # parse each line with the matched heading
+    data.each_line do |line|
+      if line.start_with?(*Headlines)
+        parts = line.partition(':')
+        head = parts.first
+        body = parts.last.strip.split(' ', 2)
+        result[head] = body
+      end
+    end
+
+    if not result.has_key? 'Time per request'
+      return {}
+    end
+
+    result
+  end
+
+end

data/lib/hornet/headquarter.rb

@@ -0,0 +1,220 @@
+require 'aws-sdk'
+require 'ostruct'
+require 'hornet/fleet'
+require 'hornet/hive'
+
+module Fleet
+  class Headquarter
+
+    STATE_FILE = File.expand_path('~/.hives')
+
+    def initialize(command, options={})
+      @command = command
+      @options = options
+
+      @state = OpenStruct.new options
+      @state.loaded = false
+
+      readServerState
+
+      if @state.region
+        Aws.config.update({:region => @state.region})
+        @ec2_resource = Aws::EC2::Resource.new
+        @ec2_client = Aws::EC2::Client.new
+      end
+    end
+
+    def dispatch
+      case @command
+      when 'up'
+        createHives @options
+      when 'attack'
+        hivesAttack @options
+      when 'scale'
+        scaleHives @options
+      when 'report'
+        hivesReport
+      when 'down'
+        destroyHives
+      end
+    end
+
+    # create a number of hives using user options
+    def createHives(options)
+      number_of_hive = options.has_key?(:number) ? options[:number].to_i : 1
+      hive_options = {
+        :key_name      => nil,
+        :image_id      => nil,
+        :min_count     => number_of_hive,
+        :max_count     => number_of_hive,
+        :instance_type => 't2.micro'
+      }
+      hive_options.merge!(options.select {|k,v| hive_options.has_key?(k)})
+      hives = @ec2_resource.create_instances hive_options
+      puts "%i hives are being built" % number_of_hive
+
+      # write the current state to the file
+      @state.hives = hives.map(&:id) + @state.hives.to_a
+      writeServerList
+
+      checkHivesStatus hives
+
+      # tagging happens after the instance is ready
+      @ec2_resource.create_tags({:tags => [{:key => 'Name', :value => 'hive'}], :resources => hives.map(&:id)})
+    end
+
+    # start the attack simultaneously.
+    def hivesAttack(options)
+      hives = []
+      attack_threads = []
+      attack_options = []
+
+      puts "Preparing the attack:"
+      puts "%s bees will attack %s times, %s at a time" % [options[:bees], options[:bees].to_i * options[:number].to_i, options[:concurrent]]
+      remains = options[:bees].to_i % @state.hives.count
+      options[:bees] = options[:bees].to_i / @state.hives.count
+
+      puts "Hive              Bees"
+      @state.hives.each_with_index do |instance_id, index|
+        if index == @state.hives.size - 1
+          options[:bees] += remains
+        end
+        attack_options << options.clone
+        puts '%s        %s' % [instance_id, options[:bees]]
+
+        hive = Hive.new @state.username, @state.key_name, instance_id
+        hives << hive
+        attack_threads << Thread.new do
+          hive.attack attack_options[index]
+        end
+      end
+
+      puts "\n"
+      attack_threads.each {|t| t.join}
+      puts "\n"
+
+      hivesReport hives
+    end
+
+    # collect report from every hive
+    def hivesReport(hives=[])
+      data = {}
+      report_threads = []
+      if not hives.any?
+        @state.hives.each_with_index do |instance_id, index|
+          hives << Hive.new(@state.username, @state.key_name, instance_id)
+        end
+      end
+
+      # create the report threads
+      hives.each do |hive|
+        report_threads << Thread.new do
+          data[hive.instance_id] = hive.report
+        end
+      end
+
+      report_threads.each {|t| t.join}
+      Fleet.print_report Fleet.report(data)
+    end
+
+    # scale hives up and down
+    def scaleHives(options)
+      if not @state.loaded
+        abort 'Perhaps build some hives first?'
+      end
+      number_of_hive = options.has_key?(:number) ? options[:number].to_i : 1
+      if @state.hives.count == number_of_hive
+        abort 'No hives scaled'
+      elsif @state.hives.count > number_of_hive
+        destroyHives number_of_hive > 0 ? @state.hives[number_of_hive..-1] : {}
+      else
+        options = {:number => number_of_hive - @state.hives.count, :image_id => @state.image_id}
+        createHives @state.to_h.merge options
+      end
+    end
+
+    # tear down all running hives
+    def destroyHives instances = []
+      instances = instances.empty? ? @state.hives : instances
+      if not instances.empty?
+
+        # attemp the terminate ec2 instances
+        begin
+          @ec2_client.terminate_instances instance_ids: instances
+        rescue Aws::EC2::Errors::InvalidInstanceIDNotFound => e
+          # for mismatches, terminate what we can
+          instances_2b_removed = instances - e.to_s.match(/\'[^']*\'/)[0].split(',').map! {|x| x.strip.tr_s("'", "")}
+          @ec2_client.terminate_instances instance_ids: instances_2b_removed
+        rescue Aws::EC2::Errors::InvalidInstanceIDMalformed
+        end
+
+        if instances.count == @state.hives.count
+          removeServerList
+        else
+          @state.hives.reject! {|item| instances.include? item}
+          writeServerList
+        end
+      else
+        abord 'Perhaps build some hives first?'
+      end
+      puts '%i hives are teared down!' % instances.count
+    end
+
+    private
+
+    def readServerState
+      if not File.exist? STATE_FILE
+        return false
+      end
+      server_state = IO.readlines(STATE_FILE).map! {|l| l.strip}
+      begin
+        @state.username = server_state[0]
+        @state.key_name = server_state[1]
+        @state.region   = server_state[2]
+        @state.image_id = server_state[3]
+        @state.hives    = server_state[4..-1]
+      rescue
+        abort 'A problem occured when reading hives'
+      end
+      @state.loaded = true
+    end
+
+    def writeServerList
+      begin
+        File.open(STATE_FILE, 'w') do |f|
+          f.write("%s\n" % @state.username)
+          f.write("%s\n" % @state.key_name)
+          f.write("%s\n" % @state.region)
+          f.write("%s\n" % @state.image_id)
+          f.write(@state.hives.join("\n"))
+        end
+      rescue
+        abort 'Failed to written down hives details'
+      end
+    end
+
+    def removeServerList
+      File.delete STATE_FILE
+    end
+
+    # check over status of hives
+    def checkHivesStatus(hives)
+      hives_built = []
+      filters = [{:name => 'instance-state-name', :values => ['pending', 'running']}]
+      while hives_built.count != hives.count do
+        statuses = @ec2_client.describe_instance_status instance_ids: hives.map(&:id), include_all_instances: true, filters: filters
+        statuses.each do |response|
+          response[:instance_statuses].each do |instance|
+            building = instance[:instance_state].name == 'running' ? false : true
+            instance_id = instance[:instance_id]
+            if not building and not hives_built.include? instance_id
+              puts 'Hive %s is ready!' % instance_id
+              hives_built << instance_id
+            end
+          end
+        end
+        sleep(1)
+      end
+    end
+  end
+end

data/lib/hornet/hive.rb

@@ -0,0 +1,110 @@
+require 'aws-sdk'
+require 'net/ssh'
+require 'hornet/fleet'
+
+module Fleet
+  class Hive
+    attr_accessor :instance_id
+    HOME_DIR = '/home/ubuntu'
+
+    def initialize(username, key, instance_id)
+      @username = username
+      @key = File.expand_path('~/.ssh/%s.pem' % key)
+
+      # grab the instance ip and id
+      instance = Aws::EC2::Instance.new instance_id
+      @instance_id = instance_id
+      @ip = instance.public_ip_address
+    end
+
+    # attack the target, clean the previous attack result, preapre the attack and then start the attack
+    def attack(option)
+      Net::SSH.start(@ip, @username, :keys => [@key]) do |ssh|
+        # remove all exited containers
+        clean_cmd = _clean ssh
+        clean_cmd.wait
+
+        # prepare the attack
+        create_cmd = _prepare ssh, option
+        create_cmd.wait
+
+        # build the command
+        #open a new channel and run the container
+        attack_cmd = _execute ssh, option
+        attack_cmd.wait
+      end
+    end
+
+    # connect to the instance and collect the results
+    def report
+      result = {}
+
+      Net::SSH.start(@ip, @username, :keys => [@key]) do |ssh|
+
+        data = ""
+        collection_cmd = _collection_info ssh, data
+        collection_cmd.wait
+
+        # parse the result
+        index = 1
+        data.split('Connection Times (ms)').each do |d|
+          data = Fleet.parse_ab_data d
+          if data.any?
+            result[index] = data
+            index += 1
+          end
+        end
+
+      end
+
+      Fleet.report result
+    end
+
+    private
+    # add new ab command to ab.sh
+    def _prepare(ssh, option)
+      benchmark_command = 'ab -s 60 -r -n %{number} -c %{concurrent} "%{url}" >> /root/${HOSTNAME}.out' % option
+      ssh.open_channel do |cha|
+        cha.exec "touch %{path}/ab.sh && echo '%{cmd}' > %{path}/ab.sh" % {:cmd => benchmark_command, :path => HOME_DIR} do |ch, success|
+          raise "could not execute command" unless success
+        end
+      end
+    end
+
+    # start the attack
+    def _execute(ssh, option)
+      puts "Hive %s is starting it's attack" % @instance_id
+      ssh.open_channel do |cha|
+        # 'for i in {1..%s}; do nohup docker run -v /home/ubuntu:/root andizzle/debian bash /root/ab.sh; done'
+        cmd = ['docker run -v /home/ubuntu:/root andizzle/debian bash /root/ab.sh'] * option[:bees]
+        cha.exec cmd.join ' & ' do |ch, success|
+          raise "could not execute command" unless success
+          ch.on_data do |c, data|
+            puts data
+          end
+          ch.on_close { puts "Hive %s has finished it's attack!" % @instance_id}
+        end
+      end
+    end
+
+    def _collection_info(ssh, data_pool)
+      ssh.open_channel do |cha|
+        cha.exec 'find %s -name "*.out" -exec cat {} \;' % HOME_DIR do |ch, success|
+          raise "could not execute command" unless success
+          ch.on_data do |c, data|
+            data_pool << data
+          end
+        end
+      end
+    end
+
+    # clean up the battlefield
+    def _clean(ssh)
+      ssh.open_channel do |cha|
+        cha.exec 'docker ps -aq -f status=exited | xargs docker rm && find /home/ubuntu -name "*.out" -exec rm {} \;' % HOME_DIR do |ch, success|
+          raise "could not execute command" unless success
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: evilhornets
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andy Zhang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: Stress test your web apps.
+email: andizzle.zhang@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/hornet
+- lib/hornet.rb
+- lib/hornet/fleet.rb
+- lib/hornet/headquarter.rb
+- lib/hornet/hive.rb
+homepage: https://github.com/andizzle/evilhornets
+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: Launch EC2 micro instances, each instance creates multiple docker containers
+  to stress test your web applications.
+test_files: []