auser-poolparty 1.1.1 → 1.1.3

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 1
+:patch: 3
 :major: 1
 :minor: 1

data/bin/cloud-show

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "poolparty"
+
+o = PoolParty::Optioner.new(ARGV) do |opts, optioner|
+  opts.on('-n name', '--name name', 'Listing for cloud name')    { |c| optioner.cloudname c }
+end
+
+o.loaded_clouds.each do |cld|
+    
+  print_with_nice_printer "Cloud: #{cld.name}", [
+    "instances #{cld.minimum_instances}..#{cld.maximum_instances}",
+    "keypair #{cld.keypair}"
+  ] do |printer|    
+    if cld.list_of_running_instances.size > 0
+      printer.empty
+      printer.center("Active instances")
+      printer << cld.list_of_running_instances.map{|a| a.ip.strip }.join("\n")
+    end
+    if cld.list_of_pending_instances.size > 0
+      printer.empty
+      printer.center "Pending instances"
+      printer << cld.list_of_pending_instances.map{|a| a.to_s}.join("\n")
+    end
+    printer.empty
+  end
+end

data/lib/poolparty/base_packages/haproxy.rb

@@ -29,15 +29,16 @@ module PoolParty
           :requires => get_package("haproxy")
         
         # Service is required
-        has_service("haproxy", :ensures => "running")
+        has_service("haproxy", :ensures => "running") do
+          stops get_service("apache2"), :immediately
+          starts get_service("apache2")
+        end
         
         has_directory "/var/run/haproxy"
         
         has_file "/etc/haproxy/haproxy.cfg" do
           template "#{::File.dirname(__FILE__)}/../templates/haproxy.conf"
           calls get_exec("reloadhaproxy")
-          stops get_service("apache2")
-          starts get_service("apache2")
         end
       end
     end

data/lib/poolparty/dependency_resolver/chef_resolver.rb

@@ -138,19 +138,23 @@ module PoolParty
       end
     end
     
+    # Check if the hash has content and that the content exists here. This is used
+    # to provide a check
     def before_filter_check_on_hash(hsh, nm)
       if hsh.has_key?(:content)
         cont = hsh.delete(:content)
         temp_file = "#{base_dir}/templates/default/#{nm}.erb"
         ::FileUtils.mkdir_p(::File.dirname(temp_file)) unless ::File.directory? temp_file
         ::File.open(temp_file, "w+") {|f| f.print cont }
-        hsh.merge!({:source => "#{nm}.erb", :variables => hsh.dup})
+        hsh.merge!({:source => "#{nm}.erb"})
       end
       # 
       hsh.delete(:require) if hsh.has_key?(:require)
       hsh
     end
     
+    # Turn the services into strings using the handle_print_service method
+    # Here we can strip out non-meaningful chef services
     def services_to_string(opts,tabs=0)
       if opts
         str = ""
@@ -164,6 +168,8 @@ module PoolParty
       end
     end
     
+    # Take the keys from the resource hash and turn them into chef-like
+    # meaningful keys. This is how helpers are created for chef
     def to_chef_key(key)
       case key
       when :ensures
@@ -185,6 +191,8 @@ module PoolParty
       end
     end
     
+    # Resolve the value of the resource hash into a meaningful chef
+    # value. Resources are turned into resource strings here
     def to_option_string(obj)
       case obj
       when PoolParty::Resources::Resource
@@ -194,7 +202,11 @@ module PoolParty
       when String
         "\"#{obj}\""
       when Array
-        "[ #{obj.map {|e| to_option_string(e) }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
+        if obj[1] && [:immediately, :delayed].include?(obj[1])
+          "#{to_option_string(obj[0])}, :#{obj[1]}"
+        else
+          "[ #{obj.map {|e| to_option_string(e) }.reject {|a| a.nil? || a.empty? }.join(", ")} ]"
+        end        
       when nil
         nil
       when Hash

data/lib/poolparty/helpers/binary.rb

@@ -15,13 +15,14 @@ module PoolParty
     end
   end
   
-  def print_with_nice_printer(header=nil, strs=[])
-    returning NicePrinter.new do |printer|
-      printer.header
-      printer.center(header) if header
-      strs.each {|st| printer << st if st}
-      printer.footer
-    end.print
+  def print_with_nice_printer(header=nil, strs=[], &block)
+    printer = NicePrinter.new
+    printer.header
+    printer.center(header) if header
+    yield(printer)
+    strs.each {|st| printer << st if st}
+    printer.footer
+    printer.print
   end
   
   def pool_specfile

