puppet 2.7.26 → 3.0.0.rc4

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

@@ -5,19 +5,9 @@ require 'puppet/resource/catalog'
 class Puppet::Resource::Catalog::ActiveRecord < Puppet::Indirector::ActiveRecord
   use_ar_model Puppet::Rails::Host
 
-  # If we can find the host, then return a catalog with the host's resources
-  # as the vertices.
+  # We don't retrieve catalogs from storeconfigs
   def find(request)
-    return nil unless request.options[:cache_integration_hack]
-    return nil unless host = ar_model.find_by_name(request.key)
-
-    catalog = Puppet::Resource::Catalog.new(host.name)
-
-    host.resources.each do |resource|
-      catalog.add_resource resource.to_transportable
-    end
-
-    catalog
+    nil
   end
 
   # Save the values from a Facts instance as the facts on a Rails Host instance.

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

@@ -13,9 +13,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   def extract_facts_from_request(request)
     return unless text_facts = request.options[:facts]
-    unless format = request.options[:facts_format]
-      raise ArgumentError, "Facts but no fact format provided for #{request.key}"
-    end
+    raise ArgumentError, "Facts but no fact format provided for #{request.name}" unless format = request.options[:facts_format]
 
     # If the facts were encoded as yaml, then the param reconstitution system
     # in Network::HTTP::Handler will automagically deserialize the value.
@@ -24,11 +22,6 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     else
       facts = Puppet::Node::Facts.convert_from(format, text_facts)
     end
-
-    unless facts.name == request.key
-      raise Puppet::Error, "Catalog for #{request.key.inspect} was requested with fact definition for the wrong node (#{facts.name.inspect})."
-    end
-
     facts.add_timestamp
     Puppet::Node::Facts.indirection.save(facts)
   end
@@ -92,12 +85,13 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   end
 
   # Turn our host name into a node object.
-  def find_node(name)
+  def find_node(name, *args)
     begin
-      return nil unless node = Puppet::Node.indirection.find(name)
+      return nil unless node = Puppet::Node.indirection.find(name, *args)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise Puppet::Error, "Failed when searching for node #{name}: #{detail}"
+      message = "Failed when searching for node #{name}: #{detail}"
+      Puppet.log_exception(detail, message)
+      raise Puppet::Error, message
     end
 
 
@@ -111,11 +105,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
   # to find the node.
   def node_from_request(request)
     if node = request.options[:use_node]
-      if request.remote?
-        raise Puppet::Error, "Invalid option use_node for a remote request"
-      else
-        return node
-      end
+      return node
     end
 
     # We rely on our authorization system to determine whether the connected
@@ -126,7 +116,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     # node's catalog with only one certificate and a modification to auth.conf 
     # If no key is provided we can only compile the currently connected node.
     name = request.key || request.node
-    if node = find_node(name)
+    if node = find_node(name, :environment => request.environment)
       return node
     end
 

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

@@ -0,0 +1,6 @@
+require 'puppet/resource/catalog'
+require 'puppet/indirector/json'
+
+class Puppet::Resource::Catalog::Json < Puppet::Indirector::JSON
+  desc "Store catalogs as flat files, serialized using JSON."
+end

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

@@ -113,7 +113,9 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
 
   def remove_existing_resources(children, catalog)
     existing_names = catalog.resources.collect { |r| r.to_s }
+
     both = (existing_names & children.keys).inject({}) { |hash, name| hash[name] = true; hash }
+
     both.each { |name| children.delete(name) }
   end
 
@@ -129,8 +131,7 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
     else
       Puppet.info "Storing content for source '#{resource[:source]}'"
       content = Puppet::FileServing::Content.indirection.find(resource[:source])
-      file = Puppet::FileBucket::File.new(content.content)
-      Puppet::FileBucket::File.indirection.save(file)
+      Puppet::FileBucket::File.indirection.save(Puppet::FileBucket::File.new(content.content))
     end
   end
 end

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

@@ -6,6 +6,7 @@ class Puppet::SSL::Certificate::Rest < Puppet::Indirector::REST
 
   use_server_setting(:ca_server)
   use_port_setting(:ca_port)
+  use_srv_service(:ca)
 
   def find(request)
     return nil unless result = super

data/lib/puppet/indirector/certificate_status/file.rb

