dmitryv-backup 2.4.0

data/lib/backup/mail/mail.txt

@@ -0,0 +1,7 @@
+A backup was successfully created for the trigger: ":trigger"!
+
+The backup was created on ":day of :month :year at :time", using the ":adapter" adapter.
+
+The Backup was stored in ":location" :remote.
+
+The following backup was stored: ":backup"

data/lib/backup/record/base.rb

@@ -0,0 +1,65 @@
+module Backup
+  module Record
+    class Base < ActiveRecord::Base
+      
+      if DB_CONNECTION_SETTINGS
+        establish_connection(DB_CONNECTION_SETTINGS)
+      end
+      
+      set_table_name 'backup'
+      
+      default_scope :order => 'created_at desc'
+
+      # Callbacks
+      after_save :clean_backups
+      
+      # Attributes
+      attr_accessor :adapter_config, :keep_backups
+      
+      # Receives the options hash and stores it
+      def load_adapter(adapter)
+        self.adapter_config = adapter
+        self.trigger        = adapter.procedure.trigger
+        self.adapter        = adapter.procedure.adapter_name.to_s
+        self.filename       = adapter.final_file
+        self.keep_backups   = adapter.procedure.attributes['keep_backups']
+        
+        # TODO calculate md5sum of file
+        load_specific_settings(adapter) if respond_to?(:load_specific_settings)
+      end
+      
+      # Destroys all backups for the specified trigger from Remote Server (FTP)
+      def self.destroy_all_backups(procedure, trigger)
+        backups = self.all(:conditions => {:trigger => trigger})
+        unless backups.empty?
+          # Derived classes must implement this method!
+          self.destroy_backups(procedure, backups)
+          
+          puts "\nAll \"#{procedure.trigger}\" backups destroyed.\n\n"
+        end
+      end
+      
+      private
+      
+        # Maintains the backup file amount on the remote server
+        # This is invoked after a successful record save
+        # This deletes the oldest files when the backup limit has been exceeded
+        def clean_backups
+          if keep_backups.is_a?(Integer)
+            backups = self.class.all(:conditions => {:trigger => trigger})
+            backups_to_destroy = backups[keep_backups, backups.size] || []
+            
+            unless backups_to_destroy.empty?
+              # Derived classes must implement this method!
+              self.class.destroy_backups(adapter_config.procedure, backups_to_destroy)
+              
+              puts "\nBackup storage for \"#{trigger}\" is limited to #{keep_backups} backups."
+              puts "\nThe #{keep_backups} most recent backups are now stored on the remote server.\n\n"
+            end
+          end
+        end
+        
+    end
+  end
+end
+

data/lib/backup/record/cloudfiles.rb

@@ -0,0 +1,28 @@
+require 'backup/connection/cloudfiles'
+
+module Backup
+  module Record
+    class CloudFiles < Backup::Record::Base
+
+      alias_attribute :container, :bucket
+
+      def load_specific_settings(adapter)
+        self.container = adapter.procedure.get_storage_configuration.attributes['container']
+      end
+
+      private
+
+        def self.destroy_backups(procedure, backups)
+          cf = Backup::Connection::CloudFiles.new
+          cf.static_initialize(procedure)
+          cf.connect
+          backups.each do |backup|
+            puts "\nDestroying backup \"#{backup.filename}\" from container \"#{backup.container}\"."
+            cf.destroy(backup.filename, backup.container)
+            backup.destroy
+          end
+        end
+
+    end
+  end
+end

data/lib/backup/record/ftp.rb

@@ -0,0 +1,39 @@
+require 'net/ftp'
+
+module Backup
+  module Record
+    class FTP < Backup::Record::Base
+      
+      attr_accessor :ip, :user, :password
+      
+      def load_specific_settings(adapter)
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          ip        = procedure.get_storage_configuration.attributes['ip']
+          user      = procedure.get_storage_configuration.attributes['user']
+          password  = procedure.get_storage_configuration.attributes['password']
+
+          Net::FTP.open(ip, user, password) do |ftp|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              begin
+                ftp.chdir(backup.path)
+                ftp.delete(backup.filename)
+                backup.destroy
+              rescue
+                puts "Could not find backup #{backup.path}/#{backup.filename}."
+                backup.destroy
+              end
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/record/local.rb

@@ -0,0 +1,26 @@
+module Backup
+  module Record
+    class Local < Backup::Record::Base
+      
+      def load_specific_settings(adapter)
+        self.path = adapter.procedure.get_storage_configuration.attributes['path']
+      end
+      
+      private
+        
+        class << self
+          include Backup::CommandHelper
+        
+          def destroy_backups(procedure, backups)
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              run "rm #{File.join(backup.path, backup.filename)}"
+              backup.destroy
+            end
+          end
+        end
+        
+    end
+  end
+end
+

data/lib/backup/record/s3.rb

