file_monitoring 0.0.2

data/bin/file_monitoring

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+# Monitors add/remove/update of files and directories.
+# File monitoring checks file modification date and size.
+# If one of the above changed, the file considered as changed.
+# A log file is written with all incremental changes of files.
+#
+# Install:
+# gem build file_monitoring.gemspec
+# gem install file_monitoring
+#
+# Run: file_monitoring {conf_file} {app suffix}
+# Examples:
+# file_monitoring
+# or
+# file_monitoring conf.yml
+# or
+# file_monitoring conf.yml my_instance
+#
+# Note that scan period is in seconds.
+# cong.yml structure:
+# log_path: ~/my_monitor_log_dir/log
+# paths:
+# - path: /a_path/one
+#   scan_period: 100
+#   stable_state: 5
+# - path: /a_path/two
+#   scan_period: 600
+#   stable_state: 3
+
+require 'rubygems'
+require 'daemons'
+require 'file_monitoring/file_monitoring.rb'
+
+conf_file_path = File.expand_path('~/.bbfs/etc/file_monitoring.yml')
+if ARGV.length > 1
+  conf_file_path = File.expand_path(ARGV[1])
+end
+
+daemon_suffix = ''
+if ARGV.length > 2
+  daemon_suffix = '_' + ARGV[2]
+end
+
+puts "Config taken from:" + conf_file_path
+pid_dir = File.expand_path('~/.bbfs/run/' + daemon_suffix)
+FileUtils.mkdir_p(pid_dir)
+puts "pid dir:" + pid_dir
+
+Daemons.run_proc(
+  'file_monitoring' + daemon_suffix, # name of daemon
+  :dir_mode => :normal,
+  :dir => pid_dir, # directory where pid file will be stored
+#  :backtrace => true,
+#  :monitor => true,
+#  :log_output => true
+) do
+  monitor_files(conf_file_path)
+end

data/lib/file_monitoring/file_monitoring.rb

@@ -0,0 +1,47 @@
+require 'file_monitoring/monitor_path.rb'
+require 'algorithms'
+require 'fileutils'
+require 'yaml'
+
+# The main method. Loops on all paths each time span and monitors them.
+def monitor_files(config_path)
+  config_yml = YAML::load_file(config_path)
+  conf_array = config_yml["paths"]
+
+  pq = Containers::PriorityQueue.new
+  conf_array.each { |elem|
+    priority = (Time.now + elem["scan_period"]).to_i
+    pq.push([priority, elem, DirStat.new(elem["path"], elem["stable_state"])], -priority)
+  }
+
+  log_path = File.expand_path("~/.bbfs/log/file_monitoring.log")
+  if config_yml.key?("log_path")
+    log_path = File.expand_path(config_yml["log_path"])
+  end
+
+  puts "Log path:" + log_path
+  FileUtils.mkdir_p(File.dirname(log_path))
+  log = File.open(log_path, 'w')
+  FileStat.set_log(log)
+
+  while true do
+    time, conf, dir_stat = pq.pop
+    #puts "time:" + time.to_s()
+    #puts "now:" + Time.now.to_i.to_s()
+    #puts conf
+
+    time_span = time - Time.now.to_i
+    if (time_span > 0)
+      sleep(time_span)
+    end
+
+    dir_stat.monitor
+
+    #puts conf["path"]
+    #puts conf["scan_period"]
+    priority = (Time.now + conf["scan_period"]).to_i
+    pq.push([priority, conf, dir_stat], -priority)
+  end
+
+  log.close
+end

data/lib/file_monitoring/monitor_path.rb

