alg-backup 3.0.10

data/lib/backup/storage/scp.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+##
+# Only load the Net::SSH and Net::SCP library/gems
+# when the Backup::Storage::SCP class is loaded
+Backup::Dependency.load('net-ssh')
+Backup::Dependency.load('net-scp')
+
+
+module Backup
+  module Storage
+    class SCP < Base
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and SCP port
+      attr_accessor :ip, :port
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the SCP storage object
+      # First it sets the defaults (if any exist) and then evaluates
+      # the configuration block which may overwrite these defaults
+      def initialize(&block)
+        load_defaults!
+
+        @port ||= 22
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+
+        @time = TIME
+        @path = path.sub(/^\~\//, '')
+      end
+
+      ##
+      # This is the remote path to where the backup files will be stored
+      def remote_path
+        File.join(path, TRIGGER)
+      end
+
+      ##
+      # Performs the backup transfer
+      def perform!
+        transfer!
+        cycle!
+      end
+
+    private
+
+      ##
+      # Establishes a connection to the remote server and returns the Net::SCP object.
+      # Not doing any instance variable caching because this object gets persisted in YAML
+      # format to a file and will issues. This, however has no impact on performance since it only
+      # gets invoked once per object for a #transfer! and once for a remove! Backups run in the
+      # background anyway so even if it were a bit slower it shouldn't matter.
+      #
+      # We will be using Net::SSH, and use Net::SCP through Net::SSH to transfer backups
+      def connection
+        Net::SSH.start(ip, username, :password => password, :port => port)
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        Logger.message("#{ self.class } started transferring \"#{ remote_file }\".")
+        create_remote_directories!
+        connection.scp.upload!(
+          File.join(local_path, local_file),
+          File.join(remote_path, remote_file)
+        )
+      end
+
+      ##
+      # Removes the transferred archive file from the server
+      def remove!
+        response = connection.exec!("rm #{ File.join(remote_path, remote_file) }")
+        if response =~ /No such file or directory/
+          Logger.warn "Could not remove file \"#{ File.join(remote_path, remote_file) }\"."
+        end
+      end
+
+      ##
+      # Creates (if they don't exist yet) all the directories on the remote
+      # server in order to upload the backup file. Net::SCP 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::SCP raises an exception when
+      # the directory it's trying ot create already exists, so we have rescue it
+      def create_remote_directories!
+        path_parts = Array.new
+        remote_path.split('/').each do |path_part|
+          path_parts << path_part
+          connection.exec!("mkdir '#{ path_parts.join('/') }'")
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/storage/sftp.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+##
+# Only load the Net::SFTP library/gem when the Backup::Storage::SFTP class is loaded
+Backup::Dependency.load('net-sftp')
+
+module Backup
+  module Storage
+    class SFTP < Base
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and SFTP port
+      attr_accessor :ip, :port
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the SFTP storage object
+      # First it sets the defaults (if any exist) and then evaluates
+      # the configuration block which may overwrite these defaults
+      def initialize(&block)
+        load_defaults!
+
+        @port ||= 22
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+
+        @time = TIME
+        @path = path.sub(/^\~\//, '')
+      end
+
+      ##
+      # This is the remote path to where the backup files will be stored
+      def remote_path
+        File.join(path, TRIGGER)
+      end
+
+      ##
+      # Performs the backup transfer
+      def perform!
+        transfer!
+        cycle!
+      end
+
+    private
+
+      ##
+      # Establishes a connection to the remote server and returns the Net::SFTP object.
+      # Not doing any instance variable caching because this object gets persisted in YAML
+      # format to a file and will issues. This, however has no impact on performance since it only
+      # gets invoked once per object for a #transfer! and once for a remove! Backups run in the
+      # background anyway so even if it were a bit slower it shouldn't matter.
+      def connection
+        Net::SFTP.start(ip, username, :password => password, :port => port)
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        Logger.message("#{ self.class } started transferring \"#{ remote_file }\".")
+        create_remote_directories!
+        connection.upload!(
+          File.join(local_path, local_file),
+          File.join(remote_path, remote_file)
+        )
+      end
+
+      ##
+      # Removes the transferred archive file from the server
+      def remove!
+        begin
+          connection.remove!(
+            File.join(remote_path, remote_file)
+          )
+        rescue Net::SFTP::StatusException
+          Logger.warn "Could not remove file \"#{ File.join(remote_path, remote_file) }\"."
+        end
+      end
+
+      ##
+      # Creates (if they don't exist yet) all the directories on the remote
+      # server in order to upload the backup file. Net::SFTP 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::SFTP raises an exception when
+      # the directory it's trying ot create already exists, so we have rescue it
+      def create_remote_directories!
+        path_parts = Array.new
+        remote_path.split('/').each do |path_part|
+          path_parts << path_part
+          begin
+            connection.mkdir!(path_parts.join('/'))
+          rescue Net::SFTP::StatusException; end
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/syncer/base.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module Backup
+  module Syncer
+    class Base
+      include Backup::CLI
+      include Backup::Configuration::Helpers
+    end
+  end
+end

data/lib/backup/syncer/rsync.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+
+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?
+
+        @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) } -vhP #{ options } #{ directories } '#{ username }@#{ ip }:#{ path }'") )
+      end
+
+      ##
+      # Returns all the specified Rsync options, concatenated, ready for the CLI
+      def options
+        ([archive, mirror, compress, port] + 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
+        "--port='#{@port}'"
+      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
+
+    end
+  end
+end

data/lib/backup/syncer/s3.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+
+module Backup
+  module Syncer
+    class S3 < Base
+
+      ##
+      # Amazon Simple Storage Service (S3) Credentials
+      attr_accessor :access_key_id, :secret_access_key
+
+      ##
+      # Amazon S3 bucket name and path to sync to
+      attr_accessor :bucket, :path
+
+      ##
+      # Directories to sync
+      attr_accessor :directories
+
+      ##
+      # Flag to enable mirroring
+      attr_accessor :mirror
+
+      ##
+      # Additional options for the s3sync cli
+      attr_accessor :additional_options
+
+      ##
+      # 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
+      def initialize(&block)
+        load_defaults!
+
+        @path               ||= 'backups'
+        @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)
+      def perform!
+        set_s3sync_credentials!
+
+        directories.each do |directory|
+          Logger.message("#{ self.class } started syncing '#{ directory }'.")
+          Logger.silent( run("#{ utility(:s3sync) } #{ options } '#{ directory }' '#{ bucket }:#{ path }'") )
+        end
+
+        unset_s3sync_credentials!
+      end
+
+      ##
+      # Returns all the specified S3Sync options, concatenated, ready for the CLI
+      def options
+        ([verbose, recursive, mirror] + additional_options).compact.join("\s")
+      end
+
+      ##
+      # Returns S3Sync syntax for enabling mirroring
+      def mirror
+        '--delete' if @mirror
+      end
+
+      ##
+      # Returns S3Sync syntax for syncing recursively
+      def recursive
+        '--recursive'
+      end
+
+      ##
+      # Returns S3Sync syntax for making output verbose
+      def verbose
+        '--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
+      # evironment variables will be used by S3Sync
+      def set_s3sync_credentials!
+        ENV['AWS_ACCESS_KEY_ID']     = access_key_id
+        ENV['AWS_SECRET_ACCESS_KEY'] = secret_access_key
+      end
+
+      ##
+      # Sets the AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY back to nil
+      def unset_s3sync_credentials!
+        ENV['AWS_ACCESS_KEY_ID']     = nil
+        ENV['AWS_SECRET_ACCESS_KEY'] = nil
+      end
+
+    end
+  end
+end