auser-poolparty 1.0.0 → 1.1.1

data/lib/poolparty/modules/file_writer.rb

@@ -2,16 +2,20 @@ module PoolParty
   module FileWriter
     def copy_file_to_storage_directory(file, preceded="")
       make_base_directory
-      path = ::File.join( Base.storage_directory, preceded, ::File.basename(file) )
+      path = ::File.join( Default.storage_directory, preceded, ::File.basename(file) )
       ::FileUtils.cp file, path unless file == path || ::File.file?(path)
     end
     def cleanup_storage_directory
-      ::FileUtils.rm_rf "#{Base.storage_directory}"
+      ::FileUtils.rm_rf "#{Default.storage_directory}"
     end
-    def copy_template_to_storage_directory(file)
+    def copy_template_to_storage_directory(file, force=false)
       make_template_directory
-      path = ::File.join( Base.tmp_path, Base.template_directory, ::File.basename(file) )
-      FileUtils.cp file, path unless file == path || ::File.exists?(path)
+      path = ::File.join( Default.tmp_path, Default.template_directory, ::File.basename(file) )
+      if force
+        FileUtils.cp file, path
+      else
+        FileUtils.cp file, path unless file == path || ::File.exists?(path)
+      end       
     end
     def copy_directory_into_template_storage_directory(dir)
       path = make_template_directory(dir)
@@ -21,22 +25,22 @@ module PoolParty
       ::File.basename(path)
     end
     def copy_directory_into_storage_directory(from, pat)
-      to = ::File.join(Base.storage_directory, pat)
+      to = ::File.join(Default.storage_directory, pat)
       
       # make_directory_in_storage_directory(to) unless ::File.directory?(to)
       FileUtils.cp_r(from, to)
     end
     def make_directory_in_storage_directory(dirname="newdir")      
-      path = ::File.join( Base.storage_directory, dirname )
+      path = ::File.join( Default.storage_directory, dirname )
       make_base_path path
     end
     def write_to_file_in_storage_directory(file, str="", preceded="", &block)
-      path = ::File.join( Base.storage_directory, preceded, ::File.basename(file) )
+      path = ::File.join( Default.storage_directory, preceded, ::File.basename(file) )
       write_to_file(path, str, &block)
     end
     def write_to_file(file, str="", preceded="", &block)
-      path = ::File.join( Base.storage_directory, preceded, ::File.basename(file) )
-      make_base_path( Base.storage_directory )
+      path = ::File.join( Default.storage_directory, preceded, ::File.basename(file) )
+      make_base_path( Default.storage_directory )
       ::File.open(path, "w+") do |f|
         f.print str
         f.flush
@@ -46,7 +50,7 @@ module PoolParty
     # Write a temp file with the content str and return the Tempfile
     # It creates a random file name
     def write_to_temp_file(str="", &block)
-      returning Tempfile.new("#{Base.storage_directory}/PoolParty-#{str[0..10].chomp}-#{rand(1000)}") do |fp|
+      returning Tempfile.new("#{Default.storage_directory}/PoolParty-#{str[0..10].chomp}-#{rand(1000)}") do |fp|
         fp.print str
         fp.flush
         block.call(fp)
@@ -65,14 +69,14 @@ module PoolParty
     end
     def make_base_directory
       begin
-        FileUtils.mkdir_p Base.storage_directory unless ::File.directory?(Base.storage_directory)
+        FileUtils.mkdir_p Default.storage_directory unless ::File.directory?(Default.storage_directory)
       rescue Errno::EEXIST
-        FileUtils.rm Base.storage_directory
+        FileUtils.rm Default.storage_directory
         make_base_directory
       end            
     end
     def make_template_directory(dir=nil)
-      path = dir ? ::File.join(Base.tmp_path, Base.template_directory, ::File.basename(dir)) : ::File.join(Base.tmp_path, Base.template_directory)
+      path = dir ? ::File.join(Default.tmp_path, Default.template_directory, ::File.basename(dir)) : ::File.join(Default.tmp_path, Default.template_directory)
       begin
         make_base_directory
         FileUtils.mkdir path unless ::File.directory?(path)
@@ -83,7 +87,7 @@ module PoolParty
       path
     end
     def clear_base_directory
-      Dir["#{Base.storage_directory}/**/*"].each do |f|
+      Dir["#{Default.storage_directory}/**/*"].each do |f|
         ::FileUtils.rm f if ::File.file?(f)
       end
     end

