puppet 0.24.9 → 0.25.0

data/lib/puppet/application/ralsh.rb

@@ -0,0 +1,168 @@
+require 'puppet'
+require 'puppet/application'
+require 'facter'
+
+Puppet::Application.new(:ralsh) do
+
+    should_not_parse_config
+
+    attr_accessor :host, :extra_params
+
+    preinit do
+        @extra_params = []
+        @host = nil
+        Facter.loadfacts
+    end
+
+    option("--debug","-d")
+    option("--verbose","-v")
+    option("--edit","-e")
+
+    option("--host HOST","-H") do |arg|
+        @host = arg
+    end
+
+    option("--types", "-t") do |arg|
+        types = []
+        Puppet::Type.loadall
+        Puppet::Type.eachtype do |t|
+            next if t.name == :component
+            types << t.name.to_s
+        end
+        puts types.sort
+        exit
+    end
+
+    option("--param PARAM", "-p") do |arg|
+        @extra_params << arg.to_sym
+    end
+
+    command(:main) do
+        if ARGV.length > 0
+            type = ARGV.shift
+        else
+            raise "You must specify the type to display"
+        end
+
+        name = nil
+        params = {}
+        if ARGV.length > 0
+            name = ARGV.shift
+        end
+
+        if ARGV.length > 0
+            ARGV.each do |setting|
+                if setting =~ /^(\w+)=(.+)$/
+                    params[$1] = $2
+                else
+                    raise "Invalid parameter setting %s" % setting
+                end
+            end
+        end
+
+        if options[:edit] and @host
+            raise "You cannot edit a remote host"
+        end
+
+        typeobj = nil
+
+        unless typeobj = Puppet::Type.type(type)
+            raise "Could not find type %s" % type
+        end
+
+        properties = typeobj.properties.collect { |s| s.name }
+
+        format = proc {|trans|
+            trans.dup.collect do |param, value|
+                if value.nil? or value.to_s.empty?
+                    trans.delete(param)
+                elsif value.to_s == "absent" and param.to_s != "ensure"
+                    trans.delete(param)
+                end
+
+                unless properties.include?(param) or @extra_params.include?(param)
+                    trans.delete(param)
+                end
+            end
+            trans.to_manifest
+        }
+
+        text = if @host
+            client = Puppet::Network::Client.resource.new(:Server => @host, :Port => Puppet[:puppetport])
+            unless client.read_cert
+                raise "client.read_cert failed"
+            end
+            begin
+                # They asked for a single resource.
+                if name
+                    transbucket = [client.describe(type, name)]
+                else
+                    # Else, list the whole thing out.
+                    transbucket = client.instances(type)
+                end
+            rescue Puppet::Network::XMLRPCClientError => exc
+                raise "client.list(#{type}) failed: #{exc.message}"
+            end
+            transbucket.sort { |a,b| a.name <=> b.name }.collect(&format)
+        else
+            if name
+                obj = typeobj.new(:name => name, :check => properties)
+                vals = obj.retrieve
+
+                unless params.empty?
+                    params.each do |param, value|
+                        obj[param] = value
+                    end
+                    catalog = Puppet::Resource::Catalog.new
+                    catalog.add_resource obj
+                    begin
+                        catalog.apply
+                    rescue => detail
+                        if Puppet[:trace]
+                            puts detail.backtrace
+                        end
+                    end
+
+                end
+                [format.call(obj.to_trans(true))]
+            else
+                typeobj.instances.collect do |obj|
+                    next if ARGV.length > 0 and ! ARGV.include? obj.name
+                    trans = obj.to_trans(true)
+                    format.call(trans)
+                end
+            end
+        end.compact.join("\n")
+
+        if options[:edit]
+            file = "/tmp/x2puppet-#{Process.pid}.pp"
+            begin
+                File.open(file, "w") do |f|
+                    f.puts text
+                end
+                ENV["EDITOR"] ||= "vi"
+                system(ENV["EDITOR"], file)
+                system("puppet -v " + file)
+            ensure
+                #if FileTest.exists? file
+                #    File.unlink(file)
+                #end
+            end
+        else
+            puts text
+        end
+    end
+
+    setup do
+        Puppet::Util::Log.newdestination(:console)
+
+        # Now parse the config
+        Puppet.parse_config
+
+        if options[:debug]
+            Puppet::Util::Log.level = :debug
+        elsif options[:verbose]
+            Puppet::Util::Log.level = :info
+        end
+    end
+end

