ruby-load 0.4.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 46e778e48feb5d53446b7387ace66c1824f50baa
+  data.tar.gz: 72141593544e44f8bbacb0609ff1194f5f5e2ad2
+SHA512:
+  metadata.gz: 1528d3bf11ad1d68f6de25b19a1c5e95c85b8520c9f7ef2eac5f16a2103b2a6ecfac513452581e1591739e6ef1867bb43ba4bdc189931ef727ef2898651f851a
+  data.tar.gz: 4d990a03f757b1ae77305f192ab614ca01414689d24553ace4f4ad39af6a62f56d26b48d2f0416177e875e36c35d84966721cb64844fd7074a48d42f2220dc5b

data/lib/load/client_command_line.rb

@@ -0,0 +1,131 @@
+require_relative "./load_node.rb"
+require_relative "./http_report.rb"
+require 'singleton'
+
+class ClientCommandLine
+  attr_reader :run_id, :node_info_json
+
+  def require_directory(directory_name)
+    project_root = File.dirname(File.absolute_path(__FILE__))
+    parent_directory = project_root + "/#{directory_name}"
+    puts "Parent root: #{parent_directory}"
+    Dir.glob("#{parent_directory}/*") do |file|
+      require file
+    end
+  end
+
+  def launch(args)
+    require_directory("custom")
+    puts "Wasp!"
+    index = 0
+    main_command = args[0]
+    puts "Command: #{main_command}"
+    index = 1
+    if (main_command == "run")
+      node_count = 1
+      configuration_file_name = nil
+      server_address = nil
+      @target_server = nil
+      while (index < args.length)
+        arg = args[index]
+
+        if (arg == "-n")
+          index += 1
+          node_count = args[index].to_i
+        end
+
+        if (arg == "-s")
+          index += 1
+          server_address = args[index]
+        end
+
+        if (arg == "-t")
+          index += 1
+          @target_server = args[index]
+        end
+
+        if (arg == "-c")
+          index += 1
+          configuration_file_name = args[index]
+        end
+        index += 1
+        #puts "Looking at command line param: #{index}"
+      end
+      if (configuration_file_name == nil)
+        raise "Failed to pass a -c parameter for config file"
+      end
+
+      if (@target_server == nil)
+        raise "Must specify: -t 'target_server' on the command line"
+      end
+
+      uri = "http://#{server_address}/client"
+      puts "Wasp server: #{uri}"
+      create_run(node_count, configuration_file_name, server_address, @target_server)
+
+      launch_node_command = "\nTo Start Nodes:\n"
+      @node_info_json.each do |node_config|
+        code = node_config["code"]
+        launch_node_command += "  ruby wasp.rb node -c #{code} -s #{server_address} -r #{@run_id}\n"
+      end
+
+      puts "
+  Run established.
+  Run ID: #{@run_id}
+  Waiting for #{node_count} nodes.
+  Run details page:    http://#{server_address}/reports/run_details?run=#{@run_id}
+  #{launch_node_command}
+          "
+
+    elsif (main_command == "node")
+      @run_id = nil
+      load_node = process_node_command(args)
+    else
+      help_text =
+        "Usage:
+           wasp run  -n /node_count/ -d /definition code/          {start with this process being the only node}
+           wasp node m        {m is number of nodes, returns the run id for the node start up}
+           wasp node -r /run_id/   {starts one of the nodes for a run}
+        "
+      puts help_text
+    end
+  end
+
+  def create_run(node_count, configuration_file_name, wasp_server_address, target_server)
+    messenger = HttpReport.new(wasp_server_address)
+    @run_id = messenger.run_create({ node_count: node_count, config_file_name: configuration_file_name, target_server: target_server})
+    @node_info_json = messenger.run_node_info({run_id: @run_id})
+  end
+
+  def process_node_command(args)
+    while (index < args.length)
+      arg = args[index]
+      if (arg == "-r")
+        index += 1
+        @run_id = args[index].to_i
+      elsif (arg == "-s")
+        index += 1
+        server_address = args[index]
+      elsif (arg == "-c")
+        index += 1
+        node_code = args[index]
+      end
+      index += 1
+    end
+
+    if (@run_id == nil)
+      raise "Failed to pass the run_id with -r for the node to run against."
+    end
+    if (server_address == nil)
+      raise "Failed to pass the server address with -s for the node to run against."
+    end
+
+    load_node = launch_node(@run_id, server_address, node_code)
+    return load_node
+  end
+
+  def launch_node(run_id, wasp_server_address, node_code)
+    load_node = LoadNode.new(run_id, wasp_server_address, node_code)
+  end
+
+end

data/lib/load/http_report.rb

