eventmachine-tail 0.1.2801 → 0.1.20100505022629

data/lib/em/filetail.rb

@@ -6,26 +6,62 @@ require "logger"
 
 EventMachine.epoll if EventMachine.epoll?
 
+# Tail a file.
+#
+# Example
+#   class Tailer < EventMachine::Tail
+#     def receive_data(data)
+#       puts "Got #{data.length} bytes"
+#     end
+#   end
+#
+#   # Now add it to EM
+#   EM.run do
+#     EM.file_tail("/var/log/messages", Tailer)
+#   end
+#
+#   # Or this way:
+#   EM.run do
+#     Tailer.new("/var/log/messages")
+#   end
 class EventMachine::FileTail
   CHUNKSIZE = 65536 
   MAXSLEEP = 2
 
   attr_reader :path
-
+  
+  # Tail a file
+  #
+  # path is a string file path
+  # startpos is an offset to start tailing the file at. If -1, start at end of 
+  # file.
+  #
   public
-  def initialize(path, startpos=0)
+  def initialize(path, startpos=-1)
     @path = path
     @logger = Logger.new(STDOUT)
     @logger.level = Logger::WARN
 
-    #@need_scheduling = true
-    open
-
     @fstat = File.stat(@path)
-    @file.sysseek(0, IO::SEEK_END)
+
+    if @fstat.directory?
+      raise Errno::EISDIR.new(@path)
+    end
+
+    open
     watch
+    if (startpos == -1)
+      @file.sysseek(0, IO::SEEK_END)
+    else
+      @file.sysseek(startpos, IO::SEEK_SET)
+      schedule_next_read
+    end
   end # def initialize
 
+  # notify is invoked by EventMachine when the file you are tailing
+  # has been modified or otherwise needs to be acted on.
+  #
+  # You won't normally call this method.
   public
   def notify(status)
     @logger.debug("#{status} on #{path}")
@@ -136,6 +172,12 @@ end # class EventMachine::FileTail::FileWatch < EventMachine::FileWatch
 
 # Add EventMachine::file_tail
 module EventMachine
+  
+  # Tail a file.
+  #
+  # path is the path to the file to tail.
+  # handler should be a module implementing 'receive_data' or
+  # must be a subclasses of EventMachine::FileTail
   def self.file_tail(path, handler=nil, *args)
     args.unshift(path)
     klass = klass_from_handler(EventMachine::FileTail, handler, *args);

data/lib/em/globwatcher.rb

@@ -5,14 +5,33 @@ require "eventmachine"
 require "logger"
 require "em/filetail"
 
+# A file glob pattern watcher for EventMachine.
+#
+# If you are unfamiliar with globs, see Wikipedia:
+# http://en.wikipedia.org/wiki/Glob_(programming)
+#
+# Any glob supported by Dir#glob will work with
+# this class.
+#
+# This class will allow you to get notified whenever a file
+# is created or deleted that matches your glob.
+#
+#
 class EventMachine::FileGlobWatch
-  def initialize(pathglob, handler, interval=60)
+  def initialize(pathglob, interval=60)
     @pathglob = pathglob
-    @handler = handler
+    #@handler = handler
     @files = Set.new
+    @watches = Hash.new
     @logger = Logger.new(STDOUT)
-    @logger.level = Logger::WARN
+    @logger.level = Logger::INFO
 
+    # We periodically check here because it is easier than writing our own glob
+    # parser (so we can smartly watch globs like /foo/*/bar*/*.log)
+    #
+    # Reasons to fix this -
+    # This will likely perform badly on globs that result in a large number of
+    # files.
     EM.next_tick do
       find_files
       EM.add_periodic_timer(interval) do
@@ -21,44 +40,91 @@ class EventMachine::FileGlobWatch
     end
   end # def initialize
 
+  private
   def find_files
+    @logger.info("Searching for files in #{@pathglob}")
     list = Set.new(Dir.glob(@pathglob))
     list.each do |path|
       next if @files.include?(path)
-      watch(path)
+      add(path)
     end
 
     (@files - list).each do |missing|
-      @files.delete(missing)
-      @handler.file_removed(missing)
+      remove(missing)
     end
   end # def find_files
 
