bolt 0.19.1 → 0.20.0

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

@@ -1,46 +0,0 @@
-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

@@ -1,116 +0,0 @@
-# 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

@@ -1,76 +0,0 @@
-# @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

@@ -1,195 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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