screwcap 0.6.3 → 0.7

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.6.3'
+  self.version  = '0.7'
   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

@@ -6,6 +6,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../lib/trollop')
 
 p = Trollop::Parser.new do
   opt :silent, "Be silent", :short => "s"
+  opt :verbose, "Be verbose", :short => "v"
   opt :nocolor, "Do not color output"
   opt :debug, "Turn on debugger.  Will print full stacktrace if an exeception was raised", :short => "d"
   opt :help, "Show this message", :short => "h"

data/lib/screwcap/runner.rb

@@ -4,74 +4,80 @@ class Runner
 
   def self.execute! options
     @@silent = options[:silent]
-    begin
-      _log "\nExecuting task named #{options[:name]} on #{options[:server].name}..\n", :color => :blue
-      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
+    @@verbose = options[:verbose]
+    task = options[:task]
+
+    if (task.__servers.nil? or task.__servers == [] or task.__servers.compact == []) and task.__built_commands.any? {|c| c[:type] == :remote or c[:type] == :scp }
+      raise Screwcap::ConfigurationError, "The task #{task.name} includes remote commands, however no servers were defined for this task."
+    end
+
+    if options[:servers] and task.__servers
+      begin
+        servers = options[:servers].select {|s| task.__servers.include? s.__name }
+        connections = servers.map {|server| server.connect! }.flatten
+      rescue Net::SSH::AuthenticationFailed => e
+        raise Net::SSH::AuthenticationFailed, "Authentication failed for server named #{server.name}.  Please check your authentication credentials."
       end
-    rescue Net::SSH::AuthenticationFailed => e
-      raise Net::SSH::AuthenticationFailed, "Authentication failed for server named #{server.name}.  Please check your authentication credentials."
-    ensure
-      _log "\nComplete\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
+    _log "\nExecuting task #{task.name}\n", :color => :blue
+
+    task.__built_commands.each do |command|
+      ret = case command[:type]
+      when :remote
+        threads = []
+        connections.each do |connection|
+          threads << Thread.new(connection) do |conn|
+            run_remote_command(command, conn, options)
+          end
+        end
+        threads.each {|t| t.join }
+      when :local
+        ret = `#{command[:command]}`
+        command[:stdout] = ret
+        if $?.to_i == 0
+          if options[:verbose]
+            _log "    O: #{ret}\n", :color => :green
+          else
+            _log(".", :color => :green)
+          end
+        else
+          _errorlog("    E: (local): #{command[:command]} return exit code: #{$?}\n", :color => :red) if $? != 0
+        end
+        ret
+      when :scp
+        threads = []
+        servers.each do |server|
+          threads << Thread.new(server) { |_server| _server._upload! command[:local], command[:remote] }
+        end
+        thread.each {|t| t.join }
+        return 0
+      when :block
+        command[:block].call
       end
     end
-    _log "\n*** END executing local task #{options[:name]}\n", :color => :blue
-    options[:commands]
+    _log "Complete\n", :color => :blue
+    task.__built_commands # for tests
   end
 
   private
 
-  def self.run_command(command, ssh, options)
-    case command[:type]
-    when :remote
-      stdout, stderr, exit_code, exit_signal = ssh_exec! ssh, command[:command]
-      command[:stdout] = stdout
-      command[:stderr] = stderr
-      command[:exit_code] = exit_code
-      if exit_code == 0
-        _log(".", :color => :green)
+  def self.run_remote_command(command, ssh, options)
+    stdout, stderr, exit_code, exit_signal = ssh_exec! ssh, command[:command]
+    command[:stdout] = stdout
+    command[:stderr] = stderr
+    command[:exit_code] = exit_code
+    if exit_code == 0
+      if @@verbose
+        _log("    I: #{command[:command]}\n", :color => :green)
+        _log("    O: #{command[:stdout]}\n", :color => :green)
       else
-        _errorlog("\n    E: (#{options[:address]}): #{command[:command]} return exit code: #{exit_code}\n", :color => :red) if exit_code != 0
-      end
-      return exit_code
-    when :local
-      ret = `#{command[:command]}`
-      command[:stdout] = ret
-      if $?.to_i == 0
         _log(".", :color => :green)
-      else
-        _errorlog("\n    E: (local): #{command[:command]} return exit code: #{$?}\n", :color => :red) if $? != 0
       end
