puppet-parse 0.0.1 → 0.0.2

data/lib/vendor/puppet/configurer.rb

@@ -0,0 +1,249 @@
+# 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_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
+      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
+
+  # Prepare for catalog retrieval.  Downloads everything necessary, etc.
+  def prepare(options)
+    dostorage
+
+    download_plugins unless options[:skip_plugin_download]
+
+    download_fact_plugins unless options[:skip_plugin_download]
+  end
+
+  # Get the remote catalog, yo.  Returns nil if no catalog can be found.
+  def retrieve_catalog(fact_options)
+    fact_options ||= {}
+    # 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.write_resource_file
+    catalog
+  end
+
+  # Retrieve (optionally) and apply a catalog. If a catalog is passed in
+  # the options, then apply that one, otherwise retrieve it.
+  def retrieve_and_apply_catalog(options, fact_options)
+    unless catalog = (options.delete(:catalog) || retrieve_catalog(fact_options))
+      Puppet.err "Could not retrieve catalog; skipping run"
+      return
+    end
+
+    report = options[:report]
+    report.configuration_version = catalog.version
+    report.environment = Puppet[:environment]
+
+    benchmark(:notice, "Finished catalog run") do
+      catalog.apply(options)
+    end
+
+    report.finalize_report
+    report
+  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 = {})
+    options[:report] ||= Puppet::Transaction::Report.new("apply")
+    report = options[:report]
+
+    Puppet::Util::Log.newdestination(report)
+    begin
+      prepare(options)
+
+      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
+      end
+
+      # set report host name now that we have the fact
+      report.host = Puppet[:node_name_value]
+
+      begin
+        execute_prerun_command or return nil
+        retrieve_and_apply_catalog(options, fact_options)
+      rescue SystemExit,NoMemoryError
+        raise
+      rescue => detail
+        puts detail.backtrace if Puppet[:trace]
+        Puppet.err "Failed to apply catalog: #{detail}"
+        return nil
+      ensure
+        execute_postrun_command or return nil
+      end
+    ensure
+      # Make sure we forget the retained module_directories of any autoload
+      # we might have used.
+      Thread.current[:env_module_directories] = nil
+    end
+  ensure
+    Puppet::Util::Log.close(report)
+    send_report(report)
+  end
+
+  def send_report(report)
+    puts report.summary if Puppet[:summarize]
+    save_last_run_summary(report)
+    Puppet::Transaction::Report.indirection.save(report) if Puppet[:report]
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    Puppet.err "Could not send report: #{detail}"
+  end
+
+  def save_last_run_summary(report)
+    mode = Puppet.settings.setting(:lastrunfile).mode
+    Puppet::Util.replace_file(Puppet[:lastrunfile], mode) do |fh|
+      fh.print YAML.dump(report.raw_summary)
+    end
+  rescue => detail
+    puts detail.backtrace if Puppet[:trace]
+    Puppet.err "Could not save last run local 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 true if (command = Puppet[setting]) == ""
+
+    begin
+      Puppet::Util.execute([command])
+      true
+    rescue => detail
+      puts detail.backtrace if Puppet[:trace]
+      Puppet.err "Could not run command from #{setting}: #{detail}"
+      false
+    end
+  end
+
+  def retrieve_catalog_from_cache(fact_options)
+    result = nil
+    @duration = thinmark do
+      result = Puppet::Resource::Catalog.indirection.find(Puppet[:node_name_value], 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.indirection.find(Puppet[:node_name_value], 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

data/lib/vendor/puppet/daemon.rb

@@ -0,0 +1,200 @@
+require 'puppet'
+require 'puppet/util/pidlock'
+require 'puppet/application'
+
+# A module that handles operations common to all daemons.  This is included
+# into the Server and Client base classes.
+class Puppet::Daemon
+  attr_accessor :agent, :server, :argv
+
+  def daemonname
+    Puppet[:name]
+  end
+
+  # Put the daemon into the background.
+  def daemonize
+    if pid = fork
+      Process.detach(pid)
+      exit(0)
+    end
+
+    create_pidfile
+
+    # Get rid of console logging
+    Puppet::Util::Log.close(:console)
+
+    Process.setsid
+    Dir.chdir("/")
+    begin
+      $stdin.reopen "/dev/null"
+      $stdout.reopen "/dev/null", "a"
+      $stderr.reopen $stdout
+      Puppet::Util::Log.reopen
+    rescue => detail
+      Puppet.err "Could not start #{Puppet[:name]}: #{detail}"
+      Puppet::Util::replace_file("/tmp/daemonout", 0644) do |f|
+        f.puts "Could not start #{Puppet[:name]}: #{detail}"
+      end
+      exit(12)
+    end
+  end
+
+  # Create a pidfile for our daemon, so we can be stopped and others
+  # don't try to start.
+  def create_pidfile
+    Puppet::Util.synchronize_on(Puppet[:name],Sync::EX) do
+      raise "Could not create PID file: #{pidfile}" unless Puppet::Util::Pidlock.new(pidfile).lock
+    end
+  end
+
+  # Provide the path to our pidfile.
+  def pidfile
+    Puppet[:pidfile]
+  end
+
+  def reexec
+    raise Puppet::DevError, "Cannot reexec unless ARGV arguments are set" unless argv
+    command = $0 + " " + argv.join(" ")
+    Puppet.notice "Restarting with '#{command}'"
+    stop(:exit => false)
+    exec(command)
+  end
+
+  def reload
+    return unless agent
+    if agent.running?
+      Puppet.notice "Not triggering already-running agent"
+      return
+    end
+
+    agent.run
+  end
+
+  # Remove the pid file for our daemon.
+  def remove_pidfile
+    Puppet::Util.synchronize_on(Puppet[:name],Sync::EX) do
+      Puppet::Util::Pidlock.new(pidfile).unlock
+    end
+  end
+
+  def restart
+    Puppet::Application.restart!
+    reexec unless agent and agent.running?
+  end
+
+  def reopen_logs
+    Puppet::Util::Log.reopen
+  end
+
+  # Trap a couple of the main signals.  This should probably be handled
+  # in a way that anyone else can register callbacks for traps, but, eh.
+  def set_signal_traps
+    signals = {:INT => :stop, :TERM => :stop }
+    # extended signals not supported under windows
+    signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs }) unless Puppet.features.microsoft_windows?
+    signals.each do |signal, method|
+      Signal.trap(signal) do
+        Puppet.notice "Caught #{signal}; calling #{method}"
+        send(method)
+      end
+    end
+  end
+
+  # Stop everything
+  def stop(args = {:exit => true})
+    Puppet::Application.stop!
+
+    server.stop if server
+
+    remove_pidfile
+
+    Puppet::Util::Log.close_all
+
+    exit if args[:exit]
+  end
+
+  def start
+    set_signal_traps
+
+    create_pidfile
+
+    raise Puppet::DevError, "Daemons must have an agent, server, or both" unless agent or server
+
+    # Start the listening server, if required.
+    server.start if server
+
+    # Finally, loop forever running events - or, at least, until we exit.
+    run_event_loop
+  end
+
+  def run_event_loop
+    # Now, we loop waiting for either the configuration file to change, or the
+    # next agent run to be due.  Fun times.
+    #
+    # We want to trigger the reparse if 15 seconds passed since the previous
+    # wakeup, and the agent run if Puppet[:runinterval] seconds have passed
+    # since the previous wakeup.
+    #
+    # We always want to run the agent on startup, so it was always before now.
+    # Because 0 means "continuously run", `to_i` does the right thing when the
+    # input is strange or badly formed by returning 0.  Integer will raise,
+    # which we don't want, and we want to protect against -1 or below.
+    next_agent_run = 0
+    agent_run_interval = [Puppet[:runinterval].to_i, 0].max
+
+    # We may not want to reparse; that can be disable.  Fun times.
+    next_reparse = 0
+    reparse_interval = Puppet[:filetimeout].to_i
+
+    loop do
+      now = Time.now.to_i
+
+      # We set a default wakeup of "one hour from now", which will
+      # recheck everything at a minimum every hour.  Just in case something in
+      # the math messes up or something; it should be inexpensive enough to
+      # wake once an hour, then go back to sleep after doing nothing, if
+      # someone only wants listen mode.
+      next_event = now + 60 * 60
+
+      # Handle reparsing of configuration files, if desired and required.
+      # `reparse` will just check if the action is required, and would be
+      # better named `reparse_if_changed` instead.
+      if reparse_interval > 0 and now >= next_reparse
+        Puppet.settings.reparse
+
+        # The time to the next reparse might have changed, so recalculate
+        # now.  That way we react dynamically to reconfiguration.
+        reparse_interval = Puppet[:filetimeout].to_i
+
+        # Set up the next reparse check based on the new reparse_interval.
+        if reparse_interval > 0
+          next_reparse = now + reparse_interval
+          next_event > next_reparse and next_event = next_reparse
+        end
+
+        # We should also recalculate the agent run interval, and adjust the
+        # next time it is scheduled to run, just in case.  In the event that
+        # we made no change the result will be a zero second adjustment.
+        new_run_interval    = [Puppet[:runinterval].to_i, 0].max
+        next_agent_run     += agent_run_interval - new_run_interval
+        agent_run_interval  = new_run_interval
+      end
+
+      # Handle triggering another agent run.  This will block the next check
+      # for configuration reparsing, which is a desired and deliberate
+      # behaviour.  You should not change that. --daniel 2012-02-21
+      if agent and now >= next_agent_run
+        agent.run
+
+        # Set up the next agent run time
+        next_agent_run = now + agent_run_interval
+        next_event > next_agent_run and next_event = next_agent_run
+      end
+
+      # Finally, an interruptable able sleep until the next scheduled event.
+      how_long = next_event - now
+      how_long > 0 and select([], [], [], how_long)
+    end
+  end
+end
+