puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/lib/puppet/feature/cfacter.rb

@@ -0,0 +1,14 @@
+require 'facter'
+require 'puppet/util/feature'
+
+Puppet.features.add :cfacter do
+  begin
+    require 'cfacter'
+
+    # The first release of cfacter didn't have the necessary interface to work with Puppet
+    # Therefore, if the version is 0.1.0, treat the feature as not present
+    CFacter.version != '0.1.0'
+  rescue LoadError
+    false
+  end
+end

data/lib/puppet/feature/pe_license.rb

@@ -0,0 +1,4 @@
+require 'puppet/util/feature'
+
+#Is the pe license library installed providing the ability to read licenses.
+Puppet.features.add(:pe_license, :libs => %{pe_license})

data/lib/puppet/file_bucket/dipper.rb

@@ -10,7 +10,7 @@ class Puppet::FileBucket::Dipper
 
   attr_accessor :name
 
-  # Create our bucket client
+  # Creates a bucket client
   def initialize(hash = {})
     # Emulate the XMLRPC client
     server      = hash[:Server]
@@ -32,13 +32,12 @@ class Puppet::FileBucket::Dipper
     !! @local_path
   end
 
-  # Back up a file to our bucket
+  # Backs up a file to the file bucket
   def backup(file)
     file_handle = Puppet::FileSystem.pathname(file)
     raise(ArgumentError, "File #{file} does not exist") unless Puppet::FileSystem.exist?(file_handle)
-    contents = Puppet::FileSystem.binread(file_handle)
     begin
-      file_bucket_file = Puppet::FileBucket::File.new(contents, :bucket_path => @local_path)
+      file_bucket_file = Puppet::FileBucket::File.new(file_handle, :bucket_path => @local_path)
       files_original_path = absolutize_path(file)
       dest_path = "#{@rest_path}#{file_bucket_file.name}/#{files_original_path}"
       file_bucket_path = "#{@rest_path}#{file_bucket_file.checksum_type}/#{file_bucket_file.checksum_data}/#{files_original_path}"
@@ -57,21 +56,26 @@ class Puppet::FileBucket::Dipper
     end
   end
 
-  # Retrieve a file by sum.
+  # Retrieves a file by sum.
   def getfile(sum)
+    get_bucket_file(sum).to_s
+  end
+
+  # Retrieves a FileBucket::File by sum.
+  def get_bucket_file(sum)
     source_path = "#{@rest_path}#{@checksum_type}/#{sum}"
     file_bucket_file = Puppet::FileBucket::File.indirection.find(source_path, :bucket_path => @local_path)
 
     raise Puppet::Error, "File not found" unless file_bucket_file
-    file_bucket_file.to_s
+    file_bucket_file
   end
 
-  # Restore the file
-  def restore(file,sum)
+  # Restores the file
+  def restore(file, sum)
     restore = true
     file_handle = Puppet::FileSystem.pathname(file)
     if Puppet::FileSystem.exist?(file_handle)
-      cursum = @digest.call(Puppet::FileSystem.binread(file_handle))
+      cursum = Puppet::FileBucket::File.new(file_handle).checksum_data()
 
       # if the checksum has changed...
       # this might be extra effort
@@ -81,8 +85,8 @@ class Puppet::FileBucket::Dipper
     end
 
     if restore
-      if newcontents = getfile(sum)
-        newsum = @digest.call(newcontents)
+      if newcontents = get_bucket_file(sum)
+        newsum = newcontents.checksum_data
         changed = nil
         if Puppet::FileSystem.exist?(file_handle) and ! Puppet::FileSystem.writable?(file_handle)
           changed = Puppet::FileSystem.stat(file_handle).mode
@@ -90,7 +94,10 @@ class Puppet::FileBucket::Dipper
         end
         ::File.open(file, ::File::WRONLY|::File::TRUNC|::File::CREAT) { |of|
           of.binmode
-          of.print(newcontents)
+          source_stream = newcontents.stream do |source_stream|
+            FileUtils.copy_stream(source_stream, of)
+          end
+          #of.print(newcontents)
         }
         ::File.chmod(changed, file) if changed
       else

