backup_checksum 3.0.23

data/lib/backup/storage/ftp.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+##
+# Only load the Net::FTP library/gem when the Backup::Storage::FTP class is loaded
+require 'net/ftp'
+
+module Backup
+  module Storage
+    class FTP < Base
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and FTP port
+      attr_accessor :ip, :port
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # use passive mode?
+      attr_accessor :passive_mode
+
+      ##
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
+
+        @port         ||= 21
+        @path         ||= 'backups'
+        @passive_mode ||= false
+
+        instance_eval(&block) if block_given?
+
+        @path = path.sub(/^\~\//, '')
+      end
+
+      private
+
+      ##
+      # Establishes a connection to the remote server
+      #
+      # Note:
+      # Since the FTP port is defined as a constant in the Net::FTP class, and
+      # might be required to change by the user, we dynamically remove and
+      # re-add the constant with the provided port value
+      def connection
+        if Net::FTP.const_defined?(:FTP_PORT)
+          Net::FTP.send(:remove_const, :FTP_PORT)
+        end; Net::FTP.send(:const_set, :FTP_PORT, port)
+
+        Net::FTP.open(ip, username, password) do |ftp|
+          ftp.passive = true if passive_mode
+          yield ftp
+        end
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        remote_path = remote_path_for(@package)
+
+        connection do |ftp|
+          create_remote_path(remote_path, ftp)
+
+          files_to_transfer_for(@package) do |local_file, remote_file|
+            Logger.message "#{storage_name} started transferring " +
+                "'#{ local_file }' to '#{ ip }'."
+            ftp.put(
+              File.join(local_path, local_file),
+              File.join(remote_path, remote_file)
+            )
+          end
+        end
+      end
+
+      ##
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
+        connection do |ftp|
+          transferred_files_for(package) do |local_file, remote_file|
+            Logger.message "#{storage_name} started removing " +
+                "'#{ local_file }' from '#{ ip }'."
+
+            ftp.delete(File.join(remote_path, remote_file))
+          end
+
+          ftp.rmdir(remote_path)
+        end
+      end
+
+      ##
+      # Creates (if they don't exist yet) all the directories on the remote
+      # server in order to upload the backup file. Net::FTP does not support
+      # paths to directories that don't yet exist when creating new
+      # directories. Instead, we split the parts up in to an array (for each
+      # '/') and loop through that to create the directories one by one.
+      # Net::FTP raises an exception when the directory it's trying to create
+      # already exists, so we have rescue it
+      def create_remote_path(remote_path, ftp)
+        path_parts = Array.new
+        remote_path.split('/').each do |path_part|
+          path_parts << path_part
+          begin
+            ftp.mkdir(path_parts.join('/'))
+          rescue Net::FTPPermError; end
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/storage/local.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module Backup
+  module Storage
+    class Local < Base
+
+      ##
+      # Path where the backup will be stored.
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
+
+        @path ||= File.join(
+          File.expand_path(ENV['HOME'] || ''),
+          'backups'
+        )
+
+        instance_eval(&block) if block_given?
+
+        @path = File.expand_path(@path)
+      end
+
+      private
+
+      ##
+      # Transfers the archived file to the specified path
+      def transfer!
+        remote_path = remote_path_for(@package)
+        FileUtils.mkdir_p(remote_path)
+
+        files_to_transfer_for(@package) do |local_file, remote_file|
+          Logger.message "#{storage_name} started transferring '#{ local_file }'."
+
+          src_path = File.join(local_path, local_file)
+          dst_path = File.join(remote_path, remote_file)
+          FileUtils.send(transfer_method, src_path, dst_path)
+        end
+      end
+
+      ##
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
+        messages = []
+        transferred_files_for(package) do |local_file, remote_file|
+          messages << "#{storage_name} started removing '#{ local_file }'."
+        end
+        Logger.message messages.join("\n")
+
+        FileUtils.rm_r(remote_path)
+      end
+
+      ##
+      # Set and return the transfer method.
+      # If this Local Storage is not the last Storage for the Model,
+      # force the transfer to use a *copy* operation and issue a warning.
+      def transfer_method
+        return @transfer_method if @transfer_method
+
+        if self == @model.storages.last
+          @transfer_method = :mv
+        else
+          Logger.warn Errors::Storage::Local::TransferError.new(<<-EOS)
+            Local File Copy Warning!
+            The final backup file(s) for '#{@model.label}' (#{@model.trigger})
+            will be *copied* to '#{remote_path_for(@package)}'
+            To avoid this, when using more than one Storage, the 'Local' Storage
+            should be added *last* so the files may be *moved* to their destination.
+          EOS
+          @transfer_method = :cp
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/storage/ninefold.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+##
+# Only load the Fog gem when the Backup::Storage::Ninefold class is loaded
+Backup::Dependency.load('fog')
+
+module Backup
+  module Storage
+    class Ninefold < Base
+
+      ##
+      # Ninefold Credentials
+      attr_accessor :storage_token, :storage_secret
+
+      ##
+      # Ninefold directory path
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
+
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+      end
+
+
+      private
+
+      ##
+      # This is the provider that Fog uses for the Ninefold storage
+      def provider
+        'Ninefold'
+      end
+
+      ##
+      # Establishes a connection to Amazon S3
+      def connection
+        @connection ||= Fog::Storage.new(
+          :provider                => provider,
+          :ninefold_storage_token  => storage_token,
+          :ninefold_storage_secret => storage_secret
+        )
+      end
+
+      ##
+      # Queries the connection for the directory for the given +remote_path+
+      # Returns nil if not found, or creates the directory if +create+ is true.
+      def directory_for(remote_path, create = false)
+        directory = connection.directories.get(remote_path)
+        if directory.nil? && create
+          directory = connection.directories.create(:key => remote_path)
+        end
+        directory
+      end
+
+      def remote_path_for(package)
+        super(package).sub(/^\//, '')
+      end
+
+      ##
+      # Transfers the archived file to the specified directory
+      def transfer!
+        remote_path = remote_path_for(@package)
+
+        directory = directory_for(remote_path, true)
+
+        files_to_transfer_for(@package) do |local_file, remote_file|
+          Logger.message "#{storage_name} started transferring '#{ local_file }'."
+
+          File.open(File.join(local_path, local_file), 'r') do |file|
+            directory.files.create(:key => remote_file, :body => file)
+          end
+        end
+      end
+
+      ##
+      # Removes the transferred archive file(s) from the storage location.
+      # Any error raised will be rescued during Cycling
+      # and a warning will be logged, containing the error message.
+      def remove!(package)
+        remote_path = remote_path_for(package)
+
+        if directory = directory_for(remote_path)
+          not_found = []
+
+          transferred_files_for(package) do |local_file, remote_file|
+            Logger.message "#{storage_name} started removing " +
+                "'#{ local_file }' from Ninefold."
+
+            if file = directory.files.get(remote_file)
+              file.destroy
+            else
+              not_found << remote_file
+            end
+          end
+
+          directory.destroy
+
+          unless not_found.empty?
+            raise Errors::Storage::Ninefold::NotFoundError, <<-EOS
+                The following file(s) were not found in '#{ remote_path }'
+                #{ not_found.join("\n") }
+            EOS
+          end
+        else
+          raise Errors::Storage::Ninefold::NotFoundError,
+              "Directory at '#{remote_path}' not found"
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/storage/rsync.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+##
+# Only load the Net::SSH library when the Backup::Storage::RSync class is loaded
+Backup::Dependency.load('net-ssh')
+
+module Backup
+  module Storage
+    class RSync < Base
+      include Backup::CLI::Helpers
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and SSH port
+      attr_accessor :ip, :port
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # Flag to use local backups
+      attr_accessor :local
+
+      ##
+      # Creates a new instance of the storage object
+      def initialize(model, storage_id = nil, &block)
+        super(model, storage_id)
+
+        @port   ||= 22
+        @path   ||= 'backups'
+        @local  ||= false
+
+        instance_eval(&block) if block_given?
+
+        @path = path.sub(/^\~\//, '')
+      end
+
+      private
+
+      ##
+      # This is the remote path to where the backup files will be stored
+      #
+      # Note: This overrides the superclass' method
+      def remote_path_for(package)
+        File.join(path, package.trigger)
+      end
+
+      ##
+      # Establishes a connection to the remote server
+      def connection
+        Net::SSH.start(
+          ip, username, :password => password, :port => port
+        ) {|ssh| yield ssh }
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        write_password_file! unless local
+
+        remote_path = remote_path_for(@package)
+
+        create_remote_path!(remote_path)
+
+        files_to_transfer_for(@package) do |local_file, remote_file|
+          if local
+            Logger.message "#{storage_name} started transferring " +
+                "'#{ local_file }' to '#{ remote_path }'."
+            run(
+              "#{ utility(:rsync) } '#{ File.join(local_path, local_file) }' " +
+              "'#{ File.join(remote_path, remote_file) }'"
+            )
+          else
+            Logger.message "#{storage_name} started transferring " +
+                "'#{ local_file }' to '#{ ip }'."
+            run(
+              "#{ utility(:rsync) } #{ rsync_options } #{ rsync_port } " +
+              "#{ rsync_password_file } '#{ File.join(local_path, local_file) }' " +
+              "'#{ username }@#{ ip }:#{ File.join(remote_path, remote_file) }'"
+            )
+          end
+        end
+
+      ensure
+        remove_password_file! unless local
+      end
+
+      ##
+      # Note: Storage::RSync doesn't cycle
+      def remove!; end
+
+      ##
+      # Creates (if they don't exist yet) all the directories on the remote
+      # server in order to upload the backup file.
+      def create_remote_path!(remote_path)
+        if @local
+          FileUtils.mkdir_p(remote_path)
+        else
+          connection do |ssh|
+            ssh.exec!("mkdir -p '#{ remote_path }'")
+          end
+        end
+      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
+
+      ##
+      # Returns Rsync syntax for using a password file
+      def rsync_password_file
+        "--password-file='#{@password_file.path}'" if @password_file
+      end
+
+      ##
+      # Returns Rsync syntax for defining a port to connect to
+      def rsync_port
+        "-e 'ssh -p #{port}'"
+      end
+
+      ##
+      # RSync options
+      # -z = Compresses the bytes that will be transferred to reduce bandwidth usage
+      def rsync_options
+        "-z"
+      end
+
+    end
+  end
+end