fairchild-poolparty 1.1.4 → 1.1.5

data/lib/poolparty/net/remoter/cloud_control.rb

@@ -3,240 +3,190 @@ require "ping"
 module PoolParty
   module Remote
     
-    # TODO: Rename and modularize the @inst.status =~ /pending/ so that it works on all 
-    # remoter_bases
-    def launch_instance!(o={}, &block)
-      @inst = launch_new_instance!( o )
-      wait "2.seconds"
-      500.times do |i|
-        if @inst.status =~ /pending/
-          sleep(2)
-          @inst = describe_instance(@inst)          
-        end
-      end
-      when_instance_is_responding @inst do
-        block.call(@inst) if block
-        after_launch_instance(@inst)
-      end
-      @inst
-    end
-    
-    # Called after an instance is launched
-    def after_launch_instance(instance=nil)      
-    end
-    
-    def when_instance_is_responding(inst, &block)
-      if ping_port(inst.ip, 22)
-        block.call if block
-      else
-        raise "Instance not responding at #{inst.ip}"
-      end
-    end
-    
-    # A convenience method for waiting until there are no more
-    # pending instances and then running the block
-    def when_no_pending_instances(&block)
-      reset!
-      if list_of_pending_instances && list_of_pending_instances.size == 0
-        vputs "" # Clear the terminal with a newline
-        block.call if block
-      else
-        vprint "."
-        wait "5.seconds"
-        when_no_pending_instances(&block)
-      end
-    end
-    
-    # Stub method for the time being to handle expansion of the cloud
-    def can_expand_cloud?(force=false)
-      (are_too_few_instances_running? || are_expansion_rules_valid? ) || force || false
-    end
-    def are_expansion_rules_valid?
-      valid_rules?(:expand_when)
-    end
-    # Stub method for the time being to handle the contraction of the cloud
-    def can_contract_cloud?(force=false)
-      return true if force
-      ((are_any_nodes_exceeding_minimum_runtime? and are_too_many_instances_running?) || are_contraction_rules_valid?) || false
-    end
-    def are_contraction_rules_valid?
-      valid_rules?(:contract_when)
-    end
-    # Expand the cloud
-    # If we can start a new instance and the load requires us to expand
-    # the cloud, then we should request_launch_new_instances
-    # Wait for the instance to boot up and when it does come back
-    # online, then provision it as a slave, this way, it is ready for action from the
-    # get go
-    def expand_cloud_if_necessary(force=false)
-      if can_start_a_new_instance? && can_expand_cloud?(force)
-        vputs "Expanding the cloud based on load"
-        @num = 1
-        @num.times do |i|
-          list_of_pending_instances.size == 0 ? request_launch_one_instance_at_a_time : wait("5.seconds")          
-          reset!
-          vputs "request_launch_new_instances: #{@num}"
-          provision_slaves_from_n(@num)
-          after_launched
-        end
-      end
-    end
-    # Contract the cloud
-    # If we can shutdown an instnace and the load allows us to contract
-    # the cloud, then we should request_termination_of_non_master_instance
-    def contract_cloud_if_necessary(force=false)
-      if can_shutdown_an_instance? && can_contract_cloud?(force)
-        vputs "Shrinking the cloud by 1"
-        before_shutdown
-        request_termination_of_non_master_instance
-      end
-    end
-    
-    # List calculation methods
-    # 
-    # Are the minimum number of instances running?
-    def minimum_number_of_instances_are_running?
-      list_of_running_instances.size >= minimum_instances.to_i
-    end
-    # Are the minimum number of instances NOT running?
-    def minimum_number_of_instances_are_not_running?
-      !(minimum_number_of_instances_are_running?)
-    end
-    # Can we shutdown an instance?
-    def can_shutdown_an_instance?
-      list_of_running_instances.size > minimum_instances.to_i
-    end
-    # Are too few instances running?
+    # # Are too few instances running?
     def are_too_few_instances_running?
-      list_of_running_instances.size < minimum_instances.to_i
+      nodes(:status => "running").size < minimum_instances.to_i
     end
