logrotate 1.0.0

data/History.txt

@@ -0,0 +1,2 @@
+=== 1.0.0 / 2008-06-19
+Initial release of LogRotate.  This package is unit tested fully.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Designing Patterns
+
+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/Manifest.txt

@@ -0,0 +1,7 @@
+Manifest.txt
+LICENSE
+History.txt
+README.txt
+Rakefile
+lib/logrotate.rb
+test/test_logrotate.rb

data/README.txt

@@ -0,0 +1,162 @@
+= logrotate
+* Project Page: http://rubyforge.org/projects/logrotate/
+* Documentation: http://logrotate.rubyforge.org/
+
+== DESCRIPTION:
+
+This package is a library of methods that perform log rotation.  The
+log rotate methods allow the caller to specify options (via
+parameters) such as how many rotated files to keep, what type of
+extension to place on the rotated file (date or a simple count), and
+whether to zip the rotated files.  Live log files (currently being
+written to by a live process) can be rotated as well.  The post_rotate
+option is useful in that context, as it can be used to send a HUP
+signal to notify the live process to reopen its log file.
+
+This package was inspired by the need to have a library version of the
+unix logrotate tool.  The unix logrotate tool requires the user to
+specify options in a config file, and is usually invoked through cron.
+
+== PROBLEMS:
+
+None (known).
+
+== SYNOPSIS:
+Here are some sample invocations of the library.
+
+Rotate a log file with simple extensions: .1, .2, etc, keep 10 rotated
+files around (.1 .. .10), and gzip the rotated files (.1.gz, .2.gz, .. .10.gz): 
+======+examples/rotate_count.rb+:
+ #!/usr/bin/env ruby
+ 
+ require 'rubygems'
+ require 'logrotate'
+ 
+ options = {
+   :count => 10, 
+   :gzip => true
+ }
+ 
+ LogRotate.rotate_file("/tmp/erwin.dat", options)
+
+
+Rotate a set of log files with date extensions, and move the rotated
+files to a specified directory:
+======+examples/rotate_date.rb+:
+ #!/usr/bin/env ruby
+ 
+ require 'rubygems'
+ require 'logrotate'
+ 
+ output_directory = "/tmp/archives"
+ if (!File.directory?(output_directory)) then Dir.mkdir(output_directory) end
+ 
+ files = (1..64).map {|i| "/tmp/erwin_#{i}.dat" }
+ files.each do |file|
+   File.open(file, "w") do |fs|
+     fs.write(file)
+   end
+ end
+ 
+ options = { 
+   :date_time_ext => true, 
+   :directory => output_directory 
+ }
+ 
+ LogRotate.rotate_files(files, options)
+
+
+Rotate a log file with date/time extensions.
+======+examples/rotate_date_time.rb+:
+ #!/usr/bin/env/ruby
+ 
+ require 'rubygems'
+ require 'logrotate'
+ 
+ options = { 
+   :date_time_ext => true, 
+   :date_time_format => '%F_%T'
+ }
+ 
+ LogRotate.rotate_file("/tmp/erwin.dat", options)
+
+
+Rotate a log file that is currently being written to by a live
+process.  After the file is rotated, notify the live process to reopen
+its log file.  
+======+examples/rotate_live.rb+:
+ #!/usr/bin/env ruby
+ 
+ require 'rubygems'
+ require 'logrotate'
+ 
+ block = Proc.new() do
+   File.open("/tmp/hupper.pid") do |pid_stream|
+     pid = pid_stream.read().to_i()
+     Process.kill("HUP", pid)
+   end
+ end
+ 
+ options = { 
+   :gzip => true, 
+   :count => 3,
+   :post_rotate => block 
+ }
+ 
+ LogRotate.rotate_file("/tmp/hupper.dat", options)
+
+
+== REQUIREMENTS:
+
+Hoe is required but only for running the tests.
+
+== INSTALL:
+
+ sudo gem install logrotate
+
+== AUTHORS:
+=== Designing Patterns
+* Homepage: http://www.designingpatterns.com
+* Blogs: http://blogs.designingpatterns.com
+
+== SUPPORT
+Please post questions, concerns, or requests for enhancement to the forums on
+the project page.  Alternatively, direct contact information for
+Designing Patterns can be found on the project page for this gem.
+
+== ENHANCEMENTS
+Please feel free to contact us with any ideas; we will try our best to
+enhance the software and respond to user requests.  Of course, we are more
+likely to work on a particular enhancement if we know that there are users
+who want it.  Designing Patterns provides contracting and consulting services,
+so if there is an enhancement that *must* get done (and in a specified time
+frame), please inquire about retaining our services!
+
+== LICENSE:
+The license text can be found in the +LICENSE+ file at the root of the
+distribution.
+
+This  package is licensed with an MIT license:
+
+Copyright (c) 2008 Designing Patterns
+
+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.
+
+== SHARE AND ENJOY!

