poolparty 0.2.6 → 0.2.18

data/lib/poolparty/plugins/git.rb

@@ -3,38 +3,36 @@ module PoolParty
         
     virtual_resource(:git) do
       
-      def loaded(opts={})
-        install_git
+      def loaded(opts={}, parent=self)
         has_git_repos
       end
-      
-      def install_git
-        has_package(:name => "git-core")
-      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}", "#{@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
-
-          if symlink
-            has_file(:name => "#{symlink}") do
-              ensures @parent.path
-            end
           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

@@ -13,18 +13,17 @@ module PoolParty
       :environment => "production",
       :user => "root", # This should change here
       :base_keypair_path => "~/.ec2",
-      :tmp_path => "tmp",
-      :remote_storage_path => "/var/poolparty",
-      :storage_directory => File.join(Dir.pwd, "tmp"),
+      :tmp_path => "/tmp/poolparty",
+      :remote_storage_path => "/var/poolparty",      
       :fileserver_base => "puppet:///files",
       :base_config_directory => "/etc/poolparty",
-      :template_directory => "tmp/templates",
+      :template_directory => "templates",
       :template_path => "/var/lib/puppet/templates",
+      :module_path => "/etc/puppet/modules/poolparty",
       :default_specfile_name => "pool.spec",
       :port => "80",
       :forwarding_port => "8080",
-      :proxy_mode => "http",
-      :pool_logger_location => File.join(Dir.pwd, "logs"),
+      :proxy_mode => "http",      
       # EC2 Options
       :ami => "ami-1cd73375" 
     })
@@ -69,6 +68,23 @@ module PoolParty
           "ppkeys"
         ]
       end
+            
+      def storage_directory
+        [
+            "/var/poolparty"           
+        ].select do |dir|
+          dir if ::File.directory?(dir) && ::File.readable?(dir)
+        end.first || ::File.join( "/tmp/poolparty")
+      end
+      
+      def pool_logger_location
+        File.join(Dir.pwd, "logs")
+      end
+      
+      # Array of allowed_commands that you can run on the remote nodes
+      def allowed_commands
+        @allowed_commands ||= open(::File.join( ::File.dirname(__FILE__), "..", "config", "allowed_commands.yml")).read.split(/\n/).map {|a| a.chomp }
+      end
       
     end
   end    

data/lib/poolparty/pool/cloud.rb

@@ -47,18 +47,21 @@ 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
       def keypair(*args)
         has_keypair? ? options[:keypair] : generate_keypair(*args)
       end
+      # Let's just make sure that the keypair exists on the options
       def has_keypair?
         options.has_key?(:keypair) && options[:keypair]
       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] = args.length > 0 ? args[0] : "#{@parent.respond_to?(:name) ? @parent.name : ""}_#{@name}"
+        options[:keypair] = args.length > 0 ? args[0] : "#{@parent && @parent.respond_to?(:name) ? @parent.name : ""}_#{@name}"
       end
       
       # Prepare to send the new configuration to the instances
@@ -104,13 +107,14 @@ module PoolParty
           copy_file_to_storage_directory(::File.join(::File.dirname(__FILE__), "..", "templates", f))
         end
       end
-      
+            
       # Configuration files
       def build_manifest
+        @build_manifest ||= build_from_existing_file
         unless @build_manifest
           reset_resources!
           add_poolparty_base_requirements
-
+          
           @build_manifest = returning Array.new do |str|
 
             str << resources_string_from_resources(resources)
@@ -130,6 +134,14 @@ module PoolParty
         @build_manifest
       end
       
+      def build_from_existing_file
+        if ::FileTest.file?("/etc/puppet/manifests/classes/poolparty.pp")
+          open("/etc/puppet/manifests/classes/poolparty.pp").read
+        else
+          nil
+        end
+      end
+      
       # To allow the remote instances to do their job,
       # they need a few options to run, these are the required options
       # to be saved on the remote "master" machine
@@ -149,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/loggable.rb

@@ -1,3 +1,6 @@
+=begin rdoc
+  A logging class to allow us to log to locations
+=end
 class Loggable
   def initialize
     Logging.init :debug, :info, :warn, :error, :fatal

data/lib/poolparty/pool/pool.rb

@@ -39,7 +39,7 @@ module PoolParty
       end
       
       def plugin_directory(*args)
-        args.each {|arg| Dir["#{arg}/*.rb"].each {|f| load f }}
+        args.each {|arg| Dir["#{arg}/*/*.rb"].each {|f| require f }}
       end
             
       # This is where the entire process starts

data/lib/poolparty/pool/resource.rb

@@ -17,14 +17,19 @@ module PoolParty
       resources[type] ||= []
     end
     
-    def add_resource(type, opts={}, parent=self, &block)
-      returning "PoolParty::Resources::#{type.to_s.camelize}".classify.constantize.new(opts, parent, &block) do |o|
-        resource(type) << o
+    def add_resource(type, opts={}, parent=self, &block)      
+      resource = get_resource(type, opts[:name], parent)
+      if resource
+        resource 
+      else
+        returning "PoolParty::Resources::#{type.to_s.camelize}".classify.constantize.new(opts, parent, &block) do |o|
+          resource(type) << o
+        end
       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:
@@ -32,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)
@@ -56,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)
@@ -85,64 +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
+      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
@@ -161,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")
@@ -180,47 +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]) })
+        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
+          else
+            opts = {}
           end
-        else
-          opts = {}
+          @modified_options = opts.reject {|k,v| disallowed_options.include?(k) }
         end
-        opts.reject {|k,v| disallowed_options.include?(k) }
+        @modified_options
       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|
-          
-          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}}"            
-          end
-          
-          output << @poststring || ""
-                    
-        end.join("\n")
-      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

data/lib/poolparty/pool/resources/class_package.rb

@@ -27,14 +27,14 @@ module PoolParty
       def to_string
         returning String.new do |output|
           output << "# #{name.sanitize}"
-          output << "\nclass #{name.sanitize} {\n"
+          output << "\nclass #{name.sanitize.downcase} {\n"
           output << resources_string_from_resources(resources)
           output << "\n}\n"
         end
       end
       
       def include_string
-        "include #{name.sanitize}"
+        "include #{name.sanitize.downcase}"
       end
       
       def name(*args)
@@ -43,19 +43,19 @@ module PoolParty
 
     end
     
-    def resources_string_from_resources(resources, prev="\t")
+    def resources_string_from_resources(resources, pre="\t")
       @variables = resources.extract! {|name,resource| name == :variable}
       returning Array.new do |str|
         unless @variables.empty?
           str << "\n# Variables \n"
           @variables.each do |name, variable|
-            str << variable.to_string("#{prev}")
+            str << variable.to_string("#{pre}")
           end          
         end
         
         resources.each do |type, resource|
-          str << "\n#{prev*2}# #{type}\n"
-          str << resource.to_string("#{prev*2}")
+          str << "\n#{pre*2}# #{type}\n"
+          str << resource.to_string("#{pre*2}")
         end        
       end.join("\n")
     end

data/lib/poolparty/pool/resources/conditional.rb

@@ -25,7 +25,11 @@ module PoolParty
         true
       end
       
-      def to_string(prev="")
+      def printable?
+        false
+      end
+      
+      def to_string(pre="")
         returning Array.new do |output|
           output << "# #{name.sanitize}"
           output << "case #{attribute} {"

data/lib/poolparty/pool/resources/exec.rb

@@ -7,9 +7,13 @@ module PoolParty
         :path => "/usr/bin:/bin:/usr/local/bin:$PATH"
       })
       
-      
+      # Execs cannot have the following parameters
+      # We use version in the gempackage resource
+      # So we have to exclude it here. Alternatively, we could
+      # exclude it in the gempackage, but this is an example
+      # of how to exclude it as well
       def disallowed_options
-        [:ensure, :name]
+        [:ensure, :name, :source, :version]
       end
       
       def key

data/lib/poolparty/pool/resources/gem.rb

@@ -1,14 +1,28 @@
 module PoolParty    
   module Resources
-    
-    def gem(opts={}, parent=self, &block)
-      add_resource(:package, opts.merge({
-        :provider => "gem",
-        :requires => "Package[rubygems]"
-      }), parent, &block)
+        
+    class Gempackage < Resource
+      
+      # When we call gempackage, we want the exec to run on the directory we suggest
+      # we also only want it to run if there is NOT a local gem already installed with
+      # the package details (version and name)
+      def loaded(opts={}, parent=self)
+        has_exec(opts.merge({:name => name, :cwd => "/tmp", :path => "/bin:/usr/bin:/usr/local/bin:/sbin:/usr/sbin:/var/lib/gems/1.8/bin"}), parent) do          
+          command "gem install -y --no-ri --no-rdoc #{"--version #{version}" if version} #{"--source #{source}" if source} #{name}"
+          ifnot "gem list --local #{name} | grep #{name} #{"| grep #{version}" if version}"
+        end
+      end
+      def virtual_resource?
+        true
+      end
+      def printable?
+        true
+      end
+      def class_type_name
+        "Exec"
+      end
+      
     end
     
-    add_has_and_does_not_have_methods_for(:gem)
-    
   end
 end

data/lib/poolparty/pool/resources/remote_file.rb

@@ -1,7 +1,7 @@
 module PoolParty    
   module Resources
         
-    class Remotefile < File
+    class Remotefile < Resource
       # Not really my favorite of lines
       include PoolParty::Configurable
       
@@ -16,6 +16,10 @@ module PoolParty
         "file"
       end
       
+      def source(arg=nil)
+        arg ? options[:source] = arg : "#{Base.fileserver_base}/#{::File.basename(name)}"
+      end
+      
     end
     
   end

data/lib/poolparty/pool/resources/symlink.rb

@@ -0,0 +1,25 @@
+module PoolParty    
+  module Resources
+        
+    class Symlink < Resource
+            
+      def class_type_name
+        "file"
+      end
+      
+      def disallowed_options
+        [:name, :source]
+      end
+      
+      def present
+        source
+      end
+      
+      def printable?
+        true
+      end
+      
+    end
+    
+  end
+end

data/lib/poolparty/pool/resources/variable.rb

@@ -8,17 +8,18 @@ module PoolParty
         :value => ""
       })
       
-      def to_string(prev="\t")
+      def to_string(pre="\t")
         "$#{name} = #{value_string}"
       end
       
       def value_string
-        case value.class.to_s
-        when "Array"
-          "[ #{value.map{|a| "'#{a}'"}.join(", ")} ]"
-        else
-          "'#{value}'"
-        end
+        value.to_option_string
+        # case value.class.to_s
+        # when "Array"
+        #   "[ #{value.map{|a| "'#{a}'"}.join(", ")} ]"
+        # else
+        #   "'#{value}'"
+        # end
       end
       
     end

data/lib/poolparty/pool/tmp/.ppkeys

@@ -0,0 +1,3 @@
+--- 
+:secret_access_key: rKZu/271FGDUKYCJb384Q4VcuUExUU7s2ZeB6GgV
+:access_key: 03KJGAWXR5TVXMGB1G02

data/lib/poolparty/pool/tmp/happydayz

@@ -0,0 +1 @@
+write this text