puppet 5.3.4 → 6.29.0

data/lib/puppet/indirector/rest.rb

@@ -1,6 +1,7 @@
 require 'net/http'
 require 'uri'
-require 'json'
+require 'puppet/util/json'
+require 'puppet/util/connection'
 require 'semantic_puppet'
 
 require 'puppet/network/http'
@@ -39,68 +40,23 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     @srv_service || :puppet
   end
 
-  # The logic for server and port is kind of gross. In summary:
-  # IF an endpoint-specific setting is requested AND that setting has been set by the user
-  #    Use that setting.
-  #         The defaults for these settings are the "normal" server/masterport settings, so
-  #         when they are unset we instead want to "fall back" to the failover-selected
-  #         host/port pair.
-  # ELSE IF we have a failover-selected host/port
-  #    Use what the failover logic came up with
-  # ELSE IF the server_list setting is in use
-  #    Use the first entry - failover hasn't happened yet, but that
-  #    setting is still authoritative
-  # ELSE
-  #    Go for the legacy server/masterport settings, and hope for the best
+  # Select the server to use based on the settings configuration
+  # for this indirection, taking into account the HA server list.
   def self.server
-    setting = server_setting()
-    if setting && setting != :server && Puppet.settings.set_by_config?(setting)
-      Puppet.settings[setting]
-    else
-      begin
-        Puppet.lookup(:server)
-      rescue
-        if primary_server = Puppet.settings[:server_list][0]
-          Puppet.debug "Dynamically-bound server lookup failed; using first entry"
-          primary_server[0]
-        else
-          setting ||= :server
-          Puppet.debug "Dynamically-bound server lookup failed, falling back to #{setting} setting"
-          Puppet.settings[setting]
-        end
-      end
-    end
+    Puppet::Util::Connection.determine_server(server_setting)
   end
 
-  # For port there's a little bit of an extra snag: setting a specific
-  # server setting and relying on the default port for that server is
-  # common, so we also want to check if the assocaited SERVER setting
-  # has been set by the user. If either of those are set we ignore the
-  # failover-selected port.
+  # Select the port to use based on the settings configuration
+  # for this indirection, taking into account the HA server list.
   def self.port
-    setting = port_setting()
-    srv_setting = server_setting()
-    if (setting && setting != :masterport && Puppet.settings.set_by_config?(setting)) ||
-       (srv_setting && srv_setting != :server && Puppet.settings.set_by_config?(srv_setting))
-      Puppet.settings[setting].to_i
-    else
-      begin
-        Puppet.lookup(:serverport).to_i
-      rescue
-        if primary_server = Puppet.settings[:server_list][0]
-          Puppet.debug "Dynamically-bound port lookup failed; using first entry"
-
-          # Port might not be set, so we want to fallback in that
-          # case. We know we don't need to use `setting` here, since
-          # the default value of every port setting is `masterport`
-          (primary_server[1] || Puppet.settings[:masterport]).to_i
-        else
-          setting ||= :masterport
-          Puppet.debug "Dynamically-bound port lookup failed; falling back to #{setting} setting"
-          Puppet.settings[setting].to_i
-        end
-      end
-    end
+    Puppet::Util::Connection.determine_port(port_setting, server_setting)
+  end
+
+  # Should we use puppet's http client to make requests. Will return
+  # false when running in puppetserver
+  def use_http_client?
+    Puppet::Network::HttpPool.http_client_class == Puppet::Network::HTTP::Connection ||
+      Puppet::Network::HttpPool.http_client_class == Puppet::Network::HTTP::ConnectionAdapter
   end
 
   # Provide appropriate headers.
@@ -124,8 +80,10 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def network(request)
-    Puppet::Network::HttpPool.http_instance(request.server || self.class.server,
-                                            request.port || self.class.port)
+    ssl_context = Puppet.lookup(:ssl_context)
+    Puppet::Network::HttpPool.connection(request.server || self.class.server,
+                                         request.port || self.class.port,
+                                         ssl_context: ssl_context)
   end
 
   def http_get(request, path, headers = nil, *args)
