puppet 0.24.9 → 0.25.0

data/lib/puppet/type/file/checksum.rb

@@ -12,11 +12,11 @@ Puppet::Type.type(:file).newproperty(:checksum) do
         specify that a file's checksum should be monitored and then subscribe to
         the file from another object and receive events to signify
         checksum changes, for instance.
-        
+
         There are a number of checksum types available including MD5 hashing (and
-        an md5lite variation that only hashes the first 500 characters of the 
+        an md5lite variation that only hashes the first 500 characters of the
         file.
-   
+
         The default checksum parameter, if checksums are enabled, is md5."
 
     @event = :file_changed
@@ -66,6 +66,7 @@ Puppet::Type.type(:file).newproperty(:checksum) do
     # Store the checksum in the data cache, or retrieve it if only the
     # sum type is provided.
     def cache(type, sum = nil)
+        return unless c = resource.catalog and c.host_config?
         unless type
             raise ArgumentError, "A type must be specified to cache a checksum"
         end
@@ -73,7 +74,7 @@ Puppet::Type.type(:file).newproperty(:checksum) do
         type = :mtime if type == :timestamp
         type = :ctime if type == :time
 
-        unless state = @resource.cached(:checksums) 
+        unless state = @resource.cached(:checksums)
             self.debug "Initializing checksum hash"
             state = {}
             @resource.cache(:checksums, state)
@@ -171,12 +172,9 @@ Puppet::Type.type(:file).newproperty(:checksum) do
         if currentvalue == :absent
             # if they're copying, then we won't worry about the file
             # not existing yet
-            unless @resource.property(:source)
-                self.warning("File %s does not exist -- cannot checksum" % @resource[:path])
-            end
-            return nil
+            return nil unless @resource.property(:source)
         end
-        
+
         # If the sums are different, then return an event.
         if self.updatesum(currentvalue)
             return :file_changed
@@ -195,7 +193,7 @@ Puppet::Type.type(:file).newproperty(:checksum) do
             return true
         end
     end
-    
+
     # Even though they can specify multiple checksums, the insync?
     # mechanism can really only test against one, so we'll just retrieve
     # the first specified sum type.
@@ -222,13 +220,14 @@ Puppet::Type.type(:file).newproperty(:checksum) do
         # out of sync.  We don't want to generate an event the first
         # time we get a sum.
         self.updatesum(currentvalue) unless cache(checktype())
-        
+
         # @resource.debug "checksum state is %s" % self.is
         return currentvalue
     end
 
     # Store the new sum to the state db.
     def updatesum(newvalue)
+        return unless c = resource.catalog and c.host_config?
         result = false
 
         # if we're replacing, vs. updating

data/lib/puppet/type/file/content.rb

@@ -1,6 +1,9 @@
+require 'puppet/util/checksums'
+
 module Puppet
     Puppet::Type.type(:file).newproperty(:content) do
         include Puppet::Util::Diff
+        include Puppet::Util::Checksums
 
         desc "Specify the contents of a file as a string.  Newlines, tabs, and
             spaces can be specified using the escaped syntax (e.g., \\n for a
@@ -18,34 +21,93 @@ module Puppet
                         content => $str
                     }
                 }
-            
+
             This attribute is especially useful when used with
             `PuppetTemplating templating`:trac:."
 
-        def string_as_checksum(string)
-            return "absent" if string == :absent
-            "{md5}" + Digest::MD5.hexdigest(string)
+        # Store a checksum as the value, rather than the actual content.
+        # Simplifies everything.
+        munge do |value|
+            if value == :absent
+                value
+            else
+                @actual_content = value
+                "{#{checksum_type}}" + send(self.checksum_type, value)
+            end
+        end
+
+        # Checksums need to invert how changes are printed.
+        def change_to_s(currentvalue, newvalue)
+            # Our "new" checksum value is provided by the source.
+            unless source = resource.parameter(:source) and newvalue = source.checksum
+                newvalue = "unknown checksum"
+            end
+            if currentvalue == :absent
+                return "defined content as '%s'" % [newvalue]
+            elsif newvalue == :absent
+                return "undefined content from '%s'" % [currentvalue]
+            else
+                return "content changed '%s' to '%s'" % [currentvalue, newvalue]
+            end
+        end
+
+        def checksum_type
+            if source = resource.parameter(:source)
+                result = source.checksum
+            elsif checksum = resource.parameter(:checksum)
+                result = checksum.checktype
+            else
+                return :md5
+            end
+            if result =~ /^\{(\w+)\}.+/
+                return $1.to_sym
+            else
+                return result
+            end
         end
 