-    # Are there more instances than allowed?
+    # # Are there more instances than allowed?
     def are_too_many_instances_running?
-      list_of_running_instances.size > maximum_instances.to_i
-    end
-    
-    ########
-    # TODO: deprecate methods below here (only if they are deprecate-able)
-    ########
-    
-    # Request to launch a number of instances
-    def request_launch_new_instances(num=1)
-      out = []
-      num.times {out << launch_new_instance!(options) }
-      out
-    end
-    def request_launch_master_instance
-      @inst = launch_new_instance!
-      wait "5.seconds"
-      when_no_pending_instances do
-        vputs "Master has launched"
-        reset!
-        after_launch_master(@inst)
-      end
+      nodes(:status => "running").size > maximum_instances.to_i
     end
     
     
-    def after_launch_master(inst=nil)
-      vputs "After launch master in remoter"
-    end
-    # Let's terminate an instance that is not the master instance
-    def request_termination_of_non_master_instance
-      inst = nonmaster_nonterminated_instances.last
-      terminate_instance!(inst.instance_id) if inst
-    end
-    # Can we start a new instance?
-    def can_start_a_new_instance?
-      maximum_number_of_instances_are_not_running? && list_of_pending_instances.size == 0
-    end
-    # Are the maximum number of instances not running?
-    def maximum_number_of_instances_are_not_running?
-      list_of_running_instances.size < maximum_instances.to_i
-    end
-    # Are the maximum number of instances running?
-    def maximum_number_of_instances_are_running?
-      list_of_running_instances.size >= maximum_instances.to_i
-    end
-    # Launch new instance while waiting for the number of pending instances
-    #  to be zero before actually launching. This ensures that we only
-    #  launch one instance at a time
-    def request_launch_one_instance_at_a_time
-      when_no_pending_instances { launch_new_instance! }
-    end
+    # TODO: Deprecate all below here
+    # # A convenience method for waiting until there are no more
+    # # pending instances and then running the block
+    # def when_no_pending_instances(&block)
+    #   reset!
+    #   if list_of_pending_instances && list_of_pending_instances.size == 0
+    #     vputs "" # Clear the terminal with a newline
+    #     block.call if block
+    #   else
+    #     vprint "."
+    #     wait "5.seconds"
+    #     when_no_pending_instances(&block)
+    #   end
+    # end
+    # 
+    # # Stub method for the time being to handle expansion of the cloud
+    # def can_expand_cloud?(force=false)
+    #   (are_too_few_instances_running? || are_expansion_rules_valid? ) || force || false
+    # end
+    # def are_expansion_rules_valid?
+    #   valid_rules?(:expand_when)
+    # end
+    # # Stub method for the time being to handle the contraction of the cloud
+    # def can_contract_cloud?(force=false)
+    #   return true if force
+    #   ((are_any_nodes_exceeding_minimum_runtime? and are_too_many_instances_running?) || are_contraction_rules_valid?) || false
+    # end
+    # def are_contraction_rules_valid?
+    #   valid_rules?(:contract_when)
+    # end
+    # # Expand the cloud
+    # # If we can start a new instance and the load requires us to expand
+    # # the cloud, then we should request_launch_new_instances
+    # # Wait for the instance to boot up and when it does come back
+    # # online, then provision it as a slave, this way, it is ready for action from the
+    # # get go
+    # def expand_cloud_if_necessary(force=false)
+    #   if can_start_a_new_instance? && can_expand_cloud?(force)
+    #     vputs "Expanding the cloud based on load"
+    #     @num = 1
+    #     @num.times do |i|
+    #       list_of_pending_instances.size == 0 ? request_launch_one_instance_at_a_time : wait("5.seconds")          
+    #       reset!
+    #       vputs "request_launch_new_instances: #{@num}"
+    #       provision_slaves_from_n(@num)
+    #       after_launched
+    #     end
+    #   end
+    # end
+    # # Contract the cloud
+    # # If we can shutdown an instnace and the load allows us to contract
+    # # the cloud, then we should request_termination_of_non_master_instance
+    # def contract_cloud_if_necessary(force=false)
+    #   if can_shutdown_an_instance? && can_contract_cloud?(force)
+    #     vputs "Shrinking the cloud by 1"
+    #     before_shutdown
+    #     request_termination_of_non_master_instance
+    #   end
+    # end
+    # 
+    # # List calculation methods
+    # # 
+    # # Are the minimum number of instances running?
+    # def minimum_number_of_instances_are_running?
+    #   nodes(:status => "running").size >= minimum_instances.to_i
+    # end
+    # # Are the minimum number of instances NOT running?
+    # def minimum_number_of_instances_are_not_running?
+    #   !(minimum_number_of_instances_are_running?)
+    # end
+    # # Can we shutdown an instance?
+    # def can_shutdown_an_instance?
+    #   nodes(:status => "running").size > minimum_instances.to_i
+    # end
+
+    # 
+    # ########
+    # # TODO: deprecate methods below here (only if they are deprecate-able)
+    # ########
+    # 
+    # # Request to launch a number of instances
+    # def request_launch_new_instances(num=1)
+    #   out = []
+    #   num.times {out << launch_new_instance!(options) }
+    #   out
+    # end
+    # def request_launch_master_instance
+    #   @inst = launch_new_instance!
+    #   wait "5.seconds"
+    #   when_no_pending_instances do
+    #     vputs "Master has launched"
+    #     reset!
+    #     after_launch_master(@inst)
+    #   end
+    # end
+    # 
+    # 
+    # def after_launch_master(inst=nil)
+    #   vputs "After launch master in remoter"
+    # end
+    # # Let's terminate an instance that is not the master instance
+    # def request_termination_of_non_master_instance
+    #   inst = nonmaster_nonterminated_instances.last
+    #   terminate_instance!(inst.instance_id) if inst
+    # end
+    # # Can we start a new instance?
+    # def can_start_a_new_instance?
+    #   maximum_number_of_instances_are_not_running? && list_of_pending_instances.size == 0
+    # end
+    # # Are the maximum number of instances not running?
+    # def maximum_number_of_instances_are_not_running?
+    #   nodes(:status => "running").size < maximum_instances.to_i
+    # end
+    # # Are the maximum number of instances running?
+    # def maximum_number_of_instances_are_running?
+    #   nodes(:status => "running").size >= maximum_instances.to_i
+    # end
+    # # Launch new instance while waiting for the number of pending instances
+    # #  to be zero before actually launching. This ensures that we only
+    # #  launch one instance at a time
+    # def request_launch_one_instance_at_a_time
+    #   when_no_pending_instances { launch_new_instance! }
+    # end
+    # 
+    # # A convenience method for waiting until all the instances have an ip
+    # # assigned to them. This is useful when shifting the ip addresses
+    # # around on the instances
+    # def when_all_assigned_ips(&block)
+    #   reset!
+    #   if list_of_nonterminated_instances.select {|a| a.ip == 'not.assigned' }.empty?          
+    #     block.call if block
+    #   else
+    #     vprint "."
+    #     wait "5.seconds"
+    #     when_all_assigned_ips(&block)
+    #   end
+    # end
+    # def running_instance_ips
+    #   remote_instances_list.select {|inst| 
+    #     inst.running? and inst.ip!='not.assigned'
+    #   }.collect{|n| n.ip}
+    # end
+    # 
+    # # This will launch the minimum_instances if the minimum number of instances are not running
+    # # If the minimum number of instances are not running and if we can start a new instance
+    # def launch_minimum_number_of_instances        
+    #   if can_start_a_new_instance? && !minimum_number_of_instances_are_running?         
+    #     list_of_pending_instances.size == 0 ? request_launch_one_instance_at_a_time : wait("5.seconds")
+    #     reset!
+    #     launch_minimum_number_of_instances
+    #     provision_slaves_from_n(minimum_instances.to_i)
+    #     after_launched
+    #   end
+    # end
+    # 
+    # def provision_slaves_from_n(num=1)
+    #   vputs "In provision_slaves_from_n: #{num}"
+    #   reset!
+    #   when_no_pending_instances do
+    #     vputs "Waiting for 10 seconds"
+    #     wait "10.seconds" # Give some time for ssh to startup          
+    #     @num_instances = nodes(:status => "running").size
+    #     vputs "(@num_instances - (num))..(@num_instances): #{(@num_instances - (num))..(@num_instances)}"
+    #     last_instances = nonmaster_nonterminated_instances[(@num_instances - (num))..(@num_instances)]
+    #     last_instances.each do |inst|
+    #       vputs "Provision slave: #{inst}"
+    #       verbose ? provisioner_for(inst).install(testing) : hide_output { provisioner_for(inst).install(testing)}
+    #     end
+    #     # PoolParty::Provisioner.reconfigure_master(self)
+    #   end
+    # end
 
