fairchild-poolparty 1.1.4 → 1.1.5

data/lib/poolparty/monitors/base_monitor.rb

@@ -1,81 +1,32 @@
-# =begin rdoc
-#   Monitor class
-#   
-#   Monitors are the basis for PoolParty scaling. Your cloud will expand and
-#   contract against these monitors. You can set your cloud to be monitored by these
-#   monitors simply by using them in the contract_when and the expand_when macros 
-#   on your cloud like so:
-#   
-#     expand_when "cpu > 1.2", "memory > 0.94"
-#     contract_when "cpu < 0.4", "memory < 0.3"
-#   
-#   You can also add your own monitors simply by creating a directory in the same
-#   directory as the pool spec (the same directory as the plugin directory exists) and
-#   placing your monitor file (format: [monitorname]_monitor.rb) there.
-#   
-#   Monitors are simply classes of the name of the monitor. They subclass the BaseMonitor
-#   class from PoolParty. A sample monitor would look similar to:
-#     
-#     class SampleMonitor < PoolParty::Monitors::BaseMonitor
-#       def run
-#       end
-#     end
-#     register_monitor :sample
-#   
-#   The monitor class must have an instance level method called run. This method is called when 
-#   the cloud is checking the monitor. The output of this method should be the output of
-#   the monitor.
-#   
-#   Notice that at the end, you must call register_monitor :monitorname. This will tell your cloud
-#   that it can monitor it with this monitor.
-# =end
-# require "#{::File.dirname(__FILE__)}/../poolparty/default"
-# 
-# module PoolParty
-#   module Monitors    
-#     
-#     module ClassMethods
-#     end
-#     
-#     module InstanceMethods
-#       def expand_when(*arr)
-#         @expand_when ||= ((arr && arr.empty?) ? options[:expand_when] : configure(:expand_when => self.class.send(:rules,:expand_when,arr,false)))
-#       end
-#       
-#       def contract_when(*arr)
-#         @contract_when ||= ((arr&&arr.empty?) ? options[:contract_when] : configure(:contract_when => self.class.send(:rules,:contract_when,arr,false)))
-#       end
-#     end
-#     
-#     def self.register_monitor(*args)
-#       args.each do |arg|
-#         (available_monitors << "#{arg}".downcase.to_sym unless available_monitors.include?("#{arg}".downcase.to_sym))
-#         
-#         InstanceMethods.module_eval "def #{arg}; @#{arg} ||= get_live_#{arg}; end"
-#         InstanceMethods.module_eval "def get_live_#{arg}; messenger_send!(\"get_current_load #{arg}\").to_f rescue -1.0; end"
-#       end
-#     end
-# 
-#     def self.available_monitors
-#       $available_monitors ||= []
-#     end
-#     
-#     class BaseMonitor
-#       def self.run
-#         new.run
-#       end
-#     end
-#     
-#     def self.included(receiver)
-#       receiver.extend                 PoolParty::Monitors::ClassMethods      
-#       receiver.send :include,         PoolParty::Monitors::InstanceMethods
-#       receiver.send :include,         Aska
-#     end
-#     
-#   end
-# end
-# 
-# # Require included monitors
-# Dir["#{File.dirname(__FILE__)}/monitors/*.rb"].each {|f| require f}
-# # Require custom monitors
-# Dir["#{PoolParty::Default.custom_monitor_directories}/*.rb"].each {|f| require f}
+=begin rdoc
+  BaseMonitor
+  
+  BaseMonitor adds a basic base monitor with callbacks for the 
+  monitors
+=end
+module Monitors
+  class BaseMonitor
+    
+    def initialize(env=nil)
+      @env=env
+    end
+    
+    %w(close).each do |event|
+      %w(before after).each do |time|
+        module_eval <<-EOE
+        def #{time}_#{event}(m=nil, &block)
+          #{time}_#{event}_callbacks << block ? block : m.to_sym
+        end
+        EOE
+      end
+      
+    end
+    
+    def before_close_callbacks
+      @before_close_callbacks ||= []
+    end
+    def after_close_callbacks
+      @after_close_callbacks ||= []
+    end
+  end
+end

data/lib/poolparty/monitors/monitor_rack.rb

@@ -1,48 +1,57 @@
-require ::File.dirname(__FILE__)+"/../aska/aska.rb"
-require ::File.dirname(__FILE__)+"/../lite.rb"
+=begin rdoc
+  MonitorRack is a rack application that maps url requests to method calls on Monitor classes.
+=end
+
+require ::File.dirname(__FILE__)+"/../aska/aska"
+require ::File.dirname(__FILE__)+"/../lite"
+require ::File.dirname(__FILE__)+"/base_monitor"
 
 require 'rubygems'
 require 'rack'
 require 'json'
 
