capistrano 1.1.0 → 1.2.0

data/lib/capistrano/shell.rb

@@ -0,0 +1,224 @@
+require 'thread'
+
+# The Capistrano::Shell class is the guts of the "shell" task. It implements
+# an interactive REPL interface that users can employ to execute tasks and
+# commands. It makes for a GREAT way to monitor systems, and perform quick
+# maintenance on one or more machines.
+
+module Capistrano
+  class Shell
+    # The actor instance employed by this shell
+    attr_reader :actor
+
+    # Instantiate a new shell and begin executing it immediately.
+    def self.run!(actor)
+      new(actor).run!
+    end
+
+    # Instantiate a new shell
+    def initialize(actor)
+      @actor = actor
+    end
+
+    # Start the shell running. This method will block until the shell
+    # terminates.
+    def run!
+      setup
+
+      puts <<-INTRO
+====================================================================
+Welcome to the interactive Capistrano shell! This is an experimental
+feature, and is liable to change in future releases.
+--------------------------------------------------------------------
+INTRO
+
+      loop do
+        command = @reader.readline("cap> ", true)
+
+        case command ? command.strip : command
+          when "" then next
+          when "help"  then help
+          when nil, "quit", "exit" then
+            puts if command.nil?
+            puts "exiting"
+            break
+          when /^set -(\w)\s*(\S+)/
+            set_option($1, $2)
+          when /^(?:(with|on)\s*(\S+))?\s*(\S.*)?/i
+            process_command($1, $2, $3)
+          else
+            raise "eh?"
+        end
+      end
+
+      @bgthread.kill
+    end
+
+    private
+
+      # A Readline replacement for platforms where readline is either
+      # unavailable, or has not been installed.
+      class ReadlineFallback
+        def self.readline(prompt, *args)
+          STDOUT.print(prompt)
+          STDOUT.flush
+          STDIN.gets
+        end
+      end
+
+      # Display a verbose help message.
+      def help
+        puts <<-HELP
+Welcome to the interactive Capistrano shell! To quit, just type quit,
+or exit. Or press ctrl-D. This shell is still experimental, so expect
+it to change (or even disappear!) in future releases.
+
+To execute a command on all servers, just type it directly, like:
+
+  cap> echo ping
+
+To execute a command on a specific set of servers, specify an 'on' clause.
+Note that if you specify more than one host name, they must be comma-
+delimited, with NO SPACES between them.
+
+  cap> on app1.foo.com,app2.foo.com echo ping
+
+To execute a command on all servers matching a set of roles:
+
+  cap> with app,db echo ping
+
+To execute a Capistrano task, prefix the name with a bang:
+
+  cap> !deploy
+
+You can specify multiple tasks to execute, separated by spaces:
+
+  cap> !update_code symlink
+
+And, lastly, you can specify 'on' or 'with' with tasks:
+
+  cap> on app6.foo.com !setup
+
+Enjoy!  
+HELP
+      end
+
+      # Determine which servers the given task requires a connection to, and
+      # establish connections to them if necessary. Return the list of
+      # servers (names).
+      def connect(task)
+        servers = task.servers(:refresh)
+        needing_connections = servers - actor.sessions.keys
+        unless needing_connections.empty?
+          puts "[establishing connection(s) to #{needing_connections.join(', ')}]"
+          actor.send(:establish_connections, servers)
+        end
+        servers
+      end
+
+      # Execute the given command. If the command is prefixed by an exclamation
+      # mark, it is assumed to refer to another capistrano task, which will
+      # be invoked. Otherwise, it is executed as a command on all associated
+      # servers.
+      def exec(command)
+        if command[0] == ?!
+          exec_tasks(command[1..-1].split)
+        else
+          servers = connect(actor.current_task)
+          exec_command(command, servers)
+        end
+      ensure
+        STDOUT.flush
+      end
+
+      # Given an array of task names, invoke them in sequence.
+      def exec_tasks(list)
+        list.each do |task_name|
+          task = task_name.to_sym
+          connect(actor.tasks[task])
+          actor.send(task)
+        end
+      end
+
+      # Execute a command on the given list of servers.
+      def exec_command(command, servers)
+        processor = Proc.new do |ch, stream, out|
+          # TODO: more robust prompt detection
+          out.each do |line|
+            if stream == :out
+              if out =~ /Password:\s*/i
+                ch.send_data "#{actor.password}\n"
+              else
+                puts "[#{ch[:host]}] #{line.chomp}"
+              end
+            elsif stream == :err
+              puts "[#{ch[:host]} ERR] #{line.chomp}"
+            end
+          end
+        end
+
+        cmd = Command.new(servers, command, processor, {}, actor)
+        previous = trap("INT") { cmd.stop! }
+        cmd.process! rescue nil
+        trap("INT", previous)
+      end
+
+      # Prepare every little thing for the shell. Starts the background
+      # thread and generally gets things ready for the REPL.
+      def setup
+        begin
+          require 'readline'
+          @reader = Readline
+        rescue LoadError
+          @reader = ReadlineFallback
+        end
+
+        @mutex = Mutex.new
+        @bgthread = Thread.new do
+            loop do
+              ready = actor.sessions.values.select { |sess| sess.connection.reader_ready? }
+              if ready.empty?
+                sleep 0.1
+              else
+                @mutex.synchronize do
+                  ready.each { |session| session.connection.process(true) }
+                end
+              end
+            end
+          end
+      end
+
+      # Set the given option to +value+.
+      def set_option(opt, value)
+        case opt
+          when "v" then
+            puts "setting log verbosity to #{value.to_i}"
+            actor.logger.level = value.to_i
+          else
+            puts "unknown setting #{value.inspect}"
+        end
+      end
+
+      # Process a command. Interprets the scope_type (must be nil, "with", or
+      # "on") and the command. If no command is given, then the scope is made
+      # effective for all subsequent commands. If the scope value is "all",
+      # then the scope is unrestricted.
+      def process_command(scope_type, scope_value, command)
+        env_var = case scope_type
+            when "with" then "ROLES"
+            when "on"   then "HOSTS"
+          end
+
+        old_var, ENV[env_var] = ENV[env_var], (scope_value == "all" ? nil : scope_value) if env_var
+        if command
+          begin
+            @mutex.synchronize { exec(command) }
+          ensure
+            ENV[env_var] = old_var if env_var
+          end
+        else
+          puts "scoping #{scope_type} #{scope_value}"
+        end
+      end
+  end
+end

