backup 2.4.5.1 → 3.0.0.build.0

data/lib/backup/storage/ftp.rb

@@ -1,38 +1,114 @@
+# 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 < Backup::Storage::Base
-      
-      attr_accessor :user, :password, :ip, :path, :tmp_path, :final_file
-      
-      # Stores the backup file on the remote server using FTP
-      def initialize(adapter)
-        %w(ip user password path).each do |method|
-          send("#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+    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
+
+      ##
+      # Creates a new instance of the FTP 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 ||= 21
+        @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::FTP 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.
+      #
+      # 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 defined? Net::FTP::FTP_PORT
+          Net::FTP.send(:remove_const, :FTP_PORT)
+        end; Net::FTP.send(:const_set, :FTP_PORT, port)
+
+        Net::FTP.new(ip, username, password)
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        Logger.message("#{ self.class } started transferring \"#{ remote_file }\".")
+        create_remote_directories!
+        connection.put(
+          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.delete(
+            File.join(remote_path, remote_file)
+          )
+        rescue Net::FTPPermError
+          Logger.warn "Could not remove file \"#{ File.join(remote_path, remote_file) }\"."
         end
-        
-        final_file = adapter.final_file
-        tmp_path   = adapter.tmp_path
-        
-        Net::FTP.open(ip, user, password) do |ftp|
-          begin
-            ftp.chdir(path)
-          rescue
-            puts "Could not find or access \"#{path}\" on \"#{ip}\", please ensure this directory exists and is accessible by the user \"#{user}\"."
-            exit
-          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 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
-            puts "Storing \"#{final_file}\" to path \"#{path}\" on remote server (#{ip})."
-            ftp.putbinaryfile(File.join(tmp_path, final_file).gsub('\ ', ' '), File.join(path, final_file))
-          rescue
-            puts "Could not save file to backup server. Is the \"#{path}\" directory writable?"
-            exit
-          end
+            connection.mkdir(path_parts.join('/'))
+          rescue Net::FTPPermError; end
         end
       end
-      
+
     end
   end
 end

data/lib/backup/storage/object.rb

@@ -0,0 +1,45 @@
+# 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_file = File.join(DATA_PATH, TRIGGER, "#{type}.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
+        if File.exist?(storage_file)
+          YAML.load_file(storage_file).sort { |a,b| b.time <=> a.time }
+        else
+          []
+        end
+      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/storage/rsync.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+##
+# Only load the Net::SSH library when the Backup::Storage::RSync class is loaded
+require 'net/ssh'
+
+module Backup
+  module Storage
+    class RSync < Base
+      include Backup::CLI
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and SSH port
+      attr_accessor :ip, :port
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the RSync 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!
+      end
+
+    private
+
+      ##
+      # Establishes a connection to the remote server and returns the Net::SSH 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::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!
+        run("#{ utility(:rsync) } #{ options } '#{ File.join(local_path, local_file) }' '#{ username }@#{ ip }:#{ File.join(remote_path, remote_file[20..-1]) }'")
+      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.
+      def create_remote_directories!
+        connection.exec!("mkdir -p '#{ remote_path }'")
+      end
+
+      ##
+      # RSync options
+      # -z     = Compresses the bytes that will be transferred to reduce bandwidth usage
+      # -e     = Allow the usage of SSH remote shell
+      # --port = the port to connect to through SSH
+      # -Phv   = debug options
+      def options
+        "-z -e ssh --port='#{ port }'"
+      end
+
+    end
+  end
+end

data/lib/backup/storage/s3.rb

@@ -1,15 +1,108 @@
-require 'backup/connection/s3'
+# encoding: utf-8
+
+##
+# Only load the Fog gem when the Backup::Storage::S3 class is loaded
+require 'fog'
 
 module Backup
   module Storage
     class S3 < Base
-      
-      # Stores the backup file on the remote server using S3
-      def initialize(adapter)
-        s3 = Backup::Connection::S3.new(adapter)
-        s3.store
+
+      ##
+      # Amazon Simple Storage Service (S3) Credentials
+      attr_accessor :access_key_id, :secret_access_key
+
+      ##
+      # Amazon S3 bucket name and path
+      attr_accessor :bucket, :path
+
+      ##
+      # Region of the specified S3 bucket
+      attr_accessor :region
+
+      ##
+      # Creates a new instance of the Amazon S3 storage object
+      # First it sets the defaults (if any exist) and then evaluates
+      # the configuration block which may overwrite these defaults
+      #
+      # Currently available regions:
+      #   eu-west-1, us-east-1, ap-southeast-1, us-west-1
+      def initialize(&block)
+        load_defaults!
+
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+
+        @path = path.sub(/^\//, '')
+        @time = TIME
+      end
+
+      ##
+      # This is the remote path to where the backup files will be stored
+      def remote_path
+        File.join(path, TRIGGER, '/')
+      end
+
+      ##
+      # This is the provider that Fog uses for the S3 Storage
+      def provider
+        'AWS'
+      end
+
+      ##
+      # Performs the backup transfer
+      def perform!
+        transfer!
+        cycle!
+      end
+
+    private
+
+      ##
+      # Establishes a connection to Amazon S3 and returns the Fog 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
+        Fog::Storage.new(
+          :provider               => provider,
+          :aws_access_key_id      => access_key_id,
+          :aws_secret_access_key  => secret_access_key,
+          :region                 => region
+        )
       end
-      
+
+      ##
+      # Transfers the archived file to the specified Amazon S3 bucket
+      def transfer!
+        begin
+          Logger.message("#{ self.class } started transferring \"#{ remote_file }\".")
+          connection.sync_clock
+          connection.put_object(
+            bucket,
+            File.join(remote_path, remote_file),
+            File.read(File.join(local_path, local_file))
+          )
+        rescue Excon::Errors::SocketError
+          puts "\nAn error occurred while trying to transfer the backup."
+          puts "Make sure the bucket exists, and that you specified the correct bucket region.\n\n"
+          puts "The available regions are:\n\n"
+          puts %w[eu-west-1 us-east-1 ap-southeast-1 us-west-1].map{ |region| "\s\s* #{region}" }.join("\n")
+          exit
+        end
+      end
+
+      ##
+      # Removes the transferred archive file from the Amazon S3 bucket
+      def remove!
+        begin
+          connection.sync_clock
+          connection.delete_object(bucket, File.join(remote_path, remote_file))
+        rescue Excon::Errors::SocketError; end
+      end
+
     end
   end
 end

data/lib/backup/storage/scp.rb

@@ -1,30 +1,105 @@
+# encoding: utf-8
+
+##
+# Only load the Net::SSH and Net::SCP library/gems
+# when the Backup::Storage::SCP class is loaded
+require 'net/ssh'
 require 'net/scp'
 
 module Backup
   module Storage
     class SCP < Base
-      
-      attr_accessor :user, :password, :ip, :path, :tmp_path, :final_file
-      
-      # Stores the backup file on the remote server using SCP
-      def initialize(adapter)
-        %w(ip user password path).each do |method|
-          send("#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
-        end
-        
-        final_file = adapter.final_file
-        tmp_path   = adapter.tmp_path
-        
-        Net::SSH.start(ip, user, :password => password) do |ssh|
-          ssh.exec "mkdir -p #{path}"
+
+      ##
+      # 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
-        
-        puts "Storing \"#{final_file}\" to path \"#{path}\" on remote server (#{ip})."
-        Net::SCP.start(ip, user, :password => password) do |scp|
-          scp.upload! File.join(tmp_path, final_file).gsub('\ ', ' '), path
+      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