grippy-doozer 0.1.0

data/lib/doozer/watcher.rb

@@ -0,0 +1,375 @@
+## taken from: http://paulhorman.com/filesystemwatcher/
+require "md5"
+require "thread"
+
+# The Runnable module is a generic mixin for including state and
+# status information in a class
+module ServiceState
+  # state constants
+  NOT_STARTED = 0
+  STARTED = 1
+  STOPPED = 2
+  CONFIGURED = 3
+  
+  attr_reader :startTime, :endTime
+  
+  # Initialize the state information
+  def initializeState()
+    @configured = false
+    @startTime = 0
+    @stopTime = 0
+    
+    @stateMutex = Mutex.new()
+    @stopWhen = nil
+    setState(NOT_STARTED)
+  end
+  
+  # Set the callback for when someone calls setState. You
+  # will be passed the state CONSTANT being set
+  def onStateChange(&callbackBlock)
+    @stateCallback = callbackBlock
+  end
+  
+  # All methods, inside this class or not, should use this
+  # method to change the state of the JobRunner
+  # @param newState The new state value
+  def setState(newState)
+    @stateMutex.synchronize {
+      if newState == CONFIGURED then
+	@configured = true
+      else
+	@state = newState
+	if isStarted? then
+	  @startTime = Time.now()
+	elsif isStopped?
+	  @stopTime = Time.now()
+	end
+      end
+    }
+    
+    if defined?(@stateCallback) then
+      @stateCallback.call(newState)
+    end
+  end
+  
+  def isConfigured?
+    return @configured
+  end
+
+  def isStarted?
+    return @state == STARTED
+  end
+
+  def isStopped?
+    if @state == STOPPED then
+      return true
+    elsif @stopWhen && @stopWhen.call() then
+      setState(STOPPED)
+      return true
+    else
+      return false
+    end
+  end   
+
+  def stopWhen(&block)
+    @stopWhen = block
+  end
+end
+
+
+# This class will watch a directory or a set of directories and alert you of
+# new files, modified files, deleted files. You can optionally only be alerted
+# when a files md5 hash has been changed so you only are alerted to real changes.
+# this of course means slower performance and higher cpu/io usage.
+class FileSystemWatcher
+  include ServiceState
+
+  CREATED = 0
+  MODIFIED = 1
+  DELETED = 2
+
+  # the time to wait before checking the directories again
+  attr_accessor :sleepTime, :priority, :mongrel
+
+  # you can optionally use the file contents md5 to detect if a file has changed
+  attr_accessor :useMD5
+
+  def initialize(dir=nil, expression="**/*")
+    @sleepTime = 5
+    @useMD5 = false
+    @priority = 0
+    @stopWhen = nil
+
+    @directories = Array.new()
+    @files = Array.new()
+
+    @foundFiles = nil
+    @firstLoad = true
+    @watchThread = nil
+    
+    initializeState()
+
+    if dir then
+      addDirectory(dir, expression)
+    end
+  end
+
+  # add a directory to be watched
+  # @param dir the directory to watch
+  # @param expression the glob pattern to search under the watched directory
+  def addDirectory(dir, expression="**/*")
+    if FileTest.exists?(dir) && FileTest.readable?(dir) then
+      @directories << FSWatcher::Directory.new(dir, expression)
+    else
+      raise FSWatcher::InvalidDirectoryError, "Dir '#{dir}' either doesnt exist or isnt readable"
+    end
+  end
+
+  def removeDirectory(dir)
+    @directories.delete(dir)
+  end
+
+  # add a specific file to the watch list
+  # @param file the file to watch
+  def addFile(file)
+    if FileTest.exists?(file) && FileTest.readable?(file) then
+      @files << file
+    else
+      raise FSWatcher::InvalidFileError, "File '#{file}' either doesnt exist or isnt readable"
+    end
+  end
+
+  def removeFile(file)
+    @files.delete(file)
+  end
+
+  # start watching the specified files/directories
+  def start(&block)
+    if isStarted? then
+      raise RuntimeError, "already started"
+    end
+
+    setState(STARTED)
+
+    @firstLoad = true
+    @foundFiles = Hash.new()
+
+    # we watch in a new thread
+    @watchThread = Thread.new {
+      # we will be stopped if someone calls stop or if someone set a stopWhen that becomes true
+      while !isStopped? do
+	if (!@directories.empty?) or (!@files.empty?) then	
+	  # this will hold the list of the files we looked at this iteration
+	  # allows us to not look at the same file again and also to compare
+	  # with the foundFile list to see if something was deleted
+	  alreadyExamined = Hash.new()
+	  
+	  # check the files in each watched directory
+	  if not @directories.empty? then
+	    @directories.each { |dirObj|
+	      examineFileList(dirObj.getFiles(), alreadyExamined, &block)
+	    }
+	  end
+	  
+	  # now examine any files the user wants to specifically watch
+	  examineFileList(@files, alreadyExamined, &block) if not @files.empty?
+	  
+	  # see if we have to delete files from our found list
+	  if not @firstLoad then
+	    if not @foundFiles.empty? then
+	      # now diff the found files and the examined files to see if
+	      # something has been deleted
+	      allFoundFiles = @foundFiles.keys()
+	      allExaminedFiles = alreadyExamined.keys()
+	      intersection = allFoundFiles - allExaminedFiles
+	      intersection.each { |fileName|
+        # callback
+        block.call(DELETED, fileName)
+        # remove deleted file from the foundFiles list
+        @foundFiles.delete(fileName)
+            }	  
+          end
+        else
+          @firstLoad = false
+        end
+      end
+
+        # go to sleep
+        sleep(@sleepTime)
+          end
+        }
+    
+    # set the watch thread priority
+    @watchThread.priority = @priority
+
+  end
+
+  # kill the filewatcher thread
+  def stop()
+    setState(STOPPED)
+    @watchThread.wakeup()
+  end
+
+  # wait for the filewatcher to finish
+  def join()
+    @watchThread.join() if @watchThread
+  end
+
+
+  private
+
+  # loops over the file list check for new or modified files
+  def examineFileList(fileList, alreadyExamined, &block)
+    fileList.each { |fileName|
+      # expand the file name to the fully qual path
+      fullFileName = File.expand_path(fileName)
+
+      # dont examine the same file 2 times
+      if not alreadyExamined.has_key?(fullFileName) then
+	# we cant do much if the file isnt readable anyway
+	if File.readable?(fullFileName) then
+	  # set that we have seen this file
+	  alreadyExamined[fullFileName] = true
+	  
+	  # get the file info
+	  modTime, size = File.mtime(fullFileName), File.size(fullFileName)
+	  
+	  # on the first iteration just load all of the files into the foundList
+	  if @firstLoad then
+	    @foundFiles[fullFileName] = FSWatcher::FoundFile.new(fullFileName, modTime, size, false, @useMD5)
+	  else
+	    # see if we have found this file already
+	    foundFile = @foundFiles[fullFileName]
+
+	    if foundFile then
+	      
+	      # if a file is marked as new, we still need to make sure it isnt still
+	      # being written to. we do this by checking the file sizes.
+	      if foundFile.isNew? then
+		
+		# if the file size is the same then it is probably done being written to
+		# unless the writer is really slow
+		if size == foundFile.size then		  
+
+		  # callback
+		  block.call(CREATED, fullFileName)
+		  
+		  # mark this file as a changed file now
+		  foundFile.updateModTime(modTime)
+		  
+		  # generate the md5 for the file since we know it is done
+		  # being written to
+		  foundFile.genMD5() if @useMD5
+		  
+		else
+		  
+		  # just update the size so we can check again at the next iteration
+		  foundFile.updateSize(size)
+		  
+		end
+		
+	      elsif modTime > foundFile.modTime then
+
+  	      # if the mod times are different on files we already have
+          # found this is an update		
+          willYield = true
+
+          # if we are using md5's then compare them
+          if @useMD5 then
+            filesMD5 = FSWatcher.genFileMD5(fullFileName)
+            if filesMD5 && foundFile.md5 then
+              if filesMD5.to_s == foundFile.md5.to_s then
+                willYield = false
+              end
+            end
+
+            # if we are yielding then the md5s are dif so
+            # update the cached md5 value
+            foundFile.setMD5(filesMD5) if willYield
+
+          end
+
+          block.call(MODIFIED, fullFileName) if willYield		
+          foundFile.updateModTime(modTime)
+	      end
+	    else
+	      # this is a new file for our list. dont update the md5 here since
+	      # the file might not yet be done being written to
+	      @foundFiles[fullFileName] = FSWatcher::FoundFile.new(fullFileName, modTime, size)
+	    end
+	  end
+	end
+      end
+    }
+  end
+end
+
+# Util classes for the FileSystemWatcher
+module FSWatcher
+  # The directory to watch
+  class Directory
+    attr_reader :dir, :expression
+
+    def initialize(dir, expression)
+      @dir, @expression = dir, expression
+      @dir.chop! if @dir =~ %r{/$}
+    end
+
+    def getFiles()
+      return Dir[@dir + "/" + @expression]
+    end
+  end
+
+  # A FoundFile entry for the FileSystemWatcher
+  class FoundFile
+    attr_reader :status, :fileName, :modTime, :size, :md5
+
+    def initialize(fileName, modTime, size, isNewFile=true, useMD5=false)
+      @fileName, @modTime, @size, @isNewFile  = fileName, modTime, size, isNewFile      
+      @md5 = nil
+      if useMD5 then
+        genMD5()
+      end
+    end
+
+    def updateModTime(modTime)
+      @modTime = modTime
+      @isNewFile = false
+    end
+
+    def updateSize(size)
+      @size = size
+    end
+
+    def isNew?
+      return @isNewFile
+    end
+
+    def setMD5(newMD5)
+      @md5 = newMD5
+    end
+
+    # generate my files md5 value
+    def genMD5()
+      @md5 = FSWatcher.genFileMD5(@fileName)
+    end
+  end
+
+  # utility function for generating md5s from a files contents
+  def FSWatcher.genFileMD5(fileName)
+    if FileTest.file?(fileName) then      
+      f = File.open(fileName)
+      contents = f.read()
+      f.close()
+      return MD5.new(contents) if contents
+    end
+    return nil
+  end
+
+  # if the directory you want to watch doesnt exist or isnt readable this is thrown
+  class InvalidDirectoryError < StandardError; end
+
+  # if the file you want to watch doesnt exist or isnt readable this is thrown
+  class InvalidFileError < StandardError; end
+end
+  

data/lib/doozer.rb

@@ -0,0 +1,30 @@
+DOOZER_PATH = File.expand_path(File.dirname(__FILE__))
+$:.unshift(DOOZER_PATH) unless $:.include?(DOOZER_PATH)
+
+# load active_support hooks
+require File.join(DOOZER_PATH, 'doozer/extend')
+
+module Doozer
+
+  autoload :App,            "doozer/app"
+  autoload :Configs,        "doozer/configs"
+  autoload :Controller,     "doozer/controller"
+  autoload :Initializer,    "doozer/initializer"
+  autoload :Lib,            "doozer/lib"
+  autoload :Partial,        "doozer/partial"
+  autoload :Redirect,       "doozer/redirect"
+  
+  module Routing
+    autoload :Route,        "doozer/route"
+    autoload :Routes,       "doozer/route"
+  end
+  
+  module Util
+    autoload :Logger,         "doozer/logger"
+  end
+  autoload :ViewHelpers,    "doozer/view_helpers"
+  autoload :Version,        "doozer/version"
+  
+  # Generator methods
+  autoload :Generator,      "generator/generator"
+end