bolt 0.21.1 → 0.21.2

data/vendored/puppet/lib/puppet/ssl/oids.rb

@@ -187,7 +187,7 @@ module Puppet::SSL::Oids
     else
       second_oid.index(first_oid) == 0
     end
-  rescue OpenSSL::ASN1::ASN1Error
+  rescue OpenSSL::ASN1::ASN1Error, TypeError
     false
   end
 end

data/vendored/puppet/lib/puppet/test/test_helper.rb

@@ -143,6 +143,9 @@ module Puppet::Test
       Puppet::Application.clear!
       Puppet::Util::Profiler.clear
 
+      Puppet::SSL::Host.reset
+      Puppet::SSL::Host.ca_location = :none
+
       Puppet.clear_deprecation_warnings
     end
 

data/vendored/puppet/lib/puppet/transaction/event_manager.rb

@@ -151,9 +151,11 @@ class Puppet::Transaction::EventManager
     end
     return true
   rescue => detail
-    resource.err _("Failed to call %{callback}: %{detail}") % { callback: callback, detail: detail }
+    resource_error_message = _("Failed to call %{callback}: %{detail}") % { callback: callback, detail: detail }
+    resource.err resource_error_message
 
     transaction.resource_status(resource).failed_to_restart = true
+    transaction.resource_status(resource).fail_with_event(resource_error_message)
     resource.log_exception(detail)
     return false
   end

data/vendored/puppet/lib/puppet/transaction/report.rb

@@ -224,7 +224,7 @@ class Puppet::Transaction::Report
     @external_times ||= {}
     @host = Puppet[:node_name_value]
     @time = Time.now
-    @report_format = 9
+    @report_format = 10
     @puppet_version = Puppet.version
     @configuration_version = configuration_version
     @transaction_uuid = transaction_uuid

data/vendored/puppet/lib/puppet/type.rb

@@ -1799,7 +1799,7 @@ end
     name = name.intern
 
     # If we don't have it yet, try loading it.
-    @providerloader.load(name) unless provider_hash.has_key?(name)
+    @providerloader.load(name, Puppet.lookup(:current_environment)) unless provider_hash.has_key?(name)
     provider_hash[name]
   end
 
@@ -1966,7 +1966,7 @@ end
   # @return [Array<Puppet::Provider>] Returns an array of all suitable providers.
   #
   def self.suitableprovider
-    providerloader.loadall if provider_hash.empty?
+    providerloader.loadall(Puppet.lookup(:current_environment)) if provider_hash.empty?
     provider_hash.find_all { |name, provider|
       provider.suitable?
     }.collect { |name, provider|

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

@@ -122,9 +122,8 @@ module Puppet
 
     # Make sure we're also managing the checksum property.
     def should=(value)
-      # treat the value as a bytestring, in Ruby versions that support it, regardless of the encoding
-      # in which it has been supplied
-      value = value.dup.force_encoding(Encoding::ASCII_8BIT) if value.respond_to?(:force_encoding)
+      # treat the value as a bytestring
+      value = value.b if value.is_a?(String)
       @resource.newattr(:checksum) unless @resource.parameter(:checksum)
       super
     end

data/vendored/puppet/lib/puppet/type/schedule.rb

@@ -112,6 +112,11 @@ module Puppet
 
           self.fail _("Invalid range %{value}") % { value: value } if range.length != 2
 
+          # Fill out 0s for unspecified minutes and seconds
+          range.each do |time_array|
+            (3 - time_array.length).times { |_| time_array << 0 }
+          end
+
           # Make sure the hours are valid
           [range[0][0], range[1][0]].each do |n|
             raise ArgumentError, _("Invalid hour '%{n}'") % { n: n } if n < 0 or n > 23
@@ -127,100 +132,44 @@ module Puppet
         ret
       end
 
+      def weekday_match?(day)
+        if @resource[:weekday]
+          @resource[:weekday].has_key?(day)
+        else
+          true
+        end
+      end
+
       def match?(previous, now)
         # The lowest-level array is of the hour, minute, second triad
         # then it's an array of two of those, to present the limits
         # then it's an array of those ranges
         @value = [@value] unless @value[0][0].is_a?(Array)
+        @value.any? do |range|
+          limit_start = Time.local(now.year, now.month, now.day, *range[0])
+          limit_end = Time.local(now.year, now.month, now.day, *range[1])
 
-        @value.each do |value|
-          limits = value.collect do |range|
-            ary = [now.year, now.month, now.day, range[0]]
-            if range[1]
-              ary << range[1]
-            else
-              ary << 0
-            end
-
-            if range[2]
-              ary << range[2]
+          if limit_start < limit_end
+            # The whole range is in one day, simple case
+            now.between?(limit_start, limit_end) && weekday_match?(now.wday)
+          else
+            # The range spans days. We have to test against a range starting
+            # today, and a range that started yesterday.
+            today = Date.new(now.year, now.month, now.day)
+            tomorrow = today.next_day
+            yesterday = today.prev_day
+
+            # First check a range starting today
+            if now.between?(limit_start, Time.local(tomorrow.year, tomorrow.month, tomorrow.day, *range[1]))
+              weekday_match?(today.wday)
             else
-              ary << 0
-            end
-
-            time = Time.local(*ary)
-
-            unless time.hour == range[0]
-              self.devfail(
-                _("Incorrectly converted time: %{time}: %{hour} vs %{value}") % { time: time, hour: time.hour, value: range[0] }
-              )
+              # Then check a range starting yesterday
+              now.between?(Time.local(yesterday.year, yesterday.month, yesterday.day, *range[0]),
+                           limit_end) &&
+                weekday_match?(yesterday.wday)
             end
-
-            time
-          end
-
-          unless limits[0] < limits[1]
-            self.info(
-            _("Assuming upper limit should be that time the next day")
-            )
-
-            # Find midnight between the two days. Adding one second
-            # to the end of the day is easier than dealing with dates.
-            ary = limits[0].to_a
-            ary[0] = 59
-            ary[1] = 59
-            ary[2] = 23
-            midnight = Time.local(*ary)+1
-
-            # If it is currently between the range start and midnight
-            # we consider that a successful match.
-            if now.between?(limits[0], midnight)
-              # We have to check the weekday match here as it is special-cased
-              # to support day-spanning ranges.
-              if @resource[:weekday]
-                return false unless @resource[:weekday].has_key?(now.wday)
-              end
-              return true
-            end
-
-            # If we didn't match between the starting time and midnight
-            # we must now move our midnight back 24 hours and try
-            # between the new midnight (24 hours prior) and the
-            # ending time.
-            midnight -= 86400
-
-            # Now we compare the current time between midnight and the
-            # end time.
-            if now.between?(midnight, limits[1])
-              # This case is the reason weekday matching is special cased
-              # in the range parameter. If we match a range that has spanned
-              # past midnight we want to match against the weekday when the range
-              # started, not when it currently is.
-              if @resource[:weekday]
-                return false unless @resource[:weekday].has_key?((now - 86400).wday)
-              end
-              return true
-            end
-
-            # If neither of the above matched then we don't match the
-            # range schedule.
-            return false
-          end
-
-          # Check to see if a weekday parameter was specified and, if so,
-          # do we match it or not. If we fail we can stop here.
-          # This is required because spanning ranges forces us to check
-          # weekday within the range parameter.
-          if @resource[:weekday]
-            return false unless @resource[:weekday].has_key?(now.wday)
           end
-
-          return true if now.between?(*limits)
         end
-
-        # Else, return false, since our current time isn't between
-        # any valid times
-        false
       end
     end
 

data/vendored/puppet/lib/puppet/type/user.rb

@@ -184,7 +184,7 @@ module Puppet
       # encoding to support concatenation for display.
       # overrides Puppet::Property#change_to_s
       def change_to_s(currentvalue, newvalue)
-        if newvalue.respond_to?(:force_encoding) && !Encoding.compatible?(currentvalue, newvalue)
+        if newvalue.is_a?(String) && !Encoding.compatible?(currentvalue, newvalue)
           return super(currentvalue, newvalue.dup.force_encoding(currentvalue.encoding))
         end
         super(currentvalue, newvalue)

data/vendored/puppet/lib/puppet/util.rb

@@ -631,6 +631,11 @@ module Util
         Puppet::Util::Windows::File.replace_file(FileSystem.path_string(file), tempfile.path)
 
       else
+        # MRI Ruby checks for this and raises an error, while JRuby removes the directory
+        # and replaces it with a file. This makes the our version of replace_file() consistent
+        if Puppet::FileSystem.exist?(file) && Puppet::FileSystem.directory?(file)
+          raise Errno::EISDIR, _("Is a directory: %{directory}") % { directory: file }
+        end
         File.rename(tempfile.path, Puppet::FileSystem.path_string(file))
       end
     ensure

data/vendored/puppet/lib/puppet/util/autoload.rb

@@ -35,19 +35,20 @@ class Puppet::Util::Autoload
     # Save the fact that a given path has been loaded.  This is so
     # we can load downloaded plugins if they've already been loaded
     # into memory.
+    # @api private
     def mark_loaded(name, file)
       name = cleanpath(name).chomp('.rb')
-      ruby_file = name + ".rb"
-      $LOADED_FEATURES << ruby_file unless $LOADED_FEATURES.include?(ruby_file)
+      file = File.expand_path(file)
+      $LOADED_FEATURES << file unless $LOADED_FEATURES.include?(file)
       loaded[name] = [file, File.mtime(file)]
     end
 
-    def changed?(name)
+    # @api private
+    def changed?(name, env)
       name = cleanpath(name).chomp('.rb')
       return true unless loaded.include?(name)
       file, old_mtime = loaded[name]
-      environment = Puppet.lookup(:current_environment)
-      return true unless file == get_file(name, environment)
+      return true unless file == get_file(name, env)
       begin
         old_mtime.to_i != File.mtime(file).to_i
       rescue Errno::ENOENT
@@ -73,7 +74,7 @@ class Puppet::Util::Autoload
       end
     end
 
-    def loadall(path, env = nil)
+    def loadall(path, env)
       # Load every instance of everything we can find.
       files_to_load(path, env).each do |file|
         name = file.chomp(".rb")
@@ -81,22 +82,28 @@ class Puppet::Util::Autoload
       end
     end
 
-    def reload_changed
-      loaded.keys.each { |file| load_file(file, nil) if changed?(file) }
+    def reload_changed(env)
+      loaded.keys.each do |file|
+        if changed?(file, env)
+          load_file(file, env)
+        end
+      end
     end
 
     # Get the correct file to load for a given path
     # returns nil if no file is found
+    # @api private
     def get_file(name, env)
       name = name + '.rb' unless name =~ /\.rb$/
       path = search_directories(env).find { |dir| Puppet::FileSystem.exist?(File.join(dir, name)) }
       path and File.join(path, name)
     end
 
-    def files_to_load(path, env = nil)
+    def files_to_load(path, env)
       search_directories(env).map {|dir| files_in_dir(dir, path) }.flatten.uniq
     end
 
+    # @api private
     def files_in_dir(dir, path)
       dir = Pathname.new(File.expand_path(dir))
       Dir.glob(File.join(dir, path, "*.rb")).collect do |file|
@@ -104,7 +111,10 @@ class Puppet::Util::Autoload
       end
     end
 
+    # @api private
     def module_directories(env)
+      raise ArgumentError, "Autoloader requires an environment" unless env
+
       # This is a little bit of a hack.  Basically, the autoloader is being
       # called indirectly during application bootstrapping when we do things
       # such as check "features".  However, during bootstrapping, we haven't
@@ -125,27 +135,22 @@ class Puppet::Util::Autoload
       # "app_defaults_initialized?" method on the main puppet Settings object.
       # --cprice 2012-03-16
       if Puppet.settings.app_defaults_initialized?
-        env ||= Puppet.lookup(:environments).get(Puppet[:environment])
-
-        if env
-          # if the app defaults have been initialized then it should be safe to access the module path setting.
-          Puppet::Util::ModuleDirectoriesAdapter.adapt(env) do |a|
-            a.directories ||= env.modulepath.collect do |dir|
-              Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
-            end.flatten.find_all do |d|
-              FileTest.directory?(d)
-            end
-          end.directories
-        else
-          []
-        end
+        # if the app defaults have been initialized then it should be safe to access the module path setting.
+        Puppet::Util::ModuleDirectoriesAdapter.adapt(env) do |a|
+          a.directories ||= env.modulepath.collect do |dir|
+            Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f, "lib") }
+          end.flatten.find_all do |d|
+            FileTest.directory?(d)
+          end
+        end.directories
       else
         # if we get here, the app defaults have not been initialized, so we basically use an empty module path.
         []
       end
     end
 