@@ -79,9 +79,4 @@ class Puppet::Indirector::CertificateStatus::File < Puppet::Indirector::Code
       nil
     end
   end
-
-  def validate_key(request)
-    # We only use desired_state from the instance and use request.key
-    # otherwise, so the name does not need to match
-  end
 end

data/lib/puppet/indirector/data_binding/hiera.rb

@@ -0,0 +1,6 @@
+require 'puppet/indirector/hiera'
+
+class Puppet::DataBinding::Hiera < Puppet::Indirector::Hiera
+  desc "Retrieve data using Hiera."
+end
+

data/lib/puppet/indirector/data_binding/none.rb

@@ -0,0 +1,5 @@
+require 'puppet/indirector/none'
+
+class Puppet::DataBinding::None < Puppet::Indirector::None
+  desc "A Dummy terminus that always returns nil for data lookups."
+end

data/lib/puppet/indirector/exec.rb

@@ -4,24 +4,7 @@ require 'puppet/util'
 class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
   # Look for external node definitions.
   def find(request)
-    # Run the command.
-    unless output = query(request.key)
-      return nil
-    end
-
-    # Translate the output to ruby.
-    output
-  end
-
-  private
-
-  # Proxy the execution, so it's easier to test.
-  def execute(command, arguments)
-    Puppet::Util.execute(command,arguments)
-  end
-
-  # Call the external command and see if it returns our output.
-  def query(name)
+    name = request.key
     external_command = command
 
     # Make sure it's an arry
@@ -45,4 +28,11 @@ class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
       return output
     end
   end
+
+  private
+
+  # Proxy the execution, so it's easier to test.
+  def execute(command, arguments)
+    Puppet::Util::Execution.execute(command,arguments)
+  end
 end

data/lib/puppet/indirector/face.rb

@@ -41,8 +41,9 @@ class Puppet::Indirector::Face < Puppet::Face
     begin
       result = indirection.__send__(method, key, options)
     rescue => detail
-      puts detail.backtrace if Puppet[:trace]
-      raise "Could not call '#{method}' on '#{indirection_name}': #{detail}"
+      message = "Could not call '#{method}' on '#{indirection_name}': #{detail}"
+      Puppet.log_exception(detail, message)
+      raise message
     end
 
     return result
@@ -50,11 +51,11 @@ class Puppet::Indirector::Face < Puppet::Face
 
   option "--extra HASH" do
     summary "Extra arguments to pass to the indirection request"
-    description <<-EOT
+    description <<-end
       A terminus can take additional arguments to refine the operation, which
       are passed as an arbitrary hash to the back-end.  Anything passed as
       the extra value is just send direct to the back-end.
-    EOT
+    end
     default_to do Hash.new end
   end
 

data/lib/puppet/indirector/facts/facter.rb

@@ -1,26 +1,17 @@
 require 'puppet/node/facts'
 require 'puppet/indirector/code'
+require 'puppet/util/config_timeout'
 
 class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
+  extend Puppet::Util::ConfigTimeout
+
   desc "Retrieve facts from Facter.  This provides a somewhat abstract interface
     between Puppet and Facter.  It's only `somewhat` abstract because it always
     returns the local host's facts, regardless of what you attempt to find."
 
-
-  # Clear out all of the loaded facts. Reload facter but not puppet facts.
-  # NOTE: This is clumsy and shouldn't be required for later (1.5.x) versions
-  # of Facter.
   def self.reload_facter
     Facter.clear
-
-    # Reload everything.
-    if Facter.respond_to? :loadfacts
-      Facter.loadfacts
-    elsif Facter.respond_to? :load
-      Facter.load
-    else
-      Puppet.warning "You should upgrade your version of Facter to at least 1.3.8"
-    end
+    Facter.loadfacts
   end
 
   def self.load_fact_plugins
@@ -44,8 +35,8 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
         fqfile = ::File.join(dir, file)
         begin
           Puppet.info "Loading facts in #{fqfile}"
-          Timeout::timeout(self.timeout) do
-            load File.join('.', file)
+          ::Timeout::timeout(self.timeout_interval) do
+            load file
           end
         rescue SystemExit,NoMemoryError
           raise
@@ -56,23 +47,6 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
     end
   end
 
