screwcap 0.3.5 → 0.5

data/Manifest.txt

@@ -1,5 +1,3 @@
-Gemfile
-Gemfile.lock
 History.txt
 Manifest.txt
 README.rdoc
@@ -8,23 +6,25 @@ TODO
 bin/screwcap
 lib/screwcap.rb
 lib/screwcap/base.rb
-lib/screwcap/deployer.rb
 lib/screwcap/message_logger.rb
 lib/screwcap/runner.rb
 lib/screwcap/sequence.rb
 lib/screwcap/server.rb
 lib/screwcap/task.rb
+lib/screwcap/task_manager.rb
 lib/trollop.rb
 recipes/setup_rails.rb
+runrdoc
 screwcap.gemspec
-spec/command_set_spec.rb
-spec/deployer_spec.rb
+spec/runner_spec.rb
 spec/sequence_spec.rb
 spec/server_spec.rb
 spec/spec.opts
 spec/spec_helper.rb
+spec/task_manager_spec.rb
 spec/task_spec.rb
 tasks/rspec.rake
+test/config/bad_use.rb
 test/config/command_sets.rb
 test/config/expect.rb
 test/config/gateway.rb
@@ -32,9 +32,11 @@ test/config/local_task.rb
 test/config/no_server.rb
 test/config/rails_tasks.rb
 test/config/simple_recipe.rb
+test/config/super_simple_recipe.rb
 test/config/undefined_command_set.rb
 test/config/undefined_item.rb
 test/config/undefined_server.rb
 test/config/unknown_use.rb
 test/config/upload.rb
 test/config/use.rb
+test/config/use2.rb

data/README.rdoc

@@ -20,6 +20,19 @@ For more info, see the main screwcap page at http://gammons.github.com/screwcap
 
 * gem install screwcap
 
+== TODO:
+* Explore removing the 'use' keyword, favoring require or load
+* Add ability to parse user input
+* Add ability to parse user input
+* DONE add --dry-run to screwcap
+
+== RECIPES:
+
+=== I need help writing rails recipes!  Please help contribute some nice rock-solid rails recipes to the following repo:
+
+http://github.com/gammons/screwcap_recipes
+
+
 == LICENSE:
 
 (The MIT License)

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.3.5'
+  self.version  = '0.5'
   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/bin/screwcap

@@ -4,14 +4,14 @@ require 'rubygems'
 require File.expand_path(File.dirname(__FILE__) + '/../lib/screwcap')
 require File.expand_path(File.dirname(__FILE__) + '/../lib/trollop')
 
-
 p = Trollop::Parser.new do
-  opt :silent, "Be silent"
+  opt :silent, "Be silent", :short => "s"
   opt :nocolor, "Do not color output"
-  opt :debug, "Turn on debugger.  Will print full stacktrace if an exeception was raised"
-  opt :help, "Show this message"
-  opt :tasks, "Display available tasks in recipe file"
-  opt :setup_rails, "Setup a rails app to use screwcap"
+  opt :debug, "Turn on debugger.  Will print full stacktrace if an exeception was raised", :short => "d"
+  opt :help, "Show this message", :short => "h"
+  opt :tasks, "Display available tasks in recipe file", :short => "t"
+  opt :setup_rails, "Setup a rails app to use screwcap", :short => "r"
+  opt :dry_run, "Setup a rails app to use screwcap", :short => "n"
   version <<-EOF 
     Screwcap #{Screwcap::VERSION} by Grant Ammons (grant@pipelinedeals.com)
     More info at http://gammons.github.com/screwcap
@@ -31,7 +31,7 @@ opts = Trollop::with_standard_exception_handling p do
 
   if opts[:tasks] == true
     recipe_file = ARGV.shift
-    deployer = Deployer.new(opts.merge(:recipe_file => recipe_file))
+    deployer = TaskManager.new(opts.merge(:recipe_file => recipe_file))
     $stdout << "Tasks Available:\n" if deployer.__tasks.size > 0
     deployer.__tasks.map {|t| t.__name }.each {|name| $stdout << "  #{name}\n" }
     $stdout << "Sequences Available:\n" if deployer.__sequences.size > 0
@@ -39,8 +39,23 @@ opts = Trollop::with_standard_exception_handling p do
     exit
   end
 