@@ -0,0 +1,132 @@
+require "json"
+require "net/http"
+
+class HttpReport
+  
+  def initialize(server_address)
+    @server = server_address
+  end
+
+  def server_address
+     return "http://#{@server}/client"
+  end
+  
+  def post(action, params)
+    address = server_address + action
+    puts "Posting to: #{address},  Params: #{params}"
+    uri = URI.parse(server_address + action)
+    begin
+      response = Net::HTTP.post_form(uri, params)
+    rescue Errno::ETIMEDOUT => error
+      raise "Communication with server error: #{error}   Address: #{uri}"
+    end
+    
+    if (response.code != "200")
+      puts "Action: #{action} Response: #{response.code} Response body: #{response.body}"
+      raise "Bad response from load http: #{response.code}  Response: #{response.body}"
+    end
+    return response.body
+  end
+  
+  def node_finished(params)
+    post "/node_finished", params
+  end
+  
+  def report_result(run_id, node_id, test_code, wasp_id, run_at_millis, time, result)
+    response = nil
+    begin
+      millis = nil
+      if (time != nil)
+        millis = time * 1000
+      end
+      response = post "/timing", {"run_at_millis" => run_at_millis, "time" => "#{millis}", "run_id" => run_id, "node_id" => node_id,"test_code" => test_code, "wasp_id" => wasp_id.to_s, "result" => result}
+    rescue Exception => e
+      puts "Error sending results (#{result} in #{millis}) to server(#{server_address}): #{e.message}"
+    end
+    return response
+  end
+  
+  def status_for_test(run_id, wasp_id)
+    # Checking for kill or finished run.
+    response = post("/status_for_test", {"run_id" => run_id, 'wasp_id' => wasp_id})
+    return JSON.parse(response)
+  end
+
+  def report_load_to_server(run_id, time, load_count)
+    response = post "/load", {"run_id" => run_id, "time" => time, "load" => load_count}
+  end
+
+  def node_register(params)
+    response = post("/node_register", params)
+    data = JSON.parse(response)
+    return data
+  end
+  
+  def node_monitors(params)
+    response = post("/node_monitors", params)
+    data = JSON.parse(response)
+    return data
+  end
+  
+
+  def node_start?(params)
+    response = post("/node_ask_to_start", params)
+    data = JSON.parse(response)
+    #puts "Node start response: #{data}"
+    return data["start"]
+  end
+
+  def node_schedule(params)
+    response = post("/node_schedule", params)
+    data = JSON.parse(response)
+    return data
+  end
+  
+  def node_ready(params)
+    response = post("/node_ready", params)
+    return response
+  end
+  
+  def run_create(params)
+    node_count = params[:node_count]
+    if (node_count == nil)
+      node_count = 1
+      params[:node_count] = node_count
+    end
+
+    if (params[:config_file_name] != nil)
+      file_name = params[:config_file_name]
+      config_from_file = ""
+      begin      
+        File.open(file_name, "r") do |f|
+          config_from_file = f.read()
+        end
+        params[:config_file_name] = file_name
+        # params[:configuration] = config_from_file
+        configuration = eval(config_from_file)
+        server_list = configuration[:servers]
+        raise "Configuration lacks 'servers' list" unless (server_list != nil)
+        target_server_address = server_list[params[:target_server].to_sym]
+        raise "Configuration lacks entry in 'servers' list for ':#{params[:target_server]}'\n #{server_list}" unless target_server_address != nil
+        params[:configuration] = configuration.to_s
+        params[:config_code] = configuration[:code]
+        raise "'duration' not specified for run." unless configuration[:duration] != nil
+        params[:duration] = configuration[:duration]
+        params[:name] = configuration[:name]
+      rescue Exception => e
+        raise "Exception reading config from file(#{File::absolute_path(file_name)}): #{e.message}"
+      end
+    end
+    
+    response = post("/run_create", params)
+    data = JSON.parse(response)
+    return data["run_id"].to_i
+  end
+  
+  def run_node_info(params)
+    response = post("/run_node_info", params)
+    data = JSON.parse(response)
+    return data
+  end
+  
+end

data/lib/load/load_manager.rb

@@ -0,0 +1,74 @@
+require_relative "./load_ramp_up"
+require_relative "./load_reporter"
+require_relative "./test_factory"
+require_relative "./http_report"
+
+
+class LoadManager
+  attr_reader :run_id, :configuration
+
+  def initialize(configuration, target_code)
+    @configuration = configuration
+  end
+
+  def ramp_up
+    puts "Load Manager - ramp_up"
+    puts "Load Manager: #{Process.pid}"
+    pids = []
+
+    definition_code = configuration[:code]
+    @server_address = ENV["SERVER"] || "localhost:2233"
+    puts "Server address: #{@server_address}"
+    ENV[""]
+
+
+    if (ENV['SERVER'] == nil)
+      puts "No 'SERVER' env specified, creating local/minimal server to store results"
+      pids << fork {
+        @reporter = LoadReporter.new({server: @server_address})
+        while (@reporter.started == false)
+          puts "Cannot find Wasp server"
+          sleep 1
+        end
+      }
+    else
+      puts "Using existent 'SERVER': #{@server_address}"
+    end
+
+    @run_id = create_run({definition_code: definition_code})
+    ramp_up = LoadRampUp.new(@run_id, @target_code, @configuration)
+
+    pids << fork {
+      ramp_up.run
+    }
+
+    quit = false
+    while !quit
+      begin
+        system("stty raw -echo")
+        str = STDIN.getc
+      ensure
+        system("stty -raw echo")
+      end
+      input = str.chr
+      puts "You pressed: #{input}  ##{str.to_i}"
+      if (input == "q")
+        quit = true
+        puts "=================================================================================="
+        puts "DONE WITH RAMP UP"
+        puts "  PID's:  #{pids}"
+        puts "=================================================================================="
+      end
+    end
+    kill_pids(pids)
+  end
+
+
+  def kill_pids(pids)
+    puts "Killing child processes"
+    pids.each do |pid|
+      Process.kill("INT", pid)
+    end
+  end
+
+end

data/lib/load/load_node.rb

@@ -0,0 +1,217 @@
+require_relative "./http_report"
+require_relative "./load_test"
+require_relative "./monitors/cpu_monitor.rb"
+require_relative "./monitors/ram_monitor.rb"
+require_relative "./monitors/file_io_monitor.rb"
+require_relative "./monitors/network_monitor.rb"
+require_relative "./test_factory.rb"
+
+@@load_node_instance = nil
+
+class LoadNode
+  attr_reader :node_id, :schedule, :duration_millis
+  attr_accessor :target_server, :target_code
+  
+  def self.instance
+    return @@load_node_instance
+  end
+  
+  def initialize(run_id, server_address, node_code = nil)
+    if (@@load_node_instance != nil)
+      raise "LoadNode instance initialized a second time"
+    end
+    @target_code = target_code
+    @test_index = 1
+    @messenger = nil
+    @@load_node_instance = self
+    @factory = TestFactory.new
+    if (server_address == nil)
+      # Perf tests don't require server
+    else
+      begin
+        puts "Registering node"
+        @run_id = run_id
+        @child_pids = []
+        @messenger = HttpReport.new(server_address)
+        node_info = @messenger.node_register({run_id: @run_id, address: "#{Socket.gethostname}", code: node_code})
+        if (node_info['configuration'] == nil)
+          puts "Error starting node.  Did run already complete?"
+        else  
+          @configuration = eval(node_info['configuration'])
+          @node_id = node_info["id"].to_i
+          @node_code = node_info["code"]
+          @target_code = node_info["target_server"]
+          @target_server = @configuration[:servers][@target_code.to_sym]
+          puts "Node registered: #{@node_id}   Code: #{@node_code}   Target server: #{@target_server}"
+          @schedule = @messenger.node_schedule({node_id: @node_id})
+          @load_tests = create_node_tests(@node_id, @schedule)
+          @duration_millis = node_info["duration"]
+          @messenger.node_ready({node_id: @node_id})
+          wait_for_node_start_ok
+          launch_node_tests
+          wait_for_finish
+          @messenger.node_finished({node_id: @node_id})
+        end
+      rescue Interrupt => e
+        puts "NODE (#{@node_id}) - Interrupt signal received, quitting.  [#{self.class}]"
+      rescue Exception => exc
+        puts "Exception in node: #{exc.message} \n" + exc.backtrace.join("\n")
+      ensure
+        kill_child_processes
+      end
+      #exit 0
+    end
+  end
+
+  def report_block_result(test_code, wasp_id, time_ellapsed, benchmark_time, result)
+    @messenger.report_result(@run_id, @node_id, test_code, wasp_id, time_ellapsed, benchmark_time, result)
+  end
+  
+  
+  def write_pid_to_file(pid)  
+    open('node_pids_#{@node_id}.pid', 'a') { |f|
+      f.puts "#{pid}\n"
+    }
+  end
+  
+  def launch_node_tests
+    @load_tests.each do |test|
+      pid = fork {
+        test.run
+      }
+      @child_pids << pid
+      write_pid_to_file(pid)
+    end
+  end
+
+
+  def wait_for_node_start_ok
+    ok_to_start = false
+    last_message_at = 0
+    while (!ok_to_start)
+      ok_to_start = @messenger.node_start?({node_id: @node_id})
+      sleep 0.2
+      if (Time.new.to_i - last_message_at > 5)
+        puts "Node waiting for other nodes to start (#{@node_code})"
+        last_message_at = Time.new.to_i
+      end
+    end
+    puts "All Nodes Launched.  Node (#{@node_code}) can start now "
+  end
+  
+  
+  def wait_for_finish
+      @start_time = Time.now.to_i
+      quit = false
+      while !quit
+        sleep 10
+        ellapsed_time = Time.now.to_i - @start_time
+        if (ellapsed_time > (@duration_millis / 1000))
+          quit = true
+          puts "Node duration reached: #{@duration_millis} seconds.  Node quitting"
+        else
+          #puts "Node duration (#{ellapsed_time} secs) NOT reached: #{@duration_millis/1000} seconds."
+        end
+        @messenger.node_schedule({node_id: @node_id})
+        
+        status = @messenger.status_for_test(@run_id, nil)
+        if (status['run_status'] == "killed")
+          puts "XXXXX  RUN HAS BEEN KILLED - KILLING NODE: #{@wasp_id}  XXXXXXX"
+          quit = true
+        elsif (status['run_status'] == "finished")
+          puts "XXXXX  RUN IS FINISHED - KILLING NODE: #{@wasp_id}  XXXXXXX"
+          quit = true
+        end
+        
+      end
+      puts "Node finished.  ##{@node_code}"
+  end
+  
+  
+  def create_node_tests(node_id, node_schedule)
+    wasp_id = 1
+    load_tests = []
+
+    puts "Node Schedule:"
+    node_schedule.each do |test_schedule|
+      test_name = test_schedule["test_name"]
+      events = test_schedule["events"]
+      sched_text = "Test: #{test_name}  Events: "
+      events.each do |event|
+        sched_text += "#{event['action'].capitalize} at #{event['time']} sec     "
+      end
+      test_config = find_config_for_test(test_name)
+      test = @factory.create_test(test_name, @target_code, test_config)
+      test.index = @test_index
+      @test_index += 1
+      
+      load_test = LoadTest.new(self, @run_id, node_id, wasp_id, test, events, @messenger)
+      load_tests << load_test
+      wasp_id += 1
+    end
+    
+    node_monitors = @messenger.node_monitors( {node_id: @node_id} )
+    node_monitors.each do |monitor_config|
+      type = monitor_config["type"]
+      name = monitor_config["name"]
+      duration = monitor_config["duration"].to_i / 1000
+      if (name == nil)
+        name = "#{type.capitalize} Monitor"
+      end
+      
+      if (type == "network")
+        puts "Config: #{monitor_config}"
+        address = monitor_config["address"]
+        monitor = NetworkMonitor.new(address)
+      elsif (type == "cpu")
+        monitor = CpuMonitor.new()
+      elsif (type == "file.io")
+        monitor = FileIoMonitor.new()
+      elsif (type == "ram")
+        monitor = RamMonitor.new()
+      else
+        raise "Do no know how to handle monitor type: #{type}   Name: #{name}"
+      end
+      
+      events = [{"time" => "0", "action"  => "run"}, {"time" => "#{duration}", "action" => "pause"}]
+      load_test = LoadTest.new(self, @run_id, node_id, wasp_id, monitor, events, @messenger)
+      load_tests << load_test
+      wasp_id += 1
+    end
+    
+    return load_tests
+  end
+  
+  def find_config_for_test(test_name)
+    test_configs = @configuration[:tests]
+    test_configs.each do |test_config|
+      if (test_config[:test] == test_name)
+        return test_config
+      end
+    end
+  end
+
+  
+  def kill_child_processes
+    # puts "=================================================================================="
+    # puts "Node Finished: #{@node_id}"
+    # puts "  Killing child PID's:  #{@child_pids}"
+    # puts "=================================================================================="
+
+    # trap("INT") do
+    #   exit
+    # end
+    Process.kill('INT', -Process.getpgrp)
+    # 
+    # @child_pids.each do |pid|
+    #   begin
+    #     puts "Killing: #{pid}"
+    #     Process.kill("INT", pid)
+    #   rescue Exception => e
+    #     puts "Exception killing pid #{pid}.  #{e.message}"
+    #   end
+    # end
+  end
+  
+  
+end

