bolt 0.20.0 → 0.20.2

data/vendored/puppet/lib/puppet/confiner.rb

@@ -0,0 +1,46 @@
+require 'puppet/confine_collection'
+
+# The Confiner module contains methods for managing a Provider's confinement (suitability under given
+# conditions). The intent is to include this module in an object where confinement management is wanted.
+# It lazily adds an instance variable `@confine_collection` to the object where it is included.
+#
+module Puppet::Confiner
+  # Confines a provider to be suitable only under the given conditions.
+  # The hash describes a confine using mapping from symbols to values or predicate code.
+  #
+  # * _fact_name_ => value of fact (or array of facts)
+  # * `:exists` => the path to an existing file
+  # * `:true` => a predicate code block returning true
+  # * `:false` => a predicate code block returning false
+  # * `:feature` => name of system feature that must be present
+  # * `:any` => an array of expressions that will be ORed together
+  #
+  # @example
+  #   confine :operatingsystem => [:redhat, :fedora]
+  #   confine :true { ... }
+  #
+  # @param hash [Hash<{Symbol => Object}>] hash of confines
+  # @return [void]
+  # @api public
+  #
+  def confine(hash)
+    confine_collection.confine(hash)
+  end
+
+  # @return [Puppet::ConfineCollection] the collection of confines
+  # @api private
+  #
+  def confine_collection
+    @confine_collection ||= Puppet::ConfineCollection.new(self.to_s)
+  end
+
+  # Checks whether this implementation is suitable for the current platform (or returns a summary
+  # of all confines if short == false).
+  # @return [Boolean. Hash] Returns whether the confines are all valid (if short == true), or a hash of all confines
+  #   if short == false.
+  # @api public
+  #
+  def suitable?(short = true)
+    return(short ? confine_collection.valid? : confine_collection.summary)
+  end
+end

data/vendored/puppet/lib/puppet/context.rb

@@ -0,0 +1,116 @@
+# Puppet::Context is a system for tracking services and contextual information
+# that puppet needs to be able to run. Values are "bound" in a context when it is created
+# and cannot be changed; however a child context can be created, using
+# {#override}, that provides a different value.
+#
+# When binding a {Proc}, the proc is called when the value is looked up, and the result
+# is memoized for subsequent lookups. This provides a lazy mechanism that can be used to
+# delay expensive production of values until they are needed.
+#
+# @api private
+class Puppet::Context
+  require 'puppet/context/trusted_information'
+
+  class UndefinedBindingError < Puppet::Error; end
+  class StackUnderflow < Puppet::Error; end
+
+  class UnknownRollbackMarkError < Puppet::Error; end
+  class DuplicateRollbackMarkError < Puppet::Error; end
+
+  # @api private
+  def initialize(initial_bindings)
+    @table = initial_bindings
+    @ignores = []
+    @description = "root"
+    @id = 0
+    @rollbacks = {}
+    @stack = [[0, nil, nil]]
+  end
+
+  # @api private
+  def push(overrides, description = "")
+    @id += 1
+    @stack.push([@id, @table, @description])
+    @table = @table.merge(overrides || {})
+    @description = description
+  end
+
+  # @api private
+  def pop
+    if @stack[-1][0] == 0
+      raise(StackUnderflow, _("Attempted to pop, but already at root of the context stack."))
+    else
+      (_, @table, @description) = @stack.pop
+    end
+  end
+
+  # @api private
+  def lookup(name, &block)
+    if @table.include?(name) && !@ignores.include?(name)
+      value = @table[name]
+      value.is_a?(Proc) ? (@table[name] = value.call) : value
+    elsif block
+      block.call
+    else
+      raise UndefinedBindingError, _("no '%{name}' in %{table} at top of %{stack}") % { name: name, table: @table.inspect, stack: @stack.inspect }
+    end
+  end
+
+  # @api private
+  def override(bindings, description = "", &block)
+    mark_point = "override over #{@stack[-1][0]}"
+    mark(mark_point)
+    push(bindings, description)
+
+    yield
+  ensure
+    rollback(mark_point)
+  end
+
+  # @api private
+  def ignore(name)
+    @ignores << name
+  end
+
+  # @api private
+  def restore(name)
+    if @ignores.include?(name)
+      @ignores.delete(name)
+    else
+      raise UndefinedBindingError, _("no '%{name}' in ignores %{ignores} at top of %{stack}") % { name: name, ignores: @ignores.inspect, stack: @stack.inspect }
+    end
+  end
+
+  # Mark a place on the context stack to later return to with {rollback}.
+  #
+  # @param name [Object] The identifier for the mark
+  #
+  # @api private
+  def mark(name)
+    if @rollbacks[name].nil?
+      @rollbacks[name] = @stack[-1][0]
+    else
+      raise DuplicateRollbackMarkError, _("Mark for '%{name}' already exists") % { name: name }
+    end
+  end
+
+  # Roll back to a mark set by {mark}.
+  #
+  # Rollbacks can only reach a mark accessible via {pop}. If the mark is not on
+  # the current context stack the behavior of rollback is undefined.
+  #
+  # @param name [Object] The identifier for the mark
+  #
+  # @api private
+  def rollback(name)
+    if @rollbacks[name].nil?
+      raise UnknownRollbackMarkError, _("Unknown mark '%{name}'") % { name: name }
+    end
+
+    while @stack[-1][0] != @rollbacks[name]
+      pop
+    end
+
+    @rollbacks.delete(name)
+  end
+end

