remote_run 0.1.0 → 0.1.1

data/lib/remote_run/configuration.rb

@@ -0,0 +1,98 @@
+module RemoteRun
+  class Configuration
+    attr_accessor :remote_path, :local_path, :login_as, :exclude, :temp_path, :quiet
+    attr_reader :local_hostname, :identifier, :start_time
+    attr_reader :host_manager, :task_manager
+
+    def initialize
+      @task_manager = TaskManager.new
+      @host_manager = HostManager.new
+
+      @local_path = Dir.getwd
+      @login_as = `whoami`.strip
+      @remote_path = "/tmp/remote"
+      @exclude = []
+      @temp_path = "/tmp/remote"
+      @quiet = false
+      @start_time = Time.now
+
+      # used in the runner
+      @identifier = `echo $RANDOM`.strip
+      @local_hostname = `hostname`.strip
+
+      $runner = self
+      yield self
+    end
+
+    def hosts
+      @host_manager.hosts
+    end
+
+    def tasks
+      @task_manager.tasks
+    end
+
+    def hosts=(hostnames)
+      hostnames.each do |hostname|
+        @host_manager.add(Host.new(hostname))
+      end
+    end
+
+    def tasks=(shell_commands)
+      shell_commands.each do |shell_command|
+        @task_manager.add(Task.new(shell_command))
+      end
+    end
+
+    def run
+      Runner.new(self).run
+    end
+
+    private
+
+    class HostManager
+      def initialize(&block)
+        @hosts = []
+      end
+
+      def add(host)
+        Thread.new do
+          if host.is_up?
+            @hosts << host
+          end
+        end
+      end
+
+      def hosts
+        while @hosts.empty?
+          sleep(0.5)
+        end
+        @hosts
+      end
+    end
+
+    class TaskManager
+      attr_reader :tasks
+
+      def initialize
+        @tasks = []
+      end
+
+      def add(task)
+        @tasks.push(task)
+      end
+
+      def find_task
+        @tasks.shift
+      end
+
+      def count
+        @tasks.length
+      end
+
+      def has_more_tasks?
+        @tasks.size > 0
+      end
+    end
+  end
+end

data/lib/remote_run/host.rb

@@ -1,128 +1,125 @@
-class Host
-  FAIL = 1
-  PASS = 0
-  SSH_CONFIG = " -o ControlMaster=auto -o ControlPath=~/.ssh/master-%l-%r@%h:%p -o NumberOfPasswordPrompts=0 -o StrictHostKeyChecking=no -4 "
-  attr_reader :hostname
-  attr_reader :lock_file
-
-  def initialize(hostname)
-    @hostname = hostname
-    @lock_file = LockFile.new(@hostname, $runner.local_hostname, $runner.identifier)
-  end
-
-  def lock
-    unless locked?
-      @lock_file.get && locked_by_me?
+module RemoteRun
+  class Host
+    FAIL = 1
+    PASS = 0
+    SSH_CONFIG = " -o ControlMaster=auto -o ControlPath=~/.ssh/master-%l-%r@%h:%p -o NumberOfPasswordPrompts=0 -o StrictHostKeyChecking=no -4 "
+    attr_reader :hostname
+
+    def initialize(hostname)
+      @hostname = hostname
+      @lock_file = LockFile.new(@hostname, $runner.local_hostname, $runner.identifier)
     end
