ffilewatch 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 211f6275bcf6037d2e6379dd206e268ebbf77362
+  data.tar.gz: b329672228fc6ddd30802abae8803f550d7e84a1
+SHA512:
+  metadata.gz: f9d01a57ce62ab9737847fc61ca14e98f17656ec0d0f1c2db52d3024fd86f56d33f2bf30e13d20de272fff75d38db07c345244463def7bb894fdb2e87ce3f9d1
+  data.tar.gz: 61084794c8ffdc1866c4c6b8cb23f94118a8ec92de05c6caffe6f0daa5238382890e71b848f729c3241fdb7e2b31b177f1eef270a521cc5e1994ca26929808ac

data/bin/globtail

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require "filewatch/tail"
+require "optparse"
+
+progname = File.basename($0)
+
+config = {
+  :verbose => false,
+}
+
+opts = OptionParser.new do |opts|
+  opts.banner = "#{progname} [-v] [-s path] [-i interval] [-x glob] path/glob ..."
+
+  opts.on("-v", "--verbose", "Enable verbose/debug output") do
+    config[:verbose] = true
+  end
+
+  opts.on("-x", "--exclude PATH", String, "path to exclude from watching") do |path|
+    config[:exclude] ||= []
+    config[:exclude] << path
+  end
+
+  opts.on("-s", "--sincedb PATH", String, "Sincedb path") do |path|
+    config[:sincedb_path] = path
+  end
+
+  opts.on("-i", "--interval SECONDS", Integer,
+          "Sincedb write interval") do |path|
+    config[:sincedb_write_interval] = path
+  end
+end
+
+begin
+  opts.order!
+rescue OptionParser::InvalidOption
+  $stderr.puts "#{progname}: #{$!}"
+  $stderr.puts opts.usage
+end
+
+logger = Logger.new(STDERR)
+logger.progname = progname
+logger.level = config[:verbose] ? Logger::DEBUG : Logger::INFO
+config[:logger] = logger
+
+tail = FileWatch::Tail.new(config)
+
+ARGV.each { |path| tail.tail(path) }
+
+Signal.trap("EXIT") { tail.sincedb_write("globtail exiting") }
+
+$stdout.sync = true
+tail.subscribe do |path, line|
+  puts "#{path}: #{line}"
+end

data/lib/filewatch/buftok.rb

@@ -0,0 +1,139 @@
+# BufferedTokenizer - Statefully split input data by a specifiable token
+#
+# Authors:: Tony Arcieri, Martin Emde
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Tony Arcieri and Martin Emde
+# 
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+#
+#---------------------------------------------------------------------------
+#
+
+# (C)2006 Tony Arcieri, Martin Emde
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+
+# BufferedTokenizer takes a delimiter upon instantiation, or acts line-based
+# by default.  It allows input to be spoon-fed from some outside source which
+# receives arbitrary length datagrams which may-or-may-not contain the token
+# by which entities are delimited.
+#
+# Commonly used to parse lines out of incoming data:
+#
+#  module LineBufferedConnection
+#    def receive_data(data)
+#      (@buffer ||= BufferedTokenizer.new).extract(data).each do |line|
+#        receive_line(line)
+#      end
+#    end
+#  end
+
+module FileWatch; class BufferedTokenizer
+  # New BufferedTokenizers will operate on lines delimited by "\n" by default
+  # or allow you to specify any delimiter token you so choose, which will then
+  # be used by String#split to tokenize the input data
+  def initialize(delimiter = "\n", size_limit = nil)
+    # Store the specified delimiter
+    @delimiter = delimiter
+
+    # Store the specified size limitation
+    @size_limit = size_limit
+
+    # The input buffer is stored as an array.  This is by far the most efficient
+    # approach given language constraints (in C a linked list would be a more
+    # appropriate data structure).  Segments of input data are stored in a list
+    # which is only joined when a token is reached, substantially reducing the
+    # number of objects required for the operation.
+    @input = []
+
+    # Size of the input buffer
+    @input_size = 0
+  end
+
+  # Extract takes an arbitrary string of input data and returns an array of
+  # tokenized entities, provided there were any available to extract.  This
+  # makes for easy processing of datagrams using a pattern like:
+  #
+  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
+  def extract(data)
+    # Extract token-delimited entities from the input string with the split command.
+    # There's a bit of craftiness here with the -1 parameter.  Normally split would
+    # behave no differently regardless of if the token lies at the very end of the 
+    # input buffer or not (i.e. a literal edge case)  Specifying -1 forces split to
+    # return "" in this case, meaning that the last entry in the list represents a
+    # new segment of data where the token has not been encountered
+    entities = data.split @delimiter, -1
+
+    # Check to see if the buffer has exceeded capacity, if we're imposing a limit
+    if @size_limit
+      raise 'input buffer full' if @input_size + entities.first.size > @size_limit
+      @input_size += entities.first.size
+    end
+    
+    # Move the first entry in the resulting array into the input buffer.  It represents
+    # the last segment of a token-delimited entity unless it's the only entry in the list.
+    @input << entities.shift
+
+    # If the resulting array from the split is empty, the token was not encountered
+    # (not even at the end of the buffer).  Since we've encountered no token-delimited
+    # entities this go-around, return an empty array.
+    return [] if entities.empty?
+
+    # At this point, we've hit a token, or potentially multiple tokens.  Now we can bring
+    # together all the data we've buffered from earlier calls without hitting a token,
+    # and add it to our list of discovered entities.
+    entities.unshift @input.join
+
+=begin
+    # Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
+    # empty tokens. Think of the empty line that delimits an HTTP header. It will have
+    # two "\n" delimiters in a row, and this code mishandles the resulting empty token.
+    # It someone figures out how to fix the problem, we can re-enable this code branch.
+    # Multi-chara
+cter token support.
+    # Split any tokens that were incomplete on the last iteration buf complete now.
+    entities.map! do |e|
+      e.split @delimiter, -1
+    end
+    # Flatten the resulting array.  This has the side effect of removing the empty
+    # entry at the end that was produced by passing -1 to split.  Add it again if
+    # necessary.
+    if (entities[-1] == [])
+      entities.flatten! << []
+    else
+      entities.flatten!
+    end
+=end
+
+    # Now that we've hit a token, joined the input buffer and added it to the entities
+    # list, we can go ahead and clear the input buffer.  All of the segments that were
+    # stored before the join can now be garbage collected.
+    @input.clear
+    
+    # The last entity in the list is not token delimited, however, thanks to the -1
+    # passed to split.  It represents the beginning of a new list of as-yet-untokenized  
+    # data, so we add it to the start of the list.
+    @input << entities.pop
+    
+    # Set the new input buffer size, provided we're keeping track
+    @input_size = @input.first.size if @size_limit
+
+    # Now we're left with the list of extracted token-delimited entities we wanted
+    # in the first place.  Hooray!
+    entities
+  end
+  
+  # Flush the contents of the input buffer, i.e. return the input buffer even though
+  # a token has not yet been encountered
+  def flush
+    buffer = @input.join
+    @input.clear
+    buffer
+  end
+
+  # Is the buffer empty?
+  def empty?
+    @input.empty?
+  end
+end; end

