auser-poolparty 1.0.0 → 1.1.1

data/lib/poolparty/helpers/optioner.rb

@@ -1,18 +1,22 @@
 require 'optparse' 
 require "poolparty"
 require "poolpartycl"
-require 'rdoc/usage'
+# require 'rdoc/usage'
 require 'ostruct'
 require 'date'
 
 module PoolParty
   class Optioner
-    include Configurable
-    include MethodMissingSugar
+    include Dslify
+    
+    default_options(:verbose => false, 
+                     :quiet => false, 
+                     :cloudname => false, 
+                     :poolname => false)
     
     def initialize(args=[], opts={}, &block)      
       boolean_args << opts[:boolean_args] if opts.has_key?(:boolean_args)
-
+      
       @arguments = parse_args(args)
       @extra_help = opts.has_key?(:extra_help) ? opts[:extra_help] : ""
       @abstract = opts.has_key?(:abstract) ? opts[:abstract] : false
@@ -21,11 +25,10 @@ module PoolParty
       @command = opts.has_key?(:command) ? opts[:command] : false
       
       parse_options(&block) if @parse_options
-      set_default_options
       self
     end
     def daemonizeable
-      @opts.on('-d', '--daemonize', 'Daemonize starting the cloud')    { self.daemon true }
+      @opts.on('-D', '--daemonize', 'Daemonize starting the cloud')    { self.daemon true }
     end
     def cloudnames
       @opts.on('-n cloudname', '--name name', 'Start cloud by this name')    { |c| self.cloudname c }
@@ -63,18 +66,21 @@ module PoolParty
       args
     end
     
+    # def parent
+    #   self
+    # end
+    
     def parent
       self
     end
     
-    def set_default_options
-      self.verbose false
-      self.quiet false
-    end
-    
     def parse_options(&blk)
+      self.spec = nil
+      self.num = nil
+      
       progname = $0.include?("-") ? "#{::File.basename($0[/(\w+)-/, 1])} #{::File.basename($0[/-(.*)/, 1])}" : ::File.basename($0)
       @opts = OptionParser.new
+      @opts.extend(Dslify)
       @opts.banner = "Usage: #{progname} #{@abstract ? "[command] " : ""}[options]"
 
       @opts.separator ""
@@ -82,10 +88,10 @@ module PoolParty
       unless @abstract
         @opts.separator "Options:"
         
-        @opts.on('-v', '--verbose', 'Be verbose')    { self.verbose true }  
-        @opts.on('', "--debug", "Debug setting") {self.debugging true}
-        @opts.on('-s [file]', '--spec-file [file]', 'Set the spec file')      { |file| self.spec file.chomp }
-        @opts.on('-t', '--test', 'Testing mode')    { self.testing true }
+        @opts.on('-v', '--verbose', 'Be verbose') { self.verbose true }  
+        @opts.on('-d', "--debug", "Debug setting") { self.debugging true }
+        @opts.on('-s [file]', '--spec-file [file]', 'Set the spec file') { |file| self.spec file.chomp }
+        @opts.on('-t', '--test', 'Testing mode') { self.testing true }
         
         blk.call(@opts, self) if blk
       end
@@ -103,26 +109,27 @@ module PoolParty
       output_options if verbose
       
       if @load_pools
-        self.loaded_pool load_pool(self.spec || Binary.get_existing_spec_location)
-
+        self.loaded_pool load_pool( spec? ? spec : Binary.get_existing_spec_location)
         self.loaded_clouds extract_cloud_from_options(self)
         self.loaded_pools extract_pool_from_options(self)
 
         reject_junk_options!
         raise CloudNotFoundException.new("Please specify your cloud with -s, move it to ./clouds.rb or in your POOL_SPEC environment variable") unless loaded_clouds && !loaded_clouds.empty?
         loaded_pools.each do |pl|
-          pl.configure(self.options)
+          pl.options(self.options)
         end
         loaded_clouds.each do |cl|
-          cl.configure(self.options)
+          cl.options(self.options)
         end
       end
     end
+    
     def reject_junk_options!
       %w(loaded_pool cloudname extract_pool_from_options).each do |opt|
-        @options.delete(opt.to_sym)
+        @dsl_options.delete(opt.to_sym)
       end
     end
+    
     def process_options
     end
         

data/lib/poolparty/lite.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require "json"
+require 'dslify' rescue 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"
+require "#{::File.dirname(__FILE__)}/exceptions/RemoteException.rb"
+
+module PoolParty
+  def self.load_cloud_from_json(json_file_path=nil)
+    json_file = json_file_path || PoolParty::Default.properties_hash_file
+    PoolParty::Schema.new( ::File.read(json_file) ) rescue exit 1
+  end
+end
+
+class String
+  def camelcase
+    gsub(/(^|_|-)(.)/) { $2.upcase }
+  end
+end

data/lib/poolparty/modules/cloud_dsl.rb

@@ -10,5 +10,11 @@ module PoolParty
       has_directory(:name => loc)
     end
     
+    def dependency_resolver(name='puppet')
+      klass = name.preserved_class_constant("Resolver")
+      raise DependencyResolverException.new("Unknown resolver") unless klass
+      dsl_options[:dependency_resolver] = klass unless dsl_options[:dependency_resolver]
+    end
+    
   end
 end

data/lib/poolparty/modules/cloud_resourcer.rb

@@ -11,9 +11,15 @@ require "ftools"
 module PoolParty
   module CloudResourcer
     
-    def plugin_directory(*args)
-      args = ["#{::File.expand_path(Dir.pwd)}/plugins"] if args.empty?
-      args.each {|arg| Dir["#{arg}/*/*.rb"].each {|f| require f }}
+    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
@@ -32,7 +38,7 @@ module PoolParty
     end
     
     # Set instances with a range or a number
-    def instances(arg)      
+    def instances(arg)
       case arg
       when Range
         minimum_instances arg.first
@@ -46,118 +52,56 @@ module PoolParty
     end
     
     def setup_dev
-      return true if ::File.exists?("#{remote_keypair_path}") || master.nil?
-      # unless ::File.exists?("#{full_keypair_basename_path}.pub")
-      #   cmd = "scp #{scp_array.join(" ")} #{Base.user}@#{master.ip}:.ssh/authorized_keys #{full_keypair_basename_path}.pub"
-      #   vputs "Running #{cmd}"
-      #   if %x[hostname].chomp == "master"
-      #     Kernel.system("cat ~/.ssh/authorized_keys > #{full_keypair_basename_path}.pub")
-      #   else
-      #     Kernel.system(cmd)
-      #   end
-      # end
-    end
-    
-    # Keypairs
-    def keypair(*args)
-      if args && !args.empty? && !has_keypair?
-        options[:keypair] = args.first
-      else
-        options[:keypair] ||= generate_keypair
-      end
-    end
-        
-    # Let's just make sure that the keypair exists on the options
-    def has_keypair?
-      options.has_key?(:keypair) && options[:keypair] && !options[:keypair].empty?
-    end
-    # Generate a keypair based on the parent's name (if there is a parent)
-    # and the cloud's name
-    def generate_keypair(*args)
-      options[:keypair] = "#{parent && parent.is_a?(PoolParty::Pool::Pool) ? parent.name : "poolparty"}_#{name}" unless has_keypair?
-    end
-    
-    def full_keypair_path
-      unless keypair_path
-        raise RuntimeException.new("Keypair cannot be found")        
+      return true if keypair || master.nil?
+    end
+    
+    def using(t)
+      @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
+          options[:remote_base] = klass.to_s if respond_to?(:options)
+                    
+          remote_instance_klass = "::PoolParty::Remote::#{klass_string}RemoteInstance"
+          options[:remote_instance_base] = remote_instance_klass if respond_to?(:options)
+          
+          @parent_cloud = @cloud
+          instance_eval "def #{t};@remote_base;end;"
+        end
       else
-        ::File.expand_path(keypair_path)
+        puts "Unknown remote base" 
       end
     end
-    def full_keypair_basename_path
-      dir = ::File.dirname(full_keypair_path)
-      basename = ::File.basename(full_keypair_path, ::File.extname(full_keypair_path))
-      ::File.join(dir, basename)
-    end
     
-    def keypair_path
-      keypair_paths.each do |path|
-        possible_keypair_basenames.each do |base|
-          full_path = ::File.join( File.expand_path(path), "#{base}#{keypair}")
-          return full_path if ::File.exists?(full_path)
-        end
-      end
-      return nil
+    def using_remoter?
+      @remote_base
     end
     
-    # The keypair name can be one name or another including id_rsa or not
-    # So let's get the name that exists as a keypair
-    def full_keypair_name
-      keypair_paths.each do |path|
-        possible_keypair_basenames.each do |base|
-          full_path = ::File.join( File.expand_path(path), "#{base}#{keypair}")
-          return "#{base}#{keypair}" if ::File.exists?(full_path)
-        end
+    # Keypairs
+    # Use the keypair path
+    def keypair(*args)
+      if args && !args.empty?
+        args.each {|arg| _keypairs.unshift Key.new(arg) }
+      else
+        _keypairs.select {|key| key.exists? }.first
       end
-      return nil
     end
     
-    def remote_keypair_path
-      ::File.join( keypair_paths.last, "#{possible_keypair_basenames.first}#{keypair}" )
-    end
-    def new_keypair_path
-      ::File.join( keypair_paths.first, "#{possible_keypair_basenames.first}#{keypair}" )
-    end
+    alias :set_keypairs :keypair
     
-    def possible_keypair_basenames
-      [
-        "id_rsa-",
-        ""
-      ]
+    def _keypairs
+      dsl_options[:keypairs] ||= [Key.new]
     end
     
-    def keypair_paths
-      [
-        Base.base_keypair_path,
-        Base.base_config_directory,
-        Base.remote_storage_path        
-      ]
-    end
-    
-    def context_stack
-      @@context_stack ||= []
+    def full_keypair_path      
+      @full_keypair_path ||= keypair.full_filepath
     end
     
-    def run_setup(parent, should_set_parent=true, &block)
-      context_stack.push parent
-      
-      set_parent if should_set_parent
-      run_in_context self, &block if block
-      
-      context_stack.pop
-    end
-    
-    # Set the parent on the resource
-    def set_parent(sink_options=true)
-      unless context_stack.last.nil?
-        @parent = context_stack.last
-        # Add self as a service on the parent
-        parent.add_service(self) if parent.respond_to?(:add_service)
-        # Take the options of the parents
-        configure(parent.options) if parent && parent.respond_to?(:options) && sink_options
-      end
-    end
-            
+    # TODO: deprecate
     def number_of_resources
       arr = resources.map do |n, r|
         r.size
@@ -165,20 +109,13 @@ module PoolParty
       resources.map {|n,r| r.size}.inject(0){|sum,i| sum+=i}
     end
     
-    def parent
-      @parent ||= nil
-    end
-    
     def plugin_store
       @plugin_store ||= []
     end
     
+    # TODO: deprecate
     def realize_plugins!(force=false)
-      plugin_store.each {|plugin| plugin.realize!(force) if plugin }
-    end
-    
-    def plugin_store
-      @plugins ||= []
+      plugin_store.each {|plugin| puts "plugin: #{plugin}";plugin.realize!(force) if plugin }
     end
     
   end

data/lib/poolparty/modules/daemonizable.rb

@@ -1,140 +1,141 @@
-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::Base.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
+# 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

@@ -36,7 +36,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 +44,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