puppet 0.23.2 → 0.24.0

data/lib/puppet/file_serving/terminus_helper.rb

@@ -0,0 +1,19 @@
+#
+#  Created by Luke Kanies on 2007-10-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet/file_serving'
+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(key, path, options = {})
+        args = [:links, :ignore, :recurse].inject({}) { |hash, param| hash[param] = options[param] if options[param]; hash }
+        Puppet::FileServing::Fileset.new(path, args).files.collect do |file|
+            inst = model.new(File.join(key, file), :path => path, :relative_path => file)
+            inst.links = options[:links] if options[:links]
+            inst
+        end
+    end
+end

data/lib/puppet/indirector.rb

@@ -0,0 +1,68 @@
+# Manage indirections to termini.  They are organized in terms of indirections -
+# - e.g., configuration, node, file, certificate -- and each indirection has one
+# or more terminus types defined.  The indirection is configured via the
+# +indirects+ method, which will be called by the class extending itself
+# with this module.
+module Puppet::Indirector
+    # LAK:FIXME We need to figure out how to handle documentation for the
+    # different indirection types.
+
+    require 'puppet/indirector/indirection'
+    require 'puppet/indirector/terminus'
+
+    # Declare that the including class indirects its methods to
+    # this terminus.  The terminus name must be the name of a Puppet
+    # default, not the value -- if it's the value, then it gets
+    # evaluated at parse time, which is before the user has had a chance
+    # to override it.
+    def indirects(indirection, options = {})
+        raise(ArgumentError, "Already handling indirection for %s; cannot also handle %s" % [@indirection.name, indirection]) if defined?(@indirection) and @indirection
+        # populate this class with the various new methods
+        extend ClassMethods
+        include InstanceMethods
+
+        # 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
+    end
+
+    module ClassMethods   
+      attr_reader :indirection
+
+      def cache_class=(klass)
+          indirection.cache_class = klass
+      end
+
+      def terminus_class=(klass)
+          indirection.terminus_class = klass
+      end
+         
+      def find(*args)
+        indirection.find(*args)
+      end
+
+      def destroy(*args)
+        indirection.destroy(*args)
+      end
+
+      def search(*args)
+        indirection.search(*args)
+      end
+
+      def version(*args)
+        indirection.version(*args)
+      end
+    end
+
+    module InstanceMethods
+      # Make it easy for the model to set versions,
+      # which are used for caching and such.
+      attr_accessor :version
+
+      # these become instance methods 
+      def save(*args)
+        self.class.indirection.save(self, *args)
+      end
+    end
+end

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

