capistrano 2.4.3 → 2.5.0

data/lib/capistrano/configuration/connections.rb

@@ -23,21 +23,27 @@ module Capistrano
 
       class GatewayConnectionFactory #:nodoc:
         def initialize(gateway, options)
-          Thread.abort_on_exception = true
-          server = ServerDefinition.new(gateway)
-
           @options = options
-          @gateway = SSH.connection_strategy(server, options) do |host, user, connect_options|
+          @options[:logger].debug "Creating gateway using #{[*gateway].join(', ')}" if @options[:logger]
+          Thread.abort_on_exception = true
+          @gateways = [*gateway].collect { |g| ServerDefinition.new(g) }
+          tunnel = SSH.connection_strategy(@gateways[0], @options) do |host, user, connect_options|
             Net::SSH::Gateway.new(host, user, connect_options)
           end
+          @gateway = (@gateways[1..-1]).inject(tunnel) do |tunnel, destination|
+            @options[:logger].debug "Creating tunnel to #{destination}" if @options[:logger]
+            local_host = ServerDefinition.new("127.0.0.1", :user => destination.user, :port => tunnel.open(destination.host, (destination.port || 22)))
+            SSH.connection_strategy(local_host, @options) do |host, user, connect_options|
+              Net::SSH::Gateway.new(host, user, connect_options)
+            end
+          end
         end
-
+        
         def connect_to(server)
           @options[:logger].debug "establishing connection to `#{server}' via gateway" if @options[:logger]
           local_host = ServerDefinition.new("127.0.0.1", :user => server.user, :port => @gateway.open(server.host, server.port || 22))
           session = SSH.connect(local_host, @options)
           session.xserver = server
-          @options[:logger].trace "connected: `#{server}' (via gateway)" if @options[:logger]
           session
         end
       end

data/lib/capistrano/configuration/execution.rb

@@ -60,8 +60,9 @@ module Capistrano
       # hook will be executed.
       def on_rollback(&block)
         if transaction?
+          # don't note a new rollback request if one has already been set
+          rollback_requests << task_call_frames.last unless task_call_frames.last.rollback
           task_call_frames.last.rollback = block
-          rollback_requests << task_call_frames.last
         end
       end
 

data/lib/capistrano/configuration/servers.rb

@@ -35,13 +35,14 @@ module Capistrano
       #   servers = find_servers :hosts => "jamis@example.host.com"
       def find_servers(options={})
         hosts  = server_list_from(ENV['HOSTS'] || options[:hosts])
-        roles  = role_list_from(ENV['ROLES'] || options[:roles] || self.roles.keys)
-        only   = options[:only] || {}
-        except = options[:except] || {}
-
+        
         if hosts.any?
           hosts.uniq
         else
+          roles  = role_list_from(ENV['ROLES'] || options[:roles] || self.roles.keys)
+          only   = options[:only] || {}
+          except = options[:except] || {}
+          
           servers = roles.inject([]) { |list, role| list.concat(self.roles[role]) }
           servers = servers.select { |server| only.all? { |key,value| server.options[key] == value } }
           servers = servers.reject { |server| except.any? { |key,value| server.options[key] == value } }

data/lib/capistrano/recipes/deploy.rb

