nickstenning-outback 0.0.1 → 0.0.2

data/lib/outback/manager.rb

@@ -1,82 +1,72 @@
 require 'yaml'
-require 'tempfile'
 
 module Outback
   
   class Manager
     
-    attr_reader :tasks, :status, :errors, :position
-    attr_writer :logger
+    ROLLOUT = 1
+    ROLLBACK = -1
+    
+    attr_reader :tasks, :position
     attr_accessor :workdir
+    attr_writer :watcher
   
     def initialize
       @tasks = []
-      @statuses = []
-      @errors = []
       @position = 0
     end
     
-    def rollout
-      @direction = 1
+    def add_tasks( *tasks )
+      [*tasks].each do |task|
+        task.workdir = @workdir unless task.workdir
+      end
+      @tasks += [*tasks]
+    end
+    
+    alias_method :add_task, :add_tasks
+    
+    def rollout!
+      @direction = ROLLOUT
       run
     end
     
-    def rollback
-      @direction = -1
+    def rollback!
+      @direction = ROLLBACK
       run
     end
     
     def rollout_from( task )
       @position = @tasks.index(task)
-      rollout
+      rollout!
     end
     
     def rollback_from( task )
       @position = @tasks.index(task) - 1
-      rollback
-    end
-    
-    def attempt
-      method = {1 => :rollout, -1 => :rollback}[@direction]
-      Dir.chdir(@workdir || Dir.pwd) do
-        @statuses << [method, *current_task.send(method)]
-      end
-      return latest_okay?
-    end
-    
-    def latest_okay?
-      status[1] == 0
+      rollback!
     end
     
-    def errors
-      @statuses.select { |status| status[1] != 0 }
-    end
-    
-    def status
-      @statuses.last
+    def attempt( task )
+      method = {ROLLOUT => :rollout!, ROLLBACK => :rollback!}[@direction]
+      ret = task.send(method)
+      @watcher.notify(task) if @watcher
+      return ret
     end
     
     def current_task
       @tasks[@position]
     end
     
-    def state
-      { :position => @position, 
-        :direction => @direction, 
-        :statuses => @statuses }
-    end
-    
     private
     
     def run
-      if @direction == 1
+      if @direction == ROLLOUT
         task_list = @tasks[@position..-1]
-      elsif @direction == -1
+      elsif @direction == ROLLBACK
         task_list = @tasks[0..@position + 1].reverse
       end
       task_list.each do |task|
         @position = @tasks.index(task)
-        unless attempt
+        unless attempt current_task
           fail
           break
         end
@@ -84,11 +74,11 @@ module Outback
     end
     
     def fail
-      case status[0]
-      when :rollout
-        rollback_from current_task
-        raise TransactionError, "Could not rollout task #{current_task}, attempting rollback."
-      when :rollback
+      case @direction
+      when ROLLOUT
+        #rollback_from current_task
+        raise Error, "Could not rollout task #{current_task}, attempting rollback."
+      when ROLLBACK
         raise TransactionError, "Could not rollback task #{current_task}, aborting."
       else
         raise Error, "Unknown direction!"

data/lib/outback/shelltask.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'open4'
+
+module Outback
+  
+  class ShellTask
+  
+    attr_accessor :rollout, :rollback, :workdir
+    attr_reader :result, :errors, :exit_code
+    
+    def initialize(out, back)
+      @rollout, @rollback = out, back
+      @rolled_out = false
+    end
+    
+    def rollout!
+      run @rollout
+      @rolled_out = true
+      return @exit_code == 0
+    end
+    
+    def rollback!
+      run @rollback
+      @rolled_out = false
+      return @exit_code == 0
+    end
+    
+    def rolled_out?
+      @rolled_out
+    end
+        
+    def reset_strings
+      @result, @errors = "", ""
+    end
+    
+    def run( command )
+      reset_strings
+      Dir.chdir(@workdir || Dir.getwd) do
+        @status = Open4.popen4(*command) do |pid, i, o, e|
+          @result = o.read
+          @errors = e.read
+        end
+        @exit_code = @status.exitstatus
+      end
+    # Catch nonexistent commands at this point and return a sensible error
+    rescue Errno::ENOENT => e
+      @exit_code = 127
+      @errors = e.message
+    end
+    
+  end
+  
+end

data/lib/outback.rb

@@ -1,7 +1,5 @@
 require 'outback/manager'
