bolt 0.24.0 → 0.25.0

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

@@ -1,61 +0,0 @@
-require 'puppet/util/autoload'
-require 'puppet/util'
-
-# A module that can easily autoload things for us.  Uses an instance
-# of Puppet::Util::Autoload
-module Puppet::Util::InstanceLoader
-  include Puppet::Util
-
-  # Are we instance-loading this type?
-  def instance_loading?(type)
-    defined?(@autoloaders) and @autoloaders.include?(type.intern)
-  end
-
-  # Define a new type of autoloading.
-  def instance_load(type, path)
-    @autoloaders ||= {}
-    @instances ||= {}
-    type = type.intern
-    @instances[type] = {}
-    @autoloaders[type] = Puppet::Util::Autoload.new(self, path)
-
-    # Now define our new simple methods
-    unless respond_to?(type)
-      meta_def(type) do |name|
-        loaded_instance(type, name)
-      end
-    end
-  end
-
-  # Return a list of the names of all instances
-  def loaded_instances(type)
-    @instances[type].keys
-  end
-
-  # Return the instance hash for our type.
-  def instance_hash(type)
-    @instances[type.intern]
-  end
-
-  # Return the Autoload object for a given type.
-  def instance_loader(type)
-    @autoloaders[type.intern]
-  end
-
-  # Retrieve an already-loaded instance, or attempt to load our instance.
-  def loaded_instance(type, name)
-    name = name.intern
-    return nil unless instances = instance_hash(type)
-    unless instances.include? name
-      if instance_loader(type).load(name, Puppet.lookup(:current_environment))
-        unless instances.include? name
-          Puppet.warning(_("Loaded %{type} file for %{name} but %{type} was not defined") % { type: type, name: name })
-          return nil
-        end
-      else
-        return nil
-      end
-    end
-    instances[name]
-  end
-end

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

@@ -1,69 +0,0 @@
-module Puppet::Util
-  module Json
-    class ParseError < StandardError
-      attr_reader :cause, :data
-
-      def self.build(original_exception, data)
-        new(original_exception.message).tap do |exception|
-          exception.instance_eval do
-            @cause = original_exception
-            set_backtrace original_exception.backtrace
-            @data = data
-          end
-        end
-      end
-    end
-
-    begin
-      require 'multi_json'
-      # Force backend detection before attempting to use the library
-      # or load any other JSON libraries
-      MultiJson.default_adapter
-
-      # Preserve core type monkey-patching done by the built-in JSON gem
-      require 'json'
-    rescue LoadError
-      require 'json'
-    end
-
-    # These methods do similar processing to the fallback implemented by MultiJson
-    # when using the built-in JSON backend, to ensure consistent behavior
-    # whether or not MultiJson can be loaded.
-    def self.load(string, options = {})
-      if defined? MultiJson
-        begin
-          # This ensures that JrJackson will parse very large or very small
-          # numbers as floats rather than BigDecimals, which are serialized as
-          # strings by the built-in JSON gem and therefore can cause schema errors,
-          # for example, when we are rendering reports to JSON using `to_pson` in
-          # PuppetDB.
-          if MultiJson.adapter.name == "MultiJson::Adapters::JrJackson"
-            options[:use_bigdecimal] = false
-          end
-
-          MultiJson.load(string, options)
-        rescue MultiJson::ParseError => e
-          raise Puppet::Util::Json::ParseError.build(e, string)
-        end
-      else
-        begin
-          string = string.read if string.respond_to?(:read)
-
-          options[:symbolize_names] = true if options.delete(:symbolize_keys)
-          ::JSON.parse(string, options)
-        rescue JSON::ParserError => e
-          raise Puppet::Util::Json::ParseError.build(e, string)
-        end
-      end
-    end
-
-    def self.dump(object, options = {})
-      if defined? MultiJson
-        MultiJson.dump(object, options)
-      else
-        options.merge!(::JSON::PRETTY_STATE_PROTOTYPE.to_h) if options.delete(:pretty)
-        object.to_json(options)
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-require 'puppet/util/lockfile'
-
-# This class provides a simple API for managing a lock file
-# whose contents are a serialized JSON object.  In addition
-# to querying the basic state (#locked?) of the lock, managing
-# the lock (#lock, #unlock), the contents can be retrieved at
-# any time while the lock is held (#lock_data).  This can be
-# used to store structured data (state messages, etc.) about
-# the lock.
-#
-# @see Puppet::Util::Lockfile
-class Puppet::Util::JsonLockfile < Puppet::Util::Lockfile
-  # Lock the lockfile.  You may optionally pass a data object, which will be
-  # retrievable for the duration of time during which the file is locked.
-  #
-  # @param [Hash] lock_data an optional Hash of data to associate with the lock.
-  #   This may be used to store pids, descriptive messages, etc.  The
-  #   data may be retrieved at any time while the lock is held by
-  #   calling the #lock_data method. <b>NOTE</b> that the JSON serialization
-  #   does NOT support Symbol objects--if you pass them in, they will be
-  #   serialized as Strings, so you should plan accordingly.
-  # @return [boolean] true if lock is successfully acquired, false otherwise.
-  def lock(lock_data = nil)
-    return false if locked?
-
-    super(Puppet::Util::Json.dump(lock_data))
-  end
-
-  # Retrieve the (optional) lock data that was specified at the time the file
-  #  was locked.
-  # @return [Object] the data object.  Remember that the serialization does not
-  #  support Symbol objects, so if your data Object originally contained symbols,
-  #  they will be converted to Strings.
-  def lock_data
-    return nil unless file_locked?
-    file_contents = super
-    return nil if file_contents.nil? or file_contents.empty?
-    Puppet::Util::Json.load(file_contents)
-  rescue Puppet::Util::Json::ParseError
-    Puppet.warning _("Unable to read lockfile data from %{path}: not in JSON") % { path: @file_path }
-    nil
-  end
-
-end

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

