capistrano 2.15.11 → 3.0.0.pre

data/lib/capistrano/transfer.rb

@@ -1,218 +0,0 @@
-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/test/cli/execute_test.rb

@@ -1,132 +0,0 @@
-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

data/test/cli/help_test.rb

@@ -1,165 +0,0 @@
-require "utils"
-require 'capistrano/cli/help'
-
-class CLIHelpTest < Test::Unit::TestCase
-  class MockCLI
-    attr_reader :options, :called_original
-
-    def initialize
-      @options = {}
-      @called_original = false
-    end
-
-    def execute_requested_actions(config)
-      @called_original = config
-    end
-
-    include Capistrano::CLI::Help
-  end
-
-  def setup
-    @cli = MockCLI.new
-    @cli.options[:verbose] = 0
-    @ui = stub("ui", :output_cols => 80, :output_rows => 20, :page_at= => nil)
-    MockCLI.stubs(:ui).returns(@ui)
-  end
-
-  def test_execute_requested_actions_without_tasks_or_explain_should_call_original
-    @cli.execute_requested_actions(:config)
-    @cli.expects(:task_list).never
-    @cli.expects(:explain_task).never
-    assert_equal :config, @cli.called_original
-  end
-
-  def test_execute_requested_actions_with_tasks_should_call_task_list
-    @cli.options[:tasks] = true
-    @cli.expects(:task_list).with(:config, true)
-    @cli.expects(:explain_task).never
-    @cli.execute_requested_actions(:config)
-    assert !@cli.called_original
-  end
-
-  def test_execute_requested_actions_with_explain_should_call_explain_task
-    @cli.options[:explain] = "deploy_with_niftiness"
-    @cli.expects(:task_list).never
-    @cli.expects(:explain_task).with(:config, "deploy_with_niftiness")
-    @cli.execute_requested_actions(:config)
-    assert !@cli.called_original
-  end
-
-  def test_task_list_with_no_tasks_should_emit_warning
-    config = mock("config", :task_list => [])
-    @cli.expects(:warn)
-    @cli.task_list(config)
-  end
-
-  def test_task_list_should_query_all_tasks_in_all_namespaces
-    expected_max_len = 80 - 3 - MockCLI::LINE_PADDING
-    task_list = [task("c"), task("g", "c:g"), task("b", "c:b"), task("a")]
-    task_list.each { |t| t.expects(:brief_description).with(expected_max_len).returns(t.fully_qualified_name) }
-
-    config = mock("config")
-    config.expects(:task_list).with(:all).returns(task_list)
-    @cli.stubs(:puts)
-    @cli.task_list(config)
-  end
-
-  def test_task_list_should_query_tasks_with_pattern
-    expected_max_len = 80 - 3 - MockCLI::LINE_PADDING
-    task_list = [task("g", "c:g"), task("b", "c:b")]
-    task_list.each { |t| t.expects(:brief_description).with(expected_max_len).returns(t.fully_qualified_name)}
-
-    config = mock("config")
-    config.expects(:task_list).with(:all).once.returns(task_list)
-
-    @cli.stubs(:puts)
-    @cli.task_list(config, "c")
-  end
-
-  def test_task_list_should_query_for_all_tasks_when_pattern_doesnt_match
-    expected_max_len = 80 - 3 - MockCLI::LINE_PADDING
-    task_list = [task("g", "c:g"), task("b", "c:b")]
-    task_list.each { |t| t.expects(:brief_description).with(expected_max_len).returns(t.fully_qualified_name) }
-
-    config = mock("config")
-    config.expects(:task_list).with(:all).times(2).returns(task_list)
-
-    @cli.stubs(:warn)
-    @cli.stubs(:puts)
-    @cli.task_list(config, "z")
-  end
-
-  def test_task_list_should_never_use_less_than_MIN_MAX_LEN_chars_for_descriptions
-    @ui.stubs(:output_cols).returns(20)
-    t = task("c")
-    t.expects(:brief_description).with(30).returns("hello")
-    config = mock("config", :task_list => [t])
-    @cli.stubs(:puts)
-    @cli.task_list(config)
-  end
-
-  def test_task_list_should_not_include_tasks_with_blank_description_or_internal_by_default
-    t1 = task("c")
-    t1.expects(:brief_description).returns("hello")
-    t2 = task("d", "d", "[internal] howdy")
-    t2.expects(:brief_description).never
-    t3 = task("e", "e", "")
-    t3.expects(:brief_description).never
-
-    config = mock("config", :task_list => [t1, t2, t3])
-    @cli.stubs(:puts)
-    @cli.expects(:puts).never.with { |s,| (s || "").include?("[internal]") || s =~ /#\s*$/ }
-    @cli.task_list(config)
-  end
-
-  def test_task_list_should_include_tasks_with_blank_descriptions_and_internal_when_verbose
-    t1 = task("c")
-    t1.expects(:brief_description).returns("hello")
-    t2 = task("d", "d", "[internal] howdy")
-    t2.expects(:brief_description).returns("[internal] howdy")
-    t3 = task("e", "e", "")
-    t3.expects(:brief_description).returns("")
-
-    config = mock("config", :task_list => [t1, t2, t3])
-    @cli.options[:verbose] = 1
-    @cli.stubs(:puts)
-    @cli.expects(:puts).with { |s,| (s || "").include?("[internal]") || s =~ /#\s*$/ }.at_least_once
-    @cli.task_list(config)
-  end
-
-  def test_explain_task_should_warn_if_task_does_not_exist
-    config = mock("config", :find_task => nil)
-    @cli.expects(:warn).with { |s,| s =~ /`deploy_with_niftiness'/ }
-    @cli.explain_task(config, "deploy_with_niftiness")
-  end
-
-  def test_explain_task_with_task_that_has_no_description_should_emit_stub
-    t = mock("task", :description => "")
-    config = mock("config")
-    config.expects(:find_task).with("deploy_with_niftiness").returns(t)
-    @cli.stubs(:puts)
-    @cli.expects(:puts).with("There is no description for this task.")
-    @cli.explain_task(config, "deploy_with_niftiness")
-  end
-
-  def test_explain_task_with_task_should_format_description
-    t = stub("task", :description => "line1\nline2\n\nline3")
-    config = mock("config", :find_task => t)
-    @cli.stubs(:puts)
-    @cli.explain_task(config, "deploy_with_niftiness")
-  end
-
-  def test_long_help_should_load_and_format_help_txt_file
-    File.expects(:dirname).returns "a/b/c"
-    File.expects(:read).with("a/b/c/help.txt").returns("text")
-    @ui.expects(:say).with("text\n")
-    @cli.long_help
-  end
-
-  private
-
-  def task(name, fqn=name, desc="a description")
-    stub("task", :name => name, :fully_qualified_name => fqn, :description => desc)
-  end
-
-end