backup 2.3.1 → 2.3.2.pre

data/generators/backup/templates/migrations/create_backup_tables.rb

@@ -1,12 +1,13 @@
 class CreateBackupTables < ActiveRecord::Migration
   def self.up
     create_table :backup do |t|
-      t.string :storage
       t.string :trigger
       t.string :adapter
       t.string :filename
+      t.string :md5sum
       t.string :path
       t.string :bucket
+      t.string :type
       t.timestamps          
     end
   end
@@ -14,4 +15,4 @@ class CreateBackupTables < ActiveRecord::Migration
   def self.down
     drop_table :backup
   end
-end
+end

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

@@ -12,10 +12,11 @@ namespace :backup do
     backup = Backup::Setup.new(ENV['trigger'], @backup_procedures)
     records = Array.new
     case backup.procedure.storage_name.to_sym
-      when :s3    then records = Backup::Record::S3.all   :conditions => {:trigger => ENV['trigger']}
-      when :scp   then records = Backup::Record::SCP.all  :conditions => {:trigger => ENV['trigger']}
-      when :ftp   then records = Backup::Record::FTP.all  :conditions => {:trigger => ENV['trigger']}
-      when :sftp  then records = Backup::Record::SFTP.all :conditions => {:trigger => ENV['trigger']}
+      when :s3    then records = Backup::Record::S3.all    :conditions => {:trigger => ENV['trigger']}
+      when :scp   then records = Backup::Record::SCP.all   :conditions => {:trigger => ENV['trigger']}
+      when :ftp   then records = Backup::Record::FTP.all   :conditions => {:trigger => ENV['trigger']}
+      when :sftp  then records = Backup::Record::SFTP.all  :conditions => {:trigger => ENV['trigger']}
+      when :local then records = Backup::Record::Local.all :conditions => {:trigger => ENV['trigger']}
     end
     
     if ENV['table'].eql?("true")
@@ -30,19 +31,13 @@ namespace :backup do
   desc "Truncates all records for the specified \"trigger\", excluding the physical files on s3 or the remote server."
   task :truncate => :environment do
     puts "Truncating backup records with trigger: #{ENV['trigger']}."
-    Backup::Record::S3.destroy_all    :trigger => ENV['trigger'], :storage => 's3'
-    Backup::Record::SCP.destroy_all   :trigger => ENV['trigger'], :storage => 'scp'
-    Backup::Record::FTP.destroy_all   :trigger => ENV['trigger'], :storage => 'ftp'
-    Backup::Record::SFTP.destroy_all  :trigger => ENV['trigger'], :storage => 'sftp'
+    Backup::Record::Base.destroy_all :trigger => ENV['trigger']
   end
   
   desc "Truncates everything."
   task :truncate_all => :environment do
     puts "Truncating all backup records."
-    Backup::Record::S3.destroy_all
-    Backup::Record::SCP.destroy_all
-    Backup::Record::FTP.destroy_all
-    Backup::Record::SFTP.destroy_all
+    Backup::Record::Base.destroy_all
   end
   
   desc "Destroys all records for the specified \"trigger\", including the physical files on s3 or the remote server."
@@ -50,10 +45,11 @@ namespace :backup do
     puts "Destroying backup records with trigger: #{ENV['trigger']}."
     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 :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']
+      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']
+      when :local then Backup::Record::Local.destroy_all_backups backup.procedure,  ENV['trigger']
     end
   end
   
@@ -67,8 +63,9 @@ namespace :backup do
         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
+        when :local then Backup::Record::Local.destroy_all_backups  backup_procedure,  backup_procedure.trigger
       end
     end
   end
   
-end
+end

data/generators/backup_update/backup_update_generator.rb

@@ -0,0 +1,50 @@
+class BackupUpdateGenerator < Rails::Generator::Base
+
+  # This method gets initialized when the generator gets run.
+  # It will receive an array of arguments inside @args
+  def initialize(runtime_args, runtime_options = {})
+    super
+  end
+  
+  # Processes the file generation/templating
+  # This will automatically be run after the initialize method
+  def manifest
+    record do |m|
+      
+      # Generates the database update migration file
+      m.migration_template                    "migrations/update_backup_tables.rb",
+                                              "db/migrate",
+                                              :migration_file_name => "update_backup_tables"
+      
+      # Outputs the generators message to the terminal
+      puts message
+    end
+  end
+  
+  def message
+    <<-MESSAGE
+    
+    
+    
+    ==============================================================
+    Backup's update files have been generated!
+    ==============================================================
+    
+    Please follow these instructions Backup:
+    
+    1: Please migrate the database to finish the update!
+
+      rake db:migrate
+    
+    
+    For More Information:
+    http://github.com/meskyanichi/backup
+    
+    ==============================================================
+    
+    
+    
+    MESSAGE
+  end
+  
+end

data/generators/backup_update/templates/migrations/update_backup_tables.rb

@@ -0,0 +1,27 @@
+class UpdateBackupTables < ActiveRecord::Migration
+  def self.up
+    change_table :backup do |t|
+      t.rename :storage, :type # will use STI from now
+      t.string :md5sum
+    end
+    
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::FTP' WHERE type='ftp'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::Local' WHERE type='local'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::S3' WHERE type='s3'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::SCP' WHERE type='scp'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::SFTP' WHERE type='sftp'"
+  end
+
+  def self.down
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='ftp' WHERE type='Backup::Record::FTP'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='local' WHERE type='Backup::Record::Local'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='s3' WHERE type='Backup::Record::S3'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='scp' WHERE type='Backup::Record::SCP'"
+    ActiveRecord::Base.connection.execute "UPDATE backup SET type='sftp' WHERE type='Backup::Record::SFTP'"
+    
+    change_table :backup do |t|
+      t.rename :type, :storage
+      t.remove :md5sum
+    end
+  end
+end

data/lib/backup.rb

@@ -1,10 +1,4 @@
 # Load Gems
-require 'net/ssh'
-require 'net/scp'
-require 'net/ftp'
-require 'net/sftp'
-require 'aws/s3'
-require 'pony'
 require 'hirb'
 
 # Load Environments
@@ -13,6 +7,7 @@ require 'backup/environment/unix'
 require 'backup/environment/rails'
 
 # Load Configuration
+require 'backup/configuration/attributes'
 require 'backup/configuration/base'
 require 'backup/configuration/adapter'
 require 'backup/configuration/adapter_options'
@@ -21,7 +16,9 @@ require 'backup/configuration/mail'
 require 'backup/configuration/smtp'
 require 'backup/configuration/helpers'
 
-# Include the Configuration adn Environment Helpers  
+require 'backup/command_helper'
+
+# Include the Configuration and Environment Helpers
 include Backup::Configuration::Helpers
 include Backup::Environment::Base
 
@@ -42,31 +39,34 @@ require 'backup/mail/base'
 # Set Mail Configuration (extracted from the backup.rb configuration file) inside the Mail Class
 Backup::Mail::Base.setup(@mail_configuration)
 
-# Load Adapters
-require 'backup/adapters/base'
-require 'backup/adapters/mysql'
-require 'backup/adapters/postgresql'
-require 'backup/adapters/archive'
-require 'backup/adapters/custom'
-
-# Load Connectors
-require 'backup/connection/s3'
-
-# Load Storage
-require 'backup/storage/s3'
-require 'backup/storage/scp'
-require 'backup/storage/ftp'
-require 'backup/storage/sftp'
+# Backup Module
+module Backup
+  module Adapters
+    autoload :Base,       'backup/adapters/base'
+    autoload :MySQL,      'backup/adapters/mysql'
+    autoload :SQLite,     'backup/adapters/sqlite'
+    autoload :PostgreSQL, 'backup/adapters/postgresql'
+    autoload :Archive,    'backup/adapters/archive'
+    autoload :Custom,     'backup/adapters/custom'
+  end
 
-# Backup Recorders
-require 'backup/record/s3'
-require 'backup/record/scp'
-require 'backup/record/ftp'
-require 'backup/record/sftp'
+  module Storage
+    autoload :S3,    'backup/storage/s3'
+    autoload :SCP,   'backup/storage/scp'
+    autoload :FTP,   'backup/storage/ftp'
+    autoload :SFTP,  'backup/storage/sftp'
+    autoload :Local, 'backup/storage/local'
+  end
 
+  module Record
+    autoload :Base,  'backup/record/base'
+    autoload :S3,    'backup/record/s3'
+    autoload :SCP,   'backup/record/scp'
+    autoload :FTP,   'backup/record/ftp'
+    autoload :SFTP,  'backup/record/sftp'
+    autoload :Local, 'backup/record/local'
+  end
 
-# Backup Module
-module Backup
   class Setup
   
     attr_accessor :trigger, :procedures, :procedure
@@ -83,6 +83,7 @@ module Backup
     def initialize_adapter
       case procedure.adapter_name.to_sym
         when :mysql       then Backup::Adapters::MySQL.new      trigger, procedure
+        when :sqlite      then Backup::Adapters::SQLite.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
@@ -108,4 +109,4 @@ module Backup
     end
 
   end
-end
+end

data/lib/backup/adapters/archive.rb

@@ -2,68 +2,33 @@ module Backup
   module Adapters
     class Archive < Backup::Adapters::Base
       
-      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
-        
-        begin
-          targz
-          encrypt
-          store
-          record
-          notify
-        ensure
-          remove_tmp_files
-        end
-      end
+      attr_accessor :files, :exclude
       
       private
-        
+
         # Archives and Compresses all files
