auser-poolparty 0.2.9 → 0.2.15

data/lib/poolparty/monitors/base_monitor.rb

@@ -6,11 +6,25 @@
 module PoolParty
   module Monitors
     
+    def self.register_monitor(*args)
+      args.each do |arg|
+        (available_monitors << "#{arg}".downcase.to_sym)
+      end
+    end
+
+    def self.available_monitors
+      $available_monitors ||= []
+    end
+    
     class BaseMonitor
       
-      
-      
+      def self.run
+        new.run
+      end
+            
     end
     
   end
-end
+end
+
+Dir["#{File.dirname(__FILE__)}/monitors/*.rb"].each {|f| require f}

data/lib/poolparty/monitors/monitors/cpu_monitor.rb

@@ -0,0 +1,15 @@
+module PoolParty
+  module Monitors
+    
+    class CpuMonitor < BaseMonitor
+      
+      def run
+        str = %x[uptime]
+        str.split(/\s+/)[-3].to_f rescue 0.0
+      end
+            
+    end
+    
+    register_monitor :cpu
+  end
+end

data/lib/poolparty/monitors/monitors/memory_monitor.rb

@@ -0,0 +1,23 @@
+module PoolParty
+  module Monitors
+    
+    class MemoryMonitor < BaseMonitor
+      
+      def run
+        str = %x[free -m | grep -i mem]
+        begin
+          total_memory = str.split[1].to_f
+          used_memory = str.split[2].to_f
+
+          used_memory / total_memory
+        rescue Exception => e
+          0.0
+        end
+        
+      end
+            
+    end
+    
+    register_monitor :memory
+  end
+end

data/lib/poolparty/net/remote_instance.rb

@@ -63,6 +63,11 @@ module PoolParty
       def to_s
         "#{name}\t#{ip}"
       end
+      
+      # Commands for the servers
+      def puppet_runner_command
+        ". /etc/profile && puppetd --onetime --no-daemonize --logdest syslog --server master > /dev/null 2>&1"
+      end
     end
     
   end  

data/lib/poolparty/net/remoter.rb

@@ -9,7 +9,7 @@ module PoolParty
     module Remoter
       def rsync_storage_files_to_command(remote_instance)
         if remote_instance
-          "#{rsync_command} #{Base.storage_directory} #{remote_instance.ip}:#{Base.remote_storage_path}"
+          "#{rsync_command} #{Base.storage_directory}/ #{remote_instance.ip}:#{Base.remote_storage_path}"
         end
       end
       def run_command_on_command(cmd="ls -l", remote_instance=nil)
@@ -195,7 +195,7 @@ module PoolParty
       end
       
       # Rsync command to the instance
-      def rsync_storage_files_to(instance=nil)        
+      def rsync_storage_files_to(instance=nil)
         hide_output do
           Kernel.system "#{rsync_storage_files_to_command(instance)}" if instance
         end
@@ -215,6 +215,16 @@ module PoolParty
       def ssh_into_instance_number(num=0)
         ssh_into( get_instance_by_number( num || 0 ) )
       end
+      
+      # Prepare reconfiguration on the master
+      # TODO: Fix the killall
+      def prepare_reconfiguration
+        unless @prepared
+          cmd = "killall ruby && rm -rf /etc/puppet/ssl/*; puppetmasterd --verbose; puppetd --test"
+          run_command_on(cmd, master)
+          @prepared = true
+        end
+      end
 
       def self.included(receiver)
         receiver.extend self

data/lib/poolparty/net/remoter_base.rb

@@ -8,7 +8,7 @@ module PoolParty
   
   def remote_bases
     $remote_bases ||= []
-  end  
+  end
 
   module Remote    
     # This class is the base class for all remote types
@@ -61,6 +61,10 @@ module PoolParty
       def list_of_nonterminated_instances(list = remote_instances_list)
         list.reject {|i| i.terminating? || i.terminated? }
       end
+      # get the master instance
+      def master
+        get_instance_by_number(0)
+      end
       # Get instance by number
       def get_instance_by_number(i=0, list = remote_instances_list)
         name = (i.zero? ? "master" : "node#{i}")

data/lib/poolparty/plugins/git.rb

@@ -3,33 +3,42 @@ module PoolParty
         
     virtual_resource(:git) do
       
-      def loaded(opts={})
+      def loaded(opts={}, parent=self)
         install_git
-        has_git_repos
       end
       
       def install_git
-        has_package(:name => "git-core")
+        has_package(:name => "git-core") do
+          has_git_repos
+        end
       end
       
       def has_git_repos
-        with_options(:requires => 'Package["git-core"]') do
-          # has_directory(:name => "#{path}")
-                    
-          exec({:name => "git-#{name}"}) do
-            command @parent.user ? "git clone #{@parent.user}@#{@parent.source} #{@parent.path}" : "git clone #{@parent.source} #{@parent.path}"
-            cwd "#{::File.dirname(@parent.path) if @parent.path}"
-            creates "#{@parent.path}/.git"
-          end
-
-          exec(:name => "git-update-#{name}", :cwd => "#{path}") do
+        exec({:name => "git-#{name}"}) do
+          command @parent.user ? "git clone #{@parent.user}@#{@parent.source} #{@parent.path}" : "git clone #{@parent.source} #{@parent.to ? @parent.to : ""}"
+          cwd "#{@parent.cwd if @parent.cwd}"
+          creates "#{::File.join( (@parent.cwd ? @parent.cwd : cwd), ::File.basename(@parent.source, ::File.extname(@parent.source)) )}/.git"
+          
+          exec(:name => "update-#{name}") do
+            cwd ::File.dirname(@parent.creates)
             command "git pull"
-            requires "Exec['git-#{@parent.name}']"
           end
-
+          
         end
       end
       
+      # Since git is not a native type, we have to say which core resource
+      # it is using to be able to require it
+      def class_type_name
+        "exec"
+      end
+      
+      # Because we are requiring an exec, instead of a built-in package of the git, we have to overload
+      # the to_s method and prepend it with the same name as above
+      def key
+        "git-#{name}"
+      end
+      
     end
     
   end

data/lib/poolparty/pool/base.rb

@@ -17,8 +17,7 @@ module PoolParty
       :remote_storage_path => "/var/poolparty",      
       :fileserver_base => "puppet:///files",
       :base_config_directory => "/etc/poolparty",
-      :template_directory => "tmp/templates",
-      :plugin_directory => "tmp/plugins",
+      :template_directory => "templates",
       :template_path => "/var/lib/puppet/templates",
       :module_path => "/etc/puppet/modules/poolparty",
       :default_specfile_name => "pool.spec",

data/lib/poolparty/pool/cloud.rb

@@ -47,7 +47,7 @@ module PoolParty
         # this can be overridden in the spec, but ec2 is the default
         self.using :ec2
       end
-                        
+                              
       # Keypairs
       # If the parent (pool) doesn't have a keypair defined on it, then generate one based on the 
       # pool_name and the cloud_name
@@ -76,7 +76,6 @@ module PoolParty
         # clear_base_directory
         make_base_directory
         copy_misc_templates
-        copy_puppet_functions
         Base.store_keys_in_file
         Script.save!
         copy_ssh_key # not my favorite...
@@ -108,13 +107,7 @@ module PoolParty
           copy_file_to_storage_directory(::File.join(::File.dirname(__FILE__), "..", "templates", f))
         end
       end
-      
-      # TODO: Fix for windowz
-      def copy_puppet_functions
-        cmd = "cp -R #{::File.join(::File.dirname(__FILE__), "..", "puppet_plugins/")} #{Base.storage_directory}/plugins"
-        %x[#{cmd}]
-      end
-      
+            
       # Configuration files
       def build_manifest
         @build_manifest ||= build_from_existing_file
@@ -168,6 +161,18 @@ module PoolParty
         ruby
         poolparty
       end
+      
+      def provisioning?
+        @provisioning_in_progress == true
+      end
+      
+      def provisioning_in_progress
+        @provisioning_in_progress = true
+      end
+      
+      def provisioning_complete
+        @provisioning_in_progress = false
+      end
             
       # Add to the services pool for the manifest listing
       def add_service(serv)

data/lib/poolparty/pool/custom_resource.rb

@@ -22,11 +22,11 @@ module PoolParty
     class CallFunction < Resource
       def initialize(str="", opts={}, parent=self, &block)
         @str = str
-        super(opts, parent, &block)
+        # super(opts, parent, &block)
       end
-      def to_string(prev="")
+      def to_string(pre="")
         returning Array.new do |arr|
-          arr << "#{prev}#{@str}"
+          arr << "#{pre}#{@str}"
         end.join("\n")
       end
     end
@@ -42,10 +42,10 @@ module PoolParty
         super(subclass)
       end
       
-      def to_string(prev="")
+      def to_string(pre="")
         returning Array.new do |output|
-          output << "#{prev} # Custom Functions\n"
-          output << self.class.custom_functions_to_string(prev)
+          output << "#{pre} # Custom Functions\n"
+          output << self.class.custom_functions_to_string(pre)
         end.join("\n")        
       end
     end

data/lib/poolparty/pool/resource.rb

@@ -17,10 +17,10 @@ module PoolParty
       resources[type] ||= []
     end
     
-    def add_resource(type, opts={}, parent=self, &block)
-      resource = get_resource(type, opts[:name])
+    def add_resource(type, opts={}, parent=self, &block)      
+      resource = get_resource(type, opts[:name], parent)
       if resource
-        return resource 
+        resource 
       else
         returning "PoolParty::Resources::#{type.to_s.camelize}".classify.constantize.new(opts, parent, &block) do |o|
           resource(type) << o
@@ -28,8 +28,8 @@ module PoolParty
       end
     end
     
-    def get_resource(type, name)
-      resource(type).select {|resource| resource.name == name }.first
+    def get_resource(type, key, parent=self)
+      resource(type).select {|resource| resource.key == key }.first
     end
             
     #:nodoc:
@@ -37,11 +37,11 @@ module PoolParty
       @resources = nil
     end
         
-    def resources_string(prev="")
-      returning Array.new do |output|        
-        output << resources_string_from_resources(resources)
-      end.join("\n")
-    end
+    # def resources_string(pre="")
+    #   returning Array.new do |output|        
+    #     output << resources_string_from_resources(resources)
+    #   end.join("\n")
+    # end
     
     def custom_file(path, str)
       write_to_file_in_storage_directory(path, str)
@@ -61,11 +61,11 @@ module PoolParty
         lowercase_class_name = subclass.to_s.downcase
         
         # Add add resource method to the Resources module
-        unless PoolParty::Resources.respond_to?(lowercase_class_name.to_sym)
+        unless PoolParty::Resources.respond_to?(lowercase_class_name.to_sym)          
           method =<<-EOE
             def #{lowercase_class_name}(opts={}, parent=self, &blk)
               add_resource(:#{lowercase_class_name}, opts, parent, &blk)
-            end            
+            end
           EOE
           PoolParty::Resources.module_eval method
           PoolParty::Resources.add_has_and_does_not_have_methods_for(lowercase_class_name.to_sym)
@@ -90,70 +90,39 @@ module PoolParty
       # Finally, it uses the parent's options as the lowest priority
       def initialize(opts={}, parent=self, &block)
         # Take the options of the parents
-        @parent = parent
+        set_resource_parent(parent)
         set_vars_from_options(opts) unless opts.empty?
         self.instance_eval &block if block
-        loaded(opts)
+        loaded(opts, @parent)
+      end
+      
+      def set_resource_parent(parent=nil)
+        if parent && parent != self
+          @parent = parent
+          requires parent.to_s if @parent.is_a?(PoolParty::Resources::Resource) && printable? && @parent.printable?
+        end
       end
       
+      # def requirement_tree
+      #   p = @parent
+      #   returning Array.new do |arr|
+      #     arr << p.to_s
+      #     while p && p != self && p.is_a?(PoolParty::Resources::Resource) && p.requires
+      #       arr << p.requires
+      #       p = p.parent
+      #     end
+      #   end.flatten.uniq
+      # end
+      
       # Stub, so you can create virtual resources
-      def loaded(opts={})
+      # This is called after the resource is initialized
+      # with the options given to it in the init-block
+      def loaded(opts={}, parent=self)
       end
       
       # DSL Overriders
-      # Overrides for syntax
-      # Allows us to send require to require a resource
-      def require(str="")
-        options[:require]
-      end
-      def requires(str="")
-        options.merge!(:require => str)
-      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.merge!(:ensure => str)
-        end        
-      end
-      # Allows us to send an ensure to ensure the presence of a resource
-      def is_present(*args)
-        options.merge!(:ensure => present)
-      end
-      # Ensures that what we are sending is absent
-      def is_absent(*args)
-        options.merge!(:ensure => absent)
-      end
-      # Alias for unless
-      def ifnot(str="")
-        options.merge!(:unless => str)
-      end
-      def present
-        "present"
-      end
-      def absent
-        "absent"
-      end
-      def cancel(*args)
-        options[:cancelled] = args.empty? ? true : args[0]
-      end
-      def cancelled?
-        options[:cancelled] || false
-      end
+      include PoolParty::ResourcingDsl
       
-      # Give us a template to work with on the resource
-      # Make sure this template is moved to the tmp directory as well
-      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)
-        else
-          copy_file_to_storage_directory(file)
-        end
-      end
       # This way we can subclass resources without worry
       def class_type_name
         self.class.to_s.top_level_class
@@ -172,11 +141,11 @@ module PoolParty
         self.class.custom_functions << str
       end
       
-      def self.custom_functions_to_string(prev="")
+      def self.custom_functions_to_string(pre="")
         returning Array.new do |output|
           PoolParty::Resources.available_custom_resources.each do |resource|
             resource.custom_functions.each do |func|
-              output << "#{prev*2}#{func}"
+              output << "#{pre*2}#{func}"
             end
           end
         end.join("\n")
@@ -191,51 +160,31 @@ module PoolParty
       def virtual_resource?
         false
       end
+      def printable?
+        true
+      end
       # We want to gather the options, but if the option sent is nil
       # then we want to override the option value by sending the key as
       # a method so that we can override this if necessary. 
       # Only runs on objects that have options defined, otherwise 
       # it returns an empty hash
       def get_modified_options
-        if options
-          opts = options.inject({}) do |sum,h| 
-            sum.merge!({h[0].to_sym => ((h[1].nil?) ? self.send(h[0].to_sym) : h[1]) })
-          end
-        else
-          opts = {}
-        end
-        opts.reject {|k,v| disallowed_options.include?(k) }
-      end
-      
-      # Generic to_s
-      # Most Resources won't need to extend this
-      def to_string(prev="")
-        opts = get_modified_options
-        returning Array.new do |output|
-          unless cancelled?
-            output << @prestring || ""
-          
-            if resources && !resources.empty?
-              @cp = classpackage_with_self(self)
-              output << @cp.to_string
-              output << "include #{@cp.name.sanitize}"
-            end
-          
-            unless virtual_resource?
-              output << "#{prev}#{class_type_name} {"
-              output << "#{prev}\"#{self.key}\":"
-              output << opts.flush_out("#{prev*2}").join(",\n")
-              output << "#{prev}}"            
+        unless @modified_options
+          if options
+            opts = options.inject({}) do |sum,h| 
+              sum.merge!({h[0].to_sym => ((h[1].nil?) ? self.send(h[0].to_sym) : h[1]) })
             end
-          
-            output << @poststring || ""
+          else
+            opts = {}
           end
-        end.join("\n")
+          @modified_options = opts.reject {|k,v| disallowed_options.include?(k) }
+        end
+        @modified_options
       end
       
-      def to_s
-        "#{class_type_name.capitalize}['#{key}']"
-      end
+      # For the time being, we'll make puppet the only available dependency resolution
+      # base, but in the future, we can rip this out and make it an option
+      include PoolParty::DependencyResolutions::Puppet
     end
     
     # Adds two methods to the module