-  def self.timeout
-    timeout = Puppet[:configtimeout]
-    case timeout
-    when String
-      if timeout =~ /^\d+$/
-        timeout = Integer(timeout)
-      else
-        raise ArgumentError, "Configuration timeout must be an integer"
-      end
-    when Integer # nothing
-    else
-      raise ArgumentError, "Configuration timeout must be an integer"
-    end
-
-    timeout
-  end
-
   def destroy(facts)
     raise Puppet::DevError, "You cannot destroy facts in the code store; it is only used for getting facts from Facter"
   end
@@ -85,7 +59,6 @@ class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
 
     result.add_local_facts
     result.stringify
-    result.downcase_if_necessary
 
     result
   end

data/lib/puppet/indirector/facts/network_device.rb

@@ -10,7 +10,6 @@ class Puppet::Node::Facts::NetworkDevice < Puppet::Indirector::Code
 
     result.add_local_facts
     result.stringify
-    result.downcase_if_necessary
 
     result
   end

data/lib/puppet/indirector/file_bucket_file/file.rb

@@ -48,10 +48,6 @@ module Puppet::FileBucketFile
       instance.to_s
     end
 
-    def validate_key(request)
-      # There are no ACLs on filebucket files so validating key is not important
-    end
-
     private
 
     def path_match(dir_path, files_original_path)

data/lib/puppet/indirector/file_bucket_file/selector.rb

@@ -44,10 +44,6 @@ module Puppet::FileBucketFile
         true
       end
     end
-
-    def validate_key(request)
-      get_terminus(request).validate(request)
-    end
   end
 end
 

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

@@ -4,4 +4,6 @@ require 'puppet/indirector/rest'
 
 class Puppet::Indirector::FileContent::Rest < Puppet::Indirector::REST
   desc "Retrieve file contents via a REST HTTP interface."
+
+  use_srv_service(:fileserver)
 end

data/lib/puppet/indirector/hiera.rb

@@ -0,0 +1,69 @@
+require 'puppet/indirector/terminus'
+
+class Puppet::Indirector::Hiera < Puppet::Indirector::Terminus
+  def initialize(*args)
+    if ! Puppet.features.hiera?
+      raise "Hiera terminus not supported without hiera library"
+    end
+    super
+  end
+
+  def find(request)
+    fake_scope = FakeScope.new(request.options[:facts])
+    hiera.lookup(request.key, nil, fake_scope, nil, nil)
+  end
+
+  private
+
+  def self.hiera_config
+    hiera_config = Puppet.settings[:hiera_config]
+    config = {}
+
+    if File.exist?(hiera_config)
+      config = Hiera::Config.load(hiera_config)
+    else
+      Puppet.warning "Config file #{hiera_config} not found, using Hiera defaults"
+    end
+
+    config[:logger] = 'puppet'
+    config
+  end
+
+  def self.hiera
+    @hiera ||= Hiera.new(:config => hiera_config)
+  end
+
+  def hiera
+    self.class.hiera
+  end
+
+  # A class that acts just enough like a Puppet::Parser::Scope to
+  # fool Hiera's puppet backend. This class doesn't actually do anything
+  # but it does allow people to use the puppet backend with the hiera
+  # data bindings withough causing problems.
+  class FakeScope
+    FAKE_RESOURCE = Struct.new(:name).new("fake").freeze
+    FAKE_CATALOG = Struct.new(:classes).new([].freeze).freeze
+
+    def initialize(variable_bindings)
+      @variable_bindings = variable_bindings
+    end
+
+    def [](name)
+      @variable_bindings[name]
+    end
+
+    def resource
+      FAKE_RESOURCE
+    end
+
+    def catalog
+      FAKE_CATALOG
+    end
+
+    def function_include(name)
+      # noop
+    end
+  end
+end
+

data/lib/puppet/indirector/indirection.rb

@@ -1,4 +1,5 @@
 require 'puppet/util/docs'
+require 'puppet/util/methodhelper'
 require 'puppet/indirector/envelope'
 require 'puppet/indirector/request'
 require 'puppet/util/instrumentation/instrumentable'
@@ -7,6 +8,7 @@ require 'puppet/util/instrumentation/instrumentable'
 # back-ends.  Each indirection has a set of associated terminus classes,
 # each of which is a subclass of Puppet::Indirector::Terminus.
 class Puppet::Indirector::Indirection
+  include Puppet::Util::MethodHelper
   include Puppet::Util::Docs
   extend Puppet::Util::Instrumentation::Instrumentable
 
