backup 1.0.0 → 1.1.0

data/README.rdoc

@@ -2,9 +2,7 @@
 
 == What is "Backup"?
 
-"Backup" is a RubyGem written for Rails to (easily) handle backing up your database files and assets to either Amazon S3, or any other server using SSH.
-You barely have to get your hands dirty! Backup provides you with 2 (easily) configurable .yml files. These two files are the only ones you will need to use to configure
-all your backups.
+“Backup” is a RubyGem, written for Ruby on Rails. It's main purpose is to Backup any files to Amazon S3 or any remotely accessible server through SSH (SCP). It supports database and regular file backups. On top of that, it's extremely easy to set up. Backup will provide a generator script that will place all necessary files inside your Rails application. Two of which, are “yaml” configuration files. Using just these two files to configure a backup for database formats such as a MySQL, SQLite3 or any Assets folder. Setting up “Backup” takes only about a minute or two!
 
 
 === Backup makes use of two storage methods:

data/Rakefile

@@ -19,7 +19,9 @@ begin
     gem.email = "meskyan@gmail.com"
     gem.homepage = "http://github.com/meskyanichi/backup"
     gem.authors = ["meskyanichi"]
-    gem.add_dependency "aws-s3"
+    gem.add_dependency "aws-s3", ">= 0.6.2"
+    gem.add_dependency "net-ssh", ">= 2.0.15"
+    gem.add_dependency "net-scp", ">= 1.0.2"
 #    gem.files.include 'generators/**/*'
 #    gem.files.include 'lib/**/*'
   end

data/VERSION

@@ -1 +1 @@
-1.0.0
+1.1.0

data/backup.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{backup}
-  s.version = "1.0.0"
+  s.version = "1.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["meskyanichi"]
-  s.date = %q{2009-10-07}
+  s.date = %q{2009-10-08}
   s.description = %q{
                           “Backup” is a RubyGem, written for Ruby on Rails. It's main purpose is to Backup any
                           files to Amazon S3 or any remotely accessible server through SSH (SCP). It supports database
@@ -32,22 +32,26 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "backup.gemspec",
-     "generators/backup_tasks/backup_tasks_generator.rb",
-     "generators/backup_tasks/templates/config.rake",
-     "generators/backup_tasks/templates/s3.rake",
-     "generators/backup_tasks/templates/s3.yml",
-     "generators/backup_tasks/templates/ssh.rake",
-     "generators/backup_tasks/templates/ssh.yml",
+     "generators/backup_files/backup_files_generator.rb",
+     "generators/backup_files/templates/backup.sqlite3",
+     "generators/backup_files/templates/config.rake",
+     "generators/backup_files/templates/db.rake",
+     "generators/backup_files/templates/s3.rake",
+     "generators/backup_files/templates/s3.yml",
+     "generators/backup_files/templates/ssh.rake",
+     "generators/backup_files/templates/ssh.yml",
      "lib/backup.rb",
-     "lib/backup/assets.rb",
+     "lib/backup/adapter/assets.rb",
+     "lib/backup/adapter/custom.rb",
+     "lib/backup/adapter/mysql.rb",
+     "lib/backup/adapter/sqlite3.rb",
+     "lib/backup/backup_record/s3.rb",
+     "lib/backup/backup_record/ssh.rb",
      "lib/backup/base.rb",
      "lib/backup/connection/base.rb",
      "lib/backup/connection/s3.rb",
      "lib/backup/connection/ssh.rb",
-     "lib/backup/custom.rb",
      "lib/backup/encrypt.rb",
-     "lib/backup/mysql.rb",
-     "lib/backup/sqlite3.rb",
      "lib/backup/transfer/base.rb",
      "lib/backup/transfer/s3.rb",
      "lib/backup/transfer/ssh.rb"
@@ -63,11 +67,17 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<aws-s3>, [">= 0"])
+      s.add_runtime_dependency(%q<aws-s3>, [">= 0.6.2"])
+      s.add_runtime_dependency(%q<net-ssh>, [">= 2.0.15"])
+      s.add_runtime_dependency(%q<net-scp>, [">= 1.0.2"])
     else