-    def libdirs()
+    # @api private
+    def libdirs
       # 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?)
@@ -155,12 +160,14 @@ class Puppet::Util::Autoload
       end
     end
 
+    # @api private
     def gem_directories
       gem_source.directories
     end
 
+    # @api private
     def search_directories(env)
-      [gem_directories, module_directories(env), libdirs(), $LOAD_PATH].flatten
+      [gem_directories, module_directories(env), libdirs, $LOAD_PATH].flatten
     end
 
     # Normalize a path. This converts ALT_SEPARATOR to SEPARATOR on Windows
@@ -185,7 +192,7 @@ class Puppet::Util::Autoload
     @object = obj
   end
 
-  def load(name, env = nil)
+  def load(name, env)
     self.class.load_file(expand(name), env)
   end
 
@@ -199,7 +206,7 @@ class Puppet::Util::Autoload
   #
   # This uses require, rather than load, so that already-loaded files don't get
   # reloaded unnecessarily.
-  def loadall(env = nil)
+  def loadall(env)
     self.class.loadall(@path, env)
   end
 
@@ -207,12 +214,13 @@ class Puppet::Util::Autoload
     self.class.loaded?(expand(name))
   end
 
-  def changed?(name)
-    self.class.changed?(expand(name))
+  # @api private
+  def changed?(name, env)
+    self.class.changed?(expand(name), env)
   end
 