-      return $?
-    when :scp
-      putc "."
-      options[:server].__upload_to!(options[:address], command[:local], command[:remote])
-
-      # this will need to be improved to allow for :onfailure
-      return 0
-    when :block
-      command[:block].call
+    else
+      _errorlog("    E: (#{options[:address]}): #{command[:command]} return exit code: #{exit_code}\n", :color => :red) if exit_code != 0
     end
+    exit_code
   end
 
   # courtesy of flitzwald on stackoverflow

data/lib/screwcap/server.rb

@@ -19,6 +19,7 @@ class Server < Screwcap::Base
 
     servers = opts.delete(:servers)
     self.__gateway = servers.select {|s| s.__options[:is_gateway] == true }.find {|s| s.__name == opts[:gateway] } if servers
+    self.__connections = []
 
     self.__options = opts
 
@@ -33,20 +34,21 @@ class Server < Screwcap::Base
     self
   end
 
-  def __with_connection_for(address, &block)
-    if self.__gateway
-      __gateway.__get_gateway_connection.ssh(address, self.__user, options_for_net_ssh) do |ssh|
-        yield ssh
-      end
-    else
-      Net::SSH.start(address, self.__user, options_for_net_ssh) do |ssh|
-        yield ssh
+  def connect!
+    self.__addresses.each  do |address|
+      if self.__gateway
+        self.__connections << __gateway.__get_gateway_connection.ssh(address, self.__user, options_for_net_ssh)
+      else
+        self.__connections << Net::SSH.start(address, self.__user, options_for_net_ssh)
       end
     end
+    self.__connections
   end
 
-  def __upload_to!(address, local, remote)
-    self.__with_connection_for(address) {|ssh| ssh.scp.upload! local, remote }
+  def upload! (local, remote)
+    self.__connections.each do |conn|
+      conn.scp.upload! local, remote
+    end
   end
 
   protected

data/lib/screwcap/task.rb

@@ -11,6 +11,7 @@ class Task < Screwcap::Base
     self.__servers  = opts.delete(:servers)
     self.__callback = opts.delete(:callback)
     self.__block = block
+    self.__built_commands = []
 
     if self.__options[:before] and self.__options[:before].class != Array
       self.__options[:before] = [self.__options[:before]] 
@@ -211,20 +212,13 @@ class Task < Screwcap::Base
       end
     end
 
-    commands.flatten
+    commands.flatten!
+    self.__built_commands = commands
   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 servers == [] or servers.nil?
-
-    # marshal :server into :servers
     self.__servers = [self.__options.delete(:server)] if self.__options[:server]
     self.__servers = [self.__servers] if self.__servers.class != Array
-
-    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

data/lib/screwcap/task_manager.rb

@@ -10,7 +10,6 @@ class TaskManager < Screwcap::Base
     self.__options = opts
     self.__tasks = []
     self.__servers = []
-    self.__command_sets = []
     self.__sequences = []
 
     instance_eval(File.read(self.__options[:recipe_file])) if self.__options[:recipe_file]
@@ -82,10 +81,11 @@ class TaskManager < Screwcap::Base
   def task name, options = {}, &block
     t = Task.new(options.merge(:name => name), &block)
     t.clone_from(self)
-    t.validate(self.__servers) unless options[:local] == true
+    t.validate(self.__servers)
     self.__tasks << t
   end
   alias :task_for :task
+  alias :command_set :task
 
   # ====A *command set* is like a generic set of tasks that you intend to use in multiple tasks.
   #
@@ -114,12 +114,6 @@ class TaskManager < Screwcap::Base
   #       redundant_task
   #     end
 
-  def command_set(name,options = {},&block)
-    t = Task.new(options.merge(:name => name), &block)
-    t.clone_from(self)
-    self.__command_sets << t
-  end
-
   # ====A *server* is the address(es) that you run a *:task* on.
   #   server :myserver, :address => "abc.com", :password => "xxx"
   #   server :app_servers, :addresses => ["abc.com","def.com"], :keys => "~/.ssh/my_key"
@@ -187,37 +181,12 @@ class TaskManager < Screwcap::Base
 
     ret = []
     tasks_to_run.each do |task|
