poolparty 0.2.84 → 1.2.2

data/lib/poolparty/monitors/monitors/stats_monitor.rb

@@ -0,0 +1,187 @@
+=begin rdoc
+  Stats returns the basic node metrics and checks to see if any actions should be taken based
+  on the default expand and contract rules defined in the clouds.rb file.
+=end
+
+module Monitors
+  
+  class Stats < BaseMonitor
+    attr_reader :stats, :request
+    attr_accessor :response
+    
+    def initialize(env, o={})
+      @env = env
+      @request = Rack::Request.new env
+      @response = Rack::Response.new
+      
+      begin
+        @cloud = JSON.parse( open('/etc/poolparty/clouds.json' ).read )
+      rescue 
+        @cloud = ::PoolParty::Default.options.merge({"options" =>
+          {"rules" => {"expand"   => PoolParty::Default.expand_when,
+                       "contract" => PoolParty::Default.contract_when
+                      }
+          }
+        })
+      end
+      # Our cloud.options.rules looks like
+      #  {"expand_when" => "load > 0.9", "contract_when" => "load < 0.4"}
+      # We set these as rules on ourselves so we can use aska to parse the rules.
+      # Later, we can call vote_rules on ourself and we'll get back Aska::Rule(s)
+      # which we'll call valid_rule? for each Rule and return the result
+      @cloud["options"]["rules"].each do |name, rul|
+        r = Aska::Rule.new(rul)
+        rule(name) << r
+      end
+      # log << "#{::Time.now.strftime("%Y-%m-%d-%H-%M")}, #{stats.to_json}\n"
+    end
+    
+    def get(data=nil)
+      begin
+        if !request.params || request.params.empty?
+          default_stats
+        else
+          stats[request.params[0].to_sym] ||= self.send(request.params[0])
+          stats[request.params[0].to_sym]
+          stats.to_json
+        end
+      rescue Exception => e
+        "Error: #{e}"
+      end
+    end
+    
+    def put(data)
+      if d = JSON.parse(request.params)
+        hsh = d.reject {|ip, _node| ip == my_ip }
+        stats.merge!(hsh)
+        handle_election
+      else
+        "boom"
+      end
+    end
+    alias :update :put
+    
+    protected
+    
+    def log(log_file_path="/var/log/poolparty/stats_monitor.log")
+      if @logfile
+        @logfile
+      else
+        ::File.file? log_file_path
+        ::FileUtils.mkdir_p ::File.dirname(log_file_path) unless ::File.directory?(::File.dirname(log_file_path))
+        @logfile ||= ::File.open(log_file_path, 'a+')
+      end
+    end
+    
+    # Handle the elections
+    def handle_election
+      # Ballots look like:
+      # host => ["contract"]
+      candidates = {:expand => 0, :contract => 0}
+      candidates.each do |action, ballots|
+        stats.each do |ip, node_hsh|
+          candidates[action]+=1 if node_hsh["nominations"] && node_hsh["nominations"].include?(action.to_s)
+        end
+      end
+      # TODO: Move?
+      # Expand the cloud if 50+% of the votes are for expansion
+      # Contract the cloud if 51+% of the votes are for contraction
+      if (candidates[:expand] - candidates[:contract])/stats.keys.size > 0.5
+        %x[/usr/bin/server-cloud-elections expand] unless elected_action == "expand"
+        @elected_action = "expand"
+      elsif (candidates[:contract] - candidates[:expand])/stats.keys.size > 0.5
+        %x[/usr/bin/server-cloud-elections contract] unless elected_action == "contract"
+        @elected_action = "contract"
+      end      
+
+      reload_data!
+      stats[my_ip]["elected_action"] = @elected_action if @elected_action
+      log << "#{Time.now.strftime("%Y-%m-%d-%H-%M")}, #{stats.to_json}\n"
+      stats.to_json
+    end
+
+
+    def elected_action
+      @elected_action ||= nil
+    end
+
+    def rules
+      @rules ||= {}
+    end
+
+    def rule(name)
+      rules[name] ||= []
+    end
+
+    def default_stats
+      %w(load nominations).each do |var|
+        stats[my_ip][var] ||= self.send(var.to_sym)
+      end      
+      stats
+    end
+
+    def stats
+      @stats ||= {my_ip  => {}}
+    end
+
+    def load
+      %x{"uptime"}.split[-3].to_f
+    end
+
+    def instances
+      # res = PoolParty::Neighborhoods.load_default.instances
+      res ||= %x[/usr/bin/server-list-active internal_ip].split("\t")
+      res
+    end
+
+    def can_expand?
+      instances.size < max_instances
+    end
+
+    def can_contract?
+      instances.size > min_instances
+    end
+
+    def min_instances
+      (@cloud["options"]["minimum_instances"] || PoolParty::Default.minimum_instances).to_i
+    end
+
+    def max_instances
+      (@cloud["options"]["maximum_instances"] || PoolParty::Default.maximum_instances).to_i
+    end
+
+    def nominations
+      load = stats[my_ip]["load"] ||= self.send(:load)
+      stats[my_ip]["nominations"] ||= rules.collect do |k,cld_rules|
+        t = cld_rules.collect do |r|
+          # If the comparison works
+          if self.send(r.key.to_sym).to_f.send(r.comparison, r.var.to_f)
+            # if we are facing an expansion rule
+            if k =~ /expand/
+              k if can_expand?
+            # if we are facing a contraction rule
+            elsif k =~ /contract/
+              k if can_contract?
+            else
+              k
+            end
+          end
+        end.compact
+      end.flatten.compact
+    end
+
+    def my_ip
+      @my_ip ||= ohai["ipaddress"]
+    end
+
+    def ohai
+      @ohai ||= JSON.parse(%x[ohai])
+    end
+
+    def reload_data!
+      @stats[my_ip] = {}
+      instances.each {|inst| @stats[inst] = {} }
+    end    
+    
+  end
+end

