puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/lib/puppet/util.rb

@@ -23,15 +23,6 @@ module Util
 
   extend Puppet::Util::SymbolicFileMode
 
-  def self.activerecord_version
-    if (defined?(::ActiveRecord) and defined?(::ActiveRecord::VERSION) and defined?(::ActiveRecord::VERSION::MAJOR) and defined?(::ActiveRecord::VERSION::MINOR))
-      ([::ActiveRecord::VERSION::MAJOR, ::ActiveRecord::VERSION::MINOR].join('.').to_f)
-    else
-      0
-    end
-  end
-
-
   # Run some code with a specific environment.  Resets the environment back to
   # what it was at the end of the code.
   def self.withenv(hash)
@@ -111,29 +102,6 @@ module Util
     }
   end
 
-  # Proxy a bunch of methods to another object.
-  def self.classproxy(klass, objmethod, *methods)
-    classobj = class << klass; self; end
-    methods.each do |method|
-      classobj.send(:define_method, method) do |*args|
-        obj = self.send(objmethod)
-
-        obj.send(method, *args)
-      end
-    end
-  end
-
-  # Proxy a bunch of methods to another object.
-  def self.proxy(klass, objmethod, *methods)
-    methods.each do |method|
-      klass.send(:define_method, method) do |*args|
-        obj = self.send(objmethod)
-
-        obj.send(method, *args)
-      end
-    end
-  end
-
   def benchmark(*args)
     msg = args.pop
     level = args.pop
@@ -292,15 +260,7 @@ module Util
       $stdout.reopen(stdout)
       $stderr.reopen(stderr)
 
-      begin
-        Dir.foreach('/proc/self/fd') do |f|
-          if f != '.' && f != '..' && f.to_i >= 3
-            IO::new(f.to_i).close rescue nil
-          end
-        end
-      rescue Errno::ENOENT # /proc/self/fd not found
-        3.upto(256){|fd| IO::new(fd).close rescue nil}
-      end
+      3.upto(256){|fd| IO::new(fd).close rescue nil}
 
       block.call if block
     end
@@ -308,17 +268,6 @@ module Util
   end
   module_function :safe_posix_fork
 
-  def memory
-    unless defined?(@pmap)
-      @pmap = which('pmap')
-    end
-    if @pmap
-      %x{#{@pmap} #{Process.pid}| grep total}.chomp.sub(/^\s*total\s+/, '').sub(/K$/, '').to_i
-    else
-      0
-    end
-  end
-
   def symbolizehash(hash)
     newhash = {}
     hash.each do |name, val|
@@ -338,14 +287,7 @@ module Util
     seconds
   end
 
-  module_function :memory, :thinmark
-
-  # Because IO#binread is only available in 1.9
-  def binread(file)
-    Puppet.deprecation_warning("Puppet::Util.binread is deprecated. Read the file without this method as it will be removed in a future version.")
-    File.open(file, 'rb') { |f| f.read }
-  end
-  module_function :binread
+  module_function :thinmark
 
   # utility method to get the current call stack and format it to a human-readable string (which some IDEs/editors
   # will recognize as links to the line numbers in the trace)
@@ -522,31 +464,6 @@ module Util
     end
   end
   module_function :deterministic_rand
-
-
-  #######################################################################################################
-  # Deprecated methods relating to process execution; these have been moved to Puppet::Util::Execution
-  #######################################################################################################
-
-  def execpipe(command, failonfail = true, &block)
-    Puppet.deprecation_warning("Puppet::Util.execpipe is deprecated; please use Puppet::Util::Execution.execpipe")
-    Puppet::Util::Execution.execpipe(command, failonfail, &block)
-  end
-  module_function :execpipe
-
-  def execfail(command, exception)
-    Puppet.deprecation_warning("Puppet::Util.execfail is deprecated; please use Puppet::Util::Execution.execfail")
-    Puppet::Util::Execution.execfail(command, exception)
-  end
-  module_function :execfail
-
-  def execute(*args)
-    Puppet.deprecation_warning("Puppet::Util.execute is deprecated; please use Puppet::Util::Execution.execute")
-
-    Puppet::Util::Execution.execute(*args)
-  end
-  module_function :execute
-
 end
 end
 

data/lib/puppet/util/autoload.rb

@@ -7,13 +7,10 @@ require 'puppet/util/methodhelper'
 class Puppet::Util::Autoload
   include Puppet::Util::MethodHelper
 
-  @autoloaders = {}
   @loaded = {}
 
   class << self
-    attr_reader :autoloaders
     attr_accessor :loaded
-    private :autoloaders, :loaded
 
     def gem_source
       @gem_source ||= Puppet::Util::RubyGems::Source.new
@@ -59,7 +56,7 @@ class Puppet::Util::Autoload
       return false unless file
       begin
         mark_loaded(name, file)
-        Kernel.load file, @wrap
+        Kernel.load file
         return true
       rescue SystemExit,NoMemoryError
         raise
@@ -150,7 +147,7 @@ class Puppet::Util::Autoload
       # See the comments in #module_directories above.  Basically, we need to be careful not to try to access the
       # libdir before we know for sure that all of the settings have been initialized (e.g., during bootstrapping).
       if (Puppet.settings.app_defaults_initialized?)
-        Puppet[:libdir].split(File::PATH_SEPARATOR)
+        [Puppet[:libdir]]
       else
         []
       end
@@ -178,21 +175,14 @@ class Puppet::Util::Autoload
     end
   end
 
-  # Send [] and []= to the @autoloaders hash
-  Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
-
-  attr_accessor :object, :path, :objwarn, :wrap
+  attr_accessor :object, :path
 
   def initialize(obj, path, options = {})
     @path = path.to_s
     raise ArgumentError, "Autoload paths cannot be fully qualified" if Puppet::Util.absolute_path?(@path)
     @object = obj
 
-    self.class[obj] = self
-
     set_options(options)
-
-    @wrap = true unless defined?(@wrap)
   end
 
   def load(name, env = nil)

data/lib/puppet/util/checksums.rb

@@ -4,10 +4,7 @@ require 'digest/sha1'
 # A stand-alone module for calculating checksums
 # in a generic way.
 module Puppet::Util::Checksums
-  # @deprecated
-  # In Puppet 4 we should switch this to `module_function` to make these methods
-  # private when this class is included.
-  extend self
+  module_function
 
   # It's not a good idea to use some of these in some contexts: for example, I
   # wouldn't try bucketing a file using the :none checksum type.
@@ -59,19 +56,23 @@ module Puppet::Util::Checksums
     sha256_file(filename, true)
   end
 
-  def sha256_stream(&block)
+  def sha256_stream(lite = false, &block)
     require 'digest/sha2'
     digest = Digest::SHA256.new
-    yield digest
-    digest.hexdigest
+    checksum_stream(digest, block, lite)
   end
 
   def sha256_hex_length
     64
   end
 
-  alias :sha256lite_stream :sha256_stream
-  alias :sha256lite_hex_length :sha256_hex_length
+  def sha256lite_stream(&block)
+    sha256_stream(true, &block)
+  end
+
+  def sha256lite_hex_length
+    sha256_hex_length
+  end
 
   # Calculate a checksum using Digest::MD5.
   def md5(content)
@@ -94,18 +95,22 @@ module Puppet::Util::Checksums
     md5_file(filename, true)
   end
 
-  def md5_stream(&block)
+  def md5_stream(lite = false, &block)
     digest = Digest::MD5.new
-    yield digest
-    digest.hexdigest
+    checksum_stream(digest, block, lite)
   end
 
   def md5_hex_length
     32
   end
 
-  alias :md5lite_stream :md5_stream
-  alias :md5lite_hex_length :md5_hex_length
+  def md5lite_stream(&block)
+    md5_stream(true, &block)
+  end
+
+  def md5lite_hex_length
+    md5_hex_length
+  end
 
   # Return the :mtime timestamp of a file.
   def mtime_file(filename)
@@ -114,7 +119,7 @@ module Puppet::Util::Checksums
 
   # by definition this doesn't exist
   # but we still need to execute the block given
-  def mtime_stream
+  def mtime_stream(&block)
     noop_digest = FakeChecksum.new
     yield noop_digest
     nil
@@ -145,25 +150,31 @@ module Puppet::Util::Checksums
     sha1_file(filename, true)
   end
 
-  def sha1_stream
+  def sha1_stream(lite = false, &block)
     digest = Digest::SHA1.new
-    yield digest
-    digest.hexdigest
+    checksum_stream(digest, block, lite)
   end
 
   def sha1_hex_length
     40
   end
 
-  alias :sha1lite_stream :sha1_stream
-  alias :sha1lite_hex_length :sha1_hex_length
+  def sha1lite_stream(&block)
+    sha1_stream(true, &block)
+  end
+
+  def sha1lite_hex_length
+    sha1_hex_length
+  end
 
   # Return the :ctime of a file.
   def ctime_file(filename)
     Puppet::FileSystem.stat(filename).send(:ctime)
   end
 
-  alias :ctime_stream :mtime_stream
+  def ctime_stream(&block)
+    mtime_stream(&block)
+  end
 
   def ctime(content)
     ""
@@ -184,7 +195,28 @@ module Puppet::Util::Checksums
     ""
   end
 
-  private
+  class DigestLite
+    def initialize(digest, lite = false)
+      @digest = digest
+      @lite = lite
+      @bytes = 0
+    end
+
+    # Provide an interface for digests. If lite, only digest the first 512 bytes
+    def <<(str)
+      if @lite
+        if @bytes < 512
+          buf = str[0, 512 - @bytes]
+          @digest << buf
+          @bytes += buf.length
+        end
+      else
+        @digest << str
+      end
+    end
+  end
+
+  private_class_method
 
   # Perform an incremental checksum on a file.
   def checksum_file(digest, filename, lite = false)
@@ -199,4 +231,9 @@ module Puppet::Util::Checksums
     digest.hexdigest
   end
 
+  def checksum_stream(digest, block, lite = false)
+    block.call(DigestLite.new(digest, lite))
+    digest.hexdigest
+  end
+
 end

data/lib/puppet/util/classgen.rb

@@ -143,18 +143,10 @@ module Puppet::Util::ClassGen
     klass
   end
 
-  # const_defined? in Ruby 1.9 behaves differently in terms
-  # of which class hierarchy it polls for nested namespaces
-  #
-  # See http://redmine.ruby-lang.org/issues/show/1915
   # @api private
   #
   def is_constant_defined?(const)
-    if ::RUBY_VERSION =~ /^1\.8/
-      const_defined?(const)
-    else
-      const_defined?(const, false)
-    end
+    const_defined?(const, false)
   end
 
   # Handle the setting and/or removing of the associated constant.

data/lib/puppet/util/colors.rb

@@ -76,127 +76,10 @@ module Puppet::Util::Colors
     :reset       => { :console => "\e[m", :html => "" }
   }
 