-class String
-  def camelcase
-    gsub(/(^|_|-)(.)/) { $2.upcase }
+# We add an after hook to Rack::Response so that we can initiate a connection after 
+# The response is sent back to client.
+# PoolParty uses this to update a value, and then pass it on to another node.
+class Rack::Response
+  %w(close).each do |event|
+    module_eval "def before_#{event}_callbacks;@before_#{event}_callbacks ||= [];end"
+    module_eval "def after_#{event}_callbacks;@after_#{event}_callbacks ||= [];end"
+  end
+  
+  def close
+    before_close_callbacks.flatten.each {|a| a.call }
+    body.close if body.respond_to?(:close)
+    after_close_callbacks.flatten.each {|a| a.call }
   end
+  
 end
 
+Dir[::File.dirname(__FILE__)+"/monitors/*"].each {|m| require m}
+# PoolParty.require_user_directory "monitors"
+
 module Monitors
-  
-  # def self.call(env)
-  #   @request = Rack::Request.new(env)
-  #   @response = Rack::Response.new
-  #   begin
-  #     response.write map_to_class_method(path_map(env)).to_json
-  #   rescue Exception=>e
-  #     @response.write e
-  #     @response.status = 500
-  #   end
-  #   @response.finish # [response.status, response.headers, response.body]
-  # end
 
   class MonitorRack
     
-    def new(opts={})
-      @opts=opts
-    end
     
     def call(env)
-      dup._call(env)
-    end
-    
-    def _call(env)
       @env = env
+      @data = env['rack.input'].read rescue nil
       @request = Rack::Request.new env
       @response = Rack::Response.new
+      @instance = nil
       begin
         path_array= path_map(env['REQUEST_PATH']) || []
-        puts "-- trying to map #{path_array.inspect}"
-        @response.write map_to_class_method(path_array).to_json
+        verb = env['REQUEST_METHOD'].downcase
+        @response.write map_to_method(path_array, verb).to_json
+        
+        if instance.respond_to? :before_close_callbacks
+          @response.before_close_callbacks << instance.before_close_callbacks
+        end
+        if instance.respond_to?(:after_close_callbacks)
+          @response.after_close_callbacks << instance.after_close_callbacks
+        end
       # rescue Exception=>e
       #   @response.write e
       #   @response.status = 500
@@ -50,6 +59,11 @@ module Monitors
       @response.finish # this is [response.status, response.headers, response.body]
     end
     
+    private
+    def instance
+      @instance ||= constantize( path_map.first ).new(env)
+    end
+    
     def env
       @env
     end
@@ -60,73 +74,50 @@ module Monitors
       @request
     end
     
-    def path_map(requested_path)
+    # Split the request path into an array
+    def path_map(requested_path=env['REQUEST_PATH'])
       requested_path.split('.')[0].split('/')[1..-1]
     end
   
     # Find class and call method from the pattern /class_name/method/args
-    def map_to_class_method(path)
+    # GET /neighborhood => ::Monitors::Neighboorhood.get
+    # POST /neighborhood => ::Monitors::Neighboorhood.post(params)
+    # GET /neighborhood/size => ::Monitors::Neighboorhood.get_size
+    def map_to_method(path, verb='get')
       if !path or path.empty? or path[0].nil?
         response.write 'cannot map an empty path' 
         response.status='404'
       else
-        klass = constantize(path[0])
-        raise "#{path[0]} did not map to a Constant" if !klass
+        raise "#{path[0]} did not map to a Constant" if !instance
         case path.size
-        when 0
-          self.respond_to?(:default) ? self.send(:default) : response.status='404'
-        when 1
-          klass.send(:default) rescue klass.new(env).send(:default)
-        when 2
-          klass.send(path[1].to_sym) rescue klass.new(env).send(path[1].to_sym)
-        else
-          klass.send(path[1].to_sym, *path[2..-1])
+        when 0 # usefull if you want to subclass from MonitorRack
+          self.respond_to?(verb.to_sym) ? self.send(verb.to_sym) : response.status='404'
+        when 1 # example: /stats
+          instance.send(verb.to_sym, @data)
+        when 2 # example: /stats/load
+          instance.send("#{verb}_#{path[1]}".to_sym, @data)
+        else # example: /stats/load/average/5/minutes
+          instance.send("#{verb}_#{path[1]}".to_sym, env['rack.input'].read, *path[2..-1])
         end
       end
     end
     
+    # Take a string and return a ruby object if a match is found in the base_objects namespace.
     def constantize(name, base_object=Monitors)
       begin