data/lib/puppet/file_bucket/file.rb

@@ -11,7 +11,6 @@ class Puppet::FileBucket::File
   extend Puppet::Indirector
   indirects :file_bucket_file, :terminus_class => :selector
 
-  attr :contents
   attr :bucket_path
 
   def self.supported_formats
@@ -28,8 +27,14 @@ class Puppet::FileBucket::File
   end
 
   def initialize(contents, options = {})
-    raise ArgumentError.new("contents must be a String, got a #{contents.class}") unless contents.is_a?(String)
-    @contents = contents
+    case contents
+    when String
+      @contents = StringContents.new(contents)
+    when Pathname
+      @contents = FileContents.new(contents)
+    else
+      raise ArgumentError.new("contents must be a String or Pathname, got a #{contents.class}")
+    end
 
     @bucket_path = options.delete(:bucket_path)
     @checksum_type = Puppet[:digest_algorithm].to_sym
@@ -38,12 +43,12 @@ class Puppet::FileBucket::File
 
   # @return [Num] The size of the contents
   def size
-    contents.size
+    @contents.size()
   end
 
   # @return [IO] A stream that reads the contents
-  def stream
-    StringIO.new(contents)
+  def stream(&block)
+    @contents.stream(&block)
   end
 
   def checksum_type
@@ -55,12 +60,15 @@ class Puppet::FileBucket::File
   end
 
   def checksum_data
-    algorithm = Puppet::Util::Checksums.method(@checksum_type)
-    @checksum_data ||= algorithm.call(contents)
+    @checksum_data ||= @contents.checksum_data(@checksum_type)
   end
 
   def to_s
-    contents
+    @contents.to_s
+  end
+
+  def contents
+    to_s
   end
 
   def name
@@ -72,7 +80,8 @@ class Puppet::FileBucket::File
   end
 
   def to_data_hash
-    { "contents" => contents }
+    # Note that this serializes the entire data to a string and places it in a hash.
+    { "contents" => contents.to_s }
   end
 
   def self.from_data_hash(data)
@@ -91,4 +100,58 @@ class Puppet::FileBucket::File
     self.from_data_hash(pson)
   end
 
+  private
+
+  class StringContents
+    def initialize(content)
+      @contents = content;
+    end
+
+    def stream(&block)
+      s = StringIO.new(@contents)
+      begin
+        block.call(s)
+      ensure
+        s.close
+      end
+    end
+
+    def size
+      @contents.size
+    end
+
+    def checksum_data(base_method)
+      Puppet.info("Computing checksum on string")
+      Puppet::Util::Checksums.method(base_method).call(@contents)
+    end
+
+    def to_s
+      # This is not so horrible as for FileContent, but still possible to mutate the content that the
+      # checksum is based on... so semi horrible...
+      return @contents;
+    end
+  end
+
+  class FileContents
+    def initialize(path)
+      @path = path
+    end
+
+    def stream(&block)
+      Puppet::FileSystem.open(@path, nil, 'rb', &block)
+    end
+
+    def size
+      Puppet::FileSystem.size(@path)
+    end
+
+    def checksum_data(base_method)
+      Puppet.info("Computing checksum on file #{@path}")
+      Puppet::Util::Checksums.method(:"#{base_method}_file").call(@path)
+    end
+
+    def to_s
+      Puppet::FileSystem::binread(@path)
+    end
+  end
 end

data/lib/puppet/file_serving/configuration/parser.rb

@@ -67,7 +67,7 @@ class Puppet::FileServing::Configuration::Parser
         mount.info "allowing #{val} access"
         mount.allow(val)
       rescue Puppet::AuthStoreError => detail
-        raise ArgumentError.new(detail.to_s, @count, @file)
+        raise ArgumentError.new("#{detail.to_s} in #{@file}, line #{@count}")
       end
     }
   end
@@ -79,14 +79,14 @@ class Puppet::FileServing::Configuration::Parser
         mount.info "denying #{val} access"
         mount.deny(val)
       rescue Puppet::AuthStoreError => detail
