eventmachine-tail 0.1.20100506012705 → 0.2.20100516235116

data/bin/rtail

@@ -2,31 +2,75 @@
 require "rubygems"
 require "eventmachine"
 require "eventmachine-tail"
+require "optparse"
 
 class Reader < EventMachine::FileTail
-  def initialize(path, startpos=-1)
+  def initialize(path, startpos=-1, with_filenames=true)
     super(path, startpos)
     @buffer = BufferedTokenizer.new
+    @with_filenames = with_filenames
   end
 
   def receive_data(data)
     @buffer.extract(data).each do |line|
-      puts "#{path}: #{line}"
-    end
-  end
-end
+      if @with_filenames # global flag, see the '-n' option
+        puts "#{path}: #{line}"
+      else
+        puts line
+      end # if @with_filenames
+    end # buffer extract
+  end # def receive_data
+end # class Reader
+
+def pattern_to_regexp(pattern)
+  pattern.gsub!(".", "\\.") # fix literal .
+  pattern.gsub!("*", ".+")  # * becomes .+
+  pattern.gsub!("?", ".")   # ? becomes .
+  return Regexp.new(pattern)
+end # def pattern_to_regexp
 
 def main(args)
+  with_filenames = true
+  globcheck_interval = 5
+  exclude_patterns = []
+
+  opts = OptionParser.new do |opts|
+    opts.banner = "Usage: #{$0} [options] <path_or_glob> [path_or_glob2] [...]"
+
+    opts.on("-n", "--no-filename", 
+            "Supress prefixing of output with file names") do |x|
+      with_filenames = false
+    end # -n
+    
+    opts.on("-i SECONDS", "--check-interval SECONDS",
+            "How frequently, in seconds, to check the glob patterns" \
+            "for new files") do |x|
+      globcheck_interval = x.to_f
+    end # -i SECONDS
+
+    opts.on("-x EXCLUDE", "--exclude EXCLUDE",
+            "A pattern to ignore. Wildcard/globs accepted." \
+            " Can be specified multiple times") do |pattern|
+      exclude_patterns << pattern_to_regexp(pattern)
+    end
+  end # OptionParser
+
+  opts.parse!(args)
+
   if args.length == 0
-    puts "Usage: #{$0} <path_or_glob> [path_or_glob2] [...]"
+    puts opts.banner
     return 1
   end
 
   EventMachine.run do
     args.each do |path|
-      EventMachine::FileGlobWatchTail.new(path, Reader)
-    end
-  end
+      EventMachine::FileGlobWatchTail.new(path, Reader,
+                                          interval = globcheck_interval,
+                                          exclude = exclude_patterns,
+                                          start_pos = -1,
+                                          with_filenames = with_filenames)
+    end # args.each
+  end # EventMachine.run
 end # def main
 
 exit(main(ARGV))

data/lib/em/filetail.rb

@@ -43,6 +43,7 @@ class EventMachine::FileTail
     @logger.level = ($DEBUG and Logger::DEBUG or Logger::WARN)
     @logger.debug("Tailing #{path} starting at position #{startpos}")
 
+    @file = nil
     @fstat = File.stat(@path)
 
     if @fstat.directory?

data/lib/em/globwatcher.rb

@@ -62,7 +62,6 @@ class EventMachine::FileGlobWatch
 
   private
   def add(path)
-    @logger.info "Watching #{path}"
     @files.add(path)
 
     # If EventMachine::watch_file fails, that's ok, I guess.
@@ -97,15 +96,26 @@ class EventMachine::FileGlobWatch
 end # class EventMachine::FileGlobWatch
 
 class EventMachine::FileGlobWatchTail < EventMachine::FileGlobWatch
-  def initialize(path, handler=nil, interval=60, *args)
+  def initialize(path, handler=nil, interval=60, exclude=[], *args)
     super(path, interval)
     @handler = handler
     @args = args
+    @exclude = exclude
   end
 
   def file_found(path)
     begin
-      EventMachine::file_tail(path, @handler)
+      @logger.info "#{self.class}: Trying #{path}"
+      @exclude.each do |exclude|
+        @logger.info "#{self.class}: Testing #{exclude} =~ #{path} == #{exclude.match(path) != nil}"
+        if exclude.match(path) != nil
+          file_excluded(path) 
+          return
+        end
+      end
+      @logger.info "#{self.class}: Watching #{path}"
+
+      EventMachine::file_tail(path, @handler, *@args)
     rescue Errno::EACCES => e
       file_error(path, e)
     rescue Errno::EISDIR => e
@@ -113,13 +123,17 @@ class EventMachine::FileGlobWatchTail < EventMachine::FileGlobWatch
     end
   end
 
+  def file_excluded(path)
+    @logger.info "#{self.class}: Skipping path #{path} due to exclude rule"
+  end
+
   def file_removed(path)
     # Nothing to do
   end
 
   def file_error(path, e)
     $stderr.puts "#{e.class} while trying to tail #{path}"
-    # Ignore by default
+    # otherwise, drop the error by default
   end
 end # class EventMachine::FileGlobWatchHandler
 
@@ -133,4 +147,14 @@ module EventMachine
     yield c if block_given?
     return c
   end
-end
+
+  def self.watch_glob(path, handler=nil, *args)
+    # This code mostly styled on what EventMachine does in many of it's other
+    # methods.
+    args = [path, *args]
+    klass = klass_from_handler(EventMachine::FileGlobWatch, handler, *args);
+    c = klass.new(*args)
+    yield c if block_given?
+    return c
+  end # def EventMachine::watch_glob
+end # module EventMachine

data/test/test_filetail.rb

@@ -6,6 +6,7 @@ require 'eventmachine-tail'
 require 'tempfile'
 require 'test/unit'
 require 'timeout'
+require 'testcase_helpers.rb'
 
 
 # Generate some data
@@ -27,20 +28,13 @@ class Reader < EventMachine::FileTail
       expected = @data.shift
       @testobj.assert_equal(expected, line, 
           "Expected '#{expected}' on line #{@lineno}, but got '#{line}'")
-      if @data.length == 0
-        EM.stop_event_loop
-      end
+      @testobj.finish if @data.length == 0
     end # @buffer.extract
   end # def receive_data
 end # class Reader
 
 class TestFileTail < Test::Unit::TestCase
-  def abort_after_timeout(seconds)
-    EM::Timer.new(seconds) do
-      EM.stop_event_loop
-      flunk("Timeout (#{seconds} seconds) while running tests. Failing.")
-    end
-  end
+  include EventMachineTailTestHelpers
 
   # This test should run slow. We are trying to ensure that
   # our file_tail correctly reads data slowly fed into the file

data/test/test_glob.rb

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'eventmachine-tail'
+require 'tempfile'
+require 'test/unit'
+require 'timeout'
+require 'tmpdir'
+
+require 'testcase_helpers'
+
+class Watcher < EventMachine::FileGlobWatch
+  def initialize(path, interval, data, testobj)
+    super(path, interval)
+    @data = data
+    @testobj = testobj
+  end # def initialize
+
+  def file_found(path)
+    # Use .include? here because files aren't going to be found in any
+    # particular order.
+    @testobj.assert(@data.include?(path), "Expected #{path} in \n#{@data.join("\n")}")
+    @data.delete(path)
+    @testobj.finish if @data.length == 0
+  end
+
+  def file_removed(path)
+    @testobj.assert(@data.include?(path), "Expected #{path} in \n#{@data.join("\n")}")
+    @data.delete(path)
+    @testobj.finish if @data.length == 0
+  end
+end # class Reader
+
+class TestGlobWatcher < Test::Unit::TestCase
+  include EventMachineTailTestHelpers
+  SLEEPMAX = 2
+
+  def setup
+    @watchinterval = 0.2
+    @dir = Dir.mktmpdir
+    @data = []
+    @data << "#{@dir}/#{rand}"
+    @data << "#{@dir}/#{rand}"
+    @data << "#{@dir}/#{rand}"
+    @data << "#{@dir}/#{rand}"
+    @data << "#{@dir}/#{rand}"
+    @data << "#{@dir}/#{rand}"
+    @data << "#{@dir}/#{rand}"
+    @data << "#{@dir}/#{rand}.gz"
+    @data << "#{@dir}/#{rand}.gz"
+    @data << "#{@dir}/#{rand}.tar.gz"
+  end # def setup
+
+  def teardown
+    @data.each do |file|
+      #puts "Deleting #{file}"
+      File.delete(file) rescue nil
+    end
+    Dir.delete(@dir)
+  end # def teardown
+
+  def finish
+    EM.stop_event_loop
+  end
+
+  def test_glob_finds_existing_files
+    EM.run do
+      abort_after_timeout(SLEEPMAX * @data.length + 10)
+
+      @data.each do |path|
+        File.new(path, "w").close
+      end
+      EM::watch_glob("#{@dir}/*", Watcher, @watchinterval, @data.clone, self)
+    end # EM.run
+  end # def test_glob_finds_existing_files
+
+  # This test should run slow. We are trying to ensure that
+  # our file_tail correctly reads data slowly fed into the file
+  # as 'tail -f' would.
+  def test_glob_finds_newly_created_files_at_runtime
+    EM.run do
+      abort_after_timeout(SLEEPMAX * @data.length + 10)
+
+      EM::watch_glob("#{@dir}/*", Watcher, @watchinterval, @data.clone, self)
+      datacopy = @data.clone
+      timer = EM::PeriodicTimer.new(0.2) do
+        #puts "Creating: #{datacopy.first}"
+        File.new(datacopy.shift, "w")
+        sleep(rand * SLEEPMAX)
+        timer.cancel if datacopy.length == 0
+      end
+    end # EM.run
+  end # def test_glob_finds_newly_created_files_at_runtime
+end # class TestGlobWatcher
+

data/test/testcase_helpers.rb

@@ -0,0 +1,13 @@
+
+module EventMachineTailTestHelpers
+  def abort_after_timeout(seconds)
+    EM::Timer.new(seconds) do
+      EM.stop_event_loop
+      flunk("Timeout (#{seconds} seconds) while running tests. Failing.")
+    end
+  end
+
+  def finish
+    EventMachine.stop_event_loop
+  end
+end # module EventMachineTailTestHelpers

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 20100506012705
-  version: 0.1.20100506012705
+  - 2
+  - 20100516235116
+  version: 0.2.20100516235116
 platform: ruby
 authors: 
 - Jordan Sissel
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-06 00:00:00 -07:00
+date: 2010-05-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,6 +45,8 @@ files:
 - samples/glob-tail.rb
 - samples/globwatch.rb
 - test/test_filetail.rb
+- test/test_glob.rb
+- test/testcase_helpers.rb
 - bin/rtail
 has_rdoc: true
 homepage: http://code.google.com/p/semicomplete/wiki/EventMachineTail
@@ -76,6 +78,6 @@ rubyforge_project:
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: eventmachine tail - a file tail implementation
+summary: eventmachine tail - a file tail implementation with glob support
 test_files: []