data/lib/capistrano/ssh.rb

@@ -5,9 +5,8 @@ module Capistrano
     require 'capistrano/version'
     require 'net/ssh/version'
     ssh_version = [Net::SSH::Version::MAJOR, Net::SSH::Version::MINOR, Net::SSH::Version::TINY]
-    required_version = [1,0,5]
-    if !Version.check(required_version, ssh_version)
-      raise "You have Net::SSH #{ssh_version.join(".")}, but you need at least #{required_version.join(".")}"
+    if !Version.check(Version::SSH_REQUIRED, ssh_version)
+      raise "You have Net::SSH #{ssh_version.join(".")}, but you need at least #{Version::SSH_REQUIRED.join(".")}"
     end
   end
 

data/lib/capistrano/version.rb

@@ -19,12 +19,12 @@ module Capistrano
     end
 
     MAJOR = 1
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join(".")
     
-    SSH_REQUIRED = [1,0,8]
+    SSH_REQUIRED = [1,0,10]
     SFTP_REQUIRED = [1,1,0]
   end
 end

data/test/actor_test.rb

@@ -55,11 +55,16 @@ class ActorTest < Test::Unit::TestCase
     end
   end
 
-  class MockConfiguration
+  class MockConfiguration < Capistrano::Configuration
     Role = Struct.new(:host, :options)
 
     attr_accessor :gateway, :pretend
 
+    def initialize(*args)
+      super
+      @logger = Capistrano::Logger.new(:output => StringIO.new)
+    end
+
     def delegated_method
       "result of method"
     end
@@ -78,10 +83,6 @@ class ActorTest < Test::Unit::TestCase
     def roles
       ROLES
     end
-
-    def logger
-      @logger ||= Capistrano::Logger.new(:output => StringIO.new)
-    end
   end
 
   module CustomExtension
@@ -93,8 +94,19 @@ class ActorTest < Test::Unit::TestCase
   def setup
     TestingCommand.reset!
     @actor = TestActor.new(MockConfiguration.new)
+    ENV["ROLES"] = nil
+    ENV["HOSTS"] = nil
   end
 
+  def test_previous_release_returns_nil_with_one_release
+    class << @actor
+      def releases
+        ["1234567890"]
+      end
+    end
+    assert_equal @actor.previous_release, nil
+  end
+ 
   def test_define_task_creates_method
     @actor.define_task :hello do
       "result"
@@ -157,6 +169,26 @@ class ActorTest < Test::Unit::TestCase
     assert_equal [:goodbye, :hello], @actor.history
   end
 
+  def test_rollback_uses_roles_for_associated_task
+    @actor.define_task :inner, :roles => :db do
+      on_rollback { run "error" }
+      run "go"
+      raise "fail"
+    end
+
+    @actor.define_task :outer do
+      transaction do
+        inner
+      end
+      run "done"
+    end
+
+    assert_raise(RuntimeError) { @actor.outer }
+
+    assert TestingCommand.invoked?
+    assert_equal %w(01.example.com 02.example.com all.example.com), @actor.sessions.keys.sort
+  end
+
   def test_delegates_to_configuration
     @actor.define_task :hello do
       delegated_method
@@ -190,6 +222,16 @@ class ActorTest < Test::Unit::TestCase
     assert_equal %w(01.example.com 02.example.com all.example.com), @actor.sessions.keys.sort
   end
 
