paparazzi 0.2.0 → 0.2.1

data/README.md

@@ -39,14 +39,14 @@ Create a ruby script that you'll run hourly from a cron.
 Available Settings
 ------------------
 
-  * `:source`      : **required** The source folder to be backed up. Trailing '/' recommended. See rsync manpage
+  * `:source`      **required** The source folder to be backed up. Trailing '/' recommended. See rsync manpage
                      for explanation of trailing '/' 
-  * `:destination` : **required** The destination folder for backups to be written to, preferably on a different
+  * `:destination` **required** The destination folder for backups to be written to, preferably on a different
                      physical drive.
-  * `:reserves`    : A hash of snapshot intervals and number of snapshots of each to keep before purging.
-                     default: {:hourly => 24, :daily => 7, :weekly => 5, :monthly => 12, :yearly => 9999} 
-  * `:rsync_flags` : additional flags to pass to rsync. Paparazzi uses -aq, --delete, & --link_dest, plus
-                     whatever you add. The author suggests considering -L and --exclude.
+  * `:intervals`    A hash of snapshot intervals and number of snapshots of each to keep before purging.
+                     default: `{:hourly => 24, :daily => 7, :weekly => 5, :monthly => 12, :yearly => 9999}` 
+  * `:rsync_flags` Additional flags to pass to rsync. Paparazzi uses `-aq`, `--delete`, & `--link_dest`, plus
+                     whatever you add. The author suggests considering `-L` and `--exclude`.
 
 
 Supported Operating Systems

data/lib/paparazzi/camera.rb

@@ -8,7 +8,7 @@ module Paparazzi
     REQUIRED_SETTINGS = [:source,:destination]
       
     class << self
-      attr_accessor :source, :destination, :rsync_flags, :reserves
+      attr_accessor :source, :destination, :rsync_flags, :intervals
       
       def trigger(settings = {})
         validate_and_cache_settings(settings)
@@ -25,7 +25,7 @@ module Paparazzi
       #######
       
       def validate_and_cache_settings(settings)
-        [:source,:destination,:rsync_flags,:reserves].each do |setting_name|
+        [:source,:destination,:rsync_flags,:intervals,:reserves].each do |setting_name|
           if REQUIRED_SETTINGS.include?(setting_name) and settings[setting_name].nil?
             raise MissingSettingError, "#{setting_name} is required"
           else
@@ -42,21 +42,21 @@ module Paparazzi
       
       def setup
         @previous_snapshot_name = {}
-        frequencies.each do |frequency|
-          Dir.mkdir(destination(frequency)) unless File.exists?(destination(frequency)) && File.directory?(destination(frequency))
+        interval_names.each do |interval_name|
+          Dir.mkdir(destination(interval_name)) unless File.exists?(destination(interval_name)) && File.directory?(destination(interval_name))
         
-          full_path = Dir[destination(frequency)+'/*'].sort{|a,b| File.ctime(b) <=> File.ctime(a) }.first
-          @previous_snapshot_name[frequency] = full_path ? File.basename(full_path) : ''
+          full_path = Dir[destination(interval_name)+'/*'].sort{|a,b| File.ctime(b) <=> File.ctime(a) }.first
+          @previous_snapshot_name[interval_name] = full_path ? File.basename(full_path) : ''
         end
         
-        if @previous_snapshot_name[frequencies.first] != last_successful_snapshot and !last_successful_snapshot.nil? and File.exists?(destination(frequencies.first) + '/' + last_successful_snapshot)
-          File.rename(previous_snapshot(frequencies.first), current_snapshot(frequencies.first))
-          @previous_snapshot_name[frequencies.first] = last_successful_snapshot
+        if @previous_snapshot_name[interval_names.first] != last_successful_snapshot and !last_successful_snapshot.nil? and File.exists?(destination(interval_names.first) + '/' + last_successful_snapshot)
+          File.rename(previous_snapshot(interval_names.first), current_snapshot(interval_names.first))
+          @previous_snapshot_name[interval_names.first] = last_successful_snapshot
         end
       end
       
-      def destination(frequency = nil)
-        frequency.nil? ? @destination : "#{@destination}/#{frequency}"
+      def destination(interval_name = nil)
+        interval_name.nil? ? @destination : "#{@destination}/#{interval_name}"
       end
       
       def last_successful_snapshot
@@ -70,35 +70,34 @@ module Paparazzi
       end
     
       def purge_old_snapshots
-        frequencies.each do |frequency|
-          #raise RuntimeError, frequency if reserves[frequency].nil?
-          while Dir[destination(frequency)+'/*'].size > (reserves[frequency]-1)
-            full_path = Dir[destination(frequency)+'/*'].sort{|a,b| File.ctime(a) <=> File.ctime(b) }.first
+        interval_names.each do |interval_name|
+          while Dir[destination(interval_name)+'/*'].size > (intervals[interval_name]-1)
+            full_path = Dir[destination(interval_name)+'/*'].sort{|a,b| File.ctime(a) <=> File.ctime(b) }.first
             FileUtils.rm_rf(full_path)
           end
         end
       end
 
       def make_snapshots
