poolparty 1.2.2 → 1.3.1

data/lib/poolparty/modules/cloud_resourcer.rb

@@ -1,126 +0,0 @@
-=begin rdoc
-  CloudResourcer provides the cloud with convenience methods
-  that you can call on your cloud. This is where the 
-  
-    instances 2..10
-    
-  method is stored, for instance. It's also where the key convenience methods are written
-=end
-require "ftools"
-
-module PoolParty
-  module CloudResourcer
-    
-    def plugin_directory(arr=[])
-      arr = [arr] if arr.is_a?(String)
-      arr << [
-        "#{::File.expand_path(Dir.pwd)}/plugins",
-        "#{::File.expand_path(Default.poolparty_home_path)}/plugins"
-      ]
-      arr.flatten.each {|arg|    
-        Dir["#{arg}/*/*.rb"].each {|f| require f } if ::File.directory?(arg)
-      }
-    end
-    
-    # Store block
-    def store_block(&block)
-      @stored_block ||= block ? block : nil
-    end
-    
-    def stored_block
-      @stored_block
-    end
-    
-    # This will run the blocks after they are stored if there is a block
-    # associated
-    def run_stored_block
-      self.run_in_context @stored_block if @stored_block
-    end
-    
-    # Set instances with a range or a number
-    # if passed with a hash, call nodes(hash) to return filtered list of 
-    # instances
-    def instances(arg)
-      case arg
-      when Range
-        minimum_instances arg.first
-        maximum_instances arg.last
-      when Fixnum
-        minimum_instances arg
-        maximum_instances arg
-      when Hash
-        nodes(arg)
-      else
-        raise SpecException.new("Don't know how to handle instances cloud input #{arg}")
-      end
-    end
-        
-    # Declare the remoter base
-    # Check to make sure the available_bases is available, otherwise raise
-    # Give access to the cloud the remote_base and instantiate a new
-    # instance of the remote base
-    def using(t, &block)
-      @cloud = self
-      if t && self.class.available_bases.include?(t.to_sym)
-        unless using_remoter?
-          self.class.send :attr_reader, :remote_base
-          self.class.send :attr_reader, :parent_cloud
-          klass_string = "#{t}".classify
-          klass = "::PoolParty::Remote::#{klass_string}".constantize
-          
-          @remote_base = klass.send :new, self, &block
-          @remote_base.instance_eval &block if block          
-          options[:remote_base] = klass.to_s if respond_to?(:options)
-          
-          @parent_cloud = @cloud
-          instance_eval "def #{t};@remote_base;end"
-        end
-      else
-        raise "Unknown remote base: #{t}"
-      end
-    end
-    
-    # Are we using a remoter?
-    def using_remoter?
-      !@remote_base.nil?
-    end
-    
-    # Keypairs
-    # Use the keypair path
-    def keypair(*args)
-      if args && !args.empty?
-        args.each {|arg| _keypairs.unshift Key.new(arg) unless arg.nil? || arg.empty? }
-      else
-        @keypair ||= _keypairs.select {|key| key.exists? }.first
-      end
-    end
-    
-    alias :set_keypairs :keypair
-    
-    def _keypairs
-      dsl_options[:keypairs] ||= [Key.new]
-    end
-    
-    def full_keypair_path
-      @full_keypair_path ||= keypair.full_filepath
-    end
-    
-    def update_from_schema(schema)
-      keypairs = schema.options.delete(:keypairs).map {|a| PoolParty::Key.new(a.basename) }
-      options.merge! schema.options
-      dsl_options[:keypairs] = keypairs
-
-      dsl_options[:dependency_resolver] = schema.options.dependency_resolver.split("::")[-1].gsub(/Resolver/, '').preserved_class_constant("Resolver") rescue PoolParty::Chef
-      
-    end
-        
-    # TODO: deprecate
-    def number_of_resources
-      arr = resources.map do |n, r|
-        r.size
-      end
-      resources.map {|n,r| r.size}.inject(0){|sum,i| sum+=i}
-    end
-    
-  end
-end