@@ -42,6 +42,7 @@ _cset(:release_name)      { set :deploy_timestamped, true; Time.now.utc.strftime
 
 _cset :version_dir,       "releases"
 _cset :shared_dir,        "shared"
+_cset :shared_children,   %w(system log pids)
 _cset :current_dir,       "current"
 
 _cset(:releases_path)     { File.join(deploy_to, version_dir) }
@@ -49,7 +50,7 @@ _cset(:shared_path)       { File.join(deploy_to, shared_dir) }
 _cset(:current_path)      { File.join(deploy_to, current_dir) }
 _cset(:release_path)      { File.join(releases_path, release_name) }
 
-_cset(:releases)          { capture("ls -x #{releases_path}").split.sort }
+_cset(:releases)          { capture("ls -xt #{releases_path}").split.reverse }
 _cset(:current_release)   { File.join(releases_path, releases.last) }
 _cset(:previous_release)  { File.join(releases_path, releases[-2]) }
 
@@ -160,7 +161,7 @@ namespace :deploy do
   DESC
   task :setup, :except => { :no_release => true } do
     dirs = [deploy_to, releases_path, shared_path]
-    dirs += %w(system log pids).map { |d| File.join(shared_path, d) }
+    dirs += shared_children.map { |d| File.join(shared_path, d) }
     run "#{try_sudo} mkdir -p #{dirs.join(' ')} && #{try_sudo} chmod g+w #{dirs.join(' ')}"
   end
 
@@ -287,28 +288,50 @@ namespace :deploy do
     try_runner "#{current_path}/script/process/reaper"
   end
 
-  desc <<-DESC
-    Rolls back to the previously deployed version. The `current' symlink will \
-    be updated to point at the previously deployed version, and then the \
-    current release will be removed from the servers. You'll generally want \
-    to call `rollback' instead, as it performs a `restart' as well.
-  DESC
-  task :rollback_code, :except => { :no_release => true } do
-    if releases.length < 2
-      abort "could not rollback the code because there is no prior release"
-    else
-      run "rm #{current_path}; ln -s #{previous_release} #{current_path} && rm -rf #{current_release}"
+  namespace :rollback do
+    desc <<-DESC
+      [internal] Points the current symlink at the previous revision.
+      This is called by the rollback sequence, and should rarely (if
+      ever) need to be called directly.
+    DESC
+    task :revision, :except => { :no_release => true } do
+      if releases.length < 2
+        abort "could not rollback the code because there is no prior release"
+      else
+        run "rm #{current_path}; ln -s #{previous_release} #{current_path}"
+      end
     end
-  end
 
-  desc <<-DESC
-    Rolls back to a previous version and restarts. This is handy if you ever \
-    discover that you've deployed a lemon; `cap rollback' and you're right \
-    back where you were, on the previously deployed version.
-  DESC
-  task :rollback do
-    rollback_code
-    restart
+    desc <<-DESC
+      [internal] Removes the most recently deployed release.
+      This is called by the rollback sequence, and should rarely
+      (if ever) need to be called directly.
+    DESC
+    task :cleanup, :except => { :no_release => true } do
+      run "if [ `readlink #{current_path}` != #{current_release} ]; then rm -rf #{current_release}; fi"
+    end
+
+    desc <<-DESC
+      Rolls back to the previously deployed version. The `current' symlink will \
+      be updated to point at the previously deployed version, and then the \
+      current release will be removed from the servers. You'll generally want \
+      to call `rollback' instead, as it performs a `restart' as well.
+    DESC
+    task :code, :except => { :no_release => true } do
+      revision
+      cleanup
+    end
+
+    desc <<-DESC
+      Rolls back to a previous version and restarts. This is handy if you ever \
+      discover that you've deployed a lemon; `cap rollback' and you're right \
+      back where you were, on the previously deployed version.
+    DESC
+    task :default do
+      revision
+      restart
+      cleanup
+    end
   end
 
   desc <<-DESC

data/lib/capistrano/recipes/deploy/local_dependency.rb

@@ -30,7 +30,7 @@ module Capistrano
       # file is found that matches the parameter, this returns true.
       def find_in_path(utility)
         path = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
-        suffixes = self.class.on_windows? ? %w(.bat .exe .com .cmd) : [""]
+        suffixes = self.class.on_windows? ? self.class.windows_executable_extensions : [""]
 
         path.each do |dir|
           suffixes.each do |sfx|
@@ -41,9 +41,13 @@ module Capistrano
 
         false
       end
-      
+
       def self.on_windows?
-        RUBY_PLATFORM =~ /mswin/
+        RUBY_PLATFORM =~ /mswin|mingw/
+      end
+
+      def self.windows_executable_extensions
+        %w(.exe .bat .com .cmd)
       end
     end
   end

data/lib/capistrano/recipes/deploy/scm/cvs.rb

@@ -71,7 +71,7 @@ module Capistrano
           revision = yield(scm(cvs_root, :log, "-r#{revision}")).
                        grep(/^date:/).
                        map { |line| line[/^date: (.*?);/, 1] }.
-                       sort.last
+                       sort.last + " UTC"
           return revision
         end
 
@@ -111,6 +111,7 @@ module Capistrano
           
           # attempts to guess what type of revision we're working with
           def revision_type(rev)
+            return :date if rev =~ /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2} UTC$/ # i.e 2007-05-15 08:13:25 UTC
             return :date if rev =~ /^\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2}$/ # i.e 2007-05-15 08:13:25
             return :revision if rev =~ /^\d/ # i.e. 1.2.1
             return :tag # i.e. RELEASE_1_2

data/lib/capistrano/recipes/deploy/scm/none.rb

@@ -27,7 +27,7 @@ module Capistrano
         # Simply does a copy from the :repository directory to the
         # :destination directory.
         def checkout(revision, destination)
