fairchild-poolparty 1.1.5 → 1.2.12

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

@@ -16,26 +16,18 @@ module Monitors
       
       begin
         @cloud = JSON.parse( open('/etc/poolparty/clouds.json' ).read )
+        # @cloud = ::PoolParty::Cloud::Cloud.load_from_json(open('/etc/poolparty/clouds.json' ).read)
       rescue 
-        @cloud = ::PoolParty::Default.options.merge({"options" =>
+        @cloud = ::PoolParty::Default.dsl_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"
+      make_aska_rules(@cloud["options"]["rules"])
     end
-    
+        
     def get(data=nil)
       begin
         if !request.params || request.params.empty?
@@ -46,15 +38,20 @@ module Monitors
           stats.to_json
         end
       rescue Exception => e
-        "Error: #{e}"
+        "Error: #{e}".to_json
       end
     end
     
+    #alias to allow access thru http route GET /stats/nominations
+    def get_nominations(_nodes=[])
+      nominations
+    end
+    
     def put(data)
       if d = JSON.parse(request.params)
         hsh = d.reject {|ip, _node| ip == my_ip }
         stats.merge!(hsh)
-        handle_election
+        # handle_election
       else
         "boom"
       end
@@ -63,16 +60,6 @@ module Monitors
     
     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:
@@ -86,26 +73,26 @@ module Monitors
       # TODO: Move?
       # Expand the cloud if 50+% of the votes are for expansion
       # Contract the cloud if 51+% of the votes are for contraction
+      # Check to make sure an elected action is not already in progress
       if (candidates[:expand] - candidates[:contract])/stats.keys.size > 0.5
-        %x[/usr/bin/server-cloud-elections expand] unless elected_action == "expand"
+        %x[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"
+        %x[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"
+      log "#{Time.now.strftime("%Y-%m-%d-%H-%M")}, #{stats.to_json}\n"
       stats.to_json
     end
 
-
-    def elected_action
+    def elected_action(_n=nil)
       @elected_action ||= nil
     end
 
-    def rules
+    def rules(_n=nil)
       @rules ||= {}
     end
 
@@ -120,39 +107,51 @@ module Monitors
       stats
     end
 
-    def stats
+    def stats(_n=nil)
       @stats ||= {my_ip  => {}}
     end
 
-    def load
+    def load(_n=nil)
       %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
+    def instances(_n=nil)
+      my_cloud.nodes(:status => "running")
     end
 
-    def can_expand?
+    def can_expand?(_n=nil)
       instances.size < max_instances
     end
 
-    def can_contract?
+    def can_contract?(_n=nil)
       instances.size > min_instances
     end
 
-    def min_instances
-      (@cloud["options"]["minimum_instances"] || PoolParty::Default.minimum_instances).to_i
+    def min_instances(_n=nil)
+      (my_cloud.minimum_instances || PoolParty::Default.minimum_instances).to_i
     end
 
-    def max_instances
-      (@cloud["options"]["maximum_instances"] || PoolParty::Default.maximum_instances).to_i
+    def max_instances(_n=nil)
+      (my_cloud.maximum_instances || PoolParty::Default.maximum_instances).to_i
     end
 
-    def nominations
+    def nominations(_n=nil)
+      # return ['expand'] if instances.size<min_instances
       load = stats[my_ip]["load"] ||= self.send(:load)
-      stats[my_ip]["nominations"] ||= rules.collect do |k,cld_rules|
+      nominations = if my_cloud.running_action
+        ["none"]
+      else
+        collect_nominations
+      end
+      # Hackity hack hack
+      nominations << "expand" if my_cloud.nodes(:status => "running").size < min_instances
+      nominations << "contract" if my_cloud.nodes(:status => "running").size > max_instances
+      stats[my_ip]["nominations"] = nominations #TODO: Deprecate
+      nominations
+    end
+    
+    def collect_nominations
+      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)
@@ -165,22 +164,42 @@ module Monitors
             else
               k
             end
-          end
+          end        
         end.compact
-      end.flatten.compact
+      end.flatten.compact      
     end
-
+    
+    def neighborhood
+      @neighborhood ||= clouds[open('/etc/poolparty/cloud_name').read].nodes
+    end
+    
+    def get_hello(_n=nil)
+      'hi there'
+    end
+    
     def my_ip
       @my_ip ||= ohai["ipaddress"]
     end
 
-    def ohai
+    def ohai(_n=nil)
       @ohai ||= JSON.parse(%x[ohai])
     end
 
     def reload_data!
       @stats[my_ip] = {}
       instances.each {|inst| @stats[inst] = {} }
+    end
+    
+    # Our cloud.dsl_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
+    def make_aska_rules(rules)
+      rules.each do |name, rul|
+        r = Aska::Rule.new(rul)
+        rule(name) << r
+      end
     end    
     
   end

data/lib/poolparty/net/init.rb

@@ -1,11 +1,16 @@
-# Load the core net libraries.  These are neccessary for any of the remoter_bases to function.
-%w(remote_instance messenger remote_bases remoter_base).each do |file|
-  require File.join(::File.dirname(__FILE__),file+'.rb')
+class Object
+  #TODO: deprecate. use RemoterBase.available_bases instead
+  def remote_bases
+    PoolParty::Remote.available
+  end
 end
 
-# Register available remoter_bases
-Dir["#{::File.dirname(__FILE__)}/remoter_bases/*/*.rb"].each do |base| 
-  name = File.join(::File.basename(base, ::File.extname(base)))
+# Load the core net libraries.
+# These are neccessary for any of the remoter_bases to function.
+require ::File.join(::File.dirname(__FILE__),'remoter_base.rb')
+require ::File.join(::File.dirname(__FILE__),'remote_instance.rb')
+
+Dir["#{::File.dirname(__FILE__)}/remoter_bases/*/*.rb"].each do |base|
+  name = ::File.basename(base, ::File.extname(base))
   require base
-  register_remote_base name
 end

data/lib/poolparty/net/remote_instance.rb

@@ -4,106 +4,90 @@ module PoolParty
     class RemoteInstance
       include Dslify
       
-      def initialize(opts={}, containing_cloud=nil)
-        @parent = containing_cloud
-
-        set_vars_from_options(containing_cloud.options) if containing_cloud && containing_cloud.respond_to?(:options)
+      dsl_methods :name,        # Name of the remote instance (internal usage)
+                  :ip,          # Ip of the remote instance
+                  :internal_ip, # Internal ip of the remote instance
+                  :public_ip,
+                  :status,       # Status of the remote instance
+                  :launch_time,
+                  :keypair_name
+      
+      def initialize(opts={})
+        opts.choose{|k,v| dsl_options.has_key? k}
         set_vars_from_options(opts) if opts.is_a?(Hash)
         on_init
       end
       
-      def elapsed_runtime
-        Time.now.to_i - launching_time.to_time.to_i
+      ## hash like methods
+      # TODO: move these into a module, or into dslify
+      # include Enumerable
+      def each
+        dsl_options.each{ |k,v| yield k,v }
       end
       
-      # Callback
-      def on_init
+      def [](k)
+        if dsl_options.has_key? k
+          dsl_options[k]
+        else
+          nil
+        end
       end
       
-      # Is this remote instance the master?
-      # DEPRECATE
-      def master?
-        name == "master"
+      def []=(k,v)
+        dsl_options[k] = v
       end
       
-      # The remote instances is only valid if there is an ip and a name
-      def valid?
-        (ip.nil? || name.nil?) ? false : true
+      def has_key?(key)
+        dsl_options.has_key?(key)
       end
       
-      # Determine if the RemoteInstance is responding
-      def responding?
-        running?
-        # !responding.nil? #TODO MF this needs to actually ping the node or something similar.  stubbed to running? for now
+      def keys
+        dsl_options.keys
       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  #NOTE MF: returning 0.0 seems like a bad idea here.  should return nil if we dont have a real value
+         
+      def values
+        dsl_options.values
       end
+      ##end of hash like methods
       
-      # Note, the next 4 methods will be overridden by the cloud specific remoter_base
       # Is this instance running?
       def running?
-        true
+        !(status =~ /running/).nil?
       end
       # Is this instance pending?
       def pending?
-        false
+        !(status =~ /pending/).nil?
       end
       # Is this instance terminating?
       def terminating?
-        false
+        !(status =~ /shutting/).nil?
       end
       # Has this instance been terminated?
       def terminated?
-        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 rescue ""}"
+        !(status =~ /terminated/).nil?
       end
       
-      # Class method to disect a neighborhood line
-      def self.hash_from_s(s)
-        arr = s.split("\t")
-        {:name => arr[0], :ip => arr[1]}
+      def elapsed_runtime
+        Time.now.to_i - launching_time.to_time.to_i
       end
       
-      def self.to_s(hsh)
-        new(hsh).to_s
+      # Callback
+      def on_init
       end
       
-      #TODO: Diet the next 5 commands
-      def dependency_resolver_command
-        cloud.dependency_resolver_command
+      # The remote instances is only valid if there is an ip and a name
+      def valid?
+        (ip.nil? || name.nil?) ? false : true
       end
       
-      #FIXME: deprecate puppet specific commands in this class
-      def puppet_runner_command
-        self.class.send :puppet_runner_command
-      end
-      # Commands for the servers
-      def self.puppet_runner_command
-        ". /etc/profile && puppetrunner"
-      end
-      def self.puppet_master_rerun_command
-        ". /etc/profile && puppetrerun"
-      end
-      def self.puppet_rerun_commad
-        puppet_runner_command
+      # 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  #NOTE MF: returning 0.0 seems like a bad idea here.  should return nil if we dont have a real value
       end
-      #
       
-      def hosts_file_listing_for(cl)
-        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

@@ -11,179 +11,6 @@ module PoolParty
     def are_too_many_instances_running?
       nodes(:status => "running").size > maximum_instances.to_i
     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
 
     def list_of_nodes_exceeding_minimum_runtime
       nodes(:status => "running").reject{|i| i.elapsed_runtime < minimum_runtime}
@@ -192,10 +19,6 @@ module PoolParty
     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?
-      !nodes(:status => "running").select {|a| a.name == "master"}.first.nil?
-    end    
     
   end
 end

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

@@ -1,4 +1,3 @@
-require "#{::File.dirname(__FILE__)}/../../modules/pinger"
 require 'rubygems'
 require 'net/ssh'
 
@@ -10,7 +9,7 @@ module PoolParty
     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
@@ -23,9 +22,10 @@ module PoolParty
       netssh hst, cmds
     end
     
-    def ssh_into(inst, extra_ssh_ops={} )
+    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}")
+      cmd = extra_ssh_ops.delete(:cmd) if extra_ssh_ops.has_key?(:cmd)
+      Kernel.system("ssh #{ssh_options(extra_ssh_ops)} #{ip}%s" % [cmd ? " #{cmd}" : ""])
     end
     
     def ssh_options(opts={})
@@ -35,19 +35,20 @@ module PoolParty
            }.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