data/lib/poolparty/modules/daemonizable.rb

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

@@ -1,54 +0,0 @@
-module PoolParty
-  module DefinableResource
-    # Define a new resource that can be called like any other resource
-    # Similar to any other resource (like file or exec)
-    # but you define it how you want it to work
-    # Example:
-    # 
-    # define_resource(:line_in_file) do
-    # end
-    # 
-    # Within the block, you can define any methods you want to run as
-    # part of the resource
-    # 
-    # One thing to note is that this is NOT like other resources in the sense
-    # that it does not give you any extra methods like the resources do
-    # 
-    # For example usage, see lib/poolparty/plugins/line.rb
-    def define_resource(name, &block)
-      name.to_s.new_resource_class &block
-    end
-    
-    # Allow us to create virtual resources
-    # Generally, in plugins
-    # This sets a virtual resource against the Resource class
-    # Example:
-    # 
-    # virtual_resource(:virtualhost) do    
-    # end
-    # 
-    # This defines a virtualhost as a virtual resource
-    #  and consequently gives the methods has_virtualhost and does_not_have_virtualhost
-    # 
-    # Note that you can define any resources within the virtual resource
-    # within the definition or the call.
-    # Call example:
-    # has_virtualhost do
-    #  name "xnot.org"
-    # end
-    # 
-    # Which sets the virtual host's name as xnot.org
-    # 
-    # An example is included in the poolparty-apache-plugin
-    def virtual_resource(name=:virtual_resource, opts={}, &block)
-      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
-    end
-    
-  end
-end

data/lib/poolparty/modules/file_writer.rb

@@ -1,95 +0,0 @@
-module PoolParty
-  module FileWriter
-    def copy_file_to_storage_directory(file, preceded="")
-      make_base_directory
-      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 "#{Default.storage_directory}"
-    end
-    def copy_template_to_storage_directory(file, force=false)
-      make_template_directory
-      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)
-      Dir["#{dir}/*"].each do |file|
-        FileUtils.cp file, path unless ::File.exists?(::File.join(path, ::File.basename(file)))
-      end
-      ::File.basename(path)
-    end
-    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( 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( Default.storage_directory, preceded, ::File.basename(file) )
-      make_base_path( Default.storage_directory )
-      ::File.open(path, "w+") do |f|
-        f.print str
-        f.flush
-        f.print block.call(f) if block
-      end
-    end
-    # 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("#{Default.storage_directory}/PoolParty-#{str[0..10].chomp}-#{rand(1000)}") do |fp|
-        fp.print str
-        fp.flush
-        block.call(fp)
-      end
-    end
-    def make_base_path(path)
-      unless FileTest.directory?(path)
-        begin
-          ::FileUtils.rm path if ::File.file?(path)
-          ::FileUtils.mkdir_p path
-        rescue Errno::ENOTDIR
-        rescue Errno::EEXIST
-          puts "There was an error"
-        end
-      end
-    end
-    def make_base_directory
-      begin
-        FileUtils.mkdir_p Default.storage_directory unless ::File.directory?(Default.storage_directory)
-      rescue Errno::EEXIST
-        FileUtils.rm Default.storage_directory
-        make_base_directory
-      end            
-    end
-    def make_template_directory(dir=nil)
-      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)
-      rescue Errno::EEXIST
-        FileUtils.rm path if ::File.exists?(path)
-        make_template_directory(dir)
-      end      
-      path
-    end
-    def clear_base_directory
-      Dir["#{Default.storage_directory}/**/*"].each do |f|
-        ::FileUtils.rm f if ::File.file?(f)
-      end
-    end
-  end
-end

data/lib/poolparty/modules/output.rb

@@ -1,13 +0,0 @@
-module PoolParty
-  module Output
-
-    def output(*args)
-      returning (@output ||= []) do |output|
-        args.each do |line|
-          (output ||= []) << line
-        end
-      end        
-    end      
-
-  end
-end

data/lib/poolparty/modules/pinger.rb

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

@@ -1,40 +0,0 @@
-module PoolParty
-  module PrettyPrinter
-    
-    def pretty_print(pre="\t")
-      pre = "\t" unless pre.is_a?(String)
-      returning Array.new do |out|
-        out << pretty_name(pre, self)
-        out << pretty_options(pre, self)
-        
-        if self.respond_to?(:clouds)
-          clouds.each do |name, cl|
-            out << pretty_name(pre*2, cl)
-            out << pretty_options(pre*2, cl) #cl.pretty_print("#{pre}\t")
-          end
-        end
-        if self.respond_to?(:plugins)
-          out << "#{pre}\t\tPlugins"
-          out << "#{pre}\t\t" + plugins.map {|a| a}.join("\n")
-        end
-      end.join("\n")
-    end
-    
-    # Gather options on the object
-    # Do not print if the option is nil or empty.
-    # Also, don't show the option if the option is empty or the default option on the cloud    
-    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.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")
-    end
-    
-    def pretty_name(pre, o)
-      "#{pre}#{o.class.to_s.top_level_class.capitalize}: #{o.name if o.respond_to?(:name)}"
-    end
-    
-  end
-end

data/lib/poolparty/modules/resourcing_dsl.rb

@@ -1,78 +0,0 @@
-module PoolParty
-  module ResourcingDsl
-    # Overrides for syntax
-    # Allows us to send require to require a resource
-    def requires(str=nil)
-      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)
-      dsl_options.merge!(:ensures => present)
-      present
-    end
-    # Ensures that what we are sending is absent
-    def is_absent(*args)
-      dsl_options.merge!(:ensures => absent)
-      absent
-    end
-    # Alias for unless
-    def ifnot(str="")
-      dsl_options.merge!(:unless => str)
-    end
-    def cancel(*args)
-      dsl_options[:cancelled] = args.empty? ? true : args[0]
-    end
-    def cancelled?
-      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
-        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/s3_string.rb

@@ -1,32 +0,0 @@
-module S3String
-  def bucket_objects
-    AWS::S3::Bucket.objects(self)
-  end
-  def bucket_object(key)
-    AWS::S3::S3Object.value key, self if bucket_object_exists?(key)
-  end
-  def bucket_object_exists?(key)
-    AWS::S3::S3Object.exists? key, self
-  end
-  def store_bucket_value(key, data)
-    AWS::S3::S3Object.store key, data, self unless bucket_object_exists?(key)
-  end
-  def delete_bucket_value(key)
-    AWS::S3::S3Object.delete(key, self) if bucket_object_exists?(key)
-  end
-  def bucket_exists?
-    begin
-      AWS::S3::Bucket.find(self)
-      return true
-    rescue
-      return false
-    end        
-  end
-  def delete_bucket
-    AWS::S3::Bucket.delete(self, :force => true) if bucket_exists?
-  end
-end
-
-class String
-  include S3String
-end

data/lib/poolparty/modules/safe_instance.rb

@@ -1,31 +0,0 @@
-=begin rdoc
-  Make a command thread-safe
-=end
-require "monitor"
-module PoolParty
-  extend self
-  
-  module ThreadSafeInstance
-    
-    module ClassMethods
-      def make_safe(meth)
-       original_method = "_unsafe_#{meth}_"
-       alias_method original_method, meth
-       define_method(meth) {|*args| self.class.synchronize { self.send(original_method) } }
-       self
-      end  
-    end
-    
-    module InstanceMethods
-      def make_safe meth
-        self.class.make_safe meth
-      end
-    end
-    
-    def self.included(receiver)
-      receiver.extend         MonitorMixin
-      receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
-    end
-  end
-end