poolparty 0.2.84 → 1.2.2

data/lib/poolparty/modules/thread_pool.rb

@@ -1,106 +1,107 @@
-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
+# 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

@@ -0,0 +1,20 @@
+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,89 +1,32 @@
 =begin rdoc
-  Monitor class
+  BaseMonitor
   
-  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.
+  BaseMonitor adds a basic base monitor with callbacks for the 
+  monitors
 =end
-require "#{::File.dirname(__FILE__)}/../poolparty/base"
-
-module PoolParty
-  module Monitors    
+module Monitors
+  class BaseMonitor
     
-    module ClassMethods
+    def initialize(env=nil)
+      @env=env
     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)))
+    %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
       
-      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
+    def before_close_callbacks
+      @before_close_callbacks ||= []
     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::Base.custom_monitor_directories}/*.rb"].each {|f| require f}
-
-module PoolParty
-  module Cloud
-    class Cloud
-      include PoolParty::Monitors
+    def after_close_callbacks
+      @after_close_callbacks ||= []
     end
   end
 end

data/lib/poolparty/monitors/monitor_rack.rb

@@ -0,0 +1,123 @@
+=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

@@ -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

@@ -0,0 +1,9 @@
+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,18 +1,20 @@
-module PoolParty
+# module PoolParty
   module Monitors
     
-    class MemoryMonitor < BaseMonitor
+    class Memory < BaseMonitor
       
-      def run
+      def get(data=nil)
         uname = %x[uname]
         case uname.chomp
         when "Darwin"
           darwin_memory_usage
         else
           nix_memory_usage
-        end                
+        end
       end
       
+      private
+      
       def darwin_memory_usage
         str = %x[vm_stat]
         keep_array = []
@@ -28,7 +30,7 @@ module PoolParty
           used_memory / total_memory
         rescue Exception => e
           0.0
-        end                 
+        end
       end
       
       def nix_memory_usage
@@ -42,9 +44,7 @@ module PoolParty
           0.0
         end
       end
-            
+
     end
-    
-    register_monitor :memory
   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