-        frequencies.each do |frequency|
-          Dir.mkdir(current_snapshot(frequency)) unless File.exists?(current_snapshot(frequency))
-          if frequency == frequencies.first and previous_snapshot_name(frequency) == ''
-            system 'rsync', *(['-aq', '--delete'] + rsync_flags + [source, current_snapshot(frequency)])
-            self.last_successful_snapshot = current_snapshot_name(frequency)
-          elsif previous_snapshot_name(frequency) != current_snapshot_name(frequency)
-            system 'rsync', *(['-aq', '--delete', "--link-dest=#{link_destination(frequency)}"] + rsync_flags + [source, current_snapshot(frequency)])
-            self.last_successful_snapshot = current_snapshot_name(frequencies.first)
+        interval_names.each do |interval_name|
+          Dir.mkdir(current_snapshot(interval_name)) unless File.exists?(current_snapshot(interval_name))
+          if interval_name == interval_names.first and previous_snapshot_name(interval_name) == ''
+            system 'rsync', *(['-aq', '--delete'] + rsync_flags + [source, current_snapshot(interval_name)])
+            self.last_successful_snapshot = current_snapshot_name(interval_name)
+          elsif previous_snapshot_name(interval_name) != current_snapshot_name(interval_name)
+            system 'rsync', *(['-aq', '--delete', "--link-dest=#{link_destination(interval_name)}"] + rsync_flags + [source, current_snapshot(interval_name)])
+            self.last_successful_snapshot = current_snapshot_name(interval_names.first)
           end
         end
       end
       
-      def current_snapshot(frequency)
-        destination(frequency) + '/' + current_snapshot_name(frequency)
+      def current_snapshot(interval_name)
+        destination(interval_name) + '/' + current_snapshot_name(interval_name)
       end
       
-      def current_snapshot_name(frequency)
+      def current_snapshot_name(interval_name)
         @start_time ||= Time.now #lock in time so that all results stay consistent over long runs
-        case frequency
+        case interval_name
           when :hourly  then @start_time.strftime('%Y-%m-%d.%H')
           when :daily   then @start_time.strftime('%Y-%m-%d')
           when :weekly  then sprintf("%04d-%02d-week-%02d", @start_time.year, @start_time.month, (@start_time.day/7))
@@ -107,28 +106,35 @@ module Paparazzi
         end
       end
       
-      def previous_snapshot(frequency)
-        destination(frequency) + '/' + previous_snapshot_name(frequency)
+      def previous_snapshot(interval_name)
+        destination(interval_name) + '/' + previous_snapshot_name(interval_name)
       end
       
-      def previous_snapshot_name(frequency)
-        @previous_snapshot_name[frequency]
+      def previous_snapshot_name(interval_name)
+        @previous_snapshot_name[interval_name]
       end
       
-      def link_destination(frequency)
-        frequency == frequencies.first ? "../#{previous_snapshot_name(frequencies.first)}" : "../../#{frequencies.first}/#{current_snapshot_name(frequencies.first)}"
+      def link_destination(interval_name)
+        interval_name == interval_names.first ? "../#{previous_snapshot_name(interval_names.first)}" : "../../#{interval_names.first}/#{current_snapshot_name(interval_names.first)}"
       end
       
-      def reserves
-        @reserves ||= {:hourly => 24, :daily => 7, :weekly => 5, :monthly => 12, :yearly => 9999}
+      def intervals
+        @intervals ||= {:hourly => 24, :daily => 7, :weekly => 5, :monthly => 12, :yearly => 9999}
       end
       
-      def frequencies
-        reserves.keys.select{ |key| reserves[key] > 0 }.sort{ |a,b| 
+      def interval_names
+        intervals.keys.select{ |key| intervals[key] > 0 }.sort{ |a,b| 
           [:hourly,:daily,:weekly,:monthly,:yearly].find_index(a) <=> [:hourly,:daily,:weekly,:monthly,:yearly].find_index(b)
         }  
       end
       
+      # provide backwards compatability with silly setting name
+      def reserves=(x)
+        if x.is_a?(Hash)
+          $stderr.puts ':reserves is deprecated. Please use :intervals instead.'
+          self.intervals=x 
+        end
+      end
     end
   end
   

data/lib/paparazzi/version.rb

@@ -1,3 +1,3 @@
 module Paparazzi
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/test/unit/camera_test.rb

@@ -107,11 +107,24 @@ class CameraTest < Test::Unit::TestCase
   
   def test_should_not_make_un_requested_frequency_snapshots
     my_settings = default_test_settings
-    my_settings[:reserves][:hourly] = 0
+    my_settings[:intervals][:hourly] = 0
     Paparazzi::Camera.trigger(my_settings)
     assert(!File.exists?("#{destination}/hourly"))
   end
   
+  def test_should_be_backwards_compatible_with_deprecated_config_option
+    original_stderr, $stderr = $stderr, StringIO.new
+    my_settings = default_test_settings
+    my_settings[:reserves] = my_settings[:intervals]
+    my_settings[:reserves][:hourly] = 1
+    my_settings.delete(:intervals)
+    Paparazzi::Camera.trigger(my_settings)
+    assert_equal(my_settings[:reserves],Paparazzi::Camera.instance_variable_get('@intervals'))
+    assert_equal(':reserves is deprecated. Please use :intervals instead.',$stderr.string.chomp)
+  ensure
+    $stderr = original_stderr
+  end
+  
   #######
   private
   #######
@@ -124,7 +137,7 @@ class CameraTest < Test::Unit::TestCase
     {
       :source => "#{File.expand_path('../../source',  __FILE__)}/",
       :destination => destination,
-      :reserves => {:hourly => 24, :daily => 7, :weekly => 5, :monthly => 12, :yearly => 9999},
+      :intervals => {:hourly => 24, :daily => 7, :weekly => 5, :monthly => 12, :yearly => 9999},
       :rsync_flags => '-L --exclude test.exclude'
       
     }

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 0
-  version: 0.2.0
+  - 1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Jonathan S. Garvin
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-23 00:00:00 -06:00
+date: 2011-05-28 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency