eventmachine-tail 0.0.1 → 0.6.1

data/test/test_filetail.rb

@@ -0,0 +1,232 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'eventmachine-tail'
+require 'tempfile'
+require 'test/unit'
+require 'timeout'
+require 'testcase_helpers.rb'
+
+
+# Generate some data
+DATA = (1..10).collect { |i| rand.to_s }
+SLEEPMAX = 1
+
+class Reader < EventMachine::FileTail
+  def initialize(path, startpos=-1, testobj=nil)
+    super(path, startpos)
+    @data = DATA.clone
+    @buffer = BufferedTokenizer.new
+    @testobj = testobj
+    @lineno = 0
+  end # def initialize
+
+  def receive_data(data)
+    @buffer.extract(data).each do |line|
+      @lineno += 1
+      expected = @data.shift
+      @testobj.assert_equal(expected, line, 
+          "Expected '#{expected}' on line #{@lineno}, but got '#{line}'")
+    end # @buffer.extract
+  end # def receive_data
+  
+  # This effectively tests EOF handling by requiring it to work in order
+  # for the tests to pass.
+  def eof
+    if @data.length == 0
+      close
+      @testobj.finish
+    end
+  end # def eof
+end # class Reader
+
+class TestFileTail < Test::Unit::TestCase
+  include EventMachineTailTestHelpers
+
+  # 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_filetail
+    tmp = Tempfile.new("testfiletail")
+    data = DATA.clone
+    EM.run do
+      abort_after_timeout(DATA.length * SLEEPMAX + 10)
+
+      EM::file_tail(tmp.path, Reader, -1, self)
+      timer = EM::PeriodicTimer.new(0.2) do
+        tmp.puts data.shift
+        tmp.flush
+        sleep(rand * SLEEPMAX)
+        timer.cancel if data.length == 0
+      end
+    end # EM.run
+  end # def test_filetail
+
+  def test_filetail_with_seek
+    tmp = Tempfile.new("testfiletail")
+    data = DATA.clone
+    data.each { |i| tmp.puts i }
+    tmp.flush
+    EM.run do
+      abort_after_timeout(2)
+
+      # Set startpos of 0 (beginning of file)
+      EM::file_tail(tmp.path, Reader, 0, self)
+    end # EM.run
+  end # def test_filetail
+
+  def test_filetail_with_block
+    tmp = Tempfile.new("testfiletail")
+    data = DATA.clone
+    EM.run do
+      abort_after_timeout(DATA.length * SLEEPMAX + 10)
+
+      lineno = 0
+      EM::file_tail(tmp.path) do |filetail, line|
+        lineno += 1
+        expected = data.shift
+        assert_equal(expected, line, 
+                     "Expected '#{expected}' on line #{@lineno}, but got '#{line}'")
+        finish if data.length == 0
+      end
+
+      data_copy = data.clone
+      timer = EM::PeriodicTimer.new(0.2) do
+        tmp.puts data_copy.shift
+        tmp.flush
+        sleep(rand * SLEEPMAX)
+        timer.cancel if data_copy.length == 0
+      end
+    end # EM.run
+  end # def test_filetail_with_block
+
+  def test_filetail_tracks_renames
+    tmp = Tempfile.new("testfiletail")
+    data = DATA.clone
+    filename = tmp.path
+
+    data_copy = data.clone
+
+    # Write first so the first read happens immediately
+    tmp.puts data_copy.shift
+    tmp.flush
+    EM.run do
+      abort_after_timeout(DATA.length * SLEEPMAX + 10)
+
+      lineno = 0
+      # Start at file position 0.
+      EM::file_tail(tmp.path, nil, 0) do |filetail, line|
+        lineno += 1
+        expected = data.shift
+        #puts "Got #{lineno}: #{line}"
+        assert_equal(expected, line, 
+                     "Expected '#{expected}' on line #{lineno}, but got '#{line}'")
+        finish if data.length == 0
+
+        # Start a timer on the first read.
+        # This is to ensure we have the file tailing before
+        # we try to rename.
+        if lineno == 1
+          timer = EM::PeriodicTimer.new(0.2) do
+            value = data_copy.shift
+            tmp.puts value
+            tmp.flush
+            sleep(rand * SLEEPMAX)
+
+            # Rename the file, create a new one in it's place.
+            # This is to simulate log rotation, etc.
+            path_newname = "#{filename}_#{value}"
+            File.rename(filename, path_newname)
+            File.delete(path_newname)
+            tmp = File.open(filename, "w")
+            timer.cancel if data_copy.length == 0
+          end # timer
+        end # if lineno == 1
+      end # EM::filetail(...)
+    end # EM.run
+
+    File.delete(filename)
+  end # def test_filetail_tracks_renames
+
+  def test_filetail_tracks_symlink_changes
+    to_delete = []
+    link = Tempfile.new("testlink")
+    File.delete(link.path)
+    to_delete << link
+    tmp = Tempfile.new("testfiletail")
+    to_delete << tmp
+    data = DATA.clone
+    File.symlink(tmp.path, link.path)
+
+    data_copy = data.clone
+
+    # Write first so the first read happens immediately
+    tmp.puts data_copy.shift
+    tmp.flush
+    EM.run do
+      abort_after_timeout(DATA.length * SLEEPMAX + 10)
+
+      lineno = 0
+      # Start at file position 0.
+      EM::file_tail(link.path, nil, 0) do |filetail, line|
+        # This needs to be less than the interval at which we are changing symlinks.
+        filetail.symlink_check_interval = 0.1
+
+        lineno += 1
+        expected = data.shift
+        puts "Got #{lineno}: #{line}" if $debug
+        assert_equal(expected, line, 
+                     "Expected '#{expected}' on line #{lineno}, but got '#{line}'")
+        finish if data.length == 0
+
+        # Start a timer on the first read.
+        # This is to ensure we have the file tailing before
+        # we try to rename.
+        if lineno == 1
+          timer = EM::PeriodicTimer.new(0.2) do
+            value = data_copy.shift
+            tmp.puts value
+            tmp.flush
+            sleep(rand * SLEEPMAX)
+
+            # Make a new file and update the symlink to point to it.
+            # This is to simulate log rotation, etc.
+            tmp.close
+            tmp = Tempfile.new("testfiletail")
+            to_delete << tmp
+            File.delete(link.path)
+            File.symlink(tmp.path, link.path)
+            puts "#{tmp.path} => #{link.path}" if $debug
+            timer.cancel if data_copy.length == 0
+          end # timer
+        end # if lineno == 1
+      end # EM::filetail(...)
+    end # EM.run
+
+    to_delete.each do |f|
+      File.delete(f.path)
+    end
+  end # def test_filetail_tracks_renames
+  
+  def test_encoding
+    return if RUBY_VERSION < '1.9.0'
+    tmp = Tempfile.new("testfiletail")
+    data = DATA.clone
+    EM.run do
+      abort_after_timeout(1)
+
+      EM::file_tail(tmp.path) do |filetail, line|
+        assert_equal(Encoding.default_external, line.encoding, 
+                     "Expected the read data to have the encoding specified in Encoding.default_external (#{Encoding.default_external}, but was #{line.encoding})")
+        finish
+      end
+
+      EM.next_tick do
+        tmp.puts(data.shift)
+        tmp.flush
+      end
+    end # EM.run
+  end # def test_encoding
+end # class TestFileTail
+

data/test/test_glob.rb

@@ -0,0 +1,146 @@
+#!/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_deleted(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 = 1
+
+  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").close
+        sleep(rand * SLEEPMAX)
+        timer.cancel if datacopy.length == 0
+      end
+    end # EM.run
+  end # def test_glob_finds_newly_created_files_at_runtime
+
+  def test_glob_ignores_file_renames
+    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
+        filename = datacopy.shift
+        File.new(filename, "w").close
+        sleep(rand * SLEEPMAX)
+
+        # This file rename should be ignored.
+        EM::Timer.new(2) do
+          newname = "#{filename}.renamed"
+          File.rename(filename, newname)
+
+          # Track the new filename so teardown removes it.
+          @data << newname
+        end
+        timer.cancel if datacopy.length == 0
+      end
+    end
+  end # def test_glob_ignores_file_renames
+
+  def test_glob_ignores_duplicate_hardlinks
+    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
+        filename = datacopy.shift
+        File.new(filename, "w").close
+        sleep(rand * SLEEPMAX)
+
+        # This file rename should be ignored.
+        EM::Timer.new(2) do
+          newname = "#{filename}.renamed"
+          File.link(filename, newname)
+
+          # Track the new filename so teardown removes it.
+          @data << newname
+        end
+        timer.cancel if datacopy.length == 0
+      end
+    end
+  end # def test_glob_ignores_file_renames
+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

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: eventmachine-tail
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  hash: 5
+  prerelease: 
+  segments: 
+  - 0
+  - 6
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Jordan Sissel
@@ -9,32 +15,49 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-11 00:00:00 -07:00
+date: 2011-02-22 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
         version: "0"
-    version: 
-description: Add file 'tail' implemented with EventMachine
+  type: :runtime
+  version_requirements: *id001
+description: Add file 'tail' implemented with EventMachine. Also includes a 'glob watch' class for watching a directory pattern for new matches, like /var/log/*.log
 email: jls@semicomplete.com
-executables: []
-
+executables: 
+- rtail
+- emtail
 extensions: []
 
 extra_rdoc_files: []
 
 files: 
+- lib/eventmachine-tail.rb
 - lib/em/filetail.rb
 - lib/em/globwatcher.rb
+- samples/tail.rb
+- samples/glob-tail.rb
+- samples/globwatch.rb
+- samples/tail-with-block.rb
+- test/test_filetail.rb
+- test/logrotate.conf
+- test/test_glob.rb
+- test/alltests.rb
+- test/testcase_helpers.rb
+- bin/rtail
+- bin/emtail
 has_rdoc: true
-homepage: http://code.google.com/p/semicomplete/wiki/EventMachine-Tail
+homepage: http://code.google.com/p/semicomplete/wiki/EventMachineTail
 licenses: []
 
 post_install_message: 
@@ -44,23 +67,29 @@ require_paths:
 - lib
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.5.0
 signing_key: 
 specification_version: 3
-summary: eventmachine tail - a file tail implementation
+summary: eventmachine tail - a file tail implementation with glob support
 test_files: []