-          "cp -R #{repository} #{destination}"
+          !Capistrano::Deploy::LocalDependency.on_windows? ? "cp -R #{repository} #{destination}" : "xcopy #{repository} \"#{destination}\" /S/I/Y/Q/E"
         end
 
         alias_method :export, :checkout

data/lib/capistrano/recipes/deploy/scm/subversion.rb

@@ -98,7 +98,7 @@ module Capistrano
             username = variable(:scm_username)
             return "" unless username
             result = "--username #{variable(:scm_username)} "
-            result << "--password #{variable(:scm_password)} " unless variable(:scm_prefer_prompt)
+            result << "--password #{variable(:scm_password)} " unless variable(:scm_auth_cache) || variable(:scm_prefer_prompt)
             result << "--no-auth-cache " unless variable(:scm_auth_cache)
             result
           end

data/lib/capistrano/recipes/deploy/strategy/copy.rb

@@ -80,7 +80,7 @@ module Capistrano
 
             if copy_exclude.any?
               logger.debug "processing exclusions..."
-              copy_exclude.each { |pattern| FileUtils.rm_rf(File.join(destination, pattern)) }
+              copy_exclude.each { |pattern| FileUtils.rm_rf(Dir.glob(File.join(destination, pattern), File::FNM_DOTMATCH)) }
             end
           end
 

data/lib/capistrano/recipes/deploy/strategy/remote_cache.rb

@@ -38,7 +38,16 @@ module Capistrano
 
           def copy_repository_cache
             logger.trace "copying the cached version to #{configuration[:release_path]}"
-            run "cp -RPp #{repository_cache} #{configuration[:release_path]} && #{mark}"
+            if copy_exclude.empty? 
+              run "cp -RPp #{repository_cache} #{configuration[:release_path]} && #{mark}"
+            else
+              exclusions = copy_exclude.map { |e| "--exclude=\"#{e}\"" }.join(' ')
+              run "rsync -rp #{exclusions} #{repository_cache}/* #{configuration[:release_path]} && #{mark}"
+            end
+          end
+          
+          def copy_exclude
+            @copy_exclude ||= Array(configuration.fetch(:copy_exclude, []))
           end
       end
 

data/lib/capistrano/role.rb

@@ -38,6 +38,10 @@ module Capistrano
       @static_servers.clear
     end
 
+    def include?(server)
+      servers.include?(server)
+    end
+
     protected
 
     # This is the combination of a block, a hash of options, and a cached value.

data/lib/capistrano/version.rb

@@ -5,8 +5,8 @@ module Capistrano
   # Describes the current version of Capistrano.
   class Version < Net::SSH::Version
     MAJOR = 2
-    MINOR = 4
-    TINY  = 3
+    MINOR = 5
+    TINY  = 0
 
     # The current version, as a Version instance
     CURRENT = new(MAJOR, MINOR, TINY)

data/test/cli/execute_test.rb

@@ -15,7 +15,7 @@ class CLIExecuteTest < Test::Unit::TestCase
   def setup
     @cli = MockCLI.new
     @logger = stub_everything
-    @config = stub(:logger => @logger, :debug= => nil)
+    @config = stub(:logger => @logger, :debug= => nil, :dry_run= => nil)
     @config.stubs(:set)
     @config.stubs(:load)
     @config.stubs(:trigger)

data/test/cli/options_test.rb

@@ -30,6 +30,18 @@ class CLIOptionsTest < Test::Unit::TestCase
     assert @cli.options[:debug]
   end
 
+  def test_parse_options_with_n_should_set_dry_run_option
+    @cli.args << "-n"
+    @cli.parse_options!
+    assert @cli.options[:dry_run]
+  end
+
+  def test_parse_options_with_dry_run_should_set_dry_run_option
+    @cli.args << "--dry-run"
+    @cli.parse_options!
+    assert @cli.options[:dry_run]
+  end
+
   def test_parse_options_with_e_should_set_explain_option
     @cli.args << "-e" << "sample"
     @cli.parse_options!
@@ -87,12 +99,84 @@ class CLIOptionsTest < Test::Unit::TestCase
     assert_equal "bar", @cli.options[:pre_vars][:foo]
   end
 