-      commands =  task.__build_commands(self.__command_sets)
-      if task.__options[:local] == true
-        Runner.execute_locally! :commands => commands, :silent => self.__options[:silent]
-      else
-        threads = []
-        self.__servers.select {|s| task.__servers.include? s.__name }.each do |server|
-          server.__addresses.each do |address|
-            if task.__options[:parallel] == false
-              Runner.execute!(:name => task.__name, 
-                              :commands => commands, 
-                              :address => address, 
-                              :server => server, 
-                              :silent => self.__options[:silent])
-            else
-              threads << Thread.new(server,address) do |server, address| 
-                Runner.execute!(:name => task.__name, 
-                                :commands => commands, 
-                                :address => address, 
-                                :server => server,
-                                :silent => self.__options[:silent]) 
-              end
-            end
-          end
-        end
-        threads.each {|t| t.join }
-      end
-      ret << commands
+      ret << task.__build_commands(self.__tasks)
+      Runner.execute!(:task => task, :servers => self.__servers, :silent => self.__options[:silent], :verbose => self.__options[:verbose])
     end
 
     $stdout << "\033[0m"
-    ret.flatten
+    ret.flatten # return this for tests
   end
 
   # ====Use will dynamically include another file into an existing configuration file.

data/lib/screwcap.rb

@@ -16,7 +16,7 @@ require 'screwcap/sequence'
 require 'screwcap/task_manager'
 
 module Screwcap
-  VERSION='0.6.3'
+  VERSION='0.7'
 
   class TaskNotFound < RuntimeError; end
   class NoServersDefined < Exception; end

data/screwcap.gemspec

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

data/spec/runner_spec.rb

@@ -8,15 +8,16 @@ describe "The Runner" do
       run "one"
       run "two"
     end
+    @task.__build_commands
+    @task.validate([@server])
   end
 
   it "should be able to execute commands on an address of a server" do
     Runner.stubs(:ssh_exec!).returns(["ok\n","",0,nil])
 
     commands = Runner.execute! :name => "test", 
-      :server => @server, 
-      :address => "fake.com", 
-      :commands => @task.__build_commands, 
+      :servers => [@server],
+      :task => @task, 
       :silent => true
 
     commands[0][:stderr].should == ""
@@ -27,25 +28,26 @@ describe "The Runner" do
   end
 
   it "should be able to handle error commands" do
-    Runner.stubs(:ssh_exec!).returns(["ok\n","",0,nil]).then.returns(["","no\n",1,nil])
+    #Runner.stubs(:ssh_exec!).returns(["ok\n","",0,nil]).then.returns(["","no\n",1,nil])
+    Runner.stubs(:ssh_exec!).returns(["","no\n",1,nil])
     commands = Runner.execute! :name => "test", 
-      :server => @server, 
-      :address => "fake.com", 
-      :commands => @task.__build_commands, 
+      :servers => [@server], 
+      :task => @task, 
       :silent => true
 
-    commands[0][:stderr].should == ""
-    commands[0][:stdout].should == "ok\n"
+    commands[0][:stderr].should == "no\n"
+    commands[0][:stdout].should == ""
 
     commands[1][:stderr].should == "no\n"
     commands[1][:stdout].should == ""
   end
 
   it "should be able to execute local commands" do
-    task = Task.new :name => :localtest, :local => true do
-      run "echo 'bongle'"
+    task = Task.new :name => :localtest do
+      local "echo 'bongle'"
     end
-    commands = Runner.execute_locally! :name => :localtest, :commands => task.__build_commands, :silent => true
+    task.__build_commands
+    commands = Runner.execute! :name => :localtest, :task => task, :silent => true
     commands[0][:stdout].should == "bongle\n"
   end
 
@@ -54,11 +56,11 @@ describe "The Runner" do
     task = Task.new :name => :extest do
       ex { @@testvar = :bango }
     end
+    task.__build_commands
     @@testvar.should == :bingo
     commands = Runner.execute! :name => "test", 
-      :server => @server, 
-      :address => "fake.com", 
-      :commands => task.__build_commands, 
+      :servers => [@server], 
+      :task => task,
       :silent => true
     @@testvar.should == :bango
   end

data/spec/server_spec.rb

@@ -27,6 +27,6 @@ describe "Servers" do
 
   it "should provide a connection to the server" do
     server = Server.new(:name => :test, :user => :root, :address => "abc.com")
-    server.should respond_to(:__with_connection_for)
+    server.should respond_to(:connect!)
   end
 end

