fairchild-poolparty 1.1.4 → 1.1.5

data/lib/poolparty/dependency_resolver/puppet_resolver.rb

@@ -43,19 +43,34 @@ module PoolParty
         if opts.has_key?(:variable)
           vars = opts.delete(:variable)
           out << vars.map do |res, arr|
-            handle_print_resource(res, :variable, arr, tabs)
+            handle_print_resource(res, :variable, tabs)
           end
         end
 
         out << opts.map do |type, arr|
           arr.map do |res|
-            handle_print_resource(res, type, arr, tabs)
+            handle_print_resource(res, type, tabs)
           end
         end
       end
       out.join("\n")
     end
     
+    def resources_to_string(opts,tabs=0)
+      out = []        
+      out << opts.map do |resource|
+        case ty = resource.delete(:pp_type)
+        when "variable"
+          handle_print_variable(resource[:name], resource[:value], :variable)
+        else
+          real_name = resource[:name]
+          handle_print_resource(resource, ty.to_sym, tabs)
+        end
+      end      
+      out.join("\n")
+    end
+    
+    
     def permitted_option?(ty, key)
       true
       # if permitted_resource_options.has_key?(ty)
@@ -74,22 +89,31 @@ module PoolParty
     end
     
     def hash_flush_out(hash, pre="", post="")
-      hash.map do |k,v|
-        key = to_puppet_key(k)
-        res = to_option_string(v)
-        res.empty? ? nil : "#{pre}#{key} => #{res}#{post}"
+      setup_hash_for_output(hash).map do |k,v|
+        hash.empty? ? nil : "#{pre}#{k} => #{v}#{post}"
       end
     end
     
-    def to_puppet_key(key)
-      case key
-      when :ensures
-        "ensure"
-      else
-        "#{key}"        
+    def setup_hash_for_output(hsh)
+      ty = hsh.delete(:klasstype)
+      if hsh.has_key?(:ensures)
+        hsh.delete(:ensures)
+        hsh[:ensure] = case ty.to_s
+        when "directory"
+          "directory"
+        when "symlink"
+          hsh[:source]
+        else
+          "present"
+        end
+      end
+      new_hsh ={}
+      hsh.each do |k,v|
+        new_hsh.merge!({k => to_option_string(v)})
       end
+      new_hsh
     end
-    
+        
     def to_option_string(obj)
       case obj
       when PoolParty::Resources::Resource
@@ -136,10 +160,12 @@ module PoolParty
       end
     end
     
-    def handle_print_resource(res, type, arr, tabs)
-      case type.to_s
-      when "variable"
-        "$#{res[:name]} = #{to_option_string(res[:value])}"
+    def handle_print_variable(name, value, tabs)
+      "$#{name} = #{to_option_string(value)}"
+    end
+    
+    def handle_print_resource(res, type, tabs)
+      case type.to_s        
       when "line_in_file"
         "#{tf(tabs)}exec { \"#{res[:file]}_line_#{tabs}\": \n#{tf(tabs+1)}command => '#{PoolParty::Resources::LineInFile.command(res[:line], res[:file])}',\n#{tf(tabs+1)}path => '/usr/local/bin:$PATH'\n#{tf(tabs)}}"
       else
@@ -151,6 +177,7 @@ module PoolParty
         else
           type
         end
+        res.merge!(:klasstype => type.to_s)
         "#{tf(tabs)}#{klasstype} { \"#{res.delete(:name) }\": #{res.empty? ? "" : "\n#{tf(tabs+1)}#{hash_flush_out(res.reject {|k,v| !permitted_option?(type, k) }).reject {|s| s.nil? }.join(",\n#{tf(tabs+1)}")}"}\n#{tf(tabs)}}"
       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/optioner.rb

@@ -9,12 +9,12 @@ module PoolParty
   class Optioner
     include Dslify
     
-    default_options(:verbose => false, 
+    default_options( :verbose => false, 
                      :quiet => false, 
                      :cloudname => false, 
                      :poolname => false)
     
-    def initialize(args=[], opts={}, &block)      
+    def initialize(args=[], opts={}, &block)
       boolean_args << opts[:boolean_args] if opts.has_key?(:boolean_args)
       
       @arguments = parse_args(args)
@@ -132,11 +132,18 @@ module PoolParty
     
     def process_options
     end
+    
+    def output_options
+      puts ""
+    end
         
     def output_version
       puts ::PoolParty::Version
     end
     
+    def output_options      
+    end
+    
   end
   
   def extract_cloud_from_options(o)

data/lib/poolparty/lite.rb

@@ -1,16 +1,26 @@
 require "rubygems"
 require "json"
-require("#{::File.dirname(__FILE__)}/../../vendor/gems/dslify/lib/dslify")
+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__)}/net/init"
+require "#{::File.dirname(__FILE__)}/core/string"
+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  
 end
 
 class String

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,14 +1,15 @@
 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)
-    end
+    
+    # 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")
@@ -22,8 +23,13 @@ module PoolParty
     def disable(service);dsl_options[service] = :disabled;end
     
     # Check to see if the package has been enabled
-    def enabled?(srv)
-      dsl_options.has_key?(srv) && dsl_options[srv] == :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

@@ -38,6 +38,8 @@ module PoolParty
     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
@@ -46,6 +48,8 @@ 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
@@ -54,8 +58,12 @@ module PoolParty
     def setup_dev
       return true if keypair || master.nil?
     end
-    
-    def using(t)
+        
+    # 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?
@@ -63,31 +71,31 @@ module PoolParty
           self.class.send :attr_reader, :parent_cloud
           klass_string = "#{t}".classify
           klass = "::PoolParty::Remote::#{klass_string}".constantize
-          @remote_base = klass.send :new, self
+          
+          @remote_base = klass.send :new, self, &block
+          @remote_base.instance_eval &block if block          
           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;"
+          instance_eval "def #{t};@remote_base;end"
         end
       else
-        puts "Unknown remote base" 
+        raise "Unknown remote base: #{t}"
       end
     end
     
+    # Are we using a remoter?
     def using_remoter?
-      @remote_base
+      !@remote_base.nil?
     end
     
     # Keypairs
     # Use the keypair path
     def keypair(*args)
       if args && !args.empty?
-        args.each {|arg| _keypairs.unshift Key.new(arg) }
+        args.each {|arg| _keypairs.unshift Key.new(arg) unless arg.nil? || arg.empty? }
       else
-        _keypairs.select {|key| key.exists? }.first
+        @keypair ||= _keypairs.select {|key| key.exists? }.first
       end
     end
     
@@ -97,10 +105,19 @@ module PoolParty
       dsl_options[:keypairs] ||= [Key.new]
     end
     
-    def full_keypair_path      
+    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|
@@ -109,14 +126,5 @@ module PoolParty
       resources.map {|n,r| r.size}.inject(0){|sum,i| sum+=i}
     end
     
-    def plugin_store
-      @plugin_store ||= []
-    end
-    
-    # TODO: deprecate
-    def realize_plugins!(force=false)
-      plugin_store.each {|plugin| puts "plugin: #{plugin}";plugin.realize!(force) if plugin }
-    end
-    
   end
 end

data/lib/poolparty/modules/definable_resource.rb

@@ -16,7 +16,7 @@ module PoolParty
     # 
     # For example usage, see lib/poolparty/plugins/line.rb
     def define_resource(name, &block)
-      name.to_s.new_resource_class(PoolParty::Resources::Resource, &block)
+      name.to_s.new_resource_class &block
     end
     
     # Allow us to create virtual resources

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/resourcing_dsl.rb

@@ -8,14 +8,18 @@ module PoolParty
     def on_change(str=nil)
       str ? dsl_options.merge!(:notify => send_if_method(str)) : dsl_options[:notify]
     end
-    def ensures(str="running")
+    def ensures(str = :present)
+      if [:absent, :present].include?(str) 
         str == :absent ? is_absent : is_present
+      else
+        str
+      end
     end
     def present
-      "present"
+      :install
     end
     def absent
-      "absent"
+      :remove
     end
     # Allows us to send an ensure to ensure the presence of a resource
     def is_present(*args)

data/lib/poolparty/modules/thread_pool.rb

@@ -1,106 +1,107 @@
-require 'thread'
-begin
-  require 'fasttread'
-rescue LoadError
-end
-
-class ThreadPool
-  class Worker
-    def initialize(thread_queue)
-      @mutex = Mutex.new
-      @cv = ConditionVariable.new
-      @queue = thread_queue
-      @running = true
-      @thread = Thread.new do
-        @mutex.synchronize do
-          while @running
-            @cv.wait(@mutex)
-            block = get_block
-            if block
-              @mutex.unlock
-              block.call
-              @mutex.lock
-              reset_block
-            end
-            @queue << self
-          end
-        end
-      end
-    end
-
-    def name
-      @thread.inspect
-    end
-
-    def get_block
-      @block
-    end
-
-    def set_block(block)
-      @mutex.synchronize do
-        raise RuntimeError, "Thread already busy." if @block
-        @block = block
-        # Signal the thread in this class, that there's a job to be done
-        @cv.signal
-      end
-    end
-
-    def reset_block
-      @block = nil
-    end
-
-    def busy?
-      @mutex.synchronize { !@block.nil? }
-    end
-
-    def stop
-      @mutex.synchronize do
-        @running = false
-        @cv.signal
-      end
-      @thread.join
-    end
-  end
-
-  attr_accessor :max_size
-
-  def initialize(max_size = 10)
-    @max_size = max_size
-    @queue = Queue.new
-    @workers = []
-  end
-
-  def size
-    @workers.size
-  end
-
-  def busy?
-    @queue.size < @workers.size
-  end
-
-  def shutdown
-    @workers.each { |w| w.stop }
-    @workers = []
-  end
-
-  alias :join :shutdown
-
-  def process(block=nil,&blk)
-    block = blk if block_given?
-    worker = get_worker
-    worker.set_block(block)
-  end
-
-  private
-
-  def get_worker
-    if !@queue.empty? or @workers.size == @max_size
-      return @queue.pop
-    else
-      worker = Worker.new(@queue)
-      @workers << worker
-      worker
-    end
-  end
-
-end
+# TODO: Deprecate
+# require 'thread'
+# begin
+#   require 'fasttread'
+# rescue LoadError
+# end
+# 
+# class ThreadPool
+#   class Worker
+#     def initialize(thread_queue)
+#       @mutex = Mutex.new
+#       @cv = ConditionVariable.new
+#       @queue = thread_queue
+#       @running = true
+#       @thread = Thread.new do
+#         @mutex.synchronize do
+#           while @running
+#             @cv.wait(@mutex)
+#             block = get_block
+#             if block
+#               @mutex.unlock
+#               block.call
+#               @mutex.lock
+#               reset_block
+#             end
+#             @queue << self
+#           end
+#         end
+#       end
+#     end
+# 
+#     def name
+#       @thread.inspect
+#     end
+# 
+#     def get_block
+#       @block
+#     end
+# 
+#     def set_block(block)
+#       @mutex.synchronize do
+#         raise RuntimeError, "Thread already busy." if @block
+#         @block = block
+#         # Signal the thread in this class, that there's a job to be done
+#         @cv.signal
+#       end
+#     end
+# 
+#     def reset_block
+#       @block = nil
+#     end
+# 
+#     def busy?
+#       @mutex.synchronize { !@block.nil? }
+#     end
+# 
+#     def stop
+#       @mutex.synchronize do
+#         @running = false
+#         @cv.signal
+#       end
+#       @thread.join
+#     end
+#   end
+# 
+#   attr_accessor :max_size
+# 
+#   def initialize(max_size = 10)
+#     @max_size = max_size
+#     @queue = Queue.new
+#     @workers = []
+#   end
+# 
+#   def size
+#     @workers.size
+#   end
+# 
+#   def busy?
+#     @queue.size < @workers.size
+#   end
+# 
+#   def shutdown
+#     @workers.each { |w| w.stop }
+#     @workers = []
+#   end
+# 
+#   alias :join :shutdown
+# 
+#   def process(block=nil,&blk)
+#     block = blk if block_given?
+#     worker = get_worker
+#     worker.set_block(block)
+#   end
+# 
+#   private
+# 
+#   def get_worker
+#     if !@queue.empty? or @workers.size == @max_size
+#       return @queue.pop
+#     else
+#       worker = Worker.new(@queue)
+#       @workers << worker
+#       worker
+#     end
+#   end
+# 
+# end

data/lib/poolparty/modules/user_helpers.rb

@@ -0,0 +1,20 @@
+module PoolParty
+  # Require all the files in a directory below the base
+  def require_user_directory(dirname)    
+    begin
+      cloud_dir = ::File.dirname($pool_specfile)
+      Dir["#{cloud_dir}/#{dirname}/**"].each {|a| require a }
+    rescue Exception => e
+      vputs "Error requiring user directory #{dirname}: #{e}"
+    end
+  end
+
+  # Add to the suitcase files below the clouds.rb base directory
+  def pack_user_directory(dirname)
+    begin
+      ::Suitcase::Zipper.add("#{::File.dirname($pool_specfile)}/#{dirname}", "etc")
+    rescue Exception => e
+      vputs "Error packing user directory #{dirname}: #{e}"
+    end    
+  end
+end