puppet 0.24.9 → 0.25.0

data/lib/puppet/file_serving/mount/file.rb

@@ -0,0 +1,126 @@
+require 'puppet/util/cacher'
+
+require 'puppet/file_serving/mount'
+
+class Puppet::FileServing::Mount::File < Puppet::FileServing::Mount
+    class << self
+        include Puppet::Util::Cacher
+
+        cached_attr(:localmap) do
+            {   "h" =>  Facter.value("hostname"),
+                "H" => [Facter.value("hostname"),
+                        Facter.value("domain")].join("."),
+                "d" =>  Facter.value("domain")
+            }
+        end
+    end
+
+    def complete_path(relative_path, node)
+        full_path = path(node)
+
+        raise ArgumentError.new("Mounts without paths are not usable") unless full_path
+
+        # If there's no relative path name, then we're serving the mount itself.
+        return full_path unless relative_path
+
+        file = ::File.join(full_path, relative_path)
+
+        return nil unless FileTest.exist?(file)
+
+        return file
+    end
+
+    # Return an instance of the appropriate class.
+    def find(short_file, request)
+        complete_path(short_file, request.node)
+    end
+
+    # Return the path as appropriate, expanding as necessary.
+    def path(node = nil)
+        if expandable?
+            return expand(@path, node)
+        else
+            return @path
+        end
+    end
+
+    # Set the path.
+    def path=(path)
+        # FIXME: For now, just don't validate paths with replacement
+        # patterns in them.
+        if path =~ /%./
+            # Mark that we're expandable.
+            @expandable = true
+        else
+            unless FileTest.directory?(path)
+                raise ArgumentError, "%s does not exist or is not a directory" % path
+            end
+            unless FileTest.readable?(path)
+                raise ArgumentError, "%s is not readable" % path
+            end
+            @expandable = false
+        end
+        @path = path
+    end
+
+    def search(path, request)
+        return nil unless path = complete_path(path, request.node)
+        return [path]
+    end
+
+    # Verify our configuration is valid.  This should really check to
+    # make sure at least someone will be allowed, but, eh.
+    def validate
+        raise ArgumentError.new("Mounts without paths are not usable") if @path.nil?
+    end
+
+    private
+
+    # Create a map for a specific node.
+    def clientmap(node)
+        {
+            "h" => node.sub(/\..*$/, ""),
+            "H" => node,
+            "d" => node.sub(/[^.]+\./, "") # domain name
+        }
+    end
+
+    # Replace % patterns as appropriate.
+    def expand(path, node = nil)
+        # This map should probably be moved into a method.
+        map = nil
+
+        if node
+            map = clientmap(node)
+        else
+            Puppet.notice "No client; expanding '%s' with local host" %
+                path
+            # Else, use the local information
+            map = localmap()
+        end
+
+        path.gsub(/%(.)/) do |v|
+            key = $1
+            if key == "%"
+                "%"
+            else
+                map[key] || v
+            end
+        end
+    end
+
+    # Do we have any patterns in our path, yo?
+    def expandable?
+        if defined? @expandable
+            @expandable
+        else
+            false
+        end
+    end
+
+    # Cache this manufactured map, since if it's used it's likely
+    # to get used a lot.
+    def localmap
+        self.class.localmap
+    end
+end

data/lib/puppet/file_serving/mount/modules.rb

@@ -0,0 +1,25 @@
+require 'puppet/file_serving/mount'
+
+# This is the modules-specific mount: it knows how to search through
+# modules for files.  Yay.
+class Puppet::FileServing::Mount::Modules < Puppet::FileServing::Mount
+    # Return an instance of the appropriate class.
+    def find(path, request)
+        module_name, relative_path = path.split("/", 2)
+        return nil unless mod = request.environment.module(module_name)
+
+        mod.file(relative_path)
+    end
+
+    def search(path, request)
+        module_name, relative_path = path.split("/", 2)
+        return nil unless mod = request.environment.module(module_name)
+
+        return nil unless path = mod.file(relative_path)
+        return [path]
+    end
+
+    def valid?
+        true
+    end
+end

data/lib/puppet/file_serving/mount/plugins.rb