data/lib/load/load_ramp_up.rb

@@ -0,0 +1,159 @@
+require_relative "./load_test"
+require_relative "./http_report"
+require_relative "./test_factory"
+
+
+class LoadRampUp
+  attr_reader :tests
+  
+  
+  def initialize(run_id, target_code, configuration)
+    puts "Load Ramp Up created"
+    if (run_id == nil)
+    end
+    @pids = []
+    @run_id = run_id
+    @target_code = target_code
+    @factory = TestFactory.new
+    @tests = {}
+    @all_tests = []
+    @configuration = configuration
+    wasp_id = 0
+    
+    @configuration[:tests].each do |test_config|
+      test_class = test_config[:test]
+      
+      initial_count = test_config[:initial]
+      ramp_up_config = test_config[:ramp_up]
+      final_count = ramp_up_config[:final]
+      @tests[test_class] = []
+      while (@tests[test_class].length < final_count)
+        #                       (run_id, node_id, wasp_id, test, schedule_events, messenger)
+        test = @factory.create_test(test_class, @target_code, test_config)
+        load_test = LoadTest.new(self, run_id, nil, wasp_id, test, test_config, messenger)
+        wasp_id += 1
+        @tests[test_class] << load_test
+        @all_tests << load_test
+      end
+      assign_schedules_to_tests(test_config,  @tests[test_class])
+    end
+    send_schedule_to_server(@configuration)
+  end
+
+
+  def send_schedule_to_server(configuration)
+    (0..duration).each do |time|
+      total_load = 0
+      @all_tests.each do |test|
+        action = test.schedule.current_action(time)
+        if (action == :run)
+          total_load += 1
+        end
+      end    
+      report_load_to_server(@run_id, time, total_load)
+    end
+  end
+
+
+  def duration
+    last_time = 0
+    @all_tests.each do |test|
+      test_last_time = test.duration
+      if (test_last_time > last_time)
+        last_time = test_last_time
+      end
+    end
+    return last_time
+  end
+  
+
+  def find_total_loads
+    load_at_times
+    time = 0
+    while (!done) do
+      count = 0
+      @all_tests.each do |test|
+        if (test.current_action(time) == :run)
+          count += 1
+        end
+      end
+      time += 1
+    end
+  end
+  
+  
+  def assign_schedules_to_tests(test_config, load_tests)
+    ramp_up = test_config[:ramp_up]
+    initial_count = test_config[:initial]
+    
+    load_tests.each do |test|
+      test.schedule.add(0, :pause)
+    end
+    
+    (0..initial_count - 1).each do |index|
+      test = load_tests[index]
+      test.schedule.add(0, :run)
+    end
+    
+    rate = ramp_up[:rate]
+    current_time = 0
+    tests_started = initial_count
+     while (tests_started < ramp_up[:final]) do
+       current_time += rate
+       load_tests[tests_started].schedule.add(current_time, :run)
+       tests_started += 1
+     end
+     
+     sustain_time = test_config[:sustain]
+     current_time += sustain_time
+     
+     ramp_down = test_config[:ramp_down]
+     final_count = ramp_down[:final]
+     rate = ramp_down[:rate]
+     while (tests_started > final_count) do
+       load_tests[tests_started - 1].schedule.add(current_time, :pause)
+       tests_started -= 1
+       current_time += rate
+     end
+  end
+
+  
+
+  def run
+    begin
+       puts "Running Load test"
+       @configuration[:tests].each do |test_config|
+         test_name = test_config[:name]
+         puts "Starting test: #{test_name}"
+         @tests[test_name].each do |load_test|
+           @pids << fork {
+             #puts "Launching test: #{test_name} : #{load_test.wasp_id}"
+             load_test.run
+           }
+         end
+       end
+       wait_for_kill_signal()
+    rescue Interrupt => e
+      puts "Interrupt signal received, quitting.  [#{e.class.name}]   #{e.message}"
+    ensure
+      kill_pids(@pids)
+    end
+    exit 0
+  end
+
+  
+  def wait_for_kill_signal()
+    while (true) do
+      sleep 2000
+    end
+  end
+  
+  
+  def kill_pids(pids)
+    puts "Killing child processes"
+    pids.each do |pid|
+      Process.kill("INT", pid)
+    end
+  end
+  
+end

data/lib/load/load_reporter.rb

@@ -0,0 +1,48 @@
+require 'webrick'
+
+class LoadReporter
+  attr_reader :started
+  include WEBrick
+
+  def initialize(params)
+    puts "Initializing Load Reporter"
+    @started = false
+    @server_address = params[:server]
+    @current_load = 0
+    file_name = "data_#{Time.now.to_i}.txt"
+    @out_file = File.new("out.txt", "w")
+    port = params[:port] || 2233
+    puts "Starting server: http://#{Socket.gethostname}:#{port}"
+    server = HTTPServer.new(:Port=>2233,:DocumentRoot=>Dir::pwd )
+    trap("INT") {
+      puts "Server going down" 
+      server.shutdown 
+    }
+    
+    server.mount_proc '/' do |request, response|
+      response.body = process_request(request)
+    end
+    server.start  
+    @started = true
+  end
+  
+  
+  def process_request(request)
+  response = "
+      Current Load: #{@current_load}
+      Query String: #{request.query_string}
+    "
+       
+    request.query.collect { | key, value | 
+      #f.write("#{key}: #{value}\n") 
+      if (key == "load")
+        @current_load = value.to_i
+        response += "Current load changed to: #{@current_load}"
+      end
+      response += "#{key}: #{value}\n"
+    }
+    puts "RESPONSE: #{response}"
+    return response
+  end
+  
+end

data/lib/load/load_test.rb