data/lib/poolparty/lite.rb

@@ -1,6 +1,6 @@
 require "rubygems"
 require "json"
-require 'dslify' rescue require("#{::File.dirname(__FILE__)}/../../vendor/gems/dslify/lib/dslify")
+require("#{::File.dirname(__FILE__)}/../../vendor/gems/dslify/lib/dslify")
 require "#{::File.dirname(__FILE__)}/poolparty/default"
 require "#{::File.dirname(__FILE__)}/schema"
 require "#{::File.dirname(__FILE__)}/net/init"

data/lib/poolparty/monitors/base_monitor.rb

@@ -1,81 +1,81 @@
-=begin rdoc
-  Monitor class
-  
-  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.
-=end
-require "#{::File.dirname(__FILE__)}/../poolparty/default"
-
-module PoolParty
-  module Monitors    
-    
-    module ClassMethods
-    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)))
-      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
-    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::Default.custom_monitor_directories}/*.rb"].each {|f| require f}
+# =begin rdoc
+#   Monitor class
+#   
+#   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.
+# =end
+# require "#{::File.dirname(__FILE__)}/../poolparty/default"
+# 
+# module PoolParty
+#   module Monitors    
+#     
+#     module ClassMethods
+#     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)))
+#       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
+#     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::Default.custom_monitor_directories}/*.rb"].each {|f| require f}

data/lib/poolparty/monitors/monitor_rack.rb

@@ -101,6 +101,13 @@ module Monitors
   
   end
   
+  # Base monitor
+  class MonitorBase
+    def initialize(env={})
+      @env = env
+    end
+  end
+  
   #load our monitors
   require ::File.dirname(__FILE__)+"/stats_monitor.rb"
   require ::File.dirname(__FILE__)+"/neighborhood_monitor.rb"
@@ -117,7 +124,7 @@ module Monitors
     end
   end
   
-  class Favicon
+  class Favicon < MonitorBase
     def self.default
       ''
     end

data/lib/poolparty/monitors/stats_monitor.rb

@@ -2,7 +2,7 @@ require ::File.dirname(__FILE__)+"/monitor_rack.rb"
 
 module Monitors
     
-  class Stats 
+  class Stats
     attr_reader :stats, :request
     attr_accessor :response
     
@@ -33,16 +33,17 @@ module Monitors
       log << "#{Time.now.strftime("%Y-%m-%d-%H-%M")}, #{stats.to_json}\n"
     end
     
-    def default
-      stats.to_json
-    end
-
     def log(log_file_path="/var/log/poolparty/stats_monitor.log")
-      ::File.file? log_file_path
-      @logfile ||= ::File.new(log_file_path, 'a')
+      if @logfile
+        @logfile
+      else
+        ::File.file? log_file_path
+        ::FileUtils.mkdir_p ::File.dirname(log_file_path) unless ::File.directory?(::File.dirname(log_file_path))
+        @logfile ||= ::File.open(log_file_path, 'a+')
+      end
     end
-
-    def default
+    
+    def default      
       begin
         if !request.params || request.params.empty?
           default_stats
@@ -52,11 +53,9 @@ module Monitors
           stats.to_json
         end
       rescue Exception => e
-        response.fail!
         "Error: #{e}"
       end
     end
-    alias :get :default
 
     def put
       if d = JSON.parse(request.params)
@@ -112,7 +111,7 @@ module Monitors
     def default_stats
       %w(load nominations).each do |var|
         stats[my_ip][var] ||= self.send(var.to_sym)
-      end
+      end      
       stats
     end
 

data/lib/poolparty/poolparty/cloud.rb

@@ -18,19 +18,18 @@ module PoolParty
     end
     
     class Cloud < PoolParty::PoolPartyBaseClass
-      attr_reader :templates, :cloud_name
+      attr_reader :templates, :cloud_name, :remote_base
 
       include CloudResourcer
       include PoolParty::PluginModel
       include PoolParty::Resources      
       include PoolParty::DependencyResolverCloudExtensions
       include PrettyPrinter
-      include Provisioner
 
       # Net methods
       include ::PoolParty::Remote
       include PoolParty::CloudDsl
-      include PoolParty::Monitors
+      # include PoolParty::Monitors
 
       def verbose
         true
@@ -46,6 +45,8 @@ module PoolParty
       
       alias :name :cloud_name
       
+      # Call the remoter commands on the cloud if they don't exist on the cloud itself
+      # This gives the cloud access to the remote_base's methods
       def method_missing(m, *args, &block)
         remote_base.respond_to?(m) ? remote_base.send(m, *args, &block) : super
       end
@@ -60,6 +61,8 @@ module PoolParty
         :user => Default.user
       )
       
+      # Freeze the cloud_name so we can't modify it at all, set the plugin_directory
+      # call and run instance_eval on the block and then call the after_create callback
       def initialize(name, &block)
         @cloud_name = name
         @cloud_name.freeze
@@ -69,11 +72,15 @@ module PoolParty
         after_create
       end
       
+      # Fetch the name of the cloud
       def name(*args)
         @cloud_name ||= @cloud_name ? @cloud_name : (args.empty? ? :default_cloud : args.first)
       end
       
       # Callback
+      # called after the cloud has been created, everything has run and is set at this point
+      # here the base requirements are added as well as an empty chef recipe is called
+      # Also, the after_create hook on the plugins used by the cloud are called here
       def after_create
         dputs "In after create"
         ::FileUtils.mkdir_p("#{Default.tmp_path}/dr_configure")
@@ -86,6 +93,7 @@ module PoolParty
         setup_defaults
       end
       
+      # setup defaults for the cloud
       def setup_defaults
         # this can be overridden in the spec, but ec2 is the default
         using :ec2
@@ -99,70 +107,11 @@ module PoolParty
         list_of_running_instances.map {|ri| ri.ip }
       end
       
+      # TODO: make this be a random ip, since we should not rely on it being the same each time
       def ip
-        ips.first  #TODO: make this be a random ip, since we should not rely on it being the same each time
+        ips.first
       end
-      
-      # TODO: Deprecated
-      def dependency_resolver_command
-         "/usr/bin/puppet -v --logdest syslog /etc/puppet/manifests/site.pp"
-      end
-      
-      # Prepare to send the new configuration to the instances
-      # First, let's make sure that our base directory is made
-      # Then copy the templates that have no other reference in
-      # a spec file. Make sure the keys are stored in a file
-      # For the master to have access to them
-      # Then, send the saved containing cloud instances to give the 
-      # remote master access to the cloud options that are required
-      # for the master to run checks
-      def prepare_for_configuration        
-        # # clear_base_directory
-        # make_base_directory
-        # copy_misc_templates
-        # copy_custom_monitors
-        # copy_custom_modules
-        # copy_custom_templates
-        # store_keys_in_file
-        # # Script.save!(self)
-        # # not my favorite...
-        # copy_ssh_key
-        # write_unique_cookie
-        # before_configuration_tasks
-        # write_properties_hash if debugging || testing
-      end
-      
-      def copy_custom_templates
-        return true unless ::File.directory?("#{Dir.pwd}/templates")
-        Dir["#{Dir.pwd}/templates/*"].each {|file| copy_template_to_storage_directory(file, true) }        
-      end
-      
-      # Copy the ssh keys to the storage directory in preparation for
-      # configuration
-      def copy_ssh_key
-        copy_file_to_storage_directory(full_keypair_path)
-      end
-      
-      # Store our keys for cloud access in a file 
-      # that is specific to this cloud
-      def store_keys_in_file
-        Default.store_keys_in_file_for(self)
-      end
-      
-      # Let's write the cookie into the tmp path
-      def write_unique_cookie
-        write_to_file_in_storage_directory("cookie") do
-          generate_unique_cookie_string
-        end
-      end
-      
-      # Generate a unique cookie string so that our erlang modules can 
-      # talk to each other safely. This is based off the keypair
-      # and the name of the cloud
-      def generate_unique_cookie_string
-        Digest::SHA256.hexdigest("#{keypair.basename}#{name}")[0..12]
-      end
-      
+            
       # Build the new poolparty manifest
       # Wrapping all of these requirements into the one 
       # poolparty class.
@@ -180,12 +129,6 @@ module PoolParty
         end
       end
       
-      def copy_misc_templates
-        ["namespaceauth.conf", "puppet/puppet.conf", "gem"].each do |f|
-          copy_file_to_storage_directory(::File.join(::File.dirname(__FILE__), "..", "templates", f))
-        end
-      end
-      
       # If there is a directory named monitors in the same directory
       # as the pool specification file is in,
       # then create a monitors directory in the storage directory
@@ -194,21 +137,8 @@ module PoolParty
       # that are in known locations, these are included
       def copy_custom_monitors
         unless Default.custom_monitor_directories.empty?
-          make_directory_in_storage_directory("monitors")
           Default.custom_monitor_directories.each do |dir|
-            Dir["#{dir}/*.rb"].each {|f| copy_file_to_storage_directory(f, "monitors")}
-          end
-        end
-      end
-      
-      def copy_custom_modules
-        unless Default.custom_modules_directories.empty?
-          make_directory_in_storage_directory("modules")
-          Default.custom_modules_directories.each do |dir|
-            Dir["#{dir}/*"].each do |d|
-              to = ::File.join("modules", ::File.basename(d))
-              copy_directory_into_storage_directory(d, to) if ::File.directory?(d)
-            end
+            Dir["#{dir}/*.rb"].each {|f| ::Suitcase::Zipper.add(f, "monitors")}
           end
         end
       end
@@ -231,35 +161,9 @@ module PoolParty
         build_manifest
       end
       
-      #FIXME DEPRECATE
-      # def build_short_manifest
-      #               returning Array.new do |str|            
-      #         
-      #                 # Refactor this into the resources method
-      #                 # TODO
-      #                 services.each do |service|
-      #                   service.options.merge!(:name => service.name)
-      #                   classpackage_with_self(service)
-      #                 end
-      #                 
-      #                 options.merge!(:name => "user")
-      #                 classpackage_with_self
-      #                 # resources.each do |type, res|
-      #                 #   str << "# #{type.to_s.pluralize}"
-      #                 #   str << res.to_string
-      #                 # end
-      #                 
-      #                 global_classpackages.each do |cls|
-      #                   str << cls.to_string
-      #                 end
-      #         
-      #                 str << "# Custom functions"
-      #                 str << Resources::CustomResource.custom_functions_to_string
-      #               end.join("\n")
-      #             end
-      
+      # If the 
       def build_from_existing_file
-        ::FileTest.file?("#{Default.manifest_path}/classes/poolparty.pp") ? open("#{Default.manifest_path}/classes/poolparty.pp").read : nil
+        ::FileTest.file?("#{Default.base_config_directory}/poolparty.pp") ? open("#{Default.base_config_directory}/poolparty.pp").read : nil
       end
       
       def write_properties_hash(filename=::File.join(Default.tmp_path, Default.properties_hash_filename) )
@@ -269,26 +173,8 @@ module PoolParty
         ::File.open("#{file_path}/#{file_name}", "w") {|f| f.write output }
         true
       end
-      
-      # To allow the remote instances to do their job,
-      # they need a few options to run, these are the required options
-      # to be saved on the remote "master" machine
-      def minimum_runnable_options
-        ([
-          :keypair, :minimum_instances, :maximum_instances,
-          :expand_when, :contract_when, :set_master_ip_to  #DEPRECATE set_master_ip_to
-        ]<< custom_minimum_runnable_options).flatten
-      end
-      
-      def custom_minimum_runnable_options
-        using_remoter? ? remote_base.custom_minimum_runnable_options : []
-      end
-      
-      def remote_base
-        @remote_base ||= nil
-      end
             
-      # Callbacks on before_bootstrap
+      # Callbacks on bootstrap and configuration
       %w( before_bootstrap 
           after_bootstrap 
           before_configure 
@@ -314,11 +200,11 @@ module PoolParty
       end
       
       def other_clouds
-        returning Array.new do |arr|
-          clouds.each do |name, cl|
-            arr << cl if name != self.name
-          end
+        arr = []
+        clouds.each do |name, cl|
+          arr << cl if name != self.name
         end
+        arr
       end
       
       def reset!

data/lib/poolparty/poolparty/template.rb

@@ -6,7 +6,7 @@ module PoolParty
         
     def self.compile_string(string, opts={})
       vars = OpenStruct.new opts
-      ERB.new(string).result(vars.send(:binding))
+      handle_render(string, vars, (opts.delete(:render) || :erb))
     end
     
     def self.compile_file(file, opts={})
@@ -14,5 +14,14 @@ module PoolParty
       compile_string(content, opts)
     end
     
+    def self.handle_render(string, vars, renderer)
+      case renderer
+      when :haml
+        nil
+      else
+        ERB.new(string).result(vars.send(:binding))
+      end
+    end
+    
   end
 end