poolparty 1.2.2 → 1.3.1

data/lib/poolparty/modules/searchable_paths.rb

@@ -1,91 +0,0 @@
-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
-        [
-          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
-
-      # 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)
-        return filepath if File.exists?(filepath) # return the file if its an absolute path
-        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/thread_pool.rb

@@ -1,107 +0,0 @@
-# TODO: Deprecate
-# require 'thread'
-# begin
-#   require 'fasttread'
-# rescue LoadError
-# end
-# 
-# class ThreadPool
-#   class Worker
-#     def initialize(thread_queue)
-#       @mutex = Mutex.new
-#       @cv = ConditionVariable.new
-#       @queue = thread_queue
-#       @running = true
-#       @thread = Thread.new do
-#         @mutex.synchronize do
-#           while @running
-#             @cv.wait(@mutex)
-#             block = get_block
-#             if block
-#               @mutex.unlock
-#               block.call
-#               @mutex.lock
-#               reset_block
-#             end
-#             @queue << self
-#           end
-#         end
-#       end
-#     end
-# 
-#     def name
-#       @thread.inspect
-#     end
-# 
-#     def get_block
-#       @block
-#     end
-# 
-#     def set_block(block)
-#       @mutex.synchronize do
-#         raise RuntimeError, "Thread already busy." if @block
-#         @block = block
-#         # Signal the thread in this class, that there's a job to be done
-#         @cv.signal
-#       end
-#     end
-# 
-#     def reset_block
-#       @block = nil
-#     end
-# 
-#     def busy?
-#       @mutex.synchronize { !@block.nil? }
-#     end
-# 
-#     def stop
-#       @mutex.synchronize do
-#         @running = false
-#         @cv.signal
-#       end
-#       @thread.join
-#     end
-#   end
-# 
-#   attr_accessor :max_size
-# 
-#   def initialize(max_size = 10)
-#     @max_size = max_size
-#     @queue = Queue.new
-#     @workers = []
-#   end
-# 
-#   def size
-#     @workers.size
-#   end
-# 
-#   def busy?
-#     @queue.size < @workers.size
-#   end
-# 
-#   def shutdown
-#     @workers.each { |w| w.stop }
-#     @workers = []
-#   end
-# 
-#   alias :join :shutdown
-# 
-#   def process(block=nil,&blk)
-#     block = blk if block_given?
-#     worker = get_worker
-#     worker.set_block(block)
-#   end
-# 
-#   private
-# 
-#   def get_worker
-#     if !@queue.empty? or @workers.size == @max_size
-#       return @queue.pop
-#     else
-#       worker = Worker.new(@queue)
-#       @workers << worker
-#       worker
-#     end
-#   end
-# 
-# end

data/lib/poolparty/modules/user_helpers.rb

@@ -1,20 +0,0 @@
-module PoolParty
-  # Require all the files in a directory below the base
-  def require_user_directory(dirname)    
-    begin
-      cloud_dir = ::File.dirname($pool_specfile)
-      Dir["#{cloud_dir}/#{dirname}/**"].each {|a| require a }
-    rescue Exception => e
-      vputs "Error requiring user directory #{dirname}: #{e}"
-    end
-  end
-
-  # 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")
-    rescue Exception => e
-      vputs "Error packing user directory #{dirname}: #{e}"
-    end    
-  end
-end

data/lib/poolparty/monitors/base_monitor.rb

@@ -1,32 +0,0 @@
-=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,123 +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/aska"
-require ::File.dirname(__FILE__)+"/../lite"
-require ::File.dirname(__FILE__)+"/base_monitor"
-
-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
-        @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
-      end
-      @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
-    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
-  
-    # 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'
-      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)
-        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/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,77 +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)
-      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