@@ -0,0 +1,173 @@
+require 'puppet/node'
+require 'puppet/node/catalog'
+require 'puppet/indirector/code'
+require 'puppet/parser/interpreter'
+require 'yaml'
+
+class Puppet::Node::Catalog::Compiler < Puppet::Indirector::Code
+    desc "Puppet's catalog compilation interface, and its back-end is
+        Puppet's compiler"
+
+    include Puppet::Util
+
+    attr_accessor :code
+
+    # Compile a node's catalog.
+    def find(key, client = nil, clientip = nil)
+        if key.is_a?(Puppet::Node)
+            node = key
+        else
+            node = find_node(key)
+        end
+
+        if catalog = compile(node)
+            return catalog.to_transportable
+        else
+            # This shouldn't actually happen; we should either return
+            # a config or raise an exception.
+            return nil
+        end
+    end
+
+    def initialize
+        set_server_facts
+    end
+
+    # Create/return our interpreter.
+    def interpreter
+        unless defined?(@interpreter) and @interpreter
+            @interpreter = create_interpreter
+        end
+        @interpreter
+    end
+
+    # Is our compiler part of a network, or are we just local?
+    def networked?
+        $0 =~ /puppetmasterd/
+    end
+
+    # Return the catalog version.  Here we're returning the
+    # latest of the node, fact, or parse date.  These are the
+    # three things that go into compiling a client catalog,
+    # so changes in any of them result in changes.
+    # LAK:FIXME Note that this only works when all three sources
+    # use timestamps; once one of them moves to using real versions,
+    # the comparison stops working.
+    def version(key)
+        if node = Puppet::Node.find_by_any_name(key)
+            return [Puppet::Node.version(key).to_f, Puppet::Node::Facts.version(key).to_f, interpreter.catalog_version(node).to_f].sort[-1]
+        else
+            # This is the standard for "got nothing for ya".
+            0
+        end
+    end
+
+    private
+
+    # 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.
+        node.merge(@server_facts)
+    end
+
+    # Compile the actual catalog.
+    def compile(node)
+        # Ask the interpreter to compile the catalog.
+        str = "Compiled catalog for %s" % node.name
+        if node.environment
+            str += " in environment %s" % node.environment
+        end
+        config = nil
+
+        loglevel = networked? ? :notice : :none
+
+        benchmark(loglevel, "Compiled catalog for %s" % node.name) do
+            begin
+                config = interpreter.compile(node)
+            rescue Puppet::Error => detail
+                Puppet.err(detail.to_s) if networked?
+                raise
+            end
+        end
+
+        return config
+    end
+
+    # Create our interpreter object.
+    def create_interpreter
+        return Puppet::Parser::Interpreter.new
+    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.
+        #if Puppet[:node_name] == 'cert' and client
+        #    key = client
+        #end
+
+        # Note that this is reasonable, because either their node source should actually
+        # know about the node, or they should be using the ``null`` node source, which
+        # will always return data.
+        unless node = Puppet::Node.find_by_any_name(key)
+            raise Puppet::Error, "Could not find node '%s'" % key
+        end
+
+        # Add any external data to the node.
+        add_node_data(node)
+
+        node
+    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
+        @server_facts = {}
+
+        # Add our server version to the fact list
+        @server_facts["serverversion"] = Puppet.version.to_s
+
+        # And then add the server name and IP
+        {"servername" => "fqdn",
+            "serverip" => "ipaddress"
+        }.each do |var, fact|
+            if value = Facter.value(fact)
+                @server_facts[var] = value
+            else
+                Puppet.warning "Could not retrieve fact %s" % fact
+            end
+        end
+
+        if @server_facts["servername"].nil?
+            host = Facter.value(:hostname)
+            if domain = Facter.value(:domain)
+                @server_facts["servername"] = [host, domain].join(".")
+            else
+                @server_facts["servername"] = host
+            end
+        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)
+        if Puppet.features.rails? and Puppet[:storeconfigs]
+            Puppet::Rails.connect
+
+            host = Puppet::Rails::Host.find_or_create_by_name(node.name)
+            host.last_freshcheck = Time.now
+            host.save
+        end
+    end
+end

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

@@ -0,0 +1,24 @@
+require 'puppet/node/catalog'
+require 'puppet/indirector/yaml'
+
+class Puppet::Node::Catalog::Yaml < Puppet::Indirector::Yaml
+    desc "Store catalogs as flat files, serialized using YAML."
+
+    private
+
+    # Override these, because yaml doesn't want to convert our self-referential
+    # 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
+
+    def to_yaml(config)
+        # We can't yaml-dump classes.
+        #config.edgelist_class = nil
+        YAML.dump(config)
+    end
+end

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

@@ -0,0 +1,33 @@
+require 'puppet/checksum'
+require 'puppet/indirector/file'
+
+class Puppet::Checksum::File < Puppet::Indirector::File
+    desc "Store files in a directory set based on their checksums."
+
+    def initialize
+        Puppet.settings.use(:filebucket)
+    end
+
+    def path(checksum)
+        path = []
+        path << Puppet[:bucketdir]                              # Start with the base directory
+        path << checksum[0..7].split("").join(File::SEPARATOR)  # Add sets of directories based on the checksum
+        path << checksum                                        # And the full checksum name itself
+        path << "contents"                                      # And the actual file name
+
+        path.join(File::SEPARATOR)
+    end
+
+    def save(file)
+        path = File.dirname(path(file.name))
+
+        # Make the directories if necessary.
+        unless FileTest.directory?(path)
+            Puppet::Util.withumask(0007) do
+                FileUtils.mkdir_p(path)
+            end
+        end
+
+        super
+    end
+end