@@ -0,0 +1,27 @@
+require 'puppet/file_serving/mount'
+
+# Find files in the modules' plugins directories.
+# This is a very strange mount because it merges
+# many directories into one.
+class Puppet::FileServing::Mount::Plugins < Puppet::FileServing::Mount
+    # Return an instance of the appropriate class.
+    def find(relative_path, request)
+        return nil unless mod = request.environment.modules.find { |mod|  mod.plugin(relative_path) }
+
+        path = mod.plugin(relative_path)
+
+        return path
+    end
+
+    def search(relative_path, request)
+        # We currently only support one kind of search on plugins - return
+        # them all.
+        paths = request.environment.modules.find_all { |mod| mod.plugins? }.collect { |mod| mod.plugin_directory }
+        return nil if paths.empty?
+        return paths
+    end
+
+    def valid?
+        true
+    end
+end

data/lib/puppet/file_serving/terminus_helper.rb

@@ -8,11 +8,16 @@ require 'puppet/file_serving/fileset'
 # Define some common methods for FileServing termini.
 module Puppet::FileServing::TerminusHelper
     # Create model instances for all files in a fileset.
-    def path2instances(request, path)
-        args = [:links, :ignore, :recurse].inject({}) { |hash, param| hash[param] = request.options[param] if request.options[param]; hash }
-        Puppet::FileServing::Fileset.new(path, args).files.collect do |file|
-            inst = model.new(File.join(request.key, file), :path => path, :relative_path => file)
+    def path2instances(request, *paths)
+        filesets = paths.collect do |path|
+            # Filesets support indirector requests as an options collection
+            Puppet::FileServing::Fileset.new(path, request)
+        end
+
+        Puppet::FileServing::Fileset.merge(*filesets).collect do |file, base_path|
+            inst = model.new(base_path, :relative_path => file)
             inst.links = request.options[:links] if request.options[:links]
+            inst.collect
             inst
         end
     end

data/lib/puppet/indirector.rb

@@ -10,6 +10,7 @@ module Puppet::Indirector
     require 'puppet/indirector/indirection'
     require 'puppet/indirector/terminus'
     require 'puppet/indirector/envelope'
+    require 'puppet/network/format_handler'
 
     # Declare that the including class indirects its methods to
     # this terminus.  The terminus name must be the name of a Puppet
@@ -22,6 +23,7 @@ module Puppet::Indirector
         extend ClassMethods
         include InstanceMethods
         include Puppet::Indirector::Envelope
+        extend Puppet::Network::FormatHandler
 
         # instantiate the actual Terminus for that type and this name (:ldap, w/ args :node)
         # & hook the instantiated Terminus into this class (Node: @indirection = terminus)
@@ -42,19 +44,19 @@ module Puppet::Indirector
          
         # Expire any cached instance.
         def expire(*args)
-            indirection.expire *args
+            indirection.expire(*args)
         end
          
         def find(*args)
-            indirection.find *args
+            indirection.find(*args)
         end
 
         def destroy(*args)
-            indirection.destroy *args
+            indirection.destroy(*args)
         end
 
         def search(*args)
-            indirection.search *args
+            indirection.search(*args)
         end
     end
 

data/lib/puppet/indirector/active_record.rb

@@ -0,0 +1,28 @@
+require 'puppet/indirector'
+
+class Puppet::Indirector::ActiveRecord < Puppet::Indirector::Terminus
+    class << self
+        attr_accessor :ar_model
+    end
+
+    def self.use_ar_model(klass)
+        self.ar_model = klass
+    end
+
+    def ar_model
+        self.class.ar_model
+    end
+
+    def initialize
+        Puppet::Rails.init
+    end
+
+    def find(request)
+        return nil unless instance = ar_model.find_by_name(request.key)
+        instance.to_puppet
+    end
+
+    def save(request)
+        ar_model.from_puppet(request.instance).save
+    end
+end

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

@@ -0,0 +1,36 @@
+require 'puppet/rails/host'
+require 'puppet/indirector/active_record'
+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.
+    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
+    end
+
+    # Save the values from a Facts instance as the facts on a Rails Host instance.
+    def save(request)
+        catalog = request.instance
+
+        host = ar_model.find_by_name(catalog.name) || ar_model.create(:name => catalog.name)
+
+        host.railsmark "Saved catalog to database" do
+            host.merge_resources(catalog.vertices)
+            host.last_compile = Time.now
+
+            host.save
+        end
+    end
+end

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

@@ -1,10 +1,10 @@
 require 'puppet/node'
-require 'puppet/node/catalog'
+require 'puppet/resource/catalog'
 require 'puppet/indirector/code'
 require 'puppet/parser/interpreter'
 require 'yaml'
 