data/vendored/puppet/lib/puppet/context/trusted_information.rb

@@ -0,0 +1,76 @@
+# @api private
+class Puppet::Context::TrustedInformation
+  # one of 'remote', 'local', or false, where 'remote' is authenticated via cert,
+  # 'local' is trusted by virtue of running on the same machine (not a remote
+  # request), and false is an unauthenticated remote request.
+  #
+  # @return [String, Boolean]
+  attr_reader :authenticated
+
+  # The validated certificate name used for the request
+  #
+  # @return [String]
+  attr_reader :certname
+
+  # Extra information that comes from the trusted certificate's extensions.
+  #
+  # @return [Hash{Object => Object}]
+  attr_reader :extensions
+
+  # The domain name derived from the validated certificate name
+  #
+  # @return [String]
+  attr_reader :domain
+
+  # The hostname derived from the validated certificate name
+  #
+  # @return [String]
+  attr_reader :hostname
+
+  def initialize(authenticated, certname, extensions)
+    @authenticated = authenticated.freeze
+    @certname = certname.freeze
+    @extensions = extensions.freeze
+    if @certname
+      hostname, domain = @certname.split('.', 2)
+    else
+      hostname = nil
+      domain = nil
+    end
+    @hostname = hostname.freeze
+    @domain = domain.freeze
+  end
+
+  def self.remote(authenticated, node_name, certificate)
+    if authenticated
+      extensions = {}
+      if certificate.nil?
+        Puppet.info(_('TrustedInformation expected a certificate, but none was given.'))
+      else
+        extensions = Hash[certificate.custom_extensions.collect do |ext|
+          [ext['oid'].freeze, ext['value'].freeze]
+        end]
+      end
+      new('remote', node_name, extensions)
+    else
+      new(false, nil, {})
+    end
+  end
+
+  def self.local(node)
+    # Always trust local data by picking up the available parameters.
+    client_cert = node ? node.parameters['clientcert'] : nil
+
+    new('local', client_cert, {})
+  end
+
+  def to_h
+    {
+      'authenticated'.freeze => authenticated,
+      'certname'.freeze => certname,
+      'extensions'.freeze => extensions,
+      'hostname'.freeze => hostname,
+      'domain'.freeze => domain,
+    }.freeze
+  end
+end

data/vendored/puppet/lib/puppet/daemon.rb

