backup 2.1.2 → 2.2.0

data/generators/backup/templates/tasks/backup.rake

@@ -9,8 +9,10 @@ namespace :backup do
   task :truncate => :environment do
     backup = Backup::Setup.new(ENV['trigger'], @backup_procedures)
     case backup.procedure.storage_name.to_sym
-      when :s3  then Backup::Record::S3.destroy_all(:trigger => ENV['trigger'], :storage => 's3')
-      when :scp then Backup::Record::SCP.destroy_all(:trigger => ENV['trigger'], :storage => 'scp')
+      when :s3    then Backup::Record::S3.destroy_all   :trigger => ENV['trigger'], :storage => 's3'
+      when :scp   then Backup::Record::SCP.destroy_all  :trigger => ENV['trigger'], :storage => 'scp'
+      when :ftp   then Backup::Record::FTP.destroy_all  :trigger => ENV['trigger'], :storage => 'ftp'
+      when :sftp  then Backup::Record::SFTP.destroy_all :trigger => ENV['trigger'], :storage => 'sftp'
     end
   end
   
@@ -18,23 +20,30 @@ namespace :backup do
   task :truncate_all => :environment do
     Backup::Record::S3.destroy_all
     Backup::Record::SCP.destroy_all
+    Backup::Record::FTP.destroy_all
+    Backup::Record::SFTP.destroy_all
   end
   
   desc "Destroys all records for the specified \"trigger\", including the physical files on s3 or the remote server."
   task :destroy => :environment do
     backup = Backup::Setup.new(ENV['trigger'], @backup_procedures)
     case backup.procedure.storage_name.to_sym
-      when :s3  then Backup::Record::S3.destroy_all_backups(backup.procedure, ENV['trigger'])
-      when :scp then Backup::Record::SCP.destroy_all_backups(backup.procedure, ENV['trigger'])
+      when :s3    then Backup::Record::S3.destroy_all_backups   backup.procedure,  ENV['trigger']
+      when :scp   then Backup::Record::SCP.destroy_all_backups  backup.procedure,  ENV['trigger']
+      when :ftp   then Backup::Record::FTP.destroy_all_backups  backup.procedure,  ENV['trigger']
+      when :sftp  then Backup::Record::SFTP.destroy_all_backups backup.procedure,  ENV['trigger']
     end
   end
   
   desc "Destroys all records for the specified \"trigger\", including the physical files on s3 or the remote server."
   task :destroy_all => :environment do
-    @backup_procedures.each do |backup_procedure|
+    backup = Backup::Setup.new(false, @backup_procedures)
+    backup.procedures.each do |backup_procedure|
       case backup_procedure.storage_name.to_sym
-        when :s3  then Backup::Record::S3.destroy_all_backups(backup_procedure, backup_procedure.trigger)
-        when :scp then Backup::Record::SCP.destroy_all_backups(backup_procedure, backup_procedure.trigger)
+        when :s3    then Backup::Record::S3.destroy_all_backups     backup_procedure,  backup_procedure.trigger
+        when :scp   then Backup::Record::SCP.destroy_all_backups    backup_procedure,  backup_procedure.trigger
+        when :ftp   then Backup::Record::FTP.destroy_all_backups    backup_procedure,  backup_procedure.trigger
+        when :sftp  then Backup::Record::SFTP.destroy_all_backups   backup_procedure,  backup_procedure.trigger
       end
     end
   end

data/lib/backup.rb

@@ -1,12 +1,16 @@
 # Load in Connectivity and Transfer Gems
 require 'net/ssh'
 require 'net/scp'
+require 'net/ftp'
+require 'net/sftp'
 require 'aws/s3'
 
 # Load in Adapters
 require 'backup/adapters/base'
 require 'backup/adapters/mysql'
+require 'backup/adapters/postgresql'
 require 'backup/adapters/archive'
+require 'backup/adapters/custom'
 
 # Load in Connectors
 require 'backup/connection/s3'
@@ -14,14 +18,19 @@ require 'backup/connection/s3'
 # Load in Storage
 require 'backup/storage/s3'
 require 'backup/storage/scp'
+require 'backup/storage/ftp'
+require 'backup/storage/sftp'
 
 # Load in Backup Recorders
 require 'backup/record/s3'
 require 'backup/record/scp'
+require 'backup/record/ftp'
+require 'backup/record/sftp'
 
 # Load in Configuration
 require 'backup/configuration/base'
 require 'backup/configuration/adapter'
+require 'backup/configuration/adapter_options'
 require 'backup/configuration/storage'
 require 'backup/configuration/helpers'
 
@@ -38,21 +47,30 @@ module Backup
   class Setup
   
     attr_accessor :trigger, :procedures, :procedure
-  
+    
+    # Sets the Trigger and All Available Procedures.
+    # Will not find a specific procedure if the "trigger" argument is set to false.
     def initialize(trigger, procedures)
       self.trigger    = trigger
       self.procedures = procedures
-      self.procedure  = find_triggered_procedure
+      self.procedure  = find_triggered_procedure unless trigger.eql?(false)
     end
     
+    # Initializes one of the few adapters and start the backup process
     def initialize_adapter
       case procedure.adapter_name.to_sym
-        when :mysql   then Backup::Adapters::MySQL.new(trigger, procedure)
-        when :archive then Backup::Adapters::Archive.new(trigger, procedure)
-        else raise "Unknown Adapter: \"#{procedure.adapter_name}\""
+        when :mysql       then Backup::Adapters::MySQL.new      trigger, procedure
+        when :postgresql  then Backup::Adapters::PostgreSQL.new trigger, procedure
+        when :archive     then Backup::Adapters::Archive.new    trigger, procedure
+        when :custom      then Backup::Adapters::Custom.new     trigger, procedure
+        else raise "Unknown Adapter: \"#{procedure.adapter_name}\"."
       end
     end
-    
+  
+    # Scans through all the backup settings and returns the backup setting
+    # that was specified in the "trigger" argument.
+    # If an non-existing trigger is specified, it will raise an error and display
+    # all the available triggers.
     def find_triggered_procedure
       procedures.each do |procedure|
         if procedure.trigger.eql?(trigger)

data/lib/backup/adapters/archive.rb

@@ -2,18 +2,32 @@ module Backup
   module Adapters
     class Archive < Backup::Adapters::Base
       
-      attr_accessor :archived_file, :compressed_file, :encrypted_file, :user, :password, :database
+      attr_accessor :archived_file, :compressed_file, :encrypted_file
       
       # Initializes the Backup Process
+      # 
+      # This will first load in any prefixed settings from the Backup::Adapters::Base
+      # Then it will add it's own settings.
+      # 
+      # First it will archive and compress every folder/file
+      # Then it will optionally encrypt the backed up file
+      # Then it will store it to the specified storage location
+      # Then it will record the data to the database
+      # Once this is all done, all the temporary files will be removed
+      # 
+      # Wrapped inside of begin/ensure/end block to ensure the deletion of any files in the tmp directory
       def initialize(trigger, procedure)
         super
         load_settings
         
-        targz
-        encrypt
-        store
-        record
-        remove_tmp_files
+        begin
+          targz
+          encrypt
+          store
+          record
+        ensure
+          remove_tmp_files
+        end
       end
       
       private
@@ -38,11 +52,9 @@ module Backup
         
         # Loads the initial settings
         def load_settings
-          self.user     = procedure.get_adapter_configuration.attributes['user']
-          self.password = procedure.get_adapter_configuration.attributes['password']
-          self.database = procedure.get_adapter_configuration.attributes['database']
+          self.trigger  = procedure.trigger
 
-          self.archived_file    = "#{timestamp}.archive.#{trigger.gsub(' ', '-')}.tar"      
+          self.archived_file    = "#{timestamp}.#{trigger.gsub(' ', '-')}.tar"      
           self.compressed_file  = "#{archived_file}.gz"
           self.encrypted_file   = "#{compressed_file}.enc"
           self.final_file       = compressed_file

data/lib/backup/adapters/base.rb

@@ -19,7 +19,7 @@ module Backup
         self.trigger                = trigger
         self.procedure              = procedure
         self.timestamp              = Time.now.strftime("%Y%m%d%H%M%S")
-        self.tmp_path               = "#{RAILS_ROOT.gsub(' ', '\ ')}/tmp/backup/#{procedure.adapter_name}"
+        self.tmp_path               = File.join(RAILS_ROOT.gsub(' ', '\ '), 'tmp', 'backup', trigger)
         self.encrypt_with_password  = procedure.attributes['encrypt_with_password']
         self.keep_backups           = procedure.attributes['keep_backups']
         create_tmp_folder
@@ -32,21 +32,25 @@ module Backup
 
       # Removes the files inside the temporary folder
       def remove_tmp_files