-        raise ArgumentError.new(detail.to_s, @count, @file)
+        raise ArgumentError.new("#{detail.to_s} in #{@file}, line #{@count}")
       end
     }
   end
 
   # Create a new mount.
   def newmount(name)
-    raise ArgumentError, "#{@mounts[name]} is already mounted at #{name}", @count, @file if @mounts.include?(name)
+    raise ArgumentError.new("#{@mounts[name]} is already mounted at #{name} in #{@file}, line #{@count}") if @mounts.include?(name)
     case name
     when "modules"
       mount = Mount::Modules.new(name)

data/lib/puppet/file_system.rb

@@ -3,7 +3,7 @@ module Puppet::FileSystem
   require 'puppet/file_system/file_impl'
   require 'puppet/file_system/memory_file'
   require 'puppet/file_system/memory_impl'
-  require 'puppet/file_system/tempfile'
+  require 'puppet/file_system/uniquefile'
 
   # create instance of the file system implementation to use for the current platform
   @impl = if RUBY_VERSION =~ /^1\.8/

data/lib/puppet/file_system/file19.rb

@@ -2,4 +2,45 @@ class Puppet::FileSystem::File19 < Puppet::FileSystem::FileImpl
   def binread(path)
     path.binread
   end
+
+  # Provide an encoding agnostic version of compare_stream
+  #
+  # The FileUtils implementation in Ruby 2.0+ was modified in a manner where
+  # it cannot properly compare File and StringIO instances. To sidestep that
+  # issue this method reimplements the faster 2.0 version that will correctly
+  # compare binary File and StringIO streams.
+  def compare_stream(path, stream)
+    open(path, 0, 'rb') do |this|
+      bsize = stream_blksize(this, stream)
+      sa = "".force_encoding('ASCII-8BIT')
+      sb = "".force_encoding('ASCII-8BIT')
+      begin
+        this.read(bsize, sa)
+        stream.read(bsize, sb)
+        return true if sa.empty? && sb.empty?
+      end while sa == sb
+      false
+    end
+  end
+
+  private
+  def stream_blksize(*streams)
+    streams.each do |s|
+      next unless s.respond_to?(:stat)
+      size = blksize(s.stat)
+      return size if size
+    end
+    default_blksize()
+  end
+
+  def blksize(st)
+    s = st.blksize
+    return nil unless s
+    return nil if s == 0
+    s
+  end
+
+  def default_blksize
+    1024
+  end
 end

data/lib/puppet/file_system/file19windows.rb

@@ -26,7 +26,6 @@ class Puppet::FileSystem::File19Windows < Puppet::FileSystem::File19
 
     dest_exists = exist?(dest) # returns false on dangling symlink
     dest_stat = Puppet::Util::Windows::File.stat(dest) if dest_exists
-    dest_symlink = Puppet::Util::Windows::File.symlink?(dest)
 
     # silent fail to preserve semantics of original FileUtils
     return 0 if dest_exists && dest_stat.ftype == 'directory'

data/lib/puppet/file_system/uniquefile.rb