@@ -0,0 +1,196 @@
+require "net/http"
+require "uri"
+require "benchmark"
+require_relative "http_report"
+require_relative "load_test_schedule"
+require 'logger'
+require 'fileutils'
+
+class LoadTest
+  PASSED = "passed"
+  FAILED = "failed"
+  
+  attr_reader :wasp_id, :start_time, :test
+  attr_accessor :schedule
+  
+  def initialize(owner, run_id, node_id, wasp_id, test, schedule_events, messenger = nil)
+    @owner = owner
+    test.owner = self
+    @schedule = LoadTestSchedule.new
+    @schedule.load_json(schedule_events)
+    @messenger = messenger
+    @node_id = node_id
+    @wasp_id = wasp_id
+    @time_of_last_status_check = 0
+    
+    @test = test
+    if (run_id == nil) || (run_id == 0)
+      raise "No run_id specified for load test"
+    end
+    test_code = self.class.name
+    @run_id = run_id
+    @name = "Test for #{test.test_code}"
+  end
+
+  def log
+    return @logger
+  end
+  
+  def create_logger
+    FileUtils.mkdir_p('./log/load') unless File.directory?('./log/load')
+    FileUtils.mkdir_p("./log/load/run_#{@run_id}") unless File.directory?("./log/load/run_#{@run_id}")
+    log_file = "./log/load/run_#{@run_id}/#{@test.class.name}_#{@wasp_id}.log"
+    @logger = Logger.new(log_file)
+    @logger.level = Logger::DEBUG
+    @test.logger = @logger
+  end
+  
+  def run
+    create_logger()
+    trap('INT') do
+        puts "Wasp asked to die: #{test_code}:#{@wasp_id}  Pid: #{Process.pid}"
+        #log.info "Wasp asked to die: #{test_code}:#{@wasp_id}  Pid: #{Process.pid}"
+        exit 0
+    end
+      
+    begin
+      @start_time = Time.now
+      @exit  = false
+      while (!@exit)
+        result = FAILED
+        run_if_time_right(time_ellapsed_millis)
+      end
+      puts "End of run for wasp: #{@wasp_id}.  Duration: #{duration_millis}"
+      log.info "End of run.  Duration: #{duration_millis}"
+    rescue Interrupt => e
+      log.warn "WASP KILL: #{test_code}:#{@wasp_id} Interrupt signal received, quitting.  [#{e.class.name}]   #{e.message}"
+      puts "WASP KILL: #{test_code}:#{@wasp_id} Interrupt signal received, quitting.  [#{e.class.name}]   #{e.message}"
+      @exit = true
+    rescue Exception => exc
+      log.warn "Exception in wasp: #{@wasp_id} .  [#{exc.class.name}]   #{exc.message}"
+      puts "Exception in wasp: #{@wasp_id} .  [#{exc.class.name}]   #{exc.message}"
+    ensure
+      log.info "Wasp process exiting: #{test_code}:#{@wasp_id}  Pid: #{Process.pid}"
+      puts "Wasp process exiting: #{test_code}:#{@wasp_id}  Pid: #{Process.pid}"
+      exit 0
+    end
+  end
+
+  
+  def run_if_time_right(current_time_millis)
+    benchmark_time = 0
+    if (current_time_millis >= duration_millis)
+      @exit = true
+      puts "Time for LoadTest instance to die.  Ellapsed: #{current_time_millis}  Test duration: #{duration_millis}"
+    else
+      current_action = current_action_for_time(current_time_millis)
+      if (current_action == :run)
+        #puts "Time is right.  Test being performed"
+        result = PASSED
+        begin        
+          benchmark_time = Benchmark.realtime {
+            perform_test
+          }
+          log.info "Test completed normally in #{benchmark_time} seconds"
+        rescue SystemExit => se
+          log.warn "Caught system exit signal.  Exiting..."
+          @exit = true
+        rescue Exception => e
+          result = FAILED
+          log.error("Test (#{@test.class}) produced exception: #{e.class} #{e.message}")
+          e.backtrace.each do |back|
+            log.error(back)
+          end
+          puts "Test (#{@test.class}) produced exception: #{e.class} #{e.message} #{e.backtrace}"
+        end
+        
+        custom_timing =  @test.timing
+        if (custom_timing != nil)
+          benchmark_time = custom_timing
+        end
+        @messenger.report_result(@run_id, @node_id, @test.test_code, @wasp_id, current_time_millis, benchmark_time, result)
+      else
+        #puts "Not running test.  current_action = #{current_action}"
+        sleep 0.2
+      end
+      
+      if (@exit == false)
+        time_since_last_status_check = current_time_millis - @time_of_last_status_check
+        if (time_since_last_status_check > 20*1000)
+          @time_of_last_status_check = current_time_millis
+          status = @messenger.status_for_test(@run_id, @wasp_id)
+          if (status['run_status'] == "killed")
+            log.warn "XXXXX  RUN HAS BEEN KILLED - KILLING WASP: #{@wasp_id}  XXXXXXX"
+            @exit = true
+          elsif (status['run_status'] == "finished")
+            log.warn "XXXXX  RUN IS FINISHED - KILLING WASP: #{@wasp_id}  XXXXXXX"
+            @exit = true
+          end
+        end
+      end
+    end
+  end
+  
+
+
+  def duration_millis
+    last_run_time = nil
+    @schedule.events.each do |event|
+      if (event[:action] == :run)
+        last_run_time = nil
+      else
+        last_run_time = event[:time]
+      end
+    end
+    
+    if (last_run_time == nil)
+      raise "This test never finishes on it's own"
+    end
+    return (last_run_time * 1000)
+  end
+
+
+  def time_ellapsed_millis
+    time_ellapsed = (Time.now - @start_time) * 1000.0
+    return time_ellapsed
+  end
+
+  def report_block_result(test_code, wasp_id, ellapsed_millis, benchmark_time, result, target_code = "unknown")
+    @owner.report_block_result(test_code, wasp_id, ellapsed_millis, benchmark_time, result)
+  end
+
+  def current_action
+    return current_action_for_time(time_ellapsed_millis)
+  end
+    
+  def current_action_for_time(millis)
+    current_action = schedule.current_action(millis / 1000)
+    return current_action
+  end
+  
+  def test_code
+    return @test.test_code
+  end
+  
+  def to_s
+    return "I am only one wasp of a swarm.  ##{@wasp_id}"
+  end
+
+  def assert(value)
+    if (value == false)
+      raise "Assertion failed"
+    end
+  end  
+  
+  def perform_test
+    @test.owner = self
+    @test.set_up
+    @test.run
+    @test.pause_after_run
+    @test.tear_down
+  end
+  
+end
+
+
+

