fairchild-poolparty 1.1.5 → 1.2.12

data/lib/poolparty/modules/searchable_paths.rb

@@ -0,0 +1,100 @@
+module PoolParty
+  # Abstracts out the searchable path for a resource such as a
+  # template file, key, or clouds.rb
+  #
+  # NOTE: this is currently _only_ implemented on templates
+  # (PoolParty::Resources::File) and not yet working on clouds.rb or key files.
+  # These will eventually be refactored to use this class.
+  module SearchablePaths
+    def self.included(mod)
+      mod.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Specify that a particular class has methods for searchable paths.
+      # 
+      # Options:
+      # * <tt>:dirs</tt>: array of directories to look in *under* the search paths. (default: <tt>["/"]</tt>)
+      # * <tt>:dir</tt>: set the directory to look in *under* the search paths. Use either dir or dirs, not both. (default: +/+)
+      # * <tt>:paths</tt>: overwrite all default paths and set the paths to this array exactly
+      # * <tt>:append_paths</tt>:  append these paths to any existing paths
+      # * <tt>:prepend_paths</tt>: prepend these paths to any existing paths
+      def has_searchable_paths(opts={})
+        class_eval do
+          extend PoolParty::SearchablePaths::SingletonMethods
+
+          @searchable_paths_dirs = [opts[:dir]] if opts[:dir]
+          @searchable_paths_dirs = opts[:dirs]  if opts[:dirs]
+          @paths_override        = opts[:paths] if opts[:paths]
+          @paths_prepend         = opts[:prepend_paths] || []
+          @paths_append          = opts[:append_paths]  || []
+        end
+        include PoolParty::SearchablePaths::InstanceMethods
+      end
+    end
+
+    module SingletonMethods
+      def searchable_paths_dir;  @searchable_paths_dirs.first; end
+      def searchable_paths_dirs
+        @searchable_paths_dirs && @searchable_paths_dirs.size > 0 ? @searchable_paths_dirs : ["/"]
+      end
+     
+      # The default paths are primarily defined in PoolParty::Default. These are the default search paths in order:
+      # 
+      # * current working directory (Dir.pwd)
+      # * ~/.poolparty
+      # * ~/.ec2
+      # * /etc/poolparty
+      # * /var/poolparty
+      def default_paths
+        @default_searchable_paths ||= [
+          Dir.pwd,
+          PoolParty::Default.poolparty_home_path,
+          PoolParty::Default.base_keypair_path,
+          PoolParty::Default.poolparty_src_path,
+          PoolParty::Default.poolparty_src_path/:lib/:poolparty,
+          PoolParty::Default.base_config_directory,
+          PoolParty::Default.remote_storage_path
+        ]
+      end
+
+      def add_searchable_path(path)
+        default_paths # instantiate @default_searchable_paths
+        @default_searchable_paths << path
+      end
+
+      # returns the full set of valid searchable paths, given the options
+      def searchable_paths
+        return @paths_override if @paths_override && @paths_override.size > 0
+        @paths_prepend + default_paths + @paths_append
+      end
+    end
+
+    module InstanceMethods
+
+      # Searches for +filepath+ in the <tt>searchable_paths</tt> iff +filepath+
+      # doesn't exist. e.g. +filepath+ is interpreted *first* as an absolute
+      # path, if +filepath+ doesn't exist verbatim then it looks for the file
+      # in the searchable_paths.
+      # 
+      # Returns +nil+ if the file cannot be found.
+      def search_in_known_locations(filepath, additional_search_paths=[])
+        return filepath if ::File.exists?(filepath) # return the file if its an absolute path
+        additional_search_paths.each do |path|
+          full_path = ::File.expand_path(path / filepath)
+          return full_path if ::File.exists?(full_path)
+        end
+        self.class.searchable_paths.each do |path|
+          self.class.searchable_paths_dirs.each do |dir|
+            full_path = ::File.expand_path(path / dir / filepath)
+            return full_path if ::File.exists?(full_path)
+          end
+        end
+        nil
+      end
+      alias_method :find_file, :search_in_known_locations
+
+    end
+
+  end
+end

data/lib/poolparty/modules/user_helpers.rb

@@ -12,7 +12,7 @@ module PoolParty
   # Add to the suitcase files below the clouds.rb base directory
   def pack_user_directory(dirname)
     begin
-      ::Suitcase::Zipper.add("#{::File.dirname($pool_specfile)}/#{dirname}", "etc")
+      ::Suitcase::Zipper.add("#{::File.dirname($pool_specfile)}/#{dirname}", "/etc/poolparty")
     rescue Exception => e
       vputs "Error packing user directory #{dirname}: #{e}"
     end    

