puppet 6.25.1-universal-darwin → 7.0.0-universal-darwin

data/lib/puppet/parser/environment_compiler.rb

@@ -1,202 +0,0 @@
-require 'puppet/parser/compiler'
-
-# @deprecated application orchestration will be removed in puppet 7
-class Puppet::Parser::EnvironmentCompiler < Puppet::Parser::Compiler
-  def self.compile(env, code_id=nil)
-    begin
-      env.check_for_reparse
-
-      node = Puppet::Node.new(env)
-      node.environment = env
-      new(node, :code_id => code_id).compile
-    rescue => detail
-      message = _("%{detail} in environment %{env}") % { detail: detail, env: env.name }
-      Puppet.log_exception(detail, message)
-      raise Puppet::Error, message, detail.backtrace
-    end
-  end
-
-  def initialize(node, options = {})
-    super(node, **options)
-    @overridden_functions = {}
-  end
-
-  def add_function_overrides
-    add_function_override('hiera_include', proc { Puppet.debug "Ignoring hiera_include() during environment catalog compilation" })
-  end
-
-  def add_function_override(func_name, override)
-    typed_name = Puppet::Pops::Loader::TypedName.new(:function, func_name)
-    loader = loaders.puppet_system_loader
-
-    # Remove and preserve existing entry. A `nil` is also preserved to indicate
-    # an override that didn't replace a loaded function.
-    entry = loader.get_entry(typed_name)
-    existing = entry.nil? ? nil : entry.value
-    loader.remove_entry(typed_name) unless existing.nil?
-    @overridden_functions[typed_name] = existing
-
-    # Add the override to the loader
-    loader.set_entry(typed_name, override)
-  end
-
-  def remove_function_overrides
-    loader = loaders.puppet_system_loader
-    @overridden_functions.each_pair do |typed_name, overridden|
-      loader.remove_entry(typed_name)
-      loader.set_entry(typed_name, overridden) unless overridden.nil?
-    end
-  end
-
-  def add_catalog_validators
-    super
-    add_catalog_validator(CatalogValidator::SiteValidator)
-    add_catalog_validator(CatalogValidator::EnvironmentRelationshipValidator)
-  end
-
-  def compile
-    Puppet.deprecation_warning("Application orchestration is deprecated. See https://puppet.com/docs/puppet/5.5/deprecated_language.html")
-
-    add_function_overrides
-    begin
-      Puppet.override(@context_overrides, _("For compiling environment catalog %{env}") % { env: environment.name }) do
-        @catalog.environment_instance = environment
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Created settings scope"), [:compiler, :create_settings_scope]) { create_settings_scope }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated main"), [:compiler, :evaluate_main]) { evaluate_main }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated site"), [:compiler, :evaluate_site]) { evaluate_site }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Evaluated application instances"), [:compiler, :evaluate_applications]) { evaluate_applications }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Prune"), [:compiler, :prune_catalog]) { prune_catalog }
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog pre-finish"), [:compiler, :validate_pre_finish]) do
-          validate_catalog(CatalogValidator::PRE_FINISH)
-        end
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Finished catalog"), [:compiler, :finish_catalog]) { finish }
-
-        fail_on_unevaluated
-
-        Puppet::Util::Profiler.profile(_("Env Compile: Validate Catalog final"), [:compiler, :validate_final]) do
-          validate_catalog(CatalogValidator::FINAL)
-        end
-
-        if block_given?
-          yield @catalog
-        else
-          @catalog
-        end
-      end
-    ensure
-      remove_function_overrides
-    end
-  end
-
-  # @api private
-  def prune_catalog
-    prune_env_catalog
-  end
-
-  # Prunes the catalog by dropping all resources that are not contained under the Site (if a site expression is used).
-  # As a consequence all edges to/from dropped resources are also dropped.
-  # Once the pruning is performed, this compiler returns the pruned list when calling the #resources method.
-  # The pruning does not alter the order of resources in the resources list.
-  #
-  def prune_env_catalog
-    # Everything under Class[main], that is not under (inclusive of) Site[site] should be pruned as those resources
-    # are intended for nodes in a node catalog.
-    #
-    the_main_class_resource = @catalog.resource('Class', '')
-    the_site_resource = @catalog.resource('Site', 'site')
-
-    # Get downstream vertexes returns a hash where the keys are the resources and values nesting level
-    rooted_in_main = @catalog.downstream_from_vertex(the_main_class_resource).keys
-
-    to_be_removed =
-    if the_site_resource
-      keep_from_site = @catalog.downstream_from_vertex(the_site_resource).keys
-      keep_from_site << the_site_resource
-      rooted_in_main - keep_from_site
-    else
-      rooted_in_main
-    end
-
-    @catalog.remove_resource(*to_be_removed)
-    # The compiler keeps a list of added resources, this shadows that list with the now pruned result
-    @pruned_resources = @catalog.resources
-  end
-
-  def add_resource(scope, resource)
-    @resources << resource
-    @catalog.add_resource(resource)
-
-    if !resource.class? && resource[:stage]
-      raise ArgumentError, _("Only classes can set 'stage'; normal resources like %{resource} cannot change run stage") % { resource: resource }
-    end
-
-    # Stages should not be inside of classes.  They are always a
-    # top-level container, regardless of where they appear in the
-    # manifest.
-    return if resource.stage?
-
-    # This adds a resource to the class it lexically appears in in the
-    # manifest.
-    unless resource.class?
-      @catalog.add_edge(scope.resource, resource)
-    end
-    resource.mark_unevaluated_consumer if is_capability_consumer?(resource)
-    assert_app_in_site(scope, resource)
-  end
-
-  def evaluate_ast_node()
-    # Do nothing, the environment catalog is not built for a particular node.
-  end
-
-  def on_empty_site
-    Puppet.warning(_("Environment Compiler: Could not find a site definition to evaluate"))
-  end
-
-  def evaluate_applications
-    exceptwrap do
-      resources.select { |resource| type = resource.resource_type; type.is_a?(Puppet::Resource::Type) && type.application? }.each do |resource|
-        Puppet::Util::Profiler.profile(_("Evaluated application %{resource}") % { resource: resource }, [:compiler, :evaluate_resource, resource]) do
-          resource.evaluate
-        end
-      end
-    end
-  end
-
-  def evaluate_classes(titles, scope, lazy)
-    # Always lazy in an Environment compilation
-    super(titles, scope, true)
-  end
-
-  # Overrides the regular compiler to be able to return the list of resources after a prune
-  # has taken place in the graph representation. Before a prune, the list is the same as in the regular
-  # compiler
-  #
-  def resources
-    @pruned_resources || super
-  end
-
-  def is_capability?(value)
-    if value.is_a?(Array)
-      value.find { |ev| is_capability?(ev) }
-    elsif value.is_a?(Puppet::Resource)
-      rstype = value.resource_type
-      rstype.nil? ? false : rstype.is_capability?
-    else
-      false
-    end
-  end
-  private :is_capability?
-
-  def is_capability_consumer?(resource)
-    resource.eachparam { |param| return true if (param.name == :consume || param.name == :require) && is_capability?(param.value) }
-    false
-  end
-  private :is_capability_consumer?
-end

