duplicati 0.0.1 → 0.0.2

data/lib/duplicati/backup.rb

@@ -1,22 +1,59 @@
 class Duplicati
   class Backup
-    def initialize(opts={})
-      @opts = opts
+    def initialize(opts)
+      @duplicati_path = opts[:duplicati_path]
+      @backup_paths = opts[:backup_paths] or raise ":backup_paths option is missing for backup!"
+      @backup_store_path = opts[:backup_store_path] or raise ":backup_store_path option is missing for backup!"
+      @backup_encryption_key = opts[:backup_encryption_key]
+      @inclusion_filters = opts[:inclusion_filters] || []
+      @exclusion_filters = opts[:exclusion_filters] || []
+      @log_path = opts[:log_path]
     end
 
     def command
-      %Q["#{@opts[:duplicati_path]}" backup "#{(@opts[:backup_paths] || []).join(File::PATH_SEPARATOR)}" "#{@opts[:backup_store_path]}"
-             --passphrase="#{@opts[:backup_encryption_key]}"
+      %Q["#{@duplicati_path}" backup "#{backup_paths}" "#{@backup_store_path}"
+             #{encryption_option}
+             #{inclusion_filters}
+             #{exclusion_filters}
              --auto-cleanup                        
              --full-if-older-than=1M
              --usn-policy=on
              --snapshot-policy=on
              --full-if-sourcefolder-changed
-             2>&1 1>> "#{@opts[:log_path]}" &&
+             2>&1 1>> "#{@log_path}" &&
 
-             "#{@opts[:duplicati_path]}" delete-all-but-n 5 "#{@opts[:backup_store_path]}"
+             "#{@duplicati_path}" delete-all-but-n 5 "#{@backup_store_path}"
              --force
-             2>&1 1>> "#{@opts[:log_path]}"]
+             2>&1 1>> "#{@log_path}"]
+    end
+
+    private
+
+    def encryption_option
+      @backup_encryption_key ? 
+        %Q[--passphrase="#{@backup_encryption_key}"] :
+        %Q[--no-encryption]
+    end
+
+    def backup_paths
+      @backup_paths.map do |path|
+        path = path.strip.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+        Dir.glob(path.gsub(/\/$/, ""))
+      end.flatten.join(File::PATH_SEPARATOR)
+    end
+
+    def inclusion_filters
+      filters "include", @inclusion_filters
+    end
+
+    def exclusion_filters
+      filters "exclude", @exclusion_filters
+    end
+
+    def filters(type, filters)
+      filters.reduce([]) do |memo, filter|
+        memo << %Q[--#{type}-regexp="#{filter.source}"]
+      end.join(" ")
     end
   end
 end

data/lib/duplicati/version.rb

@@ -1,3 +1,3 @@
 class Duplicati
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/duplicati.rb

@@ -16,12 +16,20 @@ class Duplicati
     opts[:log_path] ||= "duplicati.log"
     opts[:duplicati_path] = duplicati_path(opts[:duplicati_path])
     opts[:notifications] ||= [Notification::Growl]
+    opts[:inclusion_filters] ||= [opts[:inclusion_filter]].compact
+    opts[:exclusion_filters] ||= [opts[:exclusion_filter]].compact
+
+    if !opts[:inclusion_filters].empty? && opts[:exclusion_filters].empty?
+      opts[:exclusion_filters] = [%r{.*[^\\/]}] 
+    end
+
     @opts = opts
   end
 
   def backup
     execute Backup.new(
-      options :duplicati_path, :backup_paths, :backup_store_path, :backup_encryption_key, :log_path
+      options :duplicati_path, :backup_paths, :backup_store_path,
+        :backup_encryption_key, :inclusion_filters, :exclusion_filters, :log_path
     ).command
   end
 
@@ -34,7 +42,9 @@ class Duplicati
 
   def execute(command)
     old_log_file_size = File.read(@opts[:log_path]).strip.size rescue 0
-    @execution_success = system(format command) && File.read(@opts[:log_path]).strip.size > old_log_file_size
+    formatted_command = format command
+    puts formatted_command if $DEBUG
+    @execution_success = system(formatted_command) && File.read(@opts[:log_path]).strip.size > old_log_file_size
     notify
   end
 

data/spec/duplicati/backup_spec.rb

@@ -1,15 +1,39 @@
 require "spec_helper"
 
 describe Duplicati::Backup do
-  it "#command" do
-    Duplicati::Backup.new(
-      :duplicati_path => "/bin/duplicati-commandline",
-      :backup_paths => ["/foo/bar", "/baz/bar"],
-      :backup_store_path => "file:///foo/backup",
-      :backup_encryption_key => "secret",
-      :log_path => "/zzz/output.log"
-    ).command.should == %Q["/bin/duplicati-commandline" backup "/foo/bar#{File::PATH_SEPARATOR}/baz/bar" "file:///foo/backup"
+
+  context "#initialize" do
+  
+    it "raises an Exception if backup paths are not provided" do
+      expect {
+        Duplicati::Backup.new(:backup_store_path => "")
+      }.to raise_error(RuntimeError, ":backup_paths option is missing for backup!")
+    end
+
+    it "raises an Exception if backup store path is not provided" do
+      expect {
+        Duplicati::Backup.new(:backup_paths => [])
+      }.to raise_error(RuntimeError, ":backup_store_path option is missing for backup!")
+    end
+  end
+
+  context "#command" do
+
+    let(:basedir) { File.dirname(__FILE__) }
+
+    it "generates backup command for Duplicati using different options" do
+      Duplicati::Backup.new(
+        :duplicati_path => "/bin/duplicati-commandline",
+        :backup_paths => [basedir, File.join(basedir, "../")],
+        :backup_store_path => "file:///foo/backup",
+        :backup_encryption_key => "secret",
+        :inclusion_filters => [/include-me/],
+        :exclusion_filters => [/exclude-me/],
+        :log_path => "/zzz/output.log"
+      ).command.should == %Q["/bin/duplicati-commandline" backup "#{basedir}#{File::PATH_SEPARATOR}#{File.join(basedir, "../").chop}" "file:///foo/backup"
              --passphrase="secret"
+             --include-regexp="include-me"
+             --exclude-regexp="exclude-me"
              --auto-cleanup                        
              --full-if-older-than=1M
              --usn-policy=on
@@ -20,5 +44,55 @@ describe Duplicati::Backup do
              "/bin/duplicati-commandline" delete-all-but-n 5 "file:///foo/backup"
              --force
              2>&1 1>> "/zzz/output.log"]
+    end
+
+    it "generates backup command for Duplicati without using any encryption when encryption key is not provided" do
+      command = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :inclusion_filters => [], :exclusion_filters => []).command
+      command.should include("--no-encryption")
+      command.should_not include("--passphrase")
+    end
+
+    it "works with globs for backup paths" do
+      Duplicati::Backup.new(:backup_paths => [File.join(basedir, "../*_helper*")], :backup_store_path => "", :inclusion_filters => [], :exclusion_filters => []).
+        command.split(" ")[2].should == "\"#{File.join(basedir, "../spec_helper.rb")}\""
+    end
+
+    it "ignores not-existing backup paths" do
+      Duplicati::Backup.new(:backup_paths => ["/foo/bar", basedir, "/baz/bar"], :backup_store_path => "", :inclusion_filters => [], :exclusion_filters => []).
+        command.split(" ")[2].should == "\"#{basedir}\""
+    end
+
+    it "works with inclusion filters" do
+      command_parts = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :inclusion_filters => [/a\.exe/, /b\.exe/]).
+        command.split(" ")
+
+      command_parts[5].should == "--include-regexp=\"a\\.exe\""
+      command_parts[6].should == "--include-regexp=\"b\\.exe\""
+    end
+
+    it "works with exclusion filters" do
+      command_parts = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :exclusion_filters => [/a\.exe/, /b\.exe/]).
+        command.split(" ")
+      
+      command_parts[5].should == "--exclude-regexp=\"a\\.exe\""
+      command_parts[6].should == "--exclude-regexp=\"b\\.exe\""
+    end
+
+    it "works with inclusion and exclusion filters together" do
+      command_parts = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "", :inclusion_filters => [/a/, /b/], :exclusion_filters => [/c/, /d/]).
+        command.split(" ")
+
+      command_parts[5].should == "--include-regexp=\"a\""
+      command_parts[6].should == "--include-regexp=\"b\""
+      command_parts[7].should == "--exclude-regexp=\"c\""
+      command_parts[8].should == "--exclude-regexp=\"d\""
+    end
+
+    it "does not include filters into command when they're not specified" do
+      command = Duplicati::Backup.new(:backup_paths => [], :backup_store_path => "").command
+      command.should_not include("--include-regexp")
+      command.should_not include("--exclude-regexp")
+    end
+
   end
 end

