screwcap 0.2 → 0.3

data/Manifest.txt

@@ -9,7 +9,6 @@ bin/screwcap
 lib/exts.rb
 lib/screwcap.rb
 lib/screwcap/base.rb
-lib/screwcap/command_set.rb
 lib/screwcap/deployer.rb
 lib/screwcap/sequence.rb
 lib/screwcap/server.rb

data/Rakefile

@@ -11,7 +11,7 @@ Hoe.plugin :newgem
 # Generate all the Rake tasks
 # Run 'rake -T' to see list of generated tasks (from gem root directory)
 $hoe = Hoe.spec 'screwcap' do
-  self.version  = '0.2'
+  self.version  = '0.3'
   self.developer 'Grant Ammons', 'grant@pipelinedeals.com'
   self.rubyforge_name       = self.name # TODO this is default value
   self.extra_deps         = [['net-ssh','>= 2.0.23'],['net-ssh-gateway','>=1.0.1'], ['net-scp','>=1.0.4']]

data/lib/exts.rb

@@ -1,11 +1,5 @@
-class Array
+class Object
   def blank?
     self.nil? || self.size == 0
   end
 end
-
-class NilClass
-  def blank?
-    true
-  end
-end

data/lib/screwcap.rb

@@ -8,15 +8,16 @@ require 'ostruct'
 require 'logger'
 
 require 'exts'
+require 'screwcap/message_logger'
 require 'screwcap/base'
-require 'screwcap/command_set'
 require 'screwcap/task'
 require 'screwcap/server'
+require 'screwcap/runner'
 require 'screwcap/sequence'
 require 'screwcap/deployer'
 
 module Screwcap
-  VERSION='0.2'
+  VERSION='0.3'
 
   class TaskNotFound < RuntimeError; end
   class NoServersDefined < Exception; end
@@ -25,5 +26,6 @@ module Screwcap
   class IncludeFileNotFound < Exception; end
   class InvalidServer < Exception; end
   class CommandSetDependencyError < Exception; end
+  class CommandError < Exception; end
 end
 

data/lib/screwcap/base.rb

@@ -10,47 +10,5 @@ module Screwcap
     def set(var, *args)
       method_missing((var.to_s + "=").to_sym, args.first)
     end