data/lib/puppet/configurer.rb

@@ -0,0 +1,177 @@
+# The client for interacting with the puppetmaster config server.
+require 'sync'
+require 'timeout'
+require 'puppet/network/http_pool'
+require 'puppet/util'
+
+class Puppet::Configurer
+    require 'puppet/configurer/fact_handler'
+    require 'puppet/configurer/plugin_handler'
+
+    include Puppet::Configurer::FactHandler
+    include Puppet::Configurer::PluginHandler
+
+    # For benchmarking
+    include Puppet::Util
+
+    attr_accessor :catalog
+    attr_reader :compile_time
+
+    # Provide more helpful strings to the logging that the Agent does
+    def self.to_s
+        "Puppet configuration client"
+    end
+
+    class << self
+        # Puppetd should only have one instance running, and we need a way
+        # to retrieve it.
+        attr_accessor :instance
+        include Puppet::Util
+    end
+
+    # How to lock instances of this class.
+    def self.lockfile_path
+        Puppet[:puppetdlockfile]
+    end
+
+    def clear
+        @catalog.clear(true) if @catalog
+        @catalog = nil
+    end
+
+    # Initialize and load storage
+    def dostorage
+        begin
+            Puppet::Util::Storage.load
+            @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
+        rescue => detail
+            if Puppet[:trace]
+                puts detail.backtrace
+            end
+            Puppet.err "Corrupt state file %s: %s" % [Puppet[:statefile], detail]
+            begin
+                ::File.unlink(Puppet[:statefile])
+                retry
+            rescue => detail
+                raise Puppet::Error.new("Cannot remove %s: %s" %
+                    [Puppet[:statefile], detail])
+            end
+        end
+    end
+
+    # Just so we can specify that we are "the" instance.
+    def initialize
+        Puppet.settings.use(:main, :ssl, :puppetd)
+
+        self.class.instance = self
+        @running = false
+        @splayed = false
+    end
+
+    # Prepare for catalog retrieval.  Downloads everything necessary, etc.
+    def prepare
+        dostorage()
+
+        download_plugins()
+
+        download_fact_plugins()
+    end
+
+    # Get the remote catalog, yo.  Returns nil if no catalog can be found.
+    def retrieve_catalog
+        name = Puppet[:certname]
+        catalog_class = Puppet::Resource::Catalog
+
+        # This is a bit complicated.  We need the serialized and escaped facts,
+        # and we need to know which format they're encoded in.  Thus, we
+        # get a hash with both of these pieces of information.
+        fact_options = facts_for_uploading()
+
+        # First try it with no cache, then with the cache.
+        result = nil
+        begin
+            duration = thinmark do
+                result = catalog_class.find(name, fact_options.merge(:ignore_cache => true))
+            end
+        rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            Puppet.err "Could not retrieve catalog from remote server: %s" % detail
+        end
+
+        unless result
+            if ! Puppet[:usecacheonfailure]
+                Puppet.warning "Not using cache on failed catalog"
+                return nil
+            end
+
+            begin
+                duration = thinmark do
+                    result = catalog_class.find(name, fact_options.merge(:ignore_terminus => true))
+                end
+                Puppet.notice "Using cached catalog"
+            rescue => detail
+                puts detail.backtrace if Puppet[:trace]
+                Puppet.err "Could not retrieve catalog from cache: %s" % detail
+            end
+        end
+
+        return nil unless result
+
+        convert_catalog(result, duration)
+    end
+
+    # Convert a plain resource catalog into our full host catalog.
+    def convert_catalog(result, duration)
+        catalog = result.to_ral
+        catalog.retrieval_duration = duration
+        catalog.host_config = true
+        catalog.write_class_file
+        return catalog
+    end
+
+    # The code that actually runs the catalog.
+    # This just passes any options on to the catalog,
+    # which accepts :tags and :ignoreschedules.
+    def run(options = {})
+        prepare()
+
+        if catalog = options[:catalog]
+            options.delete(:catalog)
+        elsif ! catalog = retrieve_catalog
+            Puppet.err "Could not retrieve catalog; skipping run"
+            return
+        end
+
+        begin
+            benchmark(:notice, "Finished catalog run") do
+                catalog.apply(options)
+            end
+        rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            Puppet.err "Failed to apply catalog: %s" % detail
+        end
+
+        # Now close all of our existing http connections, since there's no
+        # reason to leave them lying open.
+        Puppet::Network::HttpPool.clear_http_instances
+    end
+
+    private
+
+    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
+end

