capistrano 2.5.3 → 2.5.4

data/CHANGELOG.rdoc

@@ -1,3 +1,18 @@
+== 2.5.4 / 4 Feb 2009
+
+* When using rsync with the remote_cache strategy include -t switch to preserve file times [Kevin McCarthy]
+
+* Bump Net::SSH dependency to version 2.0.10 [Jamis Buck]
+
+* Use 'user' from .ssh/config appropriately [Jamis Buck]
+
+* Allow respond_to?() method to accept optional second parameter (include_priv) [Matthias Marschall]
+
+* Make sure sudo prompts are retried correctly even if "try again" and the prompt appear in the same text chunk from the server [Jamis Buck]
+
+* Add supported environment variables to -H output [François Beausoleil]
+
+
 == 2.5.3 / December 6, 2008
 
 * Make previous_release return nil if there is no previous release [Mathias Meyer]

data/Rakefile

@@ -26,7 +26,7 @@ Echoe.new('capistrano', version) do |p|
   p.need_zip         = true
   p.rdoc_pattern     = /^(lib|README.rdoc|CHANGELOG.rdoc)/
 
-  p.dependencies     = ["net-ssh         >=2.0.0",
+  p.dependencies     = ["net-ssh         >=2.0.10",
                         "net-sftp        >=2.0.0",
                         "net-scp         >=1.0.0",
                         "net-ssh-gateway >=1.0.0",

data/capistrano.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
   s.name = %q{capistrano}
-  s.version = "2.5.3"
+  s.version = "2.5.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jamis Buck"]
-  s.date = %q{2008-12-06}
+  s.date = %q{2009-02-04}
   s.description = %q{Capistrano is a utility and framework for executing commands in parallel on multiple remote machines, via SSH.}
   s.email = %q{jamis@jamisbuck.org}
   s.executables = ["cap", "capify"]
@@ -24,14 +24,14 @@ Gem::Specification.new do |s|
     s.specification_version = 2
 
     if current_version >= 3 then
-      s.add_runtime_dependency(%q<net-ssh>, [">= 2.0.0"])
+      s.add_runtime_dependency(%q<net-ssh>, [">= 2.0.10"])
       s.add_runtime_dependency(%q<net-sftp>, [">= 2.0.0"])
       s.add_runtime_dependency(%q<net-scp>, [">= 1.0.0"])
       s.add_runtime_dependency(%q<net-ssh-gateway>, [">= 1.0.0"])
       s.add_runtime_dependency(%q<highline>, [">= 0"])
       s.add_development_dependency(%q<echoe>, [">= 0"])
     else
-      s.add_dependency(%q<net-ssh>, [">= 2.0.0"])
+      s.add_dependency(%q<net-ssh>, [">= 2.0.10"])
       s.add_dependency(%q<net-sftp>, [">= 2.0.0"])
       s.add_dependency(%q<net-scp>, [">= 1.0.0"])
       s.add_dependency(%q<net-ssh-gateway>, [">= 1.0.0"])
@@ -39,7 +39,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<echoe>, [">= 0"])
     end
   else
-    s.add_dependency(%q<net-ssh>, [">= 2.0.0"])
+    s.add_dependency(%q<net-ssh>, [">= 2.0.10"])
     s.add_dependency(%q<net-sftp>, [">= 2.0.0"])
     s.add_dependency(%q<net-scp>, [">= 1.0.0"])
     s.add_dependency(%q<net-ssh-gateway>, [">= 1.0.0"])

data/lib/capistrano/cli/help.txt

@@ -60,3 +60,16 @@ The following options are understood:
 
   <%= color '-x, --skip-user-config', :bold %>
 	By default, cap will look for and (if it exists) load the user-specific configuration file located in $HOME/.caprc. If you don't want cap to load that file, give this option.
