Ruby on Rails | Screencasts | Download | Documentation | Weblog | Community | Source

Ticket #8828: no_servers_found.patch

File no_servers_found.patch, 13.2 kB (added by halorgium, 2 years ago)
  • a/lib/capistrano/configuration/connections.rb

    old new  
    9393        raise ArgumentError, "expected a block" unless block_given? 
    9494 
    9595        if task = current_task 
    96           servers = find_servers_for_task(task, options) 
    97  
     96          task_options = options_to_find_servers_for_task(task, options) 
     97          servers = find_servers(task_options) 
    9898          if servers.empty? 
    99             raise ScriptError, "`#{task.fully_qualified_name}' is only run for servers matching #{task.options.inspect}, but no servers matched" 
     99            raise Capistrano::NoMatchingServersError, "`#{task.fully_qualified_name}' is only run for servers matching #{task_options.inspect}, but no servers matched" 
    100100          end 
    101101 
    102102          if task.continue_on_error? 
     
    105105          end 
    106106        else 
    107107          servers = find_servers(options) 
    108           raise ScriptError, "no servers found to match #{options.inspect}" if servers.empty? 
     108          raise Capistrano::NoMatchingServersError, "no servers found to match #{options.inspect}" if servers.empty? 
    109109        end 
    110110 
    111111        servers = [servers.first] if options[:once] 
  • a/lib/capistrano/configuration/servers.rb

    old new  
    11module Capistrano 
    22  class Configuration 
    33    module Servers 
     4      # Returns a hash for use with #find_servers using the given task.  
     5      def options_to_find_servers_for_task(task, options={}) 
     6        task.options_without_desc.merge(options) 
     7      end 
     8       
    49      # Identifies all servers that the given task should be executed on. 
    510      # The options hash accepts the same arguments as #find_servers, and any 
    611      # preexisting options there will take precedence over the options in 
    712      # the task. 
    813      def find_servers_for_task(task, options={}) 
    9         find_servers(task.options.merge(options)) 
     14        find_servers(options_to_find_servers_for_task(task, options)) 
    1015      end 
    1116 
    1217      # Attempts to find all defined servers that match the given criteria. 
  • a/lib/capistrano/errors.rb

    old new  
    33 
    44  class CaptureError < Error; end 
    55  class NoSuchTaskError < Error; end 
     6  class NoMatchingServersError < Error; end 
    67   
    78  class RemoteError < Error 
    89    attr_accessor :hosts 
  • a/lib/capistrano/shell.rb

    old new  
    160160          connect(task) 
    161161          configuration.execute_task(task) 
    162162        end 
    163       rescue Capistrano::NoSuchTaskError => error 
     163      rescue Capistrano::NoMatchingServersError, Capistrano::NoSuchTaskError => error 
    164164        warn "error: #{error.message}" 
    165165      end 
    166166 
  • a/lib/capistrano/task_definition.rb

    old new  
    99      @name, @namespace, @options = name, namespace, options 
    1010      @body = block or raise ArgumentError, "a task requires a block" 
    1111      @servers = nil 
     12    end 
     13     
     14    def options_without_desc 
     15      o = options.dup 
     16      o.delete(:desc) 
     17      o 
    1218    end 
    1319 
    1420    # Returns the task's fully-qualified name, including the namespace 
  • a/test/configuration/connections_test.rb

    old new  
    138138 
    139139  def test_execute_on_servers_without_current_task_should_raise_error_if_no_matching_servers 
    140140    @config.expects(:find_servers).with(:a => :b, :c => :d).returns([]) 
    141     assert_raises(ScriptError) { @config.execute_on_servers(:a => :b, :c => :d) { |list| } } 
     141    assert_raises(Capistrano::NoMatchingServersError) { @config.execute_on_servers(:a => :b, :c => :d) { |list| } } 
    142142  end 
    143143 
    144144  def test_execute_on_servers_should_raise_an_error_if_the_current_task_has_no_matching_servers_by_default 
    145145    @config.current_task = mock_task 
    146     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([]) 
    147     assert_raises(ScriptError) do 
     146    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     147    @config.expects(:find_servers).with(mock_task.options).returns([]) 
     148    assert_raises(Capistrano::NoMatchingServersError) do 
    148149      @config.execute_on_servers do 
    149150        flunk "should not get here" 
    150151      end 
     
    154155  def test_execute_on_servers_should_determine_server_list_from_active_task 
    155156    assert @config.sessions.empty? 
    156157    @config.current_task = mock_task 
    157     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2"), server("cap3")]) 
     158    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     159    @config.expects(:find_servers).with(mock_task.options).returns([server("cap1"), server("cap2"), server("cap3")]) 
    158160    Capistrano::SSH.expects(:connect).times(3).returns(:success) 
    159161    @config.execute_on_servers {} 
    160162    assert_equal %w(cap1 cap2 cap3), @config.sessions.keys.sort.map { |s| s.host } 
     
    163165  def test_execute_on_servers_should_yield_server_list_to_block 
    164166    assert @config.sessions.empty? 
    165167    @config.current_task = mock_task 
    166     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2"), server("cap3")]) 
     168    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     169    @config.expects(:find_servers).with(mock_task.options).returns([server("cap1"), server("cap2"), server("cap3")]) 
    167170    Capistrano::SSH.expects(:connect).times(3).returns(:success) 
    168171    block_called = false 
    169172    @config.execute_on_servers do |servers| 
     
    179182  def test_execute_on_servers_with_once_option_should_establish_connection_to_and_yield_only_the_first_server 
    180183    assert @config.sessions.empty? 
    181184    @config.current_task = mock_task 
    182     @config.expects(:find_servers_for_task).with(@config.current_task, :once => true).returns([server("cap1"), server("cap2"), server("cap3")]) 
     185    mock_options = mock_task.options.merge(:once => true) 
     186    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, :once => true).returns(mock_options) 
     187    @config.expects(:find_servers).with(mock_options).returns([server("cap1"), server("cap2"), server("cap3")]) 
    183188    Capistrano::SSH.expects(:connect).returns(:success) 
    184189    block_called = false 
    185190    @config.execute_on_servers(:once => true) do |servers| 
     
    192197   
    193198  def test_execute_servers_should_raise_connection_error_on_failure_by_default 
    194199    @config.current_task = mock_task 
    195     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1")]) 
     200    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     201    @config.expects(:find_servers).with(mock_task.options).returns([server("cap1")]) 
    196202    Capistrano::SSH.expects(:connect).raises(Exception) 
    197203    assert_raises(Capistrano::ConnectionError) { 
    198204      @config.execute_on_servers do 
     
    203209   
    204210  def test_execute_servers_should_not_raise_connection_error_on_failure_with_on_errors_continue 
    205211    @config.current_task = mock_task(:on_error => :continue) 
    206     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2")]) 
     212    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     213    @config.expects(:find_servers).with(mock_task.options).returns([server("cap1"), server("cap2")]) 
    207214    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success) 
    208215    assert_nothing_raised { 
    209216      @config.execute_on_servers do |servers| 
     
    215222  def test_execute_on_servers_should_not_try_to_connect_to_hosts_with_connection_errors_with_on_errors_continue 
    216223    list = [server("cap1"), server("cap2")] 
    217224    @config.current_task = mock_task(:on_error => :continue) 
    218     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns(list) 
     225    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     226    @config.expects(:find_servers).with(mock_task.options).returns(list) 
    219227    Capistrano::SSH.expects(:connect).times(2).raises(Exception).then.returns(:success) 
    220228    @config.expects(:failed!).with(server("cap1")) 
    221229    @config.execute_on_servers do |servers| 
    222230      assert_equal %w(cap2), servers.map { |s| s.host } 
    223231    end 
    224     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns(list) 
     232    @config.expects(:options_to_find_servers_for_task).returns(mock_task.options) 
     233    @config.expects(:find_servers).with(mock_task.options).returns(list) 
    225234    @config.execute_on_servers do |servers| 
    226235      assert_equal %w(cap2), servers.map { |s| s.host } 
    227236    end 
     
    231240    cap1 = server("cap1") 
    232241    cap2 = server("cap2") 
    233242    @config.current_task = mock_task(:on_error => :continue) 
    234     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2]) 
     243    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     244    @config.expects(:find_servers).with(mock_task.options).returns([cap1, cap2]) 
    235245    Capistrano::SSH.expects(:connect).times(2).returns(:success) 
    236246    @config.execute_on_servers do |servers| 
    237247      error = Capistrano::CommandError.new 
    238248      error.hosts = [cap1] 
    239249      raise error 
    240250    end 
    241     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2]) 
     251    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     252    @config.expects(:find_servers).with(mock_task.options).returns([cap1, cap2]) 
    242253    @config.execute_on_servers do |servers| 
    243254      assert_equal %w(cap2), servers.map { |s| s.host } 
    244255    end 
     
    248259    cap1 = server("cap1") 
    249260    cap2 = server("cap2") 
    250261    @config.current_task = mock_task(:on_error => :continue) 
    251     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2]) 
     262    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     263    @config.expects(:find_servers).with(mock_task.options).returns([cap1, cap2]) 
    252264    Capistrano::SSH.expects(:connect).times(2).returns(:success) 
    253265    @config.execute_on_servers do |servers| 
    254266      error = Capistrano::UploadError.new 
    255267      error.hosts = [cap1] 
    256268      raise error 
    257269    end 
    258     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([cap1, cap2]) 
     270    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     271    @config.expects(:find_servers).with(mock_task.options).returns([cap1, cap2]) 
    259272    @config.execute_on_servers do |servers| 
    260273      assert_equal %w(cap2), servers.map { |s| s.host } 
    261274    end 
     
    264277  def test_connect_should_establish_connections_to_all_servers_in_scope 
    265278    assert @config.sessions.empty? 
    266279    @config.current_task = mock_task 
    267     @config.expects(:find_servers_for_task).with(@config.current_task, {}).returns([server("cap1"), server("cap2"), server("cap3")]) 
     280    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, {}).returns(mock_task.options) 
     281    @config.expects(:find_servers).with(mock_task.options).returns([server("cap1"), server("cap2"), server("cap3")]) 
    268282    Capistrano::SSH.expects(:connect).times(3).returns(:success) 
    269283    @config.connect! 
    270284    assert_equal %w(cap1 cap2 cap3), @config.sessions.keys.sort.map { |s| s.host } 
     
    273287  def test_connect_should_honor_once_option 
    274288    assert @config.sessions.empty? 
    275289    @config.current_task = mock_task 
    276     @config.expects(:find_servers_for_task).with(@config.current_task, :once => true).returns([server("cap1"), server("cap2"), server("cap3")]) 
     290    @config.expects(:options_to_find_servers_for_task).with(@config.current_task, :once => true).returns(mock_task.options) 
     291    @config.expects(:find_servers).with(mock_task.options).returns([server("cap1"), server("cap2"), server("cap3")]) 
    277292    Capistrano::SSH.expects(:connect).returns(:success) 
    278293    @config.connect! :once => true 
    279294    assert_equal %w(cap1), @config.sessions.keys.sort.map { |s| s.host }