-class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
+class Puppet::Resource::Catalog::Compiler < Puppet::Indirector::Code
     desc "Puppet's catalog compilation interface, and its back-end is
         Puppet's compiler"
 
@@ -12,11 +12,25 @@ class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
 
     attr_accessor :code
 
+    def extract_facts_from_request(request)
+        return unless text_facts = request.options[:facts]
+        raise ArgumentError, "Facts but no fact format provided for %s" % 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.
+        if text_facts.is_a?(Puppet::Node::Facts)
+            facts = text_facts
+        else
+            facts = Puppet::Node::Facts.convert_from(format, text_facts)
+        end
+        facts.save
+    end
+
     # Compile a node's catalog.
     def find(request)
-        unless node = request.options[:use_node] || find_node(request.key)
-            raise ArgumentError, "Could not find node '%s'; cannot compile" % request.key
-        end
+        extract_facts_from_request(request)
+
+        node = node_from_request(request)
 
         if catalog = compile(node)
             return catalog
@@ -27,6 +41,12 @@ class Puppet::Node::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)
+        catalog
+    end
+
     def initialize
         set_server_facts
     end
@@ -81,15 +101,14 @@ class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
     end
 
     # Turn our host name into a node object.
-    def find_node(key)
-        # If we want to use the cert name as our key
-        # LAK:FIXME This needs to be figured out somehow, but it requires the routing.
-        # This should be able to use the request, yay.
-        #if Puppet[:node_name] == 'cert' and client
-        #    key = client
-        #end
+    def find_node(name)
+        begin
+            return nil unless node = Puppet::Node.find(name)
+        rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            raise Puppet::Error, "Failed when searching for node %s: %s" % [name, detail]
+        end
 
-        return nil unless node = Puppet::Node.find(key)
 
         # Add any external data to the node.
         add_node_data(node)
@@ -97,6 +116,24 @@ class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
         node
     end
 
+    # Extract the node from the request, or use the request
+    # to find the node.
+    def node_from_request(request)
+        if node = request.options[:use_node]
+            return node
+        end
+
+        # If the request is authenticated, then the 'node' info will
+        # be available; if not, then we use the passed-in key.  We rely
+        # on our authorization system to determine whether this is allowed.
+        name = request.node || request.key
+        if node = find_node(name)
+            return node
+        end
+
+        raise ArgumentError, "Could not find node '%s'; cannot compile" % name
+    end
+
     # Initialize our server fact hash; we add these to each client, and they
     # won't change while we're running, so it's safe to cache the values.
     def set_server_facts
@@ -126,17 +163,6 @@ class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
         end
     end
 
-    # Translate our catalog appropriately for sending back to a client.
-    # LAK:FIXME This method should probably be part of the protocol, but it
-    # shouldn't be here.
-    def translate(config)
-        unless networked?
-            config
-        else
-            CGI.escape(config.to_yaml(:UseBlock => true))
-        end
-    end
-
     # Mark that the node has checked in. LAK:FIXME this needs to be moved into
     # the Node class, or somewhere that's got abstract backends.
     def update_node_check(node)

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

@@ -0,0 +1,5 @@
+require 'puppet/resource/catalog'
+require 'puppet/indirector/queue'
+
+class Puppet::Resource::Catalog::Queue < Puppet::Indirector::Queue
+end

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

@@ -0,0 +1,6 @@
+require 'puppet/resource/catalog'
+require 'puppet/indirector/rest'
+
+class Puppet::Resource::Catalog::Rest < Puppet::Indirector::REST
+    desc "Find resource catalogs over HTTP via REST."
+end

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

@@ -1,7 +1,7 @@
-require 'puppet/node/catalog'
+require 'puppet/resource/catalog'
 require 'puppet/indirector/yaml'
 
-class Puppet::Node::Catalog::Yaml < Puppet::Indirector::Yaml
+class Puppet::Resource::Catalog::Yaml < Puppet::Indirector::Yaml
     desc "Store catalogs as flat files, serialized using YAML."
 
     private
@@ -10,8 +10,6 @@ class Puppet::Node::Catalog::Yaml < Puppet::Indirector::Yaml
     # objects.  This is hackish, but eh.
     def from_yaml(text)
         if config = YAML.load(text)
-            # We can't yaml-dump classes.
-            #config.edgelist_class = Puppet::Relationship
             return config
         end
     end