openvox 7.37.1

data/lib/puppet/runtime.rb

@@ -0,0 +1,65 @@
+require_relative '../puppet/http'
+require_relative '../puppet/facter_impl'
+require 'singleton'
+
+# Provides access to runtime implementations.
+#
+# @api private
+class Puppet::Runtime
+  include Singleton
+
+  def initialize
+    @runtime_services = {
+      http: proc do
+        klass = Puppet::Network::HttpPool.http_client_class
+        if klass == Puppet::Network::HTTP::Connection
+          Puppet::HTTP::Client.new
+        else
+          Puppet::HTTP::ExternalClient.new(klass)
+        end
+      end,
+      facter: proc { Puppet::FacterImpl.new }
+    }
+  end
+  private :initialize
+
+  # Loads all runtime implementations.
+  #
+  # @return Array[Symbol] the names of loaded implementations
+  # @api private
+  def load_services
+    @runtime_services.keys.each { |key| self[key] }
+  end
+
+  # Get a runtime implementation.
+  #
+  # @param name [Symbol] the name of the implementation
+  # @return [Object] the runtime implementation
+  # @api private
+  def [](name)
+    service = @runtime_services[name]
+    raise ArgumentError, "Unknown service #{name}" unless service
+
+    if service.is_a?(Proc)
+      @runtime_services[name] = service.call
+    else
+      service
+    end
+  end
+
+  # Register a runtime implementation.
+  #
+  # @param name [Symbol] the name of the implementation
+  # @param impl [Object] the runtime implementation
+  # @api private
+  def []=(name, impl)
+    @runtime_services[name] = impl
+  end
+
+  # Clears all implementations. This is used for testing.
+  #
+  # @api private
+  def clear
+    initialize
+  end
+end

data/lib/puppet/scheduler/job.rb

@@ -0,0 +1,53 @@
+module Puppet::Scheduler
+  class Job
+    attr_reader :run_interval
+    attr_accessor :last_run
+    attr_accessor :start_time
+
+    def initialize(run_interval, &block)
+      self.run_interval = run_interval
+      @last_run = nil
+      @run_proc = block
+      @enabled = true
+    end
+
+    def run_interval=(interval)
+      @run_interval = [interval, 0].max
+    end
+
+    def ready?(time)
+      if @last_run
+        @last_run + @run_interval <= time
+      else
+        true
+      end
+    end
+
+    def enabled?
+      @enabled
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def interval_to_next_from(time)
+      if ready?(time)
+        0
+      else
+        @run_interval - (time - @last_run)
+      end
+    end
+
+    def run(now)
+      @last_run = now
+      if @run_proc
+        @run_proc.call(self)
+      end
+    end
+  end
+end

data/lib/puppet/scheduler/scheduler.rb

@@ -0,0 +1,44 @@
+module Puppet::Scheduler
+  class Scheduler
+    def initialize(timer=Puppet::Scheduler::Timer.new)
+      @timer = timer
+    end
+
+    def run_loop(jobs)
+      mark_start_times(jobs, @timer.now)
+      while not enabled(jobs).empty?
+        @timer.wait_for(min_interval_to_next_run_from(jobs, @timer.now))
+        run_ready(jobs, @timer.now)
+      end
+    end
+
+    private
+
+    def enabled(jobs)
+      jobs.select(&:enabled?)
+    end
+
+    def mark_start_times(jobs, start_time)
+      jobs.each do |job|
+        job.start_time = start_time
+      end
+    end
+
+    def min_interval_to_next_run_from(jobs, from_time)
+      enabled(jobs).map do |j|
+        j.interval_to_next_from(from_time)
+      end.min
+    end
+
+    def run_ready(jobs, at_time)
+      enabled(jobs).each do |j|
+        # This check intentionally happens right before each run,
+        # instead of filtering on ready schedulers, since one may adjust
+        # the readiness of a later one
+        if j.ready?(at_time)
+          j.run(at_time)
+        end
+      end
+    end
+  end
+end

data/lib/puppet/scheduler/splay_job.rb