+  def test_S_should_coerce_digits_to_integers
+    @cli.args << "-S" << "foo=1234"
+    @cli.parse_options!
+    assert_equal 1234, @cli.options[:pre_vars][:foo]
+  end
+
+  def test_S_should_treat_quoted_integers_as_string
+    @cli.args << "-S" << "foo=\"1234\""
+    @cli.parse_options!
+    assert_equal "1234", @cli.options[:pre_vars][:foo]
+  end
+
+  def test_S_should_treat_digits_with_dot_as_floating_point
+    @cli.args << "-S" << "foo=3.1415"
+    @cli.parse_options!
+    assert_equal 3.1415, @cli.options[:pre_vars][:foo]
+  end
+
+  def test_S_should_treat_true_as_boolean_true
+    @cli.args << "-S" << "foo=true"
+    @cli.parse_options!
+    assert_equal true, @cli.options[:pre_vars][:foo]
+  end
+
+  def test_S_should_treat_false_as_boolean_false
+    @cli.args << "-S" << "foo=false"
+    @cli.parse_options!
+    assert_equal false, @cli.options[:pre_vars][:foo]
+  end
+
+  def test_S_should_treat_nil_as_nil
+    @cli.args << "-S" << "foo=nil"
+    @cli.parse_options!
+    assert_equal nil, @cli.options[:pre_vars][:foo]
+  end
+
   def test_parse_options_with_s_should_set_vars
     @cli.args << "-s" << "foo=bar"
     @cli.parse_options!
     assert_equal "bar", @cli.options[:vars][:foo]
   end
 
+  def test_s_should_coerce_digits_to_integers
+    @cli.args << "-s" << "foo=1234"
+    @cli.parse_options!
+    assert_equal 1234, @cli.options[:vars][:foo]
+  end
+
+  def test_s_should_treat_quoted_integers_as_string
+    @cli.args << "-s" << "foo=\"1234\""
+    @cli.parse_options!
+    assert_equal "1234", @cli.options[:vars][:foo]
+  end
+
+  def test_s_should_treat_digits_with_dot_as_floating_point
+    @cli.args << "-s" << "foo=3.1415"
+    @cli.parse_options!
+    assert_equal 3.1415, @cli.options[:vars][:foo]
+  end
+
+  def test_s_should_treat_true_as_boolean_true
+    @cli.args << "-s" << "foo=true"
+    @cli.parse_options!
+    assert_equal true, @cli.options[:vars][:foo]
+  end
+
+  def test_s_should_treat_false_as_boolean_false
+    @cli.args << "-s" << "foo=false"
+    @cli.parse_options!
+    assert_equal false, @cli.options[:vars][:foo]
+  end
+
+  def test_s_should_treat_nil_as_nil
+    @cli.args << "-s" << "foo=nil"
+    @cli.parse_options!
+    assert_equal nil, @cli.options[:vars][:foo]
+  end
+
   def test_parse_options_with_T_should_set_tasks_option_and_set_verbose_off
     @cli.args << "-T"
     @cli.parse_options!

data/test/command_test.rb

@@ -1,22 +1,21 @@
 require "utils"
 require 'capistrano/command'
+require 'capistrano/configuration'
 
 class CommandTest < Test::Unit::TestCase
   def test_command_should_open_channels_on_all_sessions
-    s1 = mock(:open_channel => nil)
-    s2 = mock(:open_channel => nil)
-    s3 = mock(:open_channel => nil)
-    assert_equal "ls", Capistrano::Command.new("ls", [s1, s2, s3]).command
+    s1, s2, s3 = mock_session, mock_session, mock_session
+    assert_equal "ls", Capistrano::Command.new("ls", [s1, s2, s3]).tree.fallback.command
   end
 
   def test_command_with_newlines_should_be_properly_escaped
-    cmd = Capistrano::Command.new("ls\necho", [mock(:open_channel => nil)])
-    assert_equal "ls\\\necho", cmd.command
+    cmd = Capistrano::Command.new("ls\necho", [mock_session])
+    assert_equal "ls\\\necho", cmd.tree.fallback.command
   end
 
   def test_command_with_windows_newlines_should_be_properly_escaped
-    cmd = Capistrano::Command.new("ls\r\necho", [mock(:open_channel => nil)])
-    assert_equal "ls\\\necho", cmd.command
+    cmd = Capistrano::Command.new("ls\r\necho", [mock_session])
+    assert_equal "ls\\\necho", cmd.tree.fallback.command
   end
 
   def test_command_with_pty_should_request_pty_and_register_success_callback
@@ -76,25 +75,17 @@ class CommandTest < Test::Unit::TestCase
   end
 
   def test_open_channel_should_set_host_key_on_channel
