puppet 0.25.5 → 2.6.0

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

@@ -2,80 +2,82 @@ require 'puppet/node/facts'
 require 'puppet/indirector/code'
 
 class Puppet::Node::Facts::Facter < Puppet::Indirector::Code
-    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."
+  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."
 
 
-    def self.load_fact_plugins
-        # Add any per-module fact directories to the factpath
-        module_fact_dirs = Puppet[:modulepath].split(":").collect do |d|
-            Dir.glob("%s/*/plugins/facter" % d)
-        end.flatten
-        dirs = module_fact_dirs + Puppet[:factpath].split(":")
-        x = dirs.each do |dir|
-            load_facts_in_dir(dir)
-        end
+  def self.load_fact_plugins
+    # Add any per-module fact directories to the factpath
+    module_fact_dirs = Puppet[:modulepath].split(":").collect do |d|
+      ["lib", "plugins"].map do |subdirectory|
+        Dir.glob("#{d}/*/#{subdirectory}/facter")
+      end
+    end.flatten
+    dirs = module_fact_dirs + Puppet[:factpath].split(":")
+    x = dirs.each do |dir|
+      load_facts_in_dir(dir)
     end
+  end
 
-    def self.load_facts_in_dir(dir)
-        return unless FileTest.directory?(dir)
+  def self.load_facts_in_dir(dir)
+    return unless FileTest.directory?(dir)
 
-        Dir.chdir(dir) do
-            Dir.glob("*.rb").each do |file|
-                fqfile = ::File.join(dir, file)
-                begin
-                    Puppet.info "Loading facts in %s" % [::File.basename(file.sub(".rb",''))]
-                    Timeout::timeout(self.timeout) do
-                        load file
-                    end
-                rescue SystemExit,NoMemoryError
-                    raise
-                rescue Exception => detail
-                    Puppet.warning "Could not load fact file %s: %s" % [fqfile, detail]
-                end
-            end
+    Dir.chdir(dir) do
+      Dir.glob("*.rb").each do |file|
+        fqfile = ::File.join(dir, file)
+        begin
+          Puppet.info "Loading facts in #{::File.basename(file.sub(".rb",''))}"
+          Timeout::timeout(self.timeout) do
+            load file
+          end
+        rescue SystemExit,NoMemoryError
+          raise
+        rescue Exception => detail
+          Puppet.warning "Could not load fact file #{fqfile}: #{detail}"
         end
+      end
     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
-
-        return timeout
+  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
 
-    def initialize(*args)
-        super
-        self.class.load_fact_plugins
-    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
+  def initialize(*args)
+    super
+    self.class.load_fact_plugins
+  end
 
-    # Look a host's facts up in Facter.
-    def find(request)
-        result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
+  def destroy(facts)
+    raise Puppet::DevError, "You cannot destroy facts in the code store; it is only used for getting facts from Facter"
+  end
 
-        result.add_local_facts
-        result.stringify
-        result.downcase_if_necessary
+  # Look a host's facts up in Facter.
+  def find(request)
+    result = Puppet::Node::Facts.new(request.key, Facter.to_hash)
 
-        result
-    end
+    result.add_local_facts
+    result.stringify
+    result.downcase_if_necessary
 
-    def save(facts)
-        raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from Facter"
-    end
+    result
+  end
+
+  def save(facts)
+    raise Puppet::DevError, "You cannot save facts to the code store; it is only used for getting facts from Facter"
+  end
 end

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

@@ -2,8 +2,8 @@ require 'puppet/node/facts'
 require 'puppet/indirector/memory'
 
 class Puppet::Node::Facts::Memory < Puppet::Indirector::Memory
-    desc "Keep track of facts in memory but nowhere else.  This is used for
-        one-time compiles, such as what the stand-alone ``puppet`` does.
-        To use this terminus, you must load it with the data you want it
-        to contain."
+  desc "Keep track of facts in memory but nowhere else.  This is used for
+    one-time compiles, such as what the stand-alone ``puppet`` does.
+    To use this terminus, you must load it with the data you want it
+    to contain."
 end

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

@@ -2,5 +2,5 @@ require 'puppet/node/facts'
 require 'puppet/indirector/rest'
 
 class Puppet::Node::Facts::Rest < Puppet::Indirector::REST
-    desc "Find and save facts about nodes over HTTP via REST."
+  desc "Find and save facts about nodes over HTTP via REST."
 end

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

@@ -2,6 +2,6 @@ require 'puppet/node/facts'
 require 'puppet/indirector/yaml'
 
 class Puppet::Node::Facts::Yaml < Puppet::Indirector::Yaml