-    # A convenience method for waiting until all the instances have an ip
-    # assigned to them. This is useful when shifting the ip addresses
-    # around on the instances
-    def when_all_assigned_ips(&block)
-      reset!
-      if list_of_nonterminated_instances.select {|a| a.ip == 'not.assigned' }.empty?          
-        block.call if block
-      else
-        vprint "."
-        wait "5.seconds"
-        when_all_assigned_ips(&block)
-      end
-    end
-    def running_instance_ips
-      remote_instances_list.select {|inst| 
-        inst.running? and inst.ip!='not.assigned'
-      }.collect{|n| n.ip}
-    end
-    
-    # This will launch the minimum_instances if the minimum number of instances are not running
-    # If the minimum number of instances are not running and if we can start a new instance
-    def launch_minimum_number_of_instances        
-      if can_start_a_new_instance? && !minimum_number_of_instances_are_running?         
-        list_of_pending_instances.size == 0 ? request_launch_one_instance_at_a_time : wait("5.seconds")
-        reset!
-        launch_minimum_number_of_instances
-        provision_slaves_from_n(minimum_instances.to_i)
-        after_launched
-      end
-    end
-    
-    def provision_slaves_from_n(num=1)
-      vputs "In provision_slaves_from_n: #{num}"
-      reset!
-      when_no_pending_instances do
-        vputs "Waiting for 10 seconds"
-        wait "10.seconds" # Give some time for ssh to startup          
-        @num_instances = list_of_running_instances.size
-        vputs "(@num_instances - (num))..(@num_instances): #{(@num_instances - (num))..(@num_instances)}"
-        last_instances = nonmaster_nonterminated_instances[(@num_instances - (num))..(@num_instances)]
-        last_instances.each do |inst|
-          vputs "Provision slave: #{inst}"
-          verbose ? provisioner_for(inst).install(testing) : hide_output { provisioner_for(inst).install(testing)}
-        end
-        # PoolParty::Provisioner.reconfigure_master(self)
-      end
-    end
-    # Launch the master and let the master handle the starting of the cloud
-    # We should only launch an instance if there are no pending instances, in the case 
-    # that the master has launched, but is still pending
-    # and if the master is not running AND we can start a new instance
-    # Then wait for the master to launch
-    def launch_and_configure_master!(testing=false)
-      vputs "Requesting to launch new instance"
-      dputs "Launching master"
-      request_launch_master_instance if list_of_pending_instances.size.zero? && can_start_a_new_instance? && !is_master_running? && !testing
-      reset!
-      unless testing
-        vputs ""
-        vputs "Waiting for there to be no pending instances..."
-        when_no_pending_instances do
-          when_all_assigned_ips {wait "20.seconds"}
-          vputs ""
-          vputs "Provisioning master..."
-          # cleanup_storage_directory
-          @provisioner = PoolParty::Provisioner::Capistrano.new(master, self, :ubuntu)
-          verbose ? @provisioner.install(testing) : hide_output { @provisioner.install(testing) }
-        
-          after_launched
-        end
-      end
-    end
     def list_of_nodes_exceeding_minimum_runtime