-        const = base_object.constants.find{|cnst| cnst == name.camelcase}
+        const = base_object.constants.find{|cnst| cnst == camelcase(name)}
         base_object.module_eval const
       rescue Exception => e
         puts "#{name.camelcase} is not defined. #{e}"
         nil
       end
     end
-  
-    def default
-      'default response'
+    
+    def camelcase(str)
+      str.gsub(/(^|_|-)(.)/) { $2.upcase }
     end
   
   end
   
-  # Base monitor
-  class MonitorBase
-    def initialize(env={})
-      @env = env
-    end
-  end
-  
-  #load our monitors
-  require ::File.dirname(__FILE__)+"/stats_monitor.rb"
-  require ::File.dirname(__FILE__)+"/neighborhood_monitor.rb"
-  
 
-  # just here as an example
-  # access it at /monitor_time/ or /monitor_time/now
-  class MonitorTime
-    def self.default
-      now
-    end
-    def self.now
-      Time.now
-    end
-  end
-  
-  class Favicon < MonitorBase
-    def self.default
-      ''
-    end
-  end
 end

data/lib/poolparty/monitors/monitors/favicon_monitor.rb

@@ -0,0 +1,12 @@
+=begin rdoc
+  Simple dummy monitor to return a blank response to favicon requests.
+=end
+module Monitors
+  
+  class Favicon < BaseMonitor
+    def get(data=nil)
+      ''
+    end
+  end
+  
+end

data/lib/poolparty/monitors/monitors/load_monitor.rb

@@ -1,15 +1,9 @@
-# module PoolParty
-#   module Monitors
-#     
-#     class LoadMonitor < BaseMonitor
-#       
-#       def run
-#         stdout = %x[uptime]
-#         stdout.split(/\s+/)[-1].to_f rescue 0.0
-#       end
-#             
-#     end
-#     
-#     register_monitor :cpu
-#   end
-# end
+module Monitors
+  
+  class Load < BaseMonitor
+    def get(data=nil)
+      %x{"uptime"}.split[-3].to_f
+    end
+  end
+  
+end

data/lib/poolparty/monitors/monitors/memory_monitor.rb

@@ -1,50 +1,50 @@
 # module PoolParty
-#   module Monitors
-#     
-#     class MemoryMonitor < BaseMonitor
-#       
-#       def run
-#         uname = %x[uname]
-#         case uname.chomp
-#         when "Darwin"
-#           darwin_memory_usage
-#         else
-#           nix_memory_usage
-#         end                
-#       end
-#       
-#       def darwin_memory_usage
-#         str = %x[vm_stat]
-#         keep_array = []
-#         array_of_strings = str
-#         begin
-#           free_memory = array_of_strings[/free:(\W*)+([0-9]+)/, 2].to_f
-#           active_memory = array_of_strings[/active:(\W*)([0-9]+)/, 2].to_f
-#           inactive_memory = array_of_strings[/inactive:(\W*)([0-9]+)/, 2].to_f
-# 
-#           used_memory = (active_memory + inactive_memory)
-#           total_memory = (free_memory + active_memory + inactive_memory)
-# 
-#           used_memory / total_memory
-#         rescue Exception => e
-#           0.0
-#         end                 
-#       end
-#       
-#       def nix_memory_usage
-#         str = %x[free -m | grep -i mem]
-#         begin
-#           total_memory = str.split[1].to_f
-#           used_memory = str.split[2].to_f
-# 
-#           used_memory / total_memory
-#         rescue Exception => e
-#           0.0
-#         end
-#       end
-#             
-#     end
-#     
-#     register_monitor :memory
-#   end
+  module Monitors
+    
+    class Memory < BaseMonitor
+      
+      def get(data=nil)
+        uname = %x[uname]
+        case uname.chomp
+        when "Darwin"
+          darwin_memory_usage
+        else
+          nix_memory_usage
+        end
+      end
+      
+      private
+      
+      def darwin_memory_usage
+        str = %x[vm_stat]
+        keep_array = []
+        array_of_strings = str
+        begin
+          free_memory = array_of_strings[/free:(\W*)+([0-9]+)/, 2].to_f
+          active_memory = array_of_strings[/active:(\W*)([0-9]+)/, 2].to_f
+          inactive_memory = array_of_strings[/inactive:(\W*)([0-9]+)/, 2].to_f
+
+          used_memory = (active_memory + inactive_memory)
+          total_memory = (free_memory + active_memory + inactive_memory)
+
+          used_memory / total_memory
+        rescue Exception => e
+          0.0
+        end
+      end
+      
+      def nix_memory_usage
+        str = %x[free -m | grep -i mem]
+        begin
+          total_memory = str.split[1].to_f
+          used_memory = str.split[2].to_f
+
+          used_memory / total_memory
+        rescue Exception => e
+          0.0
+        end
+      end
+
+    end
+  end
 # end