data/lib/puppet/indirector/code.rb

@@ -0,0 +1,6 @@
+require 'puppet/indirector/terminus'
+
+# Do nothing, requiring that the back-end terminus do all
+# of the work.
+class Puppet::Indirector::Code < Puppet::Indirector::Terminus
+end

data/lib/puppet/indirector/direct_file_server.rb

@@ -0,0 +1,27 @@
+#
+#  Created by Luke Kanies on 2007-10-24.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppet/file_serving/terminus_helper'
+require 'puppet/util/uri_helper'
+require 'puppet/indirector/terminus'
+
+class Puppet::Indirector::DirectFileServer < Puppet::Indirector::Terminus
+
+    include Puppet::Util::URIHelper
+    include Puppet::FileServing::TerminusHelper
+
+    def find(key, options = {})
+        uri = key2uri(key)
+        return nil unless FileTest.exists?(uri.path)
+        instance = model.new(key, :path => uri.path)
+        instance.links = options[:links] if options[:links]
+        return instance
+    end
+
+    def search(key, options = {})
+        uri = key2uri(key)
+        return nil unless FileTest.exists?(uri.path)
+        path2instances(key, uri.path, options)
+    end
+end

data/lib/puppet/indirector/exec.rb

@@ -0,0 +1,57 @@
+require 'puppet/indirector/terminus'
+require 'puppet/util'
+
+class Puppet::Indirector::Exec < Puppet::Indirector::Terminus
+    # Look for external node definitions.
+    def find(name)
+        # Run the command.
+        unless output = query(name)
+            return nil
+        end
+
+        # Translate the output to ruby.
+        return output
+    end
+
+    private
+
+    # Proxy the execution, so it's easier to test.
+    def execute(command)
+        Puppet::Util.execute(command)
+    end
+
+    # Call the external command and see if it returns our output.
+    def query(name)
+        external_command = command
+
+        # Make sure it's an arry
+        unless external_command.is_a?(Array)
+            raise Puppet::DevError, "Exec commands must be an array"
+        end
+
+        # Make sure it's fully qualified.
+        unless external_command[0][0] == File::SEPARATOR[0]
+            raise ArgumentError, "You must set the exec parameter to a fully qualified command"
+        end
+
+        # Add our name to it.
+        external_command << name
+        begin
+            output = execute(external_command)
+        rescue Puppet::ExecutionFailure => detail
+            if $?.exitstatus == 1
+                return nil
+            else
+                Puppet.err "Could not retrieve external node information for %s: %s" % [name, detail]
+            end
+            return nil
+        end
+        
+        if output =~ /\A\s*\Z/ # all whitespace
+            Puppet.debug "Empty response for %s from exec %s terminus" % [name, self.name]
+            return nil
+        else
+            return output
+        end
+    end
+end

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

@@ -0,0 +1,65 @@
+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."
+
+    def self.loaddir(dir, type)
+        return unless FileTest.directory?(dir)
+
+        Dir.entries(dir).find_all { |e| e =~ /\.rb$/ }.each do |file|
+            fqfile = ::File.join(dir, file)
+            begin
+                Puppet.info "Loading #{type} %s" % ::File.basename(file.sub(".rb",''))
+                Timeout::timeout(self.timeout) do
+                    load fqfile
+                end
+            rescue => detail
+                Puppet.warning "Could not load #{type} %s: %s" % [fqfile, detail]
+            end
+        end
+    end
+
+    def self.loadfacts
+        Puppet[:factpath].split(":").each do |dir|
+            loaddir(dir, "fact")
+        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
+    end
+
+    def initialize(*args)
+        super
+        self.class.loadfacts
+    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
+
+    # Look a host's facts up in Facter.
+    def find(key)
+        Puppet::Node::Facts.new(key, Facter.to_hash)
+    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