ngauthier-active-listener 0.3.0 → 0.3.2

data/VERSION.yml

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

data/lib/active-listener.rb

@@ -1,9 +1,23 @@
 require 'fileutils'
 require 'yaml'
 
+# =ActiveListener
+# Set up an activelistener config file in your config directory describing the
+# tasks #ActiveListener should execute. Then, in an initializer, run 
+# #ActiveListener.autostart
 class ActiveListener
+  # All the #Events that an #ActiveListener is firing
   attr_reader :events
 
+  # Run #autostart in an initializer to run #ActiveListener when your
+  # Rails application initializes.
+  #
+  #  ActiveListener.autostart(
+  #    :config => File.join(RAILS_ROOT, 'config', 'active-listener.yml'),
+  #    :pid_file => File.join(RAILS_ROOT, 'log', 'active-listener-'+RAILS_ENV+'.pid'),
+  #    :log_file => File.join(RAILS_ROOT, 'log', 'active-listener-'+RAILS_ENV+'.log'),
+  #    :rake_root => RAILS_ROOT
+  #  )
   def self.autostart(opts = {})
     begin
       config_file = File.expand_path(opts[:config])
@@ -22,30 +36,47 @@ class ActiveListener
       "--",
       "#{config_file}",
       "#{log_file}",
-      "#{rake_root}"
+      "#{rake_root}",
     ].join(" ")
     `#{command}`
   end
 
+  # Stop an #ActiveListener by specifying a pid file
+  #
+  #  ActiveListener.stop(:pid_file => File.join(RAILS_ROOT, 'log', 'active-listener.pid'))
   def self.stop(opts = {})
     pid_file = opts[:pid_file]
     `start-stop-daemon --stop --oknodo --pidfile #{File.expand_path(pid_file)}`
   end
 
+  # Create an #ActiveListener in the foreground. This is useful for a non-rails project.
+  #
+  #  ActiveListener.new(
+  #    :log_file => File.join('log', 'active-listener.log'),
+  #    :rake_root => '.'
+  #  )
   def initialize(opts = {})
     self.events = []
     self.log_file = opts[:log_file]
     self.rake_root = opts[:rake_root]
     clear_log
     log("ActiveListener Initialized")
-    load_events(opts[:config])
+    load_config(opts[:config])
   end
 
+  # Add an event to event listener.
+  #
+  #  @al.add_event(Event.new(:task => 'my_task', :period => '10'))
   def add_event(evt)
     self.events.push(evt)
     log("Added Event #{evt.inspect}")
   end
 
+  # Fire any events that have passed their period
+  #
+  #  @al.fire_events
+  #
+  # This will only fire events that have not been run within their period time of their last run
   def fire_events
     self.events.select{|e| e.time_to_fire < 0}.each do |evt|
       log("Firing event: #{evt.inspect}")
@@ -54,6 +85,10 @@ class ActiveListener
     self.events.sort{|x,y| x.time_to_fire <=> y.time_to_fire}
   end
 
+  # Returns the time in seconds until the next event needs to be fired. Useful for sleeping
+  # 
+  #  sleep(@al.time_to_next_event)
+  #  @al.fire_events
   def time_to_next_event
     if self.events.first
       sleep_time = self.events.first.time_to_fire+0.01
@@ -63,22 +98,37 @@ class ActiveListener
     return sleep_time
   end
 
-  def sleep_to_next_event
-    log("Sleeping for #{time_to_next_event}")
-    sleep(time_to_next_event)
+  # Not functional yet.
+  def self.trigger(port, event)
+
   end
 
+  # An individual #ActiveListener #Event
   class Event
+    # Create a new #Event
+    #
+    #  Event.new(
+    #    :task => 'my:rake:task',
+    #    :period => 50
+    #  )
     def initialize(opts = {})
       self.task = opts[:task] || opts["task"]
       self.period = opts[:period] || opts["period"]
+      self.trigger = opts[:trigger] || opts["trigger"]
       self.last_fire = Time.now.to_f
     end
 
+    # The amount of time until this event will need to be fired
     def time_to_fire
-      last_fire + period - Time.now.to_f
+      if period
+        return last_fire + period - Time.now.to_f
+      else
+        # oh does! forever!
+        return 1.0/0.0
+      end
     end
 
+    # Fire the event. I.e. run the rake task
     def fire(opts = {})
       self.last_fire = Time.now.to_f
       Dir.chdir(opts[:rake_root]) if opts[:rake_root]
@@ -89,18 +139,43 @@ class ActiveListener
       end
     end
 
+    # Manual firing trigger (not implemented)
+    attr_reader :trigger
+    # The amount of time in seconds between firing this task
+    attr_reader :period
+    # The last time this event was fired
+    attr_reader :last_fire
+    # A string representation of a rake task. "my:task"
+    attr_reader :task
+
     private
 
-    attr_accessor :task, :period, :last_fire
+    # Set the rake task
+    attr_writer :task
+    # Set the period
+    attr_writer :period
+    # Set the trigger
+    attr_writer :trigger
+    # Set last_fire time
+    attr_writer :last_fire
 
   end
 
   private
 
