bolt 0.24.0 → 0.25.0

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

@@ -1,9 +0,0 @@
-require 'puppet/util/tagging'
-
-class Puppet::Util::SkipTags
-  include Puppet::Util::Tagging
-
-  def initialize(stags)
-    self.tags = stags unless defined?(@tags)
-  end
-end

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

@@ -1,18 +0,0 @@
-# Handle splay options (sleeping for a random interval before executing)
-module Puppet::Util::Splayer
-  # Have we splayed already?
-  def splayed?
-    !!@splayed
-  end
-
-  # Sleep when splay is enabled; else just return.
-  def splay(do_splay = Puppet[:splay])
-    return unless do_splay
-    return if splayed?
-
-    time = rand(Puppet[:splaylimit] + 1)
-    Puppet.info _("Sleeping for %{time} seconds (splay is enabled)") % { time: time }
-    sleep(time)
-    @splayed = true
-  end
-end

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

@@ -1,92 +0,0 @@
-require 'openssl'
-
-##
-# SSL is a private module with class methods that help work with x.509
-# subjects and errors.
-#
-# @api private
-module Puppet::Util::SSL
-
-  @@dn_parsers = nil
-  @@no_name = nil
-
-  # Given a DN string, parse it into an OpenSSL certificate subject.  This
-  # method will flexibly handle both OpenSSL and RFC2253 formats, as given by
-  # nginx and Apache, respectively.
-  #
-  # @param [String] dn the x.509 Distinguished Name (DN) string.
-  #
-  # @return [OpenSSL::X509::Name] the certificate subject
-  def self.subject_from_dn(dn)
-    if is_possibly_valid_dn?(dn)
-      parsers = @@dn_parsers ||= [
-            OpenSSL::X509::Name.method(:parse_rfc2253),
-            OpenSSL::X509::Name.method(:parse_openssl)
-        ]
-      parsers.each do |parser|
-        begin
-          return parser.call(dn)
-        rescue OpenSSL::X509::NameError
-        end
-      end
-    end
-
-    @@no_name ||= OpenSSL::X509::Name.new
-  end
-
-  ##
-  # cn_from_subject extracts the CN from the given OpenSSL certificate
-  # subject.
-  #
-  # @api private
-  #
-  # @param [OpenSSL::X509::Name] subject the subject to extract the CN field from
-  #
-  # @return [String, nil] the CN, or nil if not found
-  def self.cn_from_subject(subject)
-    if subject.respond_to? :to_a
-      (subject.to_a.assoc('CN') || [])[1]
-    end
-  end
-
-  def self.is_possibly_valid_dn?(dn)
-    dn =~ /=/
-  end
-
-  ##
-  # Extract and format meaningful error messages from OpenSSL::OpenSSLErrors
-  # and a Validator. Re-raises the error if unknown.
-  #
-  # @api private
-  #
-  # @param [OpenSSL::OpenSSLError] error An error thrown during creating a
-  #   connection
-  # @param [Puppet::SSL::DefaultValidator] verifier A Validator who may have
-  #   invalidated the connection
-  # @param [String] host The DNS name of the other end of the SSL connection
-  #
-  # @raises [Puppet::Error, OpenSSL::OpenSSLError]
-  def self.handle_connection_error(error, verifier, host)
-    # can be nil
-    peer_cert = verifier.peer_certs.last
-
-    if error.message.include? "certificate verify failed"
-      msg = error.message
-      msg << ": [" + verifier.verify_errors.join('; ') + "]"
-      raise Puppet::Error, msg, error.backtrace
-    elsif peer_cert && !OpenSSL::SSL.verify_certificate_identity(peer_cert, host)
-      valid_certnames = [peer_cert.subject.to_s.sub(/.*=/, ''),
-                         *Puppet::SSL::Certificate.subject_alt_names_for(peer_cert)].uniq
-      if valid_certnames.size > 1
-        expected_certnames = _("expected one of %{certnames}") % { certnames: valid_certnames.join(', ') }
-      else
-        expected_certnames = _("expected %{certname}") % { certname: valid_certnames.first }
-      end
-
-      msg = _("Server hostname '%{host}' did not match server certificate; %{expected_certnames}") % { host: host, expected_certnames: expected_certnames }
-      raise Puppet::Error, msg, error.backtrace
-    else
-      raise error
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-require 'yaml'
-require 'sync'
-require 'singleton'
-require 'puppet/util/yaml'
-
-# a class for storing state
-class Puppet::Util::Storage
-  include Singleton
-  include Puppet::Util
-
-  def self.state
-    @@state
-  end
-
-  def initialize
-    self.class.load
-  end
-
-  # Return a hash that will be stored to disk.  It's worth noting
-  # here that we use the object's full path, not just the name/type
-  # combination.  At the least, this is useful for those non-isomorphic
-  # types like exec, but it also means that if an object changes locations
-  # in the configuration it will lose its cache.
-  def self.cache(object)
-    if object.is_a?(Symbol)
-      name = object
-    else
-      name = object.to_s
-    end
-
-    @@state[name] ||= {}
-  end
-
-  def self.clear
-    @@state.clear
-  end
-
-  def self.init
-    @@state = {}
-  end
-
-  self.init
-
-  def self.load
-    Puppet.settings.use(:main) unless FileTest.directory?(Puppet[:statedir])
-    filename = Puppet[:statefile]
-
-    unless Puppet::FileSystem.exist?(filename)
-      self.init if @@state.nil?
-      return
-    end
-    unless File.file?(filename)
-      Puppet.warning(_("Checksumfile %{filename} is not a file, ignoring") % { filename: filename })
-      return
-    end
-    Puppet::Util.benchmark(:debug, "Loaded state in %{seconds} seconds") do
-      begin
-        @@state = Puppet::Util::Yaml.safe_load_file(filename, [Symbol, Time])
-      rescue Puppet::Util::Yaml::YamlLoadError => detail
-        Puppet.err _("Checksumfile %{filename} is corrupt (%{detail}); replacing") % { filename: filename, detail: detail }
-
-        begin
-          File.rename(filename, filename + ".bad")
-        rescue
-          raise Puppet::Error, _("Could not rename corrupt %{filename}; remove manually") % { filename: filename }, detail.backtrace
-        end
-      end
-    end
-
-    unless @@state.is_a?(Hash)
-      Puppet.err _("State got corrupted")
-      self.init
-    end
-  end
-
-  def self.stateinspect
-    @@state.inspect
-  end
-
-  def self.store
-    Puppet.debug "Storing state"
-
-    Puppet.info _("Creating state file %{file}") % { file: Puppet[:statefile] } unless Puppet::FileSystem.exist?(Puppet[:statefile])
-
-    Puppet::Util.benchmark(:debug, "Stored state in %{seconds} seconds") do
-      Puppet::Util::Yaml.dump(@@state, Puppet[:statefile])
-    end
-  end
-end

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