data/lib/load/load_test_schedule.rb

@@ -0,0 +1,79 @@
+class LoadTestSchedule
+  attr_accessor :events
+  
+  def initialize
+    @events = []
+    @previous_action = nil
+  end
+  
+  def add(time, action)
+    if (action != @previous_action)
+      remove_action_at_time(time)
+      @events << {time: time, action: action}
+    else
+      warn "Attempt to add same action consecutively, ignoring the later one.  Time: #{time}  Action: #{action}"
+    end
+    @previous_action = action
+  end
+  
+  def load_json(schedule_events)
+    schedule_events.each do |event|
+      time = event["time"].to_i
+      action = event["action"].to_sym
+      add(time, action)
+    end
+  end
+  
+  def remove_action_at_time(time)
+    (0..@events.length - 1).each do |i|
+      if (@events[i][:time] == time)
+        @events.delete_at(i)
+        return
+      end
+    end
+  end
+  
+  
+  def current_action(time)
+    event = current_event(time)
+    if (event == nil)
+      return :pause
+    else
+      return event[:action]
+    end
+  end
+
+
+  def next_action(time)
+    event = next_event(time)
+    if (event == nil)
+      return nil
+    else
+      return event[:action]
+    end
+  end
+  
+  
+  def current_event(time)
+    current_event = nil
+    @events.each do |event|
+      if (event[:time] <= time.to_i)
+        current_event = event
+      end
+    end
+    return current_event
+  end
+
+
+  def next_event(time)
+    current_event = nil
+    @events.each do |event|
+      if (event[:time] > time.to_i)
+        return event
+      end
+    end
+    return @events.last
+  end
+  
+  
+end

data/lib/load/meter/meter.rb

@@ -0,0 +1,2 @@
+class Meter
+end

data/lib/load/monitors/cpu_monitor.rb

@@ -0,0 +1,30 @@
+require "uri"
+require "benchmark"
+require_relative "../timing_test"
+
+
+class CpuMonitor < TimingTest
+
+  def initialize
+    @sleep_seconds = 4
+  end
+
+  def run
+    a = 5000
+    (0..1000).each do |i|
+      a /= 2.0
+    end
+  end
+
+  def pause_after_run
+    sleep @sleep_seconds
+  end
+
+
+  def test_code
+    return ("monitor.cpu")
+  end
+
+end
+
+

data/lib/load/monitors/file_io_monitor.rb

@@ -0,0 +1,42 @@
+require "uri"
+require "benchmark"
+require_relative "../timing_test"
+
+
+class FileIoMonitor < TimingTest
+
+  def initialize
+    @sleep_seconds = 4
+  end
+
+  def run
+    file_name = "./log/file_io_bench_#{Time.now.to_i}.dat"
+    (1..200).each do |i|
+      File.open(file_name, 'w') { |file| 
+        (1..1000).each do |i|
+          file.write("Test text #{i} aohoasihdf oiahsdf pohiasdfha oisdhf aiousdfgho iausgdf oaia aiusdhfia hdfihdsfi ahsdfi ahudf \n") 
+          file.flush
+        end
+      }
+    
+      File.readlines(file_name).each do |line|      
+        if (!line.start_with? "Test text")
+          raise "Error reading back file"
+        end
+      end
+      File.delete(file_name)
+    end
+  end
+
+  def pause_after_run
+    sleep @sleep_seconds
+  end
+
+
+  def test_code
+    return ("monitor.file")
+  end
+
+end
+
+

data/lib/load/monitors/network_monitor.rb