@@ -0,0 +1,265 @@
+#  Path monitoring.
+
+#  Enum-like structure that includes possible filesystem entities (files/directories) states:
+# * <tt>NON_EXISTING</tt> - Entity that was treated during previous run, but absent currently
+# * <tt>NEW</tt> - Entity that was found and added to control during this run
+# * <tt>CHANGED</tt> - State was changed between two checks
+# * <tt>UNCHANGED</tt> - Opposite to CHANGED
+# * <tt>STABLE</tt> - Entity is in the UNCHANGED state for a defined (by user) number of iterations
+class FileStatEnum
+  NON_EXISTING = "NON_EXISTING"
+  NEW = "NEW"
+  CHANGED = "CHANGED"
+  UNCHANGED = "UNCHANGED"
+  STABLE = "STABLE"
+end
+
+#  This class holds current state of file and methods to control and report changes
+class FileStat
+  attr_reader :cycles, :path, :stable_state, :state, :size, :modification_time
+
+  DEFAULT_STABLE_STATE = 10
+
+  @@log = nil
+
+  #  Initializes new file monitoring object
+  # ==== Arguments:
+  #
+  # * <tt>path</tt> - File location
+  # * <tt>stable_state</tt> - Number of iterations to move unchanged file to stable state
+  def initialize(path, stable_state = DEFAULT_STABLE_STATE)
+    @path ||= path
+    @size = nil
+    @modification_time = nil
+    @cycles = 0  # number of iterations from the last file modification
+    @state = FileStatEnum::NON_EXISTING
+
+    @stable_state = stable_state  # number of iteration to move unchanged file to stable state
+  end
+
+  #  Sets a log file to report changes
+  # ==== Arguments:
+  #
+  # * <tt>log</tt> - already opened ruby File object
+  def self.set_log (log)
+    @@log = log
+  end
+
+  #  Checks whether file was changed from the last iteration.
+  #  For files size and modification time are checked.
+  def monitor
+    file_stats = File.lstat(@path) rescue nil
+    new_state = nil
+    if file_stats == nil
+      new_state = FileStatEnum::NON_EXISTING
+      @size = nil
+      @modification_time = nil
+      @cycles = 0
+    elsif @size == nil
+      new_state = FileStatEnum::NEW
+      @size = file_stats.size
+      @modification_time = file_stats.mtime.utc
+      @cycles = 0
+    elsif changed?(file_stats)
+      new_state = FileStatEnum::CHANGED
+      @size = file_stats.size
+      @modification_time = file_stats.mtime.utc
+      @cycles = 0
+    else
+      new_state = FileStatEnum::UNCHANGED
+      @cycles += 1
+      if @cycles >= @stable_state
+        new_state = FileStatEnum::STABLE
+      end
+    end
+
+    # The assignment
+    self.state= new_state
+  end
+
+  #  Checks that stored file attributes are the same as file attributes taken from file system.
+  def changed?(file_stats)
+    not (file_stats.size == size and file_stats.mtime.utc == modification_time.utc)
+  end
+
+  #  Sets and writes to the log a new state.
+  def state= (new_state)
+    if (@state != new_state or @state == FileStatEnum::CHANGED)
+      @state = new_state
+      if (@@log)
+        @@log.puts(cur_stat)
+        @@log.flush  #Ruby1.9.3: note that this is Ruby internal buffering only; the OS may buffer the data as well
+      end
+    end
+  end
+
+  #  Checks whether path and state are the same as of the argument
+  def == (other)
+    @path == other.path and @stable_state == other.stable_state
+  end
+
+  #  Returns path and state of the file with indentation
+  def to_s (indent = 0)
+    (" " * indent) + path.to_s + " : " + state.to_s
+  end
+
+  #  Reports current state with identification.
+  #  # This format used by log file.
+  def cur_stat
+    # TODO what output format have to be ?
+    Time.now.utc.to_s + " : " + self.state + " : " + self.path
+  end
+end
+
+#  This class holds current state of directory and methods to control changes
+class DirStat < FileStat
+  #  Initializes new directory monitoring object
+  # ==== Arguments:
+  #
+  # * <tt>path</tt> - File location
+  # * <tt>stable_state</tt> - Number of iterations to move unchanged directory to stable state
+  def initialize(path, stable_state = DEFAULT_STABLE_STATE)
+    super
+    @dirs = nil
+    @files = nil
+  end
+
+  #  Adds directory for monitoring.
+  def add_dir (dir)
+    @dirs[dir.path] = dir
+  end
+
+  #  Adds file for monitoring.
+  def add_file (file)
+    @files[file.path] = file
+  end
+
+  #  Removes directory from monitoring.
+  def rm_dir(dir)
+    @dirs.delete(dir.path)
+  end
+
+  #  Removes file from monitoring.
+  def rm_file(file)
+    @files.delete(file.path)
+  end
+
+  #  Checks that there is a sub-folder with a given path.
+  def has_dir?(path)
+    @dirs.has_key?(path)
+  end
+
+  #  Checks that there is a file with a given path.
+  def has_file?(path)
+    @files.has_key?(path)
+  end
+
+  #  Returns string with contains path and state of this directory as well as it's structure.
+  def to_s(indent = 0)
+    indent_increment = 2
+    child_indent = indent + indent_increment
+    res = super
+    @files.each_value do |file|
+      res += "\n" + file.to_s(child_ident)
+    end
+    @dirs.each_value do |dir|
+      res += "\n" + dir.to_s(child_ident)
+    end
+    res
+  end
+
+  #  Checks that directory structure (i.e. files and directories located directly under this directory)
+  #  wasn't changed since the last iteration.
+  def monitor
+    was_changed = false
+    new_state = nil
+    self_stat = File.lstat(@path) rescue nil
+    if self_stat == nil
+      new_state = FileStatEnum::NON_EXISTING
+      @files = nil
+      @dirs = nil
+      @cycles = 0
+    elsif @files == nil
+      new_state = FileStatEnum::NEW
+      @files = Hash.new
+      @dirs = Hash.new
+      @cycles = 0
+      update_dir
+    elsif update_dir
+      new_state = FileStatEnum::CHANGED
+      @cycles = 0
+    else
+      new_state = FileStatEnum::UNCHANGED
+      @cycles += 1
+      if @cycles >= @stable_state
+        new_state = FileStatEnum::STABLE
+      end
+    end
+
+    # The assignment
+    self.state= new_state
+  end
+
+  # Updates the files and directories hashes and globs the directory for changes.
+  def update_dir
+    was_changed = false
+
+    # monitor existing and absent files
+    @files.each_value do |file|
+      file.monitor
+
+      if file.state == FileStatEnum::NON_EXISTING
+        was_changed = true
+        rm_file(file)
+      end
+    end
+
+    @dirs.each_value do |dir|
+      dir.monitor
+
+      if dir.state == FileStatEnum::NON_EXISTING
+        was_changed = true
+        rm_dir(dir)
+      end
+    end
+
+    was_changed = was_changed || glob_me
+
+    return was_changed
+  end
+
+  #  Globs the directory for new files and directories
+  def glob_me
+    was_changed = false
+    files = Dir.glob(path + "/*")
+
+    # add and monitor new files and directories
+    files.each do |file|
+      file_stat = File.lstat(file) rescue nil
+      if (file_stat.directory?)
+        unless (has_dir?(file)) # new directory
+                                # change state only for existing directories
+                                # newly added directories have to remain with NEW state
+          was_changed = true
+          ds = DirStat.new(file, self.stable_state)
+          ds.monitor
+          add_dir(ds)
+        end
+      else # it is a file
+        unless(has_file?(file)) # new file
+                                # change state only for existing directories
+                                # newly added directories have to remain with NEW state
+          was_changed = true
+          fs = FileStat.new(file, self.stable_state)
+          fs.monitor
+          add_file(fs)
+        end
+      end
+    end
+
+    return was_changed
+  end
+
+  protected :add_dir, :add_file, :rm_dir, :rm_file, :update_dir, :glob_me
+end
+

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: file_monitoring
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Gena Petelko, Kolman Vornovitsky
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-01 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: algorithms
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Deamon for monitoring file changes.
+email: kolmanv@gmail.com
+executables: 
+- file_monitoring
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/file_monitoring/file_monitoring.rb
+- lib/file_monitoring/monitor_path.rb
+- bin/file_monitoring
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Deamon for monitoring file changes.
+test_files: []
+