@@ -0,0 +1,32 @@
+module Puppet::Scheduler
+  class SplayJob < Job
+    attr_reader :splay
+
+    def initialize(run_interval, splay_limit, &block)
+      @splay = calculate_splay(splay_limit)
+      super(run_interval, &block)
+    end
+
+    def interval_to_next_from(time)
+      if last_run
+        super
+      else
+        (start_time + splay) - time
+      end
+    end
+
+    def ready?(time)
+      if last_run
+        super
+      else
+        start_time + splay <= time
+      end
+    end
+
+    private
+
+    def calculate_splay(limit)
+      rand(limit + 1)
+    end
+  end
+end

data/lib/puppet/scheduler/timer.rb

@@ -0,0 +1,13 @@
+module Puppet::Scheduler
+  class Timer
+    def wait_for(seconds)
+      if seconds > 0
+        sleep(seconds)
+      end
+    end
+
+    def now
+      Time.now
+    end
+  end
+end

data/lib/puppet/scheduler.rb

@@ -0,0 +1,16 @@
+module Puppet::Scheduler
+  require_relative 'scheduler/job'
+  require_relative 'scheduler/splay_job'
+  require_relative 'scheduler/scheduler'
+  require_relative 'scheduler/timer'
+
+  module_function
+
+  def create_job(interval, splay=false, splay_limit=0, &block)
+    if splay
+      Puppet::Scheduler::SplayJob.new(interval, splay_limit, &block)
+    else
+      Puppet::Scheduler::Job.new(interval, &block)
+    end
+  end
+end

data/lib/puppet/settings/alias_setting.rb

@@ -0,0 +1,37 @@
+class Puppet::Settings::AliasSetting
+  attr_reader :name, :alias_name
+
+  def initialize(args = {})
+    @name = args[:name]
+    @alias_name = args[:alias_for]
+    @alias_for = Puppet.settings.setting(alias_name)
+  end
+
+  def optparse_args
+    args = @alias_for.optparse_args
+    args[0].gsub!(alias_name.to_s, name.to_s)
+    args
+  end
+
+  def getopt_args
+    args = @alias_for.getopt_args
+    args[0].gsub!(alias_name.to_s, name.to_s)
+    args
+  end
+
+  def type
+    :alias
+  end
+
+  def method_missing(method, *args)
+    begin
+      alias_for.send(method, *args)
+    rescue => e
+      Puppet.log_exception(self.class, e.message)
+    end
+  end
+
+  private
+
+  attr_reader :alias_for
+end

data/lib/puppet/settings/array_setting.rb

@@ -0,0 +1,17 @@
+class Puppet::Settings::ArraySetting < Puppet::Settings::BaseSetting
+
+  def type
+    :array
+  end
+
+  def munge(value)
+    case value
+    when String
+      value.split(/\s*,\s*/)
+    when Array
+      value
+    else
+      raise ArgumentError, _("Expected an Array or String, got a %{klass}") % { klass: value.class }
+    end
+  end
+end

data/lib/puppet/settings/autosign_setting.rb

@@ -0,0 +1,22 @@
+require_relative '../../puppet/settings/base_setting'
+
+# A specialization of the file setting to allow boolean values.
+#
+# The autosign value can be either a boolean or a file path, and if the setting
+# is a file path then it may have a owner/group/mode specified.
+#
+# @api private
+class Puppet::Settings::AutosignSetting < Puppet::Settings::FileSetting
+
+  def munge(value)
+    if ['true', true].include? value
+      true
+    elsif ['false', false, nil].include? value
+      false
+    elsif Puppet::Util.absolute_path?(value)
+      value
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid autosign value %{value}: must be 'true'/'false' or an absolute path") % { value: value }
+    end
+  end
+end

data/lib/puppet/settings/base_setting.rb