-        def should_to_s(should)
-            string_as_checksum(should)
+        # If content was specified, return that; else try to return the source content;
+        # else, return nil.
+        def actual_content
+            if defined?(@actual_content) and @actual_content
+                return @actual_content
+            end
+
+            if s = resource.parameter(:source)
+                return s.content
+            end
+            return nil
         end
 
-        def is_to_s(is)
-            string_as_checksum(is)
+        def content
+            self.should || (s = resource.parameter(:source) and s.content)
         end
 
         # Override this method to provide diffs if asked for.
         # Also, fix #872: when content is used, and replace is true, the file
         # should be insync when it exists
         def insync?(is)
-            if ! @resource.replace? and File.exists?(@resource[:path])
+            if resource.should_be_file?
+                return false if is == :absent
+            else
+                return true
+            end
+
+            return true if ! @resource.replace?
+
+            if self.should
+                return super
+            elsif source = resource.parameter(:source)
+                fail "Got a remote source with no checksum" unless source.checksum
+                result = (is == source.checksum)
+            else
+                # We've got no content specified, and no source from which to
+                # get content.
                 return true
             end
 
-            result = super
-            if ! result and Puppet[:show_diff] and File.exists?(@resource[:path])
-                string_file_diff(@resource[:path], self.should)
+            if ! result and Puppet[:show_diff]
+                string_file_diff(@resource[:path], actual_content)
             end
             return result
         end
@@ -53,31 +115,30 @@ module Puppet
         def retrieve
             return :absent unless stat = @resource.stat
 
-            return self.should if stat.ftype == "link" and @resource[:links] == :ignore
-
-            # Don't even try to manage the content on directories
+            # Don't even try to manage the content on directories or links
             return nil if stat.ftype == "directory"
 
             begin
-                currentvalue = File.read(@resource[:path])
-                return currentvalue
+                return "{#{checksum_type}}" + send(checksum_type.to_s + "_file", resource[:path]).to_s
             rescue => detail
-                raise Puppet::Error, "Could not read %s: %s" %
-                    [@resource.title, detail]
+                raise Puppet::Error, "Could not read %s: %s" % [@resource.title, detail]
             end
         end
 
         # Make sure we're also managing the checksum property.
         def should=(value)
+            @resource.newattr(:checksum) unless @resource.parameter(:checksum)
             super
-            @resource.newattr(:checksum) unless @resource.property(:checksum)
         end
 
         # Just write our content out to disk.
         def sync
             return_event = @resource.stat ? :file_changed : :file_created
-            
-            @resource.write(self.should, :content)
+
+            # We're safe not testing for the 'source' if there's no 'should'
+            # because we wouldn't have gotten this far if there weren't at least
+            # one valid value somewhere.
+            @resource.write(actual_content, :content)
 
             return return_event
         end

data/lib/puppet/type/file/ensure.rb

@@ -1,5 +1,5 @@
 module Puppet
-    Puppet.type(:file).ensurable do
+    Puppet::Type.type(:file).ensurable do
         require 'etc'
         desc "Whether to create files that don't currently exist.
             Possible values are *absent*, *present*, *file*, and *directory*.
@@ -9,14 +9,14 @@ module Puppet
 
             Anything other than those values will be considered to be a symlink.
             For instance, the following text creates a link::
-                
+
                 # Useful on solaris
                 file { \"/etc/inetd.conf\":
                     ensure => \"/etc/inet/inetd.conf\"
                 }
-            
+
             You can make relative links::
-                
+
                 # Useful on solaris
                 file { \"/etc/inetd.conf\":
                     ensure => \"inet/inetd.conf\"
@@ -110,13 +110,19 @@ module Puppet
         end
 
         def change_to_s(currentvalue, newvalue)
-            if property = (@resource.property(:content) || @resource.property(:source)) and ! property.insync?(currentvalue)
-                currentvalue = property.retrieve
-                
-                return property.change_to_s(property.retrieve, property.should)
+            return super unless newvalue.to_s == "file"
+
+            return super unless property = @resource.property(:content)
+
+            # We know that content is out of sync if we're here, because
+            # it's essentially equivalent to 'ensure' in the transaction.
+            if source = @resource.parameter(:source)
+                should = source.checksum
             else
-                super(currentvalue, newvalue)
+                should = property.should
             end
+
+            return property.change_to_s(property.retrieve, should)
         end
 
         # Check that we can actually create anything

data/lib/puppet/type/file/group.rb

@@ -2,7 +2,7 @@ require 'puppet/util/posix'
 
 # Manage file group ownership.
 module Puppet
-    Puppet.type(:file).newproperty(:group) do
+    Puppet::Type.type(:file).newproperty(:group) do
         include Puppet::Util::POSIX
 
         require 'etc'
@@ -79,6 +79,12 @@ module Puppet
 
         # Determine if the group is valid, and if so, return the GID
         def validgroup?(value)
+            begin
+                number = Integer(value)
+                return number
+            rescue ArgumentError
+                number = nil
+            end
             if number = gid(value)
                 return number
             else

data/lib/puppet/type/file/mode.rb

@@ -2,7 +2,7 @@
 # for specification (e.g., u+rwx, or -0011), but for now only supports
 # specifying the full mode.
 module Puppet
-    Puppet.type(:file).newproperty(:mode) do
+    Puppet::Type.type(:file).newproperty(:mode) do
         require 'etc'
         desc "Mode the file should be.  Currently relatively limited:
             you must specify the exact mode the file should be."

data/lib/puppet/type/file/owner.rb

@@ -1,5 +1,5 @@
 module Puppet
-    Puppet.type(:file).newproperty(:owner) do
+    Puppet::Type.type(:file).newproperty(:owner) do
         include Puppet::Util::POSIX
         include Puppet::Util::Warnings
 
@@ -49,6 +49,12 @@ module Puppet
 
         # Determine if the user is valid, and if so, return the UID
         def validuser?(value)
+            begin
+                number = Integer(value)
+                return number
+            rescue ArgumentError
+                number = nil
+            end
             if number = uid(value)
                 return number
             else
@@ -89,13 +95,13 @@ module Puppet
                     end
                 end
             end
-            
+
             unless stat = @resource.stat(false)
                 return :absent
             end
 
             currentvalue = stat.uid
-            
+
             # On OS X, files that are owned by -2 get returned as really
             # large UIDs instead of negative ones.  This isn't a Ruby bug,
             # it's an OS X bug, since it shows up in perl, too.

data/lib/puppet/type/file/selcontext.rb

@@ -58,7 +58,7 @@ module Puppet
         end
     end
 
-    Puppet.type(:file).newproperty(:seluser, :parent => Puppet::SELFileContext) do
+    Puppet::Type.type(:file).newproperty(:seluser, :parent => Puppet::SELFileContext) do
         desc "What the SELinux user component of the context of the file should be.
             Any valid SELinux user component is accepted.  For example ``user_u``.
             If not specified it defaults to the value returned by matchpathcon for
@@ -69,7 +69,7 @@ module Puppet
         defaultto { self.retrieve_default_context(:seluser) }
     end
 
-    Puppet.type(:file).newproperty(:selrole, :parent => Puppet::SELFileContext) do
+    Puppet::Type.type(:file).newproperty(:selrole, :parent => Puppet::SELFileContext) do
         desc "What the SELinux role component of the context of the file should be.
             Any valid SELinux role component is accepted.  For example ``role_r``.
             If not specified it defaults to the value returned by matchpathcon for
@@ -80,7 +80,7 @@ module Puppet
         defaultto { self.retrieve_default_context(:selrole) }
     end
 
-    Puppet.type(:file).newproperty(:seltype, :parent => Puppet::SELFileContext) do
+    Puppet::Type.type(:file).newproperty(:seltype, :parent => Puppet::SELFileContext) do
         desc "What the SELinux type component of the context of the file should be.
             Any valid SELinux type component is accepted.  For example ``tmp_t``.
             If not specified it defaults to the value returned by matchpathcon for
@@ -91,7 +91,7 @@ module Puppet
         defaultto { self.retrieve_default_context(:seltype) }
     end
 
-    Puppet.type(:file).newproperty(:selrange, :parent => Puppet::SELFileContext) do
+    Puppet::Type.type(:file).newproperty(:selrange, :parent => Puppet::SELFileContext) do
         desc "What the SELinux range component of the context of the file should be.
             Any valid SELinux range component is accepted.  For example ``s0`` or
             ``SystemHigh``.  If not specified it defaults to the value returned by

data/lib/puppet/type/file/source.rb

@@ -1,10 +1,14 @@
+
+require 'puppet/file_serving/content'
+require 'puppet/file_serving/metadata'
+
 module Puppet
     # Copy files from a local or remote source.  This state *only* does any work
     # when the remote file is an actual file; in that case, this state copies
     # the file down.  If the remote file is a dir or a link or whatever, then
     # this state, during retrieval, modifies the appropriate other states
     # so that things get taken care of appropriately.
-    Puppet.type(:file).newproperty(:source) do
+    Puppet::Type.type(:file).newparam(:source) do
         include Puppet::Util::Diff
 
         attr_accessor :source, :local
@@ -29,15 +33,15 @@ module Puppet
             will use the local filesystem.  This makes it easy to use the same
             configuration in both local and centralized forms.
 
-            Currently, only the ``puppet`` scheme is supported for source 
-            URL's. Puppet will connect to the file server running on 
-            ``server`` to retrieve the contents of the file. If the 
-            ``server`` part is empty, the behavior of the command-line 
+            Currently, only the ``puppet`` scheme is supported for source
+            URL's. Puppet will connect to the file server running on
+            ``server`` to retrieve the contents of the file. If the
+            ``server`` part is empty, the behavior of the command-line
             interpreter (``puppet``) and the client demon (``puppetd``) differs
             slightly: ``puppet`` will look such a file up on the module path
-            on the local host, whereas ``puppetd`` will connect to the 
+            on the local host, whereas ``puppetd`` will connect to the
             puppet server that it received the manifest from.
-     
+
             See the `FileServingConfiguration fileserver configuration documentation`:trac: for information on how to configure
             and use file services within Puppet.
 
@@ -52,225 +56,120 @@ module Puppet
                         \"/nfs/files/file\"
                     ]
                 }
-            
+
             This will use the first found file as the source.
-            
+
             You cannot currently copy links using this mechanism; set ``links``
             to ``follow`` if any remote sources are links.
             "
 
-        uncheckable
-        
-        validate do |source|
-            unless @resource.uri2obj(source)
-                raise Puppet::Error, "Invalid source %s" % source
+        validate do |sources|
+            sources = [sources] unless sources.is_a?(Array)
+            sources.each do |source|
+                begin
+                    uri = URI.parse(URI.escape(source))
+                rescue => detail
+                    self.fail "Could not understand source %s: %s" % [source, detail.to_s]
+                end
+
+                unless uri.scheme.nil? or %w{file puppet}.include?(uri.scheme)
+                    self.fail "Cannot use URLs of type '%s' as source for fileserving" % [uri.scheme]
+                end
             end
         end
-            
-        munge do |source|
-            # if source.is_a? Symbol
-            #     return source
-            # end
 
-            # Remove any trailing slashes
-            source.sub(/\/$/, '')
+        munge do |sources|
+            sources = [sources] unless sources.is_a?(Array)
+            sources.collect { |source| source.sub(/\/$/, '') }
         end
-        
+
         def change_to_s(currentvalue, newvalue)
-            # newvalue = "{md5}" + @stats[:checksum]
+            # newvalue = "{md5}" + @metadata.checksum
             if @resource.property(:ensure).retrieve == :absent