-        %x{ rm #{tmp_path}/* }
+        %x{ rm #{File.join(tmp_path, '*')} }
       end
 
       # Initializes the storing process depending on the store settings
       # Options:
       #  Amazon (S3)
       #  Remote Server (SCP)
+      #  Remote Server (FTP)
+      #  Remote Server (SFTP)
       def store
         case procedure.storage_name.to_sym
           when :s3  then Backup::Storage::S3.new(self)
           when :scp then Backup::Storage::SCP.new(self)
+          when :ftp then Backup::Storage::FTP.new(self)
+          when :sftp then Backup::Storage::SFTP.new(self)
         end
       end
       
-      # Records data on every individual file to the backup.sqlite3 local database
+      # Records data on every individual file to the database
       def record
         case procedure.storage_name.to_sym
           when :s3
@@ -57,6 +61,14 @@ module Backup
             record = Backup::Record::SCP.new
             record.load_adapter(self)
             record.save
+          when :ftp
+            record = Backup::Record::FTP.new
+            record.load_adapter(self)
+            record.save
+          when :sftp
+            record = Backup::Record::SFTP.new
+            record.load_adapter(self)
+            record.save
         end
       end
       

data/lib/backup/adapters/custom.rb

@@ -0,0 +1,74 @@
+module Backup
+  module Adapters
+    class Custom < Backup::Adapters::Base
+      
+      attr_accessor :archived_file, :compressed_file, :encrypted_file, :commands
+      
+      # Initializes the Backup Process
+      # 
+      # This will first load in any prefixed settings from the Backup::Adapters::Base
+      # Then it will add it's own settings.
+      # 
+      # First it will execute any given commands
+      # Then it will archive and compress every folder/file
+      # Then it will optionally encrypt the backed up file
+      # Then it will store it to the specified storage location
+      # Then it will record the data to the database
+      # Once this is all done, all the temporary files will be removed
+      # 
+      # Wrapped inside of begin/ensure/end block to ensure the deletion of any files in the tmp directory
+      def initialize(trigger, procedure)
+        super
+        load_settings
+        
+        begin
+          execute_commands
+          targz
+          encrypt
+          store
+          record
+        ensure
+          remove_tmp_files
+        end
+      end
+      
+      private
+        
+        # Executes the commands
+        def execute_commands
+          if commands.is_a?(Array)
+            commands.each do |command|
+              %x{ #{command.gsub(':tmp_path', tmp_path)} }
+            end
+          elsif commands.is_a?(String)
+            %x{ #{commands.gsub(':tmp_path', tmp_path)} }
+          end
+        end
+        
+        # Archives and Compresses
+        def targz
+          %x{ tar -czf #{File.join(tmp_path, compressed_file)} #{File.join(tmp_path, '*')} }
+        end
+        
+        # Encrypts the archive file
+        def encrypt
+          if encrypt_with_password.is_a?(String)
+            %x{ openssl enc -des-cbc -in #{File.join(tmp_path, compressed_file)} -out #{File.join(tmp_path, encrypted_file)} -k #{encrypt_with_password} }
+            self.final_file = encrypted_file
+          end
+        end
+        
+        # Loads the initial settings
+        def load_settings
+          self.trigger  = procedure.trigger
+          self.commands = procedure.get_adapter_configuration.attributes['commands']
+          
+          self.archived_file    = "#{timestamp}.#{trigger.gsub(' ', '-')}.tar"      
+          self.compressed_file  = "#{archived_file}.gz"
+          self.encrypted_file   = "#{compressed_file}.enc"
+          self.final_file       = compressed_file
+        end
+                
+    end
+  end
+end

data/lib/backup/adapters/mysql.rb

@@ -2,25 +2,39 @@ module Backup
   module Adapters
     class MySQL < Backup::Adapters::Base
       
-      attr_accessor :dumped_file, :compressed_file, :encrypted_file, :user, :password, :database
+      attr_accessor :dumped_file, :compressed_file, :encrypted_file, :user, :password, :database, :skip_tables, :host, :port, :socket
       
       # Initializes the Backup Process
+      # 
+      # This will first load in any prefixed settings from the Backup::Adapters::Base
+      # Then it will add it's own settings.
+      # 
+      # First it will create a compressed MySQL dump 
+      # Then it will optionally encrypt the backed up file
+      # Then it will store it to the specified storage location
+      # Then it will record the data to the database
+      # Once this is all done, all the temporary files will be removed
+      # 
+      # Wrapped inside of begin/ensure/end block to ensure the deletion of any files in the tmp directory
       def initialize(trigger, procedure)
         super
         load_settings
         
-        mysqldump
-        encrypt
-        store
-        record
-        remove_tmp_files
+        begin
+          mysqldump
+          encrypt
+          store
+          record
+        ensure
+          remove_tmp_files
+        end
       end
       
       private
         
         # Dumps and Compresses the MySQL file 
         def mysqldump
-          %x{ mysqldump -u #{user} --password='#{password}' #{database} | gzip -f --best > #{File.join(tmp_path, compressed_file)} }
+          %x{ mysqldump  -u #{user}  --password='#{password}' #{options} #{database} #{tables_to_skip} | gzip -f --best > #{File.join(tmp_path, compressed_file)} }
         end
         
         # Encrypts the MySQL file
@@ -33,16 +47,42 @@ module Backup
         
         # Loads the initial settings
         def load_settings
-          self.user     = procedure.get_adapter_configuration.attributes['user']
-          self.password = procedure.get_adapter_configuration.attributes['password']
-          self.database = procedure.get_adapter_configuration.attributes['database']
+          self.trigger  = procedure.trigger
+          
+          %w(user password database skip_tables).each do |attribute|
+            send(:"#{attribute}=", procedure.get_adapter_configuration.attributes[attribute])
+          end
+          
+          %w(host port socket).each do |attribute|
+            send(:"#{attribute}=", procedure.get_adapter_configuration.get_options.attributes[attribute])
+          end
 
-          self.dumped_file      = "#{timestamp}.#{database}.sql"      
+          self.dumped_file      = "#{timestamp}.#{trigger.gsub(' ', '-')}.sql"      
           self.compressed_file  = "#{dumped_file}.gz"
           self.encrypted_file   = "#{compressed_file}.enc"
           self.final_file       = compressed_file
         end
         
+        # Returns a list of options in MySQL syntax
+        def options
+          options = String.new
+          options += " --host='#{host}' "     unless host.blank?
+          options += " --port='#{port}' "     unless port.blank?
+          options += " --socket='#{socket}' " unless socket.blank?
+          options
+        end
+        
+        # Returns a list of tables to skip in MySQL syntax
+        def tables_to_skip
+          if skip_tables.is_a?(Array)
+            skip_tables.map {|table| " --ignore-table='#{database}.#{table}' "}
+          elsif skip_tables.is_a?(String)
+            " --ignore-table='#{database}.#{skip_tables}' "
+          else
+            ""
+          end
+        end
+                
     end
   end
 end

data/lib/backup/adapters/postgresql.rb

@@ -0,0 +1,88 @@
+module Backup
+  module Adapters
+    class PostgreSQL < Backup::Adapters::Base
+
+      attr_accessor :dumped_file, :compressed_file, :encrypted_file, :user, :password, :database, :skip_tables, :host, :port, :socket
+      
+      # Initializes the Backup Process
+      # 
+      # This will first load in any prefixed settings from the Backup::Adapters::Base
+      # Then it will add it's own settings.
+      # 
+      # First it will create a compressed PostgreSQL dump 
+      # Then it will optionally encrypt the backed up file
+      # Then it will store it to the specified storage location
+      # Then it will record the data to the database
+      # Once this is all done, all the temporary files will be removed
+      # 
+      # Wrapped inside of begin/ensure/end block to ensure the deletion of any files in the tmp directory
+      def initialize(trigger, procedure)
+        super
+        load_settings
+
+        begin
+          pg_dump
+          encrypt
+          store
+          record
+        ensure
+          remove_tmp_files
+        end
+      end
+      
+      private
+        
+        # Dumps and Compresses the PostgreSQL file 
+        def pg_dump
+           %x{ pg_dump  -U #{user} #{options} #{tables_to_skip} #{database} | gzip -f --best > #{File.join(tmp_path, compressed_file)} }
+        end
+        
+        # Encrypts the PostgreSQL file
+        def encrypt
+          if encrypt_with_password.is_a?(String)
+            %x{ openssl enc -des-cbc -in #{File.join(tmp_path, compressed_file)} -out #{File.join(tmp_path, encrypted_file)} -k #{encrypt_with_password} }
+            self.final_file = encrypted_file
+          end
+        end
+        
+        # Loads the initial settings
+        def load_settings
+          self.trigger  = procedure.trigger
+          
+          %w(user password database skip_tables).each do |attribute|
+            send(:"#{attribute}=", procedure.get_adapter_configuration.attributes[attribute])
+          end
+          
+          %w(host port socket).each do |attribute|
+            send(:"#{attribute}=", procedure.get_adapter_configuration.get_options.attributes[attribute])
+          end
+
+          self.dumped_file      = "#{timestamp}.#{trigger.gsub(' ', '-')}.sql"      
+          self.compressed_file  = "#{dumped_file}.gz"
+          self.encrypted_file   = "#{compressed_file}.enc"
+          self.final_file       = compressed_file
+        end
+        
+        # Returns a list of options in PostgreSQL syntax
+        def options
+          options = String.new
+          options += " --port='#{port}' "     unless port.blank?
+          options += " --host='#{host}' "     unless host.blank?
+          options += " --host='#{socket}' "   unless socket.blank?  unless options.include?('--host=')
+          options
+        end
+        
+        # Returns a list of tables to skip in PostgreSQL syntax
+        def tables_to_skip
+          if skip_tables.is_a?(Array)
+            skip_tables.map {|table| " -T \"#{table}\" "}
+          elsif skip_tables.is_a?(String)
+            " -T \"#{skip_tables}\" "
+          else
+            ""
+          end
+        end
+
+    end
+  end
+end