+  def test_run_in_task_with_single_role_selects_that_role_from_environment
+    ENV["ROLES"] = "app"
+    @actor.define_task :foo, :roles => :db do
+      run "do this"
+    end
+
+    @actor.foo
+    assert_equal %w(05.example.com 06.example.com 07.example.com all.example.com), @actor.sessions.keys.sort
+  end
+
   def test_run_in_task_with_multiple_roles_selects_those_roles
     @actor.define_task :foo, :roles => [:db, :web] do
       run "do this"
@@ -199,6 +241,16 @@ class ActorTest < Test::Unit::TestCase
     assert_equal %w(01.example.com 02.example.com 03.example.com 04.example.com all.example.com), @actor.sessions.keys.sort
   end
 
+  def test_run_in_task_with_multiple_roles_selects_those_roles_from_environment
+    ENV["ROLES"] = "app,db"
+    @actor.define_task :foo, :roles => [:db, :web] do
+      run "do this"
+    end
+
+    @actor.foo
+    assert_equal %w(01.example.com 02.example.com 05.example.com 06.example.com 07.example.com all.example.com), @actor.sessions.keys.sort
+  end
+
   def test_run_in_task_with_only_restricts_selected_roles
     @actor.define_task :foo, :roles => :db, :only => { :primary => true } do
       run "do this"
@@ -208,6 +260,53 @@ class ActorTest < Test::Unit::TestCase
     assert_equal %w(01.example.com), @actor.sessions.keys.sort
   end
 
+  def test_run_in_task_with_except_restricts_selected_roles
+    @actor.define_task :foo, :roles => :db, :except => { :primary => true } do
+      run "do this"
+    end
+
+    @actor.foo
+    assert_equal %w(02.example.com all.example.com), @actor.sessions.keys.sort
+  end
+
+  def test_run_in_task_with_single_host_selected
+    @actor.define_task :foo, :hosts => "01.example.com" do
+      run "do this"
+    end
+
+    @actor.foo
+    assert_equal %w(01.example.com), @actor.sessions.keys.sort
+  end
+
+  def test_run_in_task_with_single_host_selected_from_environment
+    ENV["HOSTS"] = "02.example.com"
+    @actor.define_task :foo, :hosts => "01.example.com" do
+      run "do this"
+    end
+
+    @actor.foo
+    assert_equal %w(02.example.com), @actor.sessions.keys.sort
+  end
+
+  def test_run_in_task_with_multiple_hosts_selected
+    @actor.define_task :foo, :hosts => [ "01.example.com", "07.example.com" ] do
+      run "do this"
+    end
+
+    @actor.foo
+    assert_equal %w(01.example.com 07.example.com), @actor.sessions.keys.sort
+  end
+
+  def test_run_in_task_with_multiple_hosts_selected_from_environment
+    ENV["HOSTS"] = "02.example.com,06.example.com"
+    @actor.define_task :foo, :hosts => [ "01.example.com", "07.example.com" ] do
+      run "do this"
+    end
+
+    @actor.foo
+    assert_equal %w(02.example.com 06.example.com), @actor.sessions.keys.sort
+  end
+
   def test_establish_connection_uses_gateway_if_specified
     @actor.configuration.gateway = "10.example.com"
     @actor.define_task :foo, :roles => :db do

data/test/scm/cvs_test.rb

@@ -183,4 +183,14 @@ MSG
     @scm = CvsTest.new(@config)
     assert_equal "default-branch", @scm.current_branch
   end
+
+  def test_default_local
+    @config = MockConfiguration.new
+    @config[:repository] = ":ext:joetester@rubyforge.org:/hello/world"
+    @config[:cvs] = "/path/to/cvs"
+    @config[:password] = "chocolatebrownies"
+    @config[:now] = Time.utc(2005,8,24,12,0,0)
+    @scm = CvsTest.new(@config)
+    assert_equal ".", @scm.configuration.local
+  end
 end

data/test/scm/subversion_test.rb

@@ -74,12 +74,6 @@ MSG
     assert_equal "/hello/world", @scm.last_path
   end
 
-  def test_latest_revision_searching_upwards
-    @scm.story = [ "-----------------------------\n", @log_msg ]
-    assert_equal "1967", @scm.latest_revision
-    assert_equal "/hello", @scm.last_path
-  end
-
   def test_checkout
     @actor.story = []
     assert_nothing_raised { @scm.checkout(@actor) }
@@ -114,6 +108,12 @@ MSG
     assert_equal ["chocolatebrownies\n"], @actor.channels.last.sent_data
   end
 
+  def test_checkout_needs_https_certificate
+    @actor.story = [[:out, "(R)eject, accept (t)emporarily or accept (p)ermanently? "]]
+    assert_nothing_raised { @scm.checkout(@actor) }
+    assert_equal ["t\n"], @actor.channels.last.sent_data
+  end
+
   def test_checkout_needs_alternative_ssh_password
     @actor.story = [[:out, "someone's password: "]]
     assert_nothing_raised { @scm.checkout(@actor) }