data/lib/poolparty/monitors/monitors/time_monitor.rb

@@ -0,0 +1,15 @@
+# An example monitor
+# access it at /monitor_time/ or /monitor_time/now
+module Monitors
+  
+  class Time < BaseMonitor
+    def get(data=nil)
+      Time.now
+    end
+    
+    def get_now
+      Time.now
+    end
+  end
+  
+end

data/lib/poolparty/net/init.rb

@@ -0,0 +1,10 @@
+# Load the core net libraries.  These are neccessary for any of the remoter_bases to function.
+%w(remote_instance remote_bases remoter_base).each do |file|
+  require File.join(::File.dirname(__FILE__),file+'.rb')
+end
+
+# Register available remoter_bases
+Dir["#{::File.dirname(__FILE__)}/remoter_bases/*/*.rb"].each do |base| 
+  name = File.join(::File.basename(base, ::File.extname(base)))
+  require base
+end

data/lib/poolparty/net/remote_bases.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + "/remoter_base"
+
+class Object
+  def remote_bases
+    $remote_bases ||= []
+  end
+  # Register the remoter base in the remote_bases global store
+  def register_remote_base(*args)
+    args.each do |arg|
+      base_name = "#{arg}".downcase.to_sym
+      (remote_bases << base_name) unless remote_bases.include?(base_name)
+    end
+  end
+  alias :available_bases :remote_bases
+end
+
+Dir["#{File.dirname(__FILE__)}/remote_bases/*.rb"].each do |base| 
+  name = ::File.basename(base, ::File.extname(base))
+  require base
+end

data/lib/poolparty/net/remote_instance.rb

@@ -1,19 +1,14 @@
-require File.dirname(__FILE__) + "/remoter"
-
 module PoolParty  
   module Remote
     
     class RemoteInstance
-      include Remote
-      include Configurable
-      include CloudResourcer
+      include Dslify
       
-      def initialize(opts, parent=self)        
-        run_setup(parent)
+      def initialize(opts={}, containing_cloud=nil)
+        @parent = containing_cloud
 
-        set_vars_from_options(parent.options) if parent && parent.respond_to?(:options)
-        set_vars_from_options(opts) unless opts.nil? || opts.empty?
-        
+        set_vars_from_options(containing_cloud.options) if containing_cloud && containing_cloud.respond_to?(:options)
+        set_vars_from_options(opts) if opts.is_a?(Hash)
         on_init
       end
       
@@ -25,76 +20,63 @@ module PoolParty
       def on_init
       end
       
-      # Is this remote instance the master?
-      def master?
-        name == "master"
-      end
-      
       # The remote instances is only valid if there is an ip and a name
       def valid?
-        !(ip.nil? || name.nil?)
+        (ip.nil? || name.nil?) ? false : true
       end
       
       # Determine if the RemoteInstance is responding
       def responding?