data/lib/filewatch/tail.rb

@@ -0,0 +1,340 @@
+require "filewatch/buftok"
+require "filewatch/watch"
+if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+  require "filewatch/winhelper"
+end
+require "logger"
+require "rbconfig"
+
+include Java if defined? JRUBY_VERSION
+require "JRubyFileExtension.jar" if defined? JRUBY_VERSION
+
+module FileWatch
+  class Tail
+    # how often (in seconds) we @logger.warn a failed file open, per path.
+    OPEN_WARN_INTERVAL = ENV["FILEWATCH_OPEN_WARN_INTERVAL"] ?
+                         ENV["FILEWATCH_OPEN_WARN_INTERVAL"].to_i : 300
+
+    attr_accessor :logger
+
+    class NoSinceDBPathGiven < StandardError; end
+
+    public
+    def initialize(opts={})
+      @iswindows = ((RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/) != nil)
+
+      if opts[:logger]
+        @logger = opts[:logger]
+      else
+        @logger = Logger.new(STDERR)
+        @logger.level = Logger::INFO
+      end
+      @evict = nil
+      @files = {}
+      @locked = Hash.new { |h, k| h[k] = false }
+      @changed = Hash.new { |h, k| h[k] = 0 }
+      @lastwarn = Hash.new { |h, k| h[k] = 0 }
+      @buffers = {}
+      @watch = FileWatch::Watch.new
+      @watch.logger = @logger
+      @sincedb = {}
+      @sincedb_last_write = Time.now.to_i
+      @sincedb_write_pending = false
+      @sincedb_writing = false
+      @statcache = {}
+      @opts = {
+        :eviction_interval => 60,
+        :sincedb_write_interval => 10,
+        :stat_interval => 1,
+        :discover_interval => 5,
+        :exclude => [],
+        :start_new_files_at => :end,
+        :follow_only_path => false
+      }.merge(opts)
+      if !@opts.include?(:sincedb_path)
+        @opts[:sincedb_path] = File.join(ENV["HOME"], ".sincedb") if ENV.include?("HOME")
+        @opts[:sincedb_path] = ENV["SINCEDB_PATH"] if ENV.include?("SINCEDB_PATH")
+      end
+      if !@opts.include?(:sincedb_path)
+        raise NoSinceDBPathGiven.new("No HOME or SINCEDB_PATH set in environment. I need one of these set so I can keep track of the files I am following.")
+      end
+      @watch.exclude(@opts[:exclude])
+      _start_eviction
+      _sincedb_open
+    end # def initialize
+
+    public
+    def logger=(logger)
+      @logger = logger
+      @watch.logger = logger
+    end # def logger=
+
+    public
+    def tail(path)
+      @watch.watch(path)
+    end # def tail
+
+    public
+    def subscribe(&block)
+      # subscribe(stat_interval = 1, discover_interval = 5, &block)
+      @watch.subscribe(@opts[:stat_interval],
+                       @opts[:discover_interval]) do |event, path|
+        case event
+        when :create, :create_initial
+          if @files.member?(path)
+            @logger.debug("#{event} for #{path}: already exists in @files")
+            next
+          end
+          if _open_file(path, event)
+            _read_file(path, &block)
+          end
+        when :modify
+          if !@files.member?(path)
+            @logger.debug(":modify for #{path}, does not exist in @files")
+            if _open_file(path, event)
+              _read_file(path, &block)
+            end
+          else
+            _read_file(path, &block)
+          end
+        when :delete
+          @logger.debug(":delete for #{path}, deleted from @files")
+          _read_file(path, &block)
+          @files[path].close
+          @files.delete(path)
+          @statcache.delete(path)
+        when :noupdate
+          @logger.debug(":noupdate for #{path}, from @files")
+          _sincedb_write_if_pending   # will check to see if sincedb_write requests are pending 
+        else
+          @logger.warn("unknown event type #{event} for #{path}")
+        end
+      end # @watch.subscribe
+    end # def each
+
+    private
+    def _open_file(path, event)
+      @logger.debug("_open_file: #{path}: opening")
+      @locked[path] = true
+      begin
+        if @iswindows && defined? JRUBY_VERSION
+            @files[path] = Java::RubyFileExt::getRubyFile(path)
+        else
+            @files[path] = File.open(path)
+        end
+      rescue
+        # don't emit this message too often. if a file that we can't
+        # read is changing a lot, we'll try to open it more often,
+        # and might be spammy.
+        now = Time.now.to_i
+        if now - @lastwarn[path] > OPEN_WARN_INTERVAL
+          @logger.warn("failed to open #{path}: #{$!}")
+          @lastwarn[path] = now
+        else
+          @logger.debug("(warn supressed) failed to open #{path}: #{$!}")
+        end
+        @files.delete(path)
+        @changed[path] = Time.now.to_i
+        @locked[path] = false
+        return false
+      end
+
+      stat = File::Stat.new(path)
+      
+      if @opts[:follow_only_path]
+        # In cases where files are rsynced to the consuming server, inodes will change when 
+        # updated files overwrite original ones, resulting in inode changes.  In order to 
+        # avoid having the sincedb.member check from failing in this scenario, we'll 
+        # construct the inode key using the path which will be 'stable'
+        inode = [path, stat.dev_major, stat.dev_minor]
+      else
+        if @iswindows
+          fileId = Winhelper.GetWindowsUniqueFileIdentifier(path)
+          inode = [fileId, stat.dev_major, stat.dev_minor]
+        else
+          inode = [stat.ino.to_s, stat.dev_major, stat.dev_minor]
+        end
+      end
+
+      @statcache[path] = inode
+
+      if @sincedb.member?(inode)
+        last_size = @sincedb[inode]
+        @logger.debug("#{path}: sincedb last value #{@sincedb[inode]}, cur size #{stat.size}")
+        if last_size <= stat.size
+          @logger.debug("#{path}: sincedb: seeking to #{last_size}")
+          @files[path].sysseek(last_size, IO::SEEK_SET)
+        else
+          @logger.debug("#{path}: last value size is greater than current value, starting over")
+          @sincedb[inode] = 0
+        end
+      elsif event == :create_initial && @files[path]
+        # TODO(sissel): Allow starting at beginning of the file.
+        if @opts[:start_new_files_at] == :beginning
+          @logger.debug("#{path}: initial create, no sincedb, seeking to beginning of file")
+          @files[path].sysseek(0, IO::SEEK_SET)
+          @sincedb[inode] = 0
+        else 
+          # seek to end
+          @logger.debug("#{path}: initial create, no sincedb, seeking to end #{stat.size}")
+          @files[path].sysseek(stat.size, IO::SEEK_SET)
+          @sincedb[inode] = stat.size
+        end
+      else
+        @logger.debug("#{path}: staying at position 0, no sincedb")
+      end
+      @changed[path] = Time.now.to_i
+      @locked[path] = false
+      return true
+    end # def _open_file
+
+    private
+    def _read_file(path, &block)
+      @locked[path] = true
+      @buffers[path] ||= FileWatch::BufferedTokenizer.new
+
+      changed = false
+      loop do
+        begin
+          data = @files[path].sysread(32768)
+          changed = true
+          @buffers[path].extract(data).each do |line|
+            yield(path, line)
+          end
+
+          @sincedb[@statcache[path]] = @files[path].pos
+        rescue Errno::EWOULDBLOCK, Errno::EINTR, EOFError
+          break
+        end
+      end
+
+      if changed
+        _sincedb_write
+      end
+      @changed[path] = Time.now.to_i
+      @locked[path] = false
+    end # def _read_file
+
+    public
+    def sincedb_write(reason=nil)
+      @logger.debug("caller requested sincedb write (#{reason})")
+      _sincedb_write(true)  # since this is an external request, force the write
+    end
+
+    private
+    def _sincedb_open
+      path = @opts[:sincedb_path]
+      begin
+        db = File.open(path)
+      rescue
+        @logger.debug("_sincedb_open: #{path}: #{$!}")
+        return
+      end
+
+      @logger.debug("_sincedb_open: reading from #{path}")
+      db.each do |line|
+        ino, dev_major, dev_minor, pos = line.split("*", 4)
+        inode = [ino, dev_major.to_i, dev_minor.to_i]
+        @logger.debug("_sincedb_open: setting #{inode.inspect} to #{pos.to_i}")
+        @sincedb[inode] = pos.to_i
+      end
+      db.close
+    end # def _sincedb_open
+
+    private
+    def _sincedb_write_if_pending
+
+      #  Check to see if sincedb should be written out since there was a file read after the sincedb flush, 
+      #  and during the sincedb_write_interval
+
+      if @sincedb_write_pending
+        _sincedb_write
+      end
+    end
+
+    private
+    def _sincedb_write(sincedb_force_write=false)
+
+      # This routine will only write out sincedb if enough time has passed based on @sincedb_write_interval
+      # If it hasn't and we were asked to write, then we are pending a write.
+
+      # if we were called with force == true, then we have to write sincedb and bypass a time check 
+      # ie. external caller calling the public sincedb_write method
+
+      if(@sincedb_writing)
+        @logger.warn("_sincedb_write already writing")
+        return
+      end
+
+      @sincedb_writing = true
+
+      if (!sincedb_force_write)
+         now = Time.now.to_i
+         delta = now - @sincedb_last_write
+
+         # we will have to flush out the sincedb file after the interval expires.  So, we will try again later.
+         if delta < @opts[:sincedb_write_interval]
+           @sincedb_write_pending = true
+           @sincedb_writing = false
+           return
+         end
+      end
+
+      @logger.debug("writing sincedb (delta since last write = #{delta})")
+
+      path = @opts[:sincedb_path]
+      tmp = "#{path}.new"
+      begin
+        db = File.open(tmp, "w")
+      rescue => e
+        @logger.warn("_sincedb_write failed: #{tmp}: #{e}")
+        @sincedb_writing = false
+        return
+      end
+
+      @sincedb.each do |inode, pos|
+        db.puts([inode, pos].flatten.join("*"))
+      end
+      db.close
+
+      begin
+        File.rename(tmp, path)
+      rescue => e
+        @logger.warn("_sincedb_write rename/sync failed: #{tmp} -> #{path}: #{e}")
+      end
+
+      @sincedb_last_write = now
+      @sincedb_write_pending = false
+      @sincedb_writing = false
+
+      # System.gc()
+    end # def _sincedb_write
+
+    public
+    def quit
+      @evict && @evict.kill
+      @watch.quit
+    end # def quit
+
+
+    private
+    def _start_eviction
+      @evict = Thread.new do
+        loop do
+          now = Time.now.to_i
+          @changed.keys.each do |path|
+            next if now - @changed[path] < @opts[:eviction_interval]
+            next if @locked[path]
+            next unless @files.include?(path)
+            @logger.debug(":evict for #{path}, deleted from @files")
+            @files.delete(path).close
+            @statcache.delete(path)
+            @changed.delete(path)
+            @locked.delete(path)
+          end
+          sleep 5
+        end
+      end
+    end
+  end # class Tail
+end # module FileWatch