-  end
-
-  def unlock
-    @lock_file.release
-  end
-
-  def run(task)
-    Runner.log("Running '#{task}' on #{@hostname}", :white)
-    command = %Q{ssh #{SSH_CONFIG} #{ssh_host_and_user} 'cd #{$runner.remote_path}; #{task}' 2>&1}
-    system(command)
-    $?.exitstatus
-  end
 
-  def copy_codebase
-    Runner.log("Copying from #{$runner.temp_path} to #{@hostname}:#{$runner.remote_path}", :yellow)
-    system("ssh #{SSH_CONFIG} #{ssh_host_and_user} 'mkdir -p #{$runner.remote_path}'")
-    excludes = $runner.exclude.map { |dir| "--exclude '#{dir}'"}
-    if system(%{rsync --delete --delete-excluded #{excludes.join(" ")} --rsh='ssh #{SSH_CONFIG}' --timeout=60 -a #{$runner.temp_path}/ #{ssh_host_and_user}:#{$runner.remote_path}/})
-      Runner.log("Finished copying to #{@hostname}", :green)
-      return true
-    else
-      Runner.log("rsync failed on #{@hostname}.", :red)
-      return false
+    def lock
+      unless locked?
+        @lock_file.get && locked_by_me?
+      end
     end
-  end
 
-  def is_up?
-    result = `ssh #{SSH_CONFIG} -o ConnectTimeout=2 #{ssh_host_and_user} "echo 'success'" 2>/dev/null`.strip
-    if result == "success"
-      Runner.log("#{@hostname} is up", :green)
-      return true
-    else
-      Runner.log("#{@hostname} is down: #{result}", :red)
-      return false
+    def unlock
+      @lock_file.release
     end
-  end
-
-  def start_ssh_master_connection
-    system("ssh #{SSH_CONFIG} #{ssh_host_and_user} -M &> /dev/null")
-  end
-
-  private
-
-  def ssh_host_and_user
-    "#{$runner.login_as}@#{@hostname}"
-  end
-
-  def locked?
-    @lock_file.locked?
-  end
 
-  def locked_by_me?
-    @lock_file.locked_by_me?
-  end
+    def run(task)
+      command = %Q{ssh #{SSH_CONFIG} #{ssh_host_and_user} 'cd #{$runner.remote_path}; #{task}' 2>&1}
+      system(command)
+      $?.exitstatus
+    end
 
-  class LockFile
-    FILE = "/tmp/remote-run-lock"
+    def copy_codebase
+      system("ssh #{SSH_CONFIG} #{ssh_host_and_user} 'mkdir -p #{$runner.remote_path}'")
+      excludes = $runner.exclude.map { |dir| "--exclude '#{dir}'"}
+      if system(%{rsync --delete --delete-excluded #{excludes.join(" ")} --rsh='ssh #{SSH_CONFIG}' --timeout=60 -a #{$runner.temp_path}/ #{ssh_host_and_user}:#{$runner.remote_path}/})
+        return true
+      else
+        return false
+      end
+    end
 
-    def initialize(remote_hostname, local_hostname, unique_run_marker)
-      @filename = FILE
-      @locker = "#{local_hostname}-#{unique_run_marker}"
-      @remote_file = RemoteFile.new(remote_hostname)
+    def is_up?
+      result = `ssh #{SSH_CONFIG} -o ConnectTimeout=2 #{ssh_host_and_user} "echo 'success'" 2>/dev/null`.strip
+      if result == "success"
+        return true
+      else
+        return false
+      end
     end
 
-    def release
-      if locked_by_me?
-        @remote_file.delete(@filename)
+    def start_ssh_master_connection
+      fork do
+        system("ssh #{SSH_CONFIG} #{ssh_host_and_user} -M &> /dev/null")
       end
     end
 
+    private
+
+    def ssh_host_and_user
+      "#{$runner.login_as}@#{@hostname}"
+    end
+
     def locked?
-      @remote_file.exist?(@filename)
+      @lock_file.locked?
     end
 
     def locked_by_me?
-      @remote_file.exist?(@filename) && @remote_file.read(@filename).strip == @locker
+      @lock_file.locked_by_me?
     end
 
-    def get
-      @remote_file.write(@filename, @locker)
-    end
+    class LockFile
+      FILE = "/tmp/remote-run-lock"
 
-    class RemoteFile
-      def initialize(hostname)
-        @hostname = hostname
+      def initialize(remote_hostname, local_hostname, unique_run_marker)
+        @filename = FILE
+        @locker = "#{local_hostname}-#{unique_run_marker}"
+        @remote_file = RemoteFile.new(remote_hostname)
       end
 
-      def exist?(file_path)
-        run_and_test("test -f #{file_path}")
+      def release
+        if locked_by_me?
+          @remote_file.delete(@filename)
+        end
       end
 
-      def read(file_path)
-        run("test -e #{file_path} && cat #{file_path}")
+      def locked?
+        @remote_file.exist?(@filename)
       end
 
-      def write(file_path, text)
-        run_and_test("test -e #{file_path} || echo #{text} > #{file_path}")
+      def locked_by_me?
+        @remote_file.exist?(@filename) && @remote_file.read(@filename).strip == @locker
       end
 
-      def delete(file_path)
-        run_and_test("rm -f #{file_path}")
+      def get
+        @remote_file.write(@filename, @locker)
       end
 
-      def run(command)
-        `ssh #{Host::SSH_CONFIG} #{$runner.login_as}@#{@hostname} '#{command};'`.strip
-      end
+      class RemoteFile
+        def initialize(hostname)
+          @hostname = hostname
+        end
+
+        def exist?(file_path)
+          run_and_test("test -f #{file_path}")
+        end
+
+        def read(file_path)
+          run("test -e #{file_path} && cat #{file_path}")
+        end
+
+        def write(file_path, text)
+          run_and_test("test -e #{file_path} || echo #{text} > #{file_path}")
+        end
+
+        def delete(file_path)
+          run_and_test("rm -f #{file_path}")
+        end
+
+        def run(command)
+          `ssh #{Host::SSH_CONFIG} #{$runner.login_as}@#{@hostname} '#{command};'`.strip
+        end
 
-      def run_and_test(command)
-        system("ssh #{Host::SSH_CONFIG} #{$runner.login_as}@#{@hostname} '#{command}' 2>/dev/null")
+        def run_and_test(command)
+          system("ssh #{Host::SSH_CONFIG} #{$runner.login_as}@#{@hostname} '#{command}' 2>/dev/null")
+        end
       end
     end
   end

data/lib/remote_run/runner.rb

@@ -1,233 +1,155 @@
-class Runner
-  attr_accessor :remote_path, :local_path, :login_as, :exclude, :temp_path
-  attr_reader :local_hostname, :identifier
-  @@start_time = Time.now
-  @@stty_config = `stty -g`
-
-  def initialize
-    @task_manager = TaskManager.new
-    @host_manager = HostManager.new
-
-    # config options
-    @local_path = Dir.getwd
-    @login_as = `whoami`.strip
-    @remote_path = "/tmp/remote"
-    @exclude = []
-    @temp_path = "/tmp/remote"
-
-    # used in the runner
-    @identifier = `echo $RANDOM`.strip
-    @local_hostname = `hostname`.strip
-    @results = []
-    @children = []
-    @failed = []
-    @last_timestamp = Time.now.strftime("%S")[0]
-
-    $runner = self
-    yield self
-  end
-
-  def self.run(&block)
-    @@start_time = Time.now
-    runner = new(&block)
-    runner.run
-  end
-
-  def self.run_time
-    minutes = ((Time.now - @@start_time) / 60).to_i
-    seconds = ((Time.now - @@start_time) % 60).to_i
-    "#{minutes}:#{"%02d" % seconds}"
-  end
-
-  def self.log(message, color = :yellow)
-    highline = HighLine.new
-    system("stty #{@@stty_config} 2>/dev/null")
-    highline.say(highline.color("[Remote :: #{$runner.identifier} :: #{run_time}] #{message}", color))
-  end
-
-  def hosts
-    @host_manager.all
-  end
+module RemoteRun
+  class Runner
+    def initialize(configuration)
+      @configuration = configuration
+      @results = []
+      @children = []
+      @failed = []
+      @stty_config = `stty -g`
+      @last_timestamp = Time.now.strftime("%S")[0]
+      @hosts = []
 
-  def hosts=(hostnames)
-    hostnames.each do |hostname|
-      @host_manager.add(hostname)
+      @task_manager = @configuration.task_manager
+      @host_manager = @configuration.host_manager
+      @starting_number_of_tasks = @task_manager.count
     end
-  end
 
-  def tasks=(shell_commands)
-    shell_commands.each do |shell_command|
-      @task_manager.add(shell_command)
+    def run
+      setup_unlock_on_exit
+      start_ssh_master_connections
+      sync_working_copy_to_temp_location
+      start_tasks
+      wait_for_tasks_to_finish
+      handle_results
     end
-  end
-
-  def run
-    @host_manager.unlock_on_exit
-    @host_manager.start_ssh_master_connections
-    sync_working_copy_to_temp_location
-    hosts = []
-
-    Runner.log("Starting tasks... #{Time.now}")
 
-    @starting_number_of_tasks = @task_manager.count
-    while @task_manager.has_more_tasks?
-      hosts = @host_manager.hosts.dup if hosts.empty?
+    private
 
-      display_log
-      check_for_finished
-
-      if host = hosts.sample
-        hosts.delete(host)
-        if host.lock
-          task = @task_manager.find_task
-          @children << fork do
-            begin
-              this_host = host.dup
-              unless this_host.copy_codebase
-                @task_manager.add(task)
-                status = 0
-              end
-              status = this_host.run(task)
-              host.unlock
-              Runner.log("#{host.hostname} failed.", :red) if status != 0
-            rescue Errno::EPIPE
-              Runner.log("broken pipe on #{host.hostname}...")
-            ensure
-              Process.exit!(status)
-            end
+    def setup_unlock_on_exit
+      at_exit do
+        @configuration.hosts.each do |host|
+          begin
+            host.unlock
+          rescue Errno::EPIPE
           end
         end
       end
     end
 
-    Runner.log("All tasks started... #{Time.now}")
-
-    while @children.length > 0
-      display_log
-      check_for_finished
-    end
-
-    failed_tasks = @results.select { |result| result != 0 }
-    status_code = if failed_tasks.length == 0
-      Runner.log("Task passed.", :green)
-      Host::PASS
-    else
-      Runner.log("#{failed_tasks.length} task(s) failed.", :red)
-      Host::FAIL
-    end
-
-    Runner.log("Total Time: #{self.class.run_time} minutes.")
-    status_code
-  end
-
-  def check_for_finished
-    @children.each do |child_pid|
-      if Process.waitpid(child_pid, Process::WNOHANG)
-        if $?.exitstatus != 0
-          @failed << child_pid
-        end
-
-        @results << $?.exitstatus
-        @children.delete(child_pid)
+    def start_ssh_master_connections
+      @configuration.hosts.each do |host|
+        host.start_ssh_master_connection
       end
     end
-    sleep(0.5)
-  end
-
-  private
 
-  def sync_working_copy_to_temp_location
-    Runner.log("Creating temporary copy of #{@local_path} in #{@temp_path}...")
-    excludes = exclude.map { |dir| "--exclude '#{dir}'"}
-    system("rsync --delete --delete-excluded #{excludes.join(" ")} -aq #{@local_path}/ #{@temp_path}/")
-    Runner.log("Done.")
-  end
-
-  def display_log
-    now = Time.now.strftime("%S")[0]
-    unless now == @last_timestamp
-      display_status("Waiting on #{@task_manager.count} of #{@starting_number_of_tasks} tasks to start.") if @task_manager.count > 0
-      display_status("Waiting on #{@children.length} of #{@starting_number_of_tasks - @task_manager.count} started tasks to finish. #{@failed.size} failed.") if @children.length > 0
-      $stdout.print("\n\n")
-      $stdout.flush
-      @last_timestamp = now
+    def sync_working_copy_to_temp_location
+      log("Creating temporary copy of #{@configuration.local_path} in #{@configuration.temp_path}...")
+      excludes = @configuration.exclude.map { |dir| "--exclude '#{dir}'"}
+      system("rsync --delete --delete-excluded #{excludes.join(" ")} -aq #{@configuration.local_path}/ #{@configuration.temp_path}/")
+      log("Done.")
     end
-  end
 
-  def display_status(message)
-    Runner.log(message, :yellow)
-  end
+    def start_tasks
+      log("Starting tasks... #{Time.now}")
 
-  class HostManager
-    def initialize(&block)
-      @hosts = []
-    end
+      while @task_manager.has_more_tasks?
+        display_log
+        check_for_finished
+        find_lock_and_start
+      end
 
-    def all
-      @hosts
+      log("All tasks started... #{Time.now}")
     end
 
-    def add(hostname)
-      host = Host.new(hostname)
-      Thread.new do
-        if host.is_up?
-          @hosts << host
-        end
+    def wait_for_tasks_to_finish
+      while @children.length > 0
+        display_log
+        check_for_finished
       end
     end
 
-    def hosts
-      while @hosts.empty?
-        Runner.log("Waiting for hosts...")
-        sleep(0.5)
+    def handle_results
+      failed_tasks = @results.select { |result| result != 0 }
+      status_code = if failed_tasks.length == 0
+        log("Task passed.", :green)
+        Host::PASS
+      else
+        log("#{failed_tasks.length} task(s) failed.", :red)
+        Host::FAIL
       end
 
-      @hosts
+      log("Total Time: #{run_time} minutes.")
+      status_code
     end
 
-    def unlock_on_exit
-      at_exit do
-        all.each do |host|
-          begin
-            host.unlock
-          rescue Errno::EPIPE
-          end
-        end
+    def start_task(host)
+      task = @task_manager.find_task
+      @children << fork do
+        start_forked_task(host, task)
       end
     end
 
-    def start_ssh_master_connections
-      all.each do |host|
-        fork do
-          host.start_ssh_master_connection
+    def start_forked_task(host, task)
+      begin
+        this_host = host.dup
+        unless this_host.copy_codebase
+          @task_manager.add(task)
+          status = 0
         end
+        status = this_host.run(task.command)
+        host.unlock
+      rescue Errno::EPIPE
+      ensure
+        Process.exit!(status)
       end
     end
-  end
 
-  class TaskManager
-    def initialize
-      @tasks = []
+    def find_lock_and_start
+      @hosts = @host_manager.hosts.dup if @hosts.empty?
+      if host = @hosts.sample
+        @hosts.delete(host)
+        if host.lock
+          start_task(host)
+        end
+      end
     end
 
-    def add(script)
-      @tasks.push(script)
+    def run_time
+      minutes = ((Time.now - @configuration.start_time) / 60).to_i
+      seconds = ((Time.now - @configuration.start_time) % 60).to_i
+      "#{minutes}:#{"%02d" % seconds}"
     end
 
-    def find_task
-      @tasks.shift
+    def log(message, color = :yellow)
+      unless @configuration.quiet
+        highline = HighLine.new
+        system("stty #{@stty_config} 2>/dev/null")
+        highline.say(highline.color("[Remote :: #{@configuration.identifier} :: #{run_time}] #{message}", color))
+      end
     end
 
-    def all
-      @tasks
+    def check_for_finished
+      @children.each do |child_pid|
+        if task_is_finished?(child_pid)
+          @failed << child_pid unless $?.success?
+          @results << $?.exitstatus
+          @children.delete(child_pid)
+        end
+      end
     end
 
-    def count
-      @tasks.length
+    def task_is_finished?(pid)
+      Process.waitpid(pid, Process::WNOHANG)
     end
 
-    def has_more_tasks?
-      @tasks.size > 0
+    def display_log
+      now = Time.now.strftime("%S")[0]
+      unless now == @last_timestamp
+        log("Waiting on #{@task_manager.count} of #{@starting_number_of_tasks} tasks to start.") if @task_manager.count > 0
+        log("Waiting on #{@children.length} of #{@starting_number_of_tasks - @task_manager.count} started tasks to finish. #{@failed.size} failed.") if @children.length > 0
+        $stdout.flush
+        @last_timestamp = now
+      end
     end
   end
 end

data/lib/remote_run/task.rb

@@ -0,0 +1,10 @@
+module RemoteRun
+  class Task
+    attr_accessor :command
+
+    def initialize(command)
+      @command = command
+    end
+  end
+end
+

data/lib/remote_run/version.rb

@@ -1,3 +1,3 @@
 module RemoteRun
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/remote_run.rb

@@ -1,3 +1,8 @@
+require File.join(File.dirname(__FILE__), "remote_run", "task")
 require File.join(File.dirname(__FILE__), "remote_run", "host")
 require File.join(File.dirname(__FILE__), "remote_run", "runner")
+require File.join(File.dirname(__FILE__), "remote_run", "configuration")
 require 'highline'
+
+module RemoteRun
+end

data/spec/remote_run/configuration_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe RemoteRun::Configuration::HostManager do
+  subject { RemoteRun::Configuration::HostManager.new }
+
+  describe "#add" do
+    it "adds the given host to a list of hosts" do
+      subject.add(stub(:host, :is_up? => true, :name => "foobar"))
+      subject.hosts.size.should == 1
+      subject.hosts.first.name.should == "foobar"
+    end
+  end
+
+  describe "#hosts" do
+    it "returns all hosts in the list" do
+      host = stub(:host, :is_up? => true, :name => "foobar")
+      subject.add(host)
+      subject.hosts.should == [host]
+    end
+  end
+
+  describe "#start_ssh_master_connections" do
+    before do
+      @host = stub(:host, :is_up? => true, :name => "foobar")
+      subject.add(@host)
+    end
+
+    it "asks each host to start their ssh master connection" do
+      @host.should_receive(:start_ssh_master_connection)
+      subject.start_ssh_master_connections
+    end
+  end
+end
+
+describe RemoteRun::Configuration::TaskManager do
+  subject { RemoteRun::Configuration::TaskManager.new }
+  describe "#add" do
+    it "takes a string and puts it on a list of tasks" do
+      task = RemoteRun::Task.new("date")
+      subject.add(task)
+      subject.tasks.should include(task)
+    end
+  end
+
+  describe "#find_task" do
+    before do
+      @task = RemoteRun::Task.new("date")
+      subject.add(@task)
+    end
+
+    it "finds a task from the list, returns it and removes it" do
+      subject.tasks.should == [@task]
+      subject.find_task.should == @task
+      subject.tasks.should == []
+    end
+  end
+
+  describe "#tasks" do
+    it "returns all of the tasks stored in the manager" do
+      task = RemoteRun::Task.new("foo")
+      task2 = RemoteRun::Task.new("bar")
+      subject.add(task)
+      subject.add(task2)
+      subject.tasks.should == [task, task2]
+    end
+  end
+
+  describe "#count" do
+    it "returns the number of tasks stored" do
+      task = RemoteRun::Task.new("foo")
+      task2 = RemoteRun::Task.new("bar")
+      subject.add(task)
+      subject.add(task2)
+      subject.count.should == 2
+    end
+  end
+
+  describe "#has_more_tasks?" do
+    it "returns true when there are tasks in the list" do
+      task = RemoteRun::Task.new("foo")
+      task2 = RemoteRun::Task.new("bar")
+      subject.add(task)
+      subject.add(task2)
+
+      subject.has_more_tasks?.should be_true
+      subject.find_task
+      subject.has_more_tasks?.should be_true
+      subject.find_task
+      subject.has_more_tasks?.should be_false
+    end
+  end
+end

data/spec/remote_run/host_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Host do
+describe RemoteRun::Host do
   context "when locking" do
-    let(:host) { Host.new("localhost") }
+    let(:host) { RemoteRun::Host.new("localhost") }
 
     it "can be locked" do
       host.lock.should be_true
@@ -21,9 +21,9 @@ describe Host do
 
   context "when locked by someone else" do
     before { lock_file.get }
-    let(:host) { Host.new("localhost") }
+    let(:host) { RemoteRun::Host.new("localhost") }
     let(:lock_file) {
-      lock_file = Host::LockFile.new("localhost", "myfakelocalhost", "999")
+      lock_file = RemoteRun::Host::LockFile.new("localhost", "myfakelocalhost", "999")
     }
 
     it "cannot be unlocked by me" do
@@ -33,7 +33,7 @@ describe Host do
 
   context "when locked by me" do
     before { host.lock }
-    let(:host) { Host.new("localhost") }
+    let(:host) { RemoteRun::Host.new("localhost") }
 
     it "cannot be locked" do
       host.lock.should be_false
@@ -52,7 +52,7 @@ describe Host do
 
   context "when checking to see if a host is up" do
     context "when using an authorized host" do
-      let(:host) { Host.new("localhost") }
+      let(:host) { RemoteRun::Host.new("localhost") }
 
       it "returns true" do
         host.is_up?.should be_true
@@ -60,7 +60,7 @@ describe Host do
     end
 
     context "when using an unauthorized host" do
-      let(:host) { Host.new("foozmcbarry") }
+      let(:host) { RemoteRun::Host.new("foozmcbarry") }
 
       it "returns false" do
         host.is_up?.should be_false
@@ -74,7 +74,7 @@ describe Host do
       host.lock
     end
 
-    let(:host) { Host.new("localhost") }
+    let(:host) { RemoteRun::Host.new("localhost") }
 
     context "when executing a shell command with a zero status code" do
       it "returns zero" do
@@ -95,7 +95,7 @@ describe Host do
       host.lock
     end
 
-    let(:host) { Host.new("localhost") }
+    let(:host) { RemoteRun::Host.new("localhost") }
 
     it "copies the codebase to a remote directory" do
       $runner.remote_path = "/tmp/testing-remote-run"

data/spec/spec_helper.rb

@@ -3,13 +3,14 @@ require 'bundler/setup'
 require 'rspec'
 require Dir.pwd + '/lib/remote_run'
 
-Runner.new do |config|
+RemoteRun::Configuration.new do |config|
   config.tasks = []
   config.hosts = []
+  config.quiet = true
 end
 
 RSpec.configure do |config|
   config.after(:each) do
-    system("rm -f #{Host::LockFile::FILE}")
+    system("rm -f #{RemoteRun::Host::LockFile::FILE}")
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: remote_run
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-11 00:00:00.000000000Z
+date: 2011-09-13 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: highline
-  requirement: &2151825780 !ruby/object:Gem::Requirement
+  requirement: &2151951040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2151825780
+  version_requirements: *2151951040
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2151824680 !ruby/object:Gem::Requirement
+  requirement: &2151943360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2151824680
+  version_requirements: *2151943360
 description: Can be used as a parallel unit test runner
 email:
 - casecommons-dev@googlegroups.com
@@ -48,11 +48,15 @@ files:
 - Readme.md
 - examples/demo-remote-run
 - lib/remote_run.rb
+- lib/remote_run/configuration.rb
 - lib/remote_run/host.rb
 - lib/remote_run/runner.rb
+- lib/remote_run/task.rb
 - lib/remote_run/version.rb
 - remote_run.gemspec
+- spec/remote_run/configuration_spec.rb
 - spec/remote_run/host_spec.rb
+- spec/remote_run/runner_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/Casecommons/remote_run
 licenses: []
@@ -68,7 +72,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4543623679604844651
+      hash: 3128109979642869878
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -77,13 +81,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4543623679604844651
+      hash: 3128109979642869878
 requirements: []
 rubyforge_project: remote_run
-rubygems_version: 1.8.6
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Run N shell scripts on a pool of remote hosts
 test_files:
+- spec/remote_run/configuration_spec.rb
 - spec/remote_run/host_spec.rb
+- spec/remote_run/runner_spec.rb
 - spec/spec_helper.rb