backup 3.0.20 → 3.0.21

data/lib/backup/syncer/rsync/pull.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Backup
+  module Syncer
+    module RSync
+      class Pull < Push
+
+        ##
+        # Performs the RSync::Pull operation
+        # debug options: -vhP
+        def perform!
+          write_password_file!
+
+          @directories.each do |directory|
+            Logger.message("#{ syncer_name } started syncing '#{ directory }'.")
+            Logger.silent(
+              run("#{ utility(:rsync) } #{ options } " +
+                  "'#{ username }@#{ ip }:#{ directory.sub(/^\~\//, '') }' " +
+                  "'#{ dest_path }'")
+            )
+          end
+
+        ensure
+          remove_password_file!
+        end
+
+        private
+
+        ##
+        # Return expanded @path
+        def dest_path
+          @dest_path ||= File.expand_path(@path)
+        end
+
+      end
+    end
+  end
+end

data/lib/backup/syncer/rsync/push.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+module Backup
+  module Syncer
+    module RSync
+      class Push < Base
+
+        ##
+        # Server credentials
+        attr_accessor :username, :password
+
+        ##
+        # Server IP Address and SSH port
+        attr_accessor :ip
+
+        ##
+        # The SSH port to connect to
+        attr_accessor :port
+
+        ##
+        # Flag for compressing (only compresses for the transfer)
+        attr_accessor :compress
+
+        ##
+        # Instantiates a new RSync::Push or RSync::Pull Syncer object.
+        # Default configuration values and any specified in
+        # Backup::Configuration::Syncer::RSync::[Push/Pull] are set from Base.
+        # The user's configuration file is then evaluated to overwrite
+        # these values or provide additional configuration.
+        def initialize(&block)
+          super
+
+          @port               ||= 22
+          @compress           ||= false
+
+          instance_eval(&block) if block_given?
+        end
+
+        ##
+        # Performs the RSync:Push operation
+        # debug options: -vhP
+        def perform!
+          write_password_file!
+
+          Logger.message(
+            "#{ syncer_name } started syncing the following directories:\n\s\s" +
+            @directories.join("\n\s\s")
+          )
+          Logger.silent(
+            run("#{ utility(:rsync) } #{ options } #{ directories_option } " +
+                "'#{ username }@#{ ip }:#{ dest_path }'")
+          )
+
+        ensure
+          remove_password_file!
+        end
+
+        private
+
+        ##
+        # Return @path with any preceeding "~/" removed
+        def dest_path
+          @dest_path ||= @path.sub(/^\~\//, '')
+        end
+
+        ##
+        # Returns all the specified Rsync::[Push/Pull] options,
+        # concatenated, ready for the CLI
+        def options
+          ([archive_option, mirror_option, compress_option, port_option,
+            password_option] + additional_options).compact.join("\s")
+        end
+
+        ##
+        # Returns Rsync syntax for compressing the file transfers
+        def compress_option
+          '--compress' if @compress
+        end
+
+        ##
+        # Returns Rsync syntax for defining a port to connect to
+        def port_option
+          "-e 'ssh -p #{@port}'"
+        end
+
+        ##
+        # Returns Rsync syntax for setting a password (via a file)
+        def password_option
+          "--password-file='#{@password_file.path}'" if @password_file
+        end
+
+        ##
+        # Writes the provided password to a temporary file so that
+        # the rsync utility can read the password from this file
+        def write_password_file!
+          unless @password.nil?
+            @password_file = Tempfile.new('backup-rsync-password')
+            @password_file.write(@password)
+            @password_file.close
+          end
+        end
+
+        ##
+        # Removes the previously created @password_file
+        # (temporary file containing the password)
+        def remove_password_file!
+          @password_file.delete if @password_file
+          @password_file = nil
+        end
+      end
+    end
+  end
+end

data/lib/backup/syncer/s3.rb

@@ -14,7 +14,7 @@ module Backup
 
       ##
       # Directories to sync
-      attr_accessor :directories
+      attr_writer :directories
 
       ##
       # Flag to enable mirroring
@@ -26,75 +26,85 @@ module Backup
 
       ##
       # Instantiates a new S3 Syncer object and sets the default configuration
-      # specified in the Backup::Configuration::Syncer::S3. Then it sets the object
-      # defaults if particular properties weren't set. Finally it'll evaluate the users
-      # configuration file and overwrite anything that's been defined
+      # specified in the Backup::Configuration::Syncer::S3.
+      # Then it sets the object defaults if particular properties weren't set.
+      # Finally it'll evaluate the users configuration file and overwrite
+      # anything that's been defined
       def initialize(&block)
         load_defaults!
 
         @path               ||= 'backups'
-        @directories        ||= Array.new
+        @directories          = Array.new
         @mirror             ||= false
         @additional_options ||= []
 
         instance_eval(&block) if block_given?
-
-        @path = path.sub(/^\//, '')
       end
 
       ##
-      # Performs the S3Sync operation
-      # First it'll set the Amazon S3 credentials for S3Sync before invoking it,
-      # and once it's finished syncing the files and directories to Amazon S3, it'll
-      # unset these credentials (back to nil values)
+      # Sets the Amazon S3 credentials for S3Sync, performs the S3Sync
+      # operation, then unsets the credentials (back to nil values)
       def perform!
         set_environment_variables!
 
-        directories.each do |directory|
-          Logger.message("#{ self.class } started syncing '#{ directory }'.")
-          Logger.silent( run("#{ utility(:s3sync) } #{ options } '#{ directory }' '#{ bucket }:#{ path }'") )
+        @directories.each do |directory|
+          Logger.message("#{ syncer_name } started syncing '#{ directory }'.")
+          Logger.silent(
+            run("#{ utility(:s3sync) } #{ options } " +
+                "'#{ File.expand_path(directory) }' '#{ bucket }:#{ dest_path }'")
+          )
         end
 
         unset_environment_variables!
       end
 
       ##
-      # Returns all the specified S3Sync options, concatenated, ready for the CLI
+      # Syntactical suger for the DSL for adding directories
+      def directories(&block)
+        return @directories unless block_given?
+        instance_eval(&block)
+      end
+
+      ##
+      # Adds a path to the @directories array
+      def add(path)
+        @directories << path
+      end
+
+      private
+
+      ##
+      # Return @path with preceeding '/' slash removed
+      def dest_path
+        @dest_path ||= @path.sub(/^\//, '')
+      end
+
+      ##
+      # Returns all the specified S3Sync options,
+      # concatenated, ready for the CLI
       def options
-        ([verbose, recursive, mirror] + additional_options).compact.join("\s")
+        ([verbose_option, recursive_option, mirror_option] +
+          additional_options).compact.join("\s")
       end
 
       ##
       # Returns S3Sync syntax for enabling mirroring
-      def mirror
+      def mirror_option
         '--delete' if @mirror
       end
 
       ##
       # Returns S3Sync syntax for syncing recursively
-      def recursive
+      def recursive_option
         '--recursive'
       end
 
       ##
       # Returns S3Sync syntax for making output verbose
-      def verbose
+      def verbose_option
         '--verbose'
       end
 
-      ##
-      # Syntactical suger for the DSL for adding directories
-      def directories(&block)
-        return @directories unless block_given?
-        instance_eval(&block)
-      end
-
-      ##
-      # Adds a path to the @directories array
-      def add(path)
-        @directories << path
-      end
-
       ##
       # In order for S3Sync to know what credentials to use, we have to set the
       # AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables, these

data/lib/backup/version.rb

@@ -13,7 +13,7 @@ module Backup
     #  Defines the minor version
     # PATCH:
     #  Defines the patch version
-    MAJOR, MINOR, PATCH = 3, 0, 20
+    MAJOR, MINOR, PATCH = 3, 0, 21
 
     ##
     # Returns the major version ( big release based off of multiple minor releases )

data/spec/archive_spec.rb

@@ -3,112 +3,278 @@
 require File.expand_path('../spec_helper.rb', __FILE__)
 
 describe Backup::Archive do
+  let(:model) { Backup::Model.new(:test_trigger, 'test model') }
+  let(:archive) { Backup::Archive.new(model, :test_archive) }
 
-  let(:archive) do
-    Backup::Archive.new(:dummy_archive) do |a|
-      a.add '/home/rspecuser/somefile'
-      a.add '/home/rspecuser/logs'
-      a.add '/home/rspecuser/dotfiles'
-      a.exclude '/home/rspecuser/badfile'
-      a.exclude '/home/rspecuser/wrongdir'
+  describe '#initialize' do
+
+    it 'should have no paths' do
+      archive.paths.should == []
     end
-  end
 
-  it 'should have no paths' do
-    archive = Backup::Archive.new(:dummy_archive) { |a| }
-    archive.paths.count.should == 0
-  end
+    it 'should have no excludes' do
+      archive.excludes.should == []
+    end
 
-  it 'should have no excludes' do
-    archive = Backup::Archive.new(:dummy_archive) { |a| }
-    archive.excludes.count.should == 0
-  end
+    it 'should have no tar_args' do
+      archive.tar_args.should == ''
+    end
 
-  it 'should have 3 paths' do
-    archive.paths.count.should == 3
-  end
+    it 'should set a reference to the given model' do
+      archive.instance_variable_get(:@model).should be(model)
+    end
 
-  it 'should have 2 excludes' do
-    archive.excludes.count.should == 2
-  end
+    it 'should convert name to a String' do
+      archive.name.should be_a_kind_of String
+      archive.name.should == 'test_archive'
+    end
 
-  it do
-    archive.name.should == :dummy_archive
-  end
+    context 'when a configuration block is given' do
+      let(:archive) do
+        Backup::Archive.new(model, :test_archive) do |a|
+          a.add 'added_path'
+          a.add 'another/added_path'
+          a.exclude 'excluded_path'
+          a.exclude 'another/excluded_path'
+          a.tar_options '-h --xattrs'
+        end
+      end
 
-  describe '#paths_to_package' do
-    it 'should return a tar -c friendly string' do
-      archive.send(:paths_to_package).should ==
-      "'/home/rspecuser/somefile' '/home/rspecuser/logs' '/home/rspecuser/dotfiles'"
+      before do
+        File.stubs(:exist?).returns(true)
+      end
+
+      it 'should add @paths' do
+        archive.paths.should == [
+          File.expand_path('added_path'),
+          File.expand_path('another/added_path')
+        ]
+      end
+
+      it 'should add @excludes' do
+        archive.excludes.should == [
+          File.expand_path('excluded_path'),
+          File.expand_path('another/excluded_path')
+        ]
+      end
+
+      it 'should add @tar_args' do
+        archive.tar_args.should == '-h --xattrs'
+      end
+    end
+
+  end # describe '#initialize'
+
+  describe '#add' do
+
+    context 'when the path exists' do
+      it 'should expand and add the path to @paths' do
+        File.expects(:exist?).with(File.expand_path('foo')).returns(true)
+        Backup::Logger.expects(:warn).never
+
+        archive.add 'foo'
+        archive.paths.should == [File.expand_path('foo')]
+      end
+    end
+
+    context 'when a path does not exist' do
+      it 'should omit the path and log a warning' do
+        File.expects(:exist?).with(
+          File.expand_path('path')
+        ).returns(true)
+        File.expects(:exist?).with(
+          File.expand_path('foo')
+        ).returns(false)
+        File.expects(:exist?).with(
+          File.expand_path('another/path')
+        ).returns(true)
+
+        Backup::Logger.expects(:warn).with do |err|
+          err.should be_an_instance_of Backup::Errors::Archive::NotFoundError
+          err.message.should ==
+            "Archive::NotFoundError: The following path was not found:\n" +
+            "  #{ File.expand_path('foo') }\n" +
+            "  This path will be omitted from the 'test_archive' Archive."
+        end
+
+        archive.add 'path'
+        archive.add 'foo'
+        archive.add 'another/path'
+        archive.paths.should == [
+          File.expand_path('path'),
+          File.expand_path('another/path')
+        ]
+      end
     end
   end
 
-  describe '#paths_to_exclude' do
-    it 'should be empty' do
-      archive = Backup::Archive.new(:dummy_archive) { |a| }
-      archive.send(:paths_to_exclude).should be_nil
+  describe '#exclude' do
+    it 'should expand and add the given path to #excludes' do
+      archive.exclude 'path'
+      archive.exclude 'another/path'
+      archive.excludes.should == [
+        File.expand_path('path'),
+        File.expand_path('another/path')
+      ]
     end
+  end
 
-    it 'should return a tar -c friendly string' do
-      archive.send(:paths_to_exclude).should ==
-      "--exclude='/home/rspecuser/badfile' --exclude='/home/rspecuser/wrongdir'"
+  describe '#tar_options' do
+    it 'should set #tar_options to the given string' do
+      archive = Backup::Archive.new(model, :test_archive) do |a|
+        a.tar_options '-h --xattrs'
+      end
+      archive.tar_args.should == '-h --xattrs'
     end
   end
 
   describe '#perform!' do
+    let(:archive_path) do
+      File.join(Backup::Config.tmp_path, 'test_trigger', 'archives')
+    end
+    let(:paths) { ['/path/to/add', '/another/path/to/add'] }
+    let(:excludes) { ['/path/to/exclude', '/another/path/to/exclude'] }
+
     before do
-      [:mkdir, :run, :utility].each { |method| archive.stubs(method) }
+      archive.expects(:utility).with(:tar).returns('tar')
+      FileUtils.expects(:mkdir_p).with(archive_path)
     end
 
-    context 'when both paths were added and paths that should be excluded were added' do
-      it 'should render both the syntax for the paths that be included as well as excluded' do
-        archive.expects(:mkdir).with(File.join(Backup::TMP_PATH, Backup::TRIGGER, 'archive'))
+    context 'when both #paths and #excludes were added' do
+      before do
+        archive.instance_variable_set(:@paths, paths)
+        archive.instance_variable_set(:@excludes, excludes)
+      end
+
+      it 'should render the syntax for both' do
+        Backup::Logger.expects(:message).with(
+          "Backup::Archive started packaging and archiving:\n" +
+          "  /path/to/add\n" +
+          "  /another/path/to/add"
+        )
+
         archive.expects(:run).with(
-          "tar  -cf '#{File.join(Backup::TMP_PATH, Backup::TRIGGER, 'archive', "#{:dummy_archive}.tar")}' --exclude='/home/rspecuser/badfile' --exclude='/home/rspecuser/wrongdir' '/home/rspecuser/somefile' '/home/rspecuser/logs' '/home/rspecuser/dotfiles'",
-          :ignore_exit_codes => [1]
+          "tar  -cf - " +
+          "--exclude='/path/to/exclude' --exclude='/another/path/to/exclude' " +
+          "'/path/to/add' '/another/path/to/add' " +
+          "> '#{ File.join(archive_path, 'test_archive.tar') }'"
         )
-        archive.expects(:utility).with(:tar).returns(:tar)
+
         archive.perform!
       end
-    end
+    end # context 'when both #paths and #excludes were added'
 
-    context 'when there are paths to add, and no exclude patterns were defined' do
-      it 'should only render syntax for the defined paths' do
-        archive = Backup::Archive.new(:dummy_archive) do |a|
-          a.add '/path/to/archive'
-        end
+    context 'when no excludes were added' do
+      before do
+        archive.instance_variable_set(:@paths, paths)
+      end
+
+      it 'should render only the syntax for adds' do
+        Backup::Logger.expects(:message).with(
+          "Backup::Archive started packaging and archiving:\n" +
+          "  /path/to/add\n" +
+          "  /another/path/to/add"
+        )
 
-        archive.stubs(:utility).returns(:tar)
         archive.expects(:run).with(
-          "tar  -cf '#{File.join(Backup::TMP_PATH, Backup::TRIGGER, 'archive', "#{:dummy_archive}.tar")}'  '/path/to/archive'",
-          :ignore_exit_codes => [1]
+          "tar  -cf -  " +
+          "'/path/to/add' '/another/path/to/add' " +
+          "> '#{ File.join(archive_path, 'test_archive.tar') }'"
         )
+
         archive.perform!
       end
-    end
+    end # context 'when no excludes were added'
+    context 'with #paths, #excludes and #tar_args' do
+      before do
+        archive.instance_variable_set(:@paths, paths)
+        archive.instance_variable_set(:@excludes, excludes)
+        archive.instance_variable_set(:@tar_args, '-h --xattrs')
+      end
 
-    context 'when tar_options are given' do
-      it 'should add the options to the tar command' do
-        archive = Backup::Archive.new(:dummy_archive) do |a|
-          a.add '/path/to/archive'
-          a.tar_options '-h --xattrs'
-        end
+      it 'should render the syntax for all three' do
+        Backup::Logger.expects(:message).with(
+          "Backup::Archive started packaging and archiving:\n" +
+          "  /path/to/add\n" +
+          "  /another/path/to/add"
+        )
+
+        archive.expects(:run).with(
+          "tar -h --xattrs -cf - " +
+          "--exclude='/path/to/exclude' --exclude='/another/path/to/exclude' " +
+          "'/path/to/add' '/another/path/to/add' " +
+          "> '#{ File.join(archive_path, 'test_archive.tar') }'"
+        )
+
+        archive.perform!
+      end
+    end # context 'with #paths, #excludes and #tar_args'
+
+    context 'with #paths, #excludes, #tar_args and a Gzip Compressor' do
+      before do
+        archive.instance_variable_set(:@paths, paths)
+        archive.instance_variable_set(:@excludes, excludes)
+        archive.instance_variable_set(:@tar_args, '-h --xattrs')
+        compressor = mock
+        model.expects(:compressor).twice.returns(compressor)
+        compressor.expects(:compress_with).yields('gzip', '.gz')
+      end
+
+      it 'should render the syntax with compressor modifications' do
+        Backup::Logger.expects(:message).with(
+          "Backup::Archive started packaging and archiving:\n" +
+          "  /path/to/add\n" +
+          "  /another/path/to/add"
+        )
 
-        archive.stubs(:utility).returns(:tar)
         archive.expects(:run).with(
-          "tar -h --xattrs -cf '#{File.join(Backup::TMP_PATH, Backup::TRIGGER, 'archive', "#{:dummy_archive}.tar")}'  '/path/to/archive'",
-          :ignore_exit_codes => [1]
+          "tar -h --xattrs -cf - " +
+          "--exclude='/path/to/exclude' --exclude='/another/path/to/exclude' " +
+          "'/path/to/add' '/another/path/to/add' " +
+          "| gzip > '#{ File.join(archive_path, 'test_archive.tar.gz') }'"
         )
+
         archive.perform!
       end
+    end # context 'with #paths, #excludes, #tar_args and a Gzip Compressor'
+
+  end # describe '#perform!'
+
+  describe '#paths_to_package' do
+    before do
+      archive.instance_variable_set(
+        :@paths,
+        ['/home/rspecuser/somefile',
+         '/home/rspecuser/logs',
+         '/home/rspecuser/dotfiles']
+      )
     end
-    it 'should log the status' do
-      Backup::Logger.expects(:message).
-          with("Backup::Archive started packaging and archiving:\n" +
-               "  /home/rspecuser/somefile\n" +
-               "  /home/rspecuser/logs\n" +
-               "  /home/rspecuser/dotfiles")
-      archive.perform!
+
+    it 'should return a tar friendly string' do
+      archive.send(:paths_to_package).should ==
+      "'/home/rspecuser/somefile' '/home/rspecuser/logs' '/home/rspecuser/dotfiles'"
+    end
+  end
+
+  describe '#paths_to_exclude' do
+    context 'when no excludes are added' do
+      it 'should return nil' do
+        archive.send(:paths_to_exclude).should be_nil
+      end
+    end
+
+    context 'when excludes are added' do
+      before do
+        archive.instance_variable_set(
+          :@excludes,
+          ['/home/rspecuser/badfile',
+          '/home/rspecuser/wrongdir']
+        )
+      end
+      it 'should return a tar friendly string' do
+        archive.send(:paths_to_exclude).should ==
+        "--exclude='/home/rspecuser/badfile' --exclude='/home/rspecuser/wrongdir'"
+      end
     end
   end
 end