Merge remote-tracking branch 'daniel-pittman/refactor/2.7.x/4862-remove-the-event-loop-library' into 2.7.x

* daniel-pittman/refactor/2.7.x/4862-remove-the-event-loop-library:
  (#4862) Finally remove the event-loop library.
  (#4862) define_method is not a public method in Ruby.
  (#4862) `returning` is not a standard Ruby method.
  (#4862) Stop using EventLoop in the Puppet daemon.

Author: pcarlisle

lib/puppet/agent.rb

@@ -1,5 +1,4 @@
 require 'sync'
-require 'puppet/external/event-loop'
 require 'puppet/application'
 
 # A general class for triggering a run of another
@@ -75,18 +74,6 @@ def splay
     @splayed = true
   end
 
-  # Start listening for events.  We're pretty much just listening for
-  # timer events here.
-  def start
-    # Create our timer.  Puppet will handle observing it and such.
-    timer = EventLoop::Timer.new(:interval => Puppet[:runinterval], :tolerance => 1, :start? => true) do
-      run
-    end
-
-    # Run once before we start following the timer
-    timer.sound_alarm
-  end
-
   def sync
     @sync ||= Sync.new
   end

lib/puppet/daemon.rb

@@ -1,6 +1,5 @@
 require 'puppet'
 require 'puppet/util/pidlock'
-require 'puppet/external/event-loop'
 require 'puppet/application'
 
 # A module that handles operations common to all daemons.  This is included
@@ -120,10 +119,77 @@ def start
     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
-    agent.start if agent
 
-    EventLoop.current.run
+    # 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
+
+      # 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
+        next_reparse     = now + reparse_interval
+
+        # 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
+        next_agent_run = now + agent_run_interval
+      end
+
+      # Finally, an interruptable able sleep until the next scheduled event.
+      # We also 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
+      next_event > next_reparse    and next_event = next_reparse
+      next_event > next_agent_run  and next_event = next_agent_run
+
+      how_long = next_event - now
+
+      how_long > 0 and select([], [], [], how_long)
+    end
   end
 end