data/lib/poolparty/modules/pretty_printer.rb

@@ -26,7 +26,7 @@ module PoolParty
     def pretty_options(pre, o)
       return "" unless o.respond_to?(:options)
       print_options = (o.respond_to?(:parent) && o.parent && o.parent.respond_to?(:options)) ? 
-        (o.options.delete_if {|k,v| o.parent.options.has_key?(k) && o.parent.options[k] == o.options[k] && !o.options[k].nil? } ) : 
+        (o.dsl_options.delete_if {|k,v| o.parent.dsl_options.has_key?(k) && o.parent.options[k] == o.options[k] && !o.options[k].nil? } ) : 
         o.options
       print_options = print_options.map {|k,v| [k, o.send(k.to_sym).to_s] }.inject({}) { |r,e| r[e[0]] = e[1] unless o.class.default_options[e[0]] == e[1] || e[1].nil? || e[1].empty?; r }
       print_options.flush_out("#{pre}\t")

data/lib/poolparty/modules/resourcing_dsl.rb

@@ -2,68 +2,73 @@ module PoolParty
   module ResourcingDsl
     # Overrides for syntax
     # Allows us to send require to require a resource
-    def require(str="")
-      str ? options.merge!(:require => str) : options[:require]
-    end
     def requires(str=nil)
-      # str ? options.append!(:require => str) : options[:require]
-      str ? options.append!(:require => send_if_method(str)) : options[:require]
-    end 
+      str ? dsl_options.merge!(:require => send_if_method(str)) : dsl_options[:require]
+    end
+    def on_change(str=nil)
+      str ? dsl_options.merge!(:notify => send_if_method(str)) : dsl_options[:notify]
+    end
     def ensures(str="running")
-      # if %w(absent running).map {|a| self.send a.to_sym}.include?(str)
-        str == "absent" ? is_absent : is_present
-      # else
-        # options.append!(:ensure => str)
-      # end
-      # str
+        str == :absent ? is_absent : is_present
+    end
+    def present
+      "present"
+    end
+    def absent
+      "absent"
     end
     # Allows us to send an ensure to ensure the presence of a resource
     def is_present(*args)
-      options.merge!(:ensure => present)
+      dsl_options.merge!(:ensures => present)
+      present
     end
     # Ensures that what we are sending is absent
     def is_absent(*args)
-      options.merge!(:ensure => absent)
+      dsl_options.merge!(:ensures => absent)
+      absent
     end
     # Alias for unless
     def ifnot(str="")
-      options.merge!(:unless => str)
-    end
-    def present
-      "present"
-    end
-    def absent
-      "absent"
+      dsl_options.merge!(:unless => str)
     end
     def cancel(*args)
-      options[:cancelled] = args.empty? ? true : args[0]
+      dsl_options[:cancelled] = args.empty? ? true : args[0]
     end
     def cancelled?
-      options[:cancelled] || false
+      dsl_options[:cancelled] || false
     end
     def printed(*args)
-      options[:printed] = true
+      dsl_options[:printed] = true
     end
     def printed?
-      options[:printed] || false
-    end
-    # Give us a template to work with on the resource
-    # Make sure this template is moved to the tmp directory as well
-    # 
-    # TODO: Change this method to store the template files for later
-    # copying to prevent unnecessary copying and tons of directories
-    # everywhere
-    def template(file, opts={})
-      raise TemplateNotFound.new("no template given") unless file
-      raise TemplateNotFound.new("template cannot be found #{file}") unless ::File.file?(file)
-      
-      unless opts[:just_copy]
-        options.merge!({:content => "template(\"#{::File.basename(file)}\")"})
-        options.delete(:source) if options.has_key?(:source)
-        copy_template_to_storage_directory(file)
+      dsl_options[:printed] || false
+    end
+
+    #TODO: Diet
+    def render_template
+      # @templates.
+    end
+    
+    def get_client_or_gem_template(file)
+      if ::File.file?(file) && ::File.readable?(file)
+        file
+      elsif client_templates_directory_exists? && client_template_exists?(file)
+        vputs "using custom template #{::File.join(Dir.pwd, "templates/#{file}")}"
+        ::File.join(Dir.pwd, "templates/#{file}")
       else
-        copy_file_to_storage_directory(file)
+        vputs "using standard template: #{::File.join(::File.dirname(__FILE__), "..", "templates/#{file}")}"
+        ::File.join(::File.dirname(__FILE__), "..", "templates/#{file}")
       end
     end
+    
+    def client_templates_directory_exists?
+      ::File.directory?("#{Dir.pwd}/templates")
+    end
+    
+    def client_template_exists?(filename)
+      return true if ::File.file?(filename) && ::File.readable?(filename)
+      file = ::File.join("#{Dir.pwd}/templates", filename)
+      ::File.file?(file) && ::File.readable?(file)
+    end
   end
 end

data/lib/poolparty/monitors/base_monitor.rb

@@ -29,7 +29,7 @@
   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/base"
+require "#{::File.dirname(__FILE__)}/../poolparty/default"
 
 module PoolParty
   module Monitors    
@@ -78,12 +78,4 @@ 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
-    end
-  end
-end
+Dir["#{PoolParty::Default.custom_monitor_directories}/*.rb"].each {|f| require f}

data/lib/poolparty/monitors/monitor_rack.rb

@@ -0,0 +1,125 @@
+require ::File.dirname(__FILE__)+"/../aska/aska.rb"
+require ::File.dirname(__FILE__)+"/../lite.rb"
+
+require 'rubygems'
+require 'rack'
+require 'json'
+
+class String
+  def camelcase
+    gsub(/(^|_|-)(.)/) { $2.upcase }
+  end
+end
+
+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
+      @request = Rack::Request.new env
+      @response = Rack::Response.new
+      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
+      # rescue Exception=>e
+      #   @response.write e
+      #   @response.status = 500
+      end
+      @response.finish # this is [response.status, response.headers, response.body]
+    end
+    
+    def env
+      @env
+    end
+    def response
+      @response
+    end
+    def request
+      @request
+    end
+    
+    def path_map(requested_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)
+      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
+        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])
+        end
+      end
+    end
+    
+    def constantize(name, base_object=Monitors)
+      begin
+        const = base_object.constants.find{|cnst| cnst == name.camelcase}
+        base_object.module_eval const
+      rescue Exception => e
+        puts "#{name.camelcase} is not defined. #{e}"
+        nil
+      end
+    end
+  
+    def default
+      'default response'
+    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
+    def self.default
+      ''
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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

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
-end
+# 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
+# end

data/lib/poolparty/monitors/monitors/server_monitor.rb

@@ -0,0 +1,7 @@
+module Butterfly
+  class ServerMonitor
+    def self.load
+      %x{"uptime"}.split[-3].to_f
+    end
+  end
+end

data/lib/poolparty/monitors/monitors/web_monitor.rb

@@ -1,18 +1,18 @@
-=begin rdoc
-  Web monitor.
-=end
-module PoolParty
-  module Monitors
-    
-    class WebMonitor < BaseMonitor
-      
-      def run
-        str = %x[httperf]
-        str.split(/\s+/)[-1].to_f rescue 0.0
-      end
-            
-    end
-    
-    register_monitor :cpu
-  end
-end
+# =begin rdoc
+#   Web monitor.
+# =end
+# module PoolParty
+#   module Monitors
+#     
+#     class WebMonitor < BaseMonitor
+#       
+#       def run
+#         str = %x[httperf]
+#         str.split(/\s+/)[-1].to_f rescue 0.0
+#       end
+#             
+#     end
+#     
+#     register_monitor :cpu
+#   end
+# end

data/lib/poolparty/monitors/neighborhood_monitor.rb

@@ -0,0 +1,25 @@
+require ::File.dirname(__FILE__)+"/monitor_rack.rb"
+require ::File.dirname(__FILE__)+"/../lite.rb"
+require ::File.dirname(__FILE__)+"/../core/hash.rb"
+
+module Monitors
+    
+  class Neighborhood
+    attr_reader :stats, :request
+    attr_accessor :response
+    
+    def initialize(env, o={})
+      @env = env
+      @request = Rack::Request.new env
+      @response = Rack::Response.new
+      @cloud = JSON.parse( open( "/etc/poolparty/clouds.json" ).read )
+      @opts = @cloud["options"]
+      @remoter_base = PoolParty::Remote.const_get(@opts.remote_base.split("::")[-1].camelcase)
+    end
+    
+    def default
+      @remoter_base.send :describe_instances, @opts
+    end
+    
+  end
+end