-    desc "Store client facts as flat files, serialized using YAML, or
-        return deserialized facts from disk."
+  desc "Store client facts as flat files, serialized using YAML, or
+    return deserialized facts from disk."
 end

data/lib/puppet/indirector/file.rb

@@ -1,58 +1,79 @@
 require 'puppet/indirector/terminus'
 
-# An empty terminus type, meant to just return empty objects.
+# Store instances as files, usually serialized using some format.
 class Puppet::Indirector::File < Puppet::Indirector::Terminus
-    # Remove files on disk.
-    def destroy(request)
-        if respond_to?(:path)
-            path = path(request.key)
-        else
-            path = request.key
-        end
-        raise Puppet::Error.new("File %s does not exist; cannot destroy" % [request.key]) unless File.exist?(path)
-
-        Puppet.notice "Removing file %s %s at '%s'" % [model, request.key, path]
-        begin
-            File.unlink(path)
-        rescue => detail
-            raise Puppet::Error, "Could not remove %s: %s" % [request.key, detail]
-        end
+  # Where do we store our data?
+  def data_directory
+    name = Puppet.run_mode.master? ? :server_datadir : :client_datadir
+
+    File.join(Puppet.settings[name], self.class.indirection_name.to_s)
+  end
+
+  def file_format(path)
+    path =~ /\.(\w+)$/ and return $1
+  end
+
+  def file_path(request)
+    File.join(data_directory, request.key + ".#{serialization_format}")
+  end
+
+  def latest_path(request)
+    files = Dir.glob(File.join(data_directory, request.key + ".*"))
+    return nil if files.empty?
+
+    # Return the newest file.
+    files.sort { |a, b| File.stat(b).mtime <=> File.stat(a).mtime }[0]
+  end
+
+  def serialization_format
+    model.default_format
+  end
+
+  # Remove files on disk.
+  def destroy(request)
+    begin
+      removed = false
+      Dir.glob(File.join(data_directory, request.key.to_s + ".*")).each do |file|
+        removed = true
+        File.unlink(file)
+      end
+    rescue => detail
+      raise Puppet::Error, "Could not remove #{request.key}: #{detail}"
     end
 
-    # Return a model instance for a given file on disk.
-    def find(request)
-        if respond_to?(:path)
-            path = path(request.key)
-        else
-            path = request.key
-        end
+    raise Puppet::Error, "Could not find files for #{request.key} to remove" unless removed
+  end
 
-        return nil unless File.exist?(path)
+  # Return a model instance for a given file on disk.
+  def find(request)
+    return nil unless path = latest_path(request)
+    format = file_format(path)
 
-        begin
-            content = File.read(path)
-        rescue => detail
-            raise Puppet::Error, "Could not retrieve path %s: %s" % [path, detail]
-        end
+    raise ArgumentError, "File format #{format} is not supported by #{self.class.indirection_name}" unless model.support_format?(format)
 
-        return model.new(content)
+    begin
+      return model.convert_from(format, File.read(path))
+    rescue => detail
+      raise Puppet::Error, "Could not convert path #{path} into a #{self.class.indirection_name}: #{detail}"
     end
+  end
+
+  # Save a new file to disk.
+  def save(request)
+    path = file_path(request)
+
+    dir = File.dirname(path)
 
-    # Save a new file to disk.
-    def save(request)
-        if respond_to?(:path)
-            path = path(request.key)
-        else
-            path = request.key
-        end
-        dir = File.dirname(path)
-
-        raise Puppet::Error.new("Cannot save %s; parent directory %s does not exist" % [request.key, dir]) unless File.directory?(dir)
-
-        begin
-            File.open(path, "w") { |f| f.print request.instance.content }
-        rescue => detail
-            raise Puppet::Error, "Could not write %s: %s" % [request.key, detail]
-        end
+    raise Puppet::Error.new("Cannot save #{request.key}; parent directory #{dir} does not exist") unless File.directory?(dir)
+
+    begin
+      File.open(path, "w") { |f| f.print request.instance.render(serialization_format) }
+    rescue => detail
+      raise Puppet::Error, "Could not write #{request.key}: #{detail}" % [request.key, detail]
     end
+  end
+
+  def path(key)
+    key
+  end
 end

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