+
+-----------------------------
+<%= color('Environment Variables', :bold) %>
+-----------------------------
+
+  <%= color 'HOSTS', :bold %>
+	Execute the tasks against this comma-separated list of hosts.  Effectively, this makes the host(s) part of every roles.
+
+  <%= color 'HOSTFILTER', :bold %>
+	Execute tasks against this comma-separated list of host, but only if the host has the proper role for the task.
+
+  <%= color 'ROLES', :bold %>
+	Execute tasks against this comma-separated list of roles.  Hosts which do not have the right roles will be skipped.

data/lib/capistrano/cli/options.rb

@@ -43,7 +43,7 @@ module Capistrano
             "A recipe file to load. May be given more than once."
           ) { |value| options[:recipes] << value }
 
-          opts.on("-H", "--long-help", "Explain these options.") do
+          opts.on("-H", "--long-help", "Explain these options and environment variables.") do
             long_help
             exit
           end

data/lib/capistrano/configuration/actions/invocation.rb

@@ -26,10 +26,57 @@ module Capistrano
           set :default_run_options, {}
         end
 
+        # Executes different commands in parallel. This is useful for commands
+        # that need to be different on different hosts, but which could be
+        # otherwise run in parallel.
+        #
+        # The +options+ parameter is currently unused.
+        #
+        # Example:
+        #
+        #   task :restart_everything do
+        #     parallel do |session|
+        #       session.when "in?(:app)", "/path/to/restart/mongrel"
+        #       session.when "in?(:web)", "/path/to/restart/apache"
+        #       session.when "in?(:db)", "/path/to/restart/mysql"
+        #     end
+        #   end
+        #
+        # Each command may have its own callback block, for capturing and
+        # responding to output, with semantics identical to #run:
+        #
+        #   session.when "in?(:app)", "/path/to/restart/mongrel" do |ch, stream, data|
+        #     # ch is the SSH channel for this command, used to send data
+        #     #    back to the command (e.g. ch.send_data("password\n"))
+        #     # stream is either :out or :err, for which stream the data arrived on
+        #     # data is a string containing data sent from the remote command
+        #   end
+        #
+        # Also, you can specify a fallback command, to use when none of the
+        # conditions match a server:
+        #
+        #   session.else "/execute/something/else"
+        #
+        # The string specified as the first argument to +when+ may be any valid
+        # Ruby code. It has access to the following variables and methods:
+        # 
+        # * +in?(role)+ returns true if the server participates in the given role
+        # * +server+ is the ServerDefinition object for the server. This can be
+        #   used to get the host-name, etc.
+        # * +configuration+ is the current Capistrano::Configuration object, which
+        #   you can use to get the value of variables, etc.
+        #
+        # For example:
+        #
+        #   session.when "server.host =~ /app/", "/some/command"
+        #   session.when "server.host == configuration[:some_var]", "/another/command"
+        #   session.when "in?(:web) || in?(:app)", "/more/commands"
+        #
+        # See #run for a description of the valid +options+.
         def parallel(options={})
           raise ArgumentError, "parallel() requires a block" unless block_given?
           tree = Command::Tree.new(self) { |t| yield t }
-          run_tree(tree)
+          run_tree(tree, options)
         end
 
         # Invokes the given command. If a +via+ key is given, it will be used
@@ -48,13 +95,58 @@ module Capistrano
         # channel (which may be used to send data back to the remote process),
         # the stream identifier (<tt>:err</tt> for stderr, and <tt>:out</tt> for
         # stdout), and the data that was received.