data/lib/puppet/pops/types/enumeration.rb

@@ -1,16 +0,0 @@
-# The Enumeration class provides default Enumerable::Enumerator creation for Puppet Programming Language
-# runtime objects that supports the concept of enumeration.
-#
-module Puppet::Pops::Types
-  class Enumeration
-    def self.enumerator(o)
-      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
-      Iterable.on(o)
-    end
-
-    def enumerator(o)
-      Puppet.deprecation_warning(_('Enumeration.enumerator is deprecated. Use Iterable.on instead'))
-      Iterable.on(o)
-    end
-  end
-end

data/lib/puppet/resource/capability_finder.rb

@@ -1,154 +0,0 @@
-#
-# A helper module to look a capability up from PuppetDB
-#
-# @todo lutter 2015-03-10: determine whether this should be based on
-# Puppet::Pops::Evaluator::Collectors, or at least use
-# Puppet::Util::Puppetdb::Http
-
-require 'net/http'
-require 'cgi'
-require 'puppet/util/json'
-
-# @api private
-module Puppet::Resource::CapabilityFinder
-
-  # Looks up a capability resource from PuppetDB. Capability resources are
-  # required to be unique per environment and code id. If multiple copies of a
-  # capability resource are found, the one matching the current code id is
-  # used.
-  #
-  # @param environment [String] environment name
-  # @param code_id [String,nil] code_id of the catalog
-  # @param cap [Puppet::Resource] the capability resource type instance
-  # @return [Puppet::Resource,nil] The found capability resource or `nil` if it could not be found
-  def self.find(environment, code_id, cap)
-    unless Puppet::Util.const_defined?('Puppetdb')
-      #TRANSLATOR PuppetDB is a product name and should not be translated
-      raise Puppet::DevError, _('PuppetDB is not available')
-    end
-
-    resources = search(nil, nil, cap)
-
-    if resources.size > 1
-      Puppet.debug "Found multiple resources when looking up capability #{cap}, filtering by environment #{environment}"
-      resources = resources.select { |r| r['tags'].any? { |t| t == "producer:#{environment}" } }
-    end
-
-    if resources.empty?
-      Puppet.debug "Could not find capability resource #{cap} in PuppetDB"
-    elsif resources.size == 1
-      resource_hash = resources.first
-    else
-      code_id_resource = disambiguate_by_code_id(environment, code_id, cap)
-      if code_id_resource
-        resource_hash = code_id_resource
-      else
-        #TRANSLATOR PuppetDB is a product name and should not be translated
-        message = _("Unexpected response from PuppetDB when looking up %{capability}:") % { capability: cap }
-        message += "\n" + _("expected exactly one resource but got %{count};") % { count: resources.size }
-        message += "\n" + _("returned data is:\n%{resources}") % { resources: resources.inspect }
-        raise Puppet::DevError, message
-      end
-    end
-
-    if resource_hash
-      resource_hash['type'] = cap.resource_type
-      instantiate_resource(resource_hash)
-    end
-  end
-
-  def self.search(environment, code_id, cap)
-    query_terms = [
-      'and',
-      ['=', 'type', cap.type.capitalize],
-      ['=', 'title', cap.title.to_s],
-    ]
-
-    if environment.nil?
-      query_terms << ['~', 'tag', "^producer:"]
-    else
-      query_terms << ['=', 'tag', "producer:#{environment}"]
-    end
-
-    unless code_id.nil?
-      query_terms << ['in', 'certname',
-        ['extract', 'certname',
-          ['select_catalogs',
-            ['=', 'code_id', code_id]]]]
-    end
-
-    #TRANSLATOR PuppetDB is a product name and should not be translated
-    Puppet.notice _("Looking up capability %{capability} in PuppetDB: %{query_terms}") % { capability: cap, query_terms: query_terms }
-
-    query_puppetdb(query_terms)
-  end
-
-  def self.query_puppetdb(query)
-    begin
-      # If using PuppetDB >= 4, use the API method query_puppetdb()
-      result = if Puppet::Util::Puppetdb.respond_to?(:query_puppetdb)
-        # PuppetDB 4 uses a unified query endpoint, so we have to specify what we're querying
-        Puppet::Util::Puppetdb.query_puppetdb(["from", "resources", query])
-      # For PuppetDB < 4, use the old internal method action()
-      else
-        url = "/pdb/query/v4/resource?query=#{Puppet::Util.uri_query_encode(query.to_json)}"
-        response = Puppet::Util::Puppetdb::Http.action(url) do |conn, uri|
-          conn.get(uri, { 'Accept' => 'application/json'})
-        end
-        Puppet::Util::Json.load(response.body)
-      end
-
-      # The format of the response body is documented at
-      #   https://puppet.com/docs/puppetdb/3.0/api/query/v4/resources.html#response-format
-      unless result.is_a?(Array)
-        #TRANSLATOR PuppetDB is a product name and should not be translated
-        raise Puppet::DevError, _("Unexpected response from PuppetDB when looking up %{capability}: expected an Array but got %{result}") %
-            { capability: cap, result: result.inspect }
-      end
-
-      result
-    rescue Puppet::Util::Json::ParseError => e
-      #TRANSLATOR PuppetDB is a product name and should not be translated
-      raise Puppet::DevError, _("Invalid JSON from PuppetDB when looking up %{capability}\n%{detail}") % { capability: cap, detail: e }
-    end
-  end
-
-  # Find a distinct copy of the given capability resource by searching for only
-  # resources matching the given code_id. Returns `nil` if no code_id is
-  # supplied or if there isn't exactly one matching resource.
-  #
-  # @param environment [String] environment name
-  # @param code_id [String,nil] code_id of the catalog
-  # @param cap [Puppet::Resource] the capability resource type instance
-  def self.disambiguate_by_code_id(environment, code_id, cap)
-    if code_id
-      Puppet.debug "Found multiple resources when looking up capability #{cap}, filtering by code id #{code_id}"
-      resources = search(environment, code_id, cap)
-
-      if resources.size > 1
-        Puppet.debug "Found multiple resources matching code id #{code_id} when looking up #{cap}"
-        nil
-      else
-        resources.first
-      end
-    end
-  end
-  private_class_method :disambiguate_by_code_id
-
-  def self.instantiate_resource(resource_hash)
-    real_type = resource_hash['type']
-    resource = Puppet::Resource.new(real_type, resource_hash['title'])
-    real_type.parameters.each do |param|
-      param = param.to_s
-      next if param == 'name'
-      value = resource_hash['parameters'][param]
-      if value
-        resource[param] = value
-      else
-        Puppet.debug "No capability value for #{resource}->#{param}"
-      end
-    end
-    return resource
-  end
-  private_class_method :instantiate_resource
-end

