nickstenning-outback 0.0.1

data/lib/outback/command.rb

@@ -0,0 +1,33 @@
+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/manager.rb

@@ -0,0 +1,100 @@
+require 'yaml'
+require 'tempfile'
+
+module Outback
+  
+  class Manager
+    
+    attr_reader :tasks, :status, :errors, :position
+    attr_writer :logger
+    attr_accessor :workdir
+  
+    def initialize
+      @tasks = []
+      @statuses = []
+      @errors = []
+      @position = 0
+    end
+    
+    def rollout
+      @direction = 1
+      run
+    end
+    
+    def rollback
+      @direction = -1
+      run
+    end
+    
+    def rollout_from( task )
+      @position = @tasks.index(task)
+      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
+    end
+    
+    def errors
+      @statuses.select { |status| status[1] != 0 }
+    end
+    
+    def status
+      @statuses.last
+    end
+    
+    def current_task
+      @tasks[@position]
+    end
+    
+    def state
+      { :position => @position, 
+        :direction => @direction, 
+        :statuses => @statuses }
+    end
+    
+    private
+    
+    def run
+      if @direction == 1
+        task_list = @tasks[@position..-1]
+      elsif @direction == -1
+        task_list = @tasks[0..@position + 1].reverse
+      end
+      task_list.each do |task|
+        @position = @tasks.index(task)
+        unless attempt
+          fail
+          break
+        end
+      end
+    end
+    
+    def fail
+      case status[0]
+      when :rollout
+        rollback_from current_task
+        raise TransactionError, "Could not rollout task #{current_task}, attempting rollback."
+      when :rollback
+        raise TransactionError, "Could not rollback task #{current_task}, aborting."
+      else
+        raise Error, "Unknown direction!"
+      end
+    end
+    
+  end
+
+end

data/lib/outback/task.rb

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,21 @@
+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/lib/outback/yaml.rb

@@ -0,0 +1,25 @@
+module Outback
+  
+  module YAML
+    
+    def self.load( yaml_string )
+      manager = Manager.new
+      tasks = ::YAML.load(yaml_string)
+      tasks.each do |task|
+        manager.tasks << Outback::ShellTask.new(*task)
+      end
+      return manager
+    end
+    
+    def self.load_file( yaml_file )
+      manager = Manager.new
+      tasks = ::YAML.load_file(yaml_file)
+      tasks.each do |task|
+        manager.tasks << Outback::ShellTask.new(*task)
+      end
+      return manager
+    end
+              
+  end
+  
+end

data/lib/outback.rb

@@ -0,0 +1,12 @@
+require 'outback/manager'
+require 'outback/task_helper'
+require 'outback/task'
+require 'outback/command'
+require 'outback/yaml'
+
+module Outback
+  
+  class Error < RuntimeError; end
+  class TransactionError < Error; end
+  
+end

data/outback.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name = %q{outback}
+  s.version = "0.0.1"
+ 
+  s.specification_version = 2 if s.respond_to? :specification_version=
+ 
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  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.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.description = %{Run pairs of rollout/rollback tasks in a transactional manner.}
+ 
+  s.add_dependency("open4", [">= 0.9.0"])
+end

data/spec/outback/manager_spec.rb

@@ -0,0 +1,125 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'yaml'
+
+describe Outback::Manager do
+  
+  before do
+    @obm = Outback::Manager.new
+    @task1 = mock("task1", :name => "Task 1") 
+    @task2 = mock("task2", :name => "Task 2")
+  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
+    
+  end
+  
+  describe "(with a few tasks)" do
+    
+    before do
+      @obm.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
+    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
+    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)
+    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)
+    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
+    
+    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
+    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
+    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
+    
+    before do
+      @obm.tasks << Outback::ShellTask.new('pwd', 'pwd')
+      @obm.workdir = '/tmp'
+    end
+    
+    it "should execute all tasks in the workdir" do
+      @obm.rollout
+      @obm.status[2] == "/tmp"
+    end
+  end
+end

data/spec/outback/task_spec.rb

@@ -0,0 +1,63 @@
+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

data/spec/outback/yaml_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'yaml'
+
+describe Outback::YAML do
+  
+  before do
+    @yaml =<<-EOM.gsub(/^\s{4}/, '')
+    -
+      - touch y
+      - rm y
+    -
+      - touch x
+      - rm x
+    EOM
+    @file = '/tmp/outback_yaml_spec_tmp'
+    File.open(@file, 'w') { |f| f.puts @yaml }
+  end
+  
+  after do
+    File.delete(@file)
+  end
+  
+  describe do
+    it "should return an Outback::Manager object" do 
+      Outback::YAML.load(@yaml).should be_a_kind_of(Outback::Manager)
+      Outback::YAML.load_file(@file).should be_a_kind_of(Outback::Manager)
+    end
+    it "should return an Outback::Manager object with as many tasks as the YAML passed into it" do
+      Outback::YAML.load(@yaml).should have(2).tasks
+      Outback::YAML.load_file(@file).should have(2).tasks
+    end
+    it "should add instances of Outback::ShellTask to the Outback::Manager's task array" do
+      manager = Outback::YAML.load(@yaml)
+      manager.tasks.first.should be_a_kind_of(Outback::ShellTask)
+    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"
+    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"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'outback'
+require 'logger'

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: nickstenning-outback
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nick Stenning
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: open4
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.0
+    version: 
+description: Run pairs of rollout/rollback tasks in a transactional manner.
+email: 
+- nick@whiteink.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+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
+has_rdoc: true
+homepage: http://github.com/nickstenning/outback
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Like rake, but backwards and forwards.
+test_files: []
+