fairchild-poolparty 1.1.3

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

@@ -0,0 +1,251 @@
+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?
+    def are_too_few_instances_running?
+      list_of_running_instances.size < minimum_instances.to_i
+    end
+    # 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
+    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
+
+    # 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}
+    end
+    
+    def are_any_nodes_exceeding_minimum_runtime?
+      !list_of_nodes_exceeding_minimum_runtime.blank?
+    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?
+    end    
+    
+  end
+end

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

@@ -0,0 +1,180 @@
+require 'rubygems'
+require 'net/ssh'
+require "socket"
+
+module PoolParty
+  module Remote
+    
+    def target_host(dns_or_ip=nil)
+      dns_or_ip ? @target_host=dns_or_ip : @target_host
+    end
+  
+    # Simply shell out and call ssh, simple, reliable and fewest dependencies, but slow
+    def simplest_run_remote(host=target_host, command=[], extra_ssh_ops={})
+      command = command.compact.join(' && ') if command.is_a? Array
+      cmd = "ssh #{host} #{ssh_options(extra_ssh_ops)} '#{command}'"
+      puts "\n--------------------------------\nrunning_remote:\n #{cmd}\n"
+      puts %x{#{cmd}}
+    end
+    
+    def run_remote( hst, cmds )
+      netssh hst, cmds
+    end
+    
+    def ssh_into(inst, extra_ssh_ops={} )
+      ip =  ((inst.respond_to?(:has_key) && inst.has_key?(:ip)) || inst.respond_to?(:ip)) ? inst.ip : inst
+      Kernel.system("ssh #{ssh_options(extra_ssh_ops)} #{ip}")
+    end
+    
+    def ssh_options(opts={})
+      o = {"-i" => full_keypair_path,
+           "-l" => user,
+           "-o" =>"StrictHostKeyChecking=no"
+           }.merge(opts)
+      o.collect{ |k,v| "#{k} #{v}"}.join(' ')
+    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}}
+    end
+   
+    def run_local(commands)
+      commands.each do |cmd|
+        puts `#{cmd}`
+      end
+    end
+
+    def commands
+      @commands ||= Array.new
+    end
+
+    # TODO: make extendable multithreaded version
+    def execute!(cmds=commands)
+      netssh(
+        [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],
+                          :auth_methods => 'publickey',
+                          :paranoid => false
+                           }.merge(opts)
+      
+      # Start the connection
+      Net::SSH.start(host, user, ssh_options_hash) do |ssh|  
+        cmds.each do |command|
+          ssh.exec!(command) do |ch, stream, data| 
+            if stream == :stdout
+             print data
+            else
+              $stderr.print "#{host} stderr => #{data}"
+            end
+          end
+        end
+      end
+    end
+    
+    
+##########################################################################################################   
+# TODO: Delete deprecated commands below here
+    
+    def rsync_storage_files_to_command(remote_instance)
+      #TODO: rsync_to_command("#{Default.storage_directory}/", Default.remote_storage_path, remote_storage_path) if remote_instance
+      "#{rsync_command} #{Default.storage_directory}/ #{remote_instance.ip}:#{Default.remote_storage_path}" if remote_instance
+    end
+    # rsync a file to a node.  By default to the master node.
+    def rsync_to_command(source, target=source, remote_instance=master)
+      "#{rsync_command} #{source} #{remote_instance.ip}:#{target}"
+    end
+    def run_command_on_command(cmd="ls -l", remote_instance=nil)
+      vputs "Running #{cmd} on #{remote_instance.name == %x[hostname].chomp ? "self (master)" : "#{remote_instance.name}"}"
+      (remote_instance.nil? || remote_instance.name == %x[hostname].chomp) ? %x[#{cmd}] : "#{ssh_command(remote_instance)} '#{cmd}'"
+    end
+    def ssh_command(remote_instance)
+      "#{ssh_string} #{remote_instance.ip}"
+    end
+    # Generic commandable strings
+    def ssh_string
+      (["ssh"] << ssh_array).join(" ")
+    end
+    # Array of ssh options
+    # Includes StrictHostKeyChecking to no
+    # Ssh with the user in Base
+    # And including the keypair_path
+    # "-l '#{Default.user}'", 
+    def ssh_array
+      ["-o StrictHostKeyChecking=no", "-l #{Default.user}", '-i "'+full_keypair_path+'"']
+    end
+    def scp_array
+      ["-o StrictHostKeyChecking=no", '-i "'+full_keypair_path+'"']
+    end
+    def rsync_command
+      "rsync -azP --exclude cache -e '#{ssh_string} -l #{Default.user}'"
+    end
+    def remote_ssh_array
+      ["-o StrictHostKeyChecking=no", "-l '#{Default.user}'", '-i "'+remote_keypair_path+'"']
+    end
+    def remote_ssh_string
+      (["ssh"] << remote_ssh_array).join(" ")
+    end
+    def remote_rsync_command
+      "rsync -azP --exclude cache -e '#{remote_ssh_string}'"
+    end
+          
+    def scp_to_command(source, dest=target, remote_instance=master)
+      #TODO: check if source is Directory and add -r if it is
+      "scp #{source} #{remote_instance.ip}:#{dest} #{scp_array.join(' ')}"
+    end
+    
+    # Rsync a file or directory to a node.  Rsync to master by default
+    def rsync_to(source, target=source, num=0)
+      str = "#{rsync_to_command(source, target, get_instance_by_number( num ))}"
+      dputs "Running: #{str}"
+      verbose ?  Kernel.system(str) : hide_output {Kernel.system str}
+    end
+    
+    # Rsync command to the instance
+    def rsync_storage_files_to(instance=nil)
+      hide_output {Kernel.system "#{rsync_storage_files_to_command(instance)}" if instance}
+    end
+    # Take the rsync command and execute it on the system
+    # if there is an instance given
+    def run_command_on(cmd, instance=nil)        
+      Kernel.system "#{run_command_on_command(cmd, instance)}"
+    end
+    
+    # Ssh into the instance given
+    # def ssh_into(instance)
+    #   cmd = "#{ssh_command(instance)}"
+    #   vputs "Running #{cmd}"
+    #   Kernel.system cmd if instance
+    # end
+    # Find the instance by the number given
+    # and then ssh into the instance
+    def ssh_into_instance_number(num=0)
+      ssh_into( get_instance_by_number( num ) )
+    end
+    
+    # Run command on the instance by the number
+    def run_command_on_instance_number(cmd="ls -l", num=0)
+      run_command_on(cmd, get_instance_by_number( num ) )
+    end
+    
+  end
+end

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

@@ -0,0 +1,121 @@
+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)
+    #   puts "DEPRECATED:  ip will only be callable against a RemoteInstance in the next release."
+    #   i ? options[:ip] = i : (master ? master.ip : options[:ip])
+    # end
+    # #DEPRECATE: get the master instance
+    def master
+      puts "DEPRECATED:  'master' is deprecated and will be removed in the next major release."
+      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
+    end
+    # A callback before the configuration task takes place
+    def before_configuration_tasks        
+    end
+    def remote_instances_list        
+      @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
+    end
+
+    # 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
+    end
+    # Select the instances based on their status
+    def select_from_instances_on_status(status=/running/, list=[])
+      list.select {|a| a[:status] =~ status}
+    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)
+      []
+    end
+    
+  end
+end

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