data/spec/task_manager_spec.rb

@@ -20,12 +20,6 @@ describe "Task Managers" do
     @tm.should have(1).__tasks
   end
 
-  it "should validate tasks" do
-    @tm = TaskManager.new
-    @tm.server :server, :address => "test", :user => "root"
-    lambda { @tm.task(:deploy, :server => :not_here) { run "test" } }.should raise_error(Screwcap::ConfigurationError)
-  end
-
   it "should be able to define variables" do
     @tm.moon_pie= "moon pie"
     @tm.moon_pie.should == "moon pie"
@@ -46,14 +40,13 @@ describe "Task Managers" do
       run "test"
     end
     
-    @tm.should have(1).__command_sets
+    @tm.should have(1).__tasks
   end
 
   it "should be able to load a recipe file" do
     @tm = TaskManager.new(:recipe_file => "test/config/super_simple_recipe.rb")
     @tm.pie.should == "moon pie"
-    @tm.should have(1).__command_sets
-    @tm.should have(1).__tasks
+    @tm.should have(2).__tasks
   end
 
   it "should be able to execute a recipe" do
@@ -70,13 +63,11 @@ describe "Task Managers" do
   it "should be able to include multiple recipe files in a single recipe" do
     @tm = TaskManager.new(:recipe_file => "test/config/use.rb")
     @tm.pie.should == "moon pie"
-    @tm.should have(1).__command_sets
-    @tm.should have(1).__tasks
+    @tm.should have(2).__tasks
 
     @tm = TaskManager.new(:recipe_file => "test/config/use2.rb")
     @tm.pie.should == "moon pie"
-    @tm.should have(1).__command_sets
-    @tm.should have(1).__tasks
+    @tm.should have(2).__tasks
   end
 
   it "will complain if it can't find the use file" do

data/spec/task_spec.rb

@@ -27,6 +27,7 @@ describe "Tasks" do
     end
 
     commands = task.__build_commands([unknown])
+    task.__built_commands.should_not == []
     commands.size.should == 2
 
     commands[0][:type].should == :remote
@@ -133,21 +134,6 @@ describe "Tasks" do
     commands.map {|c| c[:command] }.should == ["deploy", "after"]
   end
 
-  it "should validate" do
-    task = Task.new :name => :test 
-    lambda { task.validate([]) }.should raise_error(Screwcap::ConfigurationError)
-
-    server = Server.new :name => :server, :address => "none", :user => "yeah"
-    other_server = Server.new :name => :server2, :address => "none", :user => "yeah"
-    task = Task.new :name => :test, :server => :server
-    lambda { task.validate([server]) }.should_not raise_error
-    lambda { task.validate([other_server]) }.should raise_error(Screwcap::ConfigurationError)
-    task = Task.new :name => :test, :servers => :server
-    lambda { task.validate([server]) }.should_not raise_error
-    task = Task.new :name => :test, :servers => [:server, :server2]
-    lambda { task.validate([server,other_server]) }.should_not raise_error
-  end
-
   it "should handle before and after inside a task" do
     do_other_task = Task.new :name => :other_task do
       run "task"
@@ -281,12 +267,30 @@ describe "Tasks" do
   end
 
   it "has an ex command" do
-    
     task = Task.new :name => :task do
       @test = "asdf"
       ex { @test = "fdsa" }
     end
 
     commands = task.__build_commands([task])
+    commands[0][:type].should == :block
+  end
+
+  it "should be able to call other tasks" do
+    t1 = Task.new :name => :release_the_hounds do
+      run "release_the_hounds"
+    end
+
+    t2 = Task.new :name => :lock_the_gate do
+      run "lock_the_gate"
+    end
+
+    t3 = Task.new :name => :release_the_hounds_and_lock_the_gate do
+      release_the_hounds
+      lock_the_gate
+    end
+
+    commands = t3.__build_commands [t1, t2]
+    commands.map {|c| c[:command] }.should == %w(release_the_hounds lock_the_gate)
   end
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: screwcap
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 5
   prerelease: false
   segments: 
   - 0
-  - 6
-  - 3
-  version: 0.6.3
+  - 7
+  version: "0.7"
 platform: ruby
 authors: 
 - Grant Ammons
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-18 00:00:00 -04:00
+date: 2011-03-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency