capistrano 2.2.0 → 2.3.0

data/lib/capistrano/recipes/deploy.rb

@@ -89,6 +89,15 @@ ensure
   ENV[name] = saved
 end
 
+# If :run_method is :sudo (or :use_sudo is true), this executes the given command
+# via +sudo+. Otherwise is uses +run+. Further, if sudo is being used and :runner
+# is set, the command will be executed as the user given by :runner.
+def try_sudo(command)
+  as = fetch(:runner, "app")
+  via = fetch(:run_method, :sudo)
+  invoke_command(command, :via => via, :as => as)
+end
+
 # =========================================================================
 # These are the tasks that are available to help with deploying web apps,
 # and specifically, Rails applications. You can have cap give you a summary
@@ -122,7 +131,7 @@ namespace :deploy do
   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) }
-    run "umask 02 && mkdir -p #{dirs.join(' ')}"
+    try_sudo "umask 02 && mkdir -p #{dirs.join(' ')}"
   end
 
   desc <<-DESC
@@ -246,9 +255,7 @@ namespace :deploy do
       set :use_sudo, false
   DESC
   task :restart, :roles => :app, :except => { :no_release => true } do
-    as = fetch(:runner, "app")
-    via = fetch(:run_method, :sudo)
-    invoke_command "#{current_path}/script/process/reaper", :via => via, :as => as
+    try_sudo "#{current_path}/script/process/reaper"
   end
 
   desc <<-DESC
@@ -337,7 +344,7 @@ namespace :deploy do
       directories = (releases - releases.last(count)).map { |release|
         File.join(releases_path, release) }.join(" ")
 
-      invoke_command "rm -rf #{directories}", :via => run_method
+      try_sudo "rm -rf #{directories}"
     end
   end
 
@@ -406,9 +413,7 @@ namespace :deploy do
     the :use_sudo variable to false.
   DESC
   task :start, :roles => :app do
-    as = fetch(:runner, "app")
-    via = fetch(:run_method, :sudo)
-    invoke_command "sh -c 'cd #{current_path} && nohup script/spin'", :via => via, :as => as
+    try_sudo "sh -c 'cd #{current_path} && nohup script/spin'"
   end
 
   desc <<-DESC
@@ -423,11 +428,8 @@ namespace :deploy do
     the :use_sudo variable to false.
   DESC
   task :stop, :roles => :app do
-    as = fetch(:runner, "app")
-    via = fetch(:run_method, :sudo)
-
-    invoke_command "if [ -f #{current_path}/tmp/pids/dispatch.spawner.pid ]; then #{current_path}/script/process/reaper -a kill -r dispatch.spawner.pid; fi", :via => via, :as => as
-    invoke_command "#{current_path}/script/process/reaper -a kill", :via => via, :as => as
+    try_sudo "if [ -f #{current_path}/tmp/pids/dispatch.spawner.pid ]; then #{current_path}/script/process/reaper -a kill -r dispatch.spawner.pid; fi"
+    try_sudo "#{current_path}/script/process/reaper -a kill"
   end
 
   namespace :pending do

data/lib/capistrano/role.rb

@@ -1,4 +1,3 @@
-
 module Capistrano
   class Role
     include Enumerable
@@ -34,27 +33,14 @@ module Capistrano
       servers.empty?
     end
 
-    # Resets the cache, so that proc values may be recalculated.
-    # There should be a command in Configuration::Roles to do this,
-    # but I haven't needed it yet, and I'm not sure yet
-    # what to call that command. Suggestions?
-    def reset!
-      @dynamic_servers.each { |item| item.reset! }
-    end
-
-    # Clears everything. I still thing this should be 'clear!', but that's not
-    # the way Array does it.
     def clear
       @dynamic_servers.clear
       @static_servers.clear
     end
 
-    # Mostly for documentation purposes. Doesn't seem to do anything.
     protected
 
     # This is the combination of a block, a hash of options, and a cached value.
-    # It is protected because it is an implementation detail -- the original
-    # implementation was two lists (blocks and cached results of calling them).
     class DynamicServerList
       def initialize (block, options)
         @block = block

data/lib/capistrano/server_definition.rb

@@ -7,6 +7,11 @@ module Capistrano
     attr_reader :port
     attr_reader :options
 
+    # The default user name to use when a user name is not explicitly provided
+    def self.default_user
+      ENV['USER'] || ENV['USERNAME'] || "not-specified"
+    end
+
     def initialize(string, options={})
       @user, @host, @port = string.match(/^(?:([^;,:=]+)@|)(.*?)(?::(\d+)|)$/)[1,3]
 

data/lib/capistrano/shell.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'capistrano/processable'
 
 module Capistrano
   # The Capistrano::Shell class is the guts of the "shell" task. It implements
@@ -6,6 +7,8 @@ module Capistrano
   # commands. It makes for a GREAT way to monitor systems, and perform quick
   # maintenance on one or more machines.
   class Shell
+    include Processable
+
     # A Readline replacement for platforms where readline is either
     # unavailable, or has not been installed.
     class ReadlineFallback #:nodoc:
@@ -142,11 +145,13 @@ HELP
       # 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(configuration.current_task)
-          exec_command(command, servers)
+        @mutex.synchronize do
+          if command[0] == ?!
+            exec_tasks(command[1..-1].split)
+          else
+            servers = connect(configuration.current_task)
+            exec_command(command, servers)
+          end
         end
       ensure
         STDOUT.flush
@@ -169,7 +174,8 @@ HELP
         command = command.gsub(/\bsudo\b/, "sudo -p '#{configuration.sudo_prompt}'")
         processor = configuration.sudo_behavior_callback(Configuration.default_io_proc)
         sessions = servers.map { |server| configuration.sessions[server] }
-        cmd = Command.new(command, sessions, :logger => configuration.logger, &processor)
+        options = configuration.add_default_command_options({})
+        cmd = Command.new(command, sessions, options.merge(:logger => configuration.logger), &processor)
         previous = trap("INT") { cmd.stop! }
         cmd.process!
       rescue Capistrano::Error => error
@@ -196,17 +202,10 @@ HELP
 
         @mutex = Mutex.new
         @bgthread = Thread.new do
-            loop do
-              ready = configuration.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
+          loop do
+            @mutex.synchronize { process_iteration(0.1) }
           end
+        end
       end
 
       # Set the given option to +value+.
@@ -244,7 +243,7 @@ HELP
         old_var, ENV[env_var] = ENV[env_var], (scope_value == "all" ? nil : scope_value) if env_var
         if command
           begin
-            @mutex.synchronize { exec(command) }
+            exec(command)
           ensure
             ENV[env_var] = old_var if env_var
           end
@@ -253,4 +252,9 @@ HELP
         end
       end
     end
+
+    # All open sessions, needed to satisfy the Command::Processable include
+    def sessions
+      configuration.sessions.values
+    end
 end

data/lib/capistrano/ssh.rb

@@ -1,61 +1,12 @@
 begin
   require 'rubygems'
-  gem 'net-ssh', "< 1.99.0"
+  gem 'net-ssh', ">= 1.99.1"
 rescue LoadError, NameError
 end
 
 require 'net/ssh'
 
 module Capistrano
-  unless ENV['SKIP_VERSION_CHECK']
-    require 'capistrano/version'
-    require 'net/ssh/version'
-    ssh_version = [Net::SSH::Version::MAJOR, Net::SSH::Version::MINOR, Net::SSH::Version::TINY]
-    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
-
-  # Now, Net::SSH is kind of silly, and tries to lazy-load everything. This
-  # wreaks havoc with the parallel connection trick that Capistrano wants to
-  # use, so we're going to do something hideously ugly here and force all the
-  # files that Net::SSH uses to load RIGHT NOW, rather than lazily.
-
-  net_ssh_dependencies = %w(connection/services connection/channel connection/driver
-    service/agentforward/services service/agentforward/driver
-    service/process/driver util/prompter
-    service/forward/services service/forward/driver service/forward/local-network-handler service/forward/remote-network-handler
-    service/shell/services service/shell/driver
-    lenient-host-key-verifier
-    transport/compress/services transport/compress/zlib-compressor transport/compress/none-compressor transport/compress/zlib-decompressor transport/compress/none-decompressor
-    transport/kex/services transport/kex/dh transport/kex/dh-gex
-    transport/ossl/services
-    transport/ossl/hmac/services transport/ossl/hmac/sha1 transport/ossl/hmac/sha1-96 transport/ossl/hmac/md5 transport/ossl/hmac/md5-96 transport/ossl/hmac/none
-    transport/ossl/cipher-factory transport/ossl/hmac-factory transport/ossl/buffer-factory transport/ossl/key-factory transport/ossl/digest-factory
-    transport/identity-cipher transport/packet-stream transport/version-negotiator transport/algorithm-negotiator transport/session
-    userauth/methods/services userauth/methods/password userauth/methods/keyboard-interactive userauth/methods/publickey userauth/methods/hostbased
-    userauth/services userauth/agent userauth/userkeys userauth/driver
-    transport/services service/services
-  )
-
-  net_ssh_dependencies << "userauth/pageant" if File::ALT_SEPARATOR
-  net_ssh_dependencies.each do |path|
-    begin
-      require "net/ssh/#{path}"
-    rescue LoadError
-      # Ignore load errors from this, since some files are in the list which
-      # do not exist in different (supported) versions of Net::SSH. We know
-      # (by this point) that Net::SSH is installed, though, since we do a
-      # require 'net/ssh' at the very top of this file, and we know the
-      # installed version meets the minimum version requirements because of
-      # the version check, also at the top of this file. So, if we get a
-      # LoadError, it's simply because the file in question does not exist in
-      # the version of Net::SSH that is installed.
-      #
-      # Whew!
-    end
-  end
-
   # A helper class for dealing with SSH connections.
   class SSH
     # Patch an accessor onto an SSH connection so that we can record the server
@@ -88,13 +39,30 @@ module Capistrano
     # constructor. Values in +options+ are then merged into it, and any
     # connection information in +server+ is added last, so that +server+ info
     # takes precedence over +options+, which takes precendence over ssh_options.
-    def self.connect(server, options={}, &block)
+    def self.connect(server, options={})
+      connection_strategy(server, options) do |host, user, connection_options|
+        connection = Net::SSH.start(host, user, connection_options)
+        Server.apply_to(connection, server)
+      end
+    end
+
+    # Abstracts the logic for establishing an SSH connection (which includes
+    # testing for connection failures and retrying with a password, and so forth,
+    # mostly made complicated because of the fact that some of these variables
+    # might be lazily evaluated and try to do something like prompt the user,
+    # which should only happen when absolutely necessary.
+    #
+    # This will yield the hostname, username, and a hash of connection options
+    # to the given block, which should return a new connection.
+    def self.connection_strategy(server, options={}, &block)
       methods = [ %w(publickey hostbased), %w(password keyboard-interactive) ]
       password_value = nil
-      
-      ssh_options = (options[:ssh_options] || {}).dup
-      ssh_options[:username] = server.user || options[:user] || ssh_options[:username]
-      ssh_options[:port]     = server.port || options[:port] || ssh_options[:port] || DEFAULT_PORT
+
+      ssh_options        = (server.options[:ssh_options] || {}).merge(options[:ssh_options] || {})
+      user               = server.user || options[:user] || ssh_options[:username] || ServerDefinition.default_user
+      ssh_options[:port] = server.port || options[:port] || ssh_options[:port] || DEFAULT_PORT
+
+      ssh_options.delete(:username)
 
       begin
         connection_options = ssh_options.merge(
@@ -102,9 +70,7 @@ module Capistrano
           :auth_methods => ssh_options[:auth_methods] || methods.shift
         )
 
-        connection = Net::SSH.start(server.host, connection_options, &block)
-        Server.apply_to(connection, server)
-
+        yield server.host, user, connection_options
       rescue Net::SSH::AuthenticationFailed
         raise if methods.empty? || ssh_options[:auth_methods]
         password_value = options[:password]

data/lib/capistrano/transfer.rb

@@ -0,0 +1,216 @@
+require 'net/scp'
+require 'net/sftp'
+
+require 'capistrano/processable'
+
+module Capistrano
+  class Transfer
+    include Processable
+
+    def self.process(direction, from, to, sessions, options={}, &block)
+      new(direction, from, to, sessions, options, &block).process!
+    end
+
+    attr_reader :sessions
+    attr_reader :options
+    attr_reader :callback
+
+    attr_reader :transport
+    attr_reader :direction
+    attr_reader :from
+    attr_reader :to
+
+    attr_reader :logger
+    attr_reader :transfers
+
+    def initialize(direction, from, to, sessions, options={}, &block)
+      @direction = direction
+      @from      = from
+      @to        = to
+      @sessions  = sessions
+      @options   = options
+      @callback  = callback
+
+      @transport = options.fetch(:via, :sftp)
+      @logger    = options.delete(:logger)
+
+      @session_map = {}
+
+      prepare_transfers
+    end
+
+    def process!
+      loop do
+        begin
+          break unless process_iteration { active? }
+        rescue Exception => error
+          if error.respond_to?(:session)
+            handle_error(error)
+          else
+            raise
+          end
+        end
+      end
+
+      failed = transfers.select { |txfr| txfr[:failed] }
+      if failed.any?
+        hosts = failed.map { |txfr| txfr[:server] }
+        errors = failed.map { |txfr| "#{txfr[:error]} (#{txfr[:error].message})" }.uniq.join(", ")
+        error = TransferError.new("#{operation} via #{transport} failed on #{hosts.join(',')}: #{errors}")
+        error.hosts = hosts
+
+        logger.important(error.message) if logger
+        raise error
+      end
+
+      logger.debug "#{transport} #{operation} complete" if logger
+      self
+    end
+
+    def active?
+      transfers.any? { |transfer| transfer.active? }
+    end
+
+    def operation
+      "#{direction}load"
+    end
+
+    def sanitized_from
+      if from.responds_to?(:read)
+        "#<#{from.class}>"
+      else
+        from
+      end
+    end
+
+    def sanitized_to
+      if to.responds_to?(:read)
+        "#<#{to.class}>"
+      else
+        to
+      end
+    end
+
+    private
+
+      def session_map
+        @session_map
+      end
+
+      def prepare_transfers
+        logger.info "#{transport} #{operation} #{from} -> #{to}" if logger
+
+        @transfers = sessions.map do |session|
+          session_from = normalize(from, session)
+          session_to   = normalize(to, session)
+
+          session_map[session] = case transport
+            when :sftp
+              prepare_sftp_transfer(session_from, session_to, session)
+            when :scp
+              prepare_scp_transfer(session_from, session_to, session)
+            else
+              raise ArgumentError, "unsupported transport type: #{transport.inspect}"
+            end
+        end
+      end
+
+      def prepare_scp_transfer(from, to, session)
+        real_callback = callback || Proc.new do |channel, name, sent, total|
+          logger.trace "[#{channel[:host]}] #{name}" if logger && sent == 0
+        end
+
+        channel = case direction
+          when :up
+            session.scp.upload(from, to, options, &real_callback)
+          when :down
+            session.scp.download(from, to, options, &real_callback)
+          else
+            raise ArgumentError, "unsupported transfer direction: #{direction.inspect}"
+          end
+
+        channel[:server] = session.xserver
+        channel[:host]   = session.xserver.host
+
+        return channel
+      end
+
+      class SFTPTransferWrapper
+        attr_reader :operation
+
+        def initialize(session, &callback)
+          session.sftp(false).connect do |sftp|
+            @operation = callback.call(sftp)
+          end
+        end
+
+        def active?
+          @operation.nil? || @operation.active?
+        end
+
+        def [](key)
+          @operation[key]
+        end
+
+        def []=(key, value)
+          @operation[key] = value
+        end
+
+        def abort!
+          @operation.abort!
+        end
+      end
+
+      def prepare_sftp_transfer(from, to, session)
+        SFTPTransferWrapper.new(session) do |sftp|
+          real_callback = Proc.new do |event, op, *args|
+            if callback
+              callback.call(event, op, *args)
+            elsif event == :open
+              logger.trace "[#{op[:host]}] #{args[0].remote}"
+            elsif event == :finish
+              logger.trace "[#{op[:host]}] done"
+            end
+          end
+
+          opts = options.dup
+          opts[:properties] = (opts[:properties] || {}).merge(
+            :server  => session.xserver,
+            :host    => session.xserver.host)
+
+          case direction
+          when :up
+            sftp.upload(from, to, opts, &real_callback)
+          when :down
+            sftp.download(from, to, opts, &real_callback)
+          else
+            raise ArgumentError, "unsupported transfer direction: #{direction.inspect}"
+          end
+        end
+      end
+
+      def normalize(argument, session)
+        if argument.is_a?(String)
+          argument.gsub(/\$CAPISTRANO:HOST\$/, session.xserver.host)
+        elsif argument.respond_to?(:read)
+          pos = argument.pos
+          clone = StringIO.new(argument.read)
+          clone.pos = argument.pos = pos
+          clone
+        else
+          argument
+        end
+      end
+
+      def handle_error(error)
+        transfer = session_map[error.session]
+        transfer[:error] = error
+        transfer[:failed] = true
+
+        case transport
+        when :sftp then transfer.abort!
+        when :scp  then transfer.close
+        end
+      end
+  end
+end

data/lib/capistrano/version.rb

@@ -11,7 +11,7 @@ module Capistrano
     end
 
     MAJOR = 2
-    MINOR = 2
+    MINOR = 3
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join(".")

data/test/cli/execute_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/cli/execute'
 
 class CLIExecuteTest < Test::Unit::TestCase

data/test/cli/help_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/cli/help'
 
 class CLIHelpTest < Test::Unit::TestCase

data/test/cli/options_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/cli/options'
 
 class CLIOptionsTest < Test::Unit::TestCase

data/test/cli/ui_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/../utils"
+require "utils"
 require 'capistrano/cli/ui'
 
 class CLIUITest < Test::Unit::TestCase

data/test/cli_test.rb

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/utils"
+require "utils"
 require 'capistrano/cli'
 
 class CLI_Test < Test::Unit::TestCase