HeSYINUvSBZfxqA-capistrano 2.5.21

data/lib/capistrano/ssh.rb

@@ -0,0 +1,101 @@
+begin
+  require 'rubygems'
+  gem 'net-ssh', ">= 2.0.10"
+rescue LoadError, NameError
+end
+
+require 'net/ssh'
+
+module Capistrano
+  # A helper class for dealing with SSH connections.
+  class SSH
+    # Patch an accessor onto an SSH connection so that we can record the server
+    # definition object that defines the connection. This is useful because
+    # the gateway returns connections whose "host" is 127.0.0.1, instead of
+    # the host on the other side of the tunnel.
+    module Server #:nodoc:
+      def self.apply_to(connection, server)
+        connection.extend(Server)
+        connection.xserver = server
+        connection
+      end
+
+      attr_accessor :xserver
+    end
+
+    # 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.
+    #
+    # +server+ must be an instance of ServerDefinition.
+    #
+    # If a block is given, the new session is yielded to it, otherwise the new
+    # session is returned.
+    #
+    # If an :ssh_options key exists in +options+, it is passed to the Net::SSH
+    # 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={})
+      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
+
+      # 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(
+          :password => password_value,
+          :auth_methods => ssh_options[:auth_methods] || methods.shift
+        )
+
+        yield host, user, connection_options
+      rescue Net::SSH::AuthenticationFailed
+        raise if methods.empty? || ssh_options[:auth_methods]
+        password_value = options[:password]
+        retry
+      end
+    end
+  end
+end

data/lib/capistrano/task_definition.rb