data/lib/puppet/rest/errors.rb

@@ -1,15 +0,0 @@
-# @deprecated Use {Puppet::HTTP::Client} instead.
-module Puppet::Rest
-  class ResponseError < Puppet::Error
-    attr_reader :response
-
-    # Error thrown when request status is not OK.
-    # @param [String] msg the error message
-    # @param [Puppet::Rest::Response] response the response from the failed
-    #                                 request
-    def initialize(msg, response = nil)
-      super(msg)
-      @response = response
-    end
-  end
-end

data/lib/puppet/rest/response.rb

@@ -1,35 +0,0 @@
-# @deprecated Use {Puppet::HTTP::Client} instead.
-module Puppet::Rest
-  # This is a wrapper for the HTTP::Message class of the HTTPClient
-  # gem. It is designed to wrap a message sent as an HTTP response.
-  class Response
-    def initialize(message)
-      @message = message
-    end
-
-    def body
-      @message.body
-    end
-
-    def content_type
-      @message.content_type
-    end
-
-    def content_encoding
-      @message.headers['Content-Encoding']
-    end
-
-    def status_code
-      @message.status
-    end
-
-    def ok?
-      @message.ok?
-    end
-
-    def to_exception
-      message = _("Error %{code} on SERVER: %{returned_message}") % { code: status_code, returned_message: body }
-      Puppet::Rest::ResponseError.new(message, self)
-    end
-  end
-end