-
-    def log(msg, options = {})
-      $stdout << msg unless self.__options[:silent] == true
-    end
-
-    def errorlog(msg)
-      $stderr << msg unless self.__options[:silent] == true
-    end
-
-    def bluebold(msg, options = {:clear => true})
-      if self.__options[:nocolor] == true
-        msg
-      else
-        "\033[1;36m#{msg}#{"\033[0m" if options[:clear]}"
-      end
-    end
-
-    def blue(msg, options = {:clear => true})
-      if self.__options[:nocolor] == true
-        msg
-      else
-        "\033[0;36m#{msg}#{"\033[0m" if options[:clear]}"
-      end
-    end
-
-
-    def red(msg)
-      if self.__options[:nocolor] == true
-        msg
-      else
-        "\033[0;31m#{msg}\033[0m"
-      end
-    end
-
-    def green(msg)
-      if self.__options[:nocolor] == true
-        msg
-      else
-        "\033[0;32m#{msg}\033[0m"
-      end
-    end
-
   end
 end

data/lib/screwcap/deployer.rb

@@ -2,6 +2,7 @@
 #
 # The deployer can be thought of as the "global scope" of your tasks file.
 class Deployer < Screwcap::Base
+  include MessageLogger
 
   # create a new deployer.
   def initialize(opts = {})
@@ -16,7 +17,7 @@ class Deployer < Screwcap::Base
     # ensure that deployer options will not be passed to tasks
     opts.each_key {|k| self.delete_field(k) }
 
-    log "Reading #{self.__options[:recipe_file]}\n" unless self.__options[:silent] == true
+    Deployer.log "Reading #{self.__options[:recipe_file]}\n" unless self.__options[:silent] == true
 
     file = File.open(File.expand_path("./#{self.__options[:recipe_file]}"))
     data = file.read
@@ -27,14 +28,14 @@ class Deployer < Screwcap::Base
 
   # create a task.  Minimally, a task needs a :server specified to run the task on.
   def task_for name, options = {}, &block
-    t = Task.new(options.merge(:name => name, :nocolor => self.__options[:nocolor], :silent => self.__options[:silent], :deployment_servers => self.__servers), &block)
+    t = Task.new(options.merge(:name => name, :nocolor => self.__options[:nocolor], :silent => self.__options[:silent], :deployment_servers => self.__servers, :command_sets => self.__command_sets), &block)
     clone_table_for(t)
     t.instance_eval(&block)
     self.__tasks << t
   end
 
   def command_set(name,options = {},&block)
-    t = CommandSet.new(options.merge(:name => name), &block)
+    t = Task.new(options.merge(:name => name, :validate => false, :command_set => true, :command_sets => self.__command_sets), &block)
     clone_table_for(t)
     self.__command_sets << t
   end
@@ -66,9 +67,9 @@ class Deployer < Screwcap::Base
     tasks.each do |t| 
       sequence = self.__sequences.find {|s| s.__name == t }
       if sequence
-        sequence.__task_names.each {|task_name| self.__tasks.find {|task| task.__name == task_name }.execute!}
+        sequence.__task_names.each {|task_name| Runner.execute! self.__tasks.find {|task| task.__name == task_name }, self.__options}
       else
-        self.__tasks.select {|task| task.name.to_s == t.to_s }.first.execute! 
+        Runner.execute! self.__tasks.select {|task| task.name.to_s == t.to_s }.first, self.__options
       end
     end
     $stdout << "\033[0m"
@@ -98,7 +99,7 @@ class Deployer < Screwcap::Base
 
   def clone_table_for(object)
     self.table.each do |k,v|
-      object.set(k, v) unless [:__options, :__tasks, :__servers].include?(k)
+      object.set(k, v) unless [:__options, :__tasks, :__servers, :__command_sets].include?(k)
     end
   end
 end

data/lib/screwcap/server.rb

@@ -32,7 +32,7 @@ class Server < Screwcap::Base
   end
 
   def __upload_to!(address, local, remote)
-    Net::SCP.upload!(address, self.__user, local, remote, options_for_net_ssh)
+    self.__with_connection_for(address) {|ssh| ssh.scp.upload! local, remote }
   end
 
   protected

data/lib/screwcap/task.rb

@@ -1,11 +1,14 @@
 class Task < Screwcap::Base
+  include MessageLogger
+
   def initialize(opts = {}, &block)
     super
     self.__name = opts[:name]
     self.__options = opts
     self.__commands = []
-    self.__command_sets = []
+    self.__command_sets = opts[:command_sets] || []
     self.__server_names = []
+    self.__block = block if opts[:command_set] == true
 
 
     if opts[:server] and opts[:servers].nil?
@@ -14,15 +17,16 @@ class Task < Screwcap::Base
       self.__server_names = opts[:servers]
     end
 
-    validate(opts[:deployment_servers])
+    validate(opts[:deployment_servers]) unless opts[:validate] == false
   end
 
   # run a command. basically just pass it a string containing the command you want to run.
   def run arg, options = {}
+
     if arg.class == Symbol
-      self.__commands << {:command => self.send(arg), :type => :remote}
+      self.__commands << options.merge({:command => self.send(arg), :type => :remote, :from => self.__name})
     else
-      self.__commands << {:command => arg, :type => :remote}
+      self.__commands << options.merge({:command => arg, :type => :remote, :from => self.__name})
     end
   end
 
@@ -33,25 +37,15 @@ class Task < Screwcap::Base
   # run a command. basically just pass it a string containing the command you want to run.
   def local arg, options = {}
     if arg.class == Symbol
-      self.__commands << {:command => self.send(arg), :type => :local}
+      self.__commands << options.merge({:command => self.send(arg), :type => :local, :from => self.__name})
     else
-      self.__commands << {:command => arg, :type => :local}
+      self.__commands << options.merge({:command => arg, :type => :local, :from => self.__name})
     end
-  end
-
-
-  def execute!
-    threads = []
-    self.__servers.each do |_server|
-      _server.__addresses.each do |_address|
-        if self.__options[:parallel] == false
-          execute_on(_server, _address)
-        else
-          threads << Thread.new(_server, _address) { |server, address| execute_on(server, address) }
-        end
+    if failure_cmd = self.__commands.last[:onfailure]
+      unless self.__command_sets.find {|cs| cs.__name == failure_cmd }
+        raise ScrewCap::ConfigurationError, "Could not find failure command set named '#{failure_cmd}' for task '#{self.__name}'"
       end
     end
-    threads.each {|t| t.join }
   end
 
   protected
@@ -60,7 +54,7 @@ class Task < Screwcap::Base
     if m.to_s[0..1] == "__" or [:run].include?(m) or m.to_s.reverse[0..0] == "="
       super(m, args.first) 
     else
-      if cs = self.__command_sets.find {|cs| cs.name == m }
+      if cs = self.__command_sets.find {|cs| cs.__name == m }
         # eval what is in the block
         clone_table_for(cs)
         cs.__commands = []
@@ -76,7 +70,7 @@ class Task < Screwcap::Base
 
   def clone_table_for(object)
     self.table.each do |k,v|
-      object.set(k, v) unless [:__command_sets, :name, :__commands, :__options].include?(k)
+      object.set(k, v) unless [:__block, :__tasks, :__name, :__command_sets, :__commands, :__options].include?(k)
     end
   end
 
@@ -91,48 +85,4 @@ class Task < Screwcap::Base
     self.__servers = self.__server_names.map {|name| servers.find {|s| s.name == name } }
   end
 
-  def execute_on(server, address) 
-    begin
-      log blue("\n*** BEGIN executing task #{self.__name} on #{server.name} with address #{address}\n") unless self.__options[:silent] == true
-
-      server.__with_connection_for(address) do |ssh|
-        error = false
-        self.__commands.each do |command|
-          next if error and self.__options[:stop_on_errors]
-
-          if command[:type] == :remote
-            log green("    I: (#{address}):  #{command[:command]}\n")
-
-              ssh.exec! command[:command] do |ch,stream,data|
-                if stream == :stderr
-                  error = true
-                errorlog red("    E: (#{address}): #{data}")
-              else
-                log green("    O: (#{address}):  #{data}")
-              end
-            end # ssh.exec
-          elsif command[:type] == :local
-            ret = `#{command[:command]}`
-            if $?.to_i == 0
-              log blue("    I: (local):  #{command[:command]}\n")
-              log blue("    O: (local):  #{ret}\n")
-            else
-              log blue("    I: (local):  #{command[:command]}\n")
-              errorlog red("    O: (local):  #{ret}\n")
-            end
-          elsif command[:type] == :scp
-            server.__upload_to!(address, command[:local], command[:remote])
-            log green("    I: (#{address}): SCP #{command[:local]} to #{server.__user}@#{address}:#{command[:remote]}")
-          end
-        end # commands.each
-      end # net.ssh start
-    rescue Net::SSH::AuthenticationFailed => e
-      raise Net::SSH::AuthenticationFailed, "Authentication failed for server named #{server.name}.  Please check your authentication credentials."
-    rescue Exception => e
-      errorlog red("    F: (#{address}): #{e}")
-    ensure
-      log blue("*** END executing task #{self.__name} on #{server.name} with address #{address}\n\n") unless self.__options[:silent] == true
-    end
-  end
-
 end

data/screwcap.gemspec

@@ -6,7 +6,7 @@ require 'bundler/version'
  
 Gem::Specification.new do |s|
   s.name        = "screwcap"
-  s.version     = "0.2"
+  s.version     = "0.3"
   s.platform    = Gem::Platform::RUBY
   s.author     = "Grant Ammons"
   s.email       = ["grant@pipelinedealsco.com"]

data/spec/command_set_spec.rb

@@ -4,7 +4,7 @@ describe "Command sets" do
   before(:all) do
     @stdout = []
     Deployer.any_instance.stubs(:log).with() { |msg| @stdout << msg}
-    @deployer = Deployer.new(:recipe_file => "./test/config/command_sets.rb", :silent => false)
+    @deployer = Deployer.new(:recipe_file => "./test/config/command_sets.rb", :silent => true)
   end
 
   it "should be able to define a generic list of commands" do
@@ -48,4 +48,10 @@ describe "Command sets" do
     task.__command_sets.first.instance_eval(&task.__command_sets.first.__block)
     task.__commands.map {|c| c[:command]}.should == %w(birdo nested birdo task)
   end
+
+  it "should be able to call scp just like a task" do
+    task = @deployer.__tasks.find {|t| t.__name == :task_use_scp}
+    task.__command_sets.first.instance_eval(&task.__command_sets.first.__block)
+    task.__commands.map {|c| c[:command]}.should == [nil]
+  end
 end

data/spec/deployer_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe "Deployers" do
   before(:all) do
     Net::SSH.stubs(:start).yields(SSHObject.new(:return_stream => :stdout, :return_data => "hostname = asdf\n"))
+    Runner.stubs(:ssh_exec!).returns(["ok","",0,nil])
   end
 
   it "should complain if no server was defined" do
@@ -40,7 +41,7 @@ describe "Deployers" do
 
   it "should be able to define command sets" do
     deployer = Deployer.new(:recipe_file => "./test/config/command_sets.rb", :silent => true)
-    deployer.should have(8).__command_sets
+    deployer.should have(9).__command_sets
   end
 
   it "should be able to define gateways" do
@@ -51,12 +52,13 @@ describe "Deployers" do
 
   it "should be able to define sequences" do
     deployer = Deployer.new(:recipe_file => "./test/config/simple_recipe.rb", :silent => true)
-    deployer.should have (1).__sequences
+    deployer.should have(1).__sequences
   end
 
   it "should be able to run a single task" do
     deployer = Deployer.new(:recipe_file => "./test/config/simple_recipe.rb", :silent => true)
-    lambda { deployer.run! :task1 }.should_not raise_error
+    deployer.run! :task1
+    #lambda { deployer.run! :task1 }.should_not raise_error
   end
 
   it "should be able to run multiple tasks" do

data/spec/sequence_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe "Sequences" do
   before(:all) do
     Net::SSH.stubs(:start).yields(SSHObject.new(:return_stream => :stdout, :return_data => "hostname = asdf\n"))
+    Runner.stubs(:ssh_exec!).returns(["ok","",0,nil])
   end
   before(:each) do
     @stdout = []

data/spec/server_spec.rb

@@ -4,11 +4,8 @@ describe "Servers" do
   before(:each) do
     @stdout = []
     @stderr = []
-    Task.any_instance.stubs(:log).with() { |msg| @stdout <<  msg }
-    Task.any_instance.stubs(:errorlog).with() { |msg| @stderr <<  msg }
-    Deployer.any_instance.stubs(:log).with() { |msg| @stdout <<  msg }
-    Deployer.any_instance.stubs(:errorlog).with() { |msg| @stderr <<  msg }
-
+    Runner.stubs(:log).with() { |msg,opts| @stdout <<  msg }
+    Runner.stubs(:errorlog).with() { |msg,opts| @stderr <<  msg }
     Net::SSH::Gateway.stubs(:new).returns(SSHObject.new)
   end
 
@@ -34,7 +31,7 @@ describe "Servers" do
   end
 
   it "should provide a connection to the server with a gateway" do
-    @deployer = Deployer.new(:recipe_file => "./test/config/gateway.rb", :silent => false)
+    @deployer = Deployer.new(:recipe_file => "./test/config/gateway.rb", :silent => true)
     server = @deployer.__servers.find {|s| s.__name == :test}
     gateway = @deployer.__servers.find {|s| s.__name == :gateway1}
 

data/spec/spec_helper.rb

@@ -7,19 +7,33 @@ require 'mocha'
 require 'ruby-debug' rescue nil
 require 'net/ssh'
 
-class SSHObject
+class SSHObject < OpenStruct
   attr_accessor :options
 
   def initialize(options = {})
-    @options = {:return_stream => :stdout}
-    @options = options
   end
 
-  def exec!(cmd, &block)
-    yield nil, @options[:return_stream], @options[:return_data]
+  def on_data
+    yield SSHObject.new, ""
   end
 
-  def ssh(address, user, options = {}, &block)
-    yield nil
+  def on_extended_data
+    yield SSHObject.new, "", ""
+  end
+
+  def read_long
+    ""
+  end
+
+  def upload!(from, to)
+    nil
+  end
+
+  def scp
+    SSHObject.new
+  end
+
+  def on_request(item)
+    yield SSHObject.new, SSHObject.new
   end
 end

data/spec/task_spec.rb

@@ -4,16 +4,15 @@ describe "Tasks" do
   before(:each) do
     @stdout = []
     @stderr = []
-    Task.any_instance.stubs(:log).with() { |msg| @stdout <<  msg }
-    Task.any_instance.stubs(:errorlog).with() { |msg| @stderr <<  msg }
-    Deployer.any_instance.stubs(:log).with() { |msg| @stdout <<  msg }
-    Deployer.any_instance.stubs(:errorlog).with() { |msg| @stderr <<  msg }
-    @deployer = Deployer.new(:recipe_file => "./test/config/simple_recipe.rb", :silent => false)
+    Runner.stubs(:log).with() { |msg,opts| @stdout <<  msg }
+    Runner.stubs(:errorlog).with() { |msg,opts| @stderr <<  msg }
+    @deployer = Deployer.new(:recipe_file => "./test/config/simple_recipe.rb", :silent => true)
   end
 
   before(:all) do
     Net::SSH.stubs(:start).yields(SSHObject.new(:return_stream => :stdout, :return_data => "hostname = asdf\n"))
     Net::SCP.stubs(:upload!).returns(nil)
+    Runner.stubs(:ssh_exec!).returns(["ok","",0,nil])
   end
 
   it "should be able to create variables" do
@@ -28,9 +27,9 @@ describe "Tasks" do
 
   it "should be able to execute statements on a remote server" do
     task = @deployer.__tasks.find {|t| t.name == :task1 }
-    task.execute!
+    Runner.execute! task, @deployer.__options
     @stderr.should == []
-    @stdout.size.should == 29
+    @stdout.size.should == 26
   end
 
   it "should be able to use variables in the run statement" do
@@ -52,11 +51,11 @@ describe "Tasks" do
   end
 
   it "should complain if you do not pass the task a server argument" do
-    lambda { Deployer.new(:recipe_file => "./test/config/no_server.rb", :silent => false)}.should raise_error(Screwcap::ConfigurationError)
+    lambda { Deployer.new(:recipe_file => "./test/config/no_server.rb", :silent => true)}.should raise_error(Screwcap::ConfigurationError)
   end
 
   it "should complain if you pass a server that is not defined" do
-    lambda { Deployer.new(:recipe_file => "./test/config/undefined_server.rb", :silent => false)}.should raise_error(Screwcap::ConfigurationError)
+    lambda { Deployer.new(:recipe_file => "./test/config/undefined_server.rb", :silent => true)}.should raise_error(Screwcap::ConfigurationError)
   end
 
   it "should be able to disable parallel running" do
@@ -72,4 +71,12 @@ describe "Tasks" do
     deployer = Deployer.new(:recipe_file => "./test/config/upload.rb", :silent => true)
     deployer.run! :upload
   end
+
+  it "should respond to onfailure" do
+    deployer = Deployer.new(:recipe_file => "./test/config/expect.rb", :silent => true)
+    t = deployer.__tasks.find {|t| t.__name == :expect }
+    Runner.stubs(:ssh_exec!).returns(["","fail",1,nil]).then.returns(["ok","",0,nil])
+    Runner.execute! t, deployer.__options
+    t.__commands.map {|c| [c[:command], c[:from]] }.first.should == ["echo 'we failed'", :failover]
+  end
 end

data/test/config/command_sets.rb

@@ -47,6 +47,10 @@ command_set :nested_outside_with_var do
   run :nested_var
 end
 
+command_set :use_scp do
+  scp :local => "/tmp/test", :remote => "/tmp/test"
+end
+
 
 task_for :use_command_set_no_override, :server => :test do
   push_to_thang
@@ -85,3 +89,7 @@ task_for :nested_scoping, :server => :test do
   nested_outside_with_var
   run :nested_var
 end
+
+task_for :task_use_scp, :server => :test do
+  use_scp
+end

data/test/config/expect.rb

@@ -5,26 +5,12 @@ command_set :revert do
   run "revert"
 end
 
-task_for :logic, :server => :test do
-  case variable
-  when 1
-    run "1"
-  when 2
-    run "2"
-  else
-    run "none"
-  end
-end
-
-command_set :fail do
-  run "ls"
-end
-
-command_set :success do
-  run "ls"
+command_set :failover do
+  run "echo 'we failed'"
 end
 
 task_for :expect, :server => :test do 
-  run "ls", :onfail => :fail, :onsuccess => :success
+  run "this will fail", :onfailure => :failover
+  run "ls"
 end
 

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: screwcap
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 13
   prerelease: false
   segments: 
   - 0
-  - 2
-  version: "0.2"
+  - 3
+  version: "0.3"
 platform: ruby
 authors: 
 - Grant Ammons
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-22 00:00:00 -04:00
+date: 2010-10-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -122,7 +122,6 @@ files:
 - lib/exts.rb
 - lib/screwcap.rb
 - lib/screwcap/base.rb
-- lib/screwcap/command_set.rb
 - lib/screwcap/deployer.rb
 - lib/screwcap/sequence.rb
 - lib/screwcap/server.rb

data/lib/screwcap/command_set.rb

@@ -1,56 +0,0 @@
-class CommandSet < Screwcap::Base
-  def initialize(opts = {}, &block)
-    super
-    self.__name = opts[:name]
-    self.__options = opts
-    self.__commands = []
-    self.__command_sets = []
-    self.__block = block
-  end
-
-  # run a command. basically just pass it a string containing the command you want to run.
-  def run arg, options = {}
-    if arg.class == Symbol
-      self.__commands << {:command => self.send(arg), :type => :remote}
-    else
-      self.__commands << {:command => arg, :type => :remote}
-    end
-  end
-
-  # run a command. basically just pass it a string containing the command you want to run.
-  def local arg, options = {}
-    if arg.class == Symbol
-      self.__commands << {:command => self.send(arg), :type => :local}
-    else
-      self.__commands << {:command => arg, :type => :local}
-    end
-  end
-
-
-  protected
-
-  def method_missing(m, *args)
-    if m.to_s[0..1] == "__" or [:run].include?(m) or m.to_s.reverse[0..0] == "="
-      super(m, args.first) 
-    else
-      if cs = self.__command_sets.find {|cs| cs.name == m }
-        # eval what is in the block
-        clone_table_for(cs)
-        cs.__commands = []
-        cs.instance_eval(&cs.__block)
-        self.__commands += cs.__commands
-      else
-        raise NoMethodError, "Undefined method '#{m.to_s}' for Command Set :#{self.name.to_s}"
-      end
-    end
-  end
-
-  private
-
-  def clone_table_for(object)
-    self.table.each do |k,v|
-      object.set(k, v) unless [:__command_sets, :name, :__commands, :__options, :__block].include?(k)
-    end
-  end
-
-end