poolparty 0.2.84 → 1.2.2

data/lib/poolparty/modules/daemonizable.rb

@@ -0,0 +1,141 @@
+# TODO: Diet
+# module PoolParty
+#       
+#   module Daemonizeable
+#     
+#     attr_accessor :pid_file
+#     
+#     def self.included(base)
+#       base.extend ClassMethods
+#     end
+#     
+#     def pid
+#       @pid ||= File.file?(pid_file) ? open(pid_file).read.to_i : nil
+#     end
+#     
+#     def pid_file
+#       @pid_file ||= PoolParty::Default.agent_pid_file
+#     end
+#     
+#     # Returns +true+ the process identied by +pid+ is running.
+#     def running?
+#       return false unless pid
+#       Process.getpgid(pid) != -1
+#     rescue Errno::ESRCH
+#       false
+#     end
+#     
+#     # Turns the current script into a daemon process that detaches from the console.
+#     def daemonize(&block)
+#       raise unless pid_file
+# 
+#       remove_stale_pid_file
+#       
+#       pwd = Dir.pwd # Current directory is changed during daemonization, so store it
+#       
+#       vputs "Daemonizing..."
+#       trap("CHLD") {Process.wait(-1, Process::WNOHANG)}        
+#       @pid = fork do
+#         Signal.trap('HUP', 'IGNORE') # Don't die upon logout
+#         File.open("/dev/null", "r+") do |devnull|
+#           $stdout.reopen(devnull)
+#           $stderr.reopen(devnull)
+#           $stdin.reopen(devnull) unless @use_stdin
+#         end
+#         block.call if block
+#       end
+#       
+#       Dir.chdir(pwd)
+#       
+#       write_pid_file
+#       
+#       trap('HUP') { restart }
+#       at_exit do
+#         remove_pid_file
+#       end
+#       Process.detach(pid)
+#     end
+#     
+#     # Register a proc to be called to restart the server.
+#     def on_restart(&block)
+#       @on_restart = block
+#     end
+#     
+#     # Restart the server.
+#     def restart
+#       raise ArgumentError, "Can't restart, no 'on_restart' proc specified" unless @on_restart
+#       stop
+#       remove_pid_file
+#       @on_restart.call
+#       exit!
+#     end
+#     
+#     module ClassMethods
+#       # Send a QUIT signal the process which PID is stored in +pid_file+.
+#       # If the process is still running after +timeout+, KILL signal is
+#       # sent.
+#       def kill(pid_file, timeout=60)
+#         if pid = send_signal('QUIT', pid_file)
+#           Timeout.timeout(timeout) do
+#             sleep 0.1 while Process.running?(pid)
+#           end
+#         end
+#       rescue Timeout::Error
+#         print "Timeout! "
+#         send_signal('KILL', pid_file)
+#       rescue Interrupt
+#         send_signal('KILL', pid_file)
+#       ensure
+#         puts pid_file
+#         File.delete(pid_file) if File.exists?(pid_file)
+#       end
+#       
+#       # Restart the server by sending HUP signal.
+#       def restart(pid_file)
+#         send_signal('HUP', pid_file)
+#       end
+#       
+#       # Send a +signal+ to the process which PID is stored in +pid_file+.
+#       def send_signal(signal, pid_file)
+#         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
+#     end
+#     
+#     protected
+#       def remove_pid_file
+#         File.delete(@pid_file) if @pid_file && File.exists?(@pid_file)
+#       end
+#     
+#       def write_pid_file
+#         FileUtils.mkdir_p File.dirname(@pid_file)
+#         open(@pid_file,"w") { |f| f.write(@pid) }
+#         File.chmod(0644, @pid_file)
+#       end
+#       
+#       # If PID file is stale, remove it.
+#       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
+#   end
+#   class Daemonize
+#     include Daemonizeable
+#   end
+# end

data/lib/poolparty/modules/definable_resource.rb

@@ -16,10 +16,7 @@ module PoolParty
     # 
     # For example usage, see lib/poolparty/plugins/line.rb
     def define_resource(name, &block)
-      symc = "#{name}".camelcase
-      klass = symc.class_constant(PoolParty::Resources::CustomResource, {:preserve => true}, &block)
-      PoolParty::Resources.module_eval &block
-      klass
+      name.to_s.new_resource_class &block
     end
     
     # Allow us to create virtual resources
@@ -36,7 +33,7 @@ module PoolParty
     # Note that you can define any resources within the virtual resource
     # within the definition or the call.
     # Call example:
-    # has_virtualhost do        
+    # has_virtualhost do
     #  name "xnot.org"
     # end
     # 
@@ -44,17 +41,14 @@ module PoolParty
     # 
     # An example is included in the poolparty-apache-plugin
     def virtual_resource(name=:virtual_resource, opts={}, &block)
-      symc = "#{name}".camelcase
-      eval <<-EOE
-        class PoolParty::Resources::#{symc} < PoolParty::Resources::Resource
-        end
-      EOE
-      klass = "PoolParty::Resources::#{symc}".constantize
+      symc = "#{name}".top_level_class.camelcase
+      klass = symc.class_constant(PoolParty::Plugin::Plugin, {:preserve => true}, &block)
+      
+      PoolParty::Service.add_has_and_does_not_have_methods_for(symc)
+      
       klass.module_eval &block if block
-      klass.send :define_method, :virtual_resource?, Proc.new{true}
-      klass.send :define_method, :printable?, Proc.new{false}
       klass
     end
     
-  end  
+  end
 end

data/lib/poolparty/modules/file_writer.rb

@@ -2,18 +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
-      Dir["#{Base.storage_directory}/**/*"].each do |f|
-        ::FileUtils.rm f if ::File.file?(f)
-      end
+      ::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)
@@ -22,17 +24,23 @@ module PoolParty
       end
       ::File.basename(path)
     end
-    def make_directory_in_storage_directory(dirname="newdir")
-      path = ::File.join( Base.storage_directory, dirname )
+    def copy_directory_into_storage_directory(from, 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( 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
@@ -42,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)
@@ -61,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)
@@ -79,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/pinger.rb

@@ -0,0 +1,28 @@
+module PoolParty
+  module Pinger
+    module ClassMethods
+      # Test to see if the host has the available port open
+      # for response. 
+      def ping_port(host, port=22, retry_times=400)
+        connected = false
+        retry_times.times do |i|
+          begin
+            break if connected = TCPSocket.new(host, port).is_a?(TCPSocket)
+          rescue Exception => e
+            sleep(2)
+          end
+        end
+        connected
+      end
+    end
+  
+    module InstanceMethods
+      def ping_port(ip, port, retry_times=500);self.class.ping_port(ip, port, retry_times);end
+    end
+  
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  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,62 +2,77 @@ 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 
-    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 ? 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 = :present)
+      if [:absent, :present].include?(str) 
+        str == :absent ? is_absent : is_present
+      else
+        str
+      end
+    end
+    def present
+      :install
+    end
+    def absent
+      :remove
     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
-    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[:cancelled] || false
+    end
+    def printed(*args)
+      dsl_options[:printed] = true
+    end
+    def printed?
+      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/modules/searchable_paths.rb

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