auser-poolparty 1.2.12 → 1.3.0

data/lib/poolparty/monitors/monitor_rack.rb

@@ -1,137 +0,0 @@
-=begin rdoc
-  MonitorRack is a rack application that maps url requests to method calls on Monitor classes.
-=end
-
-require ::File.dirname(__FILE__)+"/../aska"
-require ::File.dirname(__FILE__)+"/../lite"
-require ::File.dirname(__FILE__)+"/base_monitor"
-require ::File.dirname(__FILE__)+"/monitor_daemon"
-
-require 'rubygems'
-require 'rack'
-require 'json'
-
-# 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
-
-  class MonitorRack
-    
-    
-    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']) || []
-        verb = env['REQUEST_METHOD'].downcase
-        
-        new_body = map_to_method(path_array, verb)
-        new_body = new_body.to_json unless (!path_array || path_array.empty? || path_array[0].nil?)
-        
-        @response.write new_body
-        setup_callbacks
-        
-      # rescue Exception=>e
-      #   @response.write e
-      #   @response.status = 500
-      end
-      @response.finish # this is [response.status, response.headers, response.body]
-    end
-    
-    private
-    def setup_callbacks
-      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
-    end
-    def instance
-      return nil if path_map.nil?
-      @instance ||= constantize( path_map.first ).new(env)
-    end
-    
-    def env
-      @env
-    end
-    def response
-      @response
-    end
-    def request
-      @request
-    end
-    
-    # Split the request path into an array
-    def path_map(requested_path=env['REQUEST_PATH'])
-      requested_path.split('.')[0].split('/')[1..-1]
-    end
-    
-    def html_list
-      str = "<h1>Available Monitors</h1><br /><ul>"
-      ::Monitors.available.each do |monitor|
-        str<< "<li><a href=/#{monitor.to_s.split('::').pop}>#{monitor}</a></li>"
-      end
-      str << "</ul>"
-      str
-    end
-    
-    # Find class and call method from the pattern /class_name/method/args
-    # 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?
-        html_list
-      else
-        raise "#{path[0]} did not map to a Constant" if !instance
-        case path.size
-        when 1 # example: /stats
-          instance.send(verb.to_sym, @data)
-        when 2 # example: /stats/load
-          instance.send("#{verb}_#{path[1]}".to_sym, @data) rescue instance.send("#{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 == camelcase(name)}
-        base_object.module_eval const
-      rescue Exception => e
-        puts "#{name.camelcase} is not defined. #{e}"
-        nil
-      end
-    end
-    
-    def camelcase(str)
-      str.gsub(/(^|_|-)(.)/) { $2.upcase }
-    end
-  
-  end
-  
-end

data/lib/poolparty/monitors/monitors/clock_monitor.rb

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

data/lib/poolparty/monitors/monitors/cloud_monitor.rb

@@ -1,34 +0,0 @@
-=begin rdoc
-  Cloud monitor just is a test monitor to hold cloud info
-=end
-
-module Monitors
-  
-  class Cloud < BaseMonitor
-    
-    def get(_unused=nil)
-      <<-EOE
-        #{my_cloud.name}
-        #{my_cloud.minimum_instances}..#{my_cloud.maximum_instances}
-      EOE
-    end
-    
-    def nominations(_unused=nil)
-      running_nodes = my_cloud.nodes(:status => "running")
-      nominations = []
-      running_nodes.each do |node|
-        timeout(10) do
-          log "Checking with #{node.internal_ip} for nominations: #{open("http://#{node.internal_ip}:8642/stats/get_nominations").read}"
-          nominations << begin
-            JSON.parse(open("http://#{node.internal_ip}:8642/stats/nominations").read) || "none"
-          rescue
-            log "Error when connecting to #{node.internal_ip}: #{e.inspect}"
-            "none"
-          end
-        end
-      end.histogram
-    end
-    
-  end
-  
-end

data/lib/poolparty/monitors/monitors/elections_monitor.rb

@@ -1,76 +0,0 @@
-module Monitors
-  class Elections < BaseMonitor
-    
-    # these are the rules that define the 
-    # elected actions
-    def self.candidates
-      {
-        :expand => :contract,
-        :contract => :expand,
-        :configure => nil,
-        :none => nil
-      }
-    end
-    
-    def get(data=nil)
-      'hello'
-    end
-    
-    def put(data=nil)
-      elections = JSON.parse(data)
-      log "Received #{elections.histogram.inspect} in Elections Monitor"
-      handle_election(elections.histogram)
-    end
-        
-    def count_ballots(ballots={}, candidates={:expand => 0, :contract => 0})
-      # Ballots look like:
-      # {host => ["contract"]}
-      # Count the number of nominations for each candidate action
-      candidates.each do |action, ballots|
-         stats.each do |ip, node_hsh|
-           if node_hsh["nominations"] && node_hsh["nominations"].include?(action.to_s)
-             candidates[action]+=1
-           end
-         end
-       end
-      candidates
-    end
-    
-    # Handle the elections
-    # ballots: {"contract" => 1, "expand" => 4}
-    def handle_election(ballots={})      
-      # 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      
-      log "handle_election: #{ballots.inspect}"
-      ballots.symbolize_keys!
-      total_votes = ballots.inject(0) {|total, arr| total += arr[1] }
-            
-      ballots.each do |ballot, pro_votes|        
-        contra = self.class.candidates[ballot]
-        con_votes = ballots[contra] || 0
-        
-        if (pro_votes - con_votes)/total_votes > 0.5
-          return run_elected_action(ballot)
-        end
-      end
-    end
-    
-    def run_elected_action(ballot)
-      log "Electing #{ballot}"
-      case ballot
-      when :expand
-        my_cloud.running_action = :expanding
-        my_cloud.launch_instance!(:cloud_name => my_cloud.name)
-        my_cloud.running_action = nil
-      when :contract        
-        my_cloud.running_action = :contracting
-        my_cloud.terminate_youngest_instance!
-        my_cloud.running_action = nil
-      else
-        "none"
-      end
-    end
-  
-  end
-end

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

@@ -1,12 +0,0 @@
-=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,9 +0,0 @@
-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 +0,0 @@
-# module PoolParty
-  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

@@ -1,80 +0,0 @@
-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)
-      reset!
-      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(_n=nil)
-      @instances ||= ::PoolParty::Neighborhoods.load_default.instances #.to_hash #[:instances]
-    end
-    def stats(_n=nil)
-      @stats ||= ::PoolParty::Neighborhoods.load_default.stats rescue Stats.new(@env).get
-    end
-    def reset!
-      @neighborhood = @stats = nil
-    end
-  end
-end

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