@@ -0,0 +1,195 @@
+require 'puppet/application'
+require 'puppet/scheduler'
+
+# Run periodic actions and a network server in a daemonized process.
+#
+# A Daemon has 3 parts:
+#   * config reparse
+#   * (optional) an agent that responds to #run
+#   * (optional) a server that response to #stop, #start, and #wait_for_shutdown
+#
+# The config reparse will occur periodically based on Settings. The server will
+# be started and is expected to manage its own run loop (and so not block the
+# start call). The server will, however, still be waited for by using the
+# #wait_for_shutdown method. The agent is run periodically and a time interval
+# based on Settings. The config reparse will update this time interval when
+# needed.
+#
+# The Daemon is also responsible for signal handling, starting, stopping,
+# running the agent on demand, and reloading the entire process. It ensures
+# that only one Daemon is running by using a lockfile.
+#
+# @api private
+class Puppet::Daemon
+  SIGNAL_CHECK_INTERVAL = 5
+
+  attr_accessor :agent, :server, :argv
+  attr_reader :signals
+
+  def initialize(pidfile, scheduler = Puppet::Scheduler::Scheduler.new())
+    @scheduler = scheduler
+    @pidfile = pidfile
+    @signals = []
+  end
+
+  def daemonname
+    Puppet.run_mode.name
+  end
+
+  # Put the daemon into the background.
+  def daemonize
+    if pid = fork
+      Process.detach(pid)
+      exit(0)
+    end
+
+    create_pidfile
+
+    # Get rid of console logging
+    Puppet::Util::Log.close(:console)
+
+    Process.setsid
+    Dir.chdir("/")
+
+    close_streams
+  end
+
+  # Close stdin/stdout/stderr so that we can finish our transition into 'daemon' mode.
+  # @return nil
+  def self.close_streams()
+    Puppet.debug("Closing streams for daemon mode")
+    begin
+      $stdin.reopen "/dev/null"
+      $stdout.reopen "/dev/null", "a"
+      $stderr.reopen $stdout
+      Puppet::Util::Log.reopen
+      Puppet.debug("Finished closing streams for daemon mode")
+    rescue => detail
+      Puppet.err "Could not start #{Puppet.run_mode.name}: #{detail}"
+      Puppet::Util::replace_file("/tmp/daemonout", 0644) do |f|
+        f.puts "Could not start #{Puppet.run_mode.name}: #{detail}"
+      end
+      exit(12)
+    end
+  end
+
+  # Convenience signature for calling Puppet::Daemon.close_streams
+  def close_streams()
+    Puppet::Daemon.close_streams
+  end
+
+  def reexec
+    raise Puppet::DevError, _("Cannot reexec unless ARGV arguments are set") unless argv
+    command = $0 + " " + argv.join(" ")
+    Puppet.notice "Restarting with '#{command}'"
+    stop(:exit => false)
+    exec(command)
+  end
+
+  def reload
+    return unless agent
+    agent.run({:splay => false})
+  rescue Puppet::LockError
+    Puppet.notice "Not triggering already-running agent"
+  end
+
+  def restart
+    Puppet::Application.restart!
+    reexec unless agent and agent.running?
+  end
+
+  def reopen_logs
+    Puppet::Util::Log.reopen
+  end
+
+  # Trap a couple of the main signals.  This should probably be handled
+  # in a way that anyone else can register callbacks for traps, but, eh.
+  def set_signal_traps
+    [:INT, :TERM].each do |signal|
+      Signal.trap(signal) do
+        Puppet.notice "Caught #{signal}; exiting"
+        stop
+      end
+    end
+
+    # extended signals not supported under windows
+    if !Puppet.features.microsoft_windows?
+      signals = {:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }
+      signals.each do |signal, method|
+        Signal.trap(signal) do
+          Puppet.notice "Caught #{signal}; storing #{method}"
+          @signals << method
+        end
+      end
+    end
+  end
+
+  # Stop everything
+  def stop(args = {:exit => true})
+    Puppet::Application.stop!
+
+    server.stop if server
+
+    remove_pidfile
+
+    Puppet::Util::Log.close_all
+
+    exit if args[:exit]
+  end
+
+  def start
+    create_pidfile
+
+    raise Puppet::DevError, _("Daemons must have an agent, server, or both") unless agent or server
+
+    # Start the listening server, if required.
+    server.start if server
+
+    # Finally, loop forever running events - or, at least, until we exit.
+    run_event_loop
+
+    server.wait_for_shutdown if server
+  end
+
+  private
+
+  # Create a pidfile for our daemon, so we can be stopped and others
+  # don't try to start.
+  def create_pidfile
+    raise "Could not create PID file: #{@pidfile.file_path}" unless @pidfile.lock
+  end
+
+  # Remove the pid file for our daemon.
+  def remove_pidfile
+    @pidfile.unlock
+  end
+
+  def run_event_loop
+    agent_run = Puppet::Scheduler.create_job(Puppet[:runinterval], Puppet[:splay], Puppet[:splaylimit]) do
+      # Splay for the daemon is handled in the scheduler
+      agent.run(:splay => false)
+    end
+
+    reparse_run = Puppet::Scheduler.create_job(Puppet[:filetimeout]) do
+      Puppet.settings.reparse_config_files
+      agent_run.run_interval = Puppet[:runinterval]
+      if Puppet[:filetimeout] == 0
+        reparse_run.disable
+      else
+        reparse_run.run_interval = Puppet[:filetimeout]
+      end
+    end
+
+    signal_loop = Puppet::Scheduler.create_job(SIGNAL_CHECK_INTERVAL) do
+      while method = @signals.shift
+        Puppet.notice "Processing #{method}"
+        send(method)
+      end
+    end
+
+    reparse_run.disable if Puppet[:filetimeout] == 0
+    agent_run.disable unless agent
+
+    @scheduler.run_loop([reparse_run, agent_run, signal_loop])
+  end
+end

data/vendored/puppet/lib/puppet/data_binding.rb

@@ -0,0 +1,14 @@
+require 'puppet/indirector'
+
+# A class for managing data lookups
+class Puppet::DataBinding
+  # Set up indirection, so that data can be looked for in the compiler
+  extend Puppet::Indirector
+
+  indirects(:data_binding, :terminus_setting => :data_binding_terminus,
+    :doc => "Where to find external data bindings.")
+
+  class LookupError < Puppet::PreformattedError; end
+
+  class RecursiveLookupError < Puppet::DataBinding::LookupError; end
+end