-        !responding.nil?
+        running?
+        # !responding.nil? #TODO MF this needs to actually ping the node or something similar.  stubbed to running? for now
       end
       
       # This is how we get the current load of the instance
       # The approach of this may change entirely, but the usage of
       # it will always be the same
       def load
-        current_load ||= 0.0
+        current_load ||= 0.0  #NOTE MF: returning 0.0 seems like a bad idea here.  should return nil if we dont have a real value
       end
-            
+      
+      # Note, the next 4 methods will be overridden by the cloud specific remoter_base
       # Is this instance running?
       def running?
-        !(status =~ /running/).nil?
+        true
       end
       # Is this instance pending?
       def pending?
-        !(status =~ /pending/).nil?
+        false
       end
       # Is this instance terminating?
       def terminating?
-        !(status =~ /shutting/).nil?
+        false
       end
       # Has this instance been terminated?
       def terminated?
-        !(status =~ /terminated/).nil?
+        false
       end
       
       # Printing. This is how we extract the instances into the listing on the 
       # local side into the local listing file
       def to_s
-        "#{name}\t#{ip}\t#{instance_id}"
+        "#{name}\t#{ip}\t#{instance_id rescue ""}"
       end
       
-      def puppet_runner_command
-        self.class.send :puppet_runner_command
-      end
-      # Commands for the servers
-      def self.puppet_runner_command
-        ". /etc/profile && puppetrunner"
+      # Class method to disect a neighborhood line
+      def self.hash_from_s(s)
+        arr = s.split("\t")
+        {:name => arr[0], :ip => arr[1]}
       end
-      def self.puppet_master_rerun_command
-        ". /etc/profile && puppetrerun"
-      end
-      def self.puppet_rerun_commad
-        puppet_runner_command
-      end
-      def cloud
-        @pa = parent
-        while !(@pa.is_a?(PoolParty::Cloud::Cloud) || @pa.nil? || @pa == self)
-          @pa = @pa.parent
-        end
-        @pa
+      
+      def self.to_s(hsh)
+        new(hsh).to_s
       end
+      
       def hosts_file_listing_for(cl)
-        string = (cl.name == cloud.name) ? "#{name}.#{cloud.name}\t#{name}" : "#{name}.#{cloud.name}"
+        string = (cl.name == cloud.name) ? "#{name}.#{my_cloud.name}\t#{name}" : "#{name}.#{my_cloud.name}"
         "#{internal_ip}\t#{string}"
       end
     end
     
   end  
-end
+end

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

@@ -0,0 +1,24 @@
+require "ping"
+
+module PoolParty
+  module Remote
+    
+    # # Are too few instances running?
+    def are_too_few_instances_running?
+      nodes(:status => "running").size < minimum_instances.to_i
+    end
+    # # Are there more instances than allowed?
+    def are_too_many_instances_running?
+      nodes(:status => "running").size > maximum_instances.to_i
+    end
+
+    def list_of_nodes_exceeding_minimum_runtime
+      nodes(:status => "running").reject{|i| i.elapsed_runtime < minimum_runtime}
+    end
+    
+    def are_any_nodes_exceeding_minimum_runtime?
+      !list_of_nodes_exceeding_minimum_runtime.blank?
+    end
+    
+  end
+end

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

@@ -0,0 +1,172 @@
+require "#{::File.dirname(__FILE__)}/../../modules/pinger"
+require 'rubygems'
+require 'net/ssh'
+
+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
+  
+    # 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" => keypair.full_filepath,
+           "-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'] )
+      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)
+      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 netssh(cmds=[], opts={})
+      user = opts.delete(:user) || user #rescue 'root'
+      host = opts.delete(:host) || target_host
+      ssh_options_hash = {:keys => [keypair.full_filepath],
+                          :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,45 @@
+module PoolParty
+  module Remote
+    
+    # Select a list of instances based on their status
+    def nodes(hsh={})
+      # _nodes[hsh] ||= 
+      list_of_instances.select_with_hash(hsh)
+    end
+    
+    # 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
+      @list_of_instances = (n.empty? ? _list_of_instances : n.instances)
+    end
+
+    private
+    # Cache the instances_by_status here
+    def _nodes
+      @_nodes ||= {}
+    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(select={})
+      @describe_instances ||= remote_base.describe_instances(options).select_with_hash(select)
+    end
+    
+    # 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
+
+    # Reset the cache of descriptions
+    def reset_remoter_base!
+      @_nodes = @list_of_instances = @describe_instances = nil
+    end
+    
+  end
+end