puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/lib/puppet/data_providers/json_data_provider_factory.rb

@@ -1,38 +0,0 @@
-# This file is loaded by the autoloader, and it does not find the data function support unless required relative
-#
-require 'json'
-
-module Puppet::DataProviders
-  # TODO: API 5.0, remove this class
-  # @api private
-  # @deprecated
-  class JsonDataProviderFactory < Puppet::Plugins::DataProviders::FileBasedDataProviderFactory
-    def create(name, paths, parent_data_provider)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::JsonDataProviderFactory',
-          'Puppet::DataProviders::JsonDataProviderFactory is deprecated and will be removed in the next major version of Puppet')
-      end
-      JsonDataProvider.new(name, paths, parent_data_provider)
-    end
-
-    def path_extension
-      '.json'
-    end
-  end
-
-  # TODO: API 5.0, remove this class
-  # @api private
-  # @deprecated
-  class JsonDataProvider < Puppet::Plugins::DataProviders::PathBasedDataProvider
-    def initialize_data(path, lookup_invocation)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::JsonDataProvider',
-          'Puppet::DataProviders::JsonDataProvider is deprecated and will be removed in the next major version of Puppet')
-      end
-      JSON.parse(Puppet::FileSystem.read(path, :encoding => 'utf-8'))
-    rescue JSON::ParserError => ex
-      # Filename not included in message, so we add it here.
-      raise Puppet::DataBinding::LookupError, "Unable to parse (#{path}): #{ex.message}"
-    end
-  end
-end

data/lib/puppet/data_providers/yaml_data_provider_factory.rb

@@ -1,40 +0,0 @@
-# This file is loaded by the autoloader, and it does not find the data function support unless required relative
-#
-require 'yaml'
-
-module Puppet::DataProviders
-  # TODO: API 5.0, remove this class
-  # @api private
-  # @deprecated
-  class YamlDataProviderFactory < Puppet::Plugins::DataProviders::FileBasedDataProviderFactory
-    def create(name, paths, parent_data_provider)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::YamlDataProviderFactory',
-        'Puppet::DataProviders::YamlDataProviderFactory is deprecated and will be removed in the next major version of Puppet')
-      end
-      YamlDataProvider.new(name, paths, parent_data_provider)
-    end
-
-    def path_extension
-      '.yaml'
-    end
-  end
-
-  # TODO: API 5.0, remove this class
-  # @api private
-  # @deprecated
-  class YamlDataProvider < Puppet::Plugins::DataProviders::PathBasedDataProvider
-    def initialize_data(path, lookup_invocation)
-      unless Puppet[:strict] == :off
-        Puppet.warn_once(:deprecation, 'Puppet::DataProviders::YamlDataProvider',
-        'Puppet::DataProviders::YamlDataProvider is deprecated and will be removed in the next major version of Puppet')
-      end
-      data = YAML.load_file(path)
-      HieraConfig.symkeys_to_string(data.nil? ? {} : data)
-    rescue YAML::SyntaxError => ex
-      # Psych errors includes the absolute path to the file, so no need to add that
-      # to the message
-      raise Puppet::DataBinding::LookupError, "Unable to parse #{ex.message}"
-    end
-  end
-end

data/lib/puppet/face/file.rb

@@ -1,50 +0,0 @@
-require 'puppet/indirector/face'
-
-Puppet::Indirector::Face.define(:file, '0.0.1') do
-  copyright "Puppet Inc.", 2011
-  license   "Apache 2 license; see COPYING"
-
-  summary "Retrieve and store files in a filebucket"
-  description <<-'EOT'
-    This subcommand interacts with objects stored in a local or remote
-    filebucket. File objects are accessed by their MD5 sum; see the
-    examples for the relevant syntax.
-  EOT
-  notes <<-'EOT'
-    To retrieve the unmunged contents of a file, you must call find with
-    --render-as s. Rendering as yaml will return a hash of metadata
-    about the file, including its contents.
-
-    This subcommand does not interact with the `clientbucketdir` (the default
-    local filebucket for puppet agent); it interacts with the primary
-    "master"-type filebucket located in the `bucketdir`. If you wish to
-    interact with puppet agent's default filebucket, you'll need to set
-    the <--bucketdir> option appropriately when invoking actions.
-  EOT
-
-  file = get_action(:find)
-  file.summary "Retrieve a file from the filebucket."
-  file.arguments "md5/<md5sum>"
-  file.returns <<-'EOT'
-    The file object with the specified checksum.
-
-    RENDERING ISSUES: Rendering as a string returns the contents of the
-    file object; rendering as yaml returns a hash of metadata about said
-    file, including but not limited to its contents. Rendering as json
-    is currently broken, and returns a hash containing only the contents
-    of the file.
-  EOT
-  file.examples <<-'EOT'
-    Retrieve the contents of a file:
-
-    $ puppet file find md5/9aedba7f413c97dc65895b1cd9421f2c --render-as s
-  EOT
-
-  deactivate_action(:search)
-  deactivate_action(:destroy)
-
-  set_indirection_name :file_bucket_file
-
-  # The file face is deprecated
-  deprecate
-end

data/lib/puppet/face/file/download.rb

@@ -1,56 +0,0 @@
-# Download a specified file into the local filebucket.
-Puppet::Face.define(:file, '0.0.1') do
-  action :download do |*args|
-    summary "Download a file into the local filebucket."
-    arguments "( {md5}<checksum> | <puppet_url> )"
-    returns "Nothing."
-    description <<-EOT
-      Downloads a file from the puppet master's filebucket and duplicates it in
-      the local filebucket. This action's checksum syntax differs from `find`'s,
-      and it can accept a <puppet:///> URL.
-    EOT
-    examples <<-'EOT'
-      Download a file by URL:
-
-      $ puppet file download puppet:///modules/editors/vim/.vimrc
-
-      Download a file by MD5 sum:
-
-      $ puppet file download {md5}8f798d4e754db0ac89186bbaeaf0af18
-    EOT
-
-    when_invoked do |sum, options|
-      if sum =~ /^puppet:\/\// # it's a puppet url
-        require 'puppet/file_serving'
-        require 'puppet/file_serving/content'
-        unless content = Puppet::FileServing::Content.indirection.find(sum)
-          raise "Could not find metadata for #{sum}"
-        end
-        pathname = Puppet::FileSystem.pathname(content.full_path())
-        file = Puppet::FileBucket::File.new(pathname)
-      else
-        tester = Puppet::Util::Checksums
-
-        type    = tester.sumtype(sum)
-        sumdata = tester.sumdata(sum)
-
-        key = "#{type}/#{sumdata}"
-
-        Puppet::FileBucket::File.indirection.terminus_class = :file
-        if Puppet::FileBucket::File.indirection.head(key)
-          Puppet.info "Content for '#{sum}' already exists"
-          return
-        end
-
-        Puppet::FileBucket::File.indirection.terminus_class = :rest
-        raise "Could not download content for '#{sum}'" unless file = Puppet::FileBucket::File.indirection.find(key)
-      end
-
-
-      Puppet::FileBucket::File.indirection.terminus_class = :file
-      Puppet.notice "Saved #{sum} to filebucket"
-      Puppet::FileBucket::File.indirection.save file
-      return nil
-    end
-  end
-end

data/lib/puppet/face/file/store.rb

@@ -1,21 +0,0 @@
-# Store a specified file in our filebucket.
-Puppet::Face.define(:file, '0.0.1') do
-  action :store do |*args|
-    summary "Store a file in the local filebucket."
-    arguments "<file>"
-    returns "Nothing."
-    examples <<-EOT
-      Store a file:
-
-      $ puppet file store /root/.bashrc
-    EOT
-
-    when_invoked do |path, options|
-      file = Puppet::FileBucket::File.new(Puppet::FileSystem.pathname(path))
-
-      Puppet::FileBucket::File.indirection.terminus_class = :file
-      Puppet::FileBucket::File.indirection.save file
-      file.checksum
-    end
-  end
-end

data/lib/puppet/face/resource_type.rb

@@ -1,84 +0,0 @@
-require 'puppet/indirector/face'
-
-Puppet::Indirector::Face.define(:resource_type, '0.0.1') do
-  copyright "Puppet Inc.", 2011
-  license   "Apache 2 license; see COPYING"
-
-  summary "View classes, defined resource types, and nodes from all manifests."
-  description <<-'EOT'
-    This subcommand reads information about the resource collections (classes,
-    nodes, and defined types) available in Puppet's site manifest and
-    modules.
-
-    It will eventually be extended to examine native resource types.
-  EOT
-  notes <<-'EOT'
-    The `find` and `search` actions return similar hashes of resource collection
-    info. These hashes will include the following four keys:
-
-    * `file` (a string)
-    * `name` (a string)
-    * `type` (<hostclass>, <definition>, or <node>)
-    * `line` (an integer)
-
-    They may optionally include the following keys:
-
-    * `parent`    (<name_of_resource_collection>)
-    * `arguments` (a hash of parameters and default values)
-    * `doc`       (a string)
-  EOT
-
-  deactivate_action(:save)
-  deactivate_action(:destroy)
-
-  find = get_action(:find)
-  find.summary "Retrieve info about a resource collection."
-  find.arguments "<collection_name>"
-  find.returns <<-'EOT'
-    A hash of info about the requested resource collection. When used from the
-    Ruby API: returns a Puppet::Resource::Type object.
-
-    RENDERING ISSUES: yaml and string output for this indirection are currently
-    unusable; use json instead.
-  EOT
-  find.notes <<-'EOT'
-    If two resource collections share the same name (e.g. you have both a node
-    and a class named "default"), `find` will only return one of them. This can
-    be worked around by using `search` instead.
-  EOT
-  find.examples <<-'EOT'
-    Retrieve info about a specific locally-defined class:
-
-    $ puppet resource_type find ntp::disabled
-
-    Retrieve info from the puppet master about a specific class:
-
-    $ puppet resource_type find ntp --terminus rest
-  EOT
-  # For this face we don't want to default to the certname like other indirector
-  # based faces. Instead we want the user to always supply a argument.
-  find.when_invoked = Proc.new do |key, options|
-    call_indirection_method :find, key, options[:extra]
-  end
-
-  search = get_action(:search)
-  search.summary "Search for collections matching a regular expression."
-  search.arguments "<regular_expression>"
-  search.returns <<-'EOT'
-    An array of hashes of resource collection info. When used from the Ruby API:
-    returns an array of Puppet::Resource::Type objects.
-
-    RENDERING ISSUES: yaml and string output for this indirection are currently
-    unusable; use json instead.
-  EOT
-  search.examples <<-'EOT'
-    Retrieve all classes, nodes, and defined types:
-
-    $ puppet resource_type search '.*'
-
-    Search for classes related to Nagios:
-
-    $ puppet resource_type search nagios
-  EOT
-
-end

data/lib/puppet/feature/cfacter.rb

@@ -1,15 +0,0 @@
-require 'facter'
-require 'puppet/util/feature'
-
-Puppet.features.add :cfacter do
-  Puppet.deprecation_warning("The cfacter setting is deprecated. You can use Facter 3 and higher without this setting.")
-  begin
-    require 'cfacter'
-
-    # The first release of cfacter didn't have the necessary interface to work with Puppet
-    # Therefore, if the version is 0.1.0, treat the feature as not present
-    CFacter.version != '0.1.0'
-  rescue LoadError
-    false
-  end
-end

data/lib/puppet/feature/external_facts.rb

@@ -1,5 +0,0 @@
-require 'facter'
-
-Puppet.features.add(:external_facts) {
-  true
-}

data/lib/puppet/indirector/catalog/static_compiler.rb