@@ -1,167 +0,0 @@
-require 'facter'
-require 'puppet/util/warnings'
-require 'forwardable'
-require 'etc'
-
-module Puppet::Util::SUIDManager
-  include Puppet::Util::Warnings
-  extend Forwardable
-
-  # Note groups= is handled specially due to a bug in OS X 10.6, 10.7,
-  # and probably upcoming releases...
-  to_delegate_to_process = [ :euid=, :euid, :egid=, :egid, :uid=, :uid, :gid=, :gid, :groups ]
-
-  to_delegate_to_process.each do |method|
-    def_delegator Process, method
-    module_function method
-  end
-
-  def osx_maj_ver
-    return @osx_maj_ver unless @osx_maj_ver.nil?
-    @osx_maj_ver = Facter.value('macosx_productversion_major') || false
-  end
-  module_function :osx_maj_ver
-
-  def groups=(grouplist)
-    begin
-      return Process.groups = grouplist
-    rescue Errno::EINVAL => e
-      #We catch Errno::EINVAL as some operating systems (OS X in particular) can
-      # cause troubles when using Process#groups= to change *this* user / process
-      # list of supplementary groups membership.  This is done via Ruby's function
-      # "static VALUE proc_setgroups(VALUE obj, VALUE ary)" which is effectively
-      # a wrapper for "int setgroups(size_t size, const gid_t *list)" (part of SVr4
-      # and 4.3BSD but not in POSIX.1-2001) that fails and sets errno to EINVAL.
-      #
-      # This does not appear to be a problem with Ruby but rather an issue on the
-      # operating system side.  Therefore we catch the exception and look whether
-      # we run under OS X or not -- if so, then we acknowledge the problem and
-      # re-throw the exception otherwise.
-      if osx_maj_ver and not osx_maj_ver.empty?
-        return true
-      else
-        raise e
-      end
-    end
-  end
-  module_function :groups=
-
-  def self.root?
-    if Puppet::Util::Platform.windows?
-      require 'puppet/util/windows/user'
-      Puppet::Util::Windows::User.admin?
-    else
-      Process.uid == 0
-    end
-  end
-
-  # Methods to handle changing uid/gid of the running process. In general,
-  # these will noop or fail on Windows, and require root to change to anything
-  # but the current uid/gid (which is a noop).
-
-  # Runs block setting euid and egid if provided then restoring original ids.
-  # If running on Windows or without root, the block will be run with the
-  # current euid/egid.
-  def asuser(new_uid=nil, new_gid=nil)
-    return yield if Puppet::Util::Platform.windows?
-    return yield unless root?
-    return yield unless new_uid or new_gid
-
-    old_euid, old_egid = self.euid, self.egid
-    begin
-      change_privileges(new_uid, new_gid, false)
-
-      yield
-    ensure
-      change_privileges(new_uid ? old_euid : nil, old_egid, false)
-    end
-  end
-  module_function :asuser
-
-  # If `permanently` is set, will permanently change the uid/gid of the
-  # process. If not, it will only set the euid/egid. If only uid is supplied,
-  # the primary group of the supplied gid will be used. If only gid is
-  # supplied, only gid will be changed. This method will fail if used on
-  # Windows.
-  def change_privileges(uid=nil, gid=nil, permanently=false)
-    return unless uid or gid
-
-    unless gid
-      uid = convert_xid(:uid, uid)
-      gid = Etc.getpwuid(uid).gid
-    end
-
-    change_group(gid, permanently)
-    change_user(uid, permanently) if uid
-  end
-  module_function :change_privileges
-
-  # Changes the egid of the process if `permanently` is not set, otherwise
-  # changes gid. This method will fail if used on Windows, or attempting to
-  # change to a different gid without root.
-  def change_group(group, permanently=false)
-    gid = convert_xid(:gid, group)
-    raise Puppet::Error, _("No such group %{group}") % { group: group } unless gid
-
-    return if Process.egid == gid
-
-    if permanently
-      Process::GID.change_privilege(gid)
-    else
-      Process.egid = gid
-    end
-  end
-  module_function :change_group
-
-  # As change_group, but operates on uids. If changing user permanently,
-  # supplementary groups will be set the to default groups for the new uid.
-  def change_user(user, permanently=false)
-    uid = convert_xid(:uid, user)
-    raise Puppet::Error, _("No such user %{user}") % { user: user } unless uid
-
-    return if Process.euid == uid
-
-    if permanently
-      # If changing uid, we must be root. So initgroups first here.
-      initgroups(uid)
-
-      Process::UID.change_privilege(uid)
-    else
-      # We must be root to initgroups, so initgroups before dropping euid if
-      # we're root, otherwise elevate euid before initgroups.
-      # change euid (to root) first.
-      if Process.euid == 0
-        initgroups(uid)
-        Process.euid = uid
-      else
-        Process.euid = uid
-        initgroups(uid)
-      end
-    end
-  end
-  module_function :change_user
-
-  # Make sure the passed argument is a number.
-  def convert_xid(type, id)
-    return id if id.kind_of? Integer
-    map = {:gid => :group, :uid => :user}
-    raise ArgumentError, _("Invalid id type %{type}") % { type: type } unless map.include?(type)
-    ret = Puppet::Util.send(type, id)
-    if ret == nil
-      raise Puppet::Error, _("Invalid %{klass}: %{id}") % { klass: map[type], id: id }
-    end
-    ret
-  end
-  module_function :convert_xid
-
-  # Initialize primary and supplemental groups to those of the target user.  We
-  # take the UID and manually look up their details in the system database,
-  # including username and primary group. This method will fail on Windows, or
-  # if used without root to initgroups of another user.
-  def initgroups(uid)
-    pwent = Etc.getpwuid(uid)
-    Process.initgroups(pwent.name, pwent.gid)
-  end
-
-  module_function :initgroups
-end

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

