puppet 5.0.0 → 6.0.0

data/lib/puppet/indirector/ldap.rb

@@ -1,80 +0,0 @@
-require 'puppet/indirector/terminus'
-require 'puppet/util/ldap/connection'
-
-class Puppet::Indirector::Ldap < Puppet::Indirector::Terminus
-  # Perform our ldap search and process the result.
-  def find(request)
-    ldapsearch(search_filter(request.key)) { |entry| return process(entry) } || nil
-  end
-
-  # Process the found entry.  We assume that we don't just want the
-  # ldap object.
-  def process(entry)
-    raise Puppet::DevError, "The 'process' method has not been overridden for the LDAP terminus for #{self.name}"
-  end
-
-  # Default to all attributes.
-  def search_attributes
-    nil
-  end
-
-  def search_base
-    Puppet[:ldapbase]
-  end
-
-  # The ldap search filter to use.
-  def search_filter(name)
-    raise Puppet::DevError, "No search string set for LDAP terminus for #{self.name}"
-  end
-
-  # Find the ldap node, return the class list and parent node specially,
-  # and everything else in a parameter hash.
-  def ldapsearch(filter)
-    raise ArgumentError.new(_("You must pass a block to ldapsearch")) unless block_given?
-
-    found = false
-    count = 0
-
-    begin
-      connection.search(search_base, 2, filter, search_attributes) do |entry|
-        found = true
-        yield entry
-      end
-    rescue SystemExit,NoMemoryError
-      raise
-    rescue Exception => detail
-      if count == 0
-        # Try reconnecting to ldap if we get an exception and we haven't yet retried.
-        count += 1
-        @connection = nil
-        Puppet.warning _("Retrying LDAP connection")
-        retry
-      else
-        error = Puppet::Error.new(_("LDAP Search failed"))
-        error.set_backtrace(detail.backtrace)
-        raise error
-      end
-    end
-
-    found
-  end
-
-  # Create an ldap connection.
-  def connection
-    unless @connection
-      #TRANSLATORS "ruby/ldap libraries" are code dependencies
-      raise Puppet::Error, _("Could not set up LDAP Connection: Missing ruby/ldap libraries") unless Puppet.features.ldap?
-      begin
-        conn = Puppet::Util::Ldap::Connection.instance
-        conn.start
-        @connection = conn.connection
-      rescue => detail
-        message = _("Could not connect to LDAP: %{detail}") % { detail: detail }
-        Puppet.log_exception(detail, message)
-        raise Puppet::Error, message, detail.backtrace
-      end
-    end
-
-    @connection
-  end
-end

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