@@ -1,2 +0,0 @@
-module Puppet::Util::Ldap
-end

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

@@ -1,71 +0,0 @@
-require 'puppet/util/ldap'
-
-class Puppet::Util::Ldap::Connection
-  attr_accessor :host, :port, :user, :password, :reset, :ssl
-
-  attr_reader :connection
-
-  # Return a default connection, using our default settings.
-  def self.instance
-    ssl = if Puppet[:ldaptls]
-      :tls
-        elsif Puppet[:ldapssl]
-          true
-        else
-          false
-        end
-
-    options = {}
-    options[:ssl] = ssl
-    if user = Puppet.settings[:ldapuser] and user != ""
-      options[:user] = user
-      if pass = Puppet.settings[:ldappassword] and pass != ""
-        options[:password] = pass
-      end
-    end
-
-    new(Puppet[:ldapserver], Puppet[:ldapport], options)
-  end
-
-  def close
-    connection.unbind if connection.bound?
-  end
-
-  def initialize(host, port, user: nil, password: nil, reset: nil, ssl: nil)
-    raise Puppet::Error, _("Could not set up LDAP Connection: Missing ruby/ldap libraries") unless Puppet.features.ldap?
-
-    @host = host
-    @port = port
-    @user = user
-    @password = password
-    @reset = reset
-    @ssl = ssl
-  end
-
-  # Create a per-connection unique name.
-  def name
-    [host, port, user, password, ssl].collect { |p| p.to_s }.join("/")
-  end
-
-  # Should we reset the connection?
-  def reset?
-    reset
-  end
-
-  # Start our ldap connection.
-  def start
-      case ssl
-      when :tls
-        @connection = LDAP::SSLConn.new(host, port, true)
-      when true
-        @connection = LDAP::SSLConn.new(host, port)
-      else
-        @connection = LDAP::Conn.new(host, port)
-      end
-      @connection.set_option(LDAP::LDAP_OPT_PROTOCOL_VERSION, 3)
-      @connection.set_option(LDAP::LDAP_OPT_REFERRALS, LDAP::LDAP_OPT_ON)
-      @connection.simple_bind(user, password)
-  rescue => detail
-      raise Puppet::Error, _("Could not connect to LDAP: %{detail}") % { detail: detail }, detail.backtrace
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'puppet/util/ldap'
-
-class Puppet::Util::Ldap::Generator
-  # Declare the attribute we'll use to generate the value.
-  def from(source)
-    @source = source
-    self
-  end
-
-  # Actually do the generation.
-  def generate(value = nil)
-    if value.nil?
-      @generator.call
-    else
-      @generator.call(value)
-    end
-  end
-
-  # Initialize our generator with the name of the parameter
-  # being generated.
-  def initialize(name)
-    @name = name
-  end
-
-  def name
-    @name.to_s
-  end
-
-  def source
-    if @source
-      @source.to_s
-    else
-      nil
-    end
-  end
-
-  # Provide the code that does the generation.
-  def with(&block)
-    @generator = block
-    self
-  end
-end

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

