puppet 3.4.3 → 3.5.0.rc1

data/lib/puppet/file_system/file_impl.rb

@@ -0,0 +1,145 @@
+# Abstract implementation of the Puppet::FileSystem
+#
+class Puppet::FileSystem::FileImpl
+
+  def pathname(path)
+    path.is_a?(Pathname) ? path : Pathname.new(path)
+  end
+
+  def assert_path(path)
+    return path if path.is_a?(Pathname)
+
+    # Some paths are string, or in the case of WatchedFile, it pretends to be
+    # one by implementing to_str.
+    if path.respond_to?(:to_str)
+      Pathname.new(path)
+    else
+      raise ArgumentError, "FileSystem implementation expected Pathname, got: '#{path.class}'"
+    end
+  end
+
+  def path_string(path)
+    path.to_s
+  end
+
+  def open(path, mode, options, &block)
+    ::File.open(path, options, mode, &block)
+  end
+
+  def dir(path)
+    path.dirname
+  end
+
+  def basename(path)
+    path.basename.to_s
+  end
+
+  def size(path)
+    path.size
+  end
+
+  def exclusive_create(path, mode, &block)
+    opt = File::CREAT | File::EXCL | File::WRONLY
+    self.open(path, mode, opt, &block)
+  end
+
+  def exclusive_open(path, mode, options = 'r', timeout = 300, &block)
+    wait = 0.001 + (Kernel.rand / 1000)
+    written = false
+    while !written
+      ::File.open(path, options, mode) do |rf|
+        if rf.flock(::File::LOCK_EX|::File::LOCK_NB)
+          yield rf
+          written = true
+        else
+          sleep wait
+          timeout -= wait
+          wait *= 2
+          if timeout < 0
+            raise Timeout::Error, "Timeout waiting for exclusive lock on #{@path}"
+          end
+        end
+      end
+    end
+  end
+
+  def each_line(path, &block)
+    ::File.open(path) do |f|
+      f.each_line do |line|
+        yield line
+      end
+    end
+  end
+
+  def read(path)
+    path.read
+  end
+
+  def binread(path)
+    raise NotImplementedError
+  end
+
+  def exist?(path)
+    ::File.exist?(path)
+  end
+
+  def directory?(path)
+    ::File.directory?(path)
+  end
+
+  def file?(path)
+    ::File.file?(path)
+  end
+
+  def executable?(path)
+    ::File.executable?(path)
+  end
+
+  def writable?(path)
+    path.writable?
+  end
+
+  def touch(path)
+    ::FileUtils.touch(path)
+  end
+
+  def mkpath(path)
+    path.mkpath
+  end
+
+  def children(path)
+    path.children
+  end
+
+  def symlink(path, dest, options = {})
+    FileUtils.symlink(path, dest, options)
+  end
+
+  def symlink?(path)
+    File.symlink?(path)
+  end
+
+  def readlink(path)
+    File.readlink(path)
+  end
+
+  def unlink(*paths)
+    File.unlink(*paths)
+  end
+
+  def stat(path)
+    File.stat(path)
+  end
+
+  def lstat(path)
+    File.lstat(path)
+  end
+
+  def compare_stream(path, stream)
+    open(path, 0, 'rb') { |this| FileUtils.compare_stream(this, stream) }
+  end
+
+  def chmod(mode, path)
+    FileUtils.chmod(mode, path)
+  end
+end

data/lib/puppet/file_system/memory_file.rb

@@ -1,7 +1,7 @@
 # An in-memory file abstraction. Commonly used with Puppet::FileSystem::File#overlay
 # @api private
 class Puppet::FileSystem::MemoryFile
-  attr_reader :path
+  attr_reader :path, :children
 
   def self.a_missing_file(path)
     new(path, :exist? => false, :executable? => false)
@@ -15,17 +15,31 @@ class Puppet::FileSystem::MemoryFile
     new(path, :exist? => true, :executable? => true)
   end
 
-  def initialize(path, options)
-    @path = Pathname.new(path)
-    @exist = options[:exist?]
-    @executable = options[:executable?]
-    @content = options[:content]
+  def self.a_directory(path, children = [])
+    new(path,
+        :exist? => true,
+        :excutable? => true,
+        :directory? => true,
+        :children => children)
   end
 
-  def exist?; @exist; end
-  def executable?; @executable; end
+  def initialize(path, properties)
+    @path = path
+    @properties = properties
+    @children = (properties[:children] || []).collect do |child|
+      child.duplicate_as(File.join(@path, child.path))
+    end
+  end
+
+  def directory?; @properties[:directory?]; end
+  def exist?; @properties[:exist?]; end
+  def executable?; @properties[:executable?]; end
 
   def each_line(&block)