+        #
+        # The +options+ hash may include any of the following keys:
+        #
+        # * :hosts - this is either a string (for a single target host) or an array
+        #   of strings, indicating which hosts the command should run on. By default,
+        #   the hosts are determined from the task definition.
+        # * :roles - this is either a string or symbol (for a single target role) or
+        #   an array of strings or symbols, indicating which roles the command should
+        #   run on. If :hosts is specified, :roles will be ignored.
+        # * :only - specifies a condition limiting which hosts will be selected to
+        #   run the command. This should refer to values set in the role definition.
+        #   For example, if a role is defined with :primary => true, then you could
+        #   select only hosts with :primary true by setting :only => { :primary => true }.
+        # * :except - specifies a condition limiting which hosts will be selected to
+        #   run the command. This is the inverse of :only (hosts that do _not_ match
+        #   the condition will be selected).
+        # * :once - if true, only the first matching server will be selected. The default
+        #   is false (all matching servers will be selected).
+        # * :max_hosts - specifies the maximum number of hosts that should be selected
+        #   at a time. If this value is less than the number of hosts that are selected
+        #   to run, then the hosts will be run in groups of max_hosts. The default is nil,
+        #   which indicates that there is no maximum host limit.
+        # * :shell - says which shell should be used to invoke commands. This
+        #   defaults to "sh". Setting this to false causes Capistrano to invoke
+        #   the commands directly, without wrapping them in a shell invocation.
+        # * :data - if not nil (the default), this should be a string that will
+        #   be passed to the command's stdin stream.
+        # * :pty - if true, a pseudo-tty will be allocated for each command. The
+        #   default is false. Note that there are benefits and drawbacks both ways.
+        #   Empirically, it appears that if a pty is allocated, the SSH server daemon
+        #   will _not_ read user shell start-up scripts (e.g. bashrc, etc.). However,
+        #   if a pty is _not_ allocated, some commands will refuse to run in
+        #   interactive mode and will not prompt for (e.g.) passwords.
+        # * :env - a hash of environment variable mappings that should be made
+        #   available to the command. The keys should be environment variable names,
+        #   and the values should be their corresponding values. The default is
+        #   empty, but may be modified by changing the +default_environment+
+        #   Capistrano variable.
+        #
+        # Note that if you set these keys in the +default_run_options+ Capistrano
+        # variable, they will apply for all invocations of #run, #invoke_command,
+        # and #parallel.
         def run(cmd, options={}, &block)
           block ||= self.class.default_io_proc
           tree = Command::Tree.new(self) { |t| t.else(cmd, &block) }
           run_tree(tree, options)
         end
 
-        def run_tree(tree, options={})
+        # Executes a Capistrano::Command::Tree object. This is not for direct
+        # use, but should instead be called indirectly, via #run or #parallel,
+        # or #invoke_command.
+        def run_tree(tree, options={}) #:nodoc:
           if tree.branches.empty? && tree.fallback
             logger.debug "executing #{tree.fallback}"
           elsif tree.branches.any?
@@ -98,6 +190,12 @@ module Capistrano
         # executable on the remote machine:
         #
         #   set :sudo, "/opt/local/bin/sudo"
+        #
+        # If you know what you're doing, you can also set <tt>:sudo_prompt</tt>,
+        # which tells capistrano which prompt sudo should use when asking for
+        # a password. (This is so that capistrano knows what prompt to look for
+        # in the output.) If you set :sudo_prompt to an empty string, Capistrano
+        # will not send a preferred prompt.
         def sudo(*parameters, &block)
           options = parameters.last.is_a?(Hash) ? parameters.pop.dup : {}
           command = parameters.first
@@ -125,14 +223,16 @@ module Capistrano
           prompt_host = nil
 
           Proc.new do |ch, stream, out|
-            if out =~ /^#{Regexp.escape(sudo_prompt)}/
-              ch.send_data "#{self[:password]}\n"
-            elsif out =~ /^Sorry, try again/
+            if out =~ /^Sorry, try again/
               if prompt_host.nil? || prompt_host == ch[:server]
                 prompt_host = ch[:server]
                 logger.important out, "#{stream} :: #{ch[:server]}"
                 reset! :password
               end
+            end
+
+            if out =~ /^#{Regexp.escape(sudo_prompt)}/
+              ch.send_data "#{self[:password]}\n"
             elsif fallback
               fallback.call(ch, stream, out)
             end

data/lib/capistrano/configuration/namespaces.rb

@@ -177,8 +177,8 @@ module Capistrano
             raise NotImplementedError, "roles cannot be defined in a namespace"
           end
 
-          def respond_to?(sym)
-            super || parent.respond_to?(sym)
+          def respond_to?(sym, include_priv=false)
+            super || parent.respond_to?(sym, include_priv)
           end
 
           def method_missing(sym, *args, &block)

data/lib/capistrano/configuration/variables.rb

@@ -111,8 +111,8 @@ module Capistrano
       end
       private :protect
 
-      def respond_to_with_variables?(sym) #:nodoc:
-        @variables.has_key?(sym) || respond_to_without_variables?(sym)
+      def respond_to_with_variables?(sym, include_priv=false) #:nodoc:
+        @variables.has_key?(sym) || respond_to_without_variables?(sym, include_priv)
       end
 
       def method_missing_with_variables(sym, *args, &block) #:nodoc:

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

@@ -208,7 +208,7 @@ module Capistrano
         # Getting the actual commit id, in case we were passed a tag
         # or partial sha or something - it will return the sha if you pass a sha, too
         def query_revision(revision)
-          raise ArgumentError, "Deploying remote branches has been deprecated.  Specify the remote branch as a local branch for the git repository you're deploying from (ie: '#{revision.gsub('origin/', '')}' rather than '#{revision}')." if revision =~ /^origin\//
+          raise ArgumentError, "Deploying remote branches is no longer supported.  Specify the remote branch as a local branch for the git repository you're deploying from (ie: '#{revision.gsub('origin/', '')}' rather than '#{revision}')." if revision =~ /^origin\//
           return revision if revision =~ /^[0-9a-f]{40}$/
           command = scm('ls-remote', repository, revision)
           result = yield(command)

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

@@ -42,7 +42,7 @@ module Capistrano
               run "cp -RPp #{repository_cache} #{configuration[:release_path]} && #{mark}"
             else
               exclusions = copy_exclude.map { |e| "--exclude=\"#{e}\"" }.join(' ')
-              run "rsync -lrp #{exclusions} #{repository_cache}/* #{configuration[:release_path]} && #{mark}"
+              run "rsync -lrpt #{exclusions} #{repository_cache}/* #{configuration[:release_path]} && #{mark}"
             end
           end
           

data/lib/capistrano/ssh.rb

@@ -1,6 +1,6 @@
 begin
   require 'rubygems'
-  gem 'net-ssh', ">= 1.99.1"
+  gem 'net-ssh', ">= 2.0.10"
 rescue LoadError, NameError
 end
 
@@ -55,12 +55,32 @@ module Capistrano
       methods = [ %w(publickey hostbased), %w(password keyboard-interactive) ]
       password_value = nil
 
-      ssh_options = (server.options[:ssh_options] || {}).merge(options[:ssh_options] || {})
-      user        = server.user || options[:user] || ssh_options[:username] || ServerDefinition.default_user
-      port        = server.port || options[:port] || ssh_options[:port]
+      # construct the hash of ssh options that should be passed more-or-less
+      # directly to Net::SSH. This will be the general ssh options, merged with
+      # the server-specific ssh-options.
+      ssh_options = (options[:ssh_options] || {}).merge(server.options[:ssh_options] || {})
+
+      # load any SSH configuration files that were specified in the SSH options. This
+      # will load from ~/.ssh/config and /etc/ssh_config by default (see Net::SSH
+      # for details). Merge the explicitly given ssh_options over the top of the info
+      # from the config file.
+      ssh_options = Net::SSH.configuration_for(server.host, ssh_options.fetch(:config, true)).merge(ssh_options)
+
+      # Once we've loaded the config, we don't need Net::SSH to do it again.
+      ssh_options[:config] = false
+
+      user = server.user || options[:user] || ssh_options[:username] ||
+             ssh_options[:user] || ServerDefinition.default_user
+      port = server.port || options[:port] || ssh_options[:port]
+
+      # the .ssh/config file might have changed the host-name on us
+      host = ssh_options.fetch(:host_name, server.host) 
 
       ssh_options[:port] = port if port
+
+      # delete these, since we've determined which username to use by this point
       ssh_options.delete(:username)
+      ssh_options.delete(:user)
 
       begin
         connection_options = ssh_options.merge(
@@ -68,7 +88,7 @@ module Capistrano
           :auth_methods => ssh_options[:auth_methods] || methods.shift
         )
 
-        yield server.host, user, connection_options
+        yield host, user, connection_options
       rescue Net::SSH::AuthenticationFailed
         raise if methods.empty? || ssh_options[:auth_methods]
         password_value = options[:password]

data/lib/capistrano/version.rb

@@ -6,7 +6,7 @@ module Capistrano
   class Version < Net::SSH::Version
     MAJOR = 2
     MINOR = 5
-    TINY  = 3
+    TINY  = 4
 
     # The current version, as a Version instance
     CURRENT = new(MAJOR, MINOR, TINY)

data/test/configuration/actions/invocation_test.rb

@@ -166,6 +166,20 @@ class ConfigurationActionsInvocationTest < Test::Unit::TestCase
     callback[ch, nil, "Sorry, try again."]
   end
 
+  def test_sudo_behavior_callback_should_reset_password_and_prompt_again_if_output_includes_both_cues
+    ch = mock("channel")
+    ch.stubs(:[]).with(:host).returns("capistrano")
+    ch.stubs(:[]).with(:server).returns(server("capistrano"))
+    ch.expects(:send_data, "password!\n").times(2)
+
+    @config.set(:password, "password!")
+    @config.expects(:reset!).with(:password)
+
+    callback = @config.sudo_behavior_callback(nil)
+    callback[ch, :out, "sudo password: "]
+    callback[ch, :out, "Sorry, try again.\nsudo password: "]
+  end
+
   def test_sudo_behavior_callback_should_defer_to_fallback_for_other_output
     callback = @config.sudo_behavior_callback(inspectable_proc)
 

data/test/configuration/connections_test.rb

@@ -30,6 +30,7 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
   def setup
     @config = MockConfig.new
     @config.stubs(:logger).returns(stub_everything)