@@ -0,0 +1,48 @@
+require_relative "../timing_test"
+require 'net/ping'
+
+
+class NetworkMonitor < TimingTest
+  attr_accessor :address
+
+  def initialize(address)
+    @sleep_seconds = 4
+    @address = address
+  end
+
+  def timing
+    return @timing
+  end
+
+  def run
+    output = ""
+    begin
+      timing = 0
+      pinger = Net::Ping::External.new
+      (1..10).each do
+        pinger.ping(@address)
+        timing += (pinger.duration * 1000.0)
+      end
+      puts "Ping timing for 10 pings: #{timing}"
+      @timing = timing
+    rescue Exception => e
+      @timing = nil
+      puts "Error pinging address: #{@address}    =>   #{output}"
+      raise "Error pinging address: #{@address}    =>   #{output}"
+    end
+  end
+  
+  #64 bytes from localhost (127.0.0.1): icmp_req=4 ttl=64 time=0.015 ms
+  #64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.018 ms
+
+  def pause_after_run
+    sleep @sleep_seconds
+  end
+
+  def test_code
+    return ("monitor.network")
+  end
+
+end
+
+

data/lib/load/monitors/ram_monitor.rb

@@ -0,0 +1,25 @@
+require_relative "../timing_test"
+
+
+class RamMonitor < TimingTest
+
+  def initialize
+    @sleep_seconds = 4
+  end
+
+  def run
+    
+  end
+
+  def pause_after_run
+    sleep @sleep_seconds
+  end
+
+
+  def test_code
+    return ("monitor.ram")
+  end
+
+end
+
+

data/lib/load/test_factory.rb

@@ -0,0 +1,20 @@
+# Require all files in custom test directory
+this_dir_name = File.dirname(File.absolute_path(__FILE__))
+Dir.glob(this_dir_name + '/custom/*') {|file| require file}
+
+class TestFactory
+
+  def initialize
+  end
+  
+  def create_test(test_code, target_code, config)
+    test_class = test_code.split(".").first
+    test_object = Object::const_get(test_class).new
+    test_object.test_code = test_code
+    test_object.target_code = target_code
+    raise "No parameters for target: :#{target_code}  Test: #{test_code}" unless (config[:params] != nil) && config[:params][target_code.to_sym]
+    test_object.params = config[:params][target_code.to_sym]
+    return test_object
+  end
+  
+end

data/lib/load/timing_test.rb

@@ -0,0 +1,76 @@
+require "uri"
+require "benchmark"
+
+
+class TimingTest
+  attr_accessor :params, :index, :owner, :test_code, :logger, :target_code
+  
+  def initialize
+    @params = {}
+    @index = 0
+    @owner = nil
+    @test_code = nil
+    @target_code = nil
+  end
+  
+  def set_up
+  end
+  
+  def tear_down
+  end
+  
+  def run
+    raise "Not Implemented"
+  end
+  
+  def server_url
+    url = LoadNode.instance.target_server
+    if (url == nil)
+      raise "target_server not specified when starting main process"
+    end
+    return url
+  end
+  
+  def ellaped_millis
+    @owner.time_ellapsed_millis
+  end
+
+  def log
+    return @logger
+  end
+  
+  def time_block(code)
+    start_time = Time.now
+    begin
+      yield
+      end_time = Time.now
+      block_time = (end_time.to_f - start_time.to_f) * 1000
+      @owner.report_block_result(code, @index, @owner.time_ellapsed_millis, block_time, LoadTest::PASSED, target_code)
+    rescue Exception => e
+      log.error("Exception running timing block (#{code}) test: #{e.message}")
+      end_time = Time.now
+      block_time = (end_time.to_f - start_time.to_f) * 1000
+      @owner.report_block_result(code, @index, @owner.time_ellapsed_millis, block_time, LoadTest::FAILED, target_code)
+      raise e
+    end
+  end
+
+
+  def assert(value)
+    if (value == false)
+      puts "Assertion failed"
+      raise "Assertion failed"
+    end
+  end  
+  
+  def pause_after_run
+    # Default is no pause
+  end
+  
+  def timing
+    # LoadTest times the run method and uses that timing unless the instance of TimingTest timing method returns a non-nil time.
+    return nil
+  end
+  
+end
+

data/lib/ruby_load.rb

@@ -0,0 +1 @@
+Dir["#{File.dirname(__FILE__)}/load/**/*.rb"].each {|f| require f}

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: ruby-load
+version: !ruby/object:Gem::Version
+  version: 0.4.8
+platform: ruby
+authors:
+- Mike Moore
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-29 00:00:00.000000000 Z
+dependencies: []
+description: Ruby Load Tester
+email: m.moore.denver@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/load/client_command_line.rb
+- lib/load/http_report.rb
+- lib/load/load_manager.rb
+- lib/load/load_node.rb
+- lib/load/load_ramp_up.rb
+- lib/load/load_reporter.rb
+- lib/load/load_test.rb
+- lib/load/load_test_schedule.rb
+- lib/load/meter/meter.rb
+- lib/load/monitors/cpu_monitor.rb
+- lib/load/monitors/file_io_monitor.rb
+- lib/load/monitors/network_monitor.rb
+- lib/load/monitors/ram_monitor.rb
+- lib/load/test_factory.rb
+- lib/load/timing_test.rb
+- lib/ruby_load.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/ruby_load
+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.0.14.1
+signing_key: 
+specification_version: 4
+summary: Ruby Load Tester
+test_files: []