-    StringIO.new(@content).each_line(&block)
+    StringIO.new(@properties[:content]).each_line(&block)
+  end
+
+  def duplicate_as(other_path)
+    self.class.new(other_path, @properties)
   end
 end

data/lib/puppet/file_system/memory_impl.rb

@@ -0,0 +1,64 @@
+class Puppet::FileSystem::MemoryImpl
+  def initialize(*files)
+    @files = files + all_children_of(files)
+  end
+
+  def exist?(path)
+    path.exist?
+  end
+
+  def directory?(path)
+    path.directory?
+  end
+
+  def file?(path)
+    path.file?
+  end
+
+  def executable?(path)
+    path.executable?
+  end
+
+  def children(path)
+    path.children
+  end
+
+  def each_line(path, &block)
+    path.each_line(&block)
+  end
+
+  def pathname(path)
+    find(path)
+  end
+
+  def basename(path)
+    path.duplicate_as(File.basename(path_string(path)))
+  end
+
+  def path_string(object)
+    object.path
+  end
+
+  def assert_path(path)
+    if path.is_a?(Puppet::FileSystem::MemoryFile)
+      path
+    else
+      find(path) or raise ArgumentError, "Unable to find registered object for #{path.inspect}"
+    end
+  end
+
+  private
+
+  def find(path)
+    @files.find { |file| file.path == path }
+  end
+
+  def all_children_of(files)
+    children = files.collect(&:children).flatten
+    if children.empty?
+      []
+    else
+      children + all_children_of(children)
+    end
+  end
+end

data/lib/puppet/forge.rb

@@ -2,11 +2,12 @@ require 'net/http'
 require 'open-uri'
 require 'pathname'
 require 'uri'
-require 'puppet/forge/cache'
-require 'puppet/forge/repository'
-require 'puppet/forge/errors'
 
 class Puppet::Forge
+  require 'puppet/forge/errors'
+  require 'puppet/forge/cache'
+  require 'puppet/forge/repository'
+
   include Puppet::Forge::Errors
 
   # +consumer_name+ is a name to be used for identifying the consumer of the

data/lib/puppet/forge/repository.rb

@@ -2,7 +2,6 @@ require 'net/https'
 require 'digest/sha1'
 require 'uri'
 require 'puppet/util/http_proxy'
-require 'puppet/forge/errors'
 
 if Puppet.features.zlib? && Puppet[:zlib]
   require 'zlib'

data/lib/puppet/graph/relationship_graph.rb

@@ -180,22 +180,22 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
   end
 
   # Impose our container information on another graph by using it
-  # to replace any container vertices X with a pair of verticies
-  # { admissible_X and completed_X } such that that
+  # to replace any container vertices X with a pair of vertices
+  # { admissible_X and completed_X } such that
   #
   #    0) completed_X depends on admissible_X
   #    1) contents of X each depend on admissible_X
   #    2) completed_X depends on each on the contents of X
-  #    3) everything which depended on X depens on completed_X
+  #    3) everything which depended on X depends on completed_X
   #    4) admissible_X depends on everything X depended on
   #    5) the containers and their edges must be removed
   #
   # Note that this requires attention to the possible case of containers
   # which contain or depend on other containers, but has the advantage
   # that the number of new edges created scales linearly with the number
-  # of contained verticies regardless of how containers are related;
+  # of contained vertices regardless of how containers are related;
   # alternatives such as replacing container-edges with content-edges
-  # scale as the product of the number of external dependences, which is
+  # scale as the product of the number of external dependencies, which is
   # to say geometrically in the case of nested / chained containers.
   #
   Default_label = { :callback => :refresh, :event => :ALL_EVENTS }
@@ -207,8 +207,8 @@ class Puppet::Graph::RelationshipGraph < Puppet::Graph::SimpleGraph
     #
     # These two hashes comprise the aforementioned attention to the possible
     #   case of containers that contain / depend on other containers; they map
-    #   containers to their sentinels but pass other verticies through.  Thus we
-    #   can "do the right thing" for references to other verticies that may or
+    #   containers to their sentinels but pass other vertices through.  Thus we
+    #   can "do the right thing" for references to other vertices that may or
     #   may not be containers.
     #
     admissible = Hash.new { |h,k| k }

data/lib/puppet/indirector.rb

@@ -9,6 +9,7 @@ module Puppet::Indirector
 
   require 'puppet/indirector/indirection'
   require 'puppet/indirector/terminus'
