backup-wakiki 2.4.1

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

@@ -0,0 +1,18 @@
+class CreateBackupTables < ActiveRecord::Migration
+  def self.up
+    create_table :backup do |t|
+      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
+
+  def self.down
+    drop_table :backup
+  end
+end

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

@@ -0,0 +1,71 @@
+namespace :backup do
+
+  desc "Run Backup Procedure."
+  task :run => :environment do
+    puts "Running: #{ENV['trigger']}."
+    Backup::Setup.new(ENV['trigger'], @backup_procedures).initialize_adapter
+  end
+  
+  desc "Finds backup records by trigger"
+  task :find => :environment do
+    puts "Finding backup records with trigger: #{ENV['trigger']}."
+    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 :local then records = Backup::Record::Local.all :conditions => {:trigger => ENV['trigger']}
+    end
+    
+    if ENV['table'].eql?("true")
+      puts Hirb::Helpers::AutoTable.render(records)
+    else
+      records.each do |record|
+        puts record.to_yaml
+      end
+    end
+  end
+  
+  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::Base.destroy_all :trigger => ENV['trigger']
+  end
+  
+  desc "Truncates everything."
+  task :truncate_all => :environment do
+    puts "Truncating all backup records."
+    Backup::Record::Base.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
+    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 :local then Backup::Record::Local.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
+    puts "Destroying all backup records."
+    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 :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

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

@@ -0,0 +1,112 @@
+# Load Gems
+require 'hirb'
+
+# Load Environments
+require 'backup/environment/base'
+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'
+require 'backup/configuration/storage'
+require 'backup/configuration/mail'
+require 'backup/configuration/smtp'
+require 'backup/configuration/helpers'
+
+require 'backup/command_helper'
+
+# Include the Configuration and Environment Helpers
+include Backup::Configuration::Helpers
+include Backup::Environment::Base
+
+# Load either UNIX or RAILS environment configuration
+case current_environment
+  when :unix  then include Backup::Environment::Unix
+  when :rails then include Backup::Environment::Rails
+end
+
+# Load configuration
+if File.exist?(File.join(BACKUP_PATH, 'config', 'backup.rb'))
+  require File.join(BACKUP_PATH, 'config', 'backup.rb')
+end
+
+# Load Mail Notifier
+require 'backup/mail/base'
+
+# Set Mail Configuration (extracted from the backup.rb configuration file) inside the Mail Class
+Backup::Mail::Base.setup(@mail_configuration)
+
+# 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
+
+  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
+
+  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 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 :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
+        else
+          puts "Unknown Adapter: \"#{procedure.adapter_name}\"."
+          exit
+      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)
+          return procedure
+        end
+      end
+      available_triggers = procedures.map {|procedure| "- #{procedure.trigger}\n" }
+      puts "Could not find a backup procedure with the trigger \"#{trigger}\". \nHere's a list of available triggers:\n#{available_triggers}"
+      exit
+    end
+
+  end
+end

data/lib/backup/adapters/archive.rb

@@ -0,0 +1,34 @@
+module Backup
+  module Adapters
+    class Archive < Backup::Adapters::Base
+      
+      attr_accessor :files, :exclude
+      
+      private
+
+        # Archives and Compresses all files
+        def perform
+          log system_messages[:archiving]; log system_messages[:compressing]
+          run "tar -czf #{File.join(tmp_path, compressed_file)} #{exclude_files} #{tar_files}"
+        end
+        
+        def load_settings
+          self.files   = procedure.get_adapter_configuration.attributes['files']
+          self.exclude = procedure.get_adapter_configuration.attributes['exclude']
+        end
+
+        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

data/lib/backup/adapters/base.rb

@@ -0,0 +1,113 @@
+module Backup
+  module Adapters
+    class Base
+
+      include Backup::CommandHelper
+      
+      attr_accessor :procedure, :timestamp, :options, :tmp_path, :encrypt_with_password, :keep_backups, :trigger
+
+      # IMPORTANT
+      # final_file must have the value of the final filename result
+      # so if a file gets compressed, then the file could look like this:
+      #   myfile.gz
+      #
+      # and if a file afterwards gets encrypted, the file will look like:
+      #   myfile.gz.enc
+      #
+      # It is important that, whatever the final filename of the file will be, that :final_file will contain it.
+      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
+        self.timestamp              = Time.now.strftime("%Y%m%d%H%M%S")
+        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']
+
+        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
+        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
+        run "rm #{File.join(tmp_path, '*')}"
+      end
+
+      # 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
+        record = procedure.initialize_record
+        record.load_adapter(self)
+        record.save
+      end
+      
+      # Delivers a notification by email regarding the successfully stored backup
+      def notify
+        if Backup::Mail::Base.setup?
+          Backup::Mail::Base.notify!(self)
+        end
+      end
+      
+      def system_messages
+        { :compressing  => "Compressing backup..",
+          :archiving    => "Archiving 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

data/lib/backup/adapters/custom.rb

@@ -0,0 +1,41 @@
+module Backup
+  module Adapters
+    class Custom < Backup::Adapters::Base
+      
+      attr_accessor :commands
+      
+      private
+
+        # Execute any given commands, then archive and compress every folder/file
+        def perform
+          execute_commands
+          targz
+        end
+        
+        # Executes the commands
+        def execute_commands
+          return unless commands
+          log system_messages[:commands]
+          [*commands].each do |command|
+            run "#{command.gsub(':tmp_path', tmp_path)}"
+          end
+        end
+        
+        # Archives and Compresses
+        def targz
+          log system_messages[:archiving]; log system_messages[:compressing]
+          run "tar -czf #{File.join(tmp_path, compressed_file)} #{File.join(tmp_path, '*')}"
+        end
+        
+        def performed_file_extension
+          ".tar"
+        end
+
+        # Loads the initial settings
+        def load_settings
+          self.commands = procedure.get_adapter_configuration.attributes['commands']
+        end
+                
+    end
+  end
+end