@@ -0,0 +1,146 @@
+require 'puppet/indirector/code'
+require 'puppet/file_bucket/file'
+require 'puppet/util/checksums'
+require 'fileutils'
+
+module Puppet::FileBucketFile
+  class File < Puppet::Indirector::Code
+    include Puppet::Util::Checksums
+
+    desc "Store files in a directory set based on their checksums."
+
+    def initialize
+      Puppet.settings.use(:filebucket)
+    end
+
+    def find( request )
+      checksum, path = request_to_checksum_and_path( request )
+      find_by_checksum( checksum, request.options )
+    end
+
+    def save( request )
+      checksum, path = request_to_checksum_and_path( request )
+
+      instance = request.instance
+      instance.checksum = checksum if checksum
+      instance.path = path if path
+
+      save_to_disk(instance)
+      instance.to_s
+    end
+
+    private
+
+    def find_by_checksum( checksum, options )
+      model.new( nil, :checksum => checksum ) do |bucket_file|
+        bucket_file.bucket_path = options[:bucket_path]
+        filename = contents_path_for( bucket_file )
+
+        return nil if ! ::File.exist? filename
+
+        begin
+          contents = ::File.read filename
+          Puppet.info "FileBucket read #{bucket_file.checksum}"
+        rescue RuntimeError => e
+          raise Puppet::Error, "file could not be read: #{e.message}"
+        end
+
+        if ::File.exist?(paths_path_for( bucket_file) )
+          ::File.open(paths_path_for( bucket_file) ) do |f|
+            bucket_file.paths = f.readlines.map { |l| l.chomp }
+          end
+        end
+
+        bucket_file.contents = contents
+      end
+    end
+
+    def save_to_disk( bucket_file )
+      # If the file already exists, just return the md5 sum.
+      if ::File.exist?(contents_path_for( bucket_file) )
+        verify_identical_file!(bucket_file)
+      else
+        # Make the directories if necessary.
+        unless ::File.directory?( path_for( bucket_file) )
+          Puppet::Util.withumask(0007) do
+            ::FileUtils.mkdir_p( path_for( bucket_file) )
+          end
+        end
+
+        Puppet.info "FileBucket adding #{bucket_file.path} as #{bucket_file.checksum}"
+
+        # Write the file to disk.
+        Puppet::Util.withumask(0007) do
+          ::File.open(contents_path_for(bucket_file), ::File::WRONLY|::File::CREAT, 0440) do |of|
+            of.print bucket_file.contents
+          end
+        end
+      end
+
+      save_path_to_paths_file(bucket_file)
+      bucket_file.checksum_data
+    end
+
+    def request_to_checksum_and_path( request )
+      return [request.key, nil] if checksum?(request.key)
+
+      checksum_type, checksum, path = request.key.split(/\//, 3)
+      return(checksum_type.to_s == "" ? nil : [ "{#{checksum_type}}#{checksum}", path ])
+    end
+
+    def path_for(bucket_file, subfile = nil)
+      bucket_path = bucket_file.bucket_path || Puppet[:bucketdir]
+      digest      = bucket_file.checksum_data
+
+      dir     = ::File.join(digest[0..7].split(""))
+      basedir = ::File.join(bucket_path, dir, digest)
+
+      return basedir unless subfile
+      ::File.join(basedir, subfile)
+    end
+
+    def contents_path_for(bucket_file)
+      path_for(bucket_file, "contents")
+    end
+
+    def paths_path_for(bucket_file)
+      path_for(bucket_file, "paths")
+    end
+
+    def content_check?
+      true
+    end
+
+    # If conflict_check is enabled, verify that the passed text is
+    # the same as the text in our file.
+    def verify_identical_file!(bucket_file)
+      return unless content_check?
+      disk_contents = ::File.read(contents_path_for(bucket_file))
+
+      # If the contents don't match, then we've found a conflict.
+      # Unlikely, but quite bad.
+      if disk_contents != bucket_file.contents
+        raise Puppet::FileBucket::BucketError, "Got passed new contents for sum #{bucket_file.checksum}", caller
+      else
+        Puppet.info "FileBucket got a duplicate file #{bucket_file.path} (#{bucket_file.checksum})"
+      end
+    end
+
+    def save_path_to_paths_file(bucket_file)
+      return unless bucket_file.path
+
+      # check for dupes
+      if ::File.exist?(paths_path_for( bucket_file) )
+        ::File.open(paths_path_for( bucket_file) ) do |f|
+          return if f.readlines.collect { |l| l.chomp }.include?(bucket_file.path)
+        end
+      end
+
+      # if it's a new file, or if our path isn't in the file yet, add it
+      ::File.open(paths_path_for(bucket_file), ::File::WRONLY|::File::CREAT|::File::APPEND) do |of|
+        of.puts bucket_file.path
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'puppet/indirector/rest'
+require 'puppet/file_bucket/file'
+
+module Puppet::FileBucketFile
+  class Rest < Puppet::Indirector::REST
+    desc "This is a REST based mechanism to send/retrieve file to/from the filebucket"
+  end
+end