data/lib/poolparty/monitors/base_monitor.rb

@@ -5,10 +5,35 @@
   monitors
 =end
 module Monitors
+  
+  @available_monitors =[]
+  def self.available
+    @available_monitors
+  end
+  
   class BaseMonitor
+    attr_reader :log_file, :log_file_path, :last_cloud_loaded_time
+    
+    def self.inherited(subclass)
+      unless Monitors.available.include?(subclass)
+        Monitors.available << subclass unless subclass.to_s =~ /MonitorDaemon/
+      end
+    end
     
     def initialize(env=nil)
       @env=env
+      log_filename = "poolparty_monitor.log"
+      @log_file_path = "/var/log/poolparty/#{log_filename}"
+      
+      unless ::File.file?(log_file_path)
+        ::FileUtils.mkdir_p ::File.dirname(log_file_path) unless ::File.directory?(::File.dirname(log_file_path))
+        ::File.open(log_file_path, 'a+') {|f| f << "------ #{Time.now} ------"}
+        log_file_path
+      end
+    end
+    
+    def env(env=@env)
+      @env=env
     end
     
     %w(close).each do |event|
@@ -22,11 +47,51 @@ module Monitors
       
     end
     
+    # Load the cloud
+    # Reload the cloud if necessary after 60 seconds
+    # of cache time
+    def  my_cloud
+      @my_cloud = nil if last_cloud_loaded_time && last_cloud_loaded_time > 60
+      @my_cloud ||= begin
+        require '/etc/poolparty/clouds.rb'
+        name = open("/etc/poolparty/cloud_name").read
+        last_cloud_loaded_time = Time.now.to_i
+        clouds[name.chomp.to_sym]
+      rescue Exception => e
+        JSON.parse( open('/etc/poolparty/clouds.json' ).read )
+      end
+    end
+    
+    
     def before_close_callbacks
       @before_close_callbacks ||= []
     end
     def after_close_callbacks
       @after_close_callbacks ||= []
     end
+    
+    def log(msg)
+      log_file.flush
+      log_file << "[INFO] - #{Time.now} -- #{msg}\n"
+    end
+    
+    private
+        
+    def log_file
+      if @logfile
+        @logfile
+      else
+        begin
+          ::FileUtils.mkdir_p ::File.dirname(log_file_path) unless ::File.directory?(::File.dirname(log_file_path))
+          @logfile ||= ::File.open(log_file_path, 'a+')
+        rescue Exception => e
+          puts "ERROR: #{e.inspect}"
+          @logfile = $stdout
+        end
+        
+      end
+    end
+    
+    
   end
 end

data/lib/poolparty/monitors/monitor_daemon.rb

@@ -0,0 +1,168 @@
+require "open-uri"
+require "json"
+require "#{::File.dirname(__FILE__)}/base_monitor"
+
+module PoolParty
+  class MonitorDaemon < Monitors::BaseMonitor
+    
+    attr_reader :should_daemonize, :pid_file, :sleep_time
+    
+    def self.run(o={})
+      new(o).run
+    end
+    
+    def initialize(o={})
+      @should_daemonize = o.delete(:daemonize)
+      @pid_file = o.delete(:daemonize) || "/tmp/poolparty_monitor.pid"
+      @sleep_time = o.delete(:sleep_time) || 20
+            
+      super
+    end
+    
+    def pass_the_baton
+      # Handle stats
+      my_nominations = JSON.parse(open("http://localhost:8642/stats/get_nominations").read)
+      unless my_nominations.empty?
+        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
+        log "Sending #{nominations.flatten.to_json} to #{server["/elections"].inspect}"
+        # put to "http://localhost:8642/elections/handle_election", data => nominations.to_json
+        server["/elections"].put(nominations.flatten.to_json)
+      end
+    end
+    
+    def run      
+      if should_daemonize
+        @should_daemonize = false
+        daemonize
+      else
+        log "Starting MonitorDaemon"
+        loop {          
+          begin
+            pass_the_baton
+          rescue Exception => e
+            log "There was an error with pass_the_baton: #{e}"
+          end
+          sleep sleep_time
+        }
+      end
+    end
+    
+    def daemonize(o={})
+      raise unless pid_file
+      
+      pwd = Dir.pwd # Current directory is changed during daemonization, so store it
+      
+      remove_stale_pid_file
+      pid = fork do
+        Signal.trap('HUP') do
+          restart
+        end
+        Signal.trap('INT') do
+          stop!
+        end
+        Signal.trap("CHLD") do 
+          Process.waitpid(pid, Process::WNOHANG)
+        end
+        File.open("/dev/null", "r+") do |devnull|
+          $stdout.reopen(devnull)
+          $stderr.reopen(devnull)
+          $stdin.reopen(devnull) unless @use_stdin
+        end
+        run
+      end
+      
+      Dir.chdir(pwd)
+      
+      write_pid_file(pid)
+
+      Process.detach(pid)
+    end
+        
+    def pid
+      @pid ||= File.file?(pid_file) ? open(pid_file).read.to_i : nil
+    end
+    
+    def stop!
+      log "Stopping daemon"
+      log_file.close
+      send_signal("INT")
+      remove_stale_pid_file
+      exit 0
+    end
+    
+    def restart
+      log "TODO: implement restart for HUP signal on #{__FILE__}"
+    end
+    
+    def running?
+      return false unless pid
+      Process.getpgid(pid) != -1
+    rescue Errno::ESRCH
+      false
+    end
+    
+    def send_signal(signal)
+      if File.exist?(pid_file) && pid = open(pid_file).read
+        pid = pid.to_i
+        print "Sending #{signal} signal to process #{pid} ... "
+        Process.kill(signal, pid)
+        puts
+        pid
+      else
+        puts "Can't stop process, no PID found in #{pid_file}"
+        nil
+      end
+    rescue Errno::ESRCH # No such process
+      puts "process not found!"
+      nil
+    end
+        
+    protected
+    def remove_pid_file
+      File.delete(pid_file) if pid_file && File.exists?(pid_file)
+    end
+    
+    def write_pid_file(pid)
+      FileUtils.mkdir_p File.dirname(pid_file)
+      open(pid_file,"w") { |f| f.write(pid) }
+      File.chmod(0644, pid_file)
+    end
+    
+    def remove_stale_pid_file
+      if File.exist?(@pid_file)
+        if pid && running?
+          puts "Pid file exists" and raise
+        else
+          remove_pid_file
+        end
+      end
+    end
+    
+    def server
+      if @server
+        @server
+      else
+        opts = { :content_type  =>'application/json', 
+                 :accept        => 'application/json',
+                 :host          => 'http://localhost',
+                 :port          => '8642'
+                }
+        @uri = "#{opts.delete(:host)}:#{opts.delete(:port)}"
+        @server = RestClient::Resource.new( @uri, opts)
+      end
+    end
+    
+  end
+end

data/lib/poolparty/monitors/monitor_rack.rb

@@ -2,9 +2,10 @@
   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__)+"/../aska"
 require ::File.dirname(__FILE__)+"/../lite"
 require ::File.dirname(__FILE__)+"/base_monitor"
+require ::File.dirname(__FILE__)+"/monitor_daemon"
 
 require 'rubygems'
 require 'rack'
@@ -44,14 +45,13 @@ module Monitors
       begin
         path_array= path_map(env['REQUEST_PATH']) || []
         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
+        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
@@ -60,7 +60,16 @@ module Monitors
     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
     
@@ -78,24 +87,30 @@ module Monitors
     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?
-        response.write 'cannot map an empty path' 
-        response.status='404'
+        html_list
       else
         raise "#{path[0]} did not map to a Constant" if !instance
         case path.size
-        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)
+          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
@@ -119,5 +134,4 @@ module Monitors
   
   end
   
-
 end

data/lib/poolparty/monitors/monitors/{time_monitor.rb → clock_monitor.rb}

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

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

@@ -0,0 +1,36 @@
+=begin rdoc
+  Cloud monitor just is a test monitor to hold cloud info
+=end
+
+module Monitors
+  
+  class Cloud < BaseMonitor
+    
+    def get(_unused=nil)
+      {   :name => my_cloud.name, 
+          :minimum_instances => my_cloud.minimum_instances, 
+          :maximum_instances => my_cloud.maximum_instances,
+          :remoter_base => my_cloud.remoter_base,
+          :keypair => my_cloud.keypair
+      }
+    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

@@ -0,0 +1,76 @@
+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/neighborhood_monitor.rb

@@ -8,19 +8,20 @@ module Monitors
   class Neighborhood < BaseMonitor
     
     def get(data=nil)
-      neighborhood
+      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
+      # 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
     
@@ -66,12 +67,14 @@ module Monitors
     end
     
     # HELPERS
-    def instances
-      @instances ||= ::PoolParty::Neighborhoods.load_default.instances.to_hash[:instances]
+    def instances(_n=nil)
+      @instances ||= ::PoolParty::Neighborhoods.load_default.instances #.to_hash #[:instances]
     end
-    def stats
+    def stats(_n=nil)
       @stats ||= ::PoolParty::Neighborhoods.load_default.stats rescue Stats.new(@env).get
     end
-    
+    def reset!
+      @neighborhood = @stats = nil
+    end
   end
 end