-  # We define console_has_color? at load time since it's checking the
-  # underlying platform which will not change, and we don't want to perform
-  # the check every time we use logging
-  if Puppet::Util::Platform.windows? && RUBY_VERSION =~ /^1\./
-    # We're on windows and using ruby less than v2
-    # so we need win32console for color to work
-    begin
-      require 'ffi'
-      require 'win32console'
-
-      # The win32console gem uses ANSI functions for writing to the console
-      # which doesn't work for unicode strings, e.g. module tool. Ruby 1.9
-      # does the same thing, but doesn't account for ANSI escape sequences
-      class WideConsole < Win32::Console
-        extend FFI::Library
-
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms687401(v=vs.85).aspx
-        # BOOL WINAPI WriteConsole(
-        #   _In_        HANDLE hConsoleOutput,
-        #   _In_        const VOID *lpBuffer,
-        #   _In_        DWORD nNumberOfCharsToWrite,
-        #   _Out_       LPDWORD lpNumberOfCharsWritten,
-        #   _Reserved_  LPVOID lpReserved
-        # );
-        ffi_lib :kernel32
-        attach_function_private :WriteConsoleW,
-          [:handle, :lpcwstr, :dword, :lpdword, :lpvoid], :win32_bool
-
-        # typedef struct _COORD {
-        #   SHORT X;
-        #   SHORT Y;
-        # } COORD, *PCOORD;
-        class COORD < FFI::Struct
-          layout :X, :short,
-                 :Y, :short
-        end
-
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms687410(v=vs.85).aspx
-        # BOOL WINAPI WriteConsoleOutputCharacter(
-        #   _In_   HANDLE hConsoleOutput,
-        #   _In_   LPCTSTR lpCharacter,
-        #   _In_   DWORD nLength,
-        #   _In_   COORD dwWriteCoord,
-        #   _Out_  LPDWORD lpNumberOfCharsWritten
-        # );
-        ffi_lib :kernel32
-        attach_function_private :WriteConsoleOutputCharacterW,
-          [:handle, :lpcwstr, :dword, COORD, :lpdword], :win32_bool
-
-        def initialize(t = nil)
-          super(t)
-        end
-
-        def WriteChar(str, col, row)
-          writeCoord = COORD.new()
-          writeCoord[:X] = row
-          writeCoord[:Y] = col
-
-          chars_written = 0
-          FFI::MemoryPointer.from_string_to_wide_string(str) do |msg_ptr|
-            FFI::MemoryPointer.new(:dword, 1) do |numberOfCharsWritten_ptr|
-              WriteConsoleOutputCharacterW(@handle, msg_ptr,
-                str.length, writeCoord, numberOfCharsWritten_ptr)
-              chars_written = numberOfCharsWritten_ptr.read_dword
-            end
-          end
-
-          chars_written
-        end
-
-        def Write(str)
-          result = false
-          FFI::MemoryPointer.from_string_to_wide_string(str) do |msg_ptr|
-            FFI::MemoryPointer.new(:dword, 1) do |numberOfCharsWritten_ptr|
-              result = WriteConsoleW(@handle, msg_ptr,
-                str.length, FFI::MemoryPointer.new(:dword, 1),
-                FFI::MemoryPointer::NULL) != FFI::WIN32_FALSE
-            end
-          end
-
-          result
-        end
-      end
-
-      # Override the win32console's IO class so we can supply
-      # our own Console class
-      class WideIO < Win32::Console::ANSI::IO
-        def initialize(fd_std = :stdout)
-          super(fd_std)
-
-          handle = FD_STD_MAP[fd_std][1]
-          @Out = WideConsole.new(handle)
-        end
-      end
-
-      $stdout = WideIO.new(:stdout)
-      $stderr = WideIO.new(:stderr)
-    rescue LoadError
-      def console_has_color?
-        false
-      end
-    else
-      def console_has_color?
-        true
-      end
-    end
-  else
-    # On a posix system we can just enable it
-    def console_has_color?
-      true
-    end
-  end
-
   def colorize(color, str)
     case Puppet[:color]
     when true, :ansi, "ansi", "yes"
-      if console_has_color?
         console_color(color, str)
-      else
-        str
-      end
     when :html, "html"
       html_color(color, str)
     else