@@ -1,144 +0,0 @@
-require 'puppet/util'
-
-module Puppet
-module Util
-module SymbolicFileMode
-  SetUIDBit = ReadBit  = 4
-  SetGIDBit = WriteBit = 2
-  StickyBit = ExecBit  = 1
-  SymbolicMode = { 'x' => ExecBit, 'w' => WriteBit, 'r' => ReadBit }
-  SymbolicSpecialToBit = {
-    't' => { 'u' => StickyBit, 'g' => StickyBit, 'o' => StickyBit },
-    's' => { 'u' => SetUIDBit, 'g' => SetGIDBit, 'o' => StickyBit }
-  }
-
-  def valid_symbolic_mode?(value)
-    value = normalize_symbolic_mode(value)
-    return true if value =~ /^0?[0-7]{1,4}$/
-    return true if value =~ /^([ugoa]*[-=+][-=+rstwxXugo]*)(,[ugoa]*[-=+][-=+rstwxXugo]*)*$/
-    return false
-  end
-
-  def normalize_symbolic_mode(value)
-    return nil if value.nil?
-
-    # We need to treat integers as octal numbers.
-    if value.is_a? Numeric then
-      return value.to_s(8)
-    elsif value =~ /^0?[0-7]{1,4}$/ then
-      return value.to_i(8).to_s(8)
-    else
-      return value
-    end
-  end
-
-  def symbolic_mode_to_int(modification, to_mode = 0, is_a_directory = false)
-    if modification.nil? or modification == '' then
-      raise Puppet::Error, _("An empty mode string is illegal")
-    end
-    if modification =~ /^[0-7]+$/ then return modification.to_i(8) end
-    if modification =~ /^\d+$/ then
-      raise Puppet::Error, _("Numeric modes must be in octal, not decimal!")
-    end
-
-    fail _("non-numeric current mode (%{mode})") % { mode: to_mode.inspect } unless to_mode.is_a?(Numeric)
-
-    original_mode = {
-      's' => (to_mode & 07000) >> 9,
-      'u' => (to_mode & 00700) >> 6,
-      'g' => (to_mode & 00070) >> 3,
-      'o' => (to_mode & 00007) >> 0,
-      # Are there any execute bits set in the original mode?
-      'any x?' => (to_mode & 00111) != 0
-    }
-    final_mode = {
-      's' => original_mode['s'],
-      'u' => original_mode['u'],
-      'g' => original_mode['g'],
-      'o' => original_mode['o'],
-    }
-
-    modification.split(/\s*,\s*/).each do |part|
-      begin
-        _, to, dsl = /^([ugoa]*)([-+=].*)$/.match(part).to_a
-        if dsl.nil? then raise Puppet::Error, _('Missing action') end
-        to = "a" unless to and to.length > 0
-
-        # We want a snapshot of the mode before we start messing with it to
-        # make actions like 'a-g' atomic.  Various parts of the DSL refer to
-        # the original mode, the final mode, or the current snapshot of the
-        # mode, for added fun.
-        snapshot_mode = {}
-        final_mode.each {|k,v| snapshot_mode[k] = v }
-
-        to.gsub('a', 'ugo').split('').uniq.each do |who|
-          value = snapshot_mode[who]
-
-          action = '!'
-          actions = {
-            '!' => lambda {|_,_| raise Puppet::Error, _('Missing operation (-, =, or +)') },
-            '=' => lambda {|m,v| m | v },
-            '+' => lambda {|m,v| m | v },
-            '-' => lambda {|m,v| m & ~v },
-          }
-
-          dsl.split('').each do |op|
-            case op
-            when /[-+=]/ then
-              action = op
-              # Clear all bits, if this is assignment
-              value  = 0 if op == '='
-
-            when /[ugo]/ then
-              value = actions[action].call(value, snapshot_mode[op])
-
-            when /[rwx]/ then
-              value = actions[action].call(value, SymbolicMode[op])
-
-            when 'X' then
-              # Only meaningful in combination with "set" actions.
-              if action != '+' then
-                raise Puppet::Error, _("X only works with the '+' operator")
-              end
-
-              # As per the BSD manual page, set if this is a directory, or if
-              # any execute bit is set on the original (unmodified) mode.
-              # Ignored otherwise; it is "add if", not "add or clear".
-              if is_a_directory or original_mode['any x?'] then
-                value = actions[action].call(value, ExecBit)
-              end
-
-            when /[st]/ then
-              bit = SymbolicSpecialToBit[op][who] or fail _("internal error")
-              final_mode['s'] = actions[action].call(final_mode['s'], bit)
-
-            else
-              raise Puppet::Error, _('Unknown operation')
-            end
-          end
-
-          # Now, assign back the value.
-          final_mode[who] = value
-        end
-
-      rescue Puppet::Error => e
-        if part.inspect != modification.inspect then
-          rest = " at #{part.inspect}"
-        else
-          rest = ''
-        end
-
-        raise Puppet::Error, _("%{error}%{rest} in symbolic mode %{modification}") % { error: e, rest: rest, modification: modification.inspect }, e.backtrace
-      end
-    end
-
-    result =
-      final_mode['s'] << 9 |
-      final_mode['u'] << 6 |
-      final_mode['g'] << 3 |
-      final_mode['o'] << 0
-    return result
-  end
-end
-end
-end