data/lib/poolparty/monitors/monitors/neighborhood_monitor.rb

@@ -0,0 +1,77 @@
+require ::File.dirname(__FILE__)+"/../../core/hash.rb"
+require ::File.dirname(__FILE__)+"/../../core/array.rb"
+require "#{::File.dirname(__FILE__)}/../../poolparty/neighborhoods"
+require 'rest_client'
+
+module Monitors
+  
+  class Neighborhood < BaseMonitor
+    
+    def get(data=nil)
+      neighborhood
+    end
+    
+    def put(data, from=nil)
+      @neighborhood_instances = merge_array_of_hashes_with_key(neighborhood.instances, JSON.parse(data), 'ip')
+      @neighborhood = {@neighborhood[:instances] => @neighborhood_instances}
+      after_close do
+        if @neighborhood.instances.size>1
+          # TODO: Add logger here
+          puts "Pinging #{"#{@neighborhood.instances.rand.ip}/neighborhood"}"
+          RestClient.put "#{@neighborhood.instances.rand.ip}/neighborhood", @neighborhood, :content_type => 'text/x-json'
+        end
+      end
+      save
+    end
+    
+    def post(data)
+      received = JSON.parse(data)
+      @neighborhood = JSON.parse(data)
+      save
+    end
+    
+    private
+    def myself
+      @myself ||= @neighborhood.instance.select_with_hash('ip'=>@env['REQUEST_IP'])
+    end
+    
+    def neighborhood
+      @neighborhood ||= {        
+        :instances => instances,
+        :stats => stats
+      } #rescue [{"instance_id"=>"1000", "ip"=>"172.16.68.128"}, {"instance_id"=>"456", "ip"=>"172.16.68.130"}]
+    end
+    
+    def save(filepath='/etc/poolparty/neighborhood.json')
+      puts "\n---\n#{neighborhood.to_json}\n---\n"
+      ::File.open(filepath, "w") {|f| f << neighborhood.to_json }
+      neighborhood
+    end
+    
+    # Take two arrays of hashes and merge them based on a common key.  
+    # For example:
+    # a1=[{:a=>'a'}, {'tt'=>5}]
+    # a2= [{:a=>'a', :new=>'stuff'}, {'c'=>'C'}]
+    # will merge to: [{:a=>"a", :new=>"stuff"}, {"tt"=>5}, {"c"=>"C"}]
+    def merge_array_of_hashes_with_key(arr1, arr2, key)
+      ar1=arr1.dup
+      ar2= arr2.dup
+      first_pass = ar1.collect{|h1|
+        found = ar2.detect{|hsh|
+           hsh.has_key?(key) && hsh[key]==h1[key] && ar2.delete_at(ar2.index(hsh))
+        }
+        found ? found : h1
+      }
+      first_pass + ar2
+    end
+    
+    # HELPERS
+    def instances
+      @instances ||= ::PoolParty::Neighborhoods.load_default.instances.to_hash[:instances]
+    end
+    def stats
+      @stats ||= ::PoolParty::Neighborhoods.load_default.stats rescue Stats.new(@env).get
+    end
+    
+  end
+end

data/lib/poolparty/monitors/{stats_monitor.rb → monitors/stats_monitor.rb}

@@ -1,8 +1,11 @@
-require ::File.dirname(__FILE__)+"/monitor_rack.rb"
+=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
+  
+  class Stats < BaseMonitor
     attr_reader :stats, :request
     attr_accessor :response
     
@@ -14,36 +17,26 @@ module Monitors
       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
+        @cloud = ::PoolParty::Default.options.merge({"options" =>
+          {"rules" => {"expand"   => PoolParty::Default.expand_when,
+                       "contract" => PoolParty::Default.contract_when
                       }
           }
         })
-      end      
+      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
-      # So later, we can call vote_rules on ourself and we'll get back Aska::Rule(s)
+      # 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"
+      # log << "#{::Time.now.strftime("%Y-%m-%d-%H-%M")}, #{stats.to_json}\n"
     end
     
-    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
-    
-    def default      
+    def get(data=nil)
       begin
         if !request.params || request.params.empty?
           default_stats
@@ -56,8 +49,8 @@ module Monitors
         "Error: #{e}"
       end
     end
-
-    def put
+    
+    def put(data)
       if d = JSON.parse(request.params)
         hsh = d.reject {|ip, _node| ip == my_ip }
         stats.merge!(hsh)
@@ -67,7 +60,19 @@ module Monitors
       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:

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/messenger.rb

@@ -1,3 +1,5 @@
+# TODO: Deprecate this file
+
 =begin rdoc
   The connection to the messenger from poolparty, the client.