data/lib/filewatch/watch.rb

@@ -0,0 +1,179 @@
+require "logger"
+if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+  require "filewatch/winhelper"
+end
+
+module FileWatch
+  class Watch
+    attr_accessor :logger
+
+    public
+    def initialize(opts={})
+      @iswindows = ((RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/) != nil)
+      if opts[:logger]
+        @logger = opts[:logger]
+      else
+        @logger = Logger.new(STDERR)
+        @logger.level = Logger::INFO
+      end
+      @watching = []
+      @exclude = []
+      @files = Hash.new { |h, k| h[k] = Hash.new }
+    end # def initialize
+
+    public
+    def logger=(logger)
+      @logger = logger
+    end
+
+    public
+    def exclude(path)
+      path.to_a.each { |p| @exclude << p }
+    end
+
+    public
+    def watch(path)
+      if ! @watching.member?(path)
+        @watching << path
+        _discover_file(path, true)
+      end
+
+      return true
+    end # def tail
+
+    # Calls &block with params [event_type, path]
+    # event_type can be one of:
+    #   :create_initial - initially present file (so start at end for tail)
+    #   :create - file is created (new file after initial globs, start at 0)
+    #   :modify - file is modified (size increases)
+    #   :delete - file is deleted
+    public
+    def each(&block)
+      # Send any creates.
+      @files.keys.each do |path|
+        if ! @files[path][:create_sent]
+          if @files[path][:initial]
+            yield(:create_initial, path)
+          else
+            yield(:create, path)
+          end
+          @files[path][:create_sent] = true
+        end
+      end
+
+      @files.keys.each do |path|
+        begin
+          stat = File::Stat.new(path)
+        rescue Errno::ENOENT
+          # file has gone away or we can't read it anymore.
+          @files.delete(path)
+          @logger.debug("#{path}: stat failed (#{$!}), deleting from @files")
+          yield(:delete, path)
+          next
+        end
+
+        if @iswindows
+          fileId = Winhelper.GetWindowsUniqueFileIdentifier(path)
+          inode = [fileId, stat.dev_major, stat.dev_minor]
+        else
+          inode = [stat.ino.to_s, stat.dev_major, stat.dev_minor]
+        end
+
+        if inode != @files[path][:inode]
+          @logger.debug("#{path}: old inode was #{@files[path][:inode].inspect}, new is #{inode.inspect}")
+          yield(:delete, path)
+          yield(:create, path)
+        elsif stat.size < @files[path][:size]
+          @logger.debug("#{path}: file rolled, new size is #{stat.size}, old size #{@files[path][:size]}")
+          yield(:delete, path)
+          yield(:create, path)
+        elsif stat.size > @files[path][:size]
+          @logger.debug("#{path}: file grew, old size #{@files[path][:size]}, new size #{stat.size}")
+          yield(:modify, path)
+        else 
+          # since there is no update, we should pass control back in case the caller needs to do any work
+          # otherwise, they can ONLY do other work when a file is created or modified
+          @logger.debug("#{path}: nothing to update")
+          yield(:noupdate, path)
+        end
+
+        @files[path][:size] = stat.size
+        @files[path][:inode] = inode
+      end # @files.keys.each
+    end # def each
+
+    public
+    def discover
+      @watching.each do |path|
+        _discover_file(path)
+      end
+    end
+
+    public
+    def subscribe(stat_interval = 1, discover_interval = 5, &block)
+      glob = 0
+      @quit = false
+      while !@quit
+        each(&block)
+
+        glob += 1
+        if glob == discover_interval
+          discover
+          glob = 0
+        end
+
+        sleep(stat_interval)
+      end
+    end # def subscribe
+
+    private
+    def _discover_file(path, initial=false)
+      globbed_dirs = Dir.glob(path)
+      @logger.debug("_discover_file_glob: #{path}: glob is: #{globbed_dirs}")
+      if globbed_dirs.empty? && File.file?(path)
+        globbed_dirs = [path]
+        @logger.debug("_discover_file_glob: #{path}: glob is: #{globbed_dirs} because glob did not work")
+      end
+      globbed_dirs.each do |file|
+        next if @files.member?(file)
+        next unless File.file?(file)
+
+        @logger.debug("_discover_file: #{path}: new: #{file} (exclude is #{@exclude.inspect})")
+
+        skip = false
+        @exclude.each do |pattern|
+          if File.fnmatch?(pattern, File.basename(file))
+            @logger.debug("_discover_file: #{file}: skipping because it " +
+                          "matches exclude #{pattern}")
+            skip = true
+            break
+          end
+        end
+        next if skip
+
+        stat = File::Stat.new(file)
+        @files[file] = {
+          :size => 0,
+          :inode => [stat.ino, stat.dev_major, stat.dev_minor],
+          :create_sent => false,
+        }
+
+        if @iswindows
+          fileId = Winhelper.GetWindowsUniqueFileIdentifier(path)
+          @files[file][:inode] = [fileId, stat.dev_major, stat.dev_minor]
+        else
+          @files[file][:inode] = [stat.ino.to_s, stat.dev_major, stat.dev_minor]
+        end
+
+        if initial
+          @files[file][:initial] = true
+        end
+      end
+    end # def _discover_file
+
+    public
+    def quit
+      @quit = true
+    end # def quit
+  end # class Watch
+end # module FileWatch

data/lib/filewatch/winhelper.rb

@@ -0,0 +1,70 @@
+require "ffi"
+	
+module Winhelper
+	extend FFI::Library
+	
+	ffi_lib 'kernel32'
+	ffi_convention :stdcall
+	class FileTime < FFI::Struct
+		layout :lowDateTime, :uint,
+		:highDateTime, :uint
+	end
+	
+	#http://msdn.microsoft.com/en-us/library/windows/desktop/aa363788(v=vs.85).aspx
+	class FileInformation < FFI::Struct
+		def initialize()
+			createTime = FileTime.new
+			lastAccessTime = FileTime.new
+			lastWriteTime = FileTime.new
+		end
+		
+		layout :fileAttributes, :uint, #DWORD    dwFileAttributes;
+		:createTime, FileTime,  #FILETIME ftCreationTime;
+		:lastAccessTime, FileTime, #FILETIME ftLastAccessTime;
+		:lastWriteTime, FileTime, #FILETIME ftLastWriteTime;
+		:volumeSerialNumber, :uint, #DWORD    dwVolumeSerialNumber;
+		:fileSizeHigh, :uint, #DWORD    nFileSizeHigh;
+		:fileSizeLow, :uint, #DWORD    nFileSizeLow;
+		:numberOfLinks, :uint, #DWORD    nNumberOfLinks;
+		:fileIndexHigh, :uint, #DWORD    nFileIndexHigh;
+		:fileIndexLow, :uint #DWORD    nFileIndexLow;
+	end
+		
+	
+	#http://msdn.microsoft.com/en-us/library/windows/desktop/aa363858(v=vs.85).aspx
+	#HANDLE WINAPI CreateFile(_In_ LPCTSTR lpFileName,_In_  DWORD dwDesiredAccess,_In_ DWORD dwShareMode,
+	#						_In_opt_  LPSECURITY_ATTRIBUTES lpSecurityAttributes,_In_  DWORD dwCreationDisposition,
+	#						_In_      DWORD dwFlagsAndAttributes,_In_opt_  HANDLE hTemplateFile);
+	attach_function :GetOpenFileHandle, :CreateFileA, [:pointer, :uint, :uint, :pointer, :uint, :uint, :pointer], :pointer	
+	
+	#http://msdn.microsoft.com/en-us/library/windows/desktop/aa364952(v=vs.85).aspx
+	#BOOL WINAPI GetFileInformationByHandle(_In_   HANDLE hFile,_Out_  LPBY_HANDLE_FILE_INFORMATION lpFileInformation);
+	attach_function :GetFileInformationByHandle, [:pointer, :pointer], :int
+	
+	attach_function :CloseHandle, [:pointer], :int
+	
+	
+	def self.GetWindowsUniqueFileIdentifier(path)
+		handle = GetOpenFileHandle(path, 0, 7, nil, 3, 128, nil)
+		fileInfo = Winhelper::FileInformation.new
+		success = GetFileInformationByHandle(handle, fileInfo)
+		CloseHandle(handle)
+		if  success == 1
+			#args = [
+			#		fileInfo[:fileAttributes], fileInfo[:volumeSerialNumber], fileInfo[:fileSizeHigh], fileInfo[:fileSizeLow], 
+			#		fileInfo[:numberOfLinks], fileInfo[:fileIndexHigh], fileInfo[:fileIndexLow]
+			#	]
+			#p "Information: %u %u %u %u %u %u %u " % args
+			#this is only guaranteed on NTFS, for ReFS on windows 2012, GetFileInformationByHandleEx should be used with FILE_ID_INFO, which returns a 128 bit identifier
+			return "#{fileInfo[:volumeSerialNumber]}-#{fileInfo[:fileIndexLow]}-#{fileInfo[:fileIndexHigh]}"
+		else
+			#p "cannot retrieve file information, returning path"
+			return path;
+		end
+	end
+end
+
+#fileId = Winhelper.GetWindowsUniqueFileIdentifier('C:\inetpub\logs\LogFiles\W3SVC1\u_ex1fdsadfsadfasdf30612.log')
+#p "FileId: " + fileId
+#p "outside function, sleeping"
+#sleep(10)

data/test/filewatch/tail.rb

@@ -0,0 +1,17 @@
+$:.unshift(File.join(File.dirname(__FILE__), "..", "..", "lib"))
+require "minitest/unit"
+require "minitest/autorun"
+require "filewatch/tail"
+
+class TailTest < MiniTest::Unit::TestCase
+  def test_quit
+    require "timeout"
+    tail = FileWatch::Tail.new
+    #Thread.new(tail) { |t| sleep(1); t.quit }
+
+    #Timeout.timeout(5) do
+      #tail.subscribe { |e| }
+    #end
+    tail.quit
+  end
+end # class TailTest

data/test/globtail/Makefile

@@ -0,0 +1,7 @@
+test:
+	@i=1; while [ -x "test$${i}.sh" ]; do \
+		echo "test$${i}:" ; \
+		./test$${i}.sh || exit 1 ; \
+		echo "PASS" ; \
+		i=$$(($$i+1)) ; \
+	done

data/test/globtail/framework.sh

@@ -0,0 +1,58 @@
+#!/bin/sh
+
+test_init() {
+  export TEST_BASE=$(dirname $0)
+  export FW_BASE="$TEST_BASE/../.."
+  export RUBYLIB=$FW_BASE/lib:$RUBYLIB
+  export SINCEDB=$(mktemp)
+  export TAIL="$FW_BASE/bin/globtail -v -s $SINCEDB -i 5 -x skip*.log"
+  export TEST_DIR=$(mktemp -d)
+  export TEST_OUT=$(mktemp)
+  touch $TEST_OUT
+  mkdir -p $TEST_DIR
+}
+
+test_start() {
+  $TAIL "$TEST_DIR/*" >>$TEST_OUT 2>&1 &
+  export TEST_TAIL_PID=$!
+
+  # let globtail get started and do it's initial glob
+  sleep 3
+}
+
+test_stop() {
+  kill $TEST_TAIL_PID 2>/dev/null
+  count=0
+  while kill -0 $TEST_TAIL_PID 2>/dev/null; do
+    count=$((count+1))
+    sleep 1
+    if [ "$count" -eq 5 ]; then
+      kill -9 $TEST_TAIL_PID
+      count=0
+    fi
+  done
+  export TEST_TAIL_PID=""
+}
+
+test_done() {
+  [ -n "$TEST_TAIL_PID" ] && test_stop
+
+  output=$(mktemp)
+  output_clean=$(mktemp)
+  sed -e "s,^${TEST_DIR}/,," $TEST_OUT | sort > $output
+  sed -e '/^D, \[/d' < $output > $output_clean
+
+  data_file=$(echo $0 | sed -e 's/\.sh$/.data/')
+
+  diff $TEST_BASE/$data_file $output_clean >/dev/null
+  diff_rc=$?
+
+  if [ $diff_rc -ne 0 ]; then
+    diff -u $TEST_BASE/$data_file $output_clean
+    echo "$0 TEST FAILURE (output differs)"
+    sed -e 's,^,output: ,' $TEST_OUT
+  fi
+
+  rm -rf $TEST_DIR $TEST_OUT $output $output_clean $SINCEDB
+  exit $diff_rc
+}

data/test/globtail/test1.data

@@ -0,0 +1,5 @@
+a.log: a
+a.log: a
+b.log: b
+c.log: c
+c.log: c

data/test/globtail/test1.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# Test: basic tail support
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo a > $TEST_DIR/a.log
+echo b > $TEST_DIR/b.log
+echo c > $TEST_DIR/c.log
+echo a >> $TEST_DIR/a.log
+echo c >> $TEST_DIR/c.log
+
+sleep 5
+
+test_done

data/test/globtail/test10.data

@@ -0,0 +1,4 @@
+a.log: 1
+a.log: 2
+a.log: 3
+a.log: 4

data/test/globtail/test10.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+# Test: file rename & old file name having new data
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo 1 > $TEST_DIR/a.log
+sleep 8
+
+echo 2 >> $TEST_DIR/a.log
+sleep 3
+
+echo 3 >> $TEST_DIR/a.log
+mv $TEST_DIR/a.log $TEST_DIR/b.log
+echo 4 > $TEST_DIR/a.log
+sleep 8
+
+test_done

data/test/globtail/test2.data

@@ -0,0 +1,2 @@
+a.log: a
+b.log: b

data/test/globtail/test2.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# Test: tests glob discovery of a new file, and in-memory sincedb
+# preserving file position after a rename
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo a > $TEST_DIR/a.log
+sleep 5
+mv $TEST_DIR/a.log $TEST_DIR/b.log
+sleep 5
+echo b >> $TEST_DIR/b.log
+sleep 3
+
+test_done

data/test/globtail/test3.data

@@ -0,0 +1,3 @@
+a.log: a
+a.log: b
+b.log: c

data/test/globtail/test3.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+# Test: tests glob discovery of a new file, and in-memory sincedb
+# preserving file position after a rename
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo a > $TEST_DIR/a.log
+echo b >> $TEST_DIR/a.log
+sleep 5
+mv $TEST_DIR/a.log $TEST_DIR/b.log
+sleep 5
+echo c >> $TEST_DIR/b.log
+sleep 3
+
+test_done

data/test/globtail/test4.data

@@ -0,0 +1,4 @@
+a.log: 1
+a.log: 2
+a.log: 3
+a.log: 4

data/test/globtail/test4.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+# Test: tests file truncation
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo 1 > $TEST_DIR/a.log
+echo 2 >> $TEST_DIR/a.log
+echo 3 >> $TEST_DIR/a.log
+sleep 3
+echo 4 > $TEST_DIR/a.log
+sleep 3
+
+test_done

data/test/globtail/test5.data

@@ -0,0 +1,6 @@
+a.log: 1
+a.log: 2
+a.log: 3
+a.log: 4
+a.log: 5
+a.log: 6

data/test/globtail/test5.sh

@@ -0,0 +1,25 @@
+#!/bin/sh
+# Test: make sure we properly write a sincedb on SIGTERM, and pick up
+# new log lines that were written while globtail is being restarted.
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo 1 > $TEST_DIR/a.log
+echo 2 >> $TEST_DIR/a.log
+echo 3 >> $TEST_DIR/a.log
+sleep 6
+
+echo 4 >> $TEST_DIR/a.log
+test_stop
+
+echo 5 >> $TEST_DIR/a.log
+
+test_start
+
+echo 6 >> $TEST_DIR/a.log
+sleep 3
+
+test_done