-                return "creating from source %s with contents %s" % [@source, @stats[:checksum]]
+                return "creating from source %s with contents %s" % [metadata.source, metadata.checksum]
             else
-                return "replacing from source %s with contents %s" % [@source, @stats[:checksum]]
+                return "replacing from source %s with contents %s" % [metadata.source, metadata.checksum]
             end
         end
-        
+
         def checksum
-            if defined?(@stats)
-                @stats[:checksum]
+            if metadata
+                metadata.checksum
             else
                 nil
             end
         end
 
-        # Ask the file server to describe our file.
-        def describe(source)
-            sourceobj, path = @resource.uri2obj(source)
-            server = sourceobj.server
+        # Look up (if necessary) and return remote content.
+        cached_attr(:content) do
+            raise Puppet::DevError, "No source for content was stored with the metadata" unless metadata.source
 
-            begin
-                desc = server.describe(path, @resource[:links])
-            rescue Puppet::Network::XMLRPCClientError => detail
-                fail detail, "Could not describe %s: %s" % [path, detail]
+            unless tmp = Puppet::FileServing::Content.find(metadata.source)
+                fail "Could not find any content at %s" % metadata.source
             end
+            tmp.content
+        end
 
-            return nil if desc == ""
+        # Copy the values from the source to the resource.  Yay.
+        def copy_source_values
+            devfail "Somehow got asked to copy source values without any metadata" unless metadata
 
-            # Collect everything except the checksum
-            values = desc.split("\t")
-            other = values.pop
-            args = {}
-            pinparams.zip(values).each { |param, value|
-                if value =~ /^[0-9]+$/
-                    value = value.to_i
-                end
-                unless value.nil?
-                    args[param] = value
+            # Take each of the stats and set them as states on the local file
+            # if a value has not already been provided.
+            [:owner, :mode, :group, :checksum].each do |param|
+                next if param == :owner and Puppet::Util::SUIDManager.uid != 0
+                next if param == :checksum and metadata.ftype == "directory"
+                unless value = @resource[param] and value != :absent
+                    @resource[param] = metadata.send(param)
                 end
-            }
-
-            # Now decide whether we're doing checksums or symlinks
-            if args[:type] == "link"
-                args[:target] = other
-            else
-                args[:checksum] = other
             end
 
-            # we can't manage ownership unless we're root, so don't even try
-            unless Puppet::Util::SUIDManager.uid == 0
-                args.delete(:owner)
-            end
-            
-            return args
-        end
-        
-        # Use the info we get from describe() to check if we're in sync.
-        def insync?(currentvalue)
-            if currentvalue == :nocopy
-                return true
-            end
-            
-            # the only thing this actual state can do is copy files around.  Therefore,
-            # only pay attention if the remote is a file.
-            unless @stats[:type] == "file" 
-                return true
-            end
-            
-            #FIXARB: Inefficient?  Needed to call retrieve on parent's ensure and checksum
-            parentensure = @resource.property(:ensure).retrieve
-            if parentensure != :absent and ! @resource.replace?
-                return true
-            end
-            # Now, we just check to see if the checksums are the same
-            parentchecksum = @resource.property(:checksum).retrieve
-            result = (!parentchecksum.nil? and (parentchecksum == @stats[:checksum]))
+            # Set the 'ensure' value, unless we're trying to delete the file.
+            @resource[:ensure] = metadata.ftype unless @resource[:ensure] == :absent
 
-            # Diff the contents if they ask it.  This is quite annoying -- we need to do this in
-            # 'insync?' because they might be in noop mode, but we don't want to do the file
-            # retrieval twice, so we cache the value.
-            if ! result and Puppet[:show_diff] and File.exists?(@resource[:path]) and ! @stats[:_diffed]
-                @stats[:_remote_content] = get_remote_content
-                string_file_diff(@resource[:path], @stats[:_remote_content])
-                @stats[:_diffed] = true
+            if metadata.ftype == "link"
+                @resource[:target] = metadata.destination
             end
