poolparty 0.2.84 → 1.2.2

data/lib/poolparty/helpers/binary.rb

@@ -2,26 +2,31 @@ require "ftools"
 module PoolParty
   
   # Load a file that contains a pool into memory
-  def load_pool(filename)
-
+  def load_pool(filename=nil)
+    filename = filename || Binary.get_existing_spec_location
+    dputs "Using spec at #{filename}"
+    
     unless filename && ::File.readable?(filename)
-      puts "Please specify your cloud with -s, move it to ./clouds.pool or in your POOL_SPEC environment variable"
+      puts "Please specify your cloud with -s, move it to ./clouds.rb or in your POOL_SPEC environment variable"
       exit(1)
     else
       $pool_specfile = filename
-      PoolParty::Script.inflate(open(filename).read, filename)
+      PoolParty::Pool::Pool.load_from_file filename
     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
+  # Helper to print with the nice printer
+  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
   
+  # Keep the pool_specfile 
   def pool_specfile
     $pool_specfile
   end
@@ -42,32 +47,21 @@ module PoolParty
       # These are the locations the spec file can be before the cloud
       # aborts because it cannot load the cloud
       def get_existing_spec_location
-        [                            
-            "#{Base.remote_storage_path}/#{Base.default_specfile_name}", 
-            "#{Base.default_specfile_name}",
-            ENV["POOL_SPEC"],            
-            "#{Base.storage_directory}/#{Base.default_specfile_name}",
-            "#{Base.base_config_directory}/#{Base.default_specfile_name}",
-            "#{Base.default_project_specfile_name}"
-        ].reject {|a| a.nil?}.reject do |f|
+        [ 
+          "#{Dir.pwd}/#{Default.default_specfile_name}",
+          Dir["#{Dir.pwd}/*/#{Default.default_specfile_name}"],
+          "#{Default.remote_storage_path}/#{Default.default_specfile_name}", 
+          "#{Default.default_specfile_name}",            
+          "#{Default.base_config_directory}/#{Default.default_specfile_name}",
+          "#{Default.poolparty_home_path}/#{Default.default_specfile_name}",          
+          ENV["POOL_SPEC"]
+        ].flatten.reject {|a| a.nil?}.reject do |f|
           f unless ::File.readable?(f)
         end.first
       end
       # Daemonize the process
       def daemonize(&block)
-        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
-        Process.detach(pid)
-        pid
+        Daemonize.daemonize(&block)
       end
       
     end

data/lib/poolparty/helpers/console.rb

@@ -20,7 +20,7 @@ module PoolParty
       if level >= 1
         @np.center "CloudSpeak"
         @np << "All the commands set on your cloud can be called within the console"
-        @np << "list_of_running_instances - get list of running nodes"
+        @np << "instances_by_status('running') - get list of running nodes"
         @np << "list_of_pending_instances - get list of pending nodes"
         @np << "available_monitors - get list of the available monitors on the cloud"
         @np << "  note: all monitors can be called as a method on the cloud"

data/lib/poolparty/helpers/display.rb

@@ -17,11 +17,7 @@ module PoolParty
       puts ""
       pools.size
     end
-    
-    def available_bases
-      puts Remote.available_bases
-    end
-    
+        
     def header(str="")
       "*** #{str}"
     end

data/lib/poolparty/helpers/hash_printer.rb

@@ -0,0 +1,44 @@
+module PoolParty
+  class HashPrinter
+    def self.print_to_string(props={})
+<<-EOE
+Top Level
+  #{print_hash(props, 1)}
+EOE
+    end
+    def self.print_hash(props={}, tabs=0)
+      out = []
+      if props[:options]
+        out << props[:options].map {|k,v| "#{print_tabs(tabs)}#{k} => #{print_value(v)}"}.join("#{print_tabs(tabs)}\n")
+      end
+      if props[:resources]
+        props[:resources].each do |ty,r|
+          out << [
+            "#{print_tabs(tabs)}#{ty.to_s.capitalize}",
+            r.map {|h| h.map {|k,v| "#{print_tabs(tabs+1)}#{k} => #{print_value(v)}"}}.join("#{print_tabs(tabs+1)}\n")
+          ].join("\n")
+        end
+      end
+      if props[:services]
+        props[:services].each do |nm,s|
+          out << [
+            "#{print_tabs(tabs)}#{nm.to_s.capitalize}",
+            print_hash(s,tabs+1)
+          ].join("\n")
+        end
+      end
+      out.join("\n")
+    end
+    def self.print_tabs(tabs=1)
+      "#{"\t"*tabs}"
+    end
+    def self.print_value(v)
+      case v
+      when Array
+        "[#{v.join(", ")}]"
+      else
+        v
+      end
+    end
+  end
+end

data/lib/poolparty/helpers/loading.rb

@@ -0,0 +1,4 @@
+module PoolParty
+  module Loading
+  end
+end

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
     
-    def initialize(args=[], opts={}, &block)      
+    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 = OptionParser.new
+      @opts.extend(Dslify)
       @opts.banner = "Usage: #{progname} #{@abstract ? "[command] " : ""}[options]"
 
       @opts.separator ""
@@ -82,15 +88,15 @@ module PoolParty
       unless @abstract
         @opts.separator "Options:"
         
-        @opts.on('-v', '--verbose', 'Be verbose')    { self.verbose true }  
-        @opts.on("--debug", "Debug setting") {self.debug 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
       
-      @opts.on('-V', '--version', 'Display the version')    { puts @version ; exit 0 }
+      @opts.on('-V', '--version', 'Display the version')    { output_version ; exit 0 }
       @opts.on_tail("-h", "--help", "Show this message") do
         puts @opts
         puts @extra_help
@@ -103,31 +109,39 @@ 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.pool or in your POOL_SPEC environment variable") unless loaded_clouds && !loaded_clouds.empty?
+        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
+    
+    def output_options
+      puts ""
+    end
         
     def output_version
-      puts @version
+      puts ::PoolParty::Version
+    end
+    
+    def output_options      
     end
     
   end

data/lib/poolparty/lite.rb

@@ -0,0 +1,30 @@
+require "rubygems"
+require "json"
+begin
+  require "#{::File.dirname(__FILE__)}/../../vendor/gems/dslify/lib/dslify"
+rescue Exception => e
+  require "dslify"
+end
+require "#{::File.dirname(__FILE__)}/poolparty/default"
+require "#{::File.dirname(__FILE__)}/modules/user_helpers"
+require "#{::File.dirname(__FILE__)}/schema"
+require "#{::File.dirname(__FILE__)}/core/string"
+require "#{::File.dirname(__FILE__)}/net/init"
+require "#{::File.dirname(__FILE__)}/core/hash"
+require "#{::File.dirname(__FILE__)}/poolparty/neighborhoods"
+require "#{::File.dirname(__FILE__)}/exceptions/RemoteException.rb"
+
+module PoolParty
+  extend ::PoolParty::Remote
+  
+  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/callbacks.rb

@@ -0,0 +1,44 @@
+module PoolParty
+  module Callbacks
+    module ClassMethods
+      def additional_callbacks(arr=[])
+        @additional_callbacks ||= arr
+      end
+    end
+    
+    module InstanceMethods
+      def defined_callbacks
+        [
+          :before_bootstrap,
+          :after_bootstrap,
+          :before_configure,
+          :after_configure,
+          :after_create,
+          # TODO: Add after_launch_instance and after_terminate_instance
+          # :after_launch_instance,
+          # :after_terminate_instance,
+          self.class.additional_callbacks
+        ].flatten
+      end
+      
+      # Callbacks on bootstrap and configuration
+      def setup_callbacks
+        defined_callbacks.each do |meth|
+          unless respond_to?("call_#{meth}_callbacks".to_sym)
+            self.class.module_eval <<-EOE
+              def call_#{meth}_callbacks(*args)
+                plugin_store.each {|a| a.call_#{meth}_callbacks(*args) } if respond_to?(:plugin_store) && plugin_store
+                self.send :#{meth}, *args if respond_to?(:#{meth})
+              end
+            EOE
+          end
+        end
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods      
+    end
+  end
+end

data/lib/poolparty/modules/cloud_dsl.rb

@@ -1,13 +1,43 @@
 module PoolParty
   module CloudDsl
-        
-    def mount_ebs_volume_at(id="", loc="/data")
-      ebs_volume_id id
-      ebs_volume_mount_point loc
-      ebs_volume_device "/dev/#{id.sanitize}"
-            
-      has_mount(:name => loc, :device => ebs_volume_device)
-      has_directory(:name => loc)
+    
+    # TODO: Add to ec2 remoter_base
+    # def mount_ebs_volume_at(id="", loc="/data")
+    #   ebs_volume_id id
+    #   ebs_volume_mount_point loc
+    #   ebs_volume_device "/dev/#{id.sanitize}"
+    #         
+    #   has_mount(:name => loc, :device => ebs_volume_device)
+    #   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
+    
+    # Enable a service package
+    def enable(*services)
+      services.each do |service|
+        dsl_options[service] = :enabled
+      end
+    end
+    # Disable a service package
+    def disable(*services)
+      services.each do |service|
+        dsl_options[service] = :disabled
+      end
+    end
+    
+    # Check to see if the package has been enabled
+    def enabled?(srv);dsl_options.has_key?(srv) && dsl_options[srv] == :enabled;end
+    
+    # All services that are :enabled and have a plugin that corresponds, call on the cloud
+    def add_optional_enabled_services
+      dsl_options.each do |k,v|
+        self.send k if enabled?(k) && respond_to?(k)
+      end
     end
     
   end

data/lib/poolparty/modules/cloud_resourcer.rb

@@ -1,11 +1,25 @@
+=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(*args)
-      args = ["#{::File.expand_path(Dir.pwd)}/plugins"] if args.empty?
-      args.each {|arg| Dir["#{arg}/*/*.rb"].each {|f| require f rescue "" }}
+    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
@@ -24,7 +38,9 @@ module PoolParty
     end
     
     # Set instances with a range or a number
-    def instances(arg)      
+    # 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
@@ -32,103 +48,73 @@ module PoolParty
       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
-    
-    def setup_dev
-      unless ::File.exists?("#{full_keypair_basename_path}.pub")
-        cmd = "scp #{ssh_array.join(" ")} #{Base.user}@#{master.ip}:.ssh/authorized_keys #{full_keypair_basename_path}.pub"
-        vputs "Running #{cmd}"
-        Kernel.system(cmd)
-      end
-    end
-    
-    def full_keypair_path
-      unless keypair_path
-        raise RuntimeException.new("Keypair cannot be found")        
+        
+    # 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
-        ::File.expand_path(keypair_path)
+        raise "Unknown remote base: #{t}"
       end
     end
-    def full_pub_keypair_path
-      @full_pub_keypair_path ||= ::File.expand_path("#{full_keypair_basename_path}.pub")
-    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
+    # Are we using a remoter?
+    def using_remoter?
+      !@remote_base.nil?
     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) unless arg.nil? || arg.empty? }
+      else
+        @keypair ||= _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
+    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
       
-      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
@@ -136,21 +122,5 @@ 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
-    
-    def realize_plugins!(force=false)
-      plugin_store.each {|plugin| plugin.realize!(force) if plugin }
-    end
-    
-    def plugin_store
-      @plugins ||= []
-    end
-    
   end
 end