@@ -0,0 +1,12 @@
+# Get the names of the nodes. Mainly used for puppet templating
+module PoolParty
+  module Remote
+    def list_of_node_names(options={})
+      list_of_running_instances.collect {|ri| ri.name }
+    end
+    # An array of node ips. Mainly used for puppet templating
+    def list_of_node_ips(options={})
+      list_of_running_instances.collect {|ri| ri.ip }
+    end
+  end
+end

data/lib/poolparty/net/remoter_base.rb

@@ -0,0 +1,97 @@
+=begin rdoc
+  The base for Remote Bases
+  
+  By extending this class, you can easily add remoters to 
+  PoolParty. There are 4 methods that the remote base needs to implement
+  in order to be compatible.
+  
+  The four methods are:
+    launch_new_instance!
+    terminate_instance(id)
+    describe_instance(id)
+    describe_instances
+  
+  After your remote base is written, make sure to register the base outside the context
+  of the remote base, like so:
+    register_remote_base :remote_base_name
+  
+=end
+
+module PoolParty
+
+  module Remote    
+    # This class is the base class for all remote types, such as ec2
+    # Everything remoting-wise is derived from this class
+    class RemoterBase
+      include  Remote
+      
+      def initialize(prnt = nil)
+        @parent = prnt
+      end
+      
+      def method_missing(meth, *args, &block)
+        if @parent
+          @parent.send meth, *args, &block rescue super
+        else
+          super
+        end
+      end
+      
+      # Required methods
+      # The next methods are required on all RemoteInstance types
+      # If your RemoteInstance type does not overwrite the following methods
+      # An exception will be raised and poolparty will explode into tiny little 
+      # pieces. Don't forget to overwrite these methods
+      # Launch a new instance
+      def self.launch_new_instance!(o={})
+        raise RemoteException.new(:method_not_defined, "launch_new_instance!")
+      end
+      def self.expand(o={});launch_new_instance!(o);end
+      def launch_new_instance!(o={})
+        self.class.launch_new_instance!( options.merge(o) )
+      end
+      
+      # Terminate an instance by id
+      def self.terminate_instance!(o={})
+        raise RemoteException.new(:method_not_defined, "terminate_instance!")
+      end
+      def self.contract(o={});terminate_instance!(o);end      
+      def terminate_instance!(o={})
+        self.class.terminate_instance!(o ? options.merge(o) : options)
+      end
+      
+      # Describe an instance's status
+      def self.describe_instance(o={})
+        raise RemoteException.new(:method_not_defined, "describe_instance")
+      end
+      def describe_instance(o={})
+        self.class.describe_instance(o ? options.merge(o) : options)
+      end
+      
+      # Get instances
+      # The instances must have a status associated with them on the hash
+      def self.describe_instances(o={})
+        raise RemoteException.new(:method_not_defined, "describe_instances")
+      end
+      def describe_instances(o={})
+        self.class.describe_instances(o ? options.merge(o) : options)
+      end
+      
+      # After launch callback
+      # This is called after a new instance is launched
+      def after_launched(force=false)        
+      end
+      
+      # Before shutdown callback
+      # This is called before the cloud is contracted
+      def before_shutdown
+      end
+      
+    end
+    
+  end
+end
+
+Dir["#{File.dirname(__FILE__)}/remoter/*.rb"].each do |remoter_module| 
+  require remoter_module
+end