data/test/globtail/test6.data

@@ -0,0 +1,6 @@
+a.log: 1
+a.log: 2
+a.log: 3
+a.log: 4
+a.log: 5
+a.log: 6

data/test/globtail/test6.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+# Test: ensure sincedb periodic database writing works (make sure we're not
+# relying on SIGTERM handling)
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo 1 > $TEST_DIR/a.log
+echo 2 >> $TEST_DIR/a.log
+echo 3 >> $TEST_DIR/a.log
+sleep 8
+
+echo 4 >> $TEST_DIR/a.log
+sleep 3
+
+# send a "kill -9" to test that the sincedb write interval stuff is working
+kill -9 $TEST_TAIL_PID
+test_stop
+
+echo 5 >> $TEST_DIR/a.log
+
+test_start
+
+echo 6 >> $TEST_DIR/a.log
+sleep 3
+
+test_done

data/test/globtail/test7.data

@@ -0,0 +1,5 @@
+a.log: 1
+a.log: 2
+a.log: 3
+b.log: 4
+b.log: 5

data/test/globtail/test7.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+# Test: make sure a renamed file resumes it's since state
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo 1 > $TEST_DIR/a.log
+echo 2 >> $TEST_DIR/a.log
+echo 3 >> $TEST_DIR/a.log
+sleep 6
+
+test_stop
+
+echo 4 >> $TEST_DIR/a.log
+mv $TEST_DIR/a.log $TEST_DIR/b.log
+
+test_start
+
+echo 5 >> $TEST_DIR/b.log
+sleep 3
+
+test_done

data/test/globtail/test8.data

@@ -0,0 +1,5 @@
+a.log: 1
+a.log: 2
+a.log: 3
+a.log: 4
+a.log: 5

data/test/globtail/test8.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+# Test: sincedb, and file truncation between globtail runs
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo 1 > $TEST_DIR/a.log
+echo 2 >> $TEST_DIR/a.log
+echo 3 >> $TEST_DIR/a.log
+sleep 8
+
+test_stop
+
+echo 4 > $TEST_DIR/a.log
+
+test_start
+
+echo 5 >> $TEST_DIR/a.log
+sleep 3
+
+test_done

data/test/globtail/test9.data

@@ -0,0 +1,3 @@
+a.log: a1
+b.log: b1
+b.log: b2

data/test/globtail/test9.sh

@@ -0,0 +1,22 @@
+#!/bin/sh
+# Test: exclude support
+
+. $(dirname $0)/framework.sh
+
+test_init
+test_start
+
+echo a1 > $TEST_DIR/a.log
+echo b1 > $TEST_DIR/b.log
+echo nope1 > $TEST_DIR/skip1.log
+
+sleep 8
+
+mv $TEST_DIR/b.log $TEST_DIR/skip2.log
+echo b2 > $TEST_DIR/b.log
+sleep 8
+
+echo nope2 >> $TEST_DIR/skip2.log
+sleep 3
+
+test_done

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: ffilewatch
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Jordan Sissel
+- Pete Fritchman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-05 00:00:00.000000000 Z
+dependencies: []
+description: Watch files and directories in ruby. Also supports tailing and glob file
+  patterns.
+email:
+- jls@semicomplete.com
+- petef@databits.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/globtail
+- lib/JRubyFileExtension.jar
+- lib/filewatch/buftok.rb
+- lib/filewatch/tail.rb
+- lib/filewatch/watch.rb
+- lib/filewatch/winhelper.rb
+- test/filewatch/tail.rb
+- test/globtail/Makefile
+- test/globtail/framework.sh
+- test/globtail/test1.data
+- test/globtail/test1.sh
+- test/globtail/test10.data
+- test/globtail/test10.sh
+- test/globtail/test2.data
+- test/globtail/test2.sh
+- test/globtail/test3.data
+- test/globtail/test3.sh
+- test/globtail/test4.data
+- test/globtail/test4.sh
+- test/globtail/test5.data
+- test/globtail/test5.sh
+- test/globtail/test6.data
+- test/globtail/test6.sh
+- test/globtail/test7.data
+- test/globtail/test7.sh
+- test/globtail/test8.data
+- test/globtail/test8.sh
+- test/globtail/test9.data
+- test/globtail/test9.sh
+homepage: https://github.com/jordansissel/ruby-filewatch
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: filewatch - file watching for ruby
+test_files: []
+has_rdoc: