logtwuncator 0.1.0

data/History.txt

@@ -0,0 +1,4 @@
+== 0.1.0 / 2007-10-10
+
+* Its twuncating season!
+

data/Manifest.txt

@@ -0,0 +1,19 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+example.yml
+bin/log_twuncator_service
+bin/log_twuncator_daemon
+lib/log_twuncator.rb
+lib/log_twuncator/truncator.rb
+lib/log_twuncator/options.rb
+lib/log_twuncator/service.rb
+lib/log_twuncator/daemon.rb
+lib/log_twuncator/win32_file.rb
+test/test_config.yml
+test/test_daemon.rb
+test/test_truncator.rb
+test/test_win32_file.rb
+test/test_service.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,186 @@
+log_twuncator
+    by Adam Meehan (adam.meehan@gmail.com)
+    http://log_twuncator
+
+== DESCRIPTION:
+  
+A log truncator for win32 originally to truncate rails log files but 
+generalised to any log files needing truncation and archiving. There 
+didn't seem be something easy, free and open out there so I thought
+I would hack up a gem.
+
+It comes with a windows service to install and leave running to monitor 
+the directories you specify in the config file. The config file allows the
+specification of many directories to monitor for log file age and size.
+
+File age is monitored by using the file creation date. In *nix programs like 
+logrotate the log file can be moved and recreated using POSIX signalling to 
+restart the process, and hence starting with a new file and creation date. On 
+windows this is not possible without getting really intimate with the running 
+process, so to get around it this program uses win32 API call to change the 
+created date after arching and truncating the file, leaving it in plave. 
+This seems to work fine with Rails and Apache but may cause problems 
+depending on how the running application has opened the log file to append 
+to it. 
+
+Please report any problems/suggestions you have.
+
+Credits: 
+
+Herryanto Siatono (http://www.pluitsolutions.com/) for his 
+win32 Ferret service which I based some of the service structure on.
+
+pdumpfs project (http://0xcc.net/pdumpfs/index.html.en) where I learned
+the win32 API stuff in Ruby to do the file creation date changes.
+
+
+== FEATURES/PROBLEMS:
+  
+  * Multiple log truncation and archiving
+  * Nominate specific file or directory to monitor for truncation
+  * Use name formatting for archived file name
+  * Set defaults for settings to use in multiple monitored locations
+  * Set file or folder specific size and/or age limit
+  
+  Future:  
+  * Optional formats for the timestamp
+  * More archive name options
+  * Compress archived logs
+  * Email archived logs  
+    
+== REQUIREMENTS:
+
+  win32-service gem required to run as service
+
+== INSTALL:
+
+  gem install log_twuncator
+
+== USAGE:
+
+  log_truncator_service <command> -N service_name <options>
+
+For help
+  
+  log_truncator_service -h
+
+To install service:
+
+  log_truncator_service install -N log_twuncator -c c:/twuncator_config.yml -d 1 -l c:/log_twuncator.log
+  
+  where:
+  -N : is the name of the service to install  
+  -c : is the config file with the settings for various log monitoring paths
+  -d : is the number of minutes between checking the log files for truncation. Default is 5.  
+  -l : is the log file for the truncator. Default is 'log_twuncator.log' is same folder as config file.
+
+To remove service
+
+  log_truncator_service remove -N log_twuncator
+
+To start/stop service
+  
+  log_truncator_service start -N log_twuncator
+  
+  log_truncator_service stop -N log_twuncator
+
+And remember kids the service creation does not set the startup-type to 'Automatic', 
+so if you it want it to start with every windows startup then change this setting in 
+the Services management console ('services.msc' on the command prompt).
+
+--- Config File
+
+The config file allows for multiple monitored source directories for log files. The 
+setting options are as follows:
+
+source_dir:   
+  This is the root folder to monitor
+
+filter:       
+  This is used filter the files in the folder and takes the allowed settings used in 
+  the ruby Dir.glob method. You could specify '*.log' for all files with log extension. 
+  Or a full filename like 'production.log' to limit to just one file. See Dir.glob 
+  method for more fancy possibilites including files in subdirectories.
+  
+age:
+  The age in days of the file before it should be archived and truncated. If set to 
+  zero then age is never used as the trigger to truncate.
+
+size:
+  The size of the log file in kilobytes above which the file should be truncated. 
+  If set to 0 then size is never used as the trigger to truncate
+  
+archive_dir:
+  The full path directory to store the archived log file
+
+archive_name: 
+  The format of the archived log file name. You can use three components mixed with 
+  any other characters you wish to insert into the file name when its archived. The 
+  components are
+  
+  [set_name]  - the value of key in the config file for the set of options
+  [basename]  - the original log filename without its extension
+  [ext]       - the file extension of the log file
+  [timestamp] - the timestamp in the format yyyymmddHHMMSS
+  
+  These can be combined to make the archived file name eg.
+  
+  [basename]_[timestamp].[ext] - a log file called production.log archived at 
+  2007-01-01 12:12:35 would become production_20070101121235.log                                  
+  
+The config file allows for a 'defaults' section where you can set the defaults for 
+all subsequent monitored directories. Any setting specified in a monitoring set 
+will override the defaults for the same setting.
+
+Best shown with an example:
+
+Below is config settings in yaml format
+---------------------------------------------------------------------------
+defaults:
+  age: 7
+  size: 5000
+  filter: '*.log'
+  archive_dir: 'c:/logs'
+  archive_name: '[set_name]_[basename]_[date].[ext]'
+
+app_name:
+  source_dir: 'c:/web/app/logs'
+  filter: 'production.log'
+  age: 0
+  archive_dir: 'c:/web/app/logs/archive'
+---------------------------------------------------------------------------
+
+This config defaults section defines all the settings, but keep in mind that a 
+defaults section alone does not constitute a monitored set. If you only have a 
+defaults section then nothing will be monitored. In the example the 'app_name' 
+monitored set will override the default source directory, filter, age and 
+archive_dir. The age is set to 0 so files will not be truncated based on age. 
+It will inherit the default size of 5000 (5000 KB or 5 MB) as the threshold for 
+truncation above which the file will be archived in c:/web/app/logs/archive 
+and truncated.
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2007 Adam Meehan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,19 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/log_twuncator.rb'
+
+Hoe.new('logtwuncator', LogTwuncator::VERSION) do |p|
+  p.rubyforge_name = 'logtwuncator'
+  p.author = 'Adam Meehan'
+  p.email = 'adam.meehan@gmail.com'
+  p.summary = 'A win32 log file truncator and archiver with windows service'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.remote_rdoc_dir = ''
+  p.extra_deps << ['win32-service', '>= 0.5.2']  
+end
+
+# vim: syntax=Ruby

data/bin/log_twuncator_daemon

@@ -0,0 +1,6 @@
+#!/usr/local/bin/ruby
+
+require 'log_twuncator/daemon'
+
+d = LogTwuncator::Daemon.run(ARGV)
+d.mainloop

data/bin/log_twuncator_service

@@ -0,0 +1,5 @@
+#!/usr/local/bin/ruby
+
+require 'log_twuncator/service'
+
+LogTwuncator::Service.new.run(ARGV)

data/example.yml

@@ -0,0 +1,14 @@
+defaults:
+  age: 7
+  size: 5000
+  filter: '*.log'
+  archive_dir: 'w:/logs'
+  archive_name: '[set_name]_[basename]_[timestamp].[ext]'
+
+app_name:
+  source_dir:  
+  filter:
+  age:
+  size:  
+  archive_dir:
+  archive_name:

data/lib/log_twuncator.rb

@@ -0,0 +1,3 @@
+class LogTwuncator
+  VERSION = '0.1.0'
+end

data/lib/log_twuncator/daemon.rb

@@ -0,0 +1,88 @@
+require 'yaml'
+require 'erb'
+require 'logger'
+require 'win32/service'
+require 'log_twuncator/truncator'
+require 'log_twuncator/options'
+
+module LogTwuncator
+  
+  class ConfigFileNotFound < StandardError; end
+  
+  class Daemon < Win32::Daemon
+    attr_reader :config, :delay, :truncators, :logger
+    
+    def self.run(args = ARGV)
+      new LogTwuncator::Options.parse(args)      
+    end
+    
+    def initialize(options)      
+      @config, @delay, @log = options[:config], options[:delay], options[:log]
+      @truncators = []      
+      @log = File.join(File.dirname(@config), 'log_twuncator.log') unless options[:log]
+      @logger = Logger.new(@log)
+    end
+    
+    def service_init
+      log "starting service"
+      load_config
+    end
+    
+    def service_main
+      while running?
+        @truncators.each {|truncator| truncator.truncate }
+        
+        # sleep for 1 second for number of seconds in delay minutes which prevents process blocking
+        (@delay * 60).times {sleep 1}
+      end
+    end
+    
+    def service_stop
+      log "stopping service"
+    end
+    
+    # Loads config yaml file. Sets the truncator class defaults from the config section if one is labelled 'defaults'. 
+    # Create truncators for each config section, which are run in the service_main loop.
+    # Config file can have ERB tags embedded for power and convenience
+    def load_config
+      raise LogTwuncator::ConfigFileNotFound unless File.exists?(@config)
+      config = YAML::load(ERB.new(IO.read(@config)).result)
+      set_defaults(symbolize_keys(config.delete('defaults'))) if config['defaults']
+      config.map do |key, options|       
+        options[:logger] = @logger
+        options[:name] = key
+        begin
+          @truncators << LogTwuncator::Truncator.new(symbolize_keys(options))
+        rescue InvalidTruncatorOptions => e
+          log "Config set '#{key}' was skipped due to the following errors:\n#{e.message}"
+        end
+      end
+    rescue ConfigFileNotFound
+      log "Config file not found"
+    rescue => e
+      log "Unknown error occurred: #{e}"
+    end
+  
+  private
+    # Sets the class defaults for the truncator class
+    def set_defaults(options)      
+      LogTwuncator::Truncator.defaults = options
+    end
+    
+    def log(msg)
+      if @logger
+        @logger.info msg
+      else
+        puts msg
+      end
+    end
+
+    # Taken from rails
+    def symbolize_keys(hash)
+      hash.inject({}) do |options, (key, value)|
+        options[key.to_sym] = value
+        options
+      end
+    end
+  end
+end

data/lib/log_twuncator/options.rb

@@ -0,0 +1,47 @@
+require 'optparse'
+
+module LogTwuncator
+  class Options
+    
+    def self.parse(args = ARGV)
+      options = {}
+      options[:delay] = 5      
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: log_twuncator_daemon.rb [options]"
+        opts.separator ""
+        opts.separator "Specific options:"        
+        
+        opts.on("-d", "--delay N", Integer, "Check files for truncation every N minutes (default: 5)") do |v|
+          options[:delay] = v
+        end
+  
+        opts.on("-c", "--config FILE", String, "Config file with projects session files to check") do |v|
+          options[:config] = v
+        end
+        
+        opts.on("-l", "--log FILE", String, "Log file for truncator") do |v|
+          options[:log] = v
+        end
+              
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
+      opts.parse!(args)
+      validate_options options
+      options
+    end
+    
+    def self.validate_options(options)
+      unless options[:delay]
+        puts "Delay in seconds required [-d N]"
+        exit
+      end
+      unless options[:config]
+        puts "Config file required [-c FILE]"
+        exit
+      end
+    end
+  end
+end

data/lib/log_twuncator/service.rb

@@ -0,0 +1,135 @@
+require 'optparse'
+require 'win32/service'
+
+module LogTwuncator
+  class ServiceCommand
+    attr_reader :command, :options
+    
+    def initialize
+      @options = {}
+      @options[:delay] = 5
+    end
+    
+    def run(args)
+      @command = args.shift unless args[0] == '-h'
+      @command = @command.downcase if @command
+      
+      parse(args)
+      @options
+    end
+    
+    def parse(args)
+      begin
+        opts = OptionParser.new do |opts|          
+          opts.separator ""
+          opts.banner = "Usage: log_twuncator_service <command> [options]"
+          opts.separator ""
+          opts.separator "Specific options:"
+          opts.separator ""
+          opts.separator "Commands : install, remove, start and stop"
+          opts.separator ""
+          opts.on("-N", "--name SERVICE_NAME", String, "Name of windows service") do |v|
+            @options[:name] = v
+          end
+        
+          opts.on("-c", "--config FILE", String, "Config file with log file truncation settings") do |v|
+            @options[:config] = v
+          end
+        
+          opts.on("-d", "--delay N", Integer, "Check files for truncation every N minutes") do |v|
+            @options[:delay] = v
+          end
+    
+          opts.on("-l", "--log FILE", String, "Log file for truncator") do |v|
+            @options[:log] = v
+          end
+          
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts.help
+            exit
+          end
+        end
+        opts.parse!(args)
+        validate_options
+      rescue OptionParser::ParseError => e
+        puts e
+        puts opts
+      end
+    end
+      
+    def validate_options
+      errors = []
+      errors << "Service name is required (switch -N)" unless @options[:name]
+      errors << "Delay is required (switch -d)" if !@options[:delay] && @command == 'install'      
+      errors << "Config file is required (switch -c)" if !@options[:config] && @command == 'install'
+      errors << "Config file does not exist" if @options[:config] && !FileTest.exists?(@options[:config])
+      
+      if errors.size > 0
+        puts "Error found."
+        puts errors.join("\n")
+        exit
+      end
+    end
+            
+  end
+  
+  class Service
+    
+    def install
+      svc = Win32::Service.new
+      if Win32::Service.exists?(@options[:name])
+        puts "Service name '#{@options[:name]}' already exists."
+        return
+      end
+      
+      svc.create_service do |s|
+        s.service_name = @options[:name]
+        s.display_name = @options[:name]
+        s.binary_path_name = binary_path_name
+      end
+      
+      svc.close
+      puts "Log Twuncator service '#{@options[:name]}' installed."
+    rescue Win32::ServiceError => e
+      puts "Service '#{@options[:name]}' failed to install due to error: #{e.message}"
+    end
+    
+    def start
+      Win32::Service.start(@options[:name])
+      puts "'#{@options[:name]}' service started."
+    rescue Win32::ServiceError => e
+      puts "Service '#{@options[:name]}' failed to start due to error: #{e.message}"
+    end
+    
+    def stop
+      Win32::Service.stop(@options[:name])
+      puts "'#{@options[:name]}' service stopped."
+    rescue Win32::ServiceError => e
+      puts "Service '#{@options[:name]}' failed to stop due to error: #{e.message}"      
+    end
+    
+    def remove
+      begin
+        Win32::Service.stop(@options[:name])
+      rescue
+      end
+    
+      Win32::Service.delete(@options[:name])
+      puts "'#{@options[:name]}' service removed."
+    rescue Win32::ServiceError => e
+      puts "Service '#{@options[:name]}' failed to be removed due to error: #{e.message}"
+    end
+        
+    def binary_path_name
+      path = "#{Config::CONFIG['bindir']}/rubyw #{Config::CONFIG['bindir']}/log_twuncator_daemon"
+      path << " -c #{@options[:config]}"      
+      path << " -d #{@options[:delay]}"
+    end
+    
+    def run(args)
+      command = LogTwuncator::ServiceCommand.new
+      @options = command.run(args)      
+      self.send(command.command.to_sym)
+    end
+  end
+end

data/lib/log_twuncator/truncator.rb

@@ -0,0 +1,112 @@
+require 'fileutils'
+require 'log_twuncator/win32_file'
+
+module LogTwuncator
+  
+  class InvalidTruncatorOptions < StandardError; end
+  
+  class Truncator
+    @@defaults = { 
+      :age => 7, 
+      :size => 1_000,
+      :archive_name => "[basename]_[timestamp].[ext]"
+    }
+    
+    TIMESTAMP_FORMAT = "%Y%m%d%H%M%S"
+    
+    attr_reader :name, :age, :size, :source_dir, :filter, :archive_dir, :archive_name, :logger
+    
+    def initialize(options)      
+      @options = @@defaults.merge(options)
+      [:name, :age, :size, :source_dir, :filter, :archive_dir, :archive_name, :logger].each {|sym| instance_variable_set("@#{sym}".to_sym, @options[sym]) }
+      if errors = self.class.validate_options(@options)
+        raise InvalidTruncatorOptions, errors.join("\n")
+      end
+    end
+    
+    # Find files using source directory and filter and then loop of files checking for files
+    # large than _size_ in kilobytes or older than _age_ in days.
+    def truncate
+      path_filter = File.join(@source_dir, @filter)
+      truncated = 0
+      time = Time.now - age_in_seconds
+      Dir[path_filter].each do |file|
+        next unless (@size > 0 && File.stat(file).size > size_in_bytes) || (@age > 0 && File.stat(file).ctime < time)
+        archive_time = Time.now
+        archive file, archive_time
+        File.truncate(file, 0)        
+        set_truncated_time(file, archive_time)
+        truncated += 1
+        log "Truncated #{file}"
+      end
+      truncated
+    rescue => e
+      log "Unknown error occurred: #{e}"
+    end
+  
+  private
+    
+    # Archive _file_name_ to archive directory specified by _archive_dir_
+    def archive(file_name, time = Time.now)
+      archive_file = archive_filename(file_name)
+      FileUtils.makedirs(File.dirname(archive_file))
+      FileUtils.copy(file_name, archive_file)
+      log "Archived file #{file_name} to #{archive_file}"
+    end
+    
+    # Contruct the archived filename from the archive_name setting. The filename components are allowed which are [basename], [ext] and [timestamp]. 
+    # The archived filname is then constructed by substituting the values for the file in specified in archive_name
+    def archive_filename(file_name, time = Time.now)
+      basename = File.basename(file_name, ".*")
+      ext = File.extname(file_name)
+      time_str = time.strftime(TIMESTAMP_FORMAT)
+      new_name = @archive_name.sub("[set_name]", @name.to_s).sub("[basename]", basename).sub(".[ext]", ext).sub("[timestamp]", time_str)
+      File.join(@archive_dir, new_name)
+    end
+    
+    def set_truncated_time(file, time)      
+      LogTwuncator::Win32File.set_file_time(file, time, nil, nil)
+    end
+    
+    def log(msg)
+      if @logger
+        @logger.info(msg)
+      else
+        puts msg
+      end
+    end
+    
+    # File size converted from kilobytes to bytes
+    def size_in_bytes
+      @size * 1024
+    end
+    
+    # Age converted from days into seconds
+    def age_in_seconds
+      @age * 86400
+    end
+    
+    def self.validate_options(options)
+      errors = []
+      errors << "No source directory defined" unless options[:source_dir]
+      errors << "Source directory is not a valid path" unless options[:source_dir] && FileTest.exists?(options[:source_dir])
+      errors << "Archive directory is not a valid path" unless options[:archive_dir] && FileTest.exists?(options[:archive_dir])
+      errors << "No file filter defined" unless options[:filter]
+      errors << "Size is not a valid number" unless options[:size] && options[:size].is_a?(Fixnum)
+      errors << "Age is not a valid number" unless options[:age] && options[:age].is_a?(Fixnum)
+      errors << "Either age or size must be non-zero" if options[:size].is_a?(Fixnum) && (options[:age] == 0 && options[:size] == 0)
+      
+      return errors.empty? ? false : errors
+    end
+    
+    # Allows the class defaults to be set
+    def self.defaults=(value)
+      @@defaults = value
+    end
+
+    def self.defaults
+      @@defaults
+    end
+
+  end
+end

data/lib/log_twuncator/win32_file.rb

@@ -0,0 +1,48 @@
+require 'Win32API'
+
+# This code has been mostly taken from pdumpfs project http://raa.ruby-lang.org/project/pdumpfs/
+# Uses the Win32API to do win32 system calls to change file dates
+module LogTwuncator
+  class Win32File
+    GENERIC_WRITE    = 0x40000000
+    GENERIC_EXECUTE  = 0x20000000
+    GENERIC_ALL      = 0x10000000
+    FILE_SHARE_WRITE = 2
+    OPEN_EXISTING    = 3
+    FILE_FLAG_BACKUP_SEMANTICS = 0x02000000
+    
+    GetLocaltime = Win32API.new("kernel32", "GetLocalTime", "P", 'V')
+    SystemTimeToFileTime = Win32API.new("kernel32", "SystemTimeToFileTime", "PP", 'I')
+    CreateFile  = Win32API.new("kernel32", "CreateFileA", "PLLLLLL", "L")
+    SetFileTime = Win32API.new("kernel32", "SetFileTime", "LPPP", "I")
+    CloseHandle = Win32API.new("kernel32", "CloseHandle", "L", "I") 
+    
+    # Convert Ruby time into win32 FileTime
+    def self.get_file_time(time)
+      pSYSTEMTIME = ' ' * 2 * 8 # 2byte x 8
+      pFILETIME   = ' ' * 2 * 8 # 2byte x 8
+      GetLocaltime.call(pSYSTEMTIME)
+      time_arr = pSYSTEMTIME.unpack("S8")
+      time_arr[0..1] = time.year, time.month
+      time_arr[3..6] = time.day, time.hour, time.min, time.sec
+      SystemTimeToFileTime.call(time_arr.pack("S8"), pFILETIME) 
+      pFILETIME
+    end
+    
+    # Set created, accessed and modified dates for a file
+    def self.set_file_time(file, ctime=nil, atime=nil, mtime=nil)      
+      hFile = 0
+                
+      times = [ctime, atime, mtime].collect do |time|        
+        next( 0 ) if time.nil?        
+        get_file_time(time.dup.utc)
+      end
+      
+      hFile = CreateFile.call(file.dup, GENERIC_WRITE, FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0)
+      res = SetFileTime.call(hFile, times[0], times[1], times[2])
+      CloseHandle.call(hFile)
+      return res
+    end
+    
+  end
+end

data/test/test_config.yml

@@ -0,0 +1,12 @@
+defaults:
+  age: 7
+  size: 5000
+  filter: '*.log'
+  archive_dir: <%= File.dirname(File.expand_path(__FILE__)) + '/test/test_archive' %>
+  archive_name: '[basename]_[timestamp].[ext]'
+
+app_name:
+  source_dir: <%= File.dirname(File.expand_path(__FILE__)) + '/test/test_log' %>
+  filter: '*.log'
+  age: 2
+  size: 1

data/test/test_daemon.rb

@@ -0,0 +1,44 @@
+require 'test/test_helper'
+require 'log_twuncator/daemon'
+
+class TestDaemon < Test::Unit::TestCase
+  
+  def setup
+    setup_paths_and_files
+    @defaults = LogTwuncator::Truncator.defaults
+  end
+  
+  def test_create_daemon_with_args
+    d = create
+    assert_equal @test_config, d.config
+    assert_equal 1, d.delay
+  end
+  
+  def test_load_config
+    d = create
+    d.load_config
+    assert_equal 1, d.truncators.size
+    assert_equal @log_path, d.truncators[0].source_dir
+    assert_equal 'app_name', d.truncators.first.name
+  end
+  
+  def test_truncator_class_defaults_loaded
+    d = create
+    d.load_config
+    assert_equal 5000, LogTwuncator::Truncator.defaults[:size]
+    assert_equal 7, LogTwuncator::Truncator.defaults[:age]
+  end
+
+  def test_log_file
+    d = create
+    d.load_config
+  end
+  
+  def create
+    LogTwuncator::Daemon.run( %w{-d 1 -c } << @test_config << '-l' << @log_file)
+  end
+  
+  def teardown
+    LogTwuncator::Truncator.defaults = @defaults
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+
+class Test::Unit::TestCase
+
+  def setup_paths_and_files
+    @base_path = File.dirname(File.expand_path(__FILE__))    
+      
+    @archive_path = File.join(@base_path, 'test_archive')  
+    @log_path = File.join(@base_path, 'test_log')
+    
+    Dir.mkdir(@archive_path) unless FileTest.exist?(@archive_path)
+    Dir.mkdir(@log_path) unless FileTest.exist?(@log_path)
+    
+    FileUtils.rm Dir[@log_path + "/*.*"]
+    FileUtils.rm Dir[@archive_path + "/*.*"]
+    
+    @test_config = File.join(@base_path, 'test_config.yml')     
+    @test_log = File.join(@log_path, 'test.log')    
+    @log_file = File.join(@base_path, 'log_twuncator.log')
+  end
+
+end

data/test/test_service.rb

@@ -0,0 +1,40 @@
+require 'test/test_helper'
+require 'log_twuncator/service'
+require 'win32/service'
+
+class TestService < Test::Unit::TestCase
+  
+  def setup
+    setup_paths_and_files
+    @cmd = LogTwuncator::ServiceCommand.new    
+  end
+  
+  def test_install_args    
+    options = create_command
+    assert_equal 'install', @cmd.command
+    assert_equal 'test_log_truncator', options[:name]
+    assert_equal 1, options[:delay]
+    assert_equal @test_config, options[:config]
+  end
+  
+  def test_create_service
+    assert_nothing_raised { create_service }
+  end
+  
+  def create_command
+    @cmd.run( %w{install -N test_log_truncator -d 1 -c } << @test_config )
+  end
+  
+  def create_service
+    name = 'test_log_truncator'
+    LogTwuncator::Service.new.run(%w{install -N test_log_truncator -d 1 -c } << @test_config)    
+    assert Win32::Service.exists?(name)
+    yield(name) if block_given?
+    sleep 2
+    Win32::Service.delete(name)    
+  end
+  
+  def teardown
+    Win32::Service.delete('test_log_truncator') if Win32::Service.exists?('test_log_truncator')
+  end  
+end

data/test/test_truncator.rb

@@ -0,0 +1,93 @@
+require 'test/test_helper'
+require 'log_twuncator/truncator'
+
+class TestTruncator < Test::Unit::TestCase
+  
+  DAY_IN_SECONDS = 86400
+  
+  def setup
+    setup_paths_and_files
+  end 
+    
+  def test_defaults
+    lt = LogTwuncator::Truncator.new({:source_dir => @log_path, :archive_dir => @archive_path, :filter => '*.log'})
+    assert_equal 1_000, lt.size
+    assert_equal 7, lt.age    
+    assert_equal '*.log', lt.filter
+  end
+  
+  def test_defaults_overridden_with_create_options
+    lt = create({ :size => 2_000, :age => 30 })    
+    assert_equal 30, lt.age
+    assert_equal 2_000, lt.size
+  end
+  
+  def test_archive_name_format
+    file = create_dummy_log @test_log
+    lt = create(:filter => 'test.log', :archive_dir => @archive_path, :archive_name => '[set_name]_[basename]_[timestamp].[ext]')
+    time = Time.new
+    assert_equal File.join(@archive_path, "app_name_test_#{time.strftime("%Y%m%d%H%M%S")}.log"), lt.send(:archive_filename, @test_log, time)
+  end
+  
+  def test_single_file_truncation    
+    file = create_dummy_log @test_log
+    lt = create(:filter => 'test.log', :archive_dir => @archive_path)
+    lt.truncate    
+    assert FileTest::zero?(file)
+  end  
+  
+  def test_multiple_file_truncation
+    file1 = create_dummy_log(File.dirname(@test_log) + '/test1.log')
+    file2 = create_dummy_log(File.dirname(@test_log) + '/test2.log')
+    lt = create(:filter => 'test[1-2]*.log', :archive_dir => @archive_path)
+    assert_equal 2, lt.truncate    
+    assert FileTest::zero?(file1)
+    assert FileTest::zero?(file2)
+    assert_equal 2, Dir[@archive_path + '/*.log'].size    
+  end
+  
+  def test_file_skipped_when_size_is_zero
+    file = create_dummy_log @test_log
+    lt = create :size => 0, :age => 7
+    assert_equal 0, lt.truncate
+  end 
+  
+  def test_file_skipped_when_age_is_zero
+    file = create_dummy_log @test_log
+    lt = create :size => 2, :age => 0
+    assert_equal 0, lt.truncate
+  end 
+  
+  def test_file_skipped_when_below_size_and_age
+    file = create_dummy_log @test_log
+    lt = create :size => 2, :age => 7
+    assert_equal 0, lt.truncate
+  end 
+   
+  def test_file_archived_when_below_size_but_over_age
+    file = create_dummy_log @test_log
+    LogTwuncator::Win32File.set_file_time(file, Time.now - (2 * DAY_IN_SECONDS))
+    lt = create :size => 2, :age => 1
+    assert_equal 1, lt.truncate
+  end  
+
+  def test_file_archived_when_below_age_but_over_size
+    file = create_dummy_log @test_log, 3    
+    lt = create :size => 2, :age => 1
+    assert_equal 1, lt.truncate
+  end
+
+  def create(options={})    
+    LogTwuncator::Truncator.new({:name => 'app_name', :source_dir => @log_path, :archive_dir => @archive_path, :filter => '*.log', :size => 1}.merge(options))
+  end  
+  
+  # size is in kilobytes
+  def create_dummy_log(name, size=1)    
+    filesize = 0
+    bytes = size * 1024
+    File.open(name, 'w') do |f|
+      f.puts "A" * bytes      
+    end    
+    name
+  end
+end

data/test/test_win32_file.rb

@@ -0,0 +1,45 @@
+require 'test/test_helper'
+require 'log_twuncator/win32_file'
+
+class TestWin32File < Test::Unit::TestCase
+  
+  def setup
+    setup_paths_and_files
+    @test_file = File.join(@log_path, 'test.txt')
+    @yesterday = yesterday = Time.now - 86400
+  end
+  
+  def test_set_file_time_with_no_changes
+    f = File.new(@test_file, File::CREAT)    
+    f.close
+    mtime = File.stat(@test_file).mtime
+    LogTwuncator::Win32File.set_file_time(@test_file, nil, nil, nil)
+    assert_equal mtime, File.stat(@test_file).mtime
+  end
+  
+  def test_set_file_times_on_closed_file
+    file = File.open(@test_file, File::CREAT)
+    file.close    
+    LogTwuncator::Win32File.set_file_time(file.path, @yesterday, nil, nil)
+    assert_equal @yesterday.to_s, File.stat(file.path).ctime.to_s
+    LogTwuncator::Win32File.set_file_time(file.path, nil, @yesterday, nil)
+    assert_equal @yesterday.to_s, File.stat(file.path).atime.to_s
+    LogTwuncator::Win32File.set_file_time(file.path, nil, nil, @yesterday)
+    assert_equal @yesterday.to_s, File.stat(file.path).mtime.to_s
+  end
+     
+  def test_set_file_times_on_open_file
+    File.open(@test_file, File::CREAT) do |file|      
+      LogTwuncator::Win32File.set_file_time(file.path, @yesterday, nil, nil)
+      assert_equal @yesterday.to_s, File.stat(file.path).ctime.to_s
+      
+      # FIXME: these fail and I think its because of the file interaction which changes the dates
+        # LogTwuncator::Win32File.set_file_time(file.path, nil, @yesterday, nil)
+      # assert_equal @yesterday.to_s, File.stat(file.path).atime.to_s
+      # LogTwuncator::Win32File.set_file_time(file.path, nil, nil, @yesterday)
+      # assert_equal @yesterday.to_s, File.stat(file.path).mtime.to_s
+    end
+  end   
+   
+end
+  

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: logtwuncator
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-10-17 00:00:00 +10:00
+summary: A win32 log file truncator and archiver with windows service
+require_paths: 
+- lib
+email: adam.meehan@gmail.com
+homepage: "    by Adam Meehan (adam.meehan@gmail.com)"
+rubyforge_project: logtwuncator
+description: "It comes with a windows service to install and leave running to monitor  the directories you specify in the config file. The config file allows the specification of many directories to monitor for log file age and size.  File age is monitored by using the file creation date. In *nix programs like  logrotate the log file can be moved and recreated using POSIX signalling to  restart the process, and hence starting with a new file and creation date. On  windows this is not possible without getting really intimate with the running  process, so to get around it this program uses win32 API call to change the  created date after arching and truncating the file, leaving it in plave.  This seems to work fine with Rails and Apache but may cause problems  depending on how the running application has opened the log file to append  to it.   Please report any problems/suggestions you have.  Credits:"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Adam Meehan
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- example.yml
+- bin/log_twuncator_service
+- bin/log_twuncator_daemon
+- lib/log_twuncator.rb
+- lib/log_twuncator/truncator.rb
+- lib/log_twuncator/options.rb
+- lib/log_twuncator/service.rb
+- lib/log_twuncator/daemon.rb
+- lib/log_twuncator/win32_file.rb
+- test/test_config.yml
+- test/test_daemon.rb
+- test/test_truncator.rb
+- test/test_win32_file.rb
+- test/test_service.rb
+- test/test_helper.rb
+test_files: 
+- test/test_daemon.rb
+- test/test_helper.rb
+- test/test_service.rb
+- test/test_truncator.rb
+- test/test_win32_file.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+executables: 
+- log_twuncator_service
+- log_twuncator_daemon
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: win32-service
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.5.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: