backup-gundua 2.3.1.1

data/generators/backup/templates/config/backup.rb

@@ -0,0 +1,202 @@
+# Backup Configuration File
+# 
+# Use the "backup" block to add backup settings to the configuration file.
+# The argument before the "do" in (backup "argument" do) is called a "trigger".
+# This acts as the identifier for the configuration.
+#
+# In the example below we have a "mysql-backup-s3" trigger for the backup setting.
+# All the configuration is done inside this block. To initialize the backup process for this block,
+# you invoke it using the following rake task:
+#
+#   rake backup:run trigger="mysql-backup-s3"
+# 
+# You can add as many backup block settings as you want, just be sure every trigger is unique and you can run
+# each of them separately.
+# 
+# ADAPTERS
+#  - MySQL
+#  - PostgreSQL
+#  - SQLite
+#  - Archive
+#  - Custom
+#
+# STORAGE METHODS
+#  - S3     (Amazon)
+#  - SCP    (Remote Server)
+#  - FTP    (Remote Server)
+#  - SFTP   (Remote Server)
+#  - LOCAL  (Local Server)
+#
+# GLOBAL OPTIONS
+#  - Keep Backups (keep_backups)
+#  - Encrypt With Pasword (encrypt_with_password)
+#  - Notify (notify)
+#
+#  This is the "decrypt" command for all encrypted backups:
+#    sudo backup --decrypt /path/to/encrypted/file
+#
+# Each Backup Setting can contain:
+# - 1 Adapter
+# - 1 Storage Method
+# - Multiple Global Options
+#
+# The combination of these, however, do not matter! So experiment with it.
+# 
+# You can also let Backup notify you by email on successfully created backups.
+# - Just uncomment the block of code below (notifier_settings) and fill in your credentials.
+# - Then for set "notify" to "true" in each (backup) block you wish to be notified of.
+# 
+# For more information on "Backup", please refer to the wiki on github
+#   http://wiki.github.com/meskyanichi/backup/configuration-file
+
+
+# Notifier
+#   Uncomment this if you want to enable notification by email on successful backup runs
+#   You will also have to set "notify true" inside each backup block below to enable it for that particular backup
+# notifier_settings do
+#   
+#   to    "example1@gmail.com"
+#   from  "example2@gmail.com"
+#   
+#   smtp do
+#     host            "smtp.gmail.com"
+#     port            "587"
+#     username        "example1@gmail.com"
+#     password        "example1password"
+#     authentication  "plain"
+#     domain          "localhost.localdomain"
+#     tls             true
+#   end
+# 
+# end
+
+
+# Initialize with:
+#   rake backup:run trigger='mysql-backup-s3'
+backup 'mysql-backup-s3' do
+  
+  adapter :mysql do
+    user        'user'
+    password    'password'
+    database    'database'
+  
+    # skip_tables ['table1', 'table2', 'table3']
+    # 
+    # options do
+    #   host    '123.45.678.90'
+    #   port    '80'
+    #   socket  '/tmp/socket.sock'
+    # end
+    # additional_options '--single-transaction  --quick'
+  end
+  
+  storage :s3 do
+    access_key_id     'access_key_id'
+    secret_access_key 'secret_access_key'
+    bucket            '/bucket/backups/mysql/'
+    use_ssl           true
+  end
+  
+  keep_backups 25
+  encrypt_with_password 'password'
+  notify false
+  
+end
+
+
+# Initialize with:
+#   rake backup:run trigger='postgresql-backup-s3'
+backup 'postgresql-backup-scp' do
+  
+  adapter :postgresql do
+    user      'user'
+    database  'database'
+
+    # skip_tables ['table1', 'table2', 'table3']
+  
+    # options do
+    #   host    '123.45.678.90'
+    #   port    '80'
+    #   socket  '/tmp/socket.sock'
+    # end
+    # additional_options '--clean --blobs'
+  end
+  
+  storage :scp do
+    ip        'example.com'
+    user      'user'
+    password  'password'
+    path      '/var/backups/postgresql/'
+  end
+
+  keep_backups :all
+  encrypt_with_password false
+  notify false
+
+end
+
+
+# Initialize with:
+#   rake backup:run trigger='archive-backup-ftp'
+backup 'archive-backup-ftp' do
+  
+  adapter :archive do
+    files ["#{RAILS_ROOT}/log", "#{RAILS_ROOT}/db"]
+  end
+  
+  storage :ftp do
+    ip        'example.com'
+    user      'user'
+    password  'password'
+    path      '/var/backups/archive/'
+  end
+
+  keep_backups 10
+  encrypt_with_password false
+  notify false
+
+end
+
+
+# Initialize with:
+#   rake backup:run trigger='custom-backup-sftp'
+backup 'custom-backup-sftp' do
+  
+  adapter :custom do
+    commands \
+      [ "mysqldump            [options] [database] > :tmp_path/my_mysql_dump.sql",
+        "pg_dump              [options] [database] > :tmp_path/my_postgresql_dump.sql",
+        "any_other_db_format  [options] [database] > :tmp_path/my_any_other_db_format.sql" ]
+  end
+  
+  storage :sftp do
+    ip        'example.com'
+    user      'user'
+    password  'password'
+    path      '/var/backups/custom/'
+  end
+
+  keep_backups :all
+  encrypt_with_password 'password'
+  notify false
+  
+end
+
+
+# Initializ with:
+#   rake backup:run trigger='sqlite-backup-local'
+backup 'sqlite-backup-local' do
+  
+  adapter :sqlite do
+    database "#{RAILS_ROOT}/db/production.sqlite3"
+  end
+  
+  storage :local do
+    path "/path/to/storage/location/"
+  end
+  
+  keep_backups :all
+  encrypt_with_password false
+  notify false
+  
+end

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/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

data/lib/backup/adapters/mysql.rb

@@ -0,0 +1,54 @@
+module Backup
+  module Adapters
+    class MySQL < Backup::Adapters::Base
+      
+      attr_accessor :user, :password, :database, :skip_tables, :host, :port, :socket, :additional_options
+      
+      private
+
+        # Dumps and Compresses the MySQL file 
+        def perform
+          log system_messages[:mysqldump]; log system_messages[:compressing]
+          run "#{mysqldump} -u #{user} --password='#{password}' #{options} #{additional_options} #{database} #{tables_to_skip} | gzip -f --best > #{File.join(tmp_path, compressed_file)}"
+        end
+
+        def mysqldump
+          # try to determine the full path, and fall back to myqsldump if not found
+          cmd = `which mysqldump`.chomp
+          cmd = 'mysqldump' if cmd.empty?
+          cmd
+        end
+        
+        def performed_file_extension
+          ".sql"
+        end
+
+        # Loads the initial settings
+        def load_settings
+          %w(user password database skip_tables additional_options).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
+        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
+          return "" unless skip_tables
+          [*skip_tables].map {|table| " --ignore-table='#{database}.#{table}' "}
+        end
+                
+    end
+  end
+end

data/lib/backup/adapters/postgresql.rb

@@ -0,0 +1,56 @@
+module Backup
+  module Adapters
+    class PostgreSQL < Backup::Adapters::Base
+
+      attr_accessor :user, :password, :database, :skip_tables, :host, :port, :socket, :additional_options
+      
+      private
+
+        # Dumps and Compresses the PostgreSQL file 
+        def perform
+          log system_messages[:pgdump]; log system_messages[:compressing]
+          ENV['PGPASSWORD'] = password
+          run "#{pg_dump} -U #{user} #{options} #{additional_options} #{tables_to_skip} #{database} | gzip -f --best > #{File.join(tmp_path, compressed_file)}"
+          ENV['PGPASSWORD'] = nil
+        end
+
+        def pg_dump
+          # try to determine the full path, and fall back to pg_dump if not found
+          cmd = `which pg_dump`.chomp
+          cmd = 'pg_dump' if cmd.empty?
+          cmd
+        end
+        
+        def performed_file_extension
+          ".sql"
+        end
+
+        # Loads the initial settings
+        def load_settings
+          %w(user password database skip_tables additional_options).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
+        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
+          return "" unless skip_tables
+          [*skip_tables].map {|table| " -T \"#{table}\" "}
+        end
+
+    end
+  end
+end