Threads spawning more threads

<%

#!/usr/bin/env ruby
## kill some warnings about writable directories
$VERBOSE=nil

# we want to parse input, right?
require 'optparse'

## global options (which can and will be changed)
@@options = {
		:runtime => "01:00:00",
		:total_time => 0,
		:threadlist => [],
	}


def parse_input()
  ARGV.options do |opts|
    opts.banner = "Usage: #{$0} [options] <thread names>"
    opts.separator "Threadeds spawning threads, oh my!"
    opts.separator ""
    opts.separator "Options:"

    opts.on("-h", "--help", "show this message") {
      puts opts
      exit
    }

    opts.on("-v", "--version", "show version details") {
      version = `grep -m 1 "#(@)" #{$0} | awk '{printf("version: %s (%s)",$3,$2)}'`
      puts version
      exit
    }  

    opts.on("--duration=HH:MM:SS", String, "specify how long to run test (default: #{@@options[:runtime]})") { |@@options[:runtime]| }

    opts.parse!
  end
  
  ## validate time
  hours, mins, secs = @@options[:runtime].to_s.split(":")
  if hours.nil? or mins.nil? or secs.nil?
    puts "ERROR -- Invalid time format!"
    exit 1
  end  

  @@options[:total_time] = (hours.to_i * 60 * 60) + (mins.to_i * 60) + secs.to_i

  ## thread list, anyone?
  if ARGV.length < 1
  	puts "ERROR! No thread names specified!"
	exit 1
  else
  	@@options[:threadlist] = ARGV
  end	
end

@threads = []
@start_time = Time.now

## trap ctrl-c
trap("INT") { threadDestroyAll() }

def newPass(threadname)
  ## create a new thread and add it to @threads
  @threads << Thread.new(threadname) { |myThread|
	## trap that CTRL-C
	trap("INT") { threadDestroyAll() }
  	## name thread to that of name given. easier management
  	Thread.current[:name] = "#{myThread}"
  	
  	## Stuff for thread to do goes here.
  }	
end

## this is triggered via CTRL-C trap above
# kill all threads and exit
def threadDestroyAll()
  puts "***************************"
  puts "** Killing all processes **"
  puts "***************************"
  @threads.each { |thread| thread.kill }
  sleep 2
  Thread.main.kill
end

## needed a way to watch over all the baby threads
# this will cycle through all threads, gathering a list of
#+ those that are still running (and their names, which are that of the client)
#+ any missing clients are then restarted.
def threadOverlord(threads)
  threadList = activeThreads = deadThreads = [] 
  threadList = @@options[:threadlist]
  threads.each { |thread| activeThreads << thread[:name] if thread.alive? and keepGoing() }
  ## restart baby threads that have died?
  # if time limit has been reached, that is a no
  if keepGoing()
    deadThreads = threadList - activeThreads
    deadThreads.each { |threadname| newPass(threadname) }
  end  
  activeThreads = deadThreads = threadList = nil
end  

## parent thread
# this is just to trigger threadOverlord every X seconds
#+ and check on the health of client threads
def statusThread()
  statusT = Thread.new { 
    Thread.current[:name] = "Overlord"
    loop do 
      threadOverlord(@threads) 
      sleep 15 
      break if !keepGoing() 
    end
   }
  statusT.join
end

## returns true if there is still time remaining
def keepGoing()
  return true if Time.now.to_i - @start_time.to_i < @@options[:total_time].to_i
  false
end  

parse_input()
statusThread

%>