@@ -1,206 +0,0 @@
-=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 )
-        # @cloud = ::PoolParty::Cloud::Cloud.load_from_json(open('/etc/poolparty/clouds.json' ).read)
-      rescue 
-        @cloud = ::PoolParty::Default.dsl_options.merge({"options" =>
-          {"rules" => {"expand"   => PoolParty::Default.expand_when,
-                       "contract" => PoolParty::Default.contract_when
-                      }
-          }
-        })        
-      end
-      make_aska_rules(@cloud["options"]["rules"])
-    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}".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
-      else
-        "boom"
-      end
-    end
-    alias :update :put
-    
-    protected
-    
-    # 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
-      # Check to make sure an elected action is not already in progress
-      if (candidates[:expand] - candidates[:contract])/stats.keys.size > 0.5
-        %x[server-cloud-elections expand] unless elected_action == "expand"
-        @elected_action = "expand"
-      elsif (candidates[:contract] - candidates[:expand])/stats.keys.size > 0.5
-        %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"
-      stats.to_json
-    end
-
-    def elected_action(_n=nil)
-      @elected_action ||= nil
-    end
-
-    def rules(_n=nil)
-      @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(_n=nil)
-      @stats ||= {my_ip  => {}}
-    end
-
-    def load(_n=nil)
-      %x{"uptime"}.split[-3].to_f
-    end
-
-    def instances(_n=nil)
-      my_cloud.nodes(:status => "running")
-    end
-
-    def can_expand?(_n=nil)
-      instances.size < max_instances
-    end
-
-    def can_contract?(_n=nil)
-      instances.size > min_instances
-    end
-
-    def min_instances(_n=nil)
-      (my_cloud.minimum_instances || PoolParty::Default.minimum_instances).to_i
-    end
-
-    def max_instances(_n=nil)
-      (my_cloud.maximum_instances || PoolParty::Default.maximum_instances).to_i
-    end
-
-    def nominations(_n=nil)
-      # return ['expand'] if instances.size<min_instances
-      load = stats[my_ip]["load"] ||= self.send(:load)
-      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)
-            # 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 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(_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
-end

data/lib/poolparty/net/init.rb

@@ -1,16 +0,0 @@
-class Object
-  #TODO: deprecate. use RemoterBase.available_bases instead
-  def remote_bases
-    PoolParty::Remote.available
-  end
-end
-
-# 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
-end