-  def files_to_load
-    self.class.files_to_load(@path)
+  def files_to_load(env)
+    self.class.files_to_load(@path, env)
   end
 
   def expand(name)

data/vendored/puppet/lib/puppet/util/character_encoding.rb

@@ -72,27 +72,5 @@ module Puppet::Util::CharacterEncoding
         return string_copy.force_encoding(original_encoding)
       end
     end
-
-    REPLACEMENT_CHAR_MAP = {
-      Encoding::UTF_8 => "\uFFFD",
-      Encoding::UTF_16LE => "\xFD\xFF".force_encoding(Encoding::UTF_16LE),
-    }
-
-    # Given a string, return a copy of that string with any invalid byte
-    # sequences in its current encoding replaced with the replacement character
-    # "\uFFFD" (UTF-8) if the string is UTF-8 or UTF-16LE, or "?" otherwise.
-    # @param string a string to remove invalid byte sequences from
-    # @return a copy of string invalid byte sequences replaced by the unicode
-    #   replacement character or "?" character
-    # @note does not modify encoding, but new string will have different bytes
-    #   from original. Only needed for ruby 1.9.3 support.
-    def scrub(string)
-      if string.respond_to?(:scrub)
-        string.scrub
-      else
-        replacement_character = REPLACEMENT_CHAR_MAP[string.encoding] || '?'
-        string.chars.map { |c| c.valid_encoding? ? c : replacement_character }.join
-      end
-    end
   end
 end

data/vendored/puppet/lib/puppet/util/command_line.rb

@@ -123,7 +123,6 @@ module Puppet
                 $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
               end
 
-              Puppet::GettextConfig.reset_text_domain('cli')
               Puppet::ModuleTranslations.load_from_modulepath(configured_environment.modules)
               Puppet::ModuleTranslations.load_from_vardir(Puppet[:vardir])
 

data/vendored/puppet/lib/puppet/util/connection.rb

@@ -0,0 +1,74 @@
+require 'puppet'
+
+module Puppet::Util
+  module Connection
+    # The logic for server and port is kind of gross. In summary:
+    # IF an endpoint-specific setting is requested AND that setting has been set by the user
+    #    Use that setting.
+    #         The defaults for these settings are the "normal" server/masterport settings, so
+    #         when they are unset we instead want to "fall back" to the failover-selected
+    #         host/port pair.
+    # ELSE IF we have a failover-selected host/port
+    #    Use what the failover logic came up with
+    # ELSE IF the server_list setting is in use
+    #    Use the first entry - failover hasn't happened yet, but that
+    #    setting is still authoritative
+    # ELSE
+    #    Go for the legacy server/masterport settings, and hope for the best
+
+    # Determines which server to use based on the specified setting, taking into
+    # account HA fallback from server_list.
+    # @param [Symbol] setting The preferred server setting to use
+    # @return [String] the name of the server for use in the request
+    def self.determine_server(setting)
+      if setting && setting != :server && Puppet.settings.set_by_config?(setting)
+        Puppet[setting]
+      else
+        server = Puppet.lookup(:server) do
+          if primary_server = Puppet.settings[:server_list][0]
+            Puppet.debug "Dynamically-bound server lookup failed; using first entry"
+            primary_server[0]
+          else
+            setting ||= :server
+            Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
+            Puppet.settings[setting]
+          end
+        end
+        server
+      end
+    end
+
+    # Determines which port to use based on the specified setting, taking into
+    # account HA fallback from server_list.
+    # For port there's a little bit of an extra snag: setting a specific
+    # server setting and relying on the default port for that server is
+    # common, so we also want to check if the assocaited SERVER setting
+    # has been set by the user. If either of those are set we ignore the
+    # failover-selected port.
+    # @param [Symbol] port_setting The preferred port setting to use
+    # @param [Symbol] server_setting The server setting assoicated with this route.
+    # @return [String] the port to use for use in the request
+    def self.determine_port(port_setting, server_setting)
+      if (port_setting && port_setting != :masterport && Puppet.settings.set_by_config?(port_setting)) ||
+         (server_setting && server_setting != :server && Puppet.settings.set_by_config?(server_setting))
+        Puppet.settings[port_setting].to_i
+      else
+        port = Puppet.lookup(:serverport) do
+          if primary_server = Puppet.settings[:server_list][0]
+            Puppet.debug "Dynamically-bound port lookup failed; using first entry"
+
+            # Port might not be set, so we want to fallback in that
+            # case. We know we don't need to use `setting` here, since
+            # the default value of every port setting is `masterport`
+            (primary_server[1] || Puppet.settings[:masterport])
+          else
+            port_setting ||= :masterport
+            Puppet.debug "Dynamically-bound port lookup failed; falling back to #{port_setting} setting"
+            Puppet.settings[port_setting]
+          end
+        end
+        port.to_i
+      end
+    end
+  end
+end