bolt 0.23.0 → 0.24.0

data/vendored/puppet/lib/puppet/indirector/node/ldap.rb

@@ -1,275 +0,0 @@
-require 'puppet/node'
-require 'puppet/indirector/ldap'
-
-class Puppet::Node::Ldap < Puppet::Indirector::Ldap
-  desc "Search in LDAP for node configuration information.  See
-  the [LDAP Nodes](https://puppet.com/docs/puppet/latest/nodes_ldap.html) page for more information.  This will first
-  search for whatever the certificate name is, then (if that name
-  contains a `.`) for the short name, then `default`.
-  Requires ruby-ldap with MRI ruby or jruby-ldap with puppetserver/jruby"
-
-  # The attributes that Puppet class information is stored in.
-  def class_attributes
-    Puppet[:ldapclassattrs].split(/\s*,\s*/)
-  end
-
-  # Separate this out so it's relatively atomic.  It's tempting to call
-  # process instead of name2hash() here, but it ends up being
-  # difficult to test because all exceptions get caught by ldapsearch.
-  # LAK:NOTE Unfortunately, the ldap support is too stupid to throw anything
-  # but LDAP::ResultError, even on bad connections, so we are rough-handed
-  # with our error handling.
-  def name2hash(name)
-    info = nil
-    ldapsearch(search_filter(name)) { |entry| info = entry2hash(entry) }
-    info
-  end
-
-  # Look for our node in ldap.
-  def find(request)
-    names = [request.key]
-    names << request.key.sub(/\..+/, '') if request.key.include?(".") # we assume it's an fqdn
-    names << "default"
-
-    facts = request.options[:facts].is_a?(Puppet::Node::Facts) ? request.options[:facts] : nil
-
-    node = nil
-    names.each do |name|
-      next unless info = name2hash(name)
-
-      merge_parent(info) if info[:parent]
-      info[:environment] ||= request.environment
-      node = info2node(request.key, info, facts)
-      break
-    end
-
-    node
-  end
-
-  # Find more than one node.  LAK:NOTE This is a bit of a clumsy API, because the 'search'
-  # method currently *requires* a key.  It seems appropriate in some cases but not others,
-  # and I don't really know how to get rid of it as a requirement but allow it when desired.
-  def search(request)
-    if classes = request.options[:class]
-      classes = [classes] unless classes.is_a?(Array)
-      filter = "(&(objectclass=puppetClient)(puppetclass=" + classes.join(")(puppetclass=") + "))"
-    else
-      filter = "(objectclass=puppetClient)"
-    end
-
-    infos = []
-    ldapsearch(filter) { |entry| infos << entry2hash(entry, request.options[:fqdn]) }
-
-    return infos.collect do |info|
-      merge_parent(info) if info[:parent]
-      info[:environment] ||= request.environment
-      info2node(info[:name], info)
-    end
-  end
-
-  # The parent attribute, if we have one.
-  def parent_attribute
-    if pattr = Puppet[:ldapparentattr] and ! pattr.empty?
-      pattr
-    else
-      nil
-    end
-  end
-
-  # The attributes that Puppet will stack as array over the full
-  # hierarchy.
-  def stacked_attributes
-    Puppet[:ldapstackedattrs].split(/\s*,\s*/)
-  end
-
-  # Convert the found entry into a simple hash.
-  def entry2hash(entry, fqdn = false)
-    result = {}
-
-    cn  = entry.dn[     /cn\s*=\s*([^,\s]+)/i,1]
-    dcs = entry.dn.scan(/dc\s*=\s*([^,\s]+)/i)
-    result[:name]    = fqdn ? ([cn]+dcs).join('.') : cn
-    result[:parent] = get_parent_from_entry(entry) if parent_attribute
-    result[:classes] = get_classes_from_entry(entry)
-    result[:stacked] = get_stacked_values_from_entry(entry)
-    result[:parameters] = get_parameters_from_entry(entry)
-
-    # delete from parameters to prevent "Already declered variable $environment" error
-    result[:environment] = result[:parameters].delete(:environment) if result[:parameters][:environment]
-
-    result[:stacked_parameters] = {}
-
-    if result[:stacked]
-      result[:stacked].each do |value|
-        param = value.split('=', 2)
-        result[:stacked_parameters][param[0]] = param[1]
-      end
-    end
-
-    if result[:stacked_parameters]
-      result[:stacked_parameters].each do |param, value|
-        result[:parameters][param] = value unless result[:parameters].include?(param)
-      end
-    end
-
-    result[:parameters] = convert_parameters(result[:parameters])
-
-    result
-  end
-
-  # Default to all attributes.
-  def search_attributes
-    ldapattrs = Puppet[:ldapattrs]
-
-    # results in everything getting returned
-    return nil if ldapattrs == "all"
-
-    search_attrs = class_attributes + ldapattrs.split(/\s*,\s*/)
-
-    if pattr = parent_attribute
-      search_attrs << pattr
-    end
-
-    search_attrs
-  end
-
-  # The ldap search filter to use.
-  def search_filter(name)
-    filter = Puppet[:ldapstring]
-
-    if filter.include? "%s"
-      # Don't replace the string in-line, since that would hard-code our node
-      # info.
-      filter = filter.gsub('%s', name)
-    end
-    filter
-  end
-
-  private
-
-  # Add our hash of ldap information to the node instance.
-  def add_to_node(node, information)
-    node.classes = information[:classes].uniq unless information[:classes].nil? or information[:classes].empty?
-    node.parameters = information[:parameters] unless information[:parameters].nil? or information[:parameters].empty?
-    node.environment = information[:environment] if information[:environment]
-  end
-
-  def convert_parameters(parameters)
-    result = {}
-    parameters.each do |param, value|
-      if value.is_a?(Array)
-        result[param] = value.collect { |v| convert(v) }
-      else
-        result[param] = convert(value)
-      end
-    end
-    result
-  end
-
-  # Convert any values if necessary.
-  def convert(value)
-    case value
-    when Integer; value
-    when "true"; true
-    when "false"; false
-    else
-      value
-    end
-  end
-
-  # Find information for our parent and merge it into the current info.
-  def find_and_merge_parent(parent, information)
-    parent_info = name2hash(parent) || raise(Puppet::Error.new(_("Could not find parent node '%{parent}'") % { parent: parent }))
-    information[:classes] += parent_info[:classes]
-    parent_info[:parameters].each do |param, value|
-      # Specifically test for whether it's set, so false values are handled correctly.
-      information[:parameters][param] = value unless information[:parameters].include?(param)
-    end
-    information[:environment] ||= parent_info[:environment]
-    parent_info[:parent]
-  end
-
-  # Take a name and a hash, and return a node instance.
-  def info2node(name, info, facts = nil)
-    node = Puppet::Node.new(name)
-
-    add_to_node(node, info)
-
-    node.fact_merge(facts)
-
-    node
-  end
-
-  def merge_parent(info)
-    parent = info[:parent]
-
-    # Preload the parent array with the node name.
-    parents = [info[:name]]
-    while parent
-      raise ArgumentError, _("Found loop in LDAP node parents; %{parent} appears twice") % { parent: parent } if parents.include?(parent)
-      parents << parent
-      parent = find_and_merge_parent(parent, info)
-    end
-
-    info
-  end
-
-  def get_classes_from_entry(entry)
-    result = class_attributes.inject([]) do |array, attr|
-      if values = entry.vals(attr)
-        values.each do |v| array << v end
-      end
-      array
-    end
-    result.uniq
-  end
-
-  # Workaround jruby-ldap 0.0.2 missing the #to_hash method
-  #
-  # @see https://github.com/jruby/jruby-ldap/pull/5
-  #
-  # @param entry [LDAP::Entry] The LDAP::Entry object to convert to a hash
-  # @return [Hash] The hash of the provided LDAP::Entry object with keys
-  #   downcased (puppet variables need to start with lowercase char)
-  def ldap_entry_to_hash(entry)
-     h = {}
-     entry.get_attributes.each { |a| h[a.downcase.to_sym] = entry[a] }
-     h[:dn] = [entry.dn]
-     h
-  end
-
-  def get_parameters_from_entry(entry)
-    stacked_params = stacked_attributes
-    ldap_entry_to_hash(entry).inject({}) do |hash, ary|
-      unless stacked_params.include?(ary[0]) # don't add our stacked parameters to the main param list
-        if ary[1].length == 1
-          hash[ary[0]] = ary[1].shift
-        else
-          hash[ary[0]] = ary[1]
-        end
-      end
-      hash
-    end
-  end
-
-  def get_parent_from_entry(entry)
-    pattr = parent_attribute
-
-    return nil unless values = entry.vals(pattr)
-
-    if values.length > 1
-      raise Puppet::Error,
-        _("Node entry %{entry} specifies more than one parent: %{parents}") % { entry: entry.dn, parents: values.inspect }
-    end
-    return(values.empty? ? nil : values.shift)
-  end
-
-  def get_stacked_values_from_entry(entry)
-    stacked_attributes.inject([]) do |result, attr|
-      if values = entry.vals(attr)
-        result += values
-      end
-      result
-    end
-  end
-end

data/vendored/puppet/lib/puppet/provider/aixobject.rb

@@ -1,392 +0,0 @@
-#
-# Common code for AIX providers. This class implements basic structure for
-# AIX resources.
-# Author::    Hector Rivas Gandara <keymon@gmail.com>
-#
-class Puppet::Provider::AixObject < Puppet::Provider
-  desc "Generic AIX resource provider"
-
-  # The real provider must implement these functions.
-  def lscmd( _value = @resource[:name] )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement lscmd"
-  end
-
-  def addcmd( _extra_attrs = [] )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement addcmd"
-  end
-
-  def modifycmd( _attributes_hash = {} )
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement modifycmd"
-  end
-
-  def deletecmd
-    raise Puppet::Error, "Method not defined #{@resource.class.name} #{@resource.name}: Base AixObject provider doesn't implement deletecmd"
-  end
-
-  # Valid attributes to be managed by this provider.
-  # It is a list of hashes
-  #  :aix_attr      AIX command attribute name
-  #  :puppet_prop   Puppet property name
-  #  :to            Optional. Method name that adapts puppet property to aix command value.
-  #  :from          Optional. Method to adapt aix command line value to puppet property. Optional
-  class << self
-    attr_accessor :attribute_mapping
-  end
-
-  # Mapping from Puppet property to AIX attribute.
-  def self.attribute_mapping_to
-    if ! @attribute_mapping_to
-      @attribute_mapping_to = {}
-      attribute_mapping.each { |elem|
-        attribute_mapping_to[elem[:puppet_prop]] = {
-          :key => elem[:aix_attr],
-          :method => elem[:to]
-        }
-      }
-    end
-    @attribute_mapping_to
-  end
-
-  # Mapping from AIX attribute to Puppet property.
-  def self.attribute_mapping_from
-    if ! @attribute_mapping_from
-      @attribute_mapping_from = {}
-      attribute_mapping.each { |elem|
-        attribute_mapping_from[elem[:aix_attr]] = {
-          :key => elem[:puppet_prop],
-          :method => elem[:from]
-        }
-      }
-    end
-    @attribute_mapping_from
-  end
-
-  # This functions translates a key and value using the given mapping.
-  # Mapping can be nil (no translation) or a hash with this format
-  # {:key => new_key, :method => translate_method}
-  # It returns a list with the pair [key, value]
-  def translate_attr(key, value, mapping)
-    return [key, value] unless mapping
-    return nil unless mapping[key]
-
-    if mapping[key][:method]
-      new_value = method(mapping[key][:method]).call(value)
-    else
-      new_value = value
-    end
-    [mapping[key][:key], new_value]
-  end
-
-  # Loads an AIX attribute (key=value) and stores it in the given hash with
-  # puppet semantics. It translates the pair using the given mapping.
-  #
-  # This operation works with each property one by one,
-  # subclasses must reimplement this if more complex operations are needed
-  def load_attribute(key, value, mapping, objectinfo)
-    if mapping.nil?
-      objectinfo[key] = value
-    elsif mapping[key].nil?
-      # is not present in mapping, ignore it.
-      true
-    elsif mapping[key][:method].nil?
-      objectinfo[mapping[key][:key]] = value
-    else
-      objectinfo[mapping[key][:key]] = method(mapping[key][:method]).call(value)
-    end
-
-    return objectinfo
-  end
-
-  # Gets the given command line argument for the given key and value,
-  # using the given mapping to translate key and value.
-  # All the objectinfo hash (@resource or @property_hash) is passed.
-  #
-  # This operation works with each property one by one,
-  # and default behaviour is return the arguments as key=value pairs.
-  # Subclasses must reimplement this if more complex operations/arguments
-  # are needed
-  #
-  def get_arguments(key, value, mapping, objectinfo)
-    if mapping.nil?
-      new_key = key
-      new_value = value
-    elsif mapping[key].nil?
-      # is not present in mapping, ignore it.
-      new_key = nil
-      new_value = nil
-    elsif mapping[key][:method].nil?
-      new_key = mapping[key][:key]
-      new_value = value
-    else
-      new_key = mapping[key][:key]
-      new_value = method(mapping[key][:method]).call(value)
-    end
-
-    # convert it to string
-    new_value = Array(new_value).join(',')
-
-    if new_key
-      return [ "#{new_key}=#{new_value}" ]
-    else
-      return []
-    end
-  end
-
-  # Convert the provider properties (hash) to AIX command arguments
-  # (list of strings)
-  # This function will translate each value/key and generate the argument using
-  # the get_arguments function.
-  def hash2args(hash, mapping=self.class.attribute_mapping_to)
-    return "" unless hash
-    arg_list = []
-    hash.each {|key, val|
-      arg_list += self.get_arguments(key, val, mapping, hash)
-    }
-    arg_list
-  end
-
-  # Parse AIX command attributes from the output of an AIX command, that
-  # which format is a list of space separated of key=value pairs:
-  # "uid=100 groups=a,b,c".
-  # It returns a hash.
-  #
-  # If a mapping is provided, the keys are translated as defined in the
-  # mapping hash. And only values included in mapping will be added
-  #
-  # NOTE: it will ignore the items not including '='
-  def parse_attr_list(str, mapping=self.class.attribute_mapping_from)
-    properties = {}
-    attrs = []
-    if str.nil? or (attrs = str.split()).empty?
-      return nil
-    end
-
-    attrs.each { |i|
-      if i.include? "=" # Ignore if it does not include '='
-        (key_str, val) = i.split('=')
-        # Check the key
-        if key_str.nil? or key_str.empty?
-          info _("Empty key in string 'i'?")
-          continue
-        end
-        key_str.strip!
-        key = key_str.to_sym
-        val.strip! if val
-
-        properties = self.load_attribute(key, val, mapping, properties)
-      end
-    }
-    properties.empty? ? nil : properties
-  end
-
-  # Parse AIX command output in a colon separated list of attributes,
-  # This function is useful to parse the output of commands like lsfs -c:
-  #   #MountPoint:Device:Vfs:Nodename:Type:Size:Options:AutoMount:Acct
-  #   /:/dev/hd4:jfs2::bootfs:557056:rw:yes:no
-  #   /home:/dev/hd1:jfs2:::2129920:rw:yes:no
-  #   /usr:/dev/hd2:jfs2::bootfs:9797632:rw:yes:no
-  #
-  # If a mapping is provided, the keys are translated as defined in the
-  # mapping hash. And only values included in mapping will be added
-  def parse_colon_list(str, key_list, mapping=self.class.attribute_mapping_from)
-    properties = {}
-    attrs = []
-    if str.nil? or (attrs = str.split(':')).empty?
-      return nil
-    end
-
-    attrs.each { |val|
-      key = key_list.shift.to_sym
-      properties = self.load_attribute(key, val, mapping, properties)
-    }
-    properties.empty? ? nil : properties
-  end
-
-  # Default parsing function for AIX commands.
-  # It will choose the method depending of the first line.
-  # For the colon separated list it will:
-  #  1. Get keys from first line.
-  #  2. Parse next line.
-  def parse_command_output(output, mapping=self.class.attribute_mapping_from)
-    lines = output.split("\n")
-    # if it begins with #something:... is a colon separated list.
-    if lines[0] =~ /^#.*:/
-      self.parse_colon_list(lines[1], lines[0][1..-1].split(':'), mapping)
-    else
-      self.parse_attr_list(lines[0], mapping)
-    end
-  end
-
-  # Retrieve all the information of an existing resource.
-  # It will execute 'lscmd' command and parse the output, using the mapping
-  # 'attribute_mapping_from' to translate the keys and values.
-  def getinfo(refresh = false)
-    if @objectinfo.nil? or refresh == true
-      # Execute lsuser, split all attributes and add them to a dict.
-      begin
-        output = execute(self.lscmd)
-        @objectinfo = self.parse_command_output(output)
-        # All attributes without translation
-        @objectosinfo = self.parse_command_output(output, nil)
-      rescue Puppet::ExecutionFailure => detail
-        # Print error if needed. FIXME: Do not check the user here.
-        Puppet.debug "aix.getinfo(): Could not find #{@resource.class.name} #{@resource.name}: #{detail}"
-      end
-    end
-    @objectinfo
-  end
-
-  # Like getinfo, but it will not use the mapping to translate the keys and values.
-  # It might be useful to retrieve some raw information.
-  def getosinfo(refresh = false)
-    if @objectosinfo.nil? or refresh == true
-      getinfo(refresh)
-    end
-    @objectosinfo || Hash.new
-  end
-
-
-  # List all elements of given type. It works for colon separated commands and
-  # list commands.
-  # It returns a list of names.
-  def self.list_all
-    names = []
-    begin
-      output = execute([self.command(:list), 'ALL'])
-
-      output = output.split("\n").select{ |line| line != /^#/ }
-
-      output.each do |line|
-        name = line.split(/[ :]/)[0]
-        names << name if not name.empty?
-      end
-    rescue Puppet::ExecutionFailure => detail
-      # Print error if needed
-      Puppet.debug "aix.list_all(): Could not get all resources of type #{@resource.class.name}: #{detail}"
-    end
-    names
-  end
-
-
-  #-------------
-  # Provider API
-  # ------------
-
-  # Clear out the cached values.
-  def flush
-    @property_hash.clear if @property_hash
-    @objectinfo.clear if @objectinfo
-  end
-
-  # Check that the user exists
-  def exists?
-    !!getinfo(true) # !! => converts to bool
-  end
-
-  # Return all existing instances
-  # The method for returning a list of provider instances.  Note that it returns
-  # providers, preferably with values already filled in, not resources.
-  def self.instances
-    objects=[]
-    list_all.each { |entry|
-      objects << new(:name => entry, :ensure => :present)
-    }
-    objects
-  end
-
-  #- **ensure**
-  #    The basic state that the object should be in.  Valid values are
-  #    `present`, `absent`, `role`.
-  # From ensurable: exists?, create, delete
-  def ensure
-    if exists?
-      :present
-    else
-      :absent
-    end
-  end
-
-  # Create a new instance of the resource
-  def create
-    if exists?
-      info _("already exists")
-      # The object already exists
-      return nil
-    end
-
-    begin
-      execute(self.addcmd)
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, _("Could not create %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
-    end
-  end
-
-  # Delete this instance of the resource
-  def delete
-    unless exists?
-      info _("already absent")
-      # the object already doesn't exist
-      return nil
-    end
-
-    begin
-      execute(self.deletecmd)
-    rescue Puppet::ExecutionFailure => detail
-      raise Puppet::Error, _("Could not delete %{resource} %{name}: %{detail}") % { resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
-    end
-  end
-
-  #--------------------------------
-  # Call this method when the object is initialized.
-  # It creates getter/setter methods for each property our resource type supports.
-  # If setter or getter already defined it will not be overwritten
-  def self.mk_resource_methods
-    [resource_type.validproperties, resource_type.parameters].flatten.each do |prop|
-      next if prop == :ensure
-      define_method(prop) { get(prop) || :absent} unless public_method_defined?(prop)
-      define_method(prop.to_s + "=") { |*vals| set(prop, *vals) } unless public_method_defined?(prop.to_s + "=")
-    end
-  end
-
-  # Define the needed getters and setters as soon as we know the resource type
-  def self.resource_type=(resource_type)
-    super
-    mk_resource_methods
-  end
-
-  # Retrieve a specific value by name.
-  def get(param)
-    (hash = getinfo(false)) ? hash[param] : nil
-  end
-
-  # Set a property.
-  def set(param, value)
-    @property_hash[param.intern] = value
-
-    if getinfo().nil?
-      # This is weird...
-      raise Puppet::Error, _("Trying to update parameter '%{param}' to '%{value}' for a resource that does not exists %{resource} %{name}: %{detail}") % { param: param, value: value, resource: @resource.class.name, name: @resource.name, detail: detail }
-    end
-    if value == getinfo()[param.to_sym]
-      return
-    end
-
-    #self.class.validate(param, value)
-    if cmd = modifycmd({param =>value})
-      begin
-        execute(cmd)
-      rescue Puppet::ExecutionFailure  => detail
-        raise Puppet::Error, _("Could not set %{param} on %{resource}[%{name}]: %{detail}") % { param: param, resource: @resource.class.name, name: @resource.name, detail: detail }, detail.backtrace
-      end
-    end
-
-    # Refresh de info.
-    getinfo(true)
-  end
-
-  def initialize(resource)
-    super
-    @objectinfo = nil
-    @objectosinfo = nil
-  end
-end