data/lib/puppet/rest/route.rb

@@ -1,85 +0,0 @@
-require 'uri'
-require 'puppet/util/connection'
-
-# @deprecated Use {Puppet::HTTP::Client} instead.
-module Puppet::Rest
-  class Route
-    attr_reader :server
-
-    # Create a Route containing information for querying the given API,
-    # hosted at a server determined either by SRV service or by the
-    # fallback server on the fallback port.
-    # @param [String] api the path leading to the root of the API. Must
-    #                 contain a trailing slash for proper endpoint path
-    #                 construction
-    # @param [Symbol] server_setting the setting to check for special
-    #                 server configuration
-    # @param [Symbol] port_setting the setting to check for special
-    #                  port configuration
-    # @param [Symbol] srv_service the name of the service when using SRV
-    #                 records
-    def initialize(api:, server_setting: :server, port_setting: :serverport, srv_service: :puppet)
-      @api = api
-      @default_server = Puppet::Util::Connection.determine_server(server_setting)
-      @default_port = Puppet::Util::Connection.determine_port(port_setting, server_setting)
-      @srv_service = srv_service
-    end
-
-    # Select a server and port to create a base URL for the API specified by this
-    # route. If the connection fails and SRV records are in use, the next suitable
-    # server will be tried. If SRV records are not in use or no successful connection
-    # could be made, fall back to the configured server and port for this API, taking
-    # into account failover settings.
-    # @parma [Puppet::Network::Resolver] dns_resolver the DNS resolver to use to check
-    #                                    SRV records
-    # @yield [URI] supply a base URL to make a request with
-    # @raise [Puppet::Error] if connection to selected server and port fails, and SRV
-    #                        records are not in use
-    def with_base_url(dns_resolver)
-      if @server && @port
-        # First try connecting to the previously selected server and port.
-        begin
-          return yield(base_url)
-        rescue SystemCallError => e
-          if Puppet[:use_srv_records]
-            Puppet.debug "Connection to cached server and port #{@server}:#{@port} failed, reselecting."
-          else
-            raise Puppet::Error, _("Connection to cached server and port %{server}:%{port} failed: %{message}") %
-              { server: @server, port: @port, message: e.message }
-          end
-        end
-      end
-
-      if Puppet[:use_srv_records]
-        dns_resolver.each_srv_record(Puppet[:srv_domain], @srv_service) do |srv_server, srv_port|
-          # Try each of the servers for this service in weighted order
-          # until a working one is found.
-          begin
-            @server = srv_server
-            @port = srv_port
-            return yield(base_url)
-          rescue SystemCallError
-            Puppet.debug "Connection to selected server and port #{@server}:#{@port} failed. Trying next cached SRV record."
-            @server = nil
-            @port = nil
-          end
-        end
-      end
-
-      # If not using SRV records, fall back to the defaults calculated above
-      @server = @default_server
-      @port = @default_port
-
-      Puppet.debug "No more servers in SRV record, falling back to #{@server}:#{@port}" if Puppet[:use_srv_records]
-      return yield(base_url)
-    end
-
-    private
-
-    # Returns a URI built from the information stored by this route,
-    # e.g. 'https://myserver.com:555/myapi/v1/'
-    def base_url
-      URI::HTTPS.build(host: @server, port: @port, path: @api)
-    end
-  end
-end