-      s.add_dependency(%q<aws-s3>, [">= 0"])
+      s.add_dependency(%q<aws-s3>, [">= 0.6.2"])
+      s.add_dependency(%q<net-ssh>, [">= 2.0.15"])
+      s.add_dependency(%q<net-scp>, [">= 1.0.2"])
     end
   else
-    s.add_dependency(%q<aws-s3>, [">= 0"])
+    s.add_dependency(%q<aws-s3>, [">= 0.6.2"])
+    s.add_dependency(%q<net-ssh>, [">= 2.0.15"])
+    s.add_dependency(%q<net-scp>, [">= 1.0.2"])
   end
 end

data/generators/{backup_tasks/backup_tasks_generator.rb → backup_files/backup_files_generator.rb}

@@ -1,4 +1,4 @@
-class BackupTasksGenerator < Rails::Generator::Base
+class BackupFilesGenerator < Rails::Generator::Base
 
   # This method gets initialized when the generator gets run.
   # It will receive an array of arguments inside @args
@@ -15,17 +15,22 @@ class BackupTasksGenerator < Rails::Generator::Base
     record do |m|
       
       # Generate the Rake Tasks
-      m.directory "lib/tasks/"
+      m.directory "lib/tasks"
       m.directory "lib/tasks/backup"
       m.file      "config.rake",  "lib/tasks/backup/config.rake"
       m.file      "s3.rake",      "lib/tasks/backup/s3.rake"
       m.file      "ssh.rake",     "lib/tasks/backup/ssh.rake"
+      m.file      "db.rake",      "lib/tasks/backup/db.rake"
       
       # Generate the YAML files
       m.directory "config/backup"
       m.file      "s3.yml",       "config/backup/s3.yml"
       m.file      "ssh.yml",      "config/backup/ssh.yml"
       
+      # Generates the backup.sqlite3 database
+      m.directory "db"
+      m.file      "backup.sqlite3", "db/backup.sqlite3"
+      
     end
   end
   

data/generators/backup_files/templates/db.rake

@@ -0,0 +1,49 @@
+namespace :backup do
+  namespace :db do
+    namespace :truncate do
+
+      desc 'Truncates all the Backup database records; Physical files WILL NOT be deleted.'
+      task :all => :environment do
+        puts "Truncating All!"
+        Backup::BackupRecord::S3.destroy_all
+        Backup::BackupRecord::SSH.destroy_all
+      end
+      
+      desc 'Truncates the S3 Backup database records; Physical files WILL NOT be deleted from S3.'
+      task :s3 => :environment do
+        puts "Truncating S3 Backup database records!"
+        Backup::BackupRecord::S3.destroy_all
+      end
+      
+      desc 'Truncates the SHH database records; Physical files WILL NOT be deleted from remote server.'
+      task :ssh => :environment do
+        puts "Truncating SSH database records!"
+        Backup::BackupRecord::SSH.destroy_all
+      end
+      
+    end
+
+=begin
+    namespace :destroy do
+      
+      desc 'Destroys all Backup database records; Physical files WILL be deleted as well.'
+      task :all => :environment do
+        Backup::BackupRecord::S3.destroy_all_backups
+        Backup::BackupRecord::SSH.destroy_all_backups
+      end
+      
+      desc 'Destroys S3 Backup database records; Physical files WILL be deleted as well.'
+      task :s3 => :s3_config do
+        Backup::BackupRecord::S3.destroy_all_backups
+      end
+      
+      desc 'Destroys SSH Backup database records; Physical files WILL be deleted as well.'
+      task :ssh => :ssh_config do
+        Backup::BackupRecord::SSH.destroy_all_backups
+      end
+      
+    end
+=end
+
+  end
+end

data/generators/{backup_tasks → backup_files}/templates/s3.rake

