backup 1.3.4 → 2.0.0

data/generators/backup_files/templates/s3.rake

@@ -1,231 +0,0 @@
-namespace :backup do
-  namespace :s3 do
-    
-    # => rake backup:s3:mysql
-    # Fill in your mysql credentials to allow Backup to create a mysql dump, and which database to make a dump from.
-    # Specify that you want to use :s3
-    # Fill in your Amazon S3 Account's Credentials (access_key_id, secret_access_key)
-    # Specify which bucket you wish to store your files to.
-    # If you wish to put specific files in subfolders inside the bucket, you may do so by doing something like this:
-    # :bucket => "my_bucket/subfolder1/subfolder2" etc.
-    desc 'Makes a backup from a MySQL database and transfers it to Amazon S3.'
-    task :mysql => :s3_config do
-      @config = @config['mysql']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Mysql.new({
-          :adapter    => 'mysql',
-          :index      => 0,
-          :mysql => {
-            :user     => @config['mysql_config']['user'],
-            :password => @config['mysql_config']['password'],
-            :database => @config['mysql_config']['database']
-          },
-        
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-        
-          :use => :s3,
-          :s3 => {
-            :access_key_id      => @config['s3']['access_key_id'],
-            :secret_access_key  => @config['s3']['secret_access_key'],
-            :bucket             => @config['s3']['bucket']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Mysql.new({
-            :adapter    => 'mysql',
-            :index      => index,
-            :mysql => {
-              :user     => config['mysql_config']['user'],
-              :password => config['mysql_config']['password'],
-              :database => config['mysql_config']['database']
-            },
-
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-
-            :use => :s3,
-            :s3 => {
-              :access_key_id      => config['s3']['access_key_id'],
-              :secret_access_key  => config['s3']['secret_access_key'],
-              :bucket             => config['s3']['bucket']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-    
-    # => rake backup:s3:sqlite3
-    # Specify which sqlite3 file you wish to back up. This will generally be "production.sqlite3". (and this is the default, so you can remove the :file attribute if it is)
-    # Specify that you want to use :s3
-    # Fill in your Amazon S3 Account's Credentials (access_key_id, secret_access_key)
-    # Specify which bucket you wish to store your files to.
-    # If you wish to put specific files in subfolders inside the bucket, you may do so by doing something like this:
-    # :bucket => "my_bucket/subfolder1/subfolder2" etc.
-    desc 'Makes a backup from a SQLite3 database and transfers it to Amazon S3.'
-    task :sqlite3 => :s3_config do
-      @config = @config['sqlite3']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Sqlite3.new({
-          :adapter      => 'sqlite3',
-          :index        => 0,
-          :file         => @config['file'],
-          :path         => @config['path'],
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-        
-          :use => :s3,
-          :s3 => {
-            :access_key_id      => @config['s3']['access_key_id'],
-            :secret_access_key  => @config['s3']['secret_access_key'],
-            :bucket             => @config['s3']['bucket']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Sqlite3.new({
-            :adapter      => 'sqlite3',
-            :index        => index,
-            :file         => config['file'],
-            :path         => config['path'],
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-
-            :use => :s3,
-            :s3 => {
-              :access_key_id      => config['s3']['access_key_id'],
-              :secret_access_key  => config['s3']['secret_access_key'],
-              :bucket             => config['s3']['bucket']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-    
-    # => rake backup:s3:assets
-    # Specify which directory (:path) (and all it's underlaying files and folders) you wish to backup.
-    # Specify that you want to use :s3
-    # Fill in your Amazon S3 Account's Credentials (access_key_id, secret_access_key)
-    # Specify which bucket you wish to store your files to.
-    # If you wish to put specific files in subfolders inside the bucket, you may do so by doing something like this:
-    # :bucket => "my_bucket/subfolder1/subfolder2" etc.
-    desc 'Makes a backup from Assets and transfers it to Amazon S3.'
-    task :assets => :s3_config do
-      @config = @config['assets']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Assets.new({
-          :adapter      => 'assets',
-          :index        => 0,
-          :path         => @config['path'],
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-        
-          :use => :s3,
-          :s3 => {
-            :access_key_id      => @config['s3']['access_key_id'],
-            :secret_access_key  => @config['s3']['secret_access_key'],
-            :bucket             => @config['s3']['bucket']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Assets.new({
-            :adapter      => 'assets',
-            :index        => index,
-            :path         => config['path'],
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-
-            :use => :s3,
-            :s3 => {
-              :access_key_id      => config['s3']['access_key_id'],
-              :secret_access_key  => config['s3']['secret_access_key'],
-              :bucket             => config['s3']['bucket']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-    
-    # => rake backup:s3:custom
-    # This is a more complex implementation of the Backup gem.
-    # Might you be using a database type that is currently not supported, then you can manually create an SQL dump
-    # using the :command attribute. This will take either a single string, or an array of strings, depending on how many
-    # commands you wish to execute.
-    # 
-    # Single Command
-    #  :command => "my command"
-    # Multiple Commands
-    #  :command => ["my command 1", "my command 2", "my command 3"] etc.
-    #
-    # This means you have full control over where the sql dump should be placed. But, depending on your decision, you must
-    # set the correct path to the file(s) (sql dumps) that have been generated.
-    # 
-    # Path To File(s) Directory
-    #  :path => "#{RAILS_ROOT}/db"
-    #  
-    # Finally, you must specify which file(s) should be backed up.
-    # The :file attribute can take either a single string, or an array of strings to add multiple files.
-    # 
-    # Select a single file to backup from the :path directory you specified
-    #  :file => "foobar1.sql"
-    # Select multiple files to backup from the :path directory you specified
-    #  :file => ["foobar1.sql", "foobar2.sql"] etc
-    # 
-    # When you specify you would like to backup multiple files, it will automatically archive these as a "tar" for you and then compress it.
-    #
-    # By default, after the backup has been pushed to S3, it will remove the original files (created from your :command attribute)
-    # If you wish to keep these files, then add the following line:
-    #  :keep_original_files => true
-    # This is set to 'false' by default, as you most likely don't want to keep these files on your production server.
-    # 
-    # Just use the ":use => :s3" as usual to tell it you would like to back up these files using S3.
-    # And then, like in the example below, provide the S3 credentials/details to be able to connect to the server you wish to back these files up to.
-    desc 'Makes a backup from a Custom database and transfers it to Amazon S3.'
-    task :custom => :s3_config do
-      @config = @config['custom']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Custom.new({
-          :adapter      => 'custom',
-          :index        => 0,
-          :file         => @config['file'],
-          :path         => @config['path'],
-          :command      => @config['command'],
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-                
-          :use => :s3,
-          :s3 => { 
-            :access_key_id      => @config['s3']['access_key_id'],
-            :secret_access_key  => @config['s3']['secret_access_key'],
-            :bucket             => @config['s3']['bucket']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Custom.new({
-            :adapter      => 'custom',
-            :index        => index,
-            :file         => config['file'],
-            :path         => config['path'],
-            :command      => config['command'],
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-                
-            :use => :s3,
-            :s3 => { 
-              :access_key_id      => config['s3']['access_key_id'],
-              :secret_access_key  => config['s3']['secret_access_key'],
-              :bucket             => config['s3']['bucket']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-  end
-end

data/generators/backup_files/templates/s3.yml

@@ -1,120 +0,0 @@
-# Backup Configuration file for "Amazon S3 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 the Amazon S3 service to store your
-# backups, 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:s3:mysql
-mysql:
-  mysql_config:
-    user: root
-    password: '' 
-    database: foobar
-  s3:
-    access_key_id: my_access_key_id
-    secret_access_key: my_secret_access_key
-    bucket: my_bucket
-  #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:s3:sqlite3
-sqlite3:
-  file: production.sqlite3
-  path: ':rails_root/db'
-  s3:
-    access_key_id: my_access_key_id
-    secret_access_key: my_secret_access_key
-    bucket: my_bucket
-  #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:s3:assets
-assets:
-  path: ':rails_root/public/assets'
-  s3:
-    access_key_id: my_access_key_id
-    secret_access_key: my_secret_access_key
-    bucket: my_bucket
-  #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:s3: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'
-  s3:
-    access_key_id: my_access_key_id
-    secret_access_key: my_secret_access_key
-    bucket: my_bucket
-  #encrypt: my_secret_password # Uncomment me if you want this functionality
-  #keep_backups: 25 # Uncomment me if you want this functionality

data/generators/backup_files/templates/setup.rake

@@ -1,28 +0,0 @@
-namespace :backup do
-  namespace :setup do
-    desc "Automatically sets up Capistrano Structure for you!"
-    task :capistrano => :environment do
-      puts 'Looking for shared path!'
-      if File.directory?("../../shared") then
-        puts 'Found shared path!'
-        puts 'Looking for db folder in shared path!'
-      	unless File.directory?("../../shared/db") then
-          puts 'Cound not find db folder in shared path! Creating it now!'
-      		%x{ mkdir -p ../../shared/db }
-      	else
-      	  puts 'Found db folder in shared path!'
-      	end
-	      
-	      puts 'Looking for backup.sqlite3 in shared/db path!'
-	      unless File.exist?("../../shared/db/backup.sqlite3") then
-	        puts 'Could not find, creating it now!'
-	        %x{ cp #{RAILS_ROOT}/lib/tasks/backup/files/backup.sqlite3 ../../shared/db/backup.sqlite3 }
-        else
-          puts "backup.sqlite3 already exists in the shared/db folder! Skipping backup.sqlite3 creation!"
-        end
-	        %x{ ln -nfs #{RAILS_ROOT}/../../shared/db/backup.sqlite3 #{RAILS_ROOT}/db/backup.sqlite3 }
-	        puts "Set up a symbolic link to the backup.sqlite3 inside #{RAILS_ROOT}/db/ folder!"
-      end
-    end
-  end
-end

data/generators/backup_files/templates/ssh.rake

@@ -1,226 +0,0 @@
-namespace :backup do
-  namespace :ssh do
-    
-    # => rake backup:ssh:mysql
-    # Fill in your mysql credentials to allow Backup to create a mysql dump, and which database to make a dump from.
-    # Specify that you want to use :ssh
-    # Specify what user should connect through SSH, to what address (be it IP or an URL) and the absolute path on the backup-server
-    # to where Backup should store the backups.
-    desc 'Makes a backup from a MySQL database and transfers it through SSH (SCP).'
-    task :mysql => :ssh_config do
-      @config = @config['mysql']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Mysql.new({
-          :adapter  => 'mysql',
-          :index    => 0,
-          :mysql => {
-            :user     => @config['mysql_config']['user'],
-            :password => @config['mysql_config']['password'],
-            :database => @config['mysql_config']['database']
-          },
-        
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-        
-          :use => :ssh,
-          :ssh => {
-            :user => @config['ssh']['user'],
-            :ip   => @config['ssh']['ip'],
-            :path => @config['ssh']['path']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Mysql.new({
-            :adapter => 'mysql',
-            :index   => index,
-            :mysql => {
-              :user     => config['mysql_config']['user'],
-              :password => config['mysql_config']['password'],
-              :database => config['mysql_config']['database']
-            },
-
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-
-            :use => :ssh,
-            :ssh => {
-              :user => config['ssh']['user'],
-              :ip   => config['ssh']['ip'],
-              :path => config['ssh']['path']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-
-    # => rake backup:ssh:sqlite3
-    # Specify which sqlite3 file you wish to back up. This will generally be "production.sqlite3". (and this is the default, so you can remove the :file attribute if it is)
-    # If your sqlite3 file is not located inside the #{RAILS_ROOT}/db folder, then add a :path => "#{RAILS_ROOT}/path/to/db/folder" 
-    # Specify that you want to use :ssh
-    # Specify what user should connect through SSH, to what address (be it IP or an URL) and the absolute path on the backup-server
-    # to where Backup should store the backups.
-    desc 'Makes a backup from a SQLite3 database and transfers it through SSH (SCP).'
-    task :sqlite3 => :ssh_config do
-      @config = @config['sqlite3']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Sqlite3.new({
-          :adapter      => 'sqlite3',
-          :index        => 0,
-          :file         => @config['file'],
-          :path         => @config['path'],
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-        
-          :use => :ssh,
-          :ssh => {
-            :user => @config['ssh']['user'],
-            :ip   => @config['ssh']['ip'],
-            :path => @config['ssh']['path']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Sqlite3.new({
-            :adapter      => 'sqlite3',
-            :index        => index,
-            :file         => config['file'],
-            :path         => config['path'],
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-
-            :use => :ssh,
-            :ssh => {
-              :user => config['ssh']['user'],
-              :ip   => config['ssh']['ip'],
-              :path => config['ssh']['path']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-    
-    # => rake backup:ssh:assets
-    # Specify which directory (:path) (and all it's underlaying files and folders) you wish to backup.
-    # Specify that you want to use :ssh
-    # Specify what user should connect through SSH, to what address (be it IP or an URL) and the absolute path on the backup-server
-    # to where Backup should store the backups.
-    desc 'Makes a backup from Assets and transfers it through SSH (SCP).'
-    task :assets => :ssh_config do
-      @config = @config['assets']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Assets.new({
-          :adapter      => 'assets',
-          :index        => 0,
-          :path         => @config['path'],
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-        
-          :use => :ssh,
-          :ssh => { 
-            :user => @config['ssh']['user'],
-            :ip   => @config['ssh']['ip'],
-            :path => @config['ssh']['path']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Assets.new({
-            :adapter      => 'assets',
-            :index        => index,
-            :path         => config['path'],
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-
-            :use => :ssh,
-            :ssh => { 
-              :user => config['ssh']['user'],
-              :ip   => config['ssh']['ip'],
-              :path => config['ssh']['path']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-    
-    # => rake backup:ssh:custom
-    # This is a more complex implementation of the Backup gem.
-    # Might you be using a database type that is currently not supported, then you can manually create an SQL dump
-    # using the :command attribute. This will take either a single string, or an array of strings, depending on how many
-    # commands you wish to execute.
-    # 
-    # Single Command
-    #  :command => "my command"
-    # Multiple Commands
-    #  :command => ["my command 1", "my command 2", "my command 3"] etc.
-    #
-    # This means you have full control over where the sql dump should be placed. But, depending on your decision, you must
-    # set the correct path to the file(s) (sql dumps) that have been generated.
-    # 
-    # Path To File(s) Directory
-    #  :path => "#{RAILS_ROOT}/db"
-    #  
-    # Finally, you must specify which file(s) should be backed up.
-    # The :file attribute can take either a single string, or an array of strings to add multiple files.
-    # 
-    # Select a single file to backup from the :path directory you specified
-    #  :file => "foobar1.sql"
-    # Select multiple files to backup from the :path directory you specified
-    #  :file => ["foobar1.sql", "foobar2.sql"] etc
-    # 
-    # When you specify you would like to backup multiple files, it will automatically archive these as a "tar" for you and then compress it.  
-    #
-    # By default, after the backup has been pushed to your backup server using SSH, it will remove the original files (created from your :command attribute)
-    # If you wish to keep these files, then add the following line:
-    #  :keep_original_files => true
-    # This is set to 'false' by default, as you most likely don't want to keep these files on your production server.
-    #
-    # Just use the ":use => :ssh" as usual to tell it you would like to back up these files using SSH.
-    # And then, like in the example below, provide the SSH details to be able to connect to the server you wish to back these files up to.
-    desc 'Makes a backup from a Custom database and transfers it through SSH (SCP).'
-    task :custom => :ssh_config do
-      @config = @config['custom']
-      unless @config.is_a?(Array)
-        Backup::Adapter::Custom.new({
-          :adapter      => 'custom',
-          :index        => 0,
-          :file         => @config['file'],
-          :path         => @config['path'],
-          :command      => @config['command'],
-          :encrypt      => @config['encrypt'],
-          :keep_backups => @config['keep_backups'],
-                
-          :use => :ssh,
-          :ssh => { 
-            :user => @config['ssh']['user'],
-            :ip   => @config['ssh']['ip'],
-            :path => @config['ssh']['path']
-          }
-        }).run
-      else
-        @config.each_with_index do |config, index|
-          Backup::Adapter::Custom.new({
-            :adapter      => 'custom',
-            :index        => index,
-            :file         => config['file'],
-            :path         => config['path'],
-            :command      => config['command'],
-            :encrypt      => config['encrypt'],
-            :keep_backups => config['keep_backups'],
-
-            :use => :ssh,
-            :ssh => { 
-              :user => config['ssh']['user'],
-              :ip   => config['ssh']['ip'],
-              :path => config['ssh']['path']
-            }
-          }).run
-          sleep(1)
-        end
-      end
-    end
-  end
-end