data/lib/puppet/rest/routes.rb

@@ -1,135 +0,0 @@
-require 'time'
-require 'puppet/rest/route'
-require 'puppet/network/http_pool'
-require 'puppet/network/http/compression'
-
-# @deprecated Use {Puppet::HTTP::Client} instead.
-module Puppet::Rest
-  module Routes
-    extend Puppet::Network::HTTP::Compression.module
-
-    ACCEPT_ENCODING = 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'
-
-    def self.ca
-      Puppet.deprecation_warning("Puppet::Rest::Routes is deprecated, use Puppet::HTTP::Client instead")
-
-      @ca ||= Route.new(api: '/puppet-ca/v1/',
-                        server_setting: :ca_server,
-                        port_setting: :ca_port,
-                        srv_service: :ca)
-    end
-
-    def self.clear
-      @ca = nil
-    end
-
-    # Make an HTTP request to fetch the named certificate.
-    #
-    # @param name [String] the name of the certificate to fetch
-    # @param ssl_context [Puppet::SSL::SSLContext] the ssl content to use when making the request
-    # @raise [Puppet::Rest::ResponseError] if the response status is not OK
-    # @return [String] the PEM-encoded certificate or certificate bundle
-    def self.get_certificate(name, ssl_context)
-      ca.with_base_url(Puppet::Network::Resolver.new) do |url|
-        header = { 'Accept' => 'text/plain', 'Accept-Encoding' => ACCEPT_ENCODING }
-        url.path += "certificate/#{name}"
-
-        use_ssl = url.is_a? URI::HTTPS
-
-        client = Puppet::Network::HttpPool.connection(url.host, url.port, use_ssl: use_ssl, ssl_context: ssl_context)
-
-        response = client.get(url.request_uri, header)
-        unless response.code.to_i == 200
-          raise Puppet::Rest::ResponseError.new(response.message, response)
-        end
-
-        Puppet.info _("Downloaded certificate for %{name} from %{server}") % { name: name, server: ca.server }
-
-        uncompress_body(response)
-      end
-    end
-
-    # Make an HTTP request to fetch the named crl.
-    #
-    # @param name [String] name of the crl to fetch
-    # @param ssl_context [Puppet::SSL::SSLContext] the ssl content to use when making the request
-    # @param if_modified_since [Time, nil] If non-nil, then only download the CRL if it has been
-    #   modified since the specified time.
-    # @raise [Puppet::Rest::ResponseError] if the response status is not OK
-    # @return [String] the PEM-encoded crl
-    def self.get_crls(name, ssl_context, if_modified_since: nil)
-      ca.with_base_url(Puppet::Network::Resolver.new) do |url|
-        header = { 'Accept' => 'text/plain', 'Accept-Encoding' => ACCEPT_ENCODING }
-        header['If-Modified-Since'] = if_modified_since.httpdate if if_modified_since
-
-        url.path += "certificate_revocation_list/#{name}"
-
-        use_ssl = url.is_a? URI::HTTPS
-
-        client = Puppet::Network::HttpPool.connection(url.host, url.port, use_ssl: use_ssl, ssl_context: ssl_context)
-
-        response = client.get(url.request_uri, header)
-        unless response.code.to_i == 200
-          raise Puppet::Rest::ResponseError.new(response.message, response)
-        end
-
-        Puppet.info _("Downloaded certificate revocation list for %{name} from %{server}") % { name: name, server: ca.server }
-
-        uncompress_body(response)
-      end
-    end
-
-    # Make an HTTP request to send the named CSR.
-    #
-    # @param csr_pem [String] the contents of the CSR to sent to the CA
-    # @param name [String] the name of the host whose CSR is being submitted
-    # @param ssl_context [Puppet::SSL::SSLContext] the ssl content to use when making the request
-    # @raise [Puppet::Rest::ResponseError] if the response status is not OK
-    def self.put_certificate_request(csr_pem, name, ssl_context)
-      ca.with_base_url(Puppet::Network::Resolver.new) do |url|
-        header = { 'Accept' => 'text/plain',
-                   'Accept-Encoding' => ACCEPT_ENCODING,
-                   'Content-Type' => 'text/plain' }
-        url.path += "certificate_request/#{name}"
-
-        use_ssl = url.is_a? URI::HTTPS
-
-        client = Puppet::Network::HttpPool.connection(url.host, url.port, use_ssl: use_ssl, ssl_context: ssl_context)
-
-        response = client.put(url.request_uri, csr_pem, header)
-        if response.code.to_i == 200
-          Puppet.debug "Submitted certificate request to server."
-        else
-          raise Puppet::Rest::ResponseError.new(response.message, response)
-        end
-      end
-    end
-
-    # Make an HTTP request to get the named CSR.
-    #
-    # @param name [String] the name of the host whose CSR is being queried
-    # @param ssl_context [Puppet::SSL::SSLContext] the ssl content to use when making the request
-    # @raise [Puppet::Rest::ResponseError] if the response status is not OK
-    # @return [String] the PEM encoded certificate request
-    # @deprecated
-    def self.get_certificate_request(name, ssl_context)
-      ca.with_base_url(Puppet::Network::Resolver.new) do |url|
-        header = { 'Accept' => 'text/plain', 'Accept-Encoding' => ACCEPT_ENCODING }
-        url.path += "certificate_request/#{name}"
-
-        use_ssl = url.is_a? URI::HTTPS
-
-        client = Puppet::Network::HttpPool.connection(url.host, url.port, use_ssl: use_ssl, ssl_context: ssl_context)
-
-        response = client.get(url.request_uri, header)
-        unless response.code.to_i == 200
-          raise Puppet::Rest::ResponseError.new(response.message, response)
-        end
-
-        Puppet.debug _("Downloaded existing certificate request for %{name} from %{server}") % { name: name, server: ca.server }
-
-        uncompress_body(response)
-      end
-    end
-  end
-end

data/lib/puppet/settings/alias_setting.rb

@@ -1,37 +0,0 @@
-class Puppet::Settings::AliasSetting
-  attr_reader :name, :alias_name
-
-  def initialize(args = {})
-    @name = args[:name]
-    @alias_name = args[:alias_for]
-    @alias_for = Puppet.settings.setting(alias_name)
-  end
-
-  def optparse_args
-    args = @alias_for.optparse_args
-    args[0].gsub!(alias_name.to_s, name.to_s)
-    args
-  end
-
-  def getopt_args
-    args = @alias_for.getopt_args
-    args[0].gsub!(alias_name.to_s, name.to_s)
-    args
-  end
-
-  def type
-    :alias
-  end
-
-  def method_missing(method, *args)
-    begin
-      alias_for.send(method, *args)
-    rescue => e
-      Puppet.log_exception(self.class, e.message)
-    end
-  end
-
-  private
-
-  attr_reader :alias_for
-end