@@ -11,14 +11,16 @@ namespace :backup do
     desc 'Makes a backup from a MySQL database and transfers it to Amazon S3.'
     task :mysql => :s3_config do
       @config = @config['mysql']
-      Backup::Mysql.new({
+      Backup::Adapter::Mysql.new({
+        :adapter    => 'mysql',
         :mysql => {
           :user     => @config['mysql_config']['user'],
           :password => @config['mysql_config']['password'],
           :database => @config['mysql_config']['database']
         },
         
-        :encrypt => @config['encrypt'],
+        :encrypt      => @config['encrypt'],
+        :keep_backups => @config['keep_backups'],
         
         :use => :s3,
         :s3 => {
@@ -39,11 +41,13 @@ namespace :backup do
     desc 'Makes a backup from a SQLite3 database and transfers it to Amazon S3.'
     task :sqlite3 => :s3_config do
       @config = @config['sqlite3']
-      Backup::Sqlite3.new({
-        :file     => @config['file'],
-        :path     => @config['path'],
-        :encrypt  => @config['encrypt'],
-                
+      Backup::Adapter::Sqlite3.new({
+        :adapter      => 'sqlite3',
+        :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'],
@@ -63,9 +67,11 @@ namespace :backup do
     desc 'Makes a backup from Assets and transfers it to Amazon S3.'
     task :assets => :s3_config do
       @config = @config['assets']
-      Backup::Assets.new({
-        :path     => @config['path'],
-        :encrypt  => @config['encrypt'],
+      Backup::Adapter::Assets.new({
+        :adapter      => 'assets',
+        :path         => @config['path'],
+        :encrypt      => @config['encrypt'],
+        :keep_backups => @config['keep_backups'],
         
         :use => :s3,
         :s3 => {
@@ -113,11 +119,13 @@ namespace :backup do
     desc 'Makes a backup from a Custom database and transfers it to Amazon S3.'
     task :custom => :s3_config do
       @config = @config['custom']
-      Backup::Custom.new({
-        :file     => @config['file'],
-        :path     => @config['path'],
-        :command  => @config['command'],
-        :encrypt  => @config['encrypt'],
+      Backup::Adapter::Custom.new({
+        :adapter      => 'custom',
+        :file         => @config['file'],
+        :path         => @config['path'],
+        :command      => @config['command'],
+        :encrypt      => @config['encrypt'],
+        :keep_backups => @config['keep_backups'],
                 
         :use => :s3,
         :s3 => { 

data/generators/{backup_tasks → backup_files}/templates/s3.yml

@@ -28,6 +28,35 @@
 #  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
@@ -37,12 +66,13 @@ mysql:
   mysql_config:
     user: root
     password: '' 
-    database: my_database
+    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 to encrypt the backup
+  #encrypt: my_secret_password # Uncomment me if you want this functionality
+  #keep_backups: 25 # Uncomment me if you want this functionality
 
 
 # SQLite3 Adapter
@@ -55,7 +85,8 @@ sqlite3:
     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 to encrypt the backup
+  #encrypt: my_secret_password # Uncomment me if you want this functionality
+  #keep_backups: 25 # Uncomment me if you want this functionality
 
 
 # Asset Adapter
@@ -67,8 +98,8 @@ assets:
     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 to encrypt the backup
-
+  #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:
@@ -85,4 +116,5 @@ custom:
     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 to encrypt the backup
+  #encrypt: my_secret_password # Uncomment me if you want this functionality
+  #keep_backups: 25 # Uncomment me if you want this functionality

data/generators/{backup_tasks → backup_files}/templates/ssh.rake

@@ -9,14 +9,16 @@ namespace :backup do
     desc 'Makes a backup from a MySQL database and transfers it through SSH (SCP).'
     task :mysql => :ssh_config do
       @config = @config['mysql']
-      Backup::Mysql.new({
+      Backup::Adapter::Mysql.new({
+        :adapter => 'mysql',
         :mysql => {
           :user     => @config['mysql_config']['user'],
           :password => @config['mysql_config']['password'],
           :database => @config['mysql_config']['database']
         },
         
-        :encrypt => @config['encrypt'],
+        :encrypt      => @config['encrypt'],
+        :keep_backups => @config['keep_backups'],
         
         :use => :ssh,
         :ssh => {
@@ -36,10 +38,12 @@ namespace :backup do
     desc 'Makes a backup from a SQLite3 database and transfers it through SSH (SCP).'
     task :sqlite3 => :ssh_config do
       @config = @config['sqlite3']
-      Backup::Sqlite3.new({
-        :file     => @config['file'],
-        :path     => @config['path'],
-        :encrypt  => @config['encrypt'],
+      Backup::Adapter::Sqlite3.new({
+        :adapter      => 'sqlite3',
+        :file         => @config['file'],
+        :path         => @config['path'],
+        :encrypt      => @config['encrypt'],
+        :keep_backups => @config['keep_backups'],
         
         :use => :ssh,
         :ssh => {
@@ -58,9 +62,11 @@ namespace :backup do
     desc 'Makes a backup from Assets and transfers it through SSH (SCP).'
     task :assets => :ssh_config do
       @config = @config['assets']
-      Backup::Assets.new({
-        :path     => @config['path'],
-        :encrypt  => @config['encrypt'],
+      Backup::Adapter::Assets.new({
+        :adapter      => 'assets',
+        :path         => @config['path'],
+        :encrypt      => @config['encrypt'],
+        :keep_backups => @config['keep_backups'],
         
         :use => :ssh,
         :ssh => { 
@@ -108,11 +114,13 @@ namespace :backup do
     desc 'Makes a backup from a Custom database and transfers it through SSH (SCP).'
     task :custom => :ssh_config do
       @config = @config['custom']
-      Backup::Custom.new({
-        :file     => @config['file'],
-        :path     => @config['path'],
-        :command  => @config['command'],
-        :encrypt  => @config['encrypt'],
+      Backup::Adapter::Custom.new({
+        :adapter      => 'custom',
+        :file         => @config['file'],
+        :path         => @config['path'],
+        :command      => @config['command'],
+        :encrypt      => @config['encrypt'],
+        :keep_backups => @config['keep_backups'],
                 
         :use => :ssh,
         :ssh => { 

data/generators/{backup_tasks → backup_files}/templates/ssh.yml

@@ -30,6 +30,34 @@
 #  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
@@ -42,7 +70,8 @@ mysql:
     user: root
     ip: my-domain.com
     path: '/var/backups'
-  #encrypt: my_secret_password # Uncomment me if you want to encrypt the backup
+  #encrypt: my_secret_password # Uncomment me if you want this functionality
+  #keep_backups: 25 # Uncomment me if you want this functionality
     
     
 # SQLite3 Adapter
@@ -55,8 +84,8 @@ sqlite3:
     user: root
     ip: my-domain.com
     path: '/var/backups'
-  #encrypt: my_secret_password # Uncomment me if you want to encrypt the backup
-
+  #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:
@@ -67,7 +96,8 @@ assets:
     user: root
     ip: my-domain.com
     path: '/var/backups'
-  #encrypt: my_secret_password # Uncomment me if you want to encrypt the backup
+  #encrypt: my_secret_password # Uncomment me if you want this functionality
+  #keep_backups: 25 # Uncomment me if you want this functionality
 
 
 # Custom Adapter
@@ -79,10 +109,11 @@ custom:
     - 'foobar1.sql'
     - 'foobar2.sql'
   command:
-    - 'mysqldump --quick -u root --password="" foobar1 > :rails_root/db/foobar1.sql'
-    - 'mysqldump --quick -u root --password="" foobar2 > :rails_root/db/foobar2.sql'
+    - '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 to encrypt the backup
+  #encrypt: my_secret_password # Uncomment me if you want this functionality
+  #keep_backups: 25 # Uncomment me if you want this functionality

data/lib/backup.rb

@@ -1,15 +1,16 @@
 require 'backup/base'
-require 'backup/sqlite3'
-require 'backup/mysql'
-require 'backup/assets'
-require 'backup/custom'
 require 'backup/encrypt'
+require 'backup/adapter/sqlite3'
+require 'backup/adapter/mysql'
+require 'backup/adapter/assets'
+require 'backup/adapter/custom'
 require 'backup/transfer/base'
 require 'backup/transfer/s3'
 require 'backup/transfer/ssh'
 require 'backup/connection/base'
 require 'backup/connection/s3'
 require 'backup/connection/ssh'
+require 'backup/backup_record/s3'
 
 module Backup
 end

data/lib/backup/adapter/assets.rb

@@ -0,0 +1,54 @@
+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
+      # - Records
+      #   Records the Backup Data to the Backup SQLite3 database
+      # - Remove Temp Files
+      #   Removes temporary files after the process is complete
+      def run
+        archive
+        compress
+        encrypt
+        transfer
+        record
+        remove_temp_files
+      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

@@ -0,0 +1,88 @@
+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
+      # - Records
+      #   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
+        command
+        archive
+        compress
+        encrypt
+        transfer
+        record
+        remove_temp_files
+        remove_original_file
+      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

@@ -0,0 +1,62 @@
+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
+      # - Records
+      #   Records the Backup Data to the Backup SQLite3 database
+      # - Remove Temp Files
+      #   Removes temporary files after the process is complete
+      def run
+        make_mysql_dump
+        compress
+        encrypt
+        transfer
+        record
+        remove_temp_files
+      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

@@ -0,0 +1,46 @@
+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
+      # - Records
+      #   Records the Backup Data to the Backup SQLite3 database
+      # - Remove Temp Files
+      #   Removes temporary files after the process is complete
+      def run
+        compress
+        encrypt
+        transfer
+        record
+        remove_temp_files
+      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

@@ -0,0 +1,81 @@
+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]
+      end
+      
+      def self.destroy_all_backups(options)
+        s3 = Backup::Connection::S3.new(options)
+        s3.connect
+        backups = Backup::BackupRecord::S3.all
+        backups.each do |backup|
+          puts "Destroying backup: #{backup.backup_file}.."
+          s3.destroy(backup.backup_file, backup.bucket)
+          backup.destroy
+        end
+        puts "All S3 Backups Destroyed!"
+      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})
+            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

data/lib/backup/backup_record/ssh.rb

@@ -0,0 +1,68 @@
+require 'net/ssh'
+
+module Backup
+  module BackupRecord
+    class SSH < 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, :ip, :user
+      
+      # 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.backup_path  = options[:ssh][:path]
+        self.keep_backups = options[:keep_backups]
+        self.adapter      = options[:adapter]
+        self.ip           = options[:ssh][:ip]
+        self.user         = options[:ssh][:user]
+      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::SSH.all(:conditions => {:adapter => adapter})
+            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
+              # Establish a connection with the remote server through SSH
+              Net::SSH.start(ip, user) do |ssh|
+                # 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}.."
+                  ssh.exec("rm #{File.join(backup.backup_path, backup.backup_file)}")
+                  backup.destroy
+                end
+              end
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/base.rb

@@ -38,6 +38,24 @@ module Backup
         end
       end
       
+      # Records a backup to the "backup.sqlite3" database
+      # Will destroy any old backups that exceed the amount of
+      # backups that are allowed to be stored on either S3 or any
+      # remote server through SSH.
+      def record        
+        case options[:use]
+          when :s3
+            backup = Backup::BackupRecord::S3.new
+            backup.set_options(options)
+            backup.save
+          
+          when :ssh
+            backup = Backup::BackupRecord::SSH.new
+            backup.set_options(options)
+            backup.save
+        end
+      end
+      
       # Encrypts the backup file
       # Only if the encrypt option is specified inside the .yml config file
       # Otherwise, the encryption will be not be executed.

data/lib/backup/connection/s3.rb

@@ -38,6 +38,13 @@ module Backup
           options[:s3][:bucket] )
       end
       
+      # Destroys file from a bucket on Amazon S3
+      def destroy(backup_file, bucket)
+        object.delete(
+          backup_file,
+          bucket )
+      end
+      
     end
   end 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: backup
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - meskyanichi
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-07 00:00:00 +02:00
+date: 2009-10-08 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,27 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 0.6.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.15
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: net-scp
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.2
     version: 
 description: "\n                          \xE2\x80\x9CBackup\xE2\x80\x9D is a RubyGem, written for Ruby on Rails. It's main purpose is to Backup any\n                          files to Amazon S3 or any remotely accessible server through SSH (SCP). It supports database\n                          and regular file backups. On top of that, it's extremely easy to set up. Backup will provide\n                          a generator script that will place all necessary files inside your Rails application.\n                          Two of which, are \xE2\x80\x9Cyaml\xE2\x80\x9D configuration files. Using just these two files to configure a\n                          backup for database formats such as a MySQL, SQLite3 or any Assets folder.\n                          Setting up \xE2\x80\x9CBackup\xE2\x80\x9D takes only about a minute or two!\n                        "
 email: meskyan@gmail.com
@@ -39,22 +59,26 @@ files:
 - Rakefile
 - VERSION
 - backup.gemspec
-- generators/backup_tasks/backup_tasks_generator.rb
-- generators/backup_tasks/templates/config.rake
-- generators/backup_tasks/templates/s3.rake
-- generators/backup_tasks/templates/s3.yml
-- generators/backup_tasks/templates/ssh.rake
-- generators/backup_tasks/templates/ssh.yml
+- generators/backup_files/backup_files_generator.rb
+- generators/backup_files/templates/backup.sqlite3
+- generators/backup_files/templates/config.rake
+- generators/backup_files/templates/db.rake
+- generators/backup_files/templates/s3.rake
+- generators/backup_files/templates/s3.yml
+- generators/backup_files/templates/ssh.rake
+- generators/backup_files/templates/ssh.yml
 - lib/backup.rb
-- lib/backup/assets.rb
+- lib/backup/adapter/assets.rb
+- lib/backup/adapter/custom.rb
+- lib/backup/adapter/mysql.rb
+- lib/backup/adapter/sqlite3.rb
+- lib/backup/backup_record/s3.rb
+- lib/backup/backup_record/ssh.rb
 - lib/backup/base.rb
 - lib/backup/connection/base.rb
 - lib/backup/connection/s3.rb
 - lib/backup/connection/ssh.rb
-- lib/backup/custom.rb
 - lib/backup/encrypt.rb
-- lib/backup/mysql.rb
-- lib/backup/sqlite3.rb
 - lib/backup/transfer/base.rb
 - lib/backup/transfer/s3.rb
 - lib/backup/transfer/ssh.rb

data/lib/backup/assets.rb

@@ -1,49 +0,0 @@
-module Backup
-  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
-    # - Remove Temp Files
-    #   Removes temporary files after the process is complete
-    def run
-      archive
-      compress
-      encrypt
-      transfer
-      remove_temp_files
-    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

data/lib/backup/custom.rb

@@ -1,83 +0,0 @@
-module Backup
-  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
-    # - 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
-      command
-      archive
-      compress
-      encrypt
-      transfer
-      remove_temp_files
-      remove_original_file
-    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

data/lib/backup/mysql.rb

@@ -1,57 +0,0 @@
-module Backup
-  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
-    # - Remove Temp Files
-    #   Removes temporary files after the process is complete
-    def run
-      make_mysql_dump
-      compress
-      encrypt
-      transfer
-      remove_temp_files
-    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

data/lib/backup/sqlite3.rb

@@ -1,41 +0,0 @@
-module Backup
-  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
-    # - Remove Temp Files
-    #   Removes temporary files after the process is complete
-    def run
-      compress
-      encrypt
-      transfer
-      remove_temp_files
-    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