capistrano 2.2.0 → 2.3.0

data/lib/capistrano/upload.rb

@@ -1,152 +0,0 @@
-begin
-  require 'rubygems'
-  gem 'net-sftp', "< 1.99.0"
-rescue LoadError, NameError
-end
-
-require 'net/sftp'
-require 'net/sftp/operations/errors'
-require 'capistrano/errors'
-
-module Capistrano
-  unless ENV['SKIP_VERSION_CHECK']
-    require 'capistrano/version' 
-    require 'net/sftp/version'
-    sftp_version = [Net::SFTP::Version::MAJOR, Net::SFTP::Version::MINOR, Net::SFTP::Version::TINY]
-    required_version = [1,1,0]
-    if !Capistrano::Version.check(required_version, sftp_version)
-      raise "You have Net::SFTP #{sftp_version.join(".")}, but you need at least #{required_version.join(".")}. Net::SFTP will not be used."
-    end
-  end
-
-  # This class encapsulates a single file upload to be performed in parallel
-  # across multiple machines, using the SFTP protocol. Although it is intended
-  # to be used primarily from within Capistrano, it may also be used standalone
-  # if you need to simply upload a file to multiple servers.
-  #
-  # Basic Usage:
-  #
-  #   begin
-  #     uploader = Capistrano::Upload.new(sessions, "remote-file.txt",
-  #         :data => "the contents of the file to upload")
-  #     uploader.process!
-  #   rescue Capistrano::UploadError => e
-  #     warn "Could not upload the file: #{e.message}"
-  #   end
-  class Upload
-    def self.process(sessions, filename, options)
-      new(sessions, filename, options).process!
-    end
-  
-    attr_reader :sessions, :filename, :options
-    attr_reader :failed, :completed
-
-    # Creates and prepares a new Upload instance. The +sessions+ parameter
-    # must be an array of open Net::SSH sessions. The +filename+ is the name
-    # (including path) of the destination file on the remote server. The
-    # +options+ hash accepts the following keys (as symbols):
-    #
-    # * data: required. Should refer to a String containing the contents of
-    #   the file to upload.
-    # * mode: optional. The "mode" of the destination file. Defaults to 0664.
-    # * logger: optional. Should point to a Capistrano::Logger instance, if
-    #   given.
-    def initialize(sessions, filename, options)
-      raise ArgumentError, "you must specify the data to upload via the :data option" unless options[:data]
-
-      @sessions = sessions
-      @filename = filename
-      @options  = options
-
-      @completed = @failed = 0
-      @sftps = setup_sftp
-    end
-    
-    # Uploads to all specified servers in parallel. If any one of the servers
-    # fails, an exception will be raised (UploadError).
-    def process!
-      logger.debug "uploading #{filename}" if logger
-      while running?
-        @sftps.each do |sftp|
-          next if sftp.channel[:done]
-          begin
-            sftp.channel.connection.process(true)
-          rescue Net::SFTP::Operations::StatusException => error
-            logger.important "uploading failed: #{error.description}", sftp.channel[:server] if logger
-            failed!(sftp)
-          end
-        end
-        sleep 0.01 # a brief respite, to keep the CPU from going crazy
-      end
-      logger.trace "upload finished" if logger
-
-      if (failed = @sftps.select { |sftp| sftp.channel[:failed] }).any?
-        hosts = failed.map { |sftp| sftp.channel[:server] }
-        error = UploadError.new("upload of #{filename} failed on #{hosts.join(',')}")
-        error.hosts = hosts
-        raise error
-      end
-
-      self
-    end
-
-    private
-
-      def logger
-        options[:logger]
-      end
-
-      def setup_sftp
-        sessions.map do |session|
-          server = session.xserver
-          sftp = session.sftp
-          sftp.connect unless sftp.state == :open
-
-          sftp.channel[:server] = server
-          sftp.channel[:done] = false
-          sftp.channel[:failed] = false
-
-          real_filename = filename.gsub(/\$CAPISTRANO:HOST\$/, server.host)
-          sftp.open(real_filename, IO::WRONLY | IO::CREAT | IO::TRUNC, options[:mode] || 0664) do |status, handle|
-            break unless check_status(sftp, "open #{real_filename}", server, status)
-            
-            logger.info "uploading data to #{server}:#{real_filename}" if logger
-            sftp.write(handle, options[:data] || "") do |status|
-              break unless check_status(sftp, "write to #{server}:#{real_filename}", server, status)
-              sftp.close_handle(handle) do
-                logger.debug "done uploading data to #{server}:#{real_filename}" if logger
-                completed!(sftp)
-              end
-            end
-          end
-          
-          sftp
-        end
-      end
-      
-      def check_status(sftp, action, server, status)
-        return true if status.code == Net::SFTP::Session::FX_OK
-
-        logger.error "could not #{action} on #{server} (#{status.message})" if logger
-        failed!(sftp)
-
-        return false
-      end
-
-      def running?
-        completed < @sftps.length
-      end
-
-      def failed!(sftp)
-        completed!(sftp)
-        @failed += 1
-        sftp.channel[:failed] = true
-      end
-
-      def completed!(sftp)
-        @completed += 1
-        sftp.channel[:done] = true
-      end
-  end
-
-end