@@ -0,0 +1,190 @@
+require 'puppet/file_system'
+require 'delegate'
+require 'tmpdir'
+
+# A class that provides `Tempfile`-like capabilities, but does not attempt to
+# manage the deletion of the file for you.  API is identical to the
+# normal `Tempfile` class.
+#
+# @api public
+class Puppet::FileSystem::Uniquefile < DelegateClass(File)
+  # Convenience method which ensures that the file is closed and
+  # unlinked before returning
+  #
+  # @param identifier [String] additional part of generated pathname
+  # @yieldparam file [File] the temporary file object
+  # @return result of the passed block
+  # @api private
+  def self.open_tmp(identifier)
+    f = new(identifier)
+    yield f
+  ensure
+    if f
+      f.close!
+    end
+  end
+
+  def initialize(basename, *rest)
+    create_tmpname(basename, *rest) do |tmpname, n, opts|
+      mode = File::RDWR|File::CREAT|File::EXCL
+      perm = 0600
+      if opts
+        mode |= opts.delete(:mode) || 0
+        opts[:perm] = perm
+        perm = nil
+      else
+        opts = perm
+      end
+      self.class.locking(tmpname) do
+        @tmpfile = File.open(tmpname, mode, opts)
+        @tmpname = tmpname
+      end
+      @mode = mode & ~(File::CREAT|File::EXCL)
+      perm or opts.freeze
+      @opts = opts
+    end
+
+    super(@tmpfile)
+  end
+
+  # Opens or reopens the file with mode "r+".
+  def open
+    @tmpfile.close if @tmpfile
+    @tmpfile = File.open(@tmpname, @mode, @opts)
+    __setobj__(@tmpfile)
+  end
+
+  def _close
+    begin
+      @tmpfile.close if @tmpfile
+    ensure
+      @tmpfile = nil
+    end
+  end
+  protected :_close
+
+  def close(unlink_now=false)
+    if unlink_now
+      close!
+    else
+      _close
+    end
+  end
+
+  def close!
+    _close
+    unlink
+  end
+
+  def unlink
+    return unless @tmpname
+    begin
+      File.unlink(@tmpname)
+    rescue Errno::ENOENT
+    rescue Errno::EACCES
+      # may not be able to unlink on Windows; just ignore
+      return
+    end
+    @tmpname = nil
+  end
+  alias delete unlink
+
+  # Returns the full path name of the temporary file.
+  # This will be nil if #unlink has been called.
+  def path
+    @tmpname
+  end
+
+  private
+
+  def make_tmpname(prefix_suffix, n)
+    case prefix_suffix
+      when String
+        prefix = prefix_suffix
+        suffix = ""
+      when Array
+        prefix = prefix_suffix[0]
+        suffix = prefix_suffix[1]
+      else
+        raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+    end
+    t = Time.now.strftime("%Y%m%d")
+    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+    path << "-#{n}" if n
+    path << suffix
+  end
+
+  def create_tmpname(basename, *rest)
+    if opts = try_convert_to_hash(rest[-1])
+      opts = opts.dup if rest.pop.equal?(opts)
+      max_try = opts.delete(:max_try)
+      opts = [opts]
+    else
+      opts = []
+    end
+    tmpdir, = *rest
+    if $SAFE > 0 and tmpdir.tainted?
+      tmpdir = '/tmp'
+    else
+      tmpdir ||= tmpdir()
+    end
+    n = nil
+    begin
+      path = File.expand_path(make_tmpname(basename, n), tmpdir)
+      yield(path, n, *opts)
+    rescue Errno::EEXIST
+      n ||= 0
+      n += 1
+      retry if !max_try or n < max_try
+      raise "cannot generate temporary name using `#{basename}' under `#{tmpdir}'"
+    end
+    path
+  end
+
+  def try_convert_to_hash(h)
+    begin
+      h.to_hash
+    rescue NoMethodError => e
+      nil
+    end
+  end
+
+  @@systmpdir ||= defined?(Etc.systmpdir) ? Etc.systmpdir : '/tmp'
+
+  def tmpdir
+    tmp = '.'
+    if $SAFE > 0
+      tmp = @@systmpdir
+    else
+      for dir in [ENV['TMPDIR'], ENV['TMP'], ENV['TEMP'], @@systmpdir, '/tmp']
+        if dir and stat = File.stat(dir) and stat.directory? and stat.writable?
+          tmp = dir
+          break
+        end rescue nil
+      end
+      File.expand_path(tmp)
+    end
+  end
+
+
+  class << self
+    # yields with locking for +tmpname+ and returns the result of the
+    # block.
+    def locking(tmpname)
+      lock = tmpname + '.lock'
+      mkdir(lock)
+      yield
+    ensure
+      rmdir(lock) if lock
+    end
+
+    def mkdir(*args)
+      Dir.mkdir(*args)
+    end
+
+    def rmdir(*args)
+      Dir.rmdir(*args)
+    end
+  end
+
+end