puppet 0.25.5 → 2.6.0

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

@@ -1,250 +1,33 @@
 require 'puppet/util/checksums'
 
-# Keep a copy of the file checksums, and notify when they change.  This
-# property never actually modifies the system, it only notices when the system
-# changes on its own.
-Puppet::Type.type(:file).newproperty(:checksum) do
-    include Puppet::Util::Checksums
+# Specify which checksum algorithm to use when checksumming
+# files.
+Puppet::Type.type(:file).newparam(:checksum) do
+  include Puppet::Util::Checksums
 
-    desc "How to check whether a file has changed.  This state is used internally
-        for file copying, but it can also be used to monitor files somewhat
-        like Tripwire without managing the file contents in any way.  You can
-        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.
+  desc "The checksum type to use when checksumming a file.
 
-        There are a number of checksum types available including MD5 hashing (and
-        an md5lite variation that only hashes the first 500 characters of the
-        file.
+    The default checksum parameter, if checksums are enabled, is md5."
 
-        The default checksum parameter, if checksums are enabled, is md5."
+  newvalues "md5", "md5lite", "timestamp", "mtime", "time", "none"
 
-    @event = :file_changed
+  defaultto :md5
 
-    @unmanaged = true
+  def sum(content)
+    type = value || :md5 # because this might be called before defaults are set
+    "{#{type}}" + send(type, content)
+  end
 
-    @validtypes = %w{md5 md5lite timestamp mtime time none}
+  def sum_file(path)
+    type = value || :md5 # because this might be called before defaults are set
+    method = type.to_s + "_file"
+    "{#{type}}" + send(method, path).to_s
+  end
 
-    def self.validtype?(type)
-        @validtypes.include?(type)
-    end
-
-    @validtypes.each do |ctype|
-        newvalue(ctype) do
-            handlesum()
-        end
-    end
-
-    str = @validtypes.join("|")
-
-    # This is here because Puppet sets this internally, using
-    # {md5}......
-    newvalue(/^\{#{str}\}/) do
-        handlesum()
-    end
-
-    # If they pass us a sum type, behave normally, but if they pass
-    # us a sum type + sum, stick the sum in the cache.
-    munge do |value|
-        if value =~ /^\{(\w+)\}(.+)$/
-            type = symbolize($1)
-            sum = $2
-            cache(type, sum)
-            return type
-        else
-            return :none if value.nil? or value.to_s == "" or value.to_s == "none"
-            if FileTest.directory?(@resource[:path])
-                return :time
-            elsif @resource[:source] and value.to_s != "md5"
-                 self.warning("Files with source set must use md5 as checksum. Forcing to md5 from %s for %s" % [ value, @resource[:path] ])
-                return :md5
-            else
-                return symbolize(value)
-            end
-        end
-    end
-
-    # 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
-        type = symbolize(type)
-        type = :mtime if type == :timestamp
-        type = :ctime if type == :time
-
-        unless state = @resource.cached(:checksums)
-            self.debug "Initializing checksum hash"
-            state = {}
-            @resource.cache(:checksums, state)
-        end
-
-        if sum
-            unless sum =~ /\{\w+\}/
-                sum = "{%s}%s" % [type, sum]
-            end
-            state[type] = sum
-        else
-            return state[type]
-        end
-    end
-
-    # Because source and content and whomever else need to set the checksum
-    # and do the updating, we provide a simple mechanism for doing so.
-    def checksum=(value)
-        munge(@should)
-        self.updatesum(value)
-    end
-
-    def checktype
-        self.should || :md5
-    end
-
-    # Checksums need to invert how changes are printed.
-    def change_to_s(currentvalue, newvalue)
-        begin
-            if currentvalue == :absent
-                return "defined '%s' as '%s'" %
-                    [self.name, self.currentsum]
-            elsif newvalue == :absent
-                return "undefined %s from '%s'" %
-                    [self.name, self.is_to_s(currentvalue)]
-            else
-                if defined? @cached and @cached
-                    return "%s changed '%s' to '%s'" %
-                        [self.name, @cached, self.is_to_s(currentvalue)]
-                else
-                    return "%s changed '%s' to '%s'" %
-                        [self.name, self.currentsum, self.is_to_s(currentvalue)]
-                end
-            end
-        rescue Puppet::Error, Puppet::DevError
-            raise
-        rescue => detail
-            raise Puppet::DevError, "Could not convert change %s to string: %s" %
-                [self.name, detail]
-        end
-    end
-
-    def currentsum
-        cache(checktype())
-    end
-
-    # Calculate the sum from disk.
-    def getsum(checktype, file = nil)
-        sum = ""
-
-        checktype = :mtime if checktype == :timestamp
-        checktype = :ctime if checktype == :time
-        self.should = checktype = :md5 if @resource.property(:source)
-
-        file ||= @resource[:path]
-
-        return nil unless FileTest.exist?(file)
-
-        if ! FileTest.file?(file)
-            checktype = :mtime
-        end
-        method = checktype.to_s + "_file"
-
-        self.fail("Invalid checksum type %s" % checktype) unless respond_to?(method)
-
-        return "{%s}%s" % [checktype, send(method, file)]
-    end
-
-    # At this point, we don't actually modify the system, we modify
-    # the stored state to reflect the current state, and then kick
-    # off an event to mark any changes.
-    def handlesum
-        currentvalue = self.retrieve
-        if currentvalue.nil?
-            raise Puppet::Error, "Checksum state for %s is somehow nil" %
-                @resource.title
-        end
-
-        if self.insync?(currentvalue)
-            self.debug "Checksum is already in sync"
-            return nil
-        end
-        # If we still can't retrieve a checksum, it means that
-        # the file still doesn't exist
-        if currentvalue == :absent
-            # if they're copying, then we won't worry about the file
-            # not existing yet
-            return nil unless @resource.property(:source)
-        end
-
-        # If the sums are different, then return an event.
-        if self.updatesum(currentvalue)
-            return :file_changed
-        else
-            return nil
-        end
-    end
-
-    def insync?(currentvalue)
-        @should = [checktype()]
-        if cache(checktype())
-            return currentvalue == currentsum()
-        else
-            # If there's no cached sum, then we don't want to generate
-            # an event.
-            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.
-    def retrieve(usecache = false)
-        # When the 'source' is retrieving, it passes "true" here so
-        # that we aren't reading the file twice in quick succession, yo.
-        currentvalue = currentsum()
-        return currentvalue if usecache and currentvalue
-
-        stat = nil
-        return :absent unless stat = @resource.stat
-
-        if stat.ftype == "link" and @resource[:links] != :follow
-            self.debug "Not checksumming symlink"
-            # @resource.delete(:checksum)
-            return currentvalue
-        end
-
-        # Just use the first allowed check type
-        currentvalue = getsum(checktype())
-
-        # If there is no sum defined, then store the current value
-        # into the cache, so that we're not marked as being
-        # 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
-        if sum = cache(checktype())
-            return false if newvalue == sum
-
-            self.debug "Replacing %s checksum %s with %s" % [@resource.title, sum, newvalue]
-            result = true
-        else
-            @resource.debug "Creating checksum %s" % newvalue
-            result = false
-        end
-
-        # Cache the sum so the log message can be right if possible.
-        @cached = sum
-        cache(checktype(), newvalue)
-        return result
-    end
+  def sum_stream(&block)
+    type = value || :md5 # same comment as above
+    method = type.to_s + "_stream"
+    checksum = send(method, &block)
+    "{#{type}}#{checksum}"
+  end
 end

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

@@ -1,146 +1,210 @@
+require 'net/http'
+require 'uri'
+require 'tempfile'
+
 require 'puppet/util/checksums'
+require 'puppet/network/http/api/v1'
+require 'puppet/network/http/compression'
 
 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
-            newline).  The primary purpose of this parameter is to provide a
-            kind of limited templating::
-
-                define resolve(nameserver1, nameserver2, domain, search) {
-                    $str = \"search $search
-                domain $domain
-                nameserver $nameserver1
-                nameserver $nameserver2
-                \"
-
-                    file { \"/etc/resolv.conf\":
-                        content => $str
-                    }
-                }
-
-            This attribute is especially useful when used with
-            `PuppetTemplating templating`:trac:."
-
-        # 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
+  Puppet::Type.type(:file).newproperty(:content) do
+    include Puppet::Util::Diff
+    include Puppet::Util::Checksums
+    include Puppet::Network::HTTP::API::V1
+    include Puppet::Network::HTTP::Compression.module
+
+    attr_reader :actual_content
+
+    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 newline).  The primary purpose of this parameter is to provide a
+      kind of limited templating::
+
+        define resolve(nameserver1, nameserver2, domain, search) {
+          $str = \"search $search
+        domain $domain
+        nameserver $nameserver1
+        nameserver $nameserver2
+        \"
+
+          file { \"/etc/resolv.conf\":
+            content => $str
+          }
+        }
+
+      This attribute is especially useful when used with
+      `PuppetTemplating templating`:trac:."
+
+    # Store a checksum as the value, rather than the actual content.
+    # Simplifies everything.
+    munge do |value|
+      if value == :absent
+        value
+      elsif checksum?(value)
+        # XXX This is potentially dangerous because it means users can't write a file whose
+        # entire contents are a plain checksum
+        value
+      else
+        @actual_content = value
+        resource.parameter(:checksum).sum(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
+    # Checksums need to invert how changes are printed.
+    def change_to_s(currentvalue, newvalue)
+      # Our "new" checksum value is provided by the source.
+      if source = resource.parameter(:source) and tmp = source.checksum
+        newvalue = tmp
+      end
+      if currentvalue == :absent
+        return "defined content as '#{newvalue}'"
+      elsif newvalue == :absent
+        return "undefined content from '#{currentvalue}'"
+      else
+        return "content changed '#{currentvalue}' to '#{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 checksum_type
+      if source = resource.parameter(:source)
+        result = source.checksum
+      else checksum = resource.parameter(:checksum)
+        result = resource[:checksum]
+      end
+      if result =~ /^\{(\w+)\}.+/
+        return $1.to_sym
+      else
+        return result
+      end
+    end
 
-        # 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 length
+      (actual_content and actual_content.length) || 0
+    end
 
-        def content
-            self.should || (s = resource.parameter(:source) and s.content)
-        end
+    def content
+      self.should
+    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.should_be_file?
-                return false if is == :absent
-            else
-                return true
-            end
-
-            return true if ! @resource.replace?
-
-            if self.should
-                result = 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
-
-            if ! result and Puppet[:show_diff]
-                string_file_diff(@resource[:path], actual_content)
-            end
-            return result
-        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.should_be_file?
+        return false if is == :absent
+      else
+        return true
+      end
 
-        def retrieve
-            return :absent unless stat = @resource.stat
-            ftype = stat.ftype
-            # Don't even try to manage the content on directories or links
-            return nil if ["directory","link"].include? ftype or checksum_type.nil?
-
-            begin
-                "{#{checksum_type}}" + send(checksum_type.to_s + "_file", resource[:path]).to_s
-            rescue => detail
-                raise Puppet::Error, "Could not read #{ftype} #{@resource.title}: #{detail}"
-            end
-        end
+      return true if ! @resource.replace?
+      return true unless self.should
 
-        # Make sure we're also managing the checksum property.
-        def should=(value)
-            @resource.newattr(:checksum) unless @resource.parameter(:checksum)
-            super
+      result = super
+
+      if ! result and Puppet[:show_diff]
+        write_temporarily do |path|
+          print diff(@resource[:path], path)
         end
+      end
+      result
+    end
+
+    def retrieve
+      return :absent unless stat = @resource.stat
+      ftype = stat.ftype
+      # Don't even try to manage the content on directories or links
+      return nil if ["directory","link"].include?(ftype)
+
+      begin
+        resource.parameter(:checksum).sum_file(resource[:path])
+      rescue => detail
+        raise Puppet::Error, "Could not read #{ftype} #{@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
+    end
 
-        # Just write our content out to disk.
-        def sync
-            return_event = @resource.stat ? :file_changed : :file_created
+    # Just write our content out to disk.
+    def sync
+      return_event = @resource.stat ? :file_changed : :file_created
 
-            # 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)
+      # 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(:content)
 
-            return return_event
+      return_event
+    end
+
+    def write_temporarily
+      tempfile = Tempfile.new("puppet-file")
+      tempfile.open
+
+      write(tempfile)
+
+      tempfile.close
+
+      yield tempfile.path
+
+      tempfile.delete
+    end
+
+    def write(file)
+      resource.parameter(:checksum).sum_stream { |sum|
+        each_chunk_from(actual_content || resource.parameter(:source)) { |chunk|
+          sum << chunk
+          file.print chunk
+        }
+      }
+    end
+
+    def each_chunk_from(source_or_content)
+      if source_or_content.is_a?(String)
+        yield source_or_content
+      elsif source_or_content.nil?
+        yield read_file_from_filebucket
+      elsif source_or_content.local?
+        chunk_file_from_disk(source_or_content) { |chunk| yield chunk }
+      else
+        chunk_file_from_source(source_or_content) { |chunk| yield chunk }
+      end
+    end
+
+    private
+
+    def chunk_file_from_disk(source_or_content)
+      File.open(source_or_content.full_path, "r") do |src|
+        while chunk = src.read(8192)
+          yield chunk
         end
+      end
+    end
+
+    def chunk_file_from_source(source_or_content)
+      request = Puppet::Indirector::Request.new(:file_content, :find, source_or_content.full_path)
+      connection = Puppet::Network::HttpPool.http_instance(source_or_content.server, source_or_content.port)
+      connection.request_get(indirection2uri(request), add_accept_encoding({"Accept" => "raw"})) do |response|
+        case response.code
+        when "404"; nil
+        when /^2/;  uncompress(response) { |uncompressor| response.read_body { |chunk| yield uncompressor.uncompress(chunk) } }
+        else
+          # Raise the http error if we didn't get a 'success' of some kind.
+          message = "Error #{response.code} on SERVER: #{(response.body||'').empty? ? response.message : uncompress_body(response)}"
+          raise Net::HTTPError.new(message, response)
+        end
+      end
+    end
+
+    def read_file_from_filebucket
+      raise "Could not get filebucket from file" unless dipper = resource.bucket
+      sum = should.sub(/\{\w+\}/, '')
+
+      dipper.getfile(sum)
+    rescue => detail
+      fail "Could not retrieve content for #{should} from filebucket: #{detail}"
     end
+  end
 end