@@ -1,232 +0,0 @@
-require 'puppet/node'
-require 'puppet/resource/catalog'
-require 'puppet/indirector/catalog/compiler'
-
-class Puppet::Resource::Catalog::StaticCompiler < Puppet::Resource::Catalog::Compiler
-
-  desc %q{Compiles catalogs on demand using the optional static compiler. This
-    functions similarly to the normal compiler, but it replaces puppet:/// file
-    URLs with explicit metadata and file content hashes, expecting puppet agent
-    to fetch the exact specified content from the filebucket. This guarantees
-    that a given catalog will always result in the same file states. It also
-    decreases catalog application time and fileserver load, at the cost of
-    increased compilation time.
-
-    This terminus works today, but cannot be used without additional
-    configuration. Specifically:
-
-    * You must create a special filebucket resource --- with the title `puppet`
-      and the `path` attribute set to `false` --- in site.pp or somewhere else
-      where it will be added to every node's catalog. Using `puppet` as the title
-      is mandatory; the static compiler treats this title as magical.
-
-          filebucket { puppet:
-            path => false,
-          }
-
-    * You must set `catalog_terminus = static_compiler` in the puppet
-      master's puppet.conf.
-    * The puppet master's auth.conf must allow authenticated nodes to access the
-      `file_bucket_file` endpoint. This is enabled by default (see the
-      `path /file` rule), but if you have made your auth.conf more restrictive,
-      you may need to re-enable it.)
-    * If you are using multiple puppet masters, you must configure load balancer
-      affinity for agent nodes. This is because puppet masters other than the one
-      that compiled a given catalog may not have stored the required file contents
-      in their filebuckets.}
-
-  def find(request)
-    return nil unless catalog = super
-
-    raise "Did not get catalog back" unless catalog.is_a?(model)
-
-    catalog.resources.find_all { |res| res.type == "File" }.each do |resource|
-      next if resource[:ensure] == 'absent'
-
-      next unless source = resource[:source]
-      next unless source =~ /^puppet:/
-
-      file = resource.to_ral
-
-      if file.recurse?
-        add_children(request, catalog, resource, file)
-      else
-        find_and_replace_metadata(request, resource, file)
-      end
-    end
-
-    catalog
-  end
-
-  # Take a resource with a fileserver based file source remove the source
-  # parameter, and insert the file metadata into the resource.
-  #
-  # This method acts to do the fileserver metadata retrieval in advance, while
-  # the file source is local and doesn't require an HTTP request. It retrieves
-  # the file metadata for a given file resource, removes the source parameter
-  # from the resource, inserts the metadata into the file resource, and uploads
-  # the file contents of the source to the file bucket.
-  #
-  # @param request [Puppet::Indirector::Request] The request for the catalog
-  # @param resource [Puppet::Resource] The resource to replace the metadata in
-  # @param file [Puppet::Type::File] The file RAL associated with the resource
-  def find_and_replace_metadata(request, resource, file)
-    # We remove URL info from it, so it forces a local copy
-    # rather than routing through the network.
-    # Weird, but true.
-    newsource = file[:source][0].sub("puppet:///", "")
-    file[:source][0] = newsource
-
-    raise "Could not get metadata for #{resource[:source]}" unless metadata = file.parameter(:source).metadata
-
-    replace_metadata(request, resource, metadata)
-  end
-
-  # Rewrite a given file resource with the metadata from a fileserver based file
-  #
-  # This performs the actual metadata rewrite for the given file resource and
-  # uploads the content of the source file to the filebucket.
-  #
-  # @param request [Puppet::Indirector::Request] The request for the catalog
-  # @param resource [Puppet::Resource] The resource to add the metadata to
-  # @param metadata [Puppet::FileServing::Metadata] The metadata of the given fileserver based file
-  def replace_metadata(request, resource, metadata)
-    [:owner, :group].each do |param|
-      resource[param] ||= metadata.send(param).to_s
-    end
-    resource[:mode] ||= metadata.send(:mode).to_s(8)
-
-    resource[:ensure] = metadata.ftype
-    case resource[:ensure]
-    when 'file'
-      unless resource[:content]
-        resource[:content] = metadata.checksum
-        resource[:checksum] = metadata.checksum_type
-      end
-      store_content(request, resource)
-    when 'link'
-      resource[:target] = metadata.destination
-    end
-
-    old_source = resource.delete(:source)
-    Puppet.info "Metadata for #{resource} in catalog for '#{request.key}' added from '#{old_source}'"
-  end
-
-  # Generate children resources for a recursive file and add them to the catalog.
-  #
-  # @param request [Puppet::Indirector::Request] The request for the catalog
-  # @param catalog [Puppet::Resource::Catalog]
-  # @param resource [Puppet::Resource]
-  # @param file [Puppet::Type::File] The file RAL associated with the resource
-  def add_children(request, catalog, resource, file)
-    children = get_child_resources(request, catalog, resource, file)
-    # get_child_resources() returned early because source is not
-    # a directory, but we still need to replace the metadata of the
-    # resource, so we do it here before returning.
-    if children.nil?
-      find_and_replace_metadata(request, resource, file)
-      return
-    end
-
-    remove_existing_resources(children, catalog)
-
-    children.each do |name, res|
-      catalog.add_resource res
-      catalog.add_edge(resource, res)
-    end
-  end
-
-  # Given a recursive file resource, recursively generate its children resources
-  #
-  # @param request [Puppet::Indirector::Request] The request for the catalog
-  # @param catalog [Puppet::Resource::Catalog]
-  # @param resource [Puppet::Resource]
-  # @param file [Puppet::Type::File] The file RAL associated with the resource
-  #
-  # @return [Array<Puppet::Resource>] The recursively generated File resources for the given resource
-  def get_child_resources(request, catalog, resource, file)
-    sourceselect = file[:sourceselect]
-    children = {}
-
-    source = resource[:source]
-
-    # This is largely a copy of recurse_remote in File
-    total = file[:source].collect do |src|
-      next unless result = file.perform_recursion(src)
-      return if top = result.find { |r| r.relative_path == "." } and top.ftype != "directory"
-      result.each { |data| data.source = "#{src}/#{data.relative_path}" }
-      break result if result and ! result.empty? and sourceselect == :first
-      result
-    end.flatten.compact
-
-    # This only happens if we have sourceselect == :all
-    unless sourceselect == :first
-      found = []
-      total.reject! do |data|
-        result = found.include?(data.relative_path)
-        found << data.relative_path unless found.include?(data.relative_path)
-        result
-      end
-    end
-
-    parent_meta = nil
-    total.each do |meta|
-      # This is the top-level parent directory
-      if meta.relative_path == "."
-        parent_meta = meta
-        next
-      end
-      child = children[meta.relative_path] ||=
-        Puppet::Resource.new(:file, File.join(file[:path], meta.relative_path))
-
-      # I think this is safe since it's a URL, not an actual file
-      child[:source] = source + "/" + meta.relative_path
-      resource.each do |param, value|
-        # These should never be passed to our children.
-        unless [:parent, :ensure, :recurse, :recurselimit, :target, :alias, :source].include? param
-          child[param] = value
-        end
-      end
-      replace_metadata(request, child, meta)
-    end
-    replace_metadata(request, resource, parent_meta)
-
-    children
-  end
-
-  # Remove any recursed file resources already in the catalog
-  #
-  # @param children [Array<Puppet::Resource>]
-  # @param catalog [Puppet::Resource::Catalog]
-  def remove_existing_resources(children, catalog)
-    relative_paths = children.keys
-    relative_paths.each do |relative_path|
-      child = children[relative_path]
-      if catalog.resource(child.ref)
-        Puppet.debug("Resource #{child.ref} already managed, removing from recursed children")
-        children.delete(relative_path)
-      end
-    end
-  end
-
-  # Retrieve the source of a file resource using a fileserver based source and
-  # upload it to the filebucket.
-  #
-  # @param request [Puppet::Indirector::Request] The request for the catalog
-  # @param resource [Puppet::Resource]
-  def store_content(request, resource)
-    @summer ||= Puppet::Util::Checksums
-
-    type = @summer.sumtype(resource[:content])
-    sum = @summer.sumdata(resource[:content])
-
-    if Puppet::FileBucket::File.indirection.find("#{type}/#{sum}")
-      Puppet.info "Content for '#{resource[:source]}' already exists"
-    else
-      Puppet.info "Storing content for source '#{resource[:source]}'"
-      content = Puppet::FileServing::Content.indirection.find(resource[:source], {:environment => request.environment})
-      file = Puppet::FileBucket::File.new(content.content)
-      Puppet::FileBucket::File.indirection.save(file)
-    end
-  end
-end