+  # Set the events this #ActiveListener has
   attr_writer :events
-  attr_accessor :log_file, :rake_root
-
-  def load_events(config_file)
+  # Log file path
+  attr_accessor :log_file
+  # Directory to run rake tasks from
+  attr_accessor :rake_root
+  # Port for triggers (not implemented)
+  attr_accessor :port
+
+  # Parse a config file to load up events.
+  #
+  #  @al.load_config('active-listener.yml')
+  def load_config(config_file)
     return if config_file.nil?
     unless File.exists?(config_file)
       log("Config file not found at #{config_file}")
@@ -112,13 +187,21 @@ class ActiveListener
     yml["tasks"].each do |task|
       self.add_event(Event.new(task))
     end
+    port = yml["port"]
+    # puts "The port: #{port}"
+    if port
+      self.port = port
+      spawn_listener_thread
+    end
   end
 
+  # Delete the log file
   def clear_log
     return unless log_file
     FileUtils.rm_f log_file
   end
-
+ 
+  # Log text to the log file
   def log(text)
     return unless log_file
     f = File.new(log_file, 'a')
@@ -127,4 +210,17 @@ class ActiveListener
     f.close
   end
 
+  # Trigger an event (not implemented)
+  def trigger(trigger)
+    self.events.select{|e| e.trigger == trigger}.each do |evt|
+      log("Event triggered: #{evt.inspect}")
+      log(evt.fire(:rake_root => rake_root))
+    end
+  end
+
+  # Listen on a port for triggers (not implemented)
+  def spawn_listener_thread
+    # puts "Hey a port! #{port}"
+  end
+
 end

data/test/active_listener-events.yml

@@ -0,0 +1,5 @@
+---
+  tasks:
+  - task: test:touch_file
+    trigger: MY_TRIGGER
+  port: 20150

data/test/active_listener_test.rb

@@ -23,7 +23,7 @@ class ActiveListenerTest < Test::Unit::TestCase
     end
 
     should "sleep when it has no events" do
-      @al.sleep_to_next_event
+      sleep(@al.time_to_next_event)
     end
 
     context "with a file timer" do
@@ -44,7 +44,7 @@ class ActiveListenerTest < Test::Unit::TestCase
 
       should "touch a file" do
         assert !File.exists?(@sample_file)
-        @al.sleep_to_next_event
+        sleep(@al.time_to_next_event)
         @al.fire_events
         assert File.exists?(@sample_file)
       end
@@ -59,7 +59,7 @@ class ActiveListenerTest < Test::Unit::TestCase
         FileUtils.rm_f(@sample_file)
         @al.fire_events
         assert !File.exists?(@sample_file)
-        @al.sleep_to_next_event
+        sleep(@al.time_to_next_event)
         assert @al.events[0].time_to_fire < 0
         assert !File.exists?(@sample_file)
         @al.fire_events
@@ -81,7 +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
+      sleep(@al.time_to_next_event)
       @al.fire_events
       assert File.exists?(@sample_file)
     end
@@ -160,6 +160,60 @@ class ActiveListenerTest < Test::Unit::TestCase
     end
   end
 
+  context "An event-based listener" do
+
+    setup do
+      @al = ActiveListener.new({})
+      @al.add_event(ActiveListener::Event.new(
+        :task => 'test:touch_file',
+        :trigger => "MY_TRIGGER"
+      ))
+      @sample_file = File.join(File.dirname(__FILE__),'sample.txt')
+      FileUtils.rm_f @sample_file
+    end
+
+    teardown do
+      FileUtils.rm_f @sample_file
+    end
+
+    should "not fire any events at the beginning" do
+      assert !File.exists?(@sample_file)
+      assert @al.time_to_next_event.infinite?
+      @al.fire_events
+      assert !File.exists?(@sample_file)
+    end
+  end
+
+  context "An auto-started event based listener" do
+    setup do
+      ActiveListener.stop(
+        :pid_file => File.join(File.dirname(__FILE__), 'active_listener.pid')
+      )
+      sleep(0.5)
+      ActiveListener.autostart(
+        :config => File.join(File.dirname(__FILE__), 'active_listener-events.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__), '..')
+      )
+      @sample_file = File.join(File.dirname(__FILE__),'sample.txt')
+    end
+
+    teardown do
+      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 "be able to be triggered" do
+      #assert !File.exists?(@sample_file)
+      #ActiveListener.trigger(20150,"MY_TRIGGER")
+      #assert File.exists?(@sample_file)
+    end
+  end
+
   private
 
   def pid_running(pid)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ngauthier-active-listener
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors: 
 - Nick Gauthier
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-09 00:00:00 -08:00
+date: 2009-02-12 00:00:00 -08:00
 default_executable: active-listener
 dependencies: []
 
@@ -23,12 +23,12 @@ extra_rdoc_files: []
 
 files: 
 - VERSION.yml
-- README.html
 - README.markdown
 - bin/active-listener
 - lib/activelistener
 - lib/active-listener.rb
 - test/test_helper.rb
+- test/active_listener-events.yml
 - test/active_listener.log
 - test/active_listener.pid
 - test/active_listener.yml