-require 'outback/task_helper'
-require 'outback/task'
-require 'outback/command'
+require 'outback/shelltask'
 require 'outback/yaml'
 
 module Outback

data/outback.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = %q{outback}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
  
   s.specification_version = 2 if s.respond_to? :specification_version=
  
@@ -8,11 +8,11 @@ Gem::Specification.new do |s|
   s.authors = ["Nick Stenning"]
   s.date = %q{2008-07-14}
   s.email = ["nick@whiteink.com"]
-  s.files = ["lib/outback/command.rb", "lib/outback/manager.rb", "lib/outback/task.rb", "lib/outback/task_helper.rb", "lib/outback/yaml.rb", "lib/outback.rb", "outback.gemspec", "spec/outback/manager_spec.rb", "spec/outback/task_spec.rb", "spec/outback/yaml_spec.rb", "spec/spec_helper.rb"]
+  s.files = ["lib/outback/manager.rb", "lib/outback/shelltask.rb", "lib/outback/yaml.rb", "lib/outback.rb", "outback.gemspec", "spec/outback/manager_spec.rb", "spec/outback/shelltask_spec.rb", "spec/outback/yaml_spec.rb", "spec/spec_helper.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://github.com/nickstenning/outback}
   s.require_paths = ["lib"]
-  s.summary = %q{Like rake, but backwards and forwards.}
+  s.summary = %q{Run pairs of rollout/rollback tasks in a transactional manner.}
   s.description = %{Run pairs of rollout/rollback tasks in a transactional manner.}
  
   s.add_dependency("open4", [">= 0.9.0"])

data/spec/outback/manager_spec.rb

@@ -5,121 +5,100 @@ describe Outback::Manager do
   
   before do
     @obm = Outback::Manager.new
-    @task1 = mock("task1", :name => "Task 1") 
-    @task2 = mock("task2", :name => "Task 2")
+    @task1 = mock("task1", :workdir => "/tmp")
+    @task2 = mock("task2", :workdir => nil)
+    @task1.stub!(:workdir=)
+    @task2.stub!(:workdir=)
+  end
+
+  it "should have a list of tasks" do
+    @obm.tasks.should be_a_kind_of(Enumerable)
+    @obm.should have(0).tasks
   end
   
-  describe "(empty)" do
-    
-    it "should have a list of tasks" do
-      @obm.tasks.should be_a_kind_of(Enumerable)
-      @obm.should have(0).tasks
-    end
-    
-    it "should have a rollout method" do
-      @obm.should respond_to(:rollout)
-    end
-    
-    it "should have a rollback method" do
-      @obm.should respond_to(:rollback)
-    end
-    
-    it "should add tasks to its list with standard array operations" do
-      @obm.should have(0).tasks
-      @obm.tasks << @task1
-      @obm.should have(1).tasks
-      @obm.tasks << @task2
-      @obm.should have(2).tasks
-    end
-    
+  it "should add a task to its list with #add_task" do
+    @obm.add_task(@task1)
+    @obm.should have(1).tasks
+    @obm.add_task(@task2)
+    @obm.should have(2).tasks
   end
   
+  it "should add multiple tasks to its list, in order, with #add_tasks" do
+    @obm.add_tasks(@task1, @task2, @task1)
+    @obm.should have(3).tasks
+    @obm.tasks[0].should == @task1
+    @obm.tasks[1].should == @task2
+    @obm.tasks[2].should == @task1
+  end
+
   describe "(with a few tasks)" do
     
     before do
-      @obm.tasks << @task1 << @task2
+      @obm.add_tasks(@task1, @task2)
     end
     
-    it "should call each task's rollout method on rollout (in order)" do
-      @task1.should_receive(:rollout).and_return(0)
-      @task2.should_receive(:rollout).and_return(0)
-      @obm.rollout
+    it "should call each task's #rollout! method, in order, on #rollout!" do
+      @task1.should_receive(:rollout!).and_return(true)
+      @task2.should_receive(:rollout!).and_return(true)
+      @obm.rollout!
     end
     
-    it "should call each task's rollback method on rollback (in reverse order)" do
-      @task2.should_receive(:rollback).and_return(0)
-      @task1.should_receive(:rollback).and_return(0)
-      @obm.rollback
+    it "should call each task's #rollback! method, in reverse order, on #rollback!" do
+      @task1.should_receive(:rollout!).and_return(true)
+      @task2.should_receive(:rollout!).and_return(true)
+      @obm.rollout!
     end
     
     it "should raise an Outback::Error if a rollout fails" do
-      @task1.stub!(:rollback)
-      @task1.should_receive(:rollout).and_return(1)
-      @task2.should_not_receive(:rollout)
-      @task2.should_not_receive(:rollback)
-      lambda { @obm.rollout }.should raise_error(Outback::Error)
+      @task1.stub!(:rollback!)
+      @task1.should_receive(:rollout!).and_return(false)
+      @task2.should_not_receive(:rollout!)
+      @task2.should_not_receive(:rollback!)
+      lambda { @obm.rollout! }.should raise_error(Outback::Error)
     end
     
-    it "should raise an Outback::Error if a rollback fails" do
-      @task2.should_receive(:rollback).and_return(1)
-      @task1.should_not_receive(:rollback)
-      lambda { @obm.rollback }.should raise_error(Outback::Error)
+    it "should raise an Outback::TransactionError if a rollback subsequently fails" do
+      @task2.should_receive(:rollback!).and_return(false)
+      @task1.should_not_receive(:rollback!)
+      lambda { @obm.rollback! }.should raise_error(Outback::TransactionError)
     end
     
-    it "should store the latest task's run direction (rollout, rollback), return code, stdout and stderr in #status" do
-      @task1.should_receive(:rollout).and_return([0, "A message", ""])
-      @task2.should_receive(:rollout).and_return([0, "Another message", ""])
-      @obm.rollout
-      @obm.status.should == [:rollout, 0, "Another message", ""]
-    end
+  end
+  
+  describe "(with #workdir set)" do
     
-    it "should store the latest task's status even if an earlier task raised an error." do
-      @task1.stub!(:rollback).and_return([0, "Getting rolled back", ""])
-      @task1.should_receive(:rollout).and_return([1, "", "Error message"])
-      @task2.should_not_receive(:rollout)
-      begin 
-        @obm.rollout
-      rescue Outback::Error
-        @obm.status.should == [:rollback, 0, "Getting rolled back", ""]
-      end
+    before do
+      @task1 = Outback::ShellTask.new("", "")
+      @task1.workdir = "/tmp"
+      @task2 = Outback::ShellTask.new("", "")
+      @obm.workdir = "/nonexistent"
+      @obm.add_tasks(@task1, @task2)
     end
     
-    it "should store any status messages with non-zero return codes in #errors" do
-      @task1.should_receive(:rollout).and_return([0, "All okay", ""])
-      @task2.should_receive(:rollout).and_return([1, "", "Error message"])
-      @task2.should_receive(:rollback).and_return([0, "Getting rolled back", ""])
-      @task1.should_receive(:rollback).and_return([3, "", "Error while rolling back"])
-      begin
-        @obm.rollout
-      rescue Outback::Error
-        @obm.should have(2).errors
-        @obm.errors[0].should == [:rollout, 1, "", "Error message"]
-        @obm.errors[1].should == [:rollback, 3, "", "Error while rolling back"]    
-      end
+    it "should set the workdir of each of its tasks if it is currently nil" do
+      @task1.workdir.should == "/tmp"
+      @task2.workdir.should == "/nonexistent"
     end
     
-    it "should rollback previously rolled-out tasks if a rollout fails" do
-      @task1.should_receive(:rollout).ordered.and_return([1, "", "Error message"])
-      @task2.should_not_receive(:rollout)
-      @task1.should_receive(:rollback).ordered
-      @task2.should_not_receive(:rollback)
-      begin 
-        @obm.rollout
-      rescue Outback::Error
-      end
-    end
   end
   
-  describe "(with #workdir set)" do
+  describe "(with #watcher set)" do
     
     before do
-      @obm.tasks << Outback::ShellTask.new('pwd', 'pwd')
-      @obm.workdir = '/tmp'
+      @task1 = Outback::ShellTask.new("pwd", "")
+      @task2 = Outback::ShellTask.new("echo 'hello'", "")
+      require 'tempfile'
+      @obm.workdir = Dir.tmpdir
+      @obm.add_tasks(@task1, @task2)
+      @watcher = mock("watcher")
+      @obm.watcher = @watcher
     end
     
-    it "should execute all tasks in the workdir" do
-      @obm.rollout
-      @obm.status[2] == "/tmp"
+    it "should call the watcher's #notify method after every task rollout/rollback with the task as an argument" do
+      @watcher.should_receive(:notify).ordered.with(@task1)
+      @watcher.should_receive(:notify).ordered.with(@task2)
+      @obm.rollout!
     end
+    
   end
 end

data/spec/outback/shelltask_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Outback::ShellTask do
+  
+  before do
+    @task = Outback::ShellTask.new("out", "back")
+  end
+  
+  it "should use the first parameter to the rollout command" do
+    @task.rollout.should == "out"
+  end
+  
+  it "should use the second parameter as the rollback command" do
+    @task.rollback.should == "back"
+  end
+  
+  it "should allow its rollout command to be changed with #rollout=" do
+    @task.rollout = "foo"
+    @task.rollout.should == "foo"
+  end
+  
+  it "should allow its rollback command to be changed with #rollback=" do
+    @task.rollout = "bar"
+    @task.rollout.should == "bar"
+  end
+  
+  it "should not be rolled out by default" do
+    @task.should_not be_rolled_out
+  end
+  
+  it "should rollout when called with #rollout!" do
+    @task.rollout!
+    @task.should be_rolled_out
+  end
+  
+  it "should run its commands in the current working directory if #workdir hasn't been set" do
+    @task = Outback::ShellTask.new("pwd", "")
+    @task.rollout!
+    @task.result.chomp.should == Dir.getwd
+  end
+  
+  it "should run its commands in the workdir, if set with #workdir=" do
+    @task = Outback::ShellTask.new("pwd", "")
+    @task.workdir = "/private/tmp" ## FIXME for *nix systems
+    @task.rollout!
+    @task.result.chomp.should == @task.workdir
+  end
+  
+  it "should return true on successful #rollout! or #rollback!" do
+    @task = Outback::ShellTask.new("echo", "echo")
+    @task.rollout!.should be_true
+    @task.rollback!.should be_true
+  end
+  
+  it "should return false on unsuccessful #rollout! or #rollback!" do
+    @task = Outback::ShellTask.new("I-am-a-command-most-unlikely-to-exist", "I-am-a-command-most-unlikely-to-exist")
+    @task.rollout!.should be_false
+    @task.rollback!.should be_false
+  end
+  
+  describe "(when rolled out)" do
+    
+    before do
+      @task = Outback::ShellTask.new('pwd', 'pwd')
+      @task.rollout!
+    end
+    
+    it "should be rolled out" do
+      @task.should be_rolled_out
+    end
+    
+    it "should have an integer exit code" do
+      @task.exit_code.should be_a_kind_of(Fixnum)
+    end
+    
+    it "should have a string result" do
+      @task.result.should be_a_kind_of(String)
+    end
+    
+    it "should have a string for errors (stderr)" do
+      @task.errors.should be_a_kind_of(String)
+    end
+    
+  end
+
+end

data/spec/outback/yaml_spec.rb

@@ -35,13 +35,13 @@ describe Outback::YAML do
     end
     it "should set the rollout_command to the first element of the YAML array" do
       manager = Outback::YAML.load(@yaml)
-      manager.tasks[0].rollout_command.should == "touch y"
-      manager.tasks[1].rollout_command.should == "touch x"
+      manager.tasks[0].rollout.should == "touch y"
+      manager.tasks[1].rollout.should == "touch x"
     end
     it "should set the rollback_command to the second element of the YAML array" do
       manager = Outback::YAML.load(@yaml)
-      manager.tasks[0].rollback_command.should == "rm y"
-      manager.tasks[1].rollback_command.should == "rm x"
+      manager.tasks[0].rollback.should == "rm y"
+      manager.tasks[1].rollback.should == "rm x"
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nickstenning-outback
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Nick Stenning
@@ -31,15 +31,13 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/outback/command.rb
 - lib/outback/manager.rb
-- lib/outback/task.rb
-- lib/outback/task_helper.rb
+- lib/outback/shelltask.rb
 - lib/outback/yaml.rb
 - lib/outback.rb
 - outback.gemspec
 - spec/outback/manager_spec.rb
-- spec/outback/task_spec.rb
+- spec/outback/shelltask_spec.rb
 - spec/outback/yaml_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -67,6 +65,6 @@ rubyforge_project:
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
-summary: Like rake, but backwards and forwards.
+summary: Run pairs of rollout/rollback tasks in a transactional manner.
 test_files: []
 

data/lib/outback/command.rb

@@ -1,33 +0,0 @@
-module Outback
-  
-  class Command
-    
-    def initialize( script )
-      @manager = Manager.new
-      parse(script)
-    end
-    
-    def parse( script )
-      script.each_line do |l|
-        out, back = l[/^([^\^]+)\s*\^\s*(.+)$/]
-        p "o:", out, "b:", back
-        if out and back
-          p out, back
-          t = Task.new("temp")
-          t.rollout { |t| t.sys out }
-          t.rollback { |t| t.sys back }
-          @manager.tasks << t
-        end
-      end
-    end
-    
-    def run( command )
-      raise %{Command "#{command}" not understood.} unless [:rollout, :rollback].include? command
-      
-      #@manager.tasks.each 
-      #@manager.send(command)
-    end
-    
-  end
-  
-end

data/lib/outback/task.rb

@@ -1,61 +0,0 @@
-require 'stringio'
-
-require 'rubygems'
-require 'open4'
-
-module Outback
-  
-  class Task
-  
-    attr_reader :name
-    attr_accessor :stdout, :stderr
-    
-    def initialize
-      @rollout, @rollback = lambda {}
-      @stdout = StringIO.new
-      @stderr = StringIO.new
-    end
-    
-    def rollout( &block )
-      if block_given?
-        @rollout = block
-      else
-        run @rollout
-      end
-    end
-
-    def rollback( &block )
-      if block_given?
-        @rollback = block
-      else
-        run @rollback
-      end
-    end
-    
-  private
-    
-    def run( proc )
-      proc.call(TaskHelper.new(self))
-      [0, stdout.string, stderr.string]
-    rescue SystemCallError => err
-      [1, stdout.string, stderr.string]
-    end
-
-  end
-  
-    
-  class ShellTask < Task
-    
-    attr_reader :rollout_command, :rollback_command
-    
-    def initialize(rollout, rollback)
-      super()
-      @rollout = lambda { |t| t.sys rollout }
-      @rollout_command = rollout
-      @rollback = lambda { |t| t.sys rollback }
-      @rollback_command = rollback
-    end
-    
-  end
-  
-end

data/lib/outback/task_helper.rb

@@ -1,21 +0,0 @@
-module Outback
-  
-  class TaskHelper
-    
-    def initialize( task )
-      @task = task
-    end
-    
-    def sys( *args )
-      pid, i, o, e = Open4.popen4(*args)
-      o.each_line { |l| @task.stdout.print "[#{pid}] #{l}" }
-      e.each_line { |l| @task.stderr.print "E [#{pid}] #{l}" }
-    end
-    
-    def puts( *args )
-      @task.stdout.puts *args
-    end
-    
-  end
-  
-end

data/spec/outback/task_spec.rb

@@ -1,63 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Outback::Task do
-  
-  before do
-    @task = Outback::Task.new
-  end
-
-  it "should allow its rollout method to be defined with #rollout" do
-    rollout_proc = lambda { |t| t.puts "rollout" }
-        
-    lambda do
-      @task.rollout &rollout_proc
-    end.should_not raise_error
-    
-    @task.rollout.should == [0, "rollout\n", ""]
-  end
-  
-  it "should allow its rollback method to be defined with #rollback" do
-    rollback_proc = lambda { |t| t.puts "rollback" }
-    
-    lambda do
-      @task.rollback &rollback_proc
-    end.should_not raise_error
-
-    @task.rollback.should == [0, "rollback\n", ""]
-  end
-  
-  it "should have a rollout method" do
-    @task.should respond_to(:rollout)
-  end
-  
-  it "should have a rollback method" do
-    @task.should respond_to(:rollback)
-  end
-  
-  it "should return an exit code and the command output when rollout or rollback is run" do
-    returns = @task.rollout
-    returns[0].should be_a_kind_of(Numeric)
-    returns[1].should be_a_kind_of(String)
-    returns[2].should be_a_kind_of(String)
-  end
-  
-  it "should provide a 'sys' method to rollout and rollback blocks to allow system calls" do
-    @task.rollout do |t|
-      t.sys 'echo', 'system call'
-    end
-    ret = []
-    lambda { ret = @task.rollout }.should_not raise_error
-    ret[0].should == 0
-    ret[1].should match(/\[\d+\] system call\n/)
-    ret[2].should be_empty
-  end
-  
-  it "should catch failed system commands and provide an appropriate exit code" do
-    @task.rollout do |t|
-      t.sys "nonexistent"
-    end
-    ret = []
-    lambda { ret = @task.rollout }.should_not raise_error
-    ret[0].should == 1
-  end  
-end