data/lib/puppet/configurer/downloader.rb

@@ -0,0 +1,79 @@
+require 'puppet/configurer'
+require 'puppet/resource/catalog'
+
+class Puppet::Configurer::Downloader
+    attr_reader :name, :path, :source, :ignore
+
+    # Determine the timeout value to use.
+    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
+
+    # Evaluate our download, returning the list of changed values.
+    def evaluate
+        Puppet.info "Retrieving #{name}"
+
+        files = []
+        begin
+            Timeout.timeout(self.class.timeout) do
+                catalog.apply do |trans|
+                    trans.changed?.find_all do |resource|
+                        yield resource if block_given?
+                        files << resource[:path]
+                    end
+                end
+            end
+        rescue Puppet::Error, Timeout::Error => detail
+            puts detail.backtrace if Puppet[:debug]
+            Puppet.err "Could not retrieve #{name}: %s" % detail
+        end
+
+        return files
+    end
+
+    def initialize(name, path, source, ignore = nil)
+        @name, @path, @source, @ignore = name, path, source, ignore
+    end
+
+    def catalog
+        catalog = Puppet::Resource::Catalog.new
+        catalog.add_resource(file)
+        catalog
+    end
+
+    def file
+        args = default_arguments.merge(:path => path, :source => source)
+        args[:ignore] = ignore.split if ignore
+        Puppet::Type.type(:file).new(args)
+    end
+
+    private
+
+    def default_arguments
+        {
+            :path => path,
+            :recurse => true,
+            :source => source,
+            :tag => name,
+            :owner => Process.uid,
+            :group => Process.gid,
+            :purge => true,
+            :force => true,
+            :backup => false,
+            :noop => false
+        }
+    end
+end

data/lib/puppet/configurer/fact_handler.rb

@@ -0,0 +1,68 @@
+require 'puppet/indirector/facts/facter'
+
+require 'puppet/configurer/downloader'
+
+# Break out the code related to facts.  This module is
+# just included into the agent, but having it here makes it
+# easier to test.
+module Puppet::Configurer::FactHandler
+    def download_fact_plugins?
+        Puppet[:factsync]
+    end
+
+    def find_facts
+        reload_facter()
+
+        # This works because puppetd configures Facts to use 'facter' for
+        # finding facts and the 'rest' terminus for caching them.  Thus, we'll
+        # compile them and then "cache" them on the server.
+        begin
+            Puppet::Node::Facts.find(Puppet[:certname])
+        rescue => detail
+            puts detail.backtrace if Puppet[:trace]
+            raise Puppet::Error, "Could not retrieve local facts: %s" % detail
+        end
+    end
+
+    def facts_for_uploading
+        facts = find_facts
+        #format = facts.class.default_format
+
+        # Hard-code yaml, because I couldn't get marshal to work.
+        format = :yaml
+
+        text = facts.render(format)
+
+        return {:facts_format => format, :facts => CGI.escape(text)}
+    end
+
+    # Retrieve facts from the central server.
+    def download_fact_plugins
+        return unless download_fact_plugins?
+
+        # Deprecated prior to 0.25, as of 5/19/2008
+        Puppet.warning "Fact syncing is deprecated as of 0.25 -- use 'pluginsync' instead"
+
+        Puppet::Configurer::Downloader.new("fact", Puppet[:factdest], Puppet[:factsource], Puppet[:factsignore]).evaluate
+    end
+
+    # Clear out all of the loaded facts and reload them from disk.
+    # NOTE: This is clumsy and shouldn't be required for later (1.5.x) versions
+    # of Facter.
+    def 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
+
+        # This loads all existing facts and any new ones.  We have to remove and
+        # reload because there's no way to unload specific facts.
+        Puppet::Node::Facts::Facter.load_fact_plugins()
+    end
+end