-  def watch(path)
+  public
+  def remove(path)
+    @files.delete(path)
+    @watches.delete(path)
+    file_removed(path)
+  end
+
+  private
+  def add(path)
     @logger.info "Watching #{path}"
     @files.add(path)
-    @handler.file_found(path)
+
+    # If EventMachine::watch_file fails, that's ok, I guess.
+    # We'll still find the file 'missing' from the next glob attempt.
+    begin
+      @watches[path] = EventMachine::watch_file(path, GlobFileWatch, self)
+    rescue Errno::EACCES => e
+      @logger.warn(e)
+    end
+    file_found(path)
   end # def watch
+
+  private
+  class GlobFileWatch < EventMachine::FileWatch
+    def initialize(globwatch)
+      @globwatch = globwatch
+    end
+
+    def file_moved
+      stop_watching
+      @globwatch.remove(path)
+    end
+
+    def file_deleted
+      @globwatch.remove(path)
+    end
+  end # class GlobFileWatch < EventMachine::FileWatch
 end # class EventMachine::FileGlobWatch
 
-class EventMachine::FileGlobWatchTail
-  def initialize(handler=nil, *args)
+class EventMachine::FileGlobWatchTail < EventMachine::FileGlobWatch
+  def initialize(path, handler=nil, *args)
+    super(path, *args)
     @handler = handler
     @args = args
   end
 
   def file_found(path)
-    EventMachine::file_tail(path, @handler, *@args)
+    begin
+      EventMachine::file_tail(path, @handler, *@args)
+    rescue Errno::EACCES => e
+      file_error(path, e)
+    rescue Errno::EISDIR => e
+      file_error(path, e)
+    end
   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
+  end
 end # class EventMachine::FileGlobWatchHandler
 
+# Add EventMachine::glob_tail
 module EventMachine
   def self.glob_tail(glob, handler=nil, *args)
-    handler = EventMachine::FileGlobHandler if handler == nil
+    handler = EventMachine::FileGlobWatch if handler == nil
+    args.unshift(glob)
     klass = klass_from_handler(EventMachine::FileGlobWatchTail, handler, *args)
     c = klass.new(*args)
     yield c if block_given?

data/samples/glob-tail.rb

@@ -38,9 +38,11 @@ def main(args)
   end
 
   EventMachine.run do
-    handler = EventMachine::FileGlobWatchTail.new(Reader)
+    #handler = EventMachine::FileGlobWatchTail.new(Reader)
     args.each do |path|
-      EventMachine::FileGlobWatch.new(path, handler)
+      EventMachine::FileGlobWatchTail.new(path, Reader)
+      #EventMachine::FileGlobWatch.new(path, handler)
+      #EventMachine::file_tail(path, handler)
     end
   end
 end # def main

data/samples/globwatch.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require "eventmachine"
+require "eventmachine-tail"
+
+class Watcher < EventMachine::FileGlobWatch
+  def initialize(pathglob, interval=5)
+    super(pathglob, interval)
+  end
+
+  def file_removed(path)
+    puts "Removed: #{path}"
+  end
+
+  def file_found(path)
+    puts "Found: #{path}"
+  end
+end # class Watcher
+
+EM.run do
+  Watcher.new("/var/log/*")
+end

data/test/test_filetail.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'eventmachine-tail'
+require 'tempfile'
+require 'test/unit'
+require 'timeout'
+
+
+# Generate some data
+DATA = (1..10).collect { |i| rand.to_s }
+SLEEPMAX = 2
+
+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}'")
+      if @data.length == 0
+        EM.stop_event_loop
+      end
+    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
+
+  # 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
+end # class TestFileTail
+

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: eventmachine-tail
 version: !ruby/object:Gem::Version 
-  version: 0.1.2801
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 20100505022629
+  version: 0.1.20100505022629
 platform: ruby
 authors: 
 - Jordan Sissel
@@ -9,20 +14,22 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-14 00:00:00 -07:00
+date: 2010-05-05 00:00:00 -07: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 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        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: []
 
@@ -36,6 +43,8 @@ files:
 - lib/em/globwatcher.rb
 - samples/tail.rb
 - samples/glob-tail.rb
+- samples/globwatch.rb
+- test/test_filetail.rb
 has_rdoc: true
 homepage: http://code.google.com/p/semicomplete/wiki/EventMachineTail
 licenses: []
@@ -50,18 +59,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: eventmachine tail - a file tail implementation