-    session = mock(:xserver => server("capistrano"))
-    channel = stub_everything
-
-    session.expects(:open_channel).yields(channel)
-    channel.expects(:[]=).with(:host, "capistrano")
-    channel.stubs(:[]).with(:host).returns("capistrano")
-
+    channel = nil
+    session = setup_for_extracting_channel_action { |ch| channel = ch }
     Capistrano::Command.new("ls", [session])
+    assert_equal "capistrano", channel[:host]
   end
 
   def test_open_channel_should_set_options_key_on_channel
-    session = mock(:xserver => server("capistrano"))
-    channel = stub_everything
-
-    session.expects(:open_channel).yields(channel)
-    channel.expects(:[]=).with(:options, {:data => "here we go"})
-    channel.stubs(:[]).with(:host).returns("capistrano")
-
+    channel = nil
+    session = setup_for_extracting_channel_action { |ch| channel = ch }
     Capistrano::Command.new("ls", [session], :data => "here we go")
+    assert_equal({ :data => 'here we go' }, channel[:options])
   end
 
   def test_successful_channel_should_send_command
@@ -157,17 +148,17 @@ class CommandTest < Test::Unit::TestCase
 
   def test_on_request_should_record_exit_status
     data = mock(:read_long => 5)
-    session = setup_for_extracting_channel_action([:on_request, "exit-status"], data) do |ch|
-      ch.expects(:[]=).with(:status, 5)
-    end
+    channel = nil
+    session = setup_for_extracting_channel_action([:on_request, "exit-status"], data) { |ch| channel = ch }
     Capistrano::Command.new("ls", [session])
+    assert_equal 5, channel[:status]
   end
 
   def test_on_close_should_set_channel_closed
-    session = setup_for_extracting_channel_action(:on_close) do |ch|
-      ch.expects(:[]=).with(:closed, true)
-    end
+    channel = nil
+    session = setup_for_extracting_channel_action(:on_close) { |ch| channel = ch }
     Capistrano::Command.new("ls", [session])
+    assert channel[:closed]
   end
 
   def test_stop_should_close_all_open_channels
@@ -228,10 +219,8 @@ class CommandTest < Test::Unit::TestCase
 
   def test_process_should_instantiate_command_and_process!
     cmd = mock("command", :process! => nil)
-    Capistrano::Command.expects(:new).with("ls -l", %w(a b c), {:foo => "bar"}).yields(:command).returns(cmd)
-    parameter = nil
-    Capistrano::Command.process("ls -l", %w(a b c), :foo => "bar") { |cmd| parameter = cmd }
-    assert_equal :command, parameter
+    Capistrano::Command.expects(:new).with("ls -l", %w(a b c), {:foo => "bar"}).returns(cmd)
+    Capistrano::Command.process("ls -l", %w(a b c), :foo => "bar")
   end
 
   def test_process_with_host_placeholder_should_substitute_placeholder_with_each_host
@@ -254,16 +243,20 @@ class CommandTest < Test::Unit::TestCase
       stub('session', :open_channel => channel,
         :preprocess => true,
         :postprocess => true,
-        :listeners => {})
+        :listeners => {},
+        :xserver => server("capistrano"))
+    end
+
+    class MockChannel < Hash
+      def close
+      end
     end
 
     def new_channel(closed, status=nil)
-      ch = mock("channel")
-      ch.expects(:[]).with(:closed).returns(closed)
-      ch.expects(:[]).with(:status).returns(status) if status
+      ch = MockChannel.new
+      ch.update({ :closed => closed, :host => "capistrano", :server => server("capistrano") })
+      ch[:status] = status if status
       ch.expects(:close) unless closed
-      ch.stubs(:[]).with(:host).returns("capistrano")
-      ch.stubs(:[]).with(:server).returns(server("capistrano"))
       ch
     end
 
@@ -271,11 +264,15 @@ class CommandTest < Test::Unit::TestCase
       s = server("capistrano")
       session = mock("session", :xserver => s)
 
-      channel = stub_everything
+      channel = {}
       session.expects(:open_channel).yields(channel)
 
-      channel.stubs(:[]).with(:server).returns(s)
-      channel.stubs(:[]).with(:host).returns(s.host)
+      channel.stubs(:on_data)
+      channel.stubs(:on_extended_data)
+      channel.stubs(:on_request)
+      channel.stubs(:on_close)
+      channel.stubs(:exec)
+      channel.stubs(:send_data)
 
       if action
         action = Array(action)