ngauthier-active-listener 0.2.3 → 0.3.0

data/README.markdown

@@ -20,14 +20,15 @@ This gem allows you to define tasks that can be run at specific time intervals.
 ### Add a config file
 In your rails project, add a config file like this:
 
-
     ---
       tasks:
         - task: my:rake:task
           period: 5
+        - task: my:other:rake:task
+          period: 14
 
 
-This instructs active-listener to run "rake my:rake:task" every 5 seconds.
+This instructs active-listener to run "rake my:rake:task" every 5 seconds and "rake my:other:rake:task" every 14 seconds.
 
 Usually, these config files go in RAILS_ROOT/config/active-listener.yml.
 
@@ -44,36 +45,9 @@ Create a file in the initializers directory, like RAILS_ROOT/config/initializers
 
 This will use the config file "config/active-listener.yml". It will put the log file in "log/active-listener.log" and the pid file for tracking the process in "log/active-listener.pid".
 
-### Special Handling of ActiveListener rake tasks that depend on the rails environment
-The scheme devised in the previous sections will generate an infinite loop if your Active Listener rake task(s) depend(s) on the rails environment being loaded.  This occurs because we have added the initializer code into config/initializers, which gets loaded every time the environment is loaded.  In order to avoid this, we can set a global variable that is queried in the initializer, providing conditional load behavior.  Now, our initializer looks like this:
-
-    if RAILS_ENV == "production" && !$active_listener_activated
-      require 'active-listener'
-      ActiveListener.autostart(
-        :config => File.join(RAILS_ROOT, 'config', 'active-listener.yml'),
-        :log_file => File.join(RAILS_ROOT, 'log', "active-listener-#{RAILS_ENV}.log"),
-        :pid_file => File.join(RAILS_ROOT, 'log', "active-listener-#{RAILS_ENV}.pid"),
-        :rake_root => File.join(RAILS_ROOT)
-      )
-    end    
-    
-And our Active Listener rake task (found in lib/tasks/active-listener.rake) looks like:
-
-    desc "Helper to preclude infinite loop when a listener task depends on the rails environment"
-    task :set_active_listener_active do
-      $active_listener_activated = true
-    end
-
-    namespace :listeners do
-      desc "Close games that have ended"
-      task :game_end => [:set_active_listener_active, :environment] do
-        # Logic as dictated by your app's needs
-      end
-    end
-
 ## Usage
 
-Active Listener will automatically start whenever the rails environment is loaded. It will replace an existing instance of active-listener if the pid file is the same and there is one running.
+Active Listener will automatically start whenever the rails environment is loaded. It will not start if there is one already running with the pid in the pid file.
 
 So, you don't need to run the executable, it will "autostart" thanks to the initializer. Keep in mind this means that it will be running during your tests, development server, production, and any other environments you have. If you run your tests, the daemon keeps going after the tests are done. It doesn't stop when the server stops.
 
@@ -83,9 +57,6 @@ If you want to stop active-listener, run:
 
     active-listener --stop log/active-listener.pid
 
-Make sure to point it to your pid file.
-
-
 ## Other notes
 This gem uses Jeweler.
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 2
-:patch: 3
 :major: 0
+:minor: 3
+:patch: 0

data/bin/active-listener

@@ -28,6 +28,6 @@ if @al.events.empty?
 end
 
 while running
-  @al.fire_events
-  @al.sleep_to_next_event
+  @al.fire_events if @al.time_to_next_event < 0
+  sleep(0.2)
 end

data/lib/active-listener.rb

@@ -13,7 +13,6 @@ class ActiveListener
     rescue
       raise "Need :config :pid_file :log_file :rake_root"
     end
-    ActiveListener.stop(opts)
     command = [
       "start-stop-daemon --start",
       "--make-pidfile --pidfile #{pid_file}",
@@ -30,7 +29,7 @@ class ActiveListener
 
   def self.stop(opts = {})
     pid_file = opts[:pid_file]
-    `start-stop-daemon --stop --oknodo --quiet --pidfile #{File.expand_path(pid_file)}`
+    `start-stop-daemon --stop --oknodo --pidfile #{File.expand_path(pid_file)}`
   end
 
   def initialize(opts = {})
@@ -52,24 +51,28 @@ class ActiveListener
       log("Firing event: #{evt.inspect}")
       log(evt.fire(:rake_root => rake_root))
     end
+    self.events.sort{|x,y| x.time_to_fire <=> y.time_to_fire}
   end
 
-  def sleep_to_next_event
-    self.events.sort{|x,y| x.time_to_fire <=> y.time_to_fire}
+  def time_to_next_event
     if self.events.first
       sleep_time = self.events.first.time_to_fire+0.01
     else
       sleep_time = 0.5
     end
-    log("Sleeping for #{sleep_time}")
-    sleep(sleep_time)
+    return sleep_time
+  end
+
+  def sleep_to_next_event
+    log("Sleeping for #{time_to_next_event}")
+    sleep(time_to_next_event)
   end
 
   class Event
     def initialize(opts = {})
       self.task = opts[:task] || opts["task"]
       self.period = opts[:period] || opts["period"]
-      self.last_fire = 0
+      self.last_fire = Time.now.to_f
     end
 
     def time_to_fire

data/test/active_listener_test.rb

@@ -44,12 +44,13 @@ class ActiveListenerTest < Test::Unit::TestCase
 
       should "touch a file" do
         assert !File.exists?(@sample_file)
+        @al.sleep_to_next_event
         @al.fire_events
         assert File.exists?(@sample_file)
       end
 
-      should "need to be fired when added" do
-        assert @al.events[0].time_to_fire < 0
+      should "not need to be fired when added" do
+        assert @al.events[0].time_to_fire > 0
       end
 
       should "need to be fired 1 second after being fired" do
@@ -80,6 +81,7 @@ class ActiveListenerTest < Test::Unit::TestCase
       @al = ActiveListener.new(:config => @config_path)
       assert @al.events.size > 0
       assert !File.exists?(@sample_file)
+      @al.sleep_to_next_event
       @al.fire_events
       assert File.exists?(@sample_file)
     end
@@ -89,7 +91,7 @@ class ActiveListenerTest < Test::Unit::TestCase
   context "An autostarted listener" do
 
     setup do
-      ActiveListener.autostart(
+      assert ActiveListener.autostart(
         :config => File.join(File.dirname(__FILE__), 'active_listener.yml'),
         :pid_file => File.join(File.dirname(__FILE__), 'active_listener.pid'),
         :log_file => File.join(File.dirname(__FILE__), 'active_listener.log'),
@@ -102,11 +104,12 @@ class ActiveListenerTest < Test::Unit::TestCase
       ActiveListener.stop(
         :pid_file => File.join(File.dirname(__FILE__), 'active_listener.pid')
       )
+      sleep(1)
       FileUtils.rm_f(File.join(File.dirname(__FILE__),'sample.txt'))
     end
 
     should "load events from the config file" do
-      sleep(1)
+      sleep(2)
       assert File.exists?(@sample_file)
       FileUtils.rm_f(@sample_file)
       assert !File.exists?(@sample_file)
@@ -114,5 +117,52 @@ class ActiveListenerTest < Test::Unit::TestCase
       assert File.exists?(@sample_file)
     end
 
+    should "not duplicate processes" do
+      pf = File.new(File.join(File.dirname(__FILE__), 'active_listener.pid'))
+      pid = pf.read
+      pf.close
+      assert(pid_running(pid))
+      ActiveListener.autostart(
+        :config => File.join(File.dirname(__FILE__), 'active_listener.yml'),
+        :pid_file => File.join(File.dirname(__FILE__), 'active_listener.pid'),
+        :log_file => File.join(File.dirname(__FILE__), 'active_listener.log'),
+        :rake_root => File.join(File.dirname(__FILE__), '..')
+      )
+      pf = File.new(File.join(File.dirname(__FILE__), 'active_listener.pid'))
+      new_pid = pf.read
+      pf.close
+      assert_equal pid, new_pid
+      assert(pid_running(pid))
+    end
+
+    should "be able to be stopped and a new one can be run" do
+      pf = File.new(File.join(File.dirname(__FILE__), 'active_listener.pid'))
+      pid = pf.read
+      pf.close
+      assert(pid_running(pid))
+      ActiveListener.stop(
+        :pid_file => File.join(File.dirname(__FILE__), 'active_listener.pid')
+      )
+      sleep(1)
+      assert(!pid_running(pid))
+      ActiveListener.autostart(
+        :config => File.join(File.dirname(__FILE__), 'active_listener.yml'),
+        :pid_file => File.join(File.dirname(__FILE__), 'active_listener.pid'),
+        :log_file => File.join(File.dirname(__FILE__), 'active_listener.log'),
+        :rake_root => File.join(File.dirname(__FILE__), '..')
+      )
+      pf = File.new(File.join(File.dirname(__FILE__), 'active_listener.pid'))
+      new_pid = pf.read
+      pf.close
+      assert_not_equal pid, new_pid
+      assert(pid_running(new_pid))
+      assert(!pid_running(pid))
+    end
+  end
+
+  private
+
+  def pid_running(pid)
+    `ps -p #{pid.to_i.to_s} -o pid=`.size > 0
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ngauthier-active-listener
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors: 
 - Nick Gauthier
@@ -23,6 +23,7 @@ extra_rdoc_files: []
 
 files: 
 - VERSION.yml
+- README.html
 - README.markdown
 - bin/active-listener
 - lib/activelistener