-        def targz
-          files = procedure.get_adapter_configuration.attributes['files']
-          if files.is_a?(Array)
-            puts system_messages[:archiving]; puts system_messages[:compressing]
-            %x{ tar -czf #{File.join(tmp_path, compressed_file)} #{files.map{|f| f.gsub(' ', '\ ')}.join(' ')} }
-          elsif files.is_a?(String)
-            puts system_messages[:archiving]; puts system_messages[:compressing]
-            %x{ tar -czf #{File.join(tmp_path, compressed_file)} #{files.gsub(' ', '\ ')} }
-          end
-        end
-        
-        # Encrypts the Archive
-        def encrypt
-          if encrypt_with_password.is_a?(String)
-            puts system_messages[:encrypting]
-            %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
+        def perform
+          log system_messages[:archiving]; log system_messages[:compressing]
+          run "tar -czf #{File.join(tmp_path, compressed_file)} #{exclude_files} #{tar_files}"
         end
         
-        # Loads the initial settings
         def load_settings
-          self.trigger  = procedure.trigger
+          self.files   = procedure.get_adapter_configuration.attributes['files']
+          self.exclude = procedure.get_adapter_configuration.attributes['exclude']
+        end
 
-          self.archived_file    = "#{timestamp}.#{trigger.gsub(' ', '-')}.tar"      
-          self.compressed_file  = "#{archived_file}.gz"
-          self.encrypted_file   = "#{compressed_file}.enc"
-          self.final_file       = compressed_file
+        def performed_file_extension
+          ".tar"
         end
         
+        def tar_files
+          [*files].map{|f| f.gsub(' ', '\ ')}.join(' ')
+        end
+
+        def exclude_files
+          [*exclude].compact.map{|x| "--exclude=#{x}"}.join(' ')
+        end
+
     end
   end
-end
+end

data/lib/backup/adapters/base.rb

@@ -2,6 +2,8 @@ module Backup
   module Adapters
     class Base
 
+      include Backup::CommandHelper
+      
       attr_accessor :procedure, :timestamp, :options, :tmp_path, :encrypt_with_password, :keep_backups, :trigger
 
       # IMPORTANT
@@ -13,8 +15,21 @@ module Backup
       #   myfile.gz.enc
       #
       # It is important that, whatever the final filename of the file will be, that :final_file will contain it.
-      attr_accessor :final_file
+      attr_accessor :performed_file, :compressed_file, :encrypted_file, :final_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 call the 'perform' method. This method is concerned with the backup, and must
+      # be implemented by derived classes!
+      # 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)
         self.trigger                = trigger
         self.procedure              = procedure
@@ -22,54 +37,58 @@ module Backup
         self.tmp_path               = File.join(BACKUP_PATH.gsub(' ', '\ '), 'tmp', 'backup', trigger)
         self.encrypt_with_password  = procedure.attributes['encrypt_with_password']
         self.keep_backups           = procedure.attributes['keep_backups']
-        create_tmp_folder
+
+        self.performed_file   = "#{timestamp}.#{trigger.gsub(' ', '-')}#{performed_file_extension}"
+        self.compressed_file  = "#{performed_file}.gz"
+        self.encrypted_file   = "#{compressed_file}.enc"
+        self.final_file       = compressed_file
+
+        begin
+          create_tmp_folder
+          load_settings # if respond_to?(:load_settings)
+          perform
+          encrypt
+          store
+          record
+          notify
+        ensure
+          remove_tmp_files
+        end
       end
       
       # Creates the temporary folder for the specified adapter
       def create_tmp_folder
-        %x{ mkdir -p #{tmp_path} }
+        run "mkdir -p #{tmp_path}"
+      end
+      
+      # TODO make methods in derived classes public? respond_to cannot identify private methods
+      def load_settings
       end
 
       # Removes the files inside the temporary folder
       def remove_tmp_files
-        %x{ rm #{File.join(tmp_path, '*')} }
+        run "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)
+      # Encrypts the archive file
+      def encrypt
+        if encrypt_with_password.is_a?(String)
+          log system_messages[:encrypting]
+          run "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
       
+      # Initializes the storing process
+      def store
+        procedure.initialize_storage(self)
+      end
+      
       # Records data on every individual file to the database
       def record
-        case procedure.storage_name.to_sym
-          when :s3
-            record = Backup::Record::S3.new
-            record.load_adapter(self)
-            record.save
-          when :scp
-            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
+        record = procedure.initialize_record
+        record.load_adapter(self)
+        record.save
       end
       
       # Delivers a notification by email regarding the successfully stored backup
@@ -85,9 +104,10 @@ module Backup
           :encrypting   => "Encrypting backup..",
           :mysqldump    => "Creating MySQL dump..",
           :pgdump       => "Creating PostgreSQL dump..",
+          :sqlite       => "Copying and compressing SQLite database..",
           :commands     => "Executing commands.." }
       end
       
     end
   end
-end
+end