-      list_of_running_instances.reject{|i| i.elapsed_runtime < minimum_runtime}
+      nodes(:status => "running").reject{|i| i.elapsed_runtime < minimum_runtime}
     end
     
     def are_any_nodes_exceeding_minimum_runtime?
@@ -244,7 +194,7 @@ module PoolParty
     end
     # Is there a node that is running with the name master
     def is_master_running?
-      !list_of_running_instances.select {|a| a.name == "master"}.first.nil?
+      !nodes(:status => "running").select {|a| a.name == "master"}.first.nil?
     end    
     
   end

data/lib/poolparty/net/remoter/connections.rb

@@ -1,10 +1,12 @@
+require "#{::File.dirname(__FILE__)}/../../modules/pinger"
 require 'rubygems'
 require 'net/ssh'
-require "socket"
 
 module PoolParty
   module Remote
     
+    include ::PoolParty::Pinger
+    
     def target_host(dns_or_ip=nil)
       dns_or_ip ? @target_host=dns_or_ip : @target_host
     end
@@ -27,7 +29,7 @@ module PoolParty
     end
     
     def ssh_options(opts={})
-      o = {"-i" => full_keypair_path,
+      o = {"-i" => keypair.full_filepath,
            "-l" => user,
            "-o" =>"StrictHostKeyChecking=no"
            }.merge(opts)
@@ -35,7 +37,9 @@ module PoolParty
     end
   
     def rsync( source_path, destination_path, rsync_opts=['-v -a'] )
-      puts %x{ rsync -e 'ssh #{ssh_options}' #{rsync_opts.join(' ')} #{source_path}  root@#{target_host}:#{destination_path}}
+      dputs "rsync -e 'ssh #{ssh_options}' #{rsync_opts.join(' ')} #{source_path}  root@#{target_host}:#{destination_path}"
+      out = %x{ rsync -e 'ssh #{ssh_options}' #{rsync_opts.join(' ')} #{source_path}  root@#{target_host}:#{destination_path} }
+      puts out if debugging?
     end
    
     def run_local(commands)
@@ -51,27 +55,15 @@ module PoolParty
     # TODO: make extendable multithreaded version
     def execute!(cmds=commands)
       netssh(
-        [cmds.compact.join(' && ')], 
+        [cmds.compact.join(' && ')],
         :host=>target_host, :user=>'root')
       # commands.each {|c| run_remote(c, target_host) }
-    end    
-
-    def ping_port(host, port=22, retry_times=400)
-      connected = false
-      retry_times.times do |i|
-        begin
-          break if connected = TCPSocket.new(host, port).is_a?(TCPSocket)      
-        rescue Exception => e
-          sleep(2)
-        end
-      end
-      connected
     end
     
     def netssh(cmds=[], opts={})
       user = opts.delete(:user) || user #rescue 'root'
       host = opts.delete(:host) || target_host
-      ssh_options_hash = {:keys => [full_keypair_path],
+      ssh_options_hash = {:keys => [keypair.full_filepath],
                           :auth_methods => 'publickey',
                           :paranoid => false
                            }.merge(opts)
@@ -79,7 +71,7 @@ module PoolParty
       # Start the connection
       Net::SSH.start(host, user, ssh_options_hash) do |ssh|  
         cmds.each do |command|
-          ssh.exec!(command) do |ch, stream, data| 
+          ssh.exec!(command) do |ch, stream, data|
             if stream == :stdout
              print data
             else

data/lib/poolparty/net/remoter/interactive.rb

@@ -1,27 +1,5 @@
 module PoolParty
   module Remote
-    # The following methods are inherent on the RemoterBase
-    # If you need to overwrite these methods, do so with caution
-    # Listing methods
-    def list_of_running_instances(list = list_of_nonterminated_instances)
-      list.select {|a| a if a.running? }
-    end
-    # Get a list of the pending instances
-    def list_of_pending_instances(list = list_of_nonterminated_instances)
-      list.select {|a| a if a.pending? }
-    end
-    # list of shutting down instances
-    def list_of_terminating_instances(list = remote_instances_list)
-      list.reject {|i| true if !i.terminating? }
-    end
-    # Get the instances that are non-master instances
-    def nonmaster_nonterminated_instances(list = list_of_nonterminated_instances)
-      list_of_nonterminated_instances.reject {|i| i.master? }
-    end
-    # list all the nonterminated instances
-    def list_of_nonterminated_instances(list = remote_instances_list)
-      list.reject {|i| i.terminating? || i.terminated? }
-    end
     
     # #DEPRECATE We'll stub the ip to be the master ip for ease and accessibility
     # def ip(i=nil)
@@ -34,88 +12,44 @@ module PoolParty
       get_instance_by_number(0)
     end
     
-    # Get instance by number
-    def get_instance_by_number(i=0, list = remote_instances_list)      
-      name = ((i.nil? || i.zero?) ? "master" : "node#{i}")
-      list.select {|i| i.name == name }.first
+    # Select a list of instances based on their status
+    def nodes(hsh={})
+      # _nodes[hsh] ||= 
+      list_of_instances.select_with_hash(hsh)
     end
-    # A callback before the configuration task takes place
-    def before_configuration_tasks        
+    
+    # Cache the instances_by_status here
+    def _nodes
+      @_nodes ||= {}
     end
     
-    def remote_instances_list        
+    # Select the list of instances, either based on the neighborhoods
+    # loaded from /etc/poolparty/neighborhood.json
+    # or by the remote_base on keypair
+    def list_of_instances
+      return @list_of_instances if @list_of_instances
       @containing_cloud = self
       n = Neighborhoods.load_default
-      @remote_instances_list ||= (n ? n.instances : list_of_instances(keypair.basename)).collect do |h|
-        self.remote_instance_base.constantize.send :new, h, @containing_cloud
-      end
+      @list_of_instances = (n.empty? ? _list_of_instances : n.instances)
     end
 
+    private
     # List the instances for the current key pair, regardless of their states
     # If no keypair is passed, select them all
-    def list_of_instances(keyp=nil)
-      tmp_key = (keyp ? keyp : nil)
-      
-      unless @describe_instances
-        tmpInstanceList = remote_base.describe_instances(options).select {|a| a if (tmp_key.nil? || tmp_key.empty? ? true : a[:keypair] == tmp_key) }
-        has_master = !tmpInstanceList.select {|a| a[:name] == "master" }.empty?          
-        if has_master
-          @describe_instances = tmpInstanceList
-        else
-          @id = 0
-          running = select_from_instances_on_status(/running/, tmpInstanceList)
-          pending = select_from_instances_on_status(/pending/, tmpInstanceList)
-          terminated = select_from_instances_on_status(/shutting/, tmpInstanceList)
-          
-          running = running.map do |inst|
-            inst[:name] = (@id == 0 ? "master" : "node#{@id}")
-            @id += 1
-            inst
-          end.sort_by {|a| a[:index] }
-          
-          @describe_instances = [running, pending, terminated].flatten
-        end
-      end
-      @describe_instances
+    def _list_of_instances(select={})
+      @describe_instances ||= remote_base.describe_instances(options).select_with_hash(select)
     end
-    # Select the instances based on their status
-    def select_from_instances_on_status(status=/running/, list=[])
-      list.select {|a| a[:status] =~ status}
+    
+    # If the cloud is starting an instance, it will not be listed in 
+    # the running instances, so we need to keep track of the instance
+    # that is being started so we can add it to the neighborhood list
+    def started_instance
+      @started_instance ||= []
     end
 
-    # Helpers
-    def create_keypair
-    end
     # Reset the cache of descriptions
     def reset_remoter_base!
-      @describe_instances = nil
-    end
-    def self.included(other)
-      # PoolParty.register_remote_base(self.class.to_s.downcase.to_sym)
-    end
-    
-    # Callback after loaded
-    def loaded_remoter_base        
-    end
-    
-    # Custom minimum runnable options
-    # Extend the minimum runnable options that are necessary
-    # for poolparty to run on the remote base
-    def custom_minimum_runnable_options
-      []
-    end
-          
-    # Custom installation tasks
-    # Allow the remoter bases to attach their own tasks on the 
-    # installation process
-    def custom_install_tasks_for(a=nil)
-      []
-    end
-    # Custom configure tasks
-    # Allows the remoter bases to attach their own
-    # custom configuration tasks to the configuration process
-    def custom_configure_tasks_for(a=nil)
-      []
+      @_nodes = @list_of_instances = @describe_instances = nil
     end
     
   end