backup 3.0.20 → 3.0.21

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

@@ -1,45 +0,0 @@
-# encoding: utf-8
-
-module Backup
-  module Configuration
-    module Syncer
-      class RSync < Base
-        class << self
-
-          ##
-          # Server credentials
-          attr_accessor :username, :password
-
-          ##
-          # Server IP Address and SSH port
-          attr_accessor :ip
-
-          ##
-          # The SSH port to connect to
-          attr_accessor :port
-
-          ##
-          # Directories to sync
-          attr_accessor :directories
-
-          ##
-          # Path to store the synced files/directories to
-          attr_accessor :path
-
-          ##
-          # Flag for mirroring the files/directories
-          attr_accessor :mirror
-
-          ##
-          # Flag for compressing (only compresses for the transfer)
-          attr_accessor :compress
-
-          ##
-          # Additional options for the rsync cli
-          attr_accessor :additional_options
-
-        end
-      end
-    end
-  end
-end

data/lib/backup/finder.rb

@@ -1,87 +0,0 @@
-# encoding: utf-8
-
-module Backup
-  class Finder
-    attr_accessor :trigger, :config
-
-    ##
-    # The wildcard character to match triggers
-    # Can be used alone or in mask (e.g. web_* )
-    WILDCARD = '*'
-
-    ##
-    # Initializes a new Backup::Finder object
-    # and stores the path to the configuration file
-    def initialize(trigger, config = CONFIG_FILE)
-      @trigger = trigger.to_sym
-      @config  = config
-    end
-
-    ##
-    # Tries to find and return the proper
-    # backup model configuration (specified by the 'trigger')
-    def find
-      load_config!
-
-      ##
-      # Iterates through all the instantiated backup models and returns
-      # the one that matches the specified 'trigger'
-      Backup::Model.all.each do |model|
-        if model.trigger.eql?(trigger)
-          return Backup::Model.current = model
-        end
-      end
-
-      raise Errors::Finder::MissingTriggerError,
-          "Could not find trigger '#{trigger}' in '#{config}'."
-    end
-
-    ##
-    # Tries to find and return the all triggers
-    # matching wildcard (specified by the 'trigger')
-    def matching
-      ##
-      # Define the TIME constants unless defined
-      ::Backup.send(:const_set, :TIME, Time.now.strftime("%Y.%m.%d.%H.%M.%S")) unless defined? Backup::TIME
-
-      ##
-      # Parses the backup configuration file
-      load_config!
-
-      triggers = Backup::Model.all.map{|model| model.trigger.to_s }
-
-      ##
-      # Removes the TIME constant
-      ::Backup.send(:remove_const, :TIME) if defined? Backup::TIME
-
-      ##
-      # Make regexp replacing wildcard character by (.+)
-      wildcard = %r{^#{trigger.to_s.gsub(WILDCARD, '(.+)')}$}
-
-      ##
-      # Returns all trigger names matching wildcard
-      triggers.select { |trigger| trigger =~ wildcard }
-    end
-
-    private
-
-    ##
-    # Tries to find and load the configuration file
-    def load_config!
-      unless File.exist?(config)
-        raise Errors::Finder::MissingConfigError,
-            "Could not find configuration file: '#{config}'."
-      end
-
-      ##
-      # Reset the Backup::Model.all to an empty array since this will be
-      # re-filled during the next Backup::Finder.new(arg1, arg2).find
-      # or Backup::Finder.new(arg).matching call
-      Backup::Model.all = Array.new
-
-      ##
-      # Loads the backup configuration file
-      Backup.module_eval(File.read(config), config, 1)
-    end
-  end
-end

data/lib/backup/storage/object.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-module Backup
-  module Storage
-    class Object
-
-      ##
-      # Holds the type attribute
-      attr_accessor :storage_file
-
-      ##
-      # Instantiates a new Backup::Storage::Object and stores the
-      # full path to the storage file (yaml) in the @storage_file attribute
-      def initialize(type, storage_id)
-        suffix = storage_id.to_s.strip.gsub(/[\W\s]/, '_')
-        filename = suffix.empty? ? type : "#{type}-#{suffix}"
-        @storage_file = File.join(DATA_PATH, TRIGGER, "#{filename}.yml")
-      end
-
-      ##
-      # Tries to load an existing YAML file and returns an
-      # array of storage objects. If no file exists, an empty
-      # array gets returned
-      #
-      # If a file is loaded it'll sort the array of objects by @time
-      # descending. The newest backup storage object comes in Backup::Storage::Object.load[0]
-      # and the oldest in Backup::Storage::Object.load[-1]
-      def load
-        objects = []
-        if File.exist?(storage_file) and not File.zero?(storage_file)
-          objects = YAML.load_file(storage_file).sort { |a,b| b.time <=> a.time }
-        end
-        objects
-      end
-
-      ##
-      # Takes the provided objects and converts it to YAML format.
-      # The YAML data gets written to the storage file
-      def write(objects)
-        File.open(storage_file, 'w') do |file|
-          file.write(objects.to_yaml)
-        end
-      end
-
-    end
-  end
-end

data/lib/backup/syncer/rsync.rb

@@ -1,152 +0,0 @@
-# encoding: utf-8
-
-##
-# Require the tempfile Ruby library when Backup::Syncer::RSync is loaded
-require 'tempfile'
-
-module Backup
-  module Syncer
-    class RSync < Base
-
-      ##
-      # Server credentials
-      attr_accessor :username, :password
-
-      ##
-      # Server IP Address and SSH port
-      attr_accessor :ip
-
-      ##
-      # The SSH port to connect to
-      attr_writer :port
-
-      ##
-      # Directories to sync
-      attr_writer :directories
-
-      ##
-      # Path to store the synced files/directories to
-      attr_accessor :path
-
-      ##
-      # Flag for mirroring the files/directories
-      attr_writer :mirror
-
-      ##
-      # Flag for compressing (only compresses for the transfer)
-      attr_writer :compress
-
-      ##
-      # Additional options for the rsync cli
-      attr_accessor :additional_options
-
-      ##
-      # Instantiates a new RSync Syncer object and sets the default configuration
-      # specified in the Backup::Configuration::Syncer::RSync. 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!
-
-        @directories          = Array.new
-        @additional_options ||= Array.new
-        @path               ||= 'backups'
-        @port               ||= 22
-        @mirror             ||= false
-        @compress           ||= false
-
-        instance_eval(&block) if block_given?
-        write_password_file!
-
-        @path = path.sub(/^\~\//, '')
-      end
-
-      ##
-      # Performs the RSync operation
-      # debug options: -vhP
-      def perform!
-        Logger.message("#{ self.class } started syncing #{ directories }.")
-        Logger.silent(
-          run("#{ utility(:rsync) } #{ options } #{ directories } '#{ username }@#{ ip }:#{ path }'")
-        )
-
-        remove_password_file!
-      end
-
-      ##
-      # Returns all the specified Rsync options, concatenated, ready for the CLI
-      def options
-        ([archive, mirror, compress, port, password] + additional_options).compact.join("\s")
-      end
-
-      ##
-      # Returns Rsync syntax for enabling mirroring
-      def mirror
-        '--delete' if @mirror
-      end
-
-      ##
-      # Returns Rsync syntax for compressing the file transfers
-      def compress
-        '--compress' if @compress
-      end
-
-      ##
-      # Returns Rsync syntax for invoking "archive" mode
-      def archive
-        '--archive'
-      end
-
-      ##
-      # Returns Rsync syntax for defining a port to connect to
-      def port
-        "-e 'ssh -p #{@port}'"
-      end
-
-      ##
-      # Returns Rsync syntax for setting a password (via a file)
-      def password
-        "--password-file='#{@password_file.path}'" unless @password.nil?
-      end
-
-      ##
-      # If no block has been provided, it'll return the array of @directories.
-      # If a block has been provided, it'll evaluate it and add the defined paths to the @directories
-      def directories(&block)
-        unless block_given?
-          return @directories.map do |directory|
-            "'#{directory}'"
-          end.join("\s")
-        end
-        instance_eval(&block)
-      end
-
-      ##
-      # Adds a path to the @directories array
-      def add(path)
-        @directories << path
-      end
-
-      private
-
-      ##
-      # 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.unlink unless @password.nil?
-      end
-
-    end
-  end
-end

data/spec/backup_spec.rb

@@ -1,11 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../spec_helper.rb', __FILE__)
-
-describe Backup do
-  it do
-    Backup::TMP_PATH.should    == File.join(ENV['HOME'], 'Backup', '.tmp')
-    Backup::DATA_PATH.should   == File.join(ENV['HOME'], 'Backup', 'data')
-    Backup::CONFIG_FILE.should == File.join(ENV['HOME'], 'Backup', 'config.rb')
-  end
-end

data/spec/finder_spec.rb

@@ -1,91 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../spec_helper.rb', __FILE__)
-
-describe Backup::Finder do
-
-  describe '#find' do
-    let(:finder) { Backup::Finder.new('test_trigger', 'foo') }
-
-    before do
-      finder.stubs(:load_config!)
-    end
-
-    it 'should return the first model that matches the trigger' do
-      models = %w{ foo1 test_trigger foo2 test_trigger }.map do |trigger|
-        stub(:trigger => trigger.to_sym)
-      end
-      Backup::Model.expects(:all).returns(models)
-      Backup::Model.expects(:current=).with(models[1])
-
-      expect do
-        finder.find.should == models[1]
-      end.not_to raise_error
-    end
-
-    it 'should raise an error when no models match the trigger' do
-      models = %w{ foo1 foo2 foo3 }.map do |trigger|
-        stub(:trigger => trigger.to_sym)
-      end
-      Backup::Model.expects(:all).returns(models)
-      Backup::Model.expects(:current=).never
-
-      expect do
-        finder.find
-      end.to raise_error(
-        Backup::Errors::Finder::MissingTriggerError,
-        "Finder::MissingTriggerError: Could not find trigger 'test_trigger' in 'foo'."
-      )
-    end
-
-  end # describe '#find'
-
-  describe '#load_config!' do
-    let(:finder) { Backup::Finder.new('foo', 'config_file') }
-
-    context 'when given a valid config file' do
-
-      before do
-        File.expects(:exist?).with('config_file').returns(true)
-      end
-
-      it 'should load the config file' do
-        File.expects(:read).with('config_file').returns(:file_contents)
-        Backup.expects(:module_eval).with(:file_contents, 'config_file', 1)
-
-        finder.send(:load_config!)
-      end
-
-      it 'should reset Model.all' do
-        File.stubs(:read)
-        Backup.stubs(:module_eval)
-        Backup::Model.expects(:all=).with([])
-
-        finder.send(:load_config!)
-      end
-
-    end # context 'when given a valid config file'
-
-    context 'when given a config file that does not exist' do
-
-      before do
-        File.expects(:exist?).with('config_file').returns(false)
-      end
-
-      it 'should raise an error' do
-        Backup::Model.expects(:all=).never
-        File.expects(:read).never
-        Backup.expects(:module_eval).never
-
-        expect do
-          finder.send(:load_config!)
-        end.to raise_error(
-          Backup::Errors::Finder::MissingConfigError,
-          "Finder::MissingConfigError: Could not find configuration file: 'config_file'."
-        )
-      end
-
-    end # context 'when given a config file that does not exist'
-
-  end # describe '#find'
-end

data/spec/storage/object_spec.rb

@@ -1,74 +0,0 @@
-# encoding: utf-8
-
-require File.expand_path('../../spec_helper.rb', __FILE__)
-
-describe Backup::Storage::Object do
-
-  describe '#initialize' do
-
-    it 'uses storage type only as YAML filename if no storage_id' do
-      [nil, '', ' '].each do |storage_id|
-        object = Backup::Storage::Object.new(:s3, storage_id)
-        object.storage_file.should == File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
-      end
-    end
-
-    it 'appends optional storage_id' do
-      object = Backup::Storage::Object.new(:s3, 'foo')
-      object.storage_file.should == File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3-foo.yml')
-    end
-
-    it 'sanitizes user-defined storage_id for use as filename' do
-      [ ['Backup Server #1', 'Backup_Server__1'],
-        [' {Special} Storage ', '_Special__Storage'],
-        ['Cloud (!@$%^&*) #9', 'Cloud____________9'] ].each do |input, sanitized|
-        object = Backup::Storage::Object.new(:s3, input)
-        object.storage_file.should == File.join(Backup::DATA_PATH, Backup::TRIGGER, "s3-#{sanitized}.yml")
-      end
-    end
-
-  end
-
-  describe '#load' do
-    let(:storage_object) { Backup::Storage::Object.new(:s3, nil) }
-
-    it 'should return an array with objects' do
-      loaded_objects = YAML.load([Backup::Storage::S3.new, Backup::Storage::S3.new].to_yaml)
-      sorted_objects = loaded_objects.sort {|a,b| b.time <=> a.time }
-
-      File.expects(:exist?).returns(true)
-      YAML.expects(:load_file).with(
-        File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
-      ).returns(loaded_objects)
-
-      objects = storage_object.load
-      objects.should be_an(Array)
-      objects.first.should be_an_instance_of(Backup::Storage::S3)
-    end
-
-    it 'should load them sorted by time descending (newest backup is first in the array)' do
-      obj_1 = Backup::Storage::S3.new; obj_1.time = '2007.00.00.00.00.00'
-      obj_2 = Backup::Storage::S3.new; obj_2.time = '2009.00.00.00.00.00'
-      obj_3 = Backup::Storage::S3.new; obj_3.time = '2011.00.00.00.00.00'
-
-      File.stubs(:exist?).returns(true)
-      File.stubs(:zero?).returns(false)
-
-      [obj_1, obj_2, obj_3].permutation.each do |perm|
-        loaded_objects = YAML.load(perm.to_yaml)
-        sorted_objects = loaded_objects.sort {|a,b| b.time <=> a.time }
-
-        YAML.expects(:load_file).with(
-          File.join(Backup::DATA_PATH, Backup::TRIGGER, 's3.yml')
-        ).returns(loaded_objects)
-
-        objects = storage_object.load
-        objects[0].time.should == '2011.00.00.00.00.00'
-        objects[1].time.should == '2009.00.00.00.00.00'
-        objects[2].time.should == '2007.00.00.00.00.00'
-      end
-    end
-
-  end
-
-end