-            return result
         end
 
         def pinparams
-            [:mode, :type, :owner, :group]
+            [:mode, :type, :owner, :group, :content]
         end
 
         def found?
-            ! (@stats.nil? or @stats[:type].nil?)
+            ! (metadata.nil? or metadata.ftype.nil?)
         end
 
-        # This basically calls describe() on our file, and then sets all
-        # of the local states appropriately.  If the remote file is a normal
-        # file then we set it to copy; if it's a directory, then we just mark
-        # that the local directory should be created.
-        def retrieve(remote = true)
-            sum = nil
-            @source = nil
-
-            # This is set to false by the File#retrieve function on the second
-            # retrieve, so that we do not do two describes.
-            if remote
-                # Find the first source that exists.  @shouldorig contains
-                # the sources as specified by the user.
-                @should.each { |source|
-                    if @stats = self.describe(source)
-                        @source = source
+        # Provide, and retrieve if necessary, the metadata for this file.  Fail
+        # if we can't find data about this host, and fail if there are any
+        # problems in our query.
+        cached_attr(:metadata) do
+            return nil unless value
+            result = nil
+            value.each do |source|
+                begin
+                    if data = Puppet::FileServing::Metadata.find(source)
+                        result = data
+                        result.source = source
                         break
                     end
-                }
-            end
-
-            if !found?
-                raise Puppet::Error, "No specified source was found from" + @should.inject("") { |s, source| s + " #{source},"}.gsub(/,$/,"")
-            end
-            
-            case @stats[:type]
-            when "directory", "file", "link":
-                @resource[:ensure] = @stats[:type] unless @resource.deleting?
-            else
-                self.info @stats.inspect
-                self.err "Cannot use files of type %s as sources" % @stats[:type]
-                return :nocopy
+                rescue => detail
+                    fail detail, "Could not retrieve file metadata for %s: %s" % [source, detail]
+                end
             end
-
-            # Take each of the stats and set them as states on the local file
-            # if a value has not already been provided.
-            @stats.each { |stat, value|
-                next if stat == :checksum
-                next if stat == :type
-
-                # was the stat already specified, or should the value
-                # be inherited from the source?
-                @resource[stat] = value unless @resource.argument?(stat)
-            }
-
-            return @stats[:checksum]
+            fail "Could not retrieve information from source(s) %s" % value.join(", ") unless result
+            result
         end
-        
-        def should
-            @should
-        end
-        
+
         # Make sure we're also checking the checksum
-        def should=(value)
+        def value=(value)
             super
 
             checks = (pinparams + [:ensure])
             checks.delete(:checksum)
-            
-            @resource[:check] = checks
-            @resource[:checksum] = :md5 unless @resource.property(:checksum)
-        end
-
-        def sync
-            contents = @stats[:_remote_content] || get_remote_content()
-
-            exists = File.exists?(@resource[:path])
-
-            @resource.write(contents, :source, @stats[:checksum])
-
-            if exists
-                return :file_changed
-            else
-                return :file_created
-            end
-        end
-
-        private
-
-        def get_remote_content
-            raise Puppet::DevError, "Got told to copy non-file %s" % @resource[:path] unless @stats[:type] == "file"
-
-            sourceobj, path = @resource.uri2obj(@source)
-
-            begin
-                contents = sourceobj.server.retrieve(path, @resource[:links])
-            rescue => detail
-                self.fail "Could not retrieve %s: %s" % [path, detail]
-            end
-
-            contents = CGI.unescape(contents) unless sourceobj.server.local
-
-            if contents == ""
-                self.notice "Could not retrieve contents for %s" % @source
-            end
 
-            return contents
+            resource[:check] = checks
+            resource[:checksum] = :md5 unless resource.property(:checksum)
         end
     end
 end