-   
+    
+    # Run commands on the local machine, i.e. your laptop, not the server
     def run_local(commands)
       commands.each do |cmd|
         puts `#{cmd}`
       end
     end
-
+    
     def commands
       @commands ||= Array.new
     end
@@ -61,16 +62,20 @@ module PoolParty
     end
     
     def netssh(cmds=[], opts={})
-      user = opts.delete(:user) || user #rescue 'root'
+      user = opts.delete(:user) || 'root' #user rescue 'root'
       host = opts.delete(:host) || target_host
-      ssh_options_hash = {:keys => [keypair.full_filepath],
+      ssh_options_hash = {:keys         => [keypair.full_filepath],
                           :auth_methods => 'publickey',
-                          :paranoid => false
+                          :paranoid     => false,
+                          :timeout      => 3.minutes,
+                          :user         => user
                            }.merge(opts)
-      
-      # Start the connection
-      Net::SSH.start(host, user, ssh_options_hash) do |ssh|  
+      # ssh_options_hash[:verbose]=:debug if debugging?
+      puts "connecting to ssh with options = #{ssh_options_hash.inspect}"
+
+      Net::SSH.start(host, user, ssh_options_hash) do |ssh|
         cmds.each do |command|
+          $stderr.print command if debugging
           ssh.exec!(command) do |ch, stream, data|
             if stream == :stdout
              print data
@@ -83,7 +88,7 @@ module PoolParty
     end
     
     
-##########################################################################################################   
+##########################################################################################
 # TODO: Delete deprecated commands below here
     
     def rsync_storage_files_to_command(remote_instance)