data/test/gateway_test.rb

@@ -1,167 +0,0 @@
-require "#{File.dirname(__FILE__)}/utils"
-require 'capistrano/gateway'
-
-class GatewayTest < Test::Unit::TestCase
-  def teardown
-    Thread.list { |t| t.kill unless Thread.current == t }
-  end
-
-  def test_initialize_should_open_and_set_session_value
-    run_test_initialize_should_open_and_set_session_value
-  end
-
-  def test_initialize_when_connect_lags_should_open_and_set_session_value
-    run_test_initialize_should_open_and_set_session_value do |expects|
-      expects.with { |*args| sleep 0.2; true }
-    end
-  end
-
-  def test_shutdown_without_any_open_connections_should_terminate_session
-    gateway = new_gateway
-    gateway.shutdown!
-    assert !gateway.thread.alive?
-    assert !gateway.session.looping?
-  end
-
-  def test_connect_to_should_start_local_ports_at_65535
-    gateway = new_gateway
-    expect_connect_to(:host => "127.0.0.1", :port => 65535).returns(result = sess_with_xserver("app1"))
-    newsess = gateway.connect_to(server("app1"))
-    assert_equal result, newsess
-    assert_equal [65535, "app1", 22], gateway.session.forward.active_locals[65535]
-  end
-
-  def test_connect_to_should_decrement_port_and_retry_if_ports_are_in_use
-    gateway = new_gateway(:reserved => lambda { |n| n > 65000 })
-    expect_connect_to(:host => "127.0.0.1", :port => 65000).returns(result = sess_with_xserver("app1"))
-    newsess = gateway.connect_to(server("app1"))
-    assert_equal result, newsess
-    assert_equal [65000, "app1", 22], gateway.session.forward.active_locals[65000]
-  end
-
-  def test_connect_to_should_honor_user_specification_in_server_definition
-    gateway = new_gateway
-    expect_connect_to(:host => "127.0.0.1", :user => "jamis", :port => 65535).returns(result = sess_with_xserver("app1"))
-    newsess = gateway.connect_to(server("jamis@app1"))
-    assert_equal result, newsess
-    assert_equal [65535, "app1", 22], gateway.session.forward.active_locals[65535]
-  end
-
-  def test_connect_to_should_honor_port_specification_in_server_definition
-    gateway = new_gateway
-    expect_connect_to(:host => "127.0.0.1", :port => 65535).returns(result = sess_with_xserver("app1"))
-    newsess = gateway.connect_to(server("app1:1234"))
-    assert_equal result, newsess
-    assert_equal [65535, "app1", 1234], gateway.session.forward.active_locals[65535]
-  end
-
-  def test_connect_to_should_set_xserver_to_tunnel_target
-    gateway = new_gateway
-    expect_connect_to(:host => "127.0.0.1", :port => 65535).returns(result = sess_with_xserver("app1"))
-    newsess = gateway.connect_to(server("app1:1234"))
-    assert_equal result, newsess
-  end
-
-  def test_shutdown_should_cancel_active_forwarded_ports
-    gateway = new_gateway
-    expect_connect_to(:host => "127.0.0.1", :port => 65535).returns(sess_with_xserver("app1"))
-    gateway.connect_to(server("app1"))
-    assert !gateway.session.forward.active_locals.empty?
-    gateway.shutdown!
-    assert gateway.session.forward.active_locals.empty?
-  end
-
-  def test_error_while_connecting_should_cause_connection_to_fail
-    gateway = new_gateway
-    expect_connect_to(:host => "127.0.0.1").raises(RuntimeError)
-    gateway.expects(:warn).times(2)
-    assert_raises(Capistrano::ConnectionError) { gateway.connect_to(server("app1")) }
-  end
-  
-  def test_connection_error_should_include_accessor_with_host_array
-    gateway = new_gateway
-    expect_connect_to(:host => "127.0.0.1").raises(RuntimeError)
-    gateway.expects(:warn).times(2)
-  
-    begin
-      gateway.connect_to(server("app1"))
-      flunk "expected an exception to be raised"
-    rescue Capistrano::ConnectionError => e
-      assert e.respond_to?(:hosts)
-      assert_equal %w(app1), e.hosts.map { |h| h.to_s }
-    end
-  end
-
-  private
-
-    def sess_with_xserver(host)
-      s = server(host)
-      sess = mock("session")
-      sess.expects(:xserver=).with { |v| v.host == host }
-      sess
-    end
-
-    def expect_connect_to(options={})
-      Capistrano::SSH.expects(:connect).with do |server,config|
-        options.all? do |key, value|
-          case key
-          when :host then server.host == value
-          when :user then server.user == value
-          when :port then server.port == value
-          else false
-          end
-        end
-      end
-    end
-
-    def new_gateway(options={})
-      expect_connect_to(:host => "capistrano").yields(MockSession.new(options))
-      Capistrano::Gateway.new(server("capistrano"))
-    end
-
-    def run_test_initialize_should_open_and_set_session_value
-      session = mock("Net::SSH session")
-      session.expects(:loop)
-      expectation = Capistrano::SSH.expects(:connect).yields(session)
-      yield expectation if block_given?
-      gateway = Capistrano::Gateway.new(server("capistrano"))
-      gateway.thread.join
-      assert_equal session, gateway.session
-    end
-
-    class MockForward
-      attr_reader :active_locals
-
-      def initialize(options)
-        @options = options
-        @active_locals = {}
-      end
-
-      def cancel_local(port)
-        @active_locals.delete(port)
-      end
-
-      def local(lport, host, rport)
-        raise Errno::EADDRINUSE if @options[:reserved] && @options[:reserved][lport]
-        @active_locals[lport] = [lport, host, rport]
-      end
-    end
-
-    class MockSession
-      attr_reader :forward
-
-      def initialize(options={})
-        @forward = MockForward.new(options)
-      end
-
-      def looping?
-        @looping
-      end
-
-      def loop
-        @looping = true
-        sleep 0.1 while yield
-        @looping = false
-      end
-    end
-end