data/spec/duplicati_spec.rb

@@ -40,12 +40,40 @@ describe Duplicati do
       Duplicati.new(:foo => true).opts[:foo].should be_true
     end
 
+    it "has no inclusion filters by default" do
+      Duplicati.new.opts[:inclusion_filters].should == []
+    end
+
+    it "allows to specify a single inclusion filter" do
+      Duplicati.new(:inclusion_filter => /aa/).opts[:inclusion_filters].should == [/aa/]
+    end
+
+    it "allows to specify multiple inclusion filters" do
+      Duplicati.new(:inclusion_filters => [/aa/, /bb/]).opts[:inclusion_filters].should == [/aa/, /bb/]
+    end
+
+    it "will set up an 'exclude all others files' exclusion filter automatically when inclusion filter is used" do
+      Duplicati.new(:inclusion_filter => /aa/).opts[:exclusion_filters].should == [%r{.*[^\\/]}]
+    end
+
+    it "has no exclusion filters by default" do
+      Duplicati.new.opts[:exclusion_filters].should == []
+    end
+    
+    it "allows to specify a single exclusion filter" do
+      Duplicati.new(:exclusion_filter => /aa/).opts[:exclusion_filters].should == [/aa/]
+    end
+
+    it "allows to specify multiple exclusion filters" do
+      Duplicati.new(:exclusion_filters => [/aa/, /bb/]).opts[:exclusion_filters].should == [/aa/, /bb/]
+    end
+
   end
 
   context "#backup" do
     it "executes the backup command" do
       Duplicati::Backup.any_instance.should_receive(:command).and_return("backup command")
-      duplicati = Duplicati.new
+      duplicati = Duplicati.new(:backup_paths => [], :backup_store_path => "")
       duplicati.should_receive(:execute).with("backup command")
 
       duplicati.backup
@@ -58,6 +86,8 @@ describe Duplicati do
         :backup_paths => ["foo", "bar"],
         :backup_encryption_key => "secret",
         :backup_store_path => "baz",
+        :inclusion_filters => [],
+        :exclusion_filters => [],
         :log_path => "tmp"
       }
       expected_formatted_options = options.dup
@@ -74,7 +104,7 @@ describe Duplicati do
       Duplicati::Backup.any_instance.should_receive(:command).and_return("backup command")
       Duplicati.any_instance.should_receive(:execute).with("backup command")
 
-      Duplicati.backup
+      Duplicati.backup(:backup_paths => [], :backup_store_path => "")
     end
   end
 

data/spec/spec_helper.rb

@@ -6,4 +6,5 @@ require "duplicati"
 RSpec.configure do |config|
   config.color = true
   config.order = :random
+  config.add_formatter :documentation
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: duplicati
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-28 00:00:00.000000000 Z
+date: 2012-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake