backup 1.3.4 → 2.0.0

data/generators/backup_files/templates/ssh.yml

@@ -1,119 +0,0 @@
-# Backup Configuration file for "SSH (SCP) Backups"
-# This file was generated with the Backup Generator
-#
-# FOR MORE INFORMATION, VIEW THE WIKI ON GITHUB:
-#  http://wiki.github.com/meskyanichi/backup
-# 
-# If you wish to make use of SSH (SCP) to store your
-# backups to another server, use this configuration file.
-# 
-# Step by Step
-# 
-# Step 1
-#  Choose the adapter you would like to use to back up your files
-#  (MySQL, SQLite3, Assets or something Custom)
-# 
-# Step 2
-#  Fill in the values for the adapter you choose.
-#  You do not need to fill in the values for every adapter,
-#  only the ones you are going to use. The rest you can leave untouched or remove.
-# 
-# Step 3
-#  Once you've filled in all values, you are ready to execute the rake task that
-#  starts that backup process. Above each Adapter you will see what rake task should
-#  be run to start the backup process for that specific Adapter.
-#
-# Step 4
-#  Once set up, you could set these rake tasks up in a cronjob to execute it periodically.
-#  For handling this, I recommend using the javan-whenever gem
-# 
-#  See here: http://github.com/javan/whenever
-
-
-# Global Options
-# 
-# - encrypt (optional!)
-#
-#   What "encrypt" does is encrypt your backup with the given password
-#   Example:
-#     encrypt: this_is_my_password
-#
-#   This will encrypt the backup file with the password: this_is_my_password 
-#   NOTE: To "decrypt" an encrypted file later on, use the following command:
-#     openssl enc -des-cbc -d -in encrypted_file -out decrypted_file 
-#
-#
-# - keep_backups (optional!)
-#
-#   what "keep_backups" does is it ensures that there won't be more than the specified
-#   amount of backups present on the storage location (S3 or any remotely accessible server)
-#   Example:
-#     keep_backups: 10
-#   
-#   This will make sure there won't be more than 10 backups on the server at a time.
-#   When the 11th backup is pushed to for example Amazon S3, it will delete the oldest
-#   backup. Why would you want this? To avoid S3 from being expensive and otherwise
-#   to not overload your remote server's harddisk and practically fload it.
-
-
-
-
-# MySQL Adapter
-# To run this adapter, execute the following rake task:
-# rake backup:ssh:mysql
-mysql:
-  mysql_config:
-    user: root
-    password: '' 
-    database: foobar
-  ssh:
-    user: root
-    ip: my-domain.com
-    path: '/var/backups'
-  #encrypt: my_secret_password # Uncomment me if you want this functionality
-  #keep_backups: 25 # Uncomment me if you want this functionality
-    
-    
-# SQLite3 Adapter
-# To run this adapter, execute the following rake task:
-# rake backup:ssh:sqlite3
-sqlite3:
-  file: production.sqlite3
-  path: ':rails_root/db'
-  ssh:
-    user: root
-    ip: my-domain.com
-    path: '/var/backups'
-  #encrypt: my_secret_password # Uncomment me if you want this functionality
-  #keep_backups: 25 # Uncomment me if you want this functionality
-
-# Asset Adapter
-# To run this adapter, execute the following rake task:
-# rake backup:ssh:assets
-assets:
-  path: ':rails_root/public/assets'
-  ssh:
-    user: root
-    ip: my-domain.com
-    path: '/var/backups'
-  #encrypt: my_secret_password # Uncomment me if you want this functionality
-  #keep_backups: 25 # Uncomment me if you want this functionality
-
-
-# Custom Adapter
-# To run this adapter, execute the following rake task:
-# rake backup:ssh:custom
-custom:
-  path: ':rails_root/db'
-  file:
-    - 'foobar1.sql'
-    - 'foobar2.sql'
-  command:
-    - 'mysqldump --quick -u root --password="" foobar > :rails_root/db/foobar1.sql'
-    - 'mysqldump --quick -u root --password="" foobar > :rails_root/db/foobar2.sql'
-  ssh:
-    user: root
-    ip: my-domain.com
-    path: '/var/backups'
-  #encrypt: my_secret_password # Uncomment me if you want this functionality
-  #keep_backups: 25 # Uncomment me if you want this functionality

data/lib/backup/adapter/assets.rb

@@ -1,57 +0,0 @@
-module Backup
-  module Adapter
-    class Assets < Backup::Base
-    
-      def initialize(options = {})
-        super(default_options.merge(options))
-        setup_paths("assets/#{self.class.name.downcase.gsub('::','-')}", 'tar.gz')
-      end
-    
-      # Initialize the process
-      # Executing multiple processes
-      # 
-      # - Archive
-      #   Archives the specified folder to a .tar
-      # - Compress
-      #   Compresses the .tar file using Gzip
-      # - Encrypt
-      #   Encrypts the backup file
-      # - Transfer
-      #   Initializes the transfer to either S3 or using SSH
-      # - Record
-      #   Records the Backup Data to the Backup SQLite3 database
-      # - Remove Temp Files
-      #   Removes temporary files after the process is complete
-      def run
-        begin
-          archive
-          compress
-          encrypt
-          transfer
-          record
-        ensure
-          remove_temp_files
-        end
-      end
-    
-      private
-      
-        # Archives the assets into a .tar file and stores it
-        # inside the "Backup Path"
-        def archive
-          %x{ tar -cf #{File.join(options[:backup_path], options[:backup_file])} #{options[:path]} }
-        end
-      
-        # Compresses the .tar file to .tar.gz and removes the old .tar file
-        def compress
-          %x{ gzip --best #{File.join(options[:backup_path], options[:backup_file])} }
-        end
-      
-        # Set default options
-        def default_options
-          { :path => "#{RAILS_ROOT}/public/assets", :file => "assets" }
-        end
-    
-    end
-  end
-end

data/lib/backup/adapter/custom.rb

@@ -1,91 +0,0 @@
-module Backup
-  module Adapter
-    class Custom < Backup::Base
-    
-      def initialize(options = {})
-        super(default_options.merge(options))
-        setup_paths("db/#{self.class.name.downcase.gsub('::','-')}", options[:file].is_a?(Array) ? 'tar.gz' : 'gz')
-      end
-    
-      # Initialize the process
-      # Executing multiple processes
-      #
-      # - Command
-      #   Executes a command from a user to generate a SQL dump
-      # - Archive
-      #   Archives the specified folder to a .tar
-      # - Compress
-      #   Compresses the .tar file using Gzip
-      # - Encrypt
-      #   Encrypts the backup file
-      # - Transfer
-      #   Initializes the transfer to either S3 or using SSH
-      # - Record
-      #   Records the Backup Data to the Backup SQLite3 database
-      # - Remove Temp Files
-      #   Removes temporary files after the process is complete
-      # - Remove Original File
-      #   Removes the user generated sql files (unless the user specifies he wants to keep them)
-      def run
-        begin
-          command
-          archive
-          compress
-          encrypt
-          transfer
-          record
-        ensure
-          remove_temp_files
-          remove_original_file
-        end
-      end
-    
-      private
-      
-        # Allows a user to insert one or more commands to be executed
-        # before the actual archive, compress and transferring processes.
-        # The command takes either a String for a single command, and an Array for multiple commands.
-        def command
-          if options[:command].is_a?(Array)
-            options[:command].each do |command|
-              %x{ #{command} }
-            end
-          else
-            %x{ #{options[:command]} }
-          end
-        end
-      
-        # Archives the assets into a .tar file and stores it
-        # inside the "Backup Path"
-        def archive
-          if options[:file].is_a?(Array)
-            files = options[:file].map {|file| File.join(options[:path], file)}
-            %x{ tar -cf #{File.join(options[:backup_path], options[:backup_file])} #{files.join(' ')} }
-          else
-            %x{ tar -cf #{File.join(options[:backup_path], options[:backup_file])} #{File.join(options[:path], options[:file])} }
-          end
-        end
-      
-        # If the user has bundled a couple of files to a .tar (by using an Array for the :file attribute)
-        # then it compresses the .tar file to .tar.gz and removes the old .tar file
-        # If the user has only a single file, it will be read out and a new file will be generated
-        # The old (single) file will remain until the process is complete, unless the user specifies otherwise.
-        def compress
-          if options[:file].is_a?(Array)
-            %x{ gzip --best #{File.join(options[:backup_path], options[:backup_file])} }
-          else
-            %x{ gzip -cv #{File.join(options[:path], options[:file])} --best > #{File.join(options[:backup_path], options[:backup_file])} }
-          end
-        end
-      
-        # Set default options
-        def default_options
-          { :path     => "",
-            :file     => "",
-            :command  => "",
-            :keep_original_files => false }
-        end
-    
-    end
-  end
-end

data/lib/backup/adapter/mysql.rb

@@ -1,65 +0,0 @@
-module Backup
-  module Adapter
-    class Mysql < Backup::Base
-    
-      def initialize(options = {})
-        super(default_options.merge(options))
-        setup_paths("db/#{self.class.name.downcase.gsub('::','-')}", :gz)
-      end
-    
-      # Initialize the process
-      # Executing multiple processes
-      #
-      # - Make MySQL Dump
-      #   Creates a MySQL dump based on the parameters provided by the user
-      # - Compress
-      #   Compresses the .tar file using Gzip
-      # - Encrypt
-      #   Encrypts the backup file
-      # - Transfer
-      #   Initializes the transfer to either S3 or using SSH
-      # - Record
-      #   Records the Backup Data to the Backup SQLite3 database
-      # - Remove Temp Files
-      #   Removes temporary files after the process is complete
-      def run
-        begin
-          make_mysql_dump
-          compress
-          encrypt
-          transfer
-          record
-        ensure
-          remove_temp_files
-        end
-      end
-
-      private
-      
-        # Compresses the MySQL dump file and stores the compressed version inside the tmp/backups folder.
-        def compress
-          %x{ gzip -cv #{File.join(options[:path], options[:file])} --best > #{File.join(options[:backup_path], options[:backup_file])} }
-        end
-      
-        # This will generate a MySQL dump based on the options the user passed in.
-        # The MySQL dump will be placed (by default) in the config/db directory so it can be found
-        # by the compressor.
-        def make_mysql_dump
-          # => /usr/local/mysql/bin/mysqldump on Mac OS X 10.6
-          %x{ mysqldump --quick -u #{options[:mysql][:user]} --password='#{options[:mysql][:password]}' #{options[:mysql][:database]} > #{File.join(options[:path], options[:file])} }
-        end
-      
-        # Set default options
-        def default_options
-          {:path => "#{RAILS_ROOT}/tmp/backups/db/#{self.class.name.downcase.gsub('::','-')}",
-            :file => "production.sql",
-            :mysql => {
-              :user     => "",
-              :password => "",
-              :database => ""
-          }}
-        end
-    
-    end
-  end
-end

data/lib/backup/adapter/sqlite3.rb

@@ -1,49 +0,0 @@
-module Backup
-  module Adapter
-    class Sqlite3 < Backup::Base
-    
-      def initialize(options = {})
-        super(default_options.merge(options))
-        setup_paths("db/#{self.class.name.downcase.gsub('::','-')}", :gz)
-      end
-    
-      # Initialize the process
-      # Executing multiple processes
-      #
-      # - Compress
-      #   Compresses the .tar file using Gzip
-      # - Encrypt
-      #   Encrypts the backup file
-      # - Transfer
-      #   Initializes the transfer to either S3 or using SSH
-      # - Record
-      #   Records the Backup Data to the Backup SQLite3 database
-      # - Remove Temp Files
-      #   Removes temporary files after the process is complete
-      def run
-        begin
-          compress
-          encrypt
-          transfer
-          record
-        ensure
-          remove_temp_files
-        end
-      end
-    
-      private
-      
-        # Compresses the SQLite3file and stores the compressed version inside the tmp/backups folder.
-        def compress
-          %x{ gzip -cv #{File.join(options[:path], options[:file])} --best > #{File.join(options[:backup_path], options[:backup_file])} }
-        end
-      
-        # Set default options
-        def default_options
-          { :path => "#{RAILS_ROOT}/db",
-            :file => "production.sqlite3" }
-        end
-    
-    end  
-  end
-end

data/lib/backup/backup_record/s3.rb

@@ -1,90 +0,0 @@
-require 'aws/s3'
-
-module Backup
-  module BackupRecord
-    class S3 < ActiveRecord::Base
-        
-      # Establishes a connection with the SQLite3
-      # local database to avoid conflict with users
-      # Production database.
-      establish_connection(
-        :adapter  => "sqlite3",
-        :database => "db/backup.sqlite3",
-        :pool     => 5,
-        :timeout  => 5000 )
-      
-      # Scopes
-      default_scope :order => 'created_at desc'
-      
-      # Callbacks
-      after_save :destroy_old_backups
-      
-      # Attributes
-      attr_accessor :options, :keep_backups
-      
-      # Receives the options hash and stores it
-      # Sets the S3 values
-      def set_options(options)
-        self.options      = options
-        self.backup_file  = options[:backup_file]
-        self.bucket       = options[:s3][:bucket]
-        self.keep_backups = options[:keep_backups]
-        self.adapter      = options[:adapter]
-        self.index        = options[:index]
-      end
-      
-      # This will only be triggered by the rake task
-      # rake backup:db:destroy:s3
-      # 
-      # This will loop through all the configured adapters
-      # and destroy all "Backup" database records for the
-      # S3 table and delete all backed up files from the
-      # Amazon S3 server.
-      def self.destroy_all_backups(adapter, options, index)
-        backups = Backup::BackupRecord::S3.all(:conditions => {:adapter => adapter, :index => index})
-        unless backups.empty?
-          s3 = Backup::Connection::S3.new(options)
-          s3.connect
-          backups.each do |backup|
-            puts "Destroying backup: #{backup.backup_file}.."
-            s3.destroy(backup.backup_file, backup.bucket)
-            backup.destroy
-          end
-        end
-      end
-      
-      private
-        
-        # Destroys backups when the backup limit has been reached
-        # This is determined by the "keep_backups:" parameter
-        # First all backups will be fetched. 
-        def destroy_old_backups
-          if keep_backups.is_a?(Integer)
-            backups = Backup::BackupRecord::S3.all(:conditions => {:adapter => adapter, :index => index})
-            backups_to_destroy = Array.new
-            backups.each_with_index do |backup, index|
-              if index >= keep_backups then
-                backups_to_destroy << backup
-              end
-            end
-          
-            if backups_to_destroy
-              # Create a new Amazon S3 Object
-              s3 = Backup::Connection::S3.new(options)
-            
-              # Connect to Amazon S3 with provided credentials
-              s3.connect
-          
-              # Loop through all backups that should be destroyed and remove them from S3.
-              backups_to_destroy.each do |backup|
-                puts "Destroying old backup: #{backup.backup_file}.."
-                s3.destroy(backup.backup_file, backup.bucket)
-                backup.destroy
-              end
-            end
-          end
-        end
-        
-    end
-  end
-end