With the next release of the Ruby Task Distributor, I'm changing it's name 
to TaskMaster (It's shorter and snazzier which makes it more marketable 
;-).

What is it?
TaskMaster is a framework for distributing runnable task objects to 
multiple client machines (runnable meaning they respond to a 'run' method 
which is invoked once the task object arrives at the client).

What's it good for?
It's good for parallelizing a set of tasks so that instead of running 
serially on one machine they can be distributed to multiple clients.  For 
example, say you have a testsuite which contains thousands of testcases 
and it takes 8 hours to run on one machine.  You'd like to get answers 
faster than that.  You can use TaskMaster to distribute testcases to, 
say, 8 machines and get results in an hour (or if you've got lots of 
machines, you could distribute to 16 machines and get answers in 30 
minutes... well, if your longest testcase takes longer than 30 minutes to 
run then it'll take longer, but you get the idea).

What has changed since Ruby Task Distributor 0.0.1?

Lots of stuff... including:
* you can now specify your own 'reporter' objects which are used to report 
results from clients as they are 'harvested'.  Reporter objects need to 
define a 'report' method.
* you can now specify a time period whereby every 'x' (user specified) 
seconds the distributor can check to see if clients which may have died 
(think Windows here :) have since been restarted (after a reboot - think 
Windows here :)
* you can now specify a set of criteria (attributes) that a client should 
satisfy in order for it to be included in the set of clients - for 
example, say you want to ensure that a client is running a certain version 
of a program that is to be tested.  You can now specify methods to 
determine the programs's version on the client side and you can specify on 
the distributor's side what the version number should be - if the client's 
version doesn't match the specified version you'll be promted when you 
start TaskMaster at which time you can choose to include the client or 
not.
* runnable task objects can now have a method called: pre_run_init. If a 
runnable task oject has this method (checked with a 'responds_to?' ) when 
it arrives on the client side, it is invoked.  Think of this as a 
secondary constructor that is called on the client side (Remember, the 
task object is originally constructed on the distributor(server) side and 
passed to a client.  Since it was already 'constructed' on the 
server-side, pre_run_init allows you to set up certain things on the 
client side within the context of the client's environment.  You could 
have done that within the task object's 'run' method too, though.)
* bug fixes.


Where do I get it?
http://www.aracnet.com/~ptkwt/ruby_stuff/TaskMaster
(it'll be there in a couple of hours anyway - so if you don't see it yet, 
try again)

Phil