data/Rakefile

@@ -0,0 +1,10 @@
+# -*- ruby -*-
+require 'rubygems'
+require 'hoe'
+
+Hoe.new('logrotate', "1.0.0") do |p|
+  p.remote_rdoc_dir = ''
+  p.developer('DesigningPatterns', 'technical.inquiries@designingpatterns.com')
+end
+
+# vim: syntax=Ruby

data/lib/logrotate.rb

@@ -0,0 +1,246 @@
+#!/usr/bin/env ruby 
+
+require 'English'
+require 'zlib'
+require 'date'
+
+#
+# This module provides a few methods for log rotation.
+#
+
+module LogRotate
+
+  DEFAULT_COUNT = 5
+  DEFAULT_GZIP = false
+  DEFAULT_DATE_TIME_EXTENSION = false
+  
+  DEFAULT_DATE_TIME_FORMAT = '%F'
+
+  # 
+  # ====Description: This method rotates the given files.  
+  # 
+  # ====Parameters:
+  # [file(s)]
+  #      The files to be rotated.
+  # [options = {}]
+  #      A list of optional arguments.
+  #
+  # See rotate_file for details.
+  #
+  def self.rotate_files(files, options)
+    files.each do |file|
+      rotate_single_file(file, options)
+    end
+  end
+  
+  # 
+  # ====Description: This method rotates the given file(s).  
+  # There are 2 types of extensions that can be used: the default
+  # extension which is an integer value (".1", ".2", ..), and a
+  # date/time extension (".2008-08-01", ..).  If a date/time extension
+  # is chosen, the caller can specify a date/time format for this
+  # extension.
+  # 
+  # ====Parameters:
+  # [file]
+  #      The file to be rotated.
+  # [options = {}]
+  #      A list of optional arguments.
+  #
+  # The optional arguments are listed below:
+  # +count+:: The number of rotated files to be kept.
+  # +directory+:: The directory to store the newly rotated file.  If this
+  #               option is unspecified, the original file's directory 
+  #               will be used.
+  # +date_time_ext+:: Whether the extension on the rotated files should be
+  #                   a date.  Possible values are: +true+, +false+.
+  # +date_time_format+:: For use with +date_time_ext+.  This specifies the
+  #                      format of the date / time extension.
+  # +date_time+:: For use with +date_time_ext+.  The +DateTime+ that will be
+  #               used to construct the extension of the newly rotated file.  
+  #               If this option is not specified, the current date and time 
+  #               will be used.
+  # +pre_rotate+:: A +Proc+ to be executed before the rotation is started.
+  # +post_rotate+:: A +Proc+ to be executed after the rotation is finished,
+  #                 and before the newly rotated file is zipped.
+  # +gzip+:: Whether the newly rotated file should be gzipped.  Possible 
+  #          values are: +true+, +false+.
+  #
+  def self.rotate_file(file, options)
+      rotate_single_file(file, options)
+  end
+    
+  def self.rotate_single_file(file, options = {})
+    gzip = options[:gzip] ? options[:gzip] : DEFAULT_GZIP
+    
+    # error checking
+    if (!File.exist?(file)) then raise "File does not exist: #{file}." end
+    if (!File.readable?(file)) then raise "File is not readable: #{file}." end
+    
+    if (options[:pre_rotate]) then options[:pre_rotate].call() end
+    
+    new_backup = ""
+    if (options[:date_time_ext])
+      new_backup = rotate_file_date_extension(file, options)
+    else
+      new_backup = rotate_file_integer_extension(file, options)
+    end
+    
+    if (options[:post_rotate]) then options[:post_rotate].call() end
+    
+    if (gzip) then gzip_file(new_backup) end
+  end
+  private_class_method(:rotate_single_file)
+
+  def self.rotate_file_date_extension(file, options)
+    count = options[:count] ? options[:count] : DEFAULT_COUNT
+    
+    now = options[:date_time] ? options[:date_time] : DateTime.now()
+    
+    date_time_format = options[:date_time_format] ? options[:date_time_format] : DEFAULT_DATE_TIME_FORMAT
+    
+    # Get a list of the rotated files.
+    (source_directory, base_name) = File.split(file)
+    directory = options[:directory] ? options[:directory] : source_directory
+    
+    rotated_files = Dir.entries(directory).map do |entry| 
+      rslt = nil
+      
+      # Validate the rotated file.  Since the caller is allowed to
+      # specify the date/time format, here we do not have a regular
+      # expression to match the date/time portion of the rotated
+      # file's extension.  As a result, some foreign files can sneak
+      # into our list of rotated files (eg. base_file.GARBAGE.gz).  Thus,
+      # the rotated file is validated below, and if invalid, it is 
+      # skipped / left alone / not considered in the rotation.
+      
+      if (entry.match("^#{base_name}\..+(\.gz)?$"))
+
+        # Validation #1: convert the date/time portion of the
+        # extension to a DateTime object and skip the file if an
+        # exception is thrown.
+        begin
+          match_data = entry.match("\.([^.]+)(\.gz)?$")
+          date_time = DateTime.strptime(match_data[1], date_time_format)
+          gz = match_data[2] ? match_data[2] : ""
+          
+          # Validation #2: convert the date/time portion of the
+          # extension to a DateTime object and back to a string again.
+          # Then reconstruct the rotated file name with this string,
+          # and ensure the reconstructed rotated file matches the
+          # original.  This will take into account cases where
+          # strptime succeeded but had additional garbage characters
+          # present.  
+          # eg: date_time_format = '%F', file = 'mysql_backup.2008-08-04.BACK.gz'
+          reconstructed_file = "#{base_name}.#{date_time.strftime(date_time_format)}#{gz}"
+          if (entry == reconstructed_file)
+            rslt = { :date_time => date_time, :file => entry }        
+          end
+        rescue => e
+        end
+        
+        rslt
+      end
+    end
+    
+    rotated_files = rotated_files.select { |rotated_file| rotated_file }
+    
+    # Sort files by date (newer to older).
+    rotated_files.sort! { |left, right| right[:date_time] <=> left[:date_time] }
+    
+    # Remove the oldest files so that there are count rotated files remaining.
+    
+    # Determine how many old files to be removed.  
+    new_backup_base_name = base_name + "." + now.strftime(date_time_format)
+
+    # Add 1 to account for the additional rotated file that will be
+    # created after the original file passed in is rotated.
+    num_old_files = rotated_files.length() - count + 1
+
+    # There is a chance that the newly rotated file will have the same
+    # name as one of the already existing rotated files (eg. if the
+    # extension is simply the date, and the job is ran a second time
+    # in the same day).  In this case, there will be 1 less rotated
+    # file (and thus 1 less to delete).
+    if (rotated_files.find {|rotated_file| rotated_file[:file] == new_backup_base_name})
+      num_old_files -= 1
+    end
+    
+    if (num_old_files > 0)
+      old_files = rotated_files.slice!(-num_old_files, num_old_files)
+      File.unlink(*old_files.map {|old_file| File.join(directory, old_file[:file]) })
+    end
+    
+    # Rename the original file.
+    new_backup = File.join(directory, new_backup_base_name)
+    File.rename(file, new_backup)
+    
+    return new_backup
+  end
+  private_class_method(:rotate_file_date_extension)
+  
+  def self.rotate_file_integer_extension(file, options)
+    count = options[:count] ? options[:count] : DEFAULT_COUNT
+    
+    # Get a list of the backed up files.
+    (source_directory, base_name) = File.split(file)
+    directory = options[:directory] ? options[:directory] : source_directory
+    
+    rotated_files = Dir.entries(directory).select do |entry| 
+      entry.match("#{base_name}\.[0-9]+(\.gz)?$") 
+    end
+
+    rotated_files.map! do |rotated_file|
+      index = rotated_file.match("\.([0-9]+)(\.gz)?$")[1].to_i()
+      { :index => index, :file => rotated_file }
+    end
+    
+    # Delete old files.
+    old_files = rotated_files.select { |rotated_file| rotated_file[:index] >= count }
+    File.unlink(*old_files.map {|old_file| File.join(directory, old_file[:file]) })
+    
+    rotated_files = rotated_files - old_files
+    
+    # Sort files such that the back up count is descending (eg. [hello.txt.5, hello.txt.4, ..]).
+    rotated_files.sort! { |left, right| right[:index] <=> left[:index] }
+
+    # Rotate - Increment the back up index on each file.
+    rotated_files.each do |rotated_file|
+
+      new_index = rotated_file[:index] + 1
+      new_file = rotated_file[:file].sub(/(^.*\.)(#{rotated_file[:index]})(.gz)?$/, 
+                                           "\\1#{new_index}\\3")
+      File.rename(File.join(directory, rotated_file[:file]), 
+                  File.join(directory, new_file))
+    end
+    
+    # Rename the original file.
+    new_backup = File.join(directory, base_name + ".1")
+    File.rename(file, new_backup)
+    
+    return new_backup
+  end
+  private_class_method(:rotate_file_integer_extension)
+
+  def self.gzip_file(file)
+    # Zip the original file if necessary.
+    gzip_file = file + ".gz"
+
+    begin
+      File.open(file) do |file_stream|
+        Zlib::GzipWriter.open(gzip_file) do |gz|
+          while (buffer = file_stream.read(1024))
+            gz.write(buffer)
+          end
+        end
+      end
+    rescue => error
+      raise "Unable to zip file: #{file}. Error: #{error}\n"
+    end
+    
+    File.unlink(file)
+  end
+  private_class_method(:gzip_file)
+
+end
+

data/test/test_logrotate.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+require 'logrotate'
+
+require 'test/unit'
+
+class LogRotateTest < Test::Unit::TestCase
+  TEMP_DIR = "./temp"
+
+  def remove_directory(directory)
+    if (!File.directory?(directory)) then return end
+    
+    entries = Dir.entries(directory).select {|entry| (entry != ".") && (entry != "..") }
+    entries.map! { |entry| File.join(directory, entry) }
+    
+    entries.each do |entry|
+      if File.directory?(entry) 
+        remove_directory(entry) 
+      else
+        File.delete(entry)
+      end
+    end
+
+    Dir.delete(directory)
+  end
+
+  def remove_temp_directory
+    remove_directory(TEMP_DIR)
+  end
+
+  def setup
+    remove_temp_directory()
+  end
+
+  def teardown
+    remove_temp_directory()
+  end
+
+  def test_rotate_integer_extension()
+    rotate_integer_extension(3, 10, gzip = false)
+    rotate_integer_extension(3, 10, gzip = true)
+
+    output_dir = "#{TEMP_DIR}/archives"
+    rotate_integer_extension(3, 10, gzip = false, output_dir)
+    rotate_integer_extension(3, 10, gzip = true, output_dir)
+  end
+
+  def test_rotate_date_extension()
+    date_time_format = "%F_%T"
+    
+    output_dir = nil
+    rotate_date_extension(3, 10, gzip = false)
+    rotate_date_extension(3, 10, gzip = true)
+    rotate_date_extension(3, 10, gzip = true, output_dir, date_time_format)
+    
+    output_dir = "#{TEMP_DIR}/archives"
+    rotate_date_extension(3, 10, gzip = false, output_dir)
+    rotate_date_extension(3, 10, gzip = true, output_dir)
+    rotate_date_extension(3, 10, gzip = true, output_dir, date_time_format)
+  end
+  
+  def rotate_integer_extension(count, rotations, gzip, output_dir = nil)
+    source_dir = "#{TEMP_DIR}"
+    base_name = "file.dat"
+    file = File.join(source_dir, base_name)
+    Dir.mkdir(source_dir)
+    
+    is_output_dir = false
+    if (output_dir) then 
+      Dir.mkdir(output_dir)
+      is_output_dir = true
+    else
+      output_dir = source_dir
+    end
+    
+    manipulate_garbage_files(output_dir, base_name, :insert)
+
+    #rotate the file
+    rotations.downto(1) do |i|
+      File.open(file, "w") do |file_stream|
+        file_stream.write("#{i}")
+      end
+
+      options = {:count => count}
+      if (gzip) then options[:gzip] = true end
+      if (is_output_dir) then options[:directory] = output_dir end
+
+      LogRotate.rotate_files(file, options) 
+    end
+    
+    manipulate_garbage_files(output_dir, base_name, :delete)
+
+    #verify there are count rotated files.
+    entries = Dir.glob("#{output_dir}/*").map {|entry| File.split(entry)[1]}
+    assert_equal(entries.length, count)
+    
+    #verify the contents
+    expected = (1..count).map { |i| "#{base_name}.#{i}" + (gzip ? ".gz" : "") }
+    assert_equal(entries.sort, expected)
+
+    (1..count).each do |i|
+      rotated_file = "#{output_dir}/#{base_name}.#{i}" + (gzip ? ".gz" : "")
+      if (gzip)
+        Zlib::GzipReader.open("#{rotated_file}") do |gz| 
+          assert_equal(gz.read().to_i(), i)
+        end
+      else
+        assert_equal(IO.read(rotated_file).to_i(), i)
+      end
+    end
+
+    remove_temp_directory()
+  end
+
+  def manipulate_garbage_files(dir, base_name, operation)
+    bogus_extensions = [ ".back", ".back123", ".2008-10-04_00:00:00foo", ".123x", "." ]
+    
+    bogus_extensions.each do |bogus_extension|
+      bogus_file_1 = File.join(dir, base_name + bogus_extension)
+      bogus_file_2 = bogus_file_1 + ".gz"
+
+      if (operation == :insert)
+        File.open(bogus_file_1, "w") { |file_stream| file_stream.print "garbage" }
+        File.open(bogus_file_2, "w") { |file_stream| file_stream.print "garbage" }
+      elsif (operation == :delete)
+        File.delete(bogus_file_1, bogus_file_2)
+      end
+    end
+  end
+
+  def rotate_date_extension(count, rotations, gzip, 
+                            output_dir = nil, 
+                            date_time_format = LogRotate::DEFAULT_DATE_TIME_FORMAT)
+    
+    source_dir = "#{TEMP_DIR}"
+    base_name = "file.dat"
+    file = File.join(source_dir, base_name)
+    Dir.mkdir(source_dir)
+    
+    is_output_dir = false
+    if (output_dir) then 
+      Dir.mkdir(output_dir)
+      is_output_dir = true
+    else
+      output_dir = source_dir
+    end
+
+    manipulate_garbage_files(output_dir, base_name, :insert)
+    
+    #rotate the file
+    now = DateTime.now
+    date_times = (0..(rotations - 1)).map { |i| now + i }
+    
+    date_times.each do |date_time|
+      File.open(file, "w") do |file_stream|
+        file_stream.write(date_time.strftime(date_time_format))
+      end
+      
+      options = { :date_time_ext => true, :date_time => date_time, :count => count }
+      if gzip then options[:gzip] = true end
+      if (is_output_dir) then options[:directory] = output_dir end
+      if date_time_format then options[:date_time_format] = date_time_format end
+      
+      LogRotate.rotate_files(file, options)
+    end
+    
+    #verify there are count rotated files.
+    manipulate_garbage_files(output_dir, base_name, :delete)
+    
+    entries = Dir.glob("#{output_dir}/*").map {|entry| File.split(entry)[1]}
+    assert_equal(count, entries.length)
+    
+    #verify the contents
+    date_times.slice!(0, date_times.length - count)
+    expected = date_times.map do |date_time| 
+      "#{base_name}.#{date_time.strftime(date_time_format)}" + (gzip ? ".gz" : "") 
+    end
+    
+    assert_equal(expected, entries.sort)
+
+    date_times.each do |date_time|
+      rotated_file = "#{output_dir}/#{base_name}.#{date_time.strftime(date_time_format)}" + (gzip ? ".gz" : "")
+      
+      if (gzip)
+        Zlib::GzipReader.open(rotated_file) do |gz| 
+          assert_equal(gz.read(), "#{date_time.strftime(date_time_format)}")
+        end
+      else
+        assert_equal(IO.read("#{rotated_file}"), "#{date_time.strftime(date_time_format)}")
+      end
+    end
+
+    remove_temp_directory()
+  end
+
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: logrotate
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- DesigningPatterns
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-17 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.7.0
+    version: 
+description: This package is a library of methods that perform log rotation.  The log rotate methods allow the caller to specify options (via parameters) such as how many rotated files to keep, what type of extension to place on the rotated file (date or a simple count), and whether to zip the rotated files.  Live log files (currently being written to by a live process) can be rotated as well.  The post_rotate option is useful in that context, as it can be used to send a HUP signal to notify the live process to reopen its log file.  This package was inspired by the need to have a library version of the unix logrotate tool.  The unix logrotate tool requires the user to specify options in a config file, and is usually invoked through cron.
+email: 
+- technical.inquiries@designingpatterns.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- History.txt
+- README.txt
+files: 
+- Manifest.txt
+- LICENSE
+- History.txt
+- README.txt
+- Rakefile
+- lib/logrotate.rb
+- test/test_logrotate.rb
+has_rdoc: true
+homepage: "Project Page: http://rubyforge.org/projects/logrotate/"
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: logrotate
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: This package is a library of methods that perform log rotation
+test_files: 
+- test/test_logrotate.rb