capistrano 2.0.0 → 2.15.2

data/lib/capistrano/role.rb

@@ -0,0 +1,102 @@
+module Capistrano
+  class Role
+    include Enumerable
+
+    def initialize(*list)
+      @static_servers = []
+      @dynamic_servers = []
+      push(*list)
+    end
+
+    def each(&block)
+      servers.each &block
+    end
+
+    def push(*list)
+      options = list.last.is_a?(Hash) ? list.pop : {}
+      list.each do |item|
+        if item.respond_to?(:call)
+          @dynamic_servers << DynamicServerList.new(item, options)
+        else
+          @static_servers << self.class.wrap_server(item, options)
+        end
+      end
+    end
+    alias_method :<<, :push
+
+    def servers
+      @static_servers + dynamic_servers
+    end
+    alias_method :to_ary, :servers
+
+    def empty?
+      servers.empty?
+    end
+
+    def clear
+      @dynamic_servers.clear
+      @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.
+    class DynamicServerList
+      def initialize (block, options)
+        @block = block
+        @options = options
+        @cached = []
+        @is_cached = false
+      end
+
+      # Convert to a list of ServerDefinitions
+      def to_ary
+        unless @is_cached
+          @cached = Role::wrap_list(@block.call(@options), @options)
+          @is_cached = true
+        end
+        @cached
+      end
+
+      # Clear the cached value
+      def reset!
+        @cached.clear
+        @is_cached = false
+      end
+    end
+
+    # Attribute reader for the cached results of executing the blocks in turn
+    def dynamic_servers
+      @dynamic_servers.inject([]) { |list, item| list.concat item }
+    end
+
+    # Wraps a string in a ServerDefinition, if it isn't already.
+    # This and wrap_list should probably go in ServerDefinition in some form.
+    def self.wrap_server (item, options)
+      item.is_a?(ServerDefinition) ? item : ServerDefinition.new(item, options)
+    end
+
+    # Turns a list, or something resembling a list, into a properly-formatted
+    # ServerDefinition list. Keep an eye on this one -- it's entirely too
+    # magical for its own good. In particular, if ServerDefinition ever inherits
+    # from Array, this will break.
+    def self.wrap_list (*list)
+      options = list.last.is_a?(Hash) ? list.pop : {}
+      if list.length == 1
+        if list.first.nil?
+          return []
+        elsif list.first.is_a?(Array)
+          list = list.first
+        end
+      end
+      options.merge! list.pop if list.last.is_a?(Hash)
+      list.map do |item|
+        self.wrap_server item, options
+      end
+    end
+  end
+end

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]
 
@@ -48,4 +53,4 @@ module Capistrano
       end
     end
   end
-end
+end

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:
@@ -61,6 +64,9 @@ INTRO
           return false
         when /^set -(\w)\s*(\S+)/
           set_option($1, $2)
+        when /^set :(.*)\s+(.*)/
+          configuration.set($1.to_sym, $2)
+          puts "updated :#{$1} to #{$2}"
         when /^(?:(with|on)\s*(\S+))?\s*(\S.*)?/i
           process_command($1, $2, $3)
         else
@@ -142,11 +148,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
@@ -166,24 +174,13 @@ HELP
 
       # 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 "#{configuration[:password]}\n"
-              else
-                puts "[#{ch[:server]}] #{line.chomp}"
-              end
-            elsif stream == :err
-              puts "[#{ch[:server]} ERR] #{line.chomp}"
-            end
-          end
-        end
-
-        previous = trap("INT") { cmd.stop! }
+        command = command.gsub(/^(\s*)sudo\b|([|;&])\s*sudo\b/, "\\0 -p '#{configuration.sudo_prompt}'")
+        processor = configuration.sudo_behavior_callback(Configuration.default_io_proc)
         sessions = servers.map { |server| configuration.sessions[server] }
-        Command.process(command, sessions, :logger => configuration.logger, &Capistrano::Configuration.default_io_proc)
+        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
         warn "error: #{error.message}"
       ensure
@@ -205,20 +202,15 @@ HELP
       # thread and generally gets things ready for the REPL.
       def setup
         configuration.logger.level = Capistrano::Logger::INFO
+        wait_for = 0.1
 
         @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
+            ret = @mutex.synchronize { process_iteration(wait_for) }
+            sleep wait_for if !ret
           end
+        end
       end
 
       # Set the given option to +value+.
@@ -256,7 +248,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
@@ -264,5 +256,10 @@ HELP
           puts "scoping #{scope_type} #{scope_value}"
         end
       end
+
+      # All open sessions, needed to satisfy the Command::Processable include
+      def sessions
+        configuration.sessions.values
+      end
     end
 end

data/lib/capistrano/ssh.rb

@@ -1,55 +1,6 @@
 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
@@ -66,9 +17,6 @@ module Capistrano
       attr_accessor :xserver
     end
 
-    # The default port for SSH.
-    DEFAULT_PORT = 22
-
     # An abstraction to make it possible to connect to the server via public key
     # without prompting for the password. If the public key authentication fails
     # this will fall back to password authentication.
@@ -82,13 +30,53 @@ 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
+
+      # 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
+
+      ssh_options[:verbose] = :debug if options[:verbose] && options[:verbose] > 0
+
+      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(
@@ -96,9 +84,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 host, user, connection_options
       rescue Net::SSH::AuthenticationFailed
         raise if methods.empty? || ssh_options[:auth_methods]
         password_value = options[:password]

data/lib/capistrano/task_definition.rb

@@ -1,18 +1,20 @@
 require 'capistrano/server_definition'
 
 module Capistrano
-  # Represents the definition of a single task.
+
   class TaskDefinition
-    attr_reader :name, :namespace, :options, :body, :desc, :on_error
+
+    attr_reader :name, :namespace, :options, :body, :desc, :on_error, :max_hosts
 
     def initialize(name, namespace, options={}, &block)
       @name, @namespace, @options = name, namespace, options
-      @desc = @options.delete(:desc)
-      @on_error = options.delete(:on_error)
-      @body = block or raise ArgumentError, "a task requires a block"
-      @servers = nil
+      @desc      = @options.delete(:desc)
+      @on_error  = options.delete(:on_error)
+      @max_hosts = options[:max_hosts] && options[:max_hosts].to_i
+      @body      = block or raise ArgumentError, "a task requires a block"
+      @servers   = nil
     end
-    
+
     # Returns the task's fully-qualified name, including the namespace
     def fully_qualified_name
       @fully_qualified_name ||= begin
@@ -24,6 +26,11 @@ module Capistrano
       end
     end
 
+    def name=(value)
+      raise ArgumentError, "expected a valid task name" if !value.respond_to?(:to_sym)
+      @name = value.to_sym
+    end
+
     # Returns the description for this task, with newlines collapsed and
     # whitespace stripped. Returns the empty string if there is no
     # description for this task.
@@ -65,5 +72,6 @@ module Capistrano
     def continue_on_error?
       @on_error == :continue
     end
+
   end
-end
+end

data/lib/capistrano/transfer.rb

@@ -0,0 +1,218 @@
+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  = block
+
+      @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)
+        raise error if error.message.include?('expected a file to upload')
+
+        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

@@ -1,22 +1,11 @@
 module Capistrano
-  module Version #:nodoc:
-    # A method for comparing versions of required modules. It expects two
-    # arrays of integers as parameters, the first being the minimum version
-    # required, and the second being the actual version available. It returns
-    # true if the actual version is at least equal to the required version.
-    def self.check(required, actual) #:nodoc:
-      required = required.map { |v| "%06d" % v }.join(".")
-      actual   = actual.map { |v| "%06d" % v }.join(".")
-      return actual >= required
-    end
-
+  class Version
     MAJOR = 2
-    MINOR = 0
-    TINY  = 0
+    MINOR = 15
+    PATCH = 2
 
-    STRING = [MAJOR, MINOR, TINY].join(".")
-    
-    SSH_REQUIRED = [1,0,10]
-    SFTP_REQUIRED = [1,1,0]
+    def self.to_s
+      "#{MAJOR}.#{MINOR}.#{PATCH}"
+    end
   end
 end

data/lib/capistrano.rb

@@ -1,2 +1,5 @@
+require 'capistrano/fix_rake_deprecated_dsl'
+
 require 'capistrano/configuration'
-require 'capistrano/extensions'
+require 'capistrano/extensions'
+require 'capistrano/ext/string'