+  if opts[:dry_run] == true
+    recipe_file = ARGV.shift
+    deployer = TaskManager.new(opts.merge(:recipe_file => recipe_file))
+    ARGV.map {|a| a.to_sym }.each do |tname|
+      task = deployer.__tasks.find {|t| t.__name == tname }
+      raise(Screwcap::TaskNotFound, "Could not find task named '#{tname}' in the recipe file.") if task.nil?
+      $stdout << "\n*** BEGIN dry-run task #{task.__name}\n"
+      task.__commands.each do |cmd|
+        $stdout << "    I: (dry-run):  #{cmd[:command]}\n"
+      end
+      $stdout << "*** END dry-run task #{task.__name}\n"
+    end
+    exit
+  end
+
   if opts[:setup_rails] == true
-    Deployer.new(:recipe_file => File.expand_path(File.dirname(__FILE__) + "/../recipes/setup_rails.rb")).run! :setup_rails
+    TaskManager.new(:recipe_file => File.expand_path(File.dirname(__FILE__) + "/../recipes/setup_rails.rb")).run! :setup_rails
     $stdout << "\nYour rails app now has a sample recipe, ready for the editing, in config/screwcap/recipe.rb\n"
     $stdout << "Your recipes will be automatically available in rake.  Screwcap uses the :remote namespace.\n"
     $stdout << "To see what recipes you can run, type 'rake -T remote'.\n"
@@ -51,7 +66,7 @@ opts = Trollop::with_standard_exception_handling p do
   raise Trollop::HelpNeeded if ARGV.size < 2
   recipe_file = ARGV.shift
   begin
-    Deployer.new(opts.merge(:recipe_file => recipe_file)).run! ARGV.map {|a| a.to_sym }
+    TaskManager.new(opts.merge(:recipe_file => recipe_file)).run! ARGV.map {|a| a.to_sym }
   rescue Exception => e
     raise e if opts[:debug] == true
     $stderr << e

data/lib/screwcap.rb

@@ -13,10 +13,10 @@ require 'screwcap/task'
 require 'screwcap/server'
 require 'screwcap/runner'
 require 'screwcap/sequence'
-require 'screwcap/deployer'
+require 'screwcap/task_manager'
 
 module Screwcap
-  VERSION='0.3.5'
+  VERSION='0.5'
 
   class TaskNotFound < RuntimeError; end
   class NoServersDefined < Exception; end

data/lib/screwcap/base.rb

@@ -3,5 +3,9 @@ module Screwcap
     def set(var, *args)
       method_missing((var.to_s + "=").to_sym, args.first)
     end
+
+    def clone_from(object)
+      object.table.each {|k,v| self.set(k,v) unless k.to_s[0..1] == "__" }
+    end
   end
 end

data/lib/screwcap/message_logger.rb

@@ -16,7 +16,7 @@ module MessageLogger
 
     def logmsg(msg, output, options)
       return if @options and @options[:silent] == true