@@ -154,6 +112,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def find(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#find is deprecated. Use Puppet::HTTP::Client instead."))
     uri, body = IndirectedRoutes.request_to_uri_and_body(request)
     uri_with_query_string = "#{uri}?#{body}"
 
@@ -183,7 +142,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
       # While this way of handling the issue is not perfect, there is at least an error
       # that makes a user aware of the reason for the failure.
       #
-      content_type, body = parse_response(response)
+      _, body = parse_response(response)
       msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(uri_with_query_string, 100), body: body }
       raise Puppet::Error, msg
     else
@@ -192,6 +151,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def head(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#head is deprecated. Use Puppet::HTTP::Client instead."))
     response = do_request(request) do |req|
       http_head(req, IndirectedRoutes.request_to_uri(req), headers)
     end
@@ -204,6 +164,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def search(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#search is deprecated. Use Puppet::HTTP::Client instead."))
     response = do_request(request) do |req|
       http_get(req, IndirectedRoutes.request_to_uri(req), headers)
     end
@@ -217,6 +178,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def destroy(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#destroy is deprecated. Use Puppet::HTTP::Client instead."))
     raise ArgumentError, _("DELETE does not accept options") unless request.options.empty?
 
     response = do_request(request) do |req|
@@ -232,6 +194,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   end
 
   def save(request)
+    Puppet.deprecation_warning(_("Puppet::Indirector::Rest#save is deprecated. Use Puppet::HTTP::Client instead."))
     raise ArgumentError, _("PUT does not accept options") unless request.options.empty?
 
     response = do_request(request) do |req|
@@ -263,7 +226,9 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   def handle_response(request, response)
     server_version = response[Puppet::Network::HTTP::HEADER_PUPPET_VERSION]
     if server_version
-      Puppet.push_context({:server_agent_version => server_version})
+      Puppet.lookup(:server_agent_version) do
+        Puppet.push_context(:server_agent_version => server_version)
+      end
       if SemanticPuppet::Version.parse(server_version).major < MAJOR_VERSION_JSON_DEFAULT &&
           Puppet[:preferred_serialization_format] != 'pson'
         #TRANSLATORS "PSON" should not be translated
@@ -301,7 +266,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
     elsif response['content-type'].is_a?(String)
       content_type, body = parse_response(response)
       if content_type =~ /[pj]son/
-        returned_message = JSON.parse(body)["message"]
+        returned_message = Puppet::Util::Json.load(body)["message"]
       else
         returned_message = uncompress_body(response)
       end
@@ -318,8 +283,7 @@ class Puppet::Indirector::REST < Puppet::Indirector::Terminus
   # uncompress_body)
   def parse_response(response)
     if response['content-type']
-      [ response['content-type'].gsub(/\s*;.*$/,''),
-        body = uncompress_body(response) ]
+      [ response['content-type'].gsub(/\s*;.*$/,''), uncompress_body(response) ]
     else
       raise _("No content type in http response; cannot parse")
     end

data/lib/puppet/indirector/ssl_file.rb

@@ -12,13 +12,8 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     @file_setting = setting
   end
 
-  # Specify where a specific ca file should be stored.
-  def self.store_ca_at(setting)
-    @ca_setting = setting
-  end
-
   class << self
-    attr_reader :directory_setting, :file_setting, :ca_setting
+    attr_reader :directory_setting, :file_setting
   end
 
   # The full path to where we should store our files.
@@ -33,19 +28,6 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     Puppet.settings[file_setting]
   end
 
-  # The full path to a ca file we would be managing.
-  def self.ca_location
-    return nil unless ca_setting
-    Puppet.settings[ca_setting]
-  end
-
-  # We assume that all files named 'ca' are pointing to individual ca files,
-  # rather than normal host files.  It's a bit hackish, but all the other
-  # solutions seemed even more hackish.
-  def ca?(name)
-    name == Puppet::SSL::Host.ca_name
-  end
-
   def initialize
     Puppet.settings.use(:main, :ssl)
 
@@ -58,9 +40,7 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    if ca?(name) and ca_location
-      ca_location
-    elsif collection_directory
+    if collection_directory
       File.join(collection_directory, name.to_s + ".pem")
     else
       file_location
@@ -127,10 +107,6 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     self.class.file_location
   end
 
-  def ca_location
-    self.class.ca_location
-  end
-
   # A hack method to deal with files that exist with a different case.
   # Just renames it; doesn't read it in or anything.
   # LAK:NOTE This is a copy of the method in sslcertificates/support.rb,
@@ -163,34 +139,19 @@ class Puppet::Indirector::SslFile < Puppet::Indirector::Terminus
     # All types serialized to disk contain only ASCII content:
     # * SSL::Key may be a .export(OpenSSL::Cipher::DES.new(:EDE3, :CBC), pass) or .to_pem
     # * All other classes are translated to strings by calling .to_pem
-
-    # Serialization of:
-    # Puppet::SSL::Certificate by Puppet::SSL::Certificate::Ca, Puppet::SSL::Certificate::File
-    # -----BEGIN CERTIFICATE-----
-    # Puppet::SSL::Key by Puppet::SSL::Key::Ca, Puppet::SSL::Key::File
-    # -----BEGIN RSA PRIVATE KEY-----
-    if ca?(name) and ca_location
-      Puppet.settings.setting(self.class.ca_setting).open('w:ASCII') { |f| yield f }
-    # Serialization of:
-    # Puppet::SSL::CertificateRevocationList by Puppet::SSL::CertificateRevocationList::Ca, Puppet::SSL::CertificateRevocationList::File
-    # -----BEGIN X509 CRL-----
-    elsif file_location
+    if file_location
       Puppet.settings.setting(self.class.file_setting).open('w:ASCII') { |f| yield f }
-    # Serialization of:
-    # Puppet::SSL::Certificate by Puppet::SSL::Certificate::Ca, Puppet::SSL::Certificate::File
-    # -----BEGIN CERTIFICATE-----
-    # Puppet::SSL::CertificateRequest by Puppet::SSL::CertificateRequest::Ca, Puppet::SSL::CertificateRequest::File
-    # -----BEGIN CERTIFICATE REQUEST-----
-    # Puppet::SSL::Key by Puppet::SSL::Key::Ca, Puppet::SSL::Key::File
-    # -----BEGIN RSA PRIVATE KEY-----
-    elsif setting = self.class.directory_setting
-      begin
-        Puppet.settings.setting(setting).open_file(path, 'w:ASCII') { |f| yield f }
-      rescue => detail
-        raise Puppet::Error, _("Could not write %{path} to %{setting}: %{detail}") % { path: path, setting: setting, detail: detail }, detail.backtrace
-      end
     else
-      raise Puppet::DevError, _("You must provide a setting to determine where the files are stored")
+      setting = self.class.directory_setting
+      if setting
+        begin
+          Puppet.settings.setting(setting).open_file(path, 'w:ASCII') { |f| yield f }
+        rescue => detail
+          raise Puppet::Error, _("Could not write %{path} to %{setting}: %{detail}") % { path: path, setting: setting, detail: detail }, detail.backtrace
+        end
+      else
+        raise Puppet::DevError, _("You must provide a setting to determine where the files are stored")
+      end
     end
   end
 end

data/lib/puppet/indirector/status/rest.rb

@@ -6,4 +6,22 @@ class Puppet::Indirector::Status::Rest < Puppet::Indirector::REST
   desc "Get puppet master's status via REST. Useful because it tests the health
     of both the web server and the indirector."
 
+  def find(request)
+    return super unless use_http_client?
+
+    session = Puppet.lookup(:http_session)
+    api = session.route_to(:puppet)
+    _, status = api.get_status(request.key)
+    status
+  rescue Puppet::HTTP::ResponseError => e
+    if e.response.code == 404
+      return nil unless request.options[:fail_on_404]
+
+      _, body = parse_response(e.response.nethttp)
+      msg = _("Find %{uri} resulted in 404 with the message: %{body}") % { uri: elide(e.response.url.path, 100), body: body }
+      raise Puppet::Error, msg
+    else
+      raise convert_to_http_error(e.response.nethttp)
+    end
+  end
 end

data/lib/puppet/indirector/terminus.rb

@@ -29,10 +29,13 @@ class Puppet::Indirector::Terminus
     def indirection=(name)
       if name.is_a?(Puppet::Indirector::Indirection)
         @indirection = name
-      elsif ind = Puppet::Indirector::Indirection.instance(name)
-        @indirection = ind
       else
-        raise ArgumentError, _("Could not find indirection instance %{name} for %{terminus}") % { name: name, terminus: self.name }
+        ind = Puppet::Indirector::Indirection.instance(name)
+        if ind
+          @indirection = ind
+        else
+          raise ArgumentError, _("Could not find indirection instance %{name} for %{terminus}") % { name: name, terminus: self.name }
+        end
       end
     end
 
@@ -112,7 +115,7 @@ class Puppet::Indirector::Terminus
     # Return all terminus classes for a given indirection.
     def terminus_classes(indirection_name)
       setup_instance_loading indirection_name
-      instance_loader(indirection_name).files_to_load.map do |file|
+      instance_loader(indirection_name).files_to_load(Puppet.lookup(:current_environment)).map do |file|
         File.basename(file).chomp(".rb").intern
       end
     end
@@ -140,6 +143,10 @@ class Puppet::Indirector::Terminus
     self.class.name
   end
 
+  def require_environment?
+    true
+  end
+
   def allow_remote_requests?
     true
   end

data/lib/puppet/indirector/yaml.rb

@@ -9,7 +9,7 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
     return nil unless Puppet::FileSystem.exist?(file)
 
     begin
-      return fix(Puppet::Util::Yaml.load_file(file))
+      return load_file(file)
     rescue Puppet::Util::Yaml::YamlLoadError => detail
       raise Puppet::Error, _("Could not parse YAML data for %{indirection} %{request}: %{detail}") % { indirection: indirection.name, request: request.key, detail: detail }, detail.backtrace
     end
@@ -40,7 +40,7 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
       raise ArgumentError, _("invalid key")
     end
 
-    base = Puppet.run_mode.master? ? Puppet[:yamldir] : Puppet[:clientyamldir]
+    base = Puppet.run_mode.server? ? Puppet[:yamldir] : Puppet[:clientyamldir]
     File.join(base, self.class.indirection_name.to_s, name.to_s + ext)
   end
 
@@ -51,13 +51,13 @@ class Puppet::Indirector::Yaml < Puppet::Indirector::Terminus
 
   def search(request)
     Dir.glob(path(request.key,'')).collect do |file|
-      fix(Puppet::Util::Yaml.load_file(file))
+      load_file(file)
     end
   end
 
   protected
 
-  def fix(object)
-    object
+  def load_file(file)
+    Puppet::Util::Yaml.safe_load_file(file, [model, Symbol])
   end
 end

data/lib/puppet/indirector.rb

@@ -24,8 +24,8 @@ module Puppet::Indirector
       indirection = Puppet::Indirector::Indirection.instance(indirection_name)
       raise _("Indirection %{indirection_name} does not exist") % { indirection_name: indirection_name } unless indirection
 
-      indirection.terminus_class = terminus_name if terminus_name
-      indirection.cache_class = cache_name if cache_name
+      indirection.set_global_setting(:terminus_class, terminus_name) if terminus_name
+      indirection.set_global_setting(:cache_class, cache_name) if cache_name
     end
   end
 
@@ -46,7 +46,7 @@ module Puppet::Indirector
 
     # instantiate the actual Terminus for that type and this name (:ldap, w/ args :node)
     # & hook the instantiated Terminus into this class (Node: @indirection = terminus)
-    @indirection = Puppet::Indirector::Indirection.new(self, indirection, options)
+    @indirection = Puppet::Indirector::Indirection.new(self, indirection, **options)
   end
 
   module ClassMethods

data/lib/puppet/info_service/class_information_service.rb

@@ -59,7 +59,7 @@ class Puppet::InfoService::ClassInformationService
       {:classes =>
         parse_result.definitions.select {|d| d.is_a?(Puppet::Pops::Model::HostClassDefinition)}.map do |d|
           {:name   => d.name,
-           :params => params = d.parameters.map {|p| extract_param(p) }
+           :params => d.parameters.map {|p| extract_param(p) }
           }
         end
       }

data/lib/puppet/info_service/plan_information_service.rb

@@ -0,0 +1,36 @@
+class Puppet::InfoService::PlanInformationService
+  require 'puppet/module'
+
+  def self.plans_per_environment(environment_name)
+    # get the actual environment object, raise error if the named env doesn't exist
+    env = Puppet.lookup(:environments).get!(environment_name)
+    env.modules.map do |mod|
+      mod.plans.map do |plan|
+        {:module => {:name => plan.module.name}, :name => plan.name}
+      end
+    end.flatten
+  end
+
+  def self.plan_data(environment_name, module_name, plan_name)
+    # raise EnvironmentNotFound if applicable
+    Puppet.lookup(:environments).get!(environment_name)
+
+    pup_module = Puppet::Module.find(module_name, environment_name)
+    if pup_module.nil?
+      raise Puppet::Module::MissingModule, _("Module %{module_name} not found in environment %{environment_name}.") %
+                                            {module_name: module_name, environment_name: environment_name}
+    end
+
+    plan = pup_module.plans.find { |t| t.name == plan_name }
+    if plan.nil?
+      raise Puppet::Module::Plan::PlanNotFound.new(plan_name, module_name)
+    end
+
+    begin
+      plan.validate
+      {:metadata => plan.metadata, :files => plan.files}
+    rescue Puppet::Module::Plan::Error => err
+      { :metadata => nil, :files => [], :error => err.to_h }
+    end
+  end
+end

data/lib/puppet/info_service/task_information_service.rb

@@ -23,10 +23,14 @@ class Puppet::InfoService::TaskInformationService
 
     task = pup_module.tasks.find { |t| t.name == task_name }
     if task.nil?
-      raise Puppet::Module::Task::TaskNotFound, _("Task %{task_name} not found in module %{module_name}.") %
-                                                 {task_name: task_name, module_name: module_name}
+      raise Puppet::Module::Task::TaskNotFound.new(task_name, module_name)
     end
 
-    {:metadata_file => task.metadata_file, :files => task.files}
+    begin
+      task.validate
+      {:metadata => task.metadata, :files => task.files}
+    rescue Puppet::Module::Task::Error => err
+      { :metadata => nil, :files => [], :error => err.to_h }
+    end
   end
 end

data/lib/puppet/info_service.rb

@@ -2,6 +2,7 @@
 module Puppet::InfoService
   require 'puppet/info_service/class_information_service'
   require 'puppet/info_service/task_information_service'
+  require 'puppet/info_service/plan_information_service'
 
   def self.classes_per_environment(env_file_hash)
     Puppet::InfoService::ClassInformationService.new.classes_per_environment(env_file_hash)
@@ -14,4 +15,12 @@ module Puppet::InfoService
   def self.task_data(environment_name, module_name, task_name)
     Puppet::InfoService::TaskInformationService.task_data(environment_name, module_name, task_name)
   end
+
+  def self.plans_per_environment(environment_name)
+    Puppet::InfoService::PlanInformationService.plans_per_environment(environment_name)
+  end
+
+  def self.plan_data(environment_name, module_name, plan_name)
+    Puppet::InfoService::PlanInformationService.plan_data(environment_name, module_name, plan_name)
+  end
 end

data/lib/puppet/interface/action.rb

@@ -1,4 +1,4 @@
-require 'puppet/util/methodhelper'
+# coding: utf-8
 require 'prettyprint'
 
 # This represents an action that is attached to a face. Actions should
@@ -7,12 +7,11 @@ require 'prettyprint'
 # {Puppet::Interface::ActionBuilder} in the supplied block.
 # @api private
 class Puppet::Interface::Action
-  include Puppet::Util::MethodHelper
   extend  Puppet::Interface::DocGen
   include Puppet::Interface::FullDocs
 
   # @api private
-  def initialize(face, name, attrs = {})
+  def initialize(face, name)
     raise "#{name.inspect} is an invalid action name" unless name.to_s =~ /^[a-z]\w*$/
     @face    = face
     @name    = name.to_sym
@@ -23,8 +22,6 @@ class Puppet::Interface::Action
     @authors = []
     @license  = 'All Rights Reserved'
 
-    set_options(attrs)
-
     # @options collects the added options in the order they're declared.
     # @options_hash collects the options keyed by alias for quick lookups.
     @options        = []
@@ -149,6 +146,17 @@ class Puppet::Interface::Action
     @render_as = value.to_sym
   end
 
+  # @api private
+  # @return [void]
+  def deprecate
+    @deprecated = true
+  end
+
+  # @api private
+  # @return [Boolean]
+  def deprecated?
+    @deprecated
+  end
 
   ########################################################################
   # Initially, this was defined to allow the @action.invoke pattern, which is
@@ -269,12 +277,16 @@ WRAPPER
 
   def add_option(option)
     option.aliases.each do |name|
-      if conflict = get_option(name) then
+      conflict = get_option(name)
+      if conflict
         raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict}") %
             { option: option, conflict: conflict }
-      elsif conflict = @face.get_option(name) then
-        raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{face}") %
-            { option: option, conflict: conflict, face: @face }
+      else
+        conflict = @face.get_option(name)
+        if conflict
+          raise ArgumentError, _("Option %{option} conflicts with existing option %{conflict} on %{face}") %
+              { option: option, conflict: conflict, face: @face }
+        end
       end
     end
 
@@ -332,7 +344,8 @@ WRAPPER
     overlap = Hash.new do |h, k| h[k] = [] end
     unknown = []
     original.keys.each do |name|
-      if option = get_option(name) then
+      option = get_option(name)
+      if option
         canonical = option.name
         if result.has_key? canonical
           overlap[canonical] << name

data/lib/puppet/interface/action_builder.rb

@@ -17,6 +17,14 @@ class Puppet::Interface::ActionBuilder
     new(face, name, &block).action
   end
 
+  # Deprecates the action
+  # @return [void]
+  # @api private
+  # @dsl Faces
+  def deprecate
+    @action.deprecate
+  end
+
   # Ideally the method we're defining here would be added to the action, and a
   # method on the face would defer to it, but we can't get scope correct, so
   # we stick with this. --daniel 2011-03-24

data/lib/puppet/interface/action_manager.rb

@@ -22,7 +22,8 @@ module Puppet::Interface::ActionManager
     action = Puppet::Interface::ActionBuilder.build(self, name, &block)
 
     # REVISIT: (#18042) doesn't this mean we can't redefine the default action? -- josh
-    if action.default and current = get_default_action
+    current = get_default_action if action.default
+    if current
       raise "Actions #{current.name} and #{name} cannot both be default"
     end
 

data/lib/puppet/interface/documentation.rb

@@ -76,6 +76,7 @@ class Puppet::Interface
         s.text(" ")
 
         options.each do |option|
+          next if option == :extra
           option = get_option(option)
           wrap = option.required? ? %w{ < > } : %w{ [ ] }
 
@@ -318,17 +319,20 @@ class Puppet::Interface
       when String then
         input.strip.split(/,/).map do |part|
           part = part.strip
-          if part =~ /^\d+$/ then
+          if part =~ /^\d+$/
             part.to_i
-          elsif found = part.split(/-/) then
-            unless found.length == 2 and found.all? {|x| x.strip =~ /^\d+$/ }
+          else
+            found = part.split(/-/)
+            if found
+              unless found.length == 2 and found.all? {|x| x.strip =~ /^\d+$/ }
+                #TRANSLATORS 'copyright' is an attribute name and should not be translated
+                raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
+              end
+              Range.new(found[0].to_i, found[1].to_i)
+            else
               #TRANSLATORS 'copyright' is an attribute name and should not be translated
               raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
             end
-            Range.new(found[0].to_i, found[1].to_i)
-          else
-            #TRANSLATORS 'copyright' is an attribute name and should not be translated
-            raise ArgumentError, _("%{value} is not a good copyright year or range") % { value: part.inspect }
           end
         end
 

data/lib/puppet/interface/face_collection.rb

@@ -6,7 +6,9 @@ module Puppet::Interface::FaceCollection
   def self.faces
     unless @loaded
       @loaded = true
-      names = @loader.files_to_load.map {|fn| ::File.basename(fn, '.rb')}.uniq
+      names = @loader.files_to_load(Puppet.lookup(:current_environment)).map do |fn|
+        ::File.basename(fn, '.rb')
+      end.uniq
       names.each {|name| self[name, :current]}
     end
     @faces.keys.select {|name| @faces[name].length > 0 }
@@ -22,13 +24,16 @@ module Puppet::Interface::FaceCollection
 
     # If the version they request specifically doesn't exist, don't search
     # elsewhere.  Usually this will start from :current and all...
-    return nil unless face = self[name, version]
-    unless action = face.get_action(action_name)
+    face = self[name, version]
+    return nil unless face
+    action = face.get_action(action_name)
+    unless action
       # ...we need to search for it bound to an o{lder,ther} version.  Since
       # we load all actions when the face is first references, this will be in
       # memory in the known set of versions of the face.
       (@faces[name].keys - [ :current ]).sort.reverse_each do |vers|
-        break if action = @faces[name][vers].get_action(action_name)
+        action = @faces[name][vers].get_action(action_name)
+        break if action
       end
     end