@@ -1,259 +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://docs.puppetlabs.com/guides/ldap_nodes.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`."
-
-  # 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)
-
-    result[:environment] = result[:parameters]["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
-
-  def get_parameters_from_entry(entry)
-    stacked_params = stacked_attributes
-    entry.to_hash.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/lib/puppet/indirector/node/write_only_yaml.rb

@@ -1,37 +0,0 @@
-require 'puppet/node'
-require 'puppet/indirector/yaml'
-
-# This is a WriteOnlyYaml terminus that exists only for the purpose of being able to write
-# node cache data that later can be read by the YAML terminus.
-# The use case this supports is to make it possible to search among the "current nodes"
-# when Puppet DB (recommended) or other central storage of information is not available.
-#
-# @see puppet issue 16753
-# @see Puppet::Application::Master#setup_node_cache
-# @api private
-#
-class Puppet::Node::WriteOnlyYaml < Puppet::Indirector::Yaml
-  def initialize
-    Puppet.warn_once('deprecations', 'Puppet::Node::WriteOnlyYaml', _('Puppet::Node::WriteOnlyYaml is deprecated and will be removed in a future release of Puppet.'))
-    super
-  end
-
-  desc "(Deprecated) Store node information as flat files, serialized using YAML,
-    does not deserialize (write only)."
-
-  # Overridden to always return nil. This is a write only terminus.
-  # @param [Object] request Ignored.
-  # @return [nil] This implementation always return nil'
-  # @api public
-  def find(request)
-    nil
-  end
-
-  # Overridden to always return nil. This is a write only terminus.
-  # @param [Object] request Ignored.
-  # @return [nil] This implementation always return nil
-  # @api public
-  def search(request)
-    nil
-  end
-end

data/lib/puppet/module_tool/applications/builder.rb

@@ -1,148 +0,0 @@
-require 'fileutils'
-require 'json'
-require 'puppet/file_system'
-require 'pathspec'
-
-module Puppet::ModuleTool
-  module Applications
-    class Builder < Application
-
-      def initialize(path, options = {})
-        @path = File.expand_path(path)
-        @pkg_path = File.join(@path, 'pkg')
-        super(options)
-      end
-
-      def run
-        load_metadata!
-        create_directory
-        copy_contents
-        write_json
-        Puppet.notice _("Building %{path} for release") % { path: @path }
-        pack
-        relative = Pathname.new(archive_file).relative_path_from(Pathname.new(File.expand_path(Dir.pwd)))
-
-        # Return the Pathname object representing the path to the release
-        # archive just created. This return value is used by the module_tool
-        # face build action, and displayed to on the console using the to_s
-        # method.
-        #
-        # Example return value:
-        #
-        #   <Pathname:puppetlabs-apache/pkg/puppetlabs-apache-0.0.1.tar.gz>
-        #
-        relative
-      end
-
-      private
-
-      def archive_file
-        File.join(@pkg_path, "#{metadata.release_name}.tar.gz")
-      end
-
-      def pack
-        FileUtils.rm archive_file rescue nil
-
-        tar = Puppet::ModuleTool::Tar.instance
-        Dir.chdir(@pkg_path) do
-          tar.pack(metadata.release_name, archive_file)
-        end
-      end
-
-      def create_directory
-        FileUtils.mkdir(@pkg_path) rescue nil
-        if File.directory?(build_path)
-          FileUtils.rm_rf(build_path, :secure => true)
-        end
-        FileUtils.mkdir(build_path)
-      end
-
-      def ignored_files
-        if @ignored_files
-          return @ignored_files
-        else
-          pmtignore = File.join(@path, '.pmtignore')
-          gitignore = File.join(@path, '.gitignore')
-
-          if File.file? pmtignore
-            @ignored_files = PathSpec.new Puppet::FileSystem.read(pmtignore, :encoding => 'utf-8')
-          elsif File.file? gitignore
-            @ignored_files = PathSpec.new Puppet::FileSystem.read(gitignore, :encoding => 'utf-8')
-          else
-            @ignored_files = PathSpec.new
-          end
-        end
-      end
-
-      def copy_contents
-        symlinks = []
-        Find.find(File.join(@path)) do |path|
-          # because Find.find finds the path itself
-          if path == @path
-            next
-          end
-
-          # Needed because pathspec looks for a trailing slash in the path to
-          # determine if a path is a directory
-          path = path.to_s + '/' if File.directory? path
-
-          # if it matches, then prune it with fire
-          unless ignored_files.match_paths([path], @path).empty?
-            Find.prune
-          end
-
-          # don't copy all the Puppet ARTIFACTS
-          rel = Pathname.new(path).relative_path_from(Pathname.new(@path))
-          case rel.to_s
-          when *Puppet::ModuleTool::ARTIFACTS
-            Find.prune
-          end
-
-          # make dir tree, copy files, and add symlinks to the symlinks list
-          dest = "#{build_path}/#{rel.to_s}"
-          if File.directory? path
-            FileUtils.mkdir dest, :mode => File.stat(path).mode
-          elsif Puppet::FileSystem.symlink? path
-            symlinks << path
-          else
-            FileUtils.cp path, dest, :preserve => true
-          end
-        end
-
-        # send a message about each symlink and raise an error if they exist
-        unless symlinks.empty?
-          symlinks.each do |s|
-            s = Pathname.new s
-            mpath = Pathname.new @path
-            Puppet.warning _("Symlinks in modules are unsupported. Please investigate symlink %{from} -> %{to}.") % { from: s.relative_path_from(mpath), to: s.realpath.relative_path_from(mpath) }
-          end
-
-          raise Puppet::ModuleTool::Errors::ModuleToolError, _("Found symlinks. Symlinks in modules are not allowed, please remove them.")
-        end
-      end
-
-      def write_json
-        metadata_path = File.join(build_path, 'metadata.json')
-
-        if metadata.to_hash.include? 'checksums'
-          Puppet.warning _("A 'checksums' field was found in metadata.json. This field will be ignored and can safely be removed.")
-        end
-
-        # TODO: This may necessarily change the order in which the metadata.json
-        # file is packaged from what was written by the user.  This is a
-        # regretable, but required for now.
-        Puppet::FileSystem.open(metadata_path, nil, 'w:UTF-8') do |f|
-          f.write(metadata.to_json)
-        end
-
-        Puppet::FileSystem.open(File.join(build_path, 'checksums.json'), nil, 'wb') do |f|
-          f.write(JSON.pretty_generate(Checksums.new(build_path)))
-        end
-      end
-
-      def build_path
-        @build_path ||= File.join(@pkg_path, metadata.release_name)
-      end
-    end
-  end
-end

data/lib/puppet/module_tool/skeleton/templates/generator/Gemfile

@@ -1,18 +0,0 @@
-source ENV['GEM_SOURCE'] || 'https://rubygems.org'
-
-puppetversion = ENV.key?('PUPPET_VERSION') ? ENV['PUPPET_VERSION'] : ['>= 3.3']
-gem 'metadata-json-lint'
-gem 'puppet', puppetversion
-gem 'puppetlabs_spec_helper', '>= 1.2.0'
-gem 'puppet-lint', '>= 1.0.0'
-gem 'facter', '>= 1.7.0'
-gem 'rspec-puppet'
-
-# rspec must be v2 for ruby 1.8.7
-if RUBY_VERSION >= '1.8.7' && RUBY_VERSION < '1.9'
-  gem 'rspec', '~> 2.0'
-  gem 'rake', '~> 10.0'
-else
-  # rubocop requires ruby >= 1.9
-  gem 'rubocop'
-end

data/lib/puppet/module_tool/skeleton/templates/generator/README.md.erb

@@ -1,89 +0,0 @@
-# <%= metadata.name %>
-
-#### Table of Contents
-
-1. [Description](#description)
-1. [Setup - The basics of getting started with <%= metadata.name %>](#setup)
-    * [What <%= metadata.name %> affects](#what-<%= metadata.name %>-affects)
-    * [Setup requirements](#setup-requirements)
-    * [Beginning with <%= metadata.name %>](#beginning-with-<%= metadata.name %>)
-1. [Usage - Configuration options and additional functionality](#usage)
-1. [Reference - An under-the-hood peek at what the module is doing and how](#reference)
-1. [Limitations - OS compatibility, etc.](#limitations)
-1. [Development - Guide for contributing to the module](#development)
-
-## Description
-
-Start with a one- or two-sentence summary of what the module does and/or what
-problem it solves. This is your 30-second elevator pitch for your module.
-Consider including OS/Puppet version it works with.
-
-You can give more descriptive information in a second paragraph. This paragraph
-should answer the questions: "What does this module *do*?" and "Why would I use
-it?" If your module has a range of functionality (installation, configuration,
-management, etc.), this is the time to mention it.
-
-## Setup
-
-### What <%= metadata.name %> affects **OPTIONAL**
-
-If it's obvious what your module touches, you can skip this section. For
-example, folks can probably figure out that your mysql_instance module affects
-their MySQL instances.
-
-If there's more that they should know about, though, this is the place to mention:
-
-* A list of files, packages, services, or operations that the module will alter,
-  impact, or execute.
-* Dependencies that your module automatically installs.
-* Warnings or other important notices.
-
-### Setup Requirements **OPTIONAL**
-
-If your module requires anything extra before setting up (pluginsync enabled,
-etc.), mention it here.
-
-If your most recent release breaks compatibility or requires particular steps
-for upgrading, you might want to include an additional "Upgrading" section
-here.
-
-### Beginning with <%= metadata.name %>
-
-The very basic steps needed for a user to get the module up and running. This
-can include setup steps, if necessary, or it can be an example of the most
-basic use of the module.
-
-## Usage
-
-This section is where you describe how to customize, configure, and do the
-fancy stuff with your module here. It's especially helpful if you include usage
-examples and code samples for doing things with your module.
-
-## Reference
-
-Users need a complete list of your module's classes, types, defined types providers, facts, and functions, along with the parameters for each. You can provide this list either via Puppet Strings code comments or as a complete list in this Reference section.
-
-* If you are using Puppet Strings code comments, this Reference section should include Strings information so that your users know how to access your documentation.
-
-* If you are not using Puppet Strings, include a list of all of your classes, defined types, and so on, along with their parameters. Each element in this listing should include:
-
-  * The data type, if applicable.
-  * A description of what the element does.
-  * Valid values, if the data type doesn't make it obvious.
-  * Default value, if any.
-
-## Limitations
-
-This is where you list OS compatibility, version compatibility, etc. If there
-are Known Issues, you might want to include them under their own heading here.
-
-## Development
-
-Since your module is awesome, other users will want to play with it. Let them
-know what the ground rules for contributing are.
-
-## Release Notes/Contributors/Etc. **Optional**
-
-If you aren't using changelog, put your release notes here (though you should
-consider using changelog). You can also add any additional sections you feel
-are necessary or important to include here. Please use the `## ` header.

data/lib/puppet/module_tool/skeleton/templates/generator/Rakefile

@@ -1,32 +0,0 @@
-require 'puppetlabs_spec_helper/rake_tasks'
-require 'puppet-lint/tasks/puppet-lint'
-require 'metadata-json-lint/rake_task'
-
-if RUBY_VERSION >= '1.9'
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
-end
-
-PuppetLint.configuration.send('disable_80chars')
-PuppetLint.configuration.relative = true
-PuppetLint.configuration.ignore_paths = ['spec/**/*.pp', 'pkg/**/*.pp']
-
-desc 'Validate manifests, templates, and ruby files'
-task :validate do
-  Dir['manifests/**/*.pp'].each do |manifest|
-    sh "puppet parser validate --noop #{manifest}"
-  end
-  Dir['spec/**/*.rb', 'lib/**/*.rb'].each do |ruby_file|
-    sh "ruby -c #{ruby_file}" unless ruby_file =~ %r{spec/fixtures}
-  end
-  Dir['templates/**/*.erb'].each do |template|
-    sh "erb -P -x -T '-' #{template} | ruby -c"
-  end
-end
-
-desc 'Run lint, validate, and spec tests.'
-task :test do
-  [:lint, :validate, :spec].each do |test|
-    Rake::Task[test].invoke
-  end
-end

data/lib/puppet/module_tool/skeleton/templates/generator/examples/init.pp.erb

@@ -1,12 +0,0 @@
-# The baseline for module testing used by Puppet Inc. is that each manifest
-# should have a corresponding test manifest that declares that class or defined
-# type.
-#
-# Tests are then run by using puppet apply --noop (to check for compilation
-# errors and view a log of events) or by fully applying the test in a virtual
-# environment (to compare the resulting system state to the desired state).
-#
-# Learn more about module testing here:
-# https://docs.puppet.com/guides/tests_smoke.html
-#
-include ::<%= metadata.name %>