puppet 0.24.7 → 0.24.8

data/lib/puppet/provider/service/gentoo.rb

@@ -38,7 +38,7 @@ Puppet::Type.type(:service).provide :gentoo, :parent => :init do
         return :false unless line
 
         # If it's enabled then it will print output showing service | runlevel
-        if output =~ /#{@resource[:name]}\s*\|\s*default/
+        if output =~ /#{@resource[:name]}\s*\|\s*(boot|default)/
             return :true
         else
             return :false

data/lib/puppet/provider/service/launchd.rb

@@ -103,12 +103,21 @@ Puppet::Type.type(:service).provide :launchd, :parent => :base do
 
     def status
         # launchctl list <jobname> exits zero if the job is loaded
-        # and non-zero if it isn't. Simple way to check...
+        # and non-zero if it isn't. Simple way to check... but is only
+        # available on OS X 10.5 unfortunately, so we grab the whole list
+        # and check if our resource is included. The output formats differ
+        # between 10.4 and 10.5, thus the necessity for splitting
         begin
-            launchctl :list, resource[:name]           
-            return :running
-        rescue Puppet::ExecutionFailure
+            output = launchctl :list
+            if output.nil?
+                raise Puppet::Error.new("launchctl list failed to return any data.")
+            end
+            output.split("\n").each do |j|
+                return :running if j.split(/\s/).last == resource[:name]
+            end
             return :stopped
+        rescue Puppet::ExecutionFailure
+            raise Puppet::Error.new("Unable to determine status of #{resource[:name]}")
         end
     end
 

data/lib/puppet/provider/service/redhat.rb

@@ -9,7 +9,7 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init do
 
     commands :chkconfig => "/sbin/chkconfig", :service => "/sbin/service"
  
-    defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles]
+    defaultfor :operatingsystem => [:redhat, :fedora, :suse, :centos, :sles, :oel, :ovm]
 
     def self.defpath
         superclass.defpath
@@ -73,12 +73,12 @@ Puppet::Type.type(:service).provide :redhat, :parent => :init do
         end
     end
 
-    def start
-        service(@resource[:name], "start")
+    def startcmd
+        [command(:service), @resource[:name], "start"]
     end
 
-    def stop
-        service(@resource[:name], "stop")
+    def stopcmd
+        [command(:service), @resource[:name], "stop"]
     end
 
 end

data/lib/puppet/provider/ssh_authorized_key/parsed.rb

@@ -36,29 +36,46 @@ Puppet::Type.type(:ssh_authorized_key).provide(:parsed,
         :rts      => /^\s+/,
         :match    => /^(?:(.+) )?(\d+) (\d+) (\d+)(?: (.+))?$/
 
-    def prefetch
-        # This was done in the type class but path expansion was failing for
-        # not yet existing users, the only workaround I found was to move that
-        # in the provider.
-        if user = @resource.should(:user)
-            target = File.expand_path("~%s/.ssh/authorized_keys" % user)
-            @property_hash[:target] = target
-            @resource[:target] = target
+    def target
+        @resource.should(:target)
+    end
+
+    def user
+        @resource.should(:user)
+    end
+
+    def dir_perm
+        # Determine correct permission for created directory and file
+        # we can afford more restrictive permissions when the user is known
+        if target
+            if user
+                0700
+            else
+                0755
+            end
         end
+    end
 
-        super
+    def file_perm
+        if target
+            if user
+                0600
+            else
+                0644
+            end
+        end
     end
 
     def flush
         # As path expansion had to be moved in the provider, we cannot generate new file
         # resources and thus have to chown and chmod here. It smells hackish.
-        
+
         # Create target's parent directory if nonexistant
-        if target = @property_hash[:target]
-            dir = File.dirname(@property_hash[:target])
+        if target
+            dir = File.dirname(target)
             if not File.exist? dir
                 Puppet.debug("Creating directory %s which did not exist" % dir)
-                Dir.mkdir(dir, 0700)
+                Dir.mkdir(dir, dir_perm)
             end
         end
 
@@ -66,9 +83,19 @@ Puppet::Type.type(:ssh_authorized_key).provide(:parsed,
         super
 
         # Ensure correct permissions
-        if target and user = @property_hash[:user]
-            File.chown(Puppet::Util.uid(user), nil, dir)
-            File.chown(Puppet::Util.uid(user), nil, @property_hash[:target])
+        if target and user
+            uid = Puppet::Util.uid(user)
+
+            if uid
+                File.chown(uid, nil, dir)
+                File.chown(uid, nil, target)
+            else
+                raise Puppet::Error, "Specified user does not exist"
+            end
+        end
+
+        if target
+            File.chmod(file_perm, target)
         end
     end
 

data/lib/puppet/provider/user/useradd.rb

@@ -31,7 +31,7 @@ Puppet::Type.type(:user).provide :useradd, :parent => Puppet::Provider::NameServ
         cmd = []
         if @resource.managehome?
             cmd << "-m"
-        elsif %w{Fedora RedHat}.include?(Facter.value("operatingsystem"))
+        elsif %w{Fedora RedHat CentOS OEL OVS}.include?(Facter.value("operatingsystem"))
             cmd << "-M"
         end
         cmd

data/lib/puppet/rails/database/003_add_environment_to_host.rb

@@ -1,9 +1,13 @@
 class AddEnvironmentToHost < ActiveRecord::Migration
     def self.up
-        add_column :hosts, :environment, :string
+        unless ActiveRecord::Base.connection.columns(:hosts).collect {|c| c.name}.include?("environment")
+            add_column :hosts, :environment, :string
+        end
     end
     
     def self.down
-        remove_column :hosts, :environment
+        if ActiveRecord::Base.connection.columns(:hosts).collect {|c| c.name}.include?("environment")
+            remove_column :hosts, :environment
+        end
     end
 end

data/lib/puppet/rails/host.rb

@@ -3,8 +3,6 @@ require 'puppet/rails/fact_name'
 require 'puppet/rails/source_file'
 require 'puppet/util/rails/collection_merger'
 
-# Puppet::TIME_DEBUG = true
-
 class Puppet::Rails::Host < ActiveRecord::Base
     include Puppet::Util
     include Puppet::Util::CollectionMerger
@@ -12,9 +10,7 @@ class Puppet::Rails::Host < ActiveRecord::Base
     has_many :fact_values, :dependent => :destroy
     has_many :fact_names, :through => :fact_values
     belongs_to :source_file
-    has_many :resources,
-        :include => :param_values,
-        :dependent => :destroy
+    has_many :resources, :dependent => :destroy
 
     # If the host already exists, get rid of its objects
     def self.clean(host)
@@ -38,7 +34,7 @@ class Puppet::Rails::Host < ActiveRecord::Base
                     host = new(:name => node.name)
                 end
             }
-            Puppet.notice("Searched for host in %0.2f seconds" % seconds) if defined?(Puppet::TIME_DEBUG)
+            Puppet.debug("Searched for host in %0.2f seconds" % seconds)
             if ip = node.parameters["ipaddress"]
                 host.ip = ip
             end
@@ -53,7 +49,7 @@ class Puppet::Rails::Host < ActiveRecord::Base
             seconds = Benchmark.realtime {
                 host.setresources(resources)
             }
-            Puppet.notice("Handled resources in %0.2f seconds" % seconds) if defined?(Puppet::TIME_DEBUG)
+            Puppet.debug("Handled resources in %0.2f seconds" % seconds)
 
             host.last_compile = Time.now
 
@@ -117,27 +113,60 @@ class Puppet::Rails::Host < ActiveRecord::Base
 
     # Set our resources.
     def setresources(list)
-        existing = nil
+        resource_by_id = nil
         seconds = Benchmark.realtime {
+            resource_by_id = find_resources()
+        }
+        Puppet.debug("Searched for resources in %0.2f seconds" % seconds)
 
-            # Preload the parameters with the resource query, but not the tags, since doing so makes the query take about 10x longer.
-            # I've left the other queries in so that it's straightforward to switch between them for testing, if we so desire.
-            #existing = resources.find(:all, :include => [{:param_values => :param_name, :resource_tags => :puppet_tag}, :source_file]).inject({}) do | hash, resource |
-            #existing = resources.find(:all, :include => [{:resource_tags => :puppet_tag}, :source_file]).inject({}) do | hash, resource |
-            existing = resources.find(:all, :include => [{:param_values => :param_name}, :source_file]).inject({}) do | hash, resource |
-                hash[resource.ref] = resource
-                hash
-            end
+        seconds = Benchmark.realtime {
+            find_resources_parameters_tags(resource_by_id)
+        } if id
+        Puppet.debug("Searched for resource params and tags in %0.2f seconds" % seconds)
+
+        seconds = Benchmark.realtime {
+            compare_to_catalog(resource_by_id, list)
         }
+        Puppet.debug("Resource comparison took %0.2f seconds" % seconds)
+    end
+
+    def find_resources
+        resources.find(:all, :include => :source_file).inject({}) do | hash, resource |
+            hash[resource.id] = resource
+            hash
+        end
+    end
+
+    def find_resources_parameters_tags(resources)
+        # initialize all resource parameters
+        resources.each do |key,resource|
+            resource.params_hash = []
+        end
 
-        Puppet.notice("Searched for resources in %0.2f seconds" % seconds) if defined?(Puppet::TIME_DEBUG)
+        find_resources_parameters(resources)
+        find_resources_tags(resources)
+    end
+
+    # it seems that it can happen (see bug #2010) some resources are duplicated in the
+    # database (ie logically corrupted database), in which case we remove the extraneous
+    # entries.
+    def compare_to_catalog(existing, list)
+        extra_db_resources = []
+        resources = existing.inject({}) do |hash, res|
+            resource = res[1]
+            if hash.include?(resource.ref)
+                extra_db_resources << hash[resource.ref]
+            end
+            hash[resource.ref] = resource
+            hash
+        end
 
         compiled = list.inject({}) do |hash, resource|
             hash[resource.ref] = resource
             hash
         end
-        
-        ar_hash_merge(existing, compiled,
+
+        ar_hash_merge(resources, compiled,
                       :create => Proc.new { |ref, resource|
                           resource.to_rails(self)
                       }, :delete => Proc.new { |resource|
@@ -145,6 +174,28 @@ class Puppet::Rails::Host < ActiveRecord::Base
                       }, :modify => Proc.new { |db, mem|
                           mem.modify_rails(db)
                       })
+
+        # fix-up extraneous resources
+        extra_db_resources.each do |resource|
+            self.resources.delete(resource)
+        end
+    end
+
+    def find_resources_parameters(resources)
+        params = Puppet::Rails::ParamValue.find_all_params_from_host(self)
+
+        # assign each loaded parameters/tags to the resource it belongs to
+        params.each do |param|
+            resources[param['resource_id']].add_param_to_hash(param) if resources.include?(param['resource_id'])
+        end
+    end
+
+    def find_resources_tags(resources)
+        tags = Puppet::Rails::ResourceTag.find_all_tags_from_host(self)
+
+        tags.each do |tag|
+            resources[tag['resource_id']].add_tag_to_hash(tag) if resources.include?(tag['resource_id'])
+        end
     end
 
     def update_connect_time

data/lib/puppet/rails/param_value.rb

@@ -1,28 +1,47 @@
+require 'puppet/util/rails/reference_serializer'
+
 class Puppet::Rails::ParamValue < ActiveRecord::Base
+    include Puppet::Util::ReferenceSerializer
+    extend Puppet::Util::ReferenceSerializer
+
     belongs_to :param_name
     belongs_to :resource
 
     def value
-        val = self[:value]
-        if val =~ /^--- \!/
-            YAML.load(val)
-        else
-            val
-        end
+        unserialize_value(self[:value])
     end
 
     # I could not find a cleaner way to handle making sure that resource references
     # were consistently serialized and deserialized.
     def value=(val)
-        if val.is_a?(Puppet::Parser::Resource::Reference)
-            self[:value] = YAML.dump(val)
-        else
-            self[:value] = val
-        end
+        self[:value] = serialize_value(val)
     end
 
     def to_label
       "#{self.param_name.name}"
-    end  
+    end
+
+    # returns an array of hash containing all the parameters of a given resource
+    def self.find_all_params_from_resource(db_resource)
+        params = db_resource.connection.select_all("SELECT v.id, v.value, v.line, v.resource_id, v.param_name_id, n.name FROM param_values as v INNER JOIN param_names as n ON v.param_name_id=n.id WHERE v.resource_id=%s" % db_resource.id)
+        params.each do |val|
+            val['value'] = unserialize_value(val['value'])
+            val['line'] = val['line'] ? Integer(val['line']) : nil
+            val['resource_id'] = Integer(val['resource_id'])
+        end
+        params
+    end
+
+    # returns an array of hash containing all the parameters of a given host
+    def self.find_all_params_from_host(db_host)
+        params = db_host.connection.select_all("SELECT v.id, v.value,  v.line, v.resource_id, v.param_name_id, n.name FROM param_values as v INNER JOIN resources r ON v.resource_id=r.id INNER JOIN param_names as n ON v.param_name_id=n.id WHERE r.host_id=%s" % db_host.id)
+        params.each do |val|
+            val['value'] = unserialize_value(val['value'])
+            val['line'] = val['line'] ? Integer(val['line']) : nil
+            val['resource_id'] = Integer(val['resource_id'])
+        end
+        params
+    end
+
 end
 

data/lib/puppet/rails/resource.rb

@@ -1,10 +1,12 @@
 require 'puppet'
 require 'puppet/rails/param_name'
+require 'puppet/rails/param_value'
 require 'puppet/rails/puppet_tag'
 require 'puppet/util/rails/collection_merger'
 
 class Puppet::Rails::Resource < ActiveRecord::Base
     include Puppet::Util::CollectionMerger
+    include Puppet::Util::ReferenceSerializer
 
     has_many :param_values, :dependent => :destroy, :class_name => "Puppet::Rails::ParamValue"
     has_many :param_names, :through => :param_values, :class_name => "Puppet::Rails::ParamName"
@@ -32,21 +34,46 @@ class Puppet::Rails::Resource < ActiveRecord::Base
         self.source_file = Puppet::Rails::SourceFile.find_or_create_by_filename(file)
     end
 
+    def title
+        unserialize_value(self[:title])
+    end
+
+    def add_param_to_hash(param)
+        @params_hash ||= []
+        @params_hash << param
+    end
+
+    def add_tag_to_hash(tag)
+        @tags_hash ||= []
+        @tags_hash << tag
+    end
+
+    def params_hash=(hash)
+        @params_hash = hash
+    end
+
+    def tags_hash=(hash)
+        @tags_hash = hash
+    end
+
     # returns a hash of param_names.name => [param_values]
     def get_params_hash(values = nil)
-        values ||= param_values.find(:all, :include => :param_name)
-        values.inject({}) do | hash, value |
-            hash[value.param_name.name] ||= []
-            hash[value.param_name.name] << value
+        values ||= @params_hash || Puppet::Rails::ParamValue.find_all_params_from_resource(self)
+        if values.size == 0
+            return {}
+        end
+        values.inject({}) do |hash, value|
+            hash[value['name']] ||= []
+            hash[value['name']] << value
             hash
         end
     end
-    
+
     def get_tag_hash(tags = nil)
-        tags ||= resource_tags.find(:all, :include => :puppet_tag)
+        tags ||= @tags_hash || Puppet::Rails::ResourceTag.find_all_tags_from_resource(self)
         return tags.inject({}) do |hash, tag|
             # We have to store the tag object, not just the tag name.
-            hash[tag.puppet_tag.name] = tag
+            hash[tag['name']] = tag
             hash
         end
     end
@@ -73,7 +100,7 @@ class Puppet::Rails::Resource < ActiveRecord::Base
         result = get_params_hash
         result.each do |param, value|
             if value.is_a?(Array)
-                result[param] = value.collect { |v| v.value }
+                result[param] = value.collect { |v| v['value'] }
             else
                 result[param] = value.value
             end
@@ -82,7 +109,7 @@ class Puppet::Rails::Resource < ActiveRecord::Base
     end
 
     def ref
-        "%s[%s]" % [self[:restype].split("::").collect { |s| s.capitalize }.join("::"), self[:title]]
+        "%s[%s]" % [self[:restype].split("::").collect { |s| s.capitalize }.join("::"), self.title.to_s]
     end
 
     # Convert our object to a resource.  Do not retain whether the object