-      if @options and not @options[:nocolor] == true
+      unless (@options and @options[:nocolor] == true)
         case options[:color]
         when :blue
           output << "\033[0;36m#{msg}#{"\033[0m" if options[:clear]}"

data/lib/screwcap/runner.rb

@@ -1,63 +1,76 @@
 class Runner
   include MessageLogger
+  @@silent = false
 
-  def self.execute! task, options
-    @task = task; @options = options
-    threads = []
-    if @task.__options[:local] == true
-      log "\n*** BEGIN executing local task #{@task.__name}\n", :color => :blue
-      @task.__commands.each do |command|
-        ret = `#{command[:command]}`
-        if $?.to_i == 0
-          log "    I: (local):  #{command[:command]}\n", :color => :blue
-          log("    O: (local):  #{ret}\n", :color => :blue) unless ret.nil? or ret == ""
-        else
-          log "    I: (local):  #{command[:command]}\n", :color => :blue
-          errorlog("    O: (local):  #{ret}\n", :color => :red) unless ret.nil? or ret == ""
-          errorlog("    E: (local): #{command[:command]} return exit code: #{$?}\n", :color => :red) if $? != 0
+  def self.execute! options
+    @@silent = options[:silent]
+    begin
+      _log "\n*** BEGIN executing task #{options[:name]} on #{options[:server].name} with address #{options[:address]}\n", :color => :blue unless options[:silent] == true
+      options[:server].__with_connection_for(options[:address]) do |ssh|
+        options[:commands].each do |command|
+          ret = run_command(command, ssh, options)
+          break if ret != 0 and command[:abort_on_fail] == true
         end
       end
-      log "\n*** END executing local task #{@task.__name}\n", :color => :blue
-    else
-      @task.__servers.each do |_server|
-        _server.__addresses.each do |_address|
-          if task.__options[:parallel] == false
-            execute_on(_server, _address)
-          else
-            threads << Thread.new(_server, _address) { |server, address| execute_on(server, address) }
-          end
-        end
+    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 "    F: (#{options[:address]}): #{e}", :color => :red
+    ensure
+      _log "*** END executing task #{options[:name]} on #{options[:server].name} with address #{options[:address]}\n\n", :color => :blue
+    end
+    options[:commands] # for tests
+  end
+
+  def self.execute_locally! options
+    @@silent = options[:silent]
+    _log "\n*** BEGIN executing local task #{options[:name]}\n", :color => :blue
+    options[:commands].each do |command|
+      command[:stdout] = ret = `#{command[:command]}`
+      
+      if $?.to_i == 0
+        _log "    I: (local):  #{command[:command]}\n", :color => :blue
+        _log("    O: (local):  #{ret}\n", :color => :blue) unless ret.nil? or ret == ""
+      else
+        _log "    I: (local):  #{command[:command]}\n", :color => :blue
+        _errorlog("    O: (local):  #{ret}\n", :color => :red) unless ret.nil? or ret == ""
+        _errorlog("    E: (local): #{command[:command]} return exit code: #{$?}\n", :color => :red) if $? != 0
       end
     end
-    threads.each {|t| t.join }
+    _log "\n*** END executing local task #{options[:name]}\n", :color => :blue
+    options[:commands]
   end
 
   private
 
-  def self.execute_on(server, address) 
-    begin
-      log "\n*** BEGIN executing task #{@task.__name} on #{server.name} with address #{address}\n", :color => :blue
-
-      server.__with_connection_for(address) do |ssh|
-        failed_command = nil
-        @task.__commands.each do |command|
-          if run_command(ssh, address, server, command) != 0 and command[:onfailure]
-            failed_command = command
-            break
-          end
-        end
-        if failed_command
-          @task.__commands = []
-          @task.send(failed_command[:onfailure])
-          @task.__commands.each { |command| run_command(ssh, address, server, command) }
-        end
+  def self.run_command(command, ssh, options)
+    if command[:type] == :remote
+      _log "    I: (#{options[:address]}):  #{command[:command]}\n", :color => :green
+      stdout, stderr, exit_code, exit_signal = ssh_exec! ssh, command[:command]
+      command[:stdout] = stdout
+      command[:stderr] = stderr
+      _log("    O: (#{options[:address]}):  #{stdout}", :color => :green) unless stdout.nil? or stdout == ""
+      _errorlog("    O: (#{options[:address]}):  #{stderr}", :color => :red) unless stderr.nil? or stderr == ""
+      _errorlog("    E: (#{options[:address]}): #{command[:command]} return exit code: #{exit_code}\n", :color => :red) if exit_code != 0
+      return exit_code
+    elsif command[:type] == :local
+      ret = `#{command[:command]}`
+      command[:stdout] = ret
+      if $?.to_i == 0
+        _log "    I: (local):  #{command[:command]}\n", :color => :blue
+        _log "    O: (local):  #{ret}\n", :color => :blue
+      else
+        _log "    I: (local):  #{command[:command]}\n", :color => :blue
+        _errorlog "    O: (local):  #{ret}\n", :color => :red
+        _errorlog("    E: (local): #{command[:command]} return exit code: #{$?}\n", :color => :red) if $? != 0
       end
-    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 "    F: (#{address}): #{e}", :color => :red
-    ensure
-      log "*** END executing task #{@task.__name} on #{server.name} with address #{address}\n\n", :color => :blue
+      return $?
+    elsif command[:type] == :scp
+      _log "    I: (#{options[:address]}): SCP #{command[:local]} to #{options[:server].__user}@#{options[:address]}:#{command[:remote]}\n", :color => :green
+      options[:server].__upload_to!(options[:address], command[:local], command[:remote])
+
+      # this will need to be improved to allow for :onfailure
+      return 0
     end
   end
 
@@ -91,33 +104,13 @@ class Runner
     [stdout_data, stderr_data, exit_code, exit_signal]
   end
 
+  def self._log(message, options)
+    return if @@silent == true
+    log(message, options)
+  end
 
-  def self.run_command(ssh, address, server, command)
-    if command[:type] == :remote
-      log "    I: (#{address}):  #{command[:command]}\n", :color => :green
-      stdout, stderr, exit_code, exit_signal = ssh_exec! ssh, command[:command]
-      log("    O: (#{address}):  #{stdout}", :color => :green) unless stdout.nil? or stdout == ""
-      errorlog("    O: (#{address}):  #{stderr}", :color => :red) unless stderr.nil? or stderr == ""
-      errorlog("    E: (#{address}): #{command[:command]} return exit code: #{exit_code}\n", :color => :red) if exit_code != 0
-      return exit_code
-    elsif command[:type] == :local
-      ret = `#{command[:command]}`
-      if $?.to_i == 0
-        log "    I: (local):  #{command[:command]}\n", :color => :blue
-        log "    O: (local):  #{ret}\n", :color => :blue
-      else
-        log "    I: (local):  #{command[:command]}\n", :color => :blue
-        errorlog "    O: (local):  #{ret}\n", :color => :red
-        errorlog("    E: (local): #{command[:command]} return exit code: #{$?}\n", :color => :red) if $? != 0
-      end
-      return $?
-    elsif command[:type] == :scp
-      log "    I: (#{address}): SCP #{command[:local]} to #{server.__user}@#{address}:#{command[:remote]}\n", :color => :green
-      server.__upload_to!(address, command[:local], command[:remote])
-
-      # this will need to be improved to allow for :onfailure
-      return 0
-    end
-
+  def self._errorlog(message, options)
+    return if @@silent == true
+    errorlog(message, options)
   end
 end

data/lib/screwcap/sequence.rb

@@ -23,16 +23,6 @@ class Sequence < Screwcap::Base
     super
     self.__options = opts
     self.__name = opts[:name]
-    self.__deployment_task_names = opts[:deployment_task_names]
     self.__task_names = opts[:tasks]
-    validate
-  end
-
-  private
-
-  def validate
-    self.__task_names.each do |tn|
-      raise(Screwcap::ConfigurationError, "Could not find task #{tn} in the deployment recipe.") unless self.__deployment_task_names.include?(tn)
-    end
   end
 end

data/lib/screwcap/server.rb

@@ -13,11 +13,14 @@ class Server < Screwcap::Base
   #   * *:password* specify the password to connect with.  Not recommended.  Use keys.
   def initialize(opts = {})
     super
+    self.__name = opts.delete(:name)
+    self.__user = opts.delete(:user)
+    self.__options[:keys] = [opts.delete(:key)] if opts[:key]
+
+    servers = opts.delete(:servers)
+    self.__gateway = servers.select {|s| s.__options[:is_gateway] == true }.find {|s| s.__name == opts[:gateway] } if servers
+
     self.__options = opts
-    self.__name = opts[:name]
-    self.__servers = opts[:servers]
-    self.__user = opts[:user]
-    self.__options[:keys] = [self.__options.delete(:key)] if self.__options[:key]
 
     if self.__options[:address] and self.__options[:addresses].nil?
       self.__addresses = [self.__options.delete(:address)] 
@@ -31,9 +34,8 @@ class Server < Screwcap::Base
   end
 
   def __with_connection_for(address, &block)
-    if self.__options[:gateway]
-      gateway = self.__servers.select {|s| s.__options[:is_gateway] == true }.find {|s| s.__name == self.__options[:gateway] }
-      gateway.__get_gateway_connection.ssh(address, self.__user, options_for_net_ssh) do |ssh|
+    if self.__gateway
+      __gateway.__get_gateway_connection.ssh(address, self.__user, options_for_net_ssh) do |ssh|
         yield ssh
       end
     else

data/lib/screwcap/task.rb

@@ -3,21 +3,11 @@ class Task < Screwcap::Base
 
   def initialize(opts = {}, &block)
     super
-    self.__name = opts[:name]
+    self.__name = opts.delete(:name)
     self.__options = opts
     self.__commands = []
-    self.__command_sets = opts[:command_sets] || []
-    self.__server_names = []
-    self.__block = block if opts[:command_set] == true
-
-
-    if opts[:server] and opts[:servers].nil?
-      self.__server_names << opts[:server]
-    else
-      self.__server_names = opts[:servers]
-    end
-
-    validate(opts[:deployment_servers]) unless opts[:validate] == false or opts[:local] == true
+    self.__servers  = opts.delete(:servers)
+    self.__block = block
   end
 
   # Run a command.  This can either be a string, or a symbol that is the name of a command set to run.
@@ -45,8 +35,8 @@ class Task < Screwcap::Base
   #   task_for :item, :servers => :server do
   #    run "ls -l", :onfailure => :rollback
   #   end 
+  
   def run arg, options = {}
-
     if arg.class == Symbol
       self.__commands << options.merge({:command => self.send(arg), :type => :remote, :from => self.__name})
     else
@@ -58,6 +48,7 @@ class Task < Screwcap::Base
   #   task_for :item, :servers => :server do
   #     scp :local => "/tmp/pirate_booty", :remote => "/mnt/app/config/booty.yml"
   #   end 
+  
   def scp options = {}
     self.__commands << options.merge({:type => :scp})
   end
@@ -78,54 +69,68 @@ class Task < Screwcap::Base
   #   task_for :item, :servers => :server do
   #    local "herd_cats", :onfailure => :rollback
   #   end 
+  
   def local arg, options = {}
     if arg.class == Symbol
       self.__commands << options.merge({:command => self.send(arg), :type => :local, :from => self.__name})
     else
       self.__commands << options.merge({:command => arg, :type => :local, :from => self.__name})
     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
   end
 
-  protected
+  def __build_commands(command_sets = [])
+    commands = []
 
-  def method_missing(m, *args) # :nodoc
-    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
+    self.instance_eval(&self.__block)
+
+    # :before for before_ callback
+    if before = command_sets.find {|cs| cs.__name.to_s == "before_#{self.__name}" or cs.__name == self.__options[:before] } and before != self
+      before.clone_from(self)
+      commands << before.__build_commands(command_sets)
+    end
+
+    self.__commands.each do |command|
+      if command[:type] == :unknown
+        if cs = command_sets.find {|cs| cs.__name == command[:command] }
+          cs.clone_from(self)
+          commands << cs.__build_commands(command_sets)
+        else
+          raise(NoMethodError, "Cannot find task, command set, or other method named '#{command[:command]}'")
+        end
       else
-        raise NoMethodError, "Undefined method '#{m.to_s}' for task :#{self.name.to_s}"
+        commands << command
       end
     end
-  end
-
-  private
 
-  def clone_table_for(object)
-    self.table.each do |k,v|
-      object.set(k, v) unless [:__block, :__tasks, :__name, :__command_sets, :__commands, :__options].include?(k)
+    # :after for after_ callback
+    if after = command_sets.find {|cs| cs.__name.to_s == "after_#{self.__name}" or cs.__name == self.__options[:after] } and after != self
+      after.clone_from(self)
+      commands << after.__build_commands(command_sets)
     end
+
+    commands.flatten
   end
 
   def validate(servers)
-    raise Screwcap::ConfigurationError, "Could not find a server to run this task on.  Please specify :server => :servername or :servers => [:server1, :server2] in the task_for directive." if self.__server_names.nil? or self.__server_names == []
+    raise Screwcap::ConfigurationError, "Could not find a server to run this task on.  Please specify :server => :servername or :servers => [:server1, :server2] in the task_for directive." if servers == [] or servers.nil?
 
-    self.__server_names.each do |server_name|
-      raise Screwcap::ConfigurationError, "Could not find a server to run this task on.  Please specify :server => :servername or :servers => [:server1, :server2] in the task_for directive." unless servers.map(&:name).include?(server_name)
-    end
+    # marshal :server into :servers
+    self.__servers = [self.__options.delete(:server)] if self.__options[:server]
+    self.__servers = [self.__servers] if self.__servers.class != Array
 
-    # finally map the actual server objects via name
-    self.__servers = self.__server_names.map {|name| servers.find {|s| s.name == name } }
+    server_names = servers.map {|s| s.__name }
+    self.__servers.each do |server_name|
+      raise Screwcap::ConfigurationError, "Could not find a server to run this task on.  Please specify :server => :servername or :servers => [:server1, :server2] in the task_for directive." unless server_names.include?(server_name)
+    end
   end
 
+  private
+
+  def method_missing(m, *args) # :nodoc
+    if m.to_s[0..1] == "__" or [:run].include?(m) or m.to_s.reverse[0..0] == "="
+      super(m, args.first) 
+    else
+      self.__commands << {:command => m, :type => :unknown, :from => self.__name}
+    end
+  end
 end