@@ -0,0 +1,75 @@
+require 'capistrano/server_definition'
+
+module Capistrano
+  # Represents the definition of a single task.
+  class TaskDefinition
+    attr_reader :name, :namespace, :options, :body, :desc, :on_error, :max_hosts
+    
+    def initialize(name, namespace, options={}, &block)
+      
+      if name.to_s =~ /^(?:before_|after_)/
+        Kernel.warn("[Deprecation Warning] Naming tasks with before_ and after_ is deprecated, please see the new before() and after() methods. (Offending task name was #{name})")
+      end
+      
+      @name, @namespace, @options = name, namespace, options
+      @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
+        if namespace.default_task == self
+          namespace.fully_qualified_name
+        else
+          [namespace.fully_qualified_name, name].compact.join(":")
+        end
+      end
+    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.
+    def description(rebuild=false)
+      @description = nil if rebuild
+      @description ||= begin
+        description = @desc || ""
+        
+        indentation = description[/\A\s+/]
+        if indentation
+          reformatted_description = ""
+          description.strip.each_line do |line|
+            line = line.chomp.sub(/^#{indentation}/, "")
+            line = line.gsub(/#{indentation}\s*/, " ") if line[/^\S/]
+            reformatted_description << line << "\n"
+          end
+          description = reformatted_description
+        end
+
+        description.strip.gsub(/\r\n/, "\n")
+      end
+    end
+
+    # Returns the first sentence of the full description. If +max_length+ is
+    # given, the result will be truncated if it is longer than +max_length+,
+    # and an ellipsis appended.
+    def brief_description(max_length=nil)
+      brief = description[/^.*?\.(?=\s|$)/] || description
+
+      if max_length && brief.length > max_length
+        brief = brief[0,max_length-3] + "..."
+      end
+
+      brief
+    end
+
+    # Indicates whether the task wants to continue, even if a server has failed
+    # previously
+    def continue_on_error?
+      @on_error == :continue
+    end
+  end
+end

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  = 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)
+        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

@@ -0,0 +1,18 @@
+require 'scanf'
+module Capistrano
+
+  class Version
+
+    CURRENT = File.read(File.dirname(__FILE__) + '/../../VERSION')
+
+    MAJOR, MINOR, TINY = CURRENT.scanf('%d.%d.%d')
+
+    STRING = CURRENT.to_s
+
+    def self.to_s
+      CURRENT
+    end
+    
+  end
+
+end

data/rvmrc.sample

@@ -0,0 +1 @@
+rvm use 1.8.7@capistrano-devel --create

data/test/cli/execute_test.rb

@@ -0,0 +1,132 @@
+require "utils"
+require 'capistrano/cli/execute'
+
+class CLIExecuteTest < Test::Unit::TestCase
+  class MockCLI
+    attr_reader :options
+
+    def initialize
+      @options = {}
+    end
+
+    include Capistrano::CLI::Execute
+  end
+
+  def setup
+    @cli = MockCLI.new
+    @logger = stub_everything
+    @config = stub(:logger => @logger, :debug= => nil, :dry_run= => nil, :preserve_roles= => nil)
+    @config.stubs(:set)
+    @config.stubs(:load)
+    @config.stubs(:trigger)
+    @cli.stubs(:instantiate_configuration).returns(@config)
+  end
+
+  def test_execute_should_set_logger_verbosity
+    @cli.options[:verbose] = 7
+    @logger.expects(:level=).with(7)
+    @cli.execute!
+  end
+
+  def test_execute_should_set_password
+    @cli.options[:password] = "nosoup4u"
+    @config.expects(:set).with(:password, "nosoup4u")
+    @cli.execute!
+  end
+
+  def test_execute_should_set_prevars_before_loading
+    @config.expects(:load).never
+    @config.expects(:set).with(:stage, "foobar")
+    @config.expects(:load).with("standard")
+    @cli.options[:pre_vars] = { :stage => "foobar" }
+    @cli.execute!
+  end
+
+  def test_execute_should_load_sysconf_if_sysconf_set_and_exists
+    @cli.options[:sysconf] = "/etc/capistrano.conf"
+    @config.expects(:load).with("/etc/capistrano.conf")
+    File.expects(:file?).with("/etc/capistrano.conf").returns(true)
+    @cli.execute!
+  end
+
+  def test_execute_should_not_load_sysconf_when_sysconf_set_and_not_exists
+    @cli.options[:sysconf] = "/etc/capistrano.conf"
+    File.expects(:file?).with("/etc/capistrano.conf").returns(false)
+    @cli.execute!
+  end
+
+  def test_execute_should_load_dotfile_if_dotfile_set_and_exists
+    @cli.options[:dotfile] = "/home/jamis/.caprc"
+    @config.expects(:load).with("/home/jamis/.caprc")
+    File.expects(:file?).with("/home/jamis/.caprc").returns(true)
+    @cli.execute!
+  end
+
+  def test_execute_should_not_load_dotfile_when_dotfile_set_and_not_exists
+    @cli.options[:dotfile] = "/home/jamis/.caprc"
+    File.expects(:file?).with("/home/jamis/.caprc").returns(false)
+    @cli.execute!
+  end
+
+  def test_execute_should_load_recipes_when_recipes_are_given
+    @cli.options[:recipes] = %w(config/deploy path/to/extra)
+    @config.expects(:load).with("config/deploy")
+    @config.expects(:load).with("path/to/extra")
+    @cli.execute!
+  end
+
+  def test_execute_should_set_vars_and_execute_tasks
+    @cli.options[:vars] = { :foo => "bar", :baz => "bang" }
+    @cli.options[:actions] = %w(first second)
+    @config.expects(:set).with(:foo, "bar")
+    @config.expects(:set).with(:baz, "bang")
+    @config.expects(:find_and_execute_task).with("first", :before => :start, :after => :finish)
+    @config.expects(:find_and_execute_task).with("second", :before => :start, :after => :finish)
+    @cli.execute!
+  end
+
+  def test_execute_should_call_load_and_exit_triggers
+    @cli.options[:actions] = %w(first second)
+    @config.expects(:find_and_execute_task).with("first", :before => :start, :after => :finish)
+    @config.expects(:find_and_execute_task).with("second", :before => :start, :after => :finish)
+    @config.expects(:trigger).never
+    @config.expects(:trigger).with(:load)
+    @config.expects(:trigger).with(:exit)
+    @cli.execute!
+  end
+
+  def test_execute_should_call_handle_error_when_exceptions_occur
+    @config.expects(:load).raises(Exception, "boom")
+    @cli.expects(:handle_error).with { |e,| Exception === e }
+    @cli.execute!
+  end
+
+  def test_execute_should_return_config_instance
+    assert_equal @config, @cli.execute!
+  end
+
+  def test_instantiate_configuration_should_return_new_configuration_instance
+    assert_instance_of Capistrano::Configuration, MockCLI.new.instantiate_configuration
+  end
+
+  def test_handle_error_with_auth_error_should_abort_with_message_including_user_name
+    @cli.expects(:abort).with { |s| s.include?("jamis") }
+    @cli.handle_error(Net::SSH::AuthenticationFailed.new("jamis"))
+  end
+
+  def test_handle_error_with_cap_error_should_abort_with_message
+    @cli.expects(:abort).with("Wish you were here")
+    @cli.handle_error(Capistrano::Error.new("Wish you were here"))
+  end
+
+  def test_handle_error_with_other_errors_should_reraise_error
+    other_error = Class.new(RuntimeError)
+    assert_raises(other_error) { @cli.handle_error(other_error.new("boom")) }
+  end
+
+  def test_class_execute_method_should_call_parse_and_execute_with_ARGV
+    cli = mock(:execute! => nil)
+    MockCLI.expects(:parse).with(ARGV).returns(cli)
+    MockCLI.execute
+  end
+end