+  require 'puppet/indirector/code'
   require 'puppet/indirector/envelope'
   require 'puppet/network/format_support'
 

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

@@ -23,7 +23,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       if text_facts.is_a?(Puppet::Node::Facts)
         facts = text_facts
       else
-        # We unescape here because the corrosponding code in Puppet::Configurer::FactHandler escapes
+        # We unescape here because the corresponding code in Puppet::Configurer::FactHandler escapes
         facts = Puppet::Node::Facts.convert_from(format, CGI.unescape(text_facts))
       end
 
@@ -41,7 +41,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     extract_facts_from_request(request)
 
     node = node_from_request(request)
-    node.trusted_data = trusted_hash_from_request(request)
+    node.trusted_data = Puppet.lookup(:trusted_information) { Puppet::Context::TrustedInformation.local(node) }.to_h
 
     if catalog = compile(node)
       return catalog
@@ -52,7 +52,6 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     end
   end
 
-
   # filter-out a catalog to remove exported resources
   def filter(catalog)
     return catalog.filter { |r| r.virtual? } if catalog.respond_to?(:filter)
@@ -72,32 +71,6 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
 
   private
 
-  # Produces a deeply frozen hash with trusted information
-  # The key :authenticated is always present in the result with one of the values
-  # :remote, :local, false, where :remote is authenticated via cert, :local is trusted by virtue
-  # of running on the same machine (not a remove request), and false is an unauthenticated remot request.
-  # When the trusted hash value for :authenticated == false, there is no other values set in the hash.
-  #
-  def trusted_hash_from_request(request)
-    if request.remote?
-      if request.authenticated?
-        trust_authenticated = 'remote'.freeze
-        client_cert = request.node
-      else
-        trust_authenticated = false
-        client_cert = nil
-      end
-    else
-      trust_authenticated = 'local'.freeze
-      # Always trust local data by picking up the available parameters.
-      request_node = request.options[:use_node]
-      client_cert = request_node ? request_node.parameters['clientcert'] : nil
-    end
-
-    # TODO nil or undef for client_cert missing?
-    trusted_hash = { 'authenticated' => trust_authenticated, 'certname' => client_cert }.freeze
-  end
-
   # Add any extra data necessary to the node.
   def add_node_data(node)
     # Merge in our server-side facts, so they can be used during compilation.
@@ -133,7 +106,7 @@ class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
       rescue => detail
         message = "Failed when searching for node #{name}: #{detail}"
         Puppet.log_exception(detail, message)
-        raise Puppet::Error, message
+        raise Puppet::Error, message, detail.backtrace
       end
 
 

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

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

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

@@ -1,8 +1,8 @@
 require 'puppet/node'
 require 'puppet/resource/catalog'
-require 'puppet/indirector/code'
+require 'puppet/indirector/catalog/compiler'
 
-class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
+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
@@ -35,12 +35,8 @@ class Puppet::Resource::Catalog::StaticCompiler < Puppet::Indirector::Code
       that compiled a given catalog may not have stored the required file contents
       in their filebuckets.}
 
-  def compiler
-    @compiler ||= indirection.terminus(:compiler)
-  end
-
   def find(request)
-    return nil unless catalog = compiler.find(request)
+    return nil unless catalog = super
 
     raise "Did not get catalog back" unless catalog.is_a?(model)
 

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

@@ -29,7 +29,7 @@ class Puppet::DataBinding::Hiera < Puppet::Indirector::Code
     hiera_config = Puppet.settings[:hiera_config]
     config = {}
 
-    if Puppet::FileSystem::File.exist?(hiera_config)
+    if Puppet::FileSystem.exist?(hiera_config)
       config = Hiera::Config.load(hiera_config)
     else
       Puppet.warning "Config file #{hiera_config} not found, using Hiera defaults"

data/lib/puppet/indirector/direct_file_server.rb

@@ -6,14 +6,14 @@ class Puppet::Indirector::DirectFileServer < Puppet::Indirector::Terminus
   include Puppet::FileServing::TerminusHelper
 
   def find(request)
-    return nil unless Puppet::FileSystem::File.exist?(request.key)
+    return nil unless Puppet::FileSystem.exist?(request.key)
     instance = model.new(request.key)
     instance.links = request.options[:links] if request.options[:links]
     instance
   end
 
   def search(request)
-    return nil unless Puppet::FileSystem::File.exist?(request.key)
+    return nil unless Puppet::FileSystem.exist?(request.key)
     path2instances(request, request.key)
   end
 end