+    Net::SSH.stubs(:configuration_for).returns({})
     @ssh_options = {
       :user        => "user",
       :port        => 8080,
@@ -60,29 +61,29 @@ class ConfigurationConnectionsTest < Test::Unit::TestCase
 
   def test_should_connect_through_gateway_if_gateway_variable_is_set
     @config.values[:gateway] = "j@gateway"
-    Net::SSH::Gateway.expects(:new).with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+    Net::SSH::Gateway.expects(:new).with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
     assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
   end
 
   def test_connection_factory_as_gateway_should_honor_config_options
     @config.values[:gateway] = "gateway"
     @config.values.update(@ssh_options)
-    Net::SSH::Gateway.expects(:new).with("gateway", "user", :debug => :verbose, :port => 8080, :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+    Net::SSH::Gateway.expects(:new).with("gateway", "user", :debug => :verbose, :port => 8080, :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
     assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
   end
   
   def test_connection_factory_as_gateway_should_chain_gateways_if_gateway_variable_is_an_array
     @config.values[:gateway] = ["j@gateway1", "k@gateway2"]
     gateway1 = mock
-    Net::SSH::Gateway.expects(:new).with("gateway1", "j", :password => nil, :auth_methods => %w(publickey hostbased)).returns(gateway1)
+    Net::SSH::Gateway.expects(:new).with("gateway1", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(gateway1)
     gateway1.expects(:open).returns(65535)
-    Net::SSH::Gateway.expects(:new).with("127.0.0.1", "k", :port => 65535, :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+    Net::SSH::Gateway.expects(:new).with("127.0.0.1", "k", :port => 65535, :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
     assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
   end
   
   def test_connection_factory_as_gateway_should_share_gateway_between_connections
     @config.values[:gateway] = "j@gateway"
-    Net::SSH::Gateway.expects(:new).once.with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased)).returns(stub_everything)
+    Net::SSH::Gateway.expects(:new).once.with("gateway", "j", :password => nil, :auth_methods => %w(publickey hostbased), :config => false).returns(stub_everything)
     Capistrano::SSH.stubs(:connect).returns(stub_everything)
     assert_instance_of Capistrano::Configuration::Connections::GatewayConnectionFactory, @config.connection_factory
     @config.establish_connections_to(server("capistrano"))

data/test/configuration/namespace_dsl_test.rb

@@ -238,6 +238,12 @@ class ConfigurationNamespacesDSLTest < Test::Unit::TestCase
     ns = @config.namespaces[:outer]
     assert ns.respond_to?(:original_initialize_called)
   end
+  
+  def test_namespace_should_accept_respond_to_with_include_priv_parameter
+    @config.namespace(:outer) {}
+    ns = @config.namespaces[:outer]
+    assert ns.respond_to?(:original_initialize_called, true)
+  end
 
   def test_namespace_should_delegate_unknown_messages_to_its_parent
     @config.namespace(:outer) {}

data/test/configuration/variables_test.rb

@@ -53,6 +53,10 @@ class ConfigurationVariablesTest < Test::Unit::TestCase
     @config[:sample] = :value
     assert @config.respond_to?(:sample)
   end
+  
+  def test_respond_to_with_include_priv_paramter
+    assert !@config.respond_to?(:sample, true)
+  end
 
   def test_set_should_require_value
     assert_raises(ArgumentError) do

data/test/ssh_test.rb

@@ -5,8 +5,10 @@ class SSHTest < Test::Unit::TestCase
   def setup
     Capistrano::ServerDefinition.stubs(:default_user).returns("default-user")
     @options = { :password => nil,
-                 :auth_methods => %w(publickey hostbased) }
+                 :auth_methods => %w(publickey hostbased),
+                 :config => false }
     @server = server("capistrano")
+    Net::SSH.stubs(:configuration_for).returns({})
   end
 
   def test_connect_with_bare_server_without_options_or_config_with_public_key_succeeding_should_only_loop_once
@@ -69,8 +71,8 @@ class SSHTest < Test::Unit::TestCase
   end
 
   def test_connect_with_ssh_options_should_use_ssh_options
-    ssh_options = { :username => "JamisMan", :port => 8125 }
-    Net::SSH.expects(:start).with(@server.host, "JamisMan", @options.merge(:port => 8125)).returns(success = Object.new)
+    ssh_options = { :username => "JamisMan", :port => 8125, :config => false }
+    Net::SSH.expects(:start).with(@server.host, "JamisMan", @options.merge(:port => 8125, :config => false)).returns(success = Object.new)
     assert_equal success, Capistrano::SSH.connect(@server, {:ssh_options => ssh_options})
   end
 
@@ -83,7 +85,7 @@ class SSHTest < Test::Unit::TestCase
   def test_connect_with_ssh_options_should_see_server_options_override_ssh_options
     ssh_options = { :username => "JamisMan", :port => 8125, :forward_agent => true }
     server = server("jamis@capistrano:1235")
-    Net::SSH.expects(:start).with(server.host, "jamis", @options.merge(:port => 1235, :forward_agent => true)).returns(success = Object.new)
+    Net::SSH.expects(:start).with(server.host, "jamis", @options.merge(:port => 1235, :forward_agent => true, :config => false)).returns(success = Object.new)
     assert_equal success, Capistrano::SSH.connect(server, {:ssh_options => ssh_options})
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: capistrano
 version: !ruby/object:Gem::Version 
-  version: 2.5.3
+  version: 2.5.4
 platform: ruby
 authors: 
 - Jamis Buck
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-06 00:00:00 -07:00
+date: 2009-02-04 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.0.0
+        version: 2.0.10
     version: 
 - !ruby/object:Gem::Dependency 
   name: net-sftp