data/test/upload_test.rb

@@ -1,131 +0,0 @@
-require "#{File.dirname(__FILE__)}/utils"
-require 'capistrano/upload'
-
-class UploadTest < Test::Unit::TestCase
-  def setup
-    @mode = IO::WRONLY | IO::CREAT | IO::TRUNC
-  end
-
-  def test_initialize_should_raise_error_if_data_is_missing
-    assert_raises(ArgumentError) do
-      Capistrano::Upload.new([], "test.txt", :foo => "bar")
-    end
-  end
-
-  def test_initialize_should_get_sftp_for_each_session
-    new_sftp = Proc.new do |state|
-      sftp = mock("sftp", :state => state, :open => nil)
-      sftp.expects(:connect) unless state == :open
-      sftp.stubs(:channel).returns({})
-      sftp
-    end
-
-    sessions = [mock("session", :xserver => server("a"), :sftp => new_sftp[:closed]),
-                mock("session", :xserver => server("b"), :sftp => new_sftp[:closed]),
-                mock("session", :xserver => server("c"), :sftp => new_sftp[:open])]
-    Capistrano::Upload.new(sessions, "test.txt", :data => "data")
-  end
-
-  def test_self_process_should_instantiate_uploader_and_start_process
-    Capistrano::Upload.expects(:new).with([:s1, :s2], "test.txt", :data => "data").returns(mock(:process! => nil))
-    Capistrano::Upload.process([:s1, :s2], "test.txt", :data => "data")
-  end
-
-  def test_process_when_sftp_open_fails_should_raise_error
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status", :code => "bad status", :message => "bad status"), :file_handle)
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    assert_raises(Capistrano::UploadError) { upload.process! }
-    assert_equal 1, upload.failed
-    assert_equal 1, upload.completed
-  end
-
-  def test_process_when_sftp_write_fails_should_raise_error
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
-    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => "bad status", :message => "bad status"))
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    assert_raises(Capistrano::UploadError) { upload.process! }
-    assert_equal 1, upload.failed
-    assert_equal 1, upload.completed
-  end
-  
-  def test_upload_error_should_include_accessor_with_host_array
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
-    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => "bad status", :message => "bad status"))
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    
-    begin
-      upload.process!
-      flunk "expected an exception to be raised"
-    rescue Capistrano::UploadError => e
-      assert e.respond_to?(:hosts)
-      assert_equal %w(capistrano), e.hosts.map { |h| h.to_s }
-    end
-  end
-  
-  def test_process_when_sftp_succeeds_should_raise_nothing
-    sftp = mock_sftp
-    sftp.expects(:open).with("test.txt", @mode, 0664).yields(mock("status1", :code => Net::SFTP::Session::FX_OK), :file_handle)
-    sftp.expects(:write).with(:file_handle, "data").yields(mock("status2", :code => Net::SFTP::Session::FX_OK))
-    sftp.expects(:close_handle).with(:file_handle).yields
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data", :logger => stub_everything)
-    assert_nothing_raised { upload.process! }
-    assert_equal 0, upload.failed
-    assert_equal 1, upload.completed
-  end
-
-  def test_process_should_loop_while_running
-    con = mock("connection")
-    con.expects(:process).with(true).times(10)
-    channel = {}
-    channel.expects(:connection).returns(con).times(10)
-    sftp = mock("sftp", :state => :open, :open => nil)
-    sftp.stubs(:channel).returns(channel)
-    session = mock("session", :sftp => sftp, :xserver => server("capistrano"))
-    upload = Capistrano::Upload.new([session], "test.txt", :data => "data")
-    upload.expects(:running?).times(11).returns(*([true]*10 + [false]))
-    upload.process!
-  end
-
-  def test_process_should_loop_but_not_process_done_channels
-    new_sftp = Proc.new do |done|
-      channel = {}
-      channel[:needs_done] = done
-
-      if !done
-        con = mock("connection")
-        con.expects(:process).with(true).times(10)
-        channel.expects(:connection).returns(con).times(10)
-      end
-
-      sftp = mock("sftp", :state => :open, :open => nil)
-      sftp.stubs(:channel).returns(channel)
-      sftp
-    end
-
-    sessions = [stub("session", :sftp => new_sftp[true], :xserver => server("capistrano")),
-                stub("session", :sftp => new_sftp[false], :xserver => server("cap2"))]
-    upload = Capistrano::Upload.new(sessions, "test.txt", :data => "data")
-
-    # make sure the sftp channels we wanted to be done, start as done
-    # (Upload.new marks each channel as not-done, so we have to do it here)
-    sessions.each { |s| s.sftp.channel[:done] = true if s.sftp.channel[:needs_done] }
-    upload.expects(:running?).times(11).returns(*([true]*10 + [false]))
-    upload.process!
-  end
-
-  private
-
-    def mock_sftp
-      sftp = mock("sftp", :state => :open)
-      sftp.stubs(:channel).returns(Hash.new)
-      yield sftp if block_given?
-      sftp
-    end
-end