puppet 0.25.5 → 2.6.0

data/lib/puppet/application/resource.rb

@@ -0,0 +1,118 @@
+require 'puppet/application'
+
+class Puppet::Application::Resource < Puppet::Application
+
+  should_not_parse_config
+
+  attr_accessor :host, :extra_params
+
+  def preinit
+    @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
+
+  def main
+    args = command_line.args
+    type = args.shift or raise "You must specify the type to display"
+    typeobj = Puppet::Type.type(type) or raise "Could not find type #{type}"
+    name = args.shift
+    params = {}
+    args.each do |setting|
+      if setting =~ /^(\w+)=(.+)$/
+        params[$1] = $2
+      else
+        raise "Invalid parameter setting #{setting}"
+      end
+    end
+
+    raise "You cannot edit a remote host" if options[:edit] and @host
+
+    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
+
+        trans.delete(param) unless properties.include?(param) or @extra_params.include?(param)
+      end
+      trans.to_manifest
+    }
+
+    if @host
+      Puppet::Resource.indirection.terminus_class = :rest
+      port = Puppet[:puppetport]
+      key = ["https://#{host}:#{port}", "production", "resources", type, name].join('/')
+    else
+      key = [type, name].join('/')
+    end
+
+    text = if name
+      if params.empty?
+        [ Puppet::Resource.find( key ) ]
+      else
+        [ Puppet::Resource.new( type, name, :parameters => params ).save( key ) ]
+      end
+    else
+      Puppet::Resource.search( key, {} )
+    end.map(&format).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
+
+  def setup
+    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

@@ -5,214 +5,231 @@ require 'puppet/network/http_pool'
 require 'puppet/util'
 
 class Puppet::Configurer
-    class CommandHookError < RuntimeError; end
+  class CommandHookError < RuntimeError; end
 
-    require 'puppet/configurer/fact_handler'
-    require 'puppet/configurer/plugin_handler'
+  require 'puppet/configurer/fact_handler'
+  require 'puppet/configurer/plugin_handler'
 
-    include Puppet::Configurer::FactHandler
-    include Puppet::Configurer::PluginHandler
+  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
-
-    def execute_postrun_command
-        execute_from_setting(:postrun_command)
-    end
-
-    def execute_prerun_command
-        execute_from_setting(:prerun_command)
-    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()
+  # For benchmarking
+  include Puppet::Util
 
-        download_plugins()
+  attr_reader :compile_time
 
-        download_fact_plugins()
+  # Provide more helpful strings to the logging that the Agent does
+  def self.to_s
+    "Puppet configuration client"
+  end
 
-        execute_prerun_command
-    end
-
-    # Get the remote catalog, yo.  Returns nil if no catalog can be found.
-    def retrieve_catalog
-        if Puppet::Resource::Catalog.indirection.terminus_class == :rest
-            # 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()
-        else
-            fact_options = {}
-        end
-
-        # First try it with no cache, then with the cache.
-        unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(fact_options)) or result = retrieve_new_catalog(fact_options)
-            if ! Puppet[:usecacheonfailure]
-                Puppet.warning "Not using cache on failed catalog"
-                return nil
-            end
-            result = retrieve_catalog_from_cache(fact_options)
-        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.finalize
-        catalog.retrieval_duration = duration
-        catalog.host_config = true
-        catalog.write_class_file
-        return catalog
+  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
+
+  def execute_postrun_command
+    execute_from_setting(:postrun_command)
+  end
+
+  def execute_prerun_command
+    execute_from_setting(:prerun_command)
+  end
+
+  # Initialize and load storage
+  def dostorage
+      Puppet::Util::Storage.load
+      @compile_time ||= Puppet::Util::Storage.cache(:configuration)[:compile_time]
+  rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Corrupt state file #{Puppet[:statefile]}: #{detail}"
+      begin
+        ::File.unlink(Puppet[:statefile])
+        retry
+      rescue => detail
+        raise Puppet::Error.new("Cannot remove #{Puppet[:statefile]}: #{detail}")
+      end
+  end
+
+  # Just so we can specify that we are "the" instance.
+  def initialize
+    Puppet.settings.use(:main, :ssl, :agent)
+
+    self.class.instance = self
+    @running = false
+    @splayed = false
+  end
+
+  def initialize_report
+    Puppet::Transaction::Report.new
+  end
+
+  # Prepare for catalog retrieval.  Downloads everything necessary, etc.
+  def prepare
+    dostorage
+
+    download_plugins
+
+    download_fact_plugins
+
+    execute_prerun_command
+  end
+
+  # Get the remote catalog, yo.  Returns nil if no catalog can be found.
+  def retrieve_catalog
+    if Puppet::Resource::Catalog.indirection.terminus_class == :rest
+      # 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
+    else
+      fact_options = {}
+    end
+
+    # First try it with no cache, then with the cache.
+    unless (Puppet[:use_cached_catalog] and result = retrieve_catalog_from_cache(fact_options)) or result = retrieve_new_catalog(fact_options)
+      if ! Puppet[:usecacheonfailure]
+        Puppet.warning "Not using cache on failed catalog"
+        return nil
+      end
+      result = retrieve_catalog_from_cache(fact_options)
+    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.finalize
+    catalog.retrieval_duration = duration
+    catalog.write_class_file
+    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 = {})
+    begin
+      prepare
+    rescue SystemExit,NoMemoryError
+      raise
+    rescue Exception => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Failed to prepare catalog: #{detail}"
     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 = {})
-        begin
-            prepare()
-        rescue SystemExit,NoMemoryError
-            raise
-        rescue Exception => detail
-            puts detail.backtrace if Puppet[:trace]
-            Puppet.err "Failed to prepare catalog: %s" % detail
-        end
-
-        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
-    ensure
-        execute_postrun_command
-    end
+    options[:report] ||= initialize_report
+    report = options[:report]
+    Puppet::Util::Log.newdestination(report)
 
-    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
+    if catalog = options[:catalog]
+      options.delete(:catalog)
+    elsif ! catalog = retrieve_catalog
+      Puppet.err "Could not retrieve catalog; skipping run"
+      return
     end
 
-    def execute_from_setting(setting)
-        return if (command = Puppet[setting]) == ""
+    transaction = nil
 
-        begin
-            Puppet::Util.execute([command])
-        rescue => detail
-            raise CommandHookError, "Could not run command from #{setting}: #{detail}"
-        end
-    end
-
-    def retrieve_catalog_from_cache(fact_options)
-        result = nil
-        @duration = thinmark do
-            result = Puppet::Resource::Catalog.find(Puppet[:certname], fact_options.merge(:ignore_terminus => true))
-        end
-        Puppet.notice "Using cached catalog"
-        result
+    begin
+      benchmark(:notice, "Finished catalog run") do
+        transaction = catalog.apply(options)
+      end
+      report
     rescue => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Could not retrieve catalog from cache: %s" % detail
-        return nil
-    end
-
-    def retrieve_new_catalog(fact_options)
-        result = nil
-        @duration = thinmark do
-            result = Puppet::Resource::Catalog.find(Puppet[:certname], fact_options.merge(:ignore_cache => true))
-        end
-        result
-    rescue SystemExit,NoMemoryError
-        raise
-    rescue Exception => detail
-        puts detail.backtrace if Puppet[:trace]
-        Puppet.err "Could not retrieve catalog from remote server: %s" % detail
-        return nil
-    end
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Failed to apply catalog: #{detail}"
+      return
+    end
+  ensure
+    # Now close all of our existing http connections, since there's no
+    # reason to leave them lying open.
+    Puppet::Network::HttpPool.clear_http_instances
+    execute_postrun_command
+
+    Puppet::Util::Log.close(report)
+
+    send_report(report, transaction)
+  end
+
+  def send_report(report, trans = nil)
+    trans.generate_report if trans
+    puts report.summary if Puppet[:summarize]
+    report.save if Puppet[:report]
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    Puppet.err "Could not send report: #{detail}"
+  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
+
+    timeout
+  end
+
+  def execute_from_setting(setting)
+    return if (command = Puppet[setting]) == ""
+
+    begin
+      Puppet::Util.execute([command])
+    rescue => detail
+      raise CommandHookError, "Could not run command from #{setting}: #{detail}"
+    end
+  end
+
+  def retrieve_catalog_from_cache(fact_options)
+    result = nil
+    @duration = thinmark do
+      result = Puppet::Resource::Catalog.find(Puppet[:certname], fact_options.merge(:ignore_terminus => true))
+    end
+    Puppet.notice "Using cached catalog"
+    result
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    Puppet.err "Could not retrieve catalog from cache: #{detail}"
+    return nil
+  end
+
+  def retrieve_new_catalog(fact_options)
+    result = nil
+    @duration = thinmark do
+      result = Puppet::Resource::Catalog.find(Puppet[:certname], fact_options.merge(:ignore_cache => true))
+    end
+    result
+  rescue SystemExit,NoMemoryError
+    raise
+  rescue Exception => detail
+    puts detail.backtrace if Puppet[:trace]
+    Puppet.err "Could not retrieve catalog from remote server: #{detail}"
+    return nil
+  end
 end