backup 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 meskyanichi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,237 @@
+= Backup
+
+Backup is a gem/plugin that enables you to very easily create backups and transfer these to Amazon S3 or another server using SSH.
+It currently supports MySQL, SQLite3 and basic Assets (documents, images, etc) inside a folder. The files will get tar'd / gzip'd and get a timestamp-prefix.
+After the backup file has been created, it can be transferred to either Amazon S3 or any remote server through SSH.
+
+== Installation
+
+=== Add Repository Source(s)
+
+  gem sources -a http://gemcutter.org
+  gem sources -a http://gems.github.com
+
+=== Gem
+
+  # Gem Cutter
+  sudo gem install backup
+  
+  # GitHub
+  sudo gem install meskyanichi-backup
+
+=== Plugin
+
+  ./script/plugin install git://github.com/meskyanichi/backup.git
+
+
+=== Dependencies
+
+  # This will automatically install when installing the Backup gem.
+  # If you are using the Plugin, instead of the gem, be sure to install the aws-s3 gem.
+  sudo gem install aws-s3
+
+
+== Getting started
+
+Well, this is ridiculously easy to set up! So let's do this.
+First install either the gem or plugin.
+
+If you are using the gem version you "must" add the following line to your environment.rb file
+
+==== config/environment.rb
+
+  # For GemCutter Version
+  config.gem "backup", :lib => "backup", :version => "0.1.0", :source => "http://gemcutter.org"
+  
+  # For GitHub Version
+  config.gem "meskyanichi-backup", :lib => "backup", :version => "0.1.0", :source => "http://gems.github.com"
+
+Once that's done, run the following command from the "root" of your Rails App
+
+  ./script/generate backup_rake_tasks
+  
+
+This will generate two rake tasks and a README inside your "#{RAILS_ROOT}/lib/tasks/backup" folder.
+- README.rdoc
+- s3.rake
+- ssh.rake
+
+Open and read the README.rdoc if you want. It will explain everything very quickly, though, I doubt there is much to explain!
+Then (or otherwise) open the "s3.rake" and "ssh.rake" rake task files. These include all the rake tasks/combinations that are (currently!) available.
+Above each task inside these files is a description, explaining what you must do, again, "very" straight forward. Stupidly Easy to set up, thankfully!
+
+After you've set up the tasks you wish to utilize (obviously you don't need to use all of them, you can simply just choose to use one of them),
+they are all generated so you can basically just fill in the configuration values and be done with it. You obviously don't have to fill in the configuration
+for any rake tasks you are not going to use.
+
+That's it! So you have now done two things:
+- Configured the Rake Files (just filled in the empty values)
+- And at the same time, these are the executable rake tasks you will be using to create a backup
+
+Just run one of the configured rake tasks to perform a backup!
+
+== Example
+
+So let me give an example of what one of these rake tasks will look like:
+
+==== Rake Task for Backing up a Sqlite3 file to S3
+
+  task :sqlite3 => :environment do
+    Backup::Sqlite3.new({
+      :file => 'production.sqlite3',
+      
+      :use => :s3,
+      :s3 => {
+        :access_key_id      => 'your-s3-id',
+        :secret_access_key  => 'your-s3-password',
+        :bucket             => 'your-bucket-to-backup-to'
+      }
+    }).run
+  end
+
+So this is one of the rake that's that the generator provides. Simple, isn't it?
+Just fill in the values and run:
+
+  rake backup:s3:sqlite3
+
+==== Rake Task for Backing up a Sqlite3 file to another server through SSH
+
+  task :sqlite3 => :environment do
+    Backup::Sqlite3.new({
+      :file => 'production.sqlite3',
+     
+      :use => :ssh,
+      :ssh => {
+        :user => "root",
+        :ip   => "123.45.678.90", # OR my-domain.com
+        :path => "/var/backups/etc"
+      }
+    }).run
+  end
+
+Again, quick and easy. Now just execute this Backing/SSH transfer by running:
+
+  rake backing:ssh:sqlite3
+
+
+See below what the requirements are when using S3 or SSH.
+
+== Requirements
+
+=== Using Amazon S3
+
+This obviously requires you to have access to an Amazon S3 account.
+These accounts are free and you only get charged for what you actually "use".
+So no transfers = no cost. And aside of that, S3 is EXTREMELY cheap!
+
+You can get an account here: http://aws.amazon.com/s3
+
+Once you have an account you must install the AWS S3 gem, like so:
+
+  sudo gem install aws-s3
+
+Backup makes use of the "aws-s3" gem to connect to Amazon S3. This is a dependency and will be installed when installing the Backup gem.
+If you are using the plugin, you will need to manually install it.
+
+=== Using SSH
+
+If you're using SSH then there is one thing you must do. You must provide the machine that's going to "receive" your backups
+your machine's (the senders) ssh-key. This is basically what you did with GitHub so you could push data to your GitHub repository
+without getting prompted for a password.
+
+=== Setting Up A Key For SSH
+
+Setting up SSH Keychains is quite simple.
+
+SSH to the "production" server and run the following command:
+  ssh-keygen -t rsa
+
+It will prompt you 3 times, first it will ask what you wish to call the filename.
+
+Just hit enter every time, do "not" fill in a password. 
+
+This will generate two files in the ~/.ssh/ directory, namely:
+- id_rsa
+- id_rsa.pub
+
+So, now that the files are generated, holding the authorization keys, you can use these on any server you wish to login to without using a password.
+The procedure accomplishing this is easy.
+
+First, we will ensure there is a .ssh directory on the "backup" server by running the following command:
+  ssh root@your_ip mkdir -p .ssh
+
+Once that's in place, we will append our newly (or already existing) key to the backup servers' .ssh/authorized_keys file.
+  cat ~/.ssh/id_rsa.pub | ssh root@server.com 'cat >> .ssh/authorized_keys'
+
+Done. Now the key, generated on your "production" server, has been inserted inside the ".ssh/authorized_keys" file on the Backup server.
+You should now be set to run all SSH rake tasks that have been configured to work with that particular Backup server.
+
+==== Note: If the "authorized_keys" file does not yet exist, it will be automatically be created.
+
+
+== Periodical Backups (using the "rake tasks" and a "cron")
+
+Assuming you will want to run these backups (rake tasks) periodically.
+What I currently use to run them is the "javan-whenever" gem. This is a very simple, easy to use gem
+that makes it EXTREMELY simple to manage cron, using Ruby syntax. To understand what I mean, see the example below!
+
+
+=== Javan's Whenever Gem Example
+
+With this gem you can basically get periodic backup execution as easy as this:
+
+  every 2.hours do
+    rake "backup:s3:sqlite3"
+  end
+
+Obviously this will update the crontab to make SQLite3 backups and store them on Amazon S3 every 2 hours.
+If you want to do multiple backups, like perhaps backup your MySQL database, along with your assets:
+
+  every 2.hours do
+    rake "backup:s3:mysql"
+    rake "backup:s3:assets"
+  end
+
+So yes, I highly recommend using the javan-whenever gem for this. It's very easy to write and maintain the crontab this way.
+For more information on this gem and on how to use it: http://github.com/javan/whenever
+Also, Ryan Bates has created a screencast for this gem, see it here: http://railscasts.com/episodes/164-cron-in-ruby
+It's awesome, go check it out!
+
+
+== Resources
+
+So let me sum up the resources
+
+==== My Backup Gem
+  sudo gem install backup
+  or
+  sudo gem install meskyanichi-backup
+
+==== AWS-S3 Gem
+  sudo gem install aws-s3
+
+==== Whenever Gem
+  sudo gem install javan-whenever
+  http://railscasts.com/episodes/164-cron-in-ruby
+
+==== Amazon S3 Account Creation
+  http://aws.amazon.com/s3
+
+
+==== Notes:
+
+If you are going to use Amazon S3 to store your backups, be sure to install "AWS-S3".
+
+If you want a nice and super easy way of managing the crontab and do periodical backups, install "Whenever".
+
+Watch the Whenever Gem Screencast by Ryan Bates: http://railscasts.com/episodes/164-cron-in-ruby
+
+
+== Requests
+
+If anyone wishes to see support for PostgreSQL or any other database format, please send me a message!
+
+
+== Copyright
+
+Copyright (c) 2009 Michael van Rooijen | Final Creation. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "backup"
+    gem.summary = %Q{Backup is a gem/plugin that enables you to very easily create backups and transfer these to Amazon S3 or another server with SSH.}
+    gem.description = %Q{Backup is a gem/plugin that enables you to very easily create backups and transfer these to Amazon S3 or another server with SSH.
+                        It currently supports MySQL, SQLite3 and basic Assets (documents, images, etc). The files will get tar'd / gzip'd and get a timestamp.
+                        After creation, these files can be transferred to either Amazon S3 or any remote server through SSH.}
+    gem.email = "meskyan@gmail.com"
+    gem.homepage = "http://github.com/meskyanichi/backup"
+    gem.authors = ["meskyanichi"]
+    gem.add_dependency "aws-s3"
+#    gem.files.include 'generators/**/*'
+#    gem.files.include 'lib/**/*'
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "backup #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/backup.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{backup}
+  s.version = "0.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-03}
+  s.description = %q{Backup is a gem/plugin that enables you to very easily create backups and transfer these to Amazon S3 or another server with SSH.
+                        It currently supports MySQL, SQLite3 and basic Assets (documents, images, etc). The files will get tar'd / gzip'd and get a timestamp.
+                        After creation, these files can be transferred to either Amazon S3 or any remote server through SSH.}
+  s.email = %q{meskyan@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "backup.gemspec",
+     "generators/backup_rake_tasks/backup_rake_tasks_generator.rb",
+     "generators/backup_rake_tasks/templates/README.rdoc",
+     "generators/backup_rake_tasks/templates/s3.rake",
+     "generators/backup_rake_tasks/templates/ssh.rake",
+     "lib/backup.rb",
+     "lib/backup/assets.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/mysql.rb",
+     "lib/backup/sqlite3.rb",
+     "lib/backup/transfer/base.rb",
+     "lib/backup/transfer/s3.rb",
+     "lib/backup/transfer/ssh.rb"
+  ]
+  s.homepage = %q{http://github.com/meskyanichi/backup}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Backup is a gem/plugin that enables you to very easily create backups and transfer these to Amazon S3 or another server with SSH.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    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"])
+    else
+      s.add_dependency(%q<aws-s3>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<aws-s3>, [">= 0"])
+  end
+end

data/generators/backup_rake_tasks/backup_rake_tasks_generator.rb

@@ -0,0 +1,56 @@
+class BackupRakeTasksGenerator < 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
+    extract_args
+    set_defaults
+    confirm_input
+  end
+  
+  # Processes the file generation/templating
+  # This will automatically be run after the initialize method
+  def manifest
+    record do |m|
+      m.directory "lib/tasks/"
+      m.directory "lib/tasks/backup"
+      m.file      "README.rdoc",  "lib/tasks/backup/README.rdoc"
+      m.file      "s3.rake",      "lib/tasks/backup/s3.rake"
+      m.file      "ssh.rake",     "lib/tasks/backup/ssh.rake"
+    end
+  end
+  
+  # Creates a new Hash Object containing the user input
+  # The user input will be available through @input and input
+  def extract_args
+    @input = Hash.new
+    @args.each do |arg|
+      if arg.include?(":") then
+        @input[:"#{arg.slice(0, arg.index(":"))}"] = arg.slice((arg.index(":") + 1)..-1)
+      end
+    end
+  end
+  
+  # Input Method that's available inside the generated templates
+  # because instance variable are not available, so we access them through methods
+  def input
+    @input
+  end
+
+  # Sets defaults for user input when left blank by the user
+  # for each parameter
+  def set_defaults
+  end
+  
+  # Confirms whether the model and attachment arguments were passed in
+  # Raises an error if not
+  def confirm_input
+  end
+  
+  private
+  
+  def input_error
+  end
+  
+end

data/generators/backup_rake_tasks/templates/README.rdoc

@@ -0,0 +1,25 @@
+* Backup's Generated Rake Tasks
+	http://github.com/meskyanichi/backup
+
+Quite simple, the generator has now generated all (currently!) possible backup options in the form of rake tasks!
+Just open the desired backup-method's file (S3 or SHH or BOTH!). The basic structure of every task is already setup correctly.
+Above each task you will find a description about the settings of each task. Please be sure to read this first before asking questions.
+
+All in all this is extremely straight forward, there is no need to setup anything else inside your Rails Application other than installing the plugin,
+running (this) generator and changing the values inside the rake task files.
+
+Here is a list of the current rake tasks that are available:
+
+backup:s3:mysql
+backup:s3:sqlite3
+backup:s3:assets
+backup:s3:custom
+backup:ssh:mysql
+backup:ssh:sqlite3
+backup:ssh:assets
+backup:ssh:custom
+
+
+So now you have rake tasks for all your essential backups.
+What I like to do is use a cronjob manager gem to manage my cronjobs to trigger these rake tasks.
+javan-whenever is a good gem for doing this! Try it, or any other method you can think of to trigger these rake tasks periodically.

data/generators/backup_rake_tasks/templates/s3.rake

@@ -0,0 +1,119 @@
+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.
+    task :mysql => :environment do
+      Backup::Mysql.new({
+        :mysql => {
+          :user     => "",
+          :password => "",
+          :database => ""
+        },
+        
+        :use => :s3,
+        :s3 => {
+          :access_key_id      => '',
+          :secret_access_key  => '',
+          :bucket             => 'mybucket/backups/etc'
+        }
+      }).run
+    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.
+    task :sqlite3 => :environment do
+      Backup::Sqlite3.new({
+        :file => 'production.sqlite3', # "production.sqlite3" is default, can remove the whole :file attribute or change it's value
+        
+        :use => :s3,
+        :s3 => {
+          :access_key_id      => '',
+          :secret_access_key  => '',
+          :bucket             => 'mybucket/backups/etc'
+        }
+      }).run
+    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.
+    task :assets => :environment do
+      Backup::Assets.new({
+        :path => "#{RAILS_ROOT}/public/assets",
+        
+        :use => :s3,
+        :s3 => {
+          :access_key_id      => '',
+          :secret_access_key  => '',
+          :bucket             => 'mybucket/backups/etc'
+        }
+      }).run
+    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.
+    task :custom => :environment do
+      Backup::Custom.new({
+        :command  => ["mysqldump --quick -u root --password='' foobar > #{RAILS_ROOT}/db/foobar1.sql",
+                      "mysqldump --quick -u root --password='' foobar > #{RAILS_ROOT}/db/foobar2.sql"],
+                      
+        :path     => "#{RAILS_ROOT}/db",
+        :file     => ["foobar1.sql","foobar2.sql"],
+                
+        :use => :s3,
+        :s3 => { 
+          :access_key_id      => '',
+          :secret_access_key  => '',
+          :bucket             => 'mybucket/backups/etc'
+        }
+      }).run
+    end
+  end
+end

data/generators/backup_rake_tasks/templates/ssh.rake

@@ -0,0 +1,114 @@
+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.
+    task :mysql => :environment do
+      Backup::Mysql.new({
+        :mysql => {
+          :user     => "",
+          :password => "",
+          :database => ""
+        },
+        
+        :use => :ssh,
+        :ssh => {
+          :user => "root",
+          :ip   => "mydomain.com", # or: 123.45.678.90
+          :path => "/var/backups/etc"
+        }
+      }).run
+    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.
+    task :sqlite3 => :environment do
+      Backup::Sqlite3.new({
+        :file => 'production.sqlite3', # "production.sqlite3" is default, can remove the whole :file attribute or change it's value
+        
+        :use => :ssh,
+        :ssh => {
+          :user => "root",
+          :ip   => "mydomain.com", # or: 123.45.678.90
+          :path => "/var/backups/etc"
+        }
+      }).run
+    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.
+    task :assets => :environment do
+      Backup::Assets.new({
+        :path => "#{RAILS_ROOT}/public/assets",
+        
+        :use => :ssh,
+        :ssh => { 
+          :user => "root",
+          :ip   => "mydomain.com", # or: 123.45.678.90
+          :path => "/var/backups/etc"
+        }
+      }).run
+    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.
+    task :custom => :environment do
+      Backup::Custom.new({
+        :command  => ["mysqldump --quick -u root --password='' foobar > #{RAILS_ROOT}/db/foobar1.sql",
+                      "mysqldump --quick -u root --password='' foobar > #{RAILS_ROOT}/db/foobar2.sql"],
+                      
+        :path     => "#{RAILS_ROOT}/db",
+        :file     => ["foobar1.sql", "foobar2.sql"],
+                
+        :use => :ssh,
+        :ssh => { 
+          :user => "root",
+          :ip   => "mydomain.com", # or: 123.45.678.90
+          :path => "/var/backups/etc"
+        }
+      }).run
+    end
+  end
+end

data/lib/backup.rb

@@ -0,0 +1,14 @@
+require 'backup/base'
+require 'backup/sqlite3'
+require 'backup/mysql'
+require 'backup/assets'
+require 'backup/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'
+
+module Backup
+end

data/lib/backup/assets.rb

@@ -0,0 +1,31 @@
+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
+    
+    def run
+      archive
+      compress
+      transfer
+      remove_temp_files
+    end
+    
+    private
+      
+      def archive
+        %x{ tar -cf #{File.join(options[:backup_path], options[:backup_file])} #{options[:path]} }
+      end
+      
+      def compress
+        %x{ gzip --best #{File.join(options[:backup_path], options[:backup_file])} }
+      end
+      
+      def default_options
+        { :path => "#{RAILS_ROOT}/public/assets", :file => "assets" }
+      end
+    
+  end
+end

data/lib/backup/base.rb

@@ -0,0 +1,46 @@
+module Backup
+  class Base
+    
+    attr_accessor :options, :backup_time
+    
+    def initialize(options = {})
+      self.options      = options
+      self.backup_time  = Time.now.strftime("%Y%m%d%H%M%S") 
+    end
+    
+    private
+    
+      def setup_paths(path, type = nil)
+        %x{ mkdir -p #{RAILS_ROOT}/tmp/backups/#{path} }
+        options[:backup_path] = "#{RAILS_ROOT}/tmp/backups/#{path}"
+        
+        if options[:file].is_a?(Array)
+          options[:backup_file] = "#{backup_time}-#{options[:file].first}.#{type}"
+        else
+          options[:backup_file] = "#{backup_time}-#{options[:file]}.#{type}"
+        end
+      end
+    
+      def transfer
+        case options[:use]
+          when :s3  then Backup::Transfer::S3.new(options)
+          when :ssh then Backup::Transfer::SSH.new(options)
+        end
+      end
+      
+      def remove_temp_files
+        %x{ rm #{File.join(options[:backup_path], "*")} }
+      end
+      
+      def remove_original_file
+        if options[:file].is_a?(Array)
+          options[:file].each do |file|
+            %x{ rm #{File.join(options[:path], file)} }          
+          end
+        else
+          %x{ rm #{File.join(options[:path], options[:file])} }
+        end
+      end
+      
+  end
+end

data/lib/backup/connection/base.rb

@@ -0,0 +1,13 @@
+module Backup
+  module Connection
+    class Base
+      
+      attr_accessor :options
+      
+      def initialize(options)
+        self.options = options
+      end
+
+    end
+  end
+end

data/lib/backup/connection/s3.rb

@@ -0,0 +1,30 @@
+module Backup
+  module Connection
+    class S3 < Backup::Connection::Base
+      
+      def initialize(options = {})
+        super(options)
+      end
+      
+      def connect
+        AWS::S3::Base.establish_connection!(
+          :access_key_id     => options[:s3][:access_key_id], 
+          :secret_access_key => options[:s3][:secret_access_key]
+        )
+      end
+      
+      def service
+        AWS::S3::Service
+      end
+      
+      def bucket
+        AWS::S3::Bucket
+      end
+      
+      def object
+        AWS::S3::S3Object
+      end
+      
+    end
+  end 
+end

data/lib/backup/connection/ssh.rb

@@ -0,0 +1,16 @@
+module Backup
+  module Connection
+    class SSH < Backup::Connection::Base
+      
+      def initialize(options = {})
+        super(options)
+      end
+      
+      def store
+        %x{ ssh #{options[:ssh][:user]}@#{options[:ssh][:ip]} mkdir -p #{options[:ssh][:path]} }
+        %x{ scp #{File.join(options[:backup_path], options[:backup_file])} #{options[:ssh][:user]}@#{options[:ssh][:ip]}:#{options[:ssh][:path]} }
+      end
+
+    end
+  end 
+end

data/lib/backup/custom.rb

@@ -0,0 +1,55 @@
+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
+    
+    def run
+      command
+      archive
+      compress
+      transfer
+      remove_temp_files
+      remove_original_file unless options[:keep_original_files].eql?(true)
+    end
+    
+    private
+    
+      def command
+        if options[:command].is_a?(Array)
+          options[:command].each do |command|
+            %x{ #{command} }
+          end
+        else
+          %x{ #{options[:command]} }
+        end
+      end
+      
+      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
+      
+      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
+      
+      def default_options
+        { :path     => "",
+          :file     => "",
+          :command  => "",
+          :keep_original_files => false }
+      end
+    
+  end  
+end

data/lib/backup/mysql.rb

@@ -0,0 +1,38 @@
+module Backup
+  class Mysql < Backup::Base
+    
+    def initialize(options = {})
+      super(default_options.merge(options))
+      setup_paths("db/#{self.class.name.downcase.gsub('::','-')}", :gz)
+    end
+    
+    def run
+      make_mysql_dump
+      compress
+      transfer
+      remove_temp_files
+    end
+
+    private
+    
+      def compress
+        %x{ gzip -cv #{File.join(options[:path], options[:file])} --best > #{File.join(options[:backup_path], options[:backup_file])} }
+      end
+    
+      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
+    
+      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

@@ -0,0 +1,27 @@
+module Backup
+  class Sqlite3 < Backup::Base
+    
+    def initialize(options = {})
+      super(default_options.merge(options))
+      setup_paths("db/#{self.class.name.downcase.gsub('::','-')}", :gz)
+    end
+    
+    def run
+      compress
+      transfer
+      remove_temp_files
+    end
+    
+    private
+      
+      def compress
+        %x{ gzip -cv #{File.join(options[:path], options[:file])} --best > #{File.join(options[:backup_path], options[:backup_file])} }
+      end
+      
+      def default_options
+        { :path => "#{RAILS_ROOT}/db",
+          :file => "production.sqlite3" }
+      end
+    
+  end  
+end

data/lib/backup/transfer/base.rb

@@ -0,0 +1,13 @@
+module Backup
+  module Transfer
+    class Base
+      
+      attr_accessor :options
+      
+      def initialize(options)
+        self.options = options
+      end
+      
+    end
+  end
+end

data/lib/backup/transfer/s3.rb

@@ -0,0 +1,30 @@
+require 'aws/s3'
+
+module Backup
+  module Transfer
+    class S3 < Backup::Transfer::Base
+    
+      def initialize(options)
+        super(default_options.merge(options))
+        
+        s3 = Backup::Connection::S3.new(options)
+        s3.connect
+        s3.object.store(
+          options[:backup_file],
+          open(File.join(options[:backup_path], options[:backup_file])),
+          options[:s3][:bucket] )
+      end
+      
+      private
+      
+        def default_options
+          {:s3 => {
+              :access_key_id      => '',
+              :secret_access_key  => '',
+              :bucket             => ''
+            }}
+        end
+      
+    end
+  end
+end

data/lib/backup/transfer/ssh.rb

@@ -0,0 +1,24 @@
+module Backup
+  module Transfer
+    class SSH < Backup::Transfer::Base
+      
+      def initialize(options)
+        super(default_options.merge(options))
+        
+        ssh = Backup::Connection::SSH.new(options)
+        ssh.store
+      end
+      
+      private
+      
+        def default_options
+          {:ssh => {
+            :user => "",
+            :ip   => "",
+            :path => "/var/backups/"
+          }}
+        end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: backup
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- meskyanichi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-03 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: aws-s3
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: |-
+  Backup is a gem/plugin that enables you to very easily create backups and transfer these to Amazon S3 or another server with SSH.
+                          It currently supports MySQL, SQLite3 and basic Assets (documents, images, etc). The files will get tar'd / gzip'd and get a timestamp.
+                          After creation, these files can be transferred to either Amazon S3 or any remote server through SSH.
+email: meskyan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- backup.gemspec
+- generators/backup_rake_tasks/backup_rake_tasks_generator.rb
+- generators/backup_rake_tasks/templates/README.rdoc
+- generators/backup_rake_tasks/templates/s3.rake
+- generators/backup_rake_tasks/templates/ssh.rake
+- lib/backup.rb
+- lib/backup/assets.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/mysql.rb
+- lib/backup/sqlite3.rb
+- lib/backup/transfer/base.rb
+- lib/backup/transfer/s3.rb
+- lib/backup/transfer/ssh.rb
+has_rdoc: true
+homepage: http://github.com/meskyanichi/backup
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Backup is a gem/plugin that enables you to very easily create backups and transfer these to Amazon S3 or another server with SSH.
+test_files: []
+