@@ -108,13 +110,7 @@ class Puppet::Indirector::Indirection
     end
 
     # This is currently only used for cache_class and terminus_class.
-    options.each do |name, value|
-      begin
-        send(name.to_s + "=", value)
-      rescue NoMethodError
-        raise ArgumentError, "#{name} is not a valid Indirection parameter"
-      end
-    end
+    set_options(options)
   end
 
   # Set up our request object.
@@ -166,25 +162,25 @@ class Puppet::Indirector::Indirection
   # Expire a cached object, if one is cached.  Note that we don't actually
   # remove it, we expire it and write it back out to disk.  This way people
   # can still use the expired object if they want.
-  def expire(key, *args)
-    request = request(:expire, key, *args)
+  def expire(key, options={})
+    request = request(:expire, key, nil, options)
 
     return nil unless cache?
 
-    return nil unless instance = cache.find(request(:find, key, *args))
+    return nil unless instance = cache.find(request(:find, key, nil, options))
 
     Puppet.info "Expiring the #{self.name} cache of #{instance.name}"
 
     # Set an expiration date in the past
     instance.expiration = Time.now - 60
 
-    cache.save(request(:save, instance, *args))
+    cache.save(request(:save, nil, instance, options))
   end
 
   # Search for an instance in the appropriate terminus, caching the
   # results if caching is configured..
-  def find(key, *args)
-    request = request(:find, key, *args)
+  def find(key, options={})
+    request = request(:find, key, nil, options)
     terminus = prepare(request)
 
     if result = find_in_cache(request)
@@ -196,7 +192,7 @@ class Puppet::Indirector::Indirection
       result.expiration ||= self.expiration if result.respond_to?(:expiration)
       if cache? and request.use_cache?
         Puppet.info "Caching #{self.name} for #{request.key}"
-        cache.save request(:save, result, *args)
+        cache.save request(:save, nil, result, options)
       end
 
       return terminus.respond_to?(:filter) ? terminus.filter(result) : result
@@ -207,8 +203,8 @@ class Puppet::Indirector::Indirection
 
   # Search for an instance in the appropriate terminus, and return a
   # boolean indicating whether the instance was found.
-  def head(key, *args)
-    request = request(:head, key, *args)
+  def head(key, options={})
+    request = request(:head, key, nil, options)
     terminus = prepare(request)
 
     # Look in the cache first, then in the terminus.  Force the result
@@ -227,19 +223,18 @@ class Puppet::Indirector::Indirection
     Puppet.debug "Using cached #{self.name} for #{request.key}"
     cached
   rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    Puppet.err "Cached #{self.name} for #{request.key} failed: #{detail}"
+    Puppet.log_exception(detail, "Cached #{self.name} for #{request.key} failed: #{detail}")
     nil
   end
 
   # Remove something via the terminus.
-  def destroy(key, *args)
-    request = request(:destroy, key, *args)
+  def destroy(key, options={})
+    request = request(:destroy, key, nil, options)
     terminus = prepare(request)
 
     result = terminus.destroy(request)
 
-    if cache? and cached = cache.find(request(:find, key, *args))
+    if cache? and cached = cache.find(request(:find, key, nil, options))
       # Reuse the existing request, since it's equivalent.
       cache.destroy(request)
     end
@@ -248,8 +243,8 @@ class Puppet::Indirector::Indirection
   end
 
   # Search for more than one instance.  Should always return an array.
-  def search(key, *args)
-    request = request(:search, key, *args)
+  def search(key, options={})
+    request = request(:search, key, nil, options)
     terminus = prepare(request)
 
     if result = terminus.search(request)
@@ -264,8 +259,8 @@ class Puppet::Indirector::Indirection
 
   # Save the instance in the appropriate terminus.  This method is
   # normally an instance method on the indirected class.
-  def save(instance, key = nil)
-    request = request(:save, key, instance)
+  def save(instance, key = nil, options={})
+    request = request(:save, key, instance, options)
     terminus = prepare(request)
 
     result = terminus.save(request)
@@ -308,7 +303,6 @@ class Puppet::Indirector::Indirection
 
     dest_terminus = terminus(terminus_name)
     check_authorization(request, dest_terminus)
-    dest_terminus.validate(request)
 
     dest_terminus
   end