@@ -1,281 +0,0 @@
-require 'puppet/util/ldap'
-require 'puppet/util/ldap/connection'
-require 'puppet/util/ldap/generator'
-
-# The configuration class for LDAP providers, plus
-# connection handling for actually interacting with ldap.
-class Puppet::Util::Ldap::Manager
-  attr_reader :objectclasses, :puppet2ldap, :location, :rdn
-
-  # A null-op that just returns the config.
-  def and
-    self
-  end
-
-  # Set the offset from the search base and return the config.
-  def at(location)
-    @location = location
-    self
-  end
-
-  # The basic search base.
-  def base
-    [location, Puppet[:ldapbase]].join(",")
-  end
-
-  # Convert the name to a dn, then pass the args along to
-  # our connection.
-  def create(name, attributes)
-    attributes = attributes.dup
-
-    # Add the objectclasses
-    attributes["objectClass"] = objectclasses.collect { |o| o.to_s }
-    attributes["objectClass"] << "top" unless attributes["objectClass"].include?("top")
-
-    attributes[rdn.to_s] = [name]
-
-    # Generate any new values we might need.
-    generate(attributes)
-
-    # And create our resource.
-    connect { |conn| conn.add dn(name), attributes }
-  end
-
-  # Open, yield, and close the connection.  Cannot be left
-  # open, at this point.
-  def connect
-    #TRANSLATORS '#connect' is a method name and and should not be translated, 'block' refers to a Ruby code block
-    raise ArgumentError, _("You must pass a block to #connect") unless block_given?
-
-    unless @connection
-      if Puppet[:ldaptls]
-        ssl = :tls
-      elsif Puppet[:ldapssl]
-        ssl = true
-      else
-        ssl = false
-      end
-      options = {:ssl => ssl}
-      if user = Puppet[:ldapuser] and user != ""
-        options[:user] = user
-      end
-      if password = Puppet[:ldappassword] and password != ""
-        options[:password] = password
-      end
-      @connection = Puppet::Util::Ldap::Connection.new(Puppet[:ldapserver], Puppet[:ldapport], options)
-    end
-    @connection.start
-    begin
-      yield @connection.connection
-    ensure
-      @connection.close
-    end
-    nil
-  end
-
-  # Convert the name to a dn, then pass the args along to
-  # our connection.
-  def delete(name)
-    connect { |connection| connection.delete dn(name) }
-  end
-
-  # Calculate the dn for a given resource.
-  def dn(name)
-    ["#{rdn}=#{name}", base].join(",")
-  end
-
-  # Convert an ldap-style entry hash to a provider-style hash.
-  def entry2provider(entry)
-    #TRANSLATOR 'dn' refers to a 'distinguished name' in LDAP (Lightweight Directory Access Protocol) and they should not be translated
-    raise ArgumentError, _("Could not get dn from ldap entry") unless entry["dn"]
-
-    # DN is always a single-entry array.  Strip off the bits before the
-    # first comma, then the bits after the remaining equal sign.  This is the
-    # name.
-    name = entry["dn"].dup.pop.split(",").shift.split("=").pop
-
-    result = {:name => name}
-
-    @ldap2puppet.each do |ldap, puppet|
-      result[puppet] = entry[ldap.to_s] || :absent
-    end
-
-    result
-  end
-
-  # Create our normal search filter.
-  def filter
-    return(objectclasses.length == 1 ? "objectclass=#{objectclasses[0]}" : "(&(objectclass=" + objectclasses.join(")(objectclass=") + "))")
-  end
-
-  # Find the associated entry for a resource.  Returns a hash, minus
-  # 'dn', or nil if the entry cannot be found.
-  def find(name)
-    connect do |conn|
-      begin
-        conn.search2(dn(name), 0, "objectclass=*") do |result|
-          # Convert to puppet-appropriate attributes
-          return entry2provider(result)
-        end
-      rescue
-        return nil
-      end
-    end
-  end
-
-  # Declare a new attribute generator.
-  def generates(parameter)
-    @generators << Puppet::Util::Ldap::Generator.new(parameter)
-    @generators[-1]
-  end
-
-  # Generate any extra values we need to make the ldap entry work.
-  def generate(values)
-    return unless @generators.length > 0
-
-    @generators.each do |generator|
-      # Don't override any values that might exist.
-      next if values[generator.name]
-
-      if generator.source
-        unless value = values[generator.source]
-          raise ArgumentError, _("%{source} must be defined to generate %{name}") %
-              { source: generator.source, name: generator.name }
-        end
-        result = generator.generate(value)
-      else
-        result = generator.generate
-      end
-
-      result = [result] unless result.is_a?(Array)
-      result = result.collect { |r| r.to_s }
-
-      values[generator.name] = result
-    end
-  end
-
-  def initialize
-    @rdn = :cn
-    @generators = []
-  end
-
-  # Specify what classes this provider models.
-  def manages(*classes)
-    @objectclasses = classes
-    self
-  end
-
-  # Specify the attribute map.  Assumes the keys are the puppet
-  # attributes, and the values are the ldap attributes, and creates a map
-  # for each direction.
-  def maps(attributes)
-    # The map with the puppet attributes as the keys
-    @puppet2ldap = attributes
-
-    # and the ldap attributes as the keys.
-    @ldap2puppet = attributes.inject({}) { |map, ary| map[ary[1]] = ary[0]; map }
-
-    self
-  end
-
-  # Return the ldap name for a puppet attribute.
-  def ldap_name(attribute)
-    @puppet2ldap[attribute].to_s
-  end
-
-  # Convert the name to a dn, then pass the args along to
-  # our connection.
-  def modify(name, mods)
-    connect { |connection| connection.modify dn(name), mods }
-  end
-
-  # Specify the rdn that we use to build up our dn.
-  def named_by(attribute)
-    @rdn = attribute
-    self
-  end
-
-  # Return the puppet name for an ldap attribute.
-  def puppet_name(attribute)
-    @ldap2puppet[attribute]
-  end
-
-  # Search for all entries at our base.  A potentially expensive search.
-  def search(sfilter = nil)
-    sfilter ||= filter
-
-    result = []
-    connect do |conn|
-      conn.search2(base, 1, sfilter) do |entry|
-        result << entry2provider(entry)
-      end
-    end
-    return(result.empty? ? nil : result)
-  end
-
-  # Update the ldap entry with the desired state.
-  def update(name, is, should)
-    if should[:ensure] == :absent
-      Puppet.info _("Removing %{name} from ldap") % { name: dn(name) }
-      delete(name)
-      return
-    end
-
-    # We're creating a new entry
-    if is.empty? or is[:ensure] == :absent
-      Puppet.info _("Creating %{name} in ldap") % { name: dn(name) }
-      # Remove any :absent params and :ensure, then convert the names to ldap names.
-      attrs = ldap_convert(should)
-      create(name, attrs)
-      return
-    end
-
-    # We're modifying an existing entry.  Yuck.
-
-    mods = []
-    # For each attribute we're deleting that is present, create a
-    # modify instance for deletion.
-    [is.keys, should.keys].flatten.uniq.each do |property|
-      # They're equal, so do nothing.
-      next if is[property] == should[property]
-
-      attributes = ldap_convert(should)
-
-      prop_name = ldap_name(property).to_s
-
-      # We're creating it.
-      if is[property] == :absent or is[property].nil?
-        mods << LDAP::Mod.new(LDAP::LDAP_MOD_ADD, prop_name, attributes[prop_name])
-        next
-      end
-
-      # We're deleting it
-      if should[property] == :absent or should[property].nil?
-        mods << LDAP::Mod.new(LDAP::LDAP_MOD_DELETE, prop_name, [])
-        next
-      end
-
-      # We're replacing an existing value
-      mods << LDAP::Mod.new(LDAP::LDAP_MOD_REPLACE, prop_name, attributes[prop_name])
-    end
-
-    modify(name, mods)
-  end
-
-  # Is this a complete ldap configuration?
-  def valid?
-    location and objectclasses and ! objectclasses.empty? and puppet2ldap
-  end
-
-  private
-
-  # Convert a hash of attributes to ldap-like forms.  This mostly means
-  # getting rid of :ensure and making sure everything's an array of strings.
-  def ldap_convert(attributes)
-    attributes.reject { |param, value| value == :absent or param == :ensure }.inject({}) do |result, ary|
-      value = (ary[1].is_a?(Array) ? ary[1] : [ary[1]]).collect { |v| v.to_s }
-      result[ldap_name(ary[0])] = value
-      result
-    end
-  end
-end