@@ -0,0 +1,223 @@
+require 'set'
+require_relative '../../puppet/settings/errors'
+
+# The base setting type
+class Puppet::Settings::BaseSetting
+  attr_writer :default
+  attr_accessor :name, :desc, :section
+  attr_reader :short, :deprecated, :call_hook
+
+  # Hooks are called during different parts of the settings lifecycle:
+  #
+  # * :on_write_only - This is the default hook type. The hook will be called
+  #   if its value is set in `main` or programmatically. If its value is set in
+  #   a section that doesn't match the application's run mode, it will be
+  #   ignored entirely. If the section does match the run mode, the value will
+  #   be used, but the hook will not be called!
+  #
+  # * :on_define_and_write - The hook behaves the same as above, except it is
+  #   also called immediately when the setting is defined in
+  #   {Puppet::Settings.define_settings}. In that case, the hook receives the
+  #   default value as specified.
+  #
+  # * :on_initialize_and_write - The hook will be called if the value is set in
+  #   `main`, the section that matches the run mode, or programmatically.
+  #
+  HOOK_TYPES = Set.new([:on_define_and_write, :on_initialize_and_write, :on_write_only]).freeze
+
+  def self.available_call_hook_values
+    HOOK_TYPES.to_a
+  end
+
+  # Registers a hook to be called later based on the type of hook specified in `value`.
+  #
+  # @param value [Symbol] One of {HOOK_TYPES}
+  def call_hook=(value)
+    if value.nil?
+      #TRANSLATORS ':%{name}', ':call_hook', and ':on_write_only' should not be translated
+      Puppet.warning _("Setting :%{name} :call_hook is nil, defaulting to :on_write_only") % { name: name }
+      value = :on_write_only
+    end
+    unless HOOK_TYPES.include?(value)
+      #TRANSLATORS 'call_hook' is a Puppet option name and should not be translated
+      raise ArgumentError, _("Invalid option %{value} for call_hook") % { value: value }
+    end
+    @call_hook = value
+  end
+
+  # @see {HOOK_TYPES}
+  def call_hook_on_define?
+    call_hook == :on_define_and_write
+  end
+
+  # @see {HOOK_TYPES}
+  def call_hook_on_initialize?
+    call_hook == :on_initialize_and_write
+  end
+
+  # get the arguments in getopt format
+  def getopt_args
+    if short
+      [["--#{name}", "-#{short}", GetoptLong::REQUIRED_ARGUMENT]]
+    else
+      [["--#{name}", GetoptLong::REQUIRED_ARGUMENT]]
+    end
+  end
+
+  # get the arguments in OptionParser format
+  def optparse_args
+    if short
+      ["--#{name}", "-#{short}", desc, :REQUIRED]
+    else
+      ["--#{name}", desc, :REQUIRED]
+    end
+  end
+
+  def hook=(block)
+    @has_hook = true
+    meta_def :handle, &block
+  end
+
+  def has_hook?
+    @has_hook
+  end
+
+  # Create the new element.  Pretty much just sets the name.
+  def initialize(args = {})
+    @settings = args.delete(:settings)
+    unless @settings
+      raise ArgumentError.new("You must refer to a settings object")
+    end
+
+    # explicitly set name prior to calling other param= methods to provide meaningful feedback during
+    # other warnings
+    @name = args[:name] if args.include? :name
+
+    #set the default value for call_hook
+    @call_hook = :on_write_only if args[:hook] and not args[:call_hook]
+    @has_hook = false
+
+    if args[:call_hook] and not args[:hook]
+      #TRANSLATORS ':call_hook' and ':hook' are specific setting names and should not be translated
+      raise ArgumentError, _("Cannot reference :call_hook for :%{name} if no :hook is defined") % { name: @name }
+    end
+
+    args.each do |param, value|
+      method = param.to_s + "="
+      unless self.respond_to? method
+        raise ArgumentError, _("%{class_name} (setting '%{setting}') does not accept %{parameter}") %
+            { class_name: self.class, setting: args[:name], parameter: param }
+      end
+
+      self.send(method, value)
+    end
+    unless self.desc
+      raise ArgumentError, _("You must provide a description for the %{class_name} config option") % { class_name: self.name }
+    end
+  end
+
+  def iscreated
+    @iscreated = true
+  end
+
+  def iscreated?
+    @iscreated
+  end
+
+  # short name for the element
+  def short=(value)
+    raise ArgumentError, _("Short names can only be one character.") if value.to_s.length != 1
+    @short = value.to_s
+  end
+
+  def default(check_application_defaults_first = false)
+    if @default.is_a? Proc
+      # Give unit tests a chance to reevaluate the call by removing the instance variable
+      unless instance_variable_defined?(:@evaluated_default)
+        @evaluated_default = @default.call
+      end
+      default_value = @evaluated_default
+    else
+      default_value = @default
+    end
+    return default_value unless check_application_defaults_first
+    return @settings.value(name, :application_defaults, true) || default_value
+  end
+
+  # Convert the object to a config statement.
+  def to_config
+    require_relative '../../puppet/util/docs'
+    # Scrub any funky indentation; comment out description.
+    str = Puppet::Util::Docs.scrub(@desc).gsub(/^/, "# ") + "\n"
+
+    # Add in a statement about the default.
+    str << "# The default value is '#{default(true)}'.\n" if default(true)
+
+    # If the value has not been overridden, then print it out commented
+    # and unconverted, so it's clear that that's the default and how it
+    # works.
+    value = @settings.value(self.name)
+
+    if value != @default
+      line = "#{@name} = #{value}"
+    else
+      line = "# #{@name} = #{@default}"
+    end
+
+    str << (line + "\n")
+
+    # Indent
+    str.gsub(/^/, "    ")
+  end
+
+  # @param bypass_interpolation [Boolean] Set this true to skip the
+  #   interpolation step, returning the raw setting value.  Defaults to false.
+  # @return [String] Retrieves the value, or if it's not set, retrieves the default.
+  # @api public
+  def value(bypass_interpolation = false)
+    @settings.value(self.name, nil, bypass_interpolation)
+  end
+
+  # Modify the value when it is first evaluated
+  def munge(value)
+    value
+  end
+
+  # Print the value for the user in a config compatible format
+  def print(value)
+    munge(value)
+  end
+
+  def set_meta(meta)
+    Puppet.notice("#{name} does not support meta data. Ignoring.")
+  end
+
+  def deprecated=(deprecation)
+    unless [:completely, :allowed_on_commandline].include?(deprecation)
+      #TRANSLATORS 'deprecated' is a Puppet setting and ':completely' and ':allowed_on_commandline' are possible values and should not be translated
+      raise ArgumentError, _("Unsupported deprecated value '%{deprecation}'.") % { deprecation: deprecation } +
+          ' ' + _("Supported values for deprecated are ':completely' or ':allowed_on_commandline'")
+    end
+    @deprecated = deprecation
+  end
+
+  def deprecated?
+    !!@deprecated
+  end
+
+  # True if we should raise a deprecation_warning if the setting is submitted
+  # on the commandline or is set in puppet.conf.
+  def completely_deprecated?
+    @deprecated == :completely
+  end
+
+  # True if we should raise a deprecation_warning if the setting is found in
+  # puppet.conf, but not if the user sets it on the commandline
+  def allowed_on_commandline?
+    @deprecated == :allowed_on_commandline
+  end
+
+  def inspect
+    %Q{<#{self.class}:#{self.object_id} @name="#{@name}" @section="#{@section}" @default="#{@default}" @call_hook="#{@call_hook}">}
+  end
+end

data/lib/puppet/settings/boolean_setting.rb

@@ -0,0 +1,32 @@
+# A simple boolean.
+class Puppet::Settings::BooleanSetting < Puppet::Settings::BaseSetting
+  # get the arguments in getopt format
+  def getopt_args
+    if short
+      [["--#{name}", "-#{short}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
+    else
+      [["--#{name}", GetoptLong::NO_ARGUMENT], ["--no-#{name}", GetoptLong::NO_ARGUMENT]]
+    end
+  end
+
+  def optparse_args
+    if short
+      ["--[no-]#{name}", "-#{short}", desc, :NONE ]
+    else
+      ["--[no-]#{name}", desc, :NONE]
+    end
+  end
+
+  def munge(value)
+    case value
+    when true, "true"; return true
+    when false, "false"; return false
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid value '%{value}' for boolean parameter: %{name}") % { value: value.inspect, name: @name }
+    end
+  end
+
+  def type
+    :boolean
+  end
+end

data/lib/puppet/settings/certificate_revocation_setting.rb

@@ -0,0 +1,21 @@
+require_relative '../../puppet/settings/base_setting'
+
+class Puppet::Settings::CertificateRevocationSetting < Puppet::Settings::BaseSetting
+
+  def type
+    :certificate_revocation
+  end
+
+  def munge(value)
+    case value
+    when 'chain', 'true', TrueClass
+      :chain
+    when 'leaf'
+      :leaf
+    when 'false', FalseClass, NilClass
+      false
+    else
+      raise Puppet::Settings::ValidationError, _("Invalid certificate revocation value %{value}: must be one of 'true', 'chain', 'leaf', or 'false'") % { value: value }
+    end
+  end
+end