@@ -0,0 +1,26 @@
+require 'backup/connection/s3'
+
+module Backup
+  module Record
+    class S3 < Backup::Record::Base
+      
+      def load_specific_settings(adapter)
+        self.bucket = adapter.procedure.get_storage_configuration.attributes['bucket']
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          s3 = Backup::Connection::S3.new
+          s3.static_initialize(procedure)
+          s3.connect
+          backups.each do |backup|
+            puts "\nDestroying backup \"#{backup.filename}\" from bucket \"#{backup.bucket}\"."
+            s3.destroy(backup.filename, backup.bucket)
+            backup.destroy
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/record/scp.rb

@@ -0,0 +1,33 @@
+require 'net/scp'
+
+module Backup
+  module Record
+    class SCP < Backup::Record::Base
+
+      attr_accessor :ip, :user, :password
+      
+      def load_specific_settings(adapter)
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          ip        = procedure.get_storage_configuration.attributes['ip']
+          user      = procedure.get_storage_configuration.attributes['user']
+          password  = procedure.get_storage_configuration.attributes['password']
+          
+          Net::SSH.start(ip, user, :password => password) do |ssh|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              ssh.exec("rm #{File.join(backup.path, backup.filename)}")
+              backup.destroy
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/record/sftp.rb

@@ -0,0 +1,38 @@
+require 'net/sftp'
+
+module Backup
+  module Record
+    class SFTP < Backup::Record::Base
+
+      attr_accessor :ip, :user, :password
+      
+      def load_specific_settings(adapter)
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          ip        = procedure.get_storage_configuration.attributes['ip']
+          user      = procedure.get_storage_configuration.attributes['user']
+          password  = procedure.get_storage_configuration.attributes['password']
+          
+          Net::SFTP.start(ip, user, :password => password) do |sftp|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              begin
+                sftp.remove!(File.join(backup.path, backup.filename))
+                backup.destroy
+              rescue
+                puts "Could not find backup #{backup.path}/#{backup.filename}.."
+                backup.destroy
+              end
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/storage/base.rb

@@ -0,0 +1,10 @@
+module Backup
+  module Storage
+    class Base
+      include Backup::CommandHelper
+
+    end
+  end
+end
+
+

data/lib/backup/storage/cloudfiles.rb

@@ -0,0 +1,16 @@
+require 'backup/connection/cloudfiles'
+
+module Backup
+  module Storage
+    class CloudFiles < Base
+
+      # Stores the backup file on the remote server using Rackspace Cloud Files
+      def initialize(adapter)
+        cf = Backup::Connection::CloudFiles.new(adapter)
+        cf.connect
+        cf.store
+      end
+
+    end
+  end
+end

data/lib/backup/storage/ftp.rb

@@ -0,0 +1,38 @@
+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])
+        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
+          
+          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
+        end
+      end
+      
+    end
+  end
+end

data/lib/backup/storage/local.rb

@@ -0,0 +1,22 @@
+module Backup
+  module Storage
+    class Local < Base
+      
+      # Store on same machine, preferentially in a different hard drive or in 
+      # a mounted network path (NFS, Samba, etc)
+      attr_accessor :path, :tmp_path, :final_file
+      
+      # Stores the backup file on local machine
+      def initialize(adapter)
+        self.path = adapter.procedure.get_storage_configuration.attributes['path']
+        self.tmp_path   = adapter.tmp_path
+        self.final_file = adapter.final_file
+        
+        run "mkdir -p #{path}"
+        run "cp #{File.join(tmp_path, final_file).gsub('\ ', ' ')} #{File.join(path, final_file)}"
+      end
+      
+    end
+  end
+end
+

data/lib/backup/storage/s3.rb

@@ -0,0 +1,17 @@
+require 'backup/connection/s3'
+
+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.connect
+        log("Saving '#{s3.final_file}' to s3 bucket '#{s3.s3_bucket}'")
+        s3.store
+      end
+      
+    end
+  end
+end

data/lib/backup/storage/scp.rb

@@ -0,0 +1,30 @@
+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}"
+        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
+      end
+      
+    end
+  end
+end

data/lib/backup/storage/sftp.rb

@@ -0,0 +1,31 @@
+require 'net/sftp'
+
+module Backup
+  module Storage
+    class SFTP < Base
+      
+      attr_accessor :user, :password, :ip, :path, :tmp_path, :final_file
+      
+      # Stores the backup file on the remote server using SFTP
+      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::SFTP.start(ip, user, :password => password) do |sftp|
+          begin
+            puts "Storing \"#{final_file}\" to path \"#{path}\" on remote server (#{ip})."
+            sftp.upload!(File.join(tmp_path, final_file).gsub('\ ', ' '), File.join(path, final_file))
+          rescue
+            puts "Could not find \"#{path}\" on \"#{ip}\", please ensure this directory exists."
+            exit
+          end
+        end
+      end
+      
+    end
+  end
+end