backup-rails 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2ZiNjBmNjIyY2Q2OTJmNzYyMWIxYzhmYzA0M2UxYTMwYTFkZWYyZA==
+  data.tar.gz: !binary |-
+    OGE5ODc1NTk0Yjg5MTBkNTRkM2Q4M2NjYTUyYzIyZjU2NjgwYTY5Ng==
+SHA512:
+  metadata.gz: !binary |-
+    YTQwODczYjIxNGZmYTQ5OWQ3ZGEzMGQ5MDBlZTc1NzY0MDA2ZGM1NWMyYzA2
+    MWJkOTE1OWM2MTBmYzFiMTEwZTE2NWUzODYzZTk4YzIyNWZkYjJiNDVmOWQw
+    OTdjNDhhMmQwODE2OWEyMDI5MWRiMTljYzM0ZTE3YjU1ZWJmNWE=
+  data.tar.gz: !binary |-
+    N2Q0Y2Q4NTkxZmJmODA4NzczZTk1OWMyMTBhMzFiNjkzMWJmYzY4MGRmOGYy
+    NDAwYWZiZWM4ZmI0ODM4MzM5ZWRhZjFkYmI0N2NkYmY1ZmFmZjI2OWIzNTVh
+    YjMyYmQ5MWIxMGY4ODgwOTYwZjNhZjRhNDQ0MDM5Y2I5N2VjNmM=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.env
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--fail-fast
+--format documentation

data/Gemfile

@@ -0,0 +1,23 @@
+source 'https://rubygems.org'
+
+group :development, :test do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-bundler'
+
+  gem 'rspec'
+  #gem 'generator_spec', github: "jesson/generator_spec"
+  gem 'rb-inotify'
+  gem 'thor'
+
+  gem 'rails', '~> 3.2.16'
+  gem 'sqlite3'
+  gem 'mysql2'
+  gem 'mongoid'
+  gem 'pg'
+  gem 'bson_ext'
+end
+
+# Specify your gem's dependencies in backup-rails.gemspec
+gemspec
+

data/Guardfile

@@ -0,0 +1,31 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  # Uncomment next line if Gemfile contain `gemspec' command
+  # watch(/^.+\.gemspec/)
+end
+
+guard 'rspec', cli: "--fail-fast" do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Oleg Bavaev
+
+MIT License
+
+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.md

@@ -0,0 +1,29 @@
+# Backup::Rails
+
+Backup rails project with backup & whenever gems
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'backup-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install backup-rails
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/backup-rails.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'backup-rails/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "backup-rails"
+  gem.version       = Backup::Rails::VERSION
+  gem.authors       = ["Oleg Bavaev"]
+  gem.email         = ["jesoba7@gmail.com"]
+  gem.description   = %q{Backup rails project with backup & whenever gems}
+  gem.summary       = %q{Backup rails project}
+  gem.homepage      = "https://github.com/jesson/backup-rails"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'backup', '>= 3.4.0'
+  gem.add_dependency 'whenever'
+  gem.add_dependency 'dotenv-rails'
+  gem.add_dependency 'fog', '~> 1.9'
+  gem.add_dependency 'net-ssh', '>= 2.3.0', '<= 2.5.2'
+  gem.add_dependency 'excon', '~> 0.17.0'
+end
+

data/bin/backup_rails

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby
+require 'thor'
+require 'dotenv'
+require 'yaml'
+
+class BackupRailsCLI < Thor
+  include Thor::Actions
+
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+
+  desc "restore ARCHIVE DESTINATION", "Restore files from backup file"
+  method_option :ssl_password,
+                :aliases => ['-sp'],
+                :required => false,
+                :type => :string,
+                :desc => "password for SSL encrypt"
+  def restore archive_path, destination_path
+    puts "Restoring from #{archive_path}"
+
+    Dotenv.load
+
+    dir = Dir.mktmpdir
+
+    begin
+      if options[:ssl_password]
+        # decrypt & untar
+        create_file dir + "/simple.txt", options[:ssl_password]
+        system "cd #{dir} && openssl aes-256-cbc -d -base64 -pass file:simple.txt -in #{archive_path} -out restore.tar && rm simple.txt"
+        system "cd #{dir} && tar -xf restore.tar"
+      else
+        # untar
+        system "cd #{dir} && tar -xf #{archive_path}"
+      end
+      # unpacking code
+      system "mkdir -p #{destination_path} && cd #{destination_path} && tar -xf #{dir}/general/archives/code.tar.gz"
+
+      # restore database
+      environment = 'production'
+      if File.exists? destination_path + "/config/database.yml"
+        dbconfig = YAML::load(ERB.new(IO.read(File.join(destination_path, 'config', 'database.yml'))).result)[environment]
+
+        if dbconfig['adapter'] == 'mysql2'
+          run "echo \"create database #{dbconfig['database']}\" | mysql -u #{dbconfig['username']} --password=#{dbconfig['password']}"
+          run "cd #{dir}/general/databases && gzip -d MySQL.sql.gz"
+          run "cd #{dir}/general/databases && mysql -u #{dbconfig['username']} --password=#{dbconfig['password']} #{dbconfig['database']} < MySQL.sql"
+        elsif dbconfig['adapter'] == 'postgresql'
+          run "export PGPASSWORD=#{dbconfig['password']} && createdb -U#{dbconfig['username']} #{dbconfig['database']}"
+          run "cd #{dir}/general/databases && gzip -d PostgreSQL.sql.gz"
+          run "cd #{dir}/general/databases && export PGPASSWORD=#{dbconfig['password']} && psql -U#{dbconfig['username']} #{dbconfig['database']} < PostgreSQL.sql"
+        end
+      end
+      # mongoid
+      if File.exists? destination_path + "/config/mongoid.yml"
+        dbconfig = YAML::load(ERB.new(IO.read(File.join(destination_path, 'config', 'mongoid.yml'))).result)[environment]
+        dbconfig = dbconfig['sessions']['default']
+        run "cd #{dir}/general/databases && tar -xf MongoDB.tar.gz"
+        options = { username: dbconfig['username'], password: dbconfig['password'], db: dbconfig['database'] }
+        params = options.select {|k,v| !v.nil? && !v.empty? }.map {|k,v| "--#{k} #{v}"}.join(" ")
+        run "cd #{dir}/general/databases && mongorestore #{params} #{dir}/general/databases/MongoDB/#{dbconfig['database']}"
+      end
+
+    ensure
+      # remove the directory.
+      #FileUtils.remove_entry_secure dir
+    end
+  end
+end
+
+BackupRailsCLI.start

data/lib/backup-rails/version.rb

@@ -0,0 +1,5 @@
+module Backup
+  module Rails
+    VERSION = "1.0.0"
+  end
+end

data/lib/backup-rails.rb

@@ -0,0 +1,12 @@
+require "backup-rails/version"
+require "rails"
+
+module Backup
+  module Rails
+    class Railtie < ::Rails::Railtie
+      rake_tasks do
+        load "tasks/backup.rake"
+      end
+    end
+  end
+end

data/lib/generators/backup/rails/install_generator.rb

@@ -0,0 +1,32 @@
+require 'rails/generators'
+
+module Backup
+  module Rails
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        desc "Generates configurations for backup and whenever"
+
+        def self.source_root
+          @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+        end
+
+        # Generator Code. Remember this is just suped-up Thor so methods are executed in order
+        def install
+          run "bundle exec backup generate:config --config-path=config/backup"  unless File.exists?("config/backup/config.rb")
+          template "general.rb", "config/backup/models/general.rb"
+          if File.exists? ".env"
+            append_file ".env" do
+              File.read(File.expand_path(find_in_source_paths('.env')))
+            end
+          else
+            template ".env"
+          end
+          run "bundle exec wheneverize ."  unless File.exists?("config/schedule.rb")
+          append_file "config/schedule.rb" do
+            File.read(File.expand_path(find_in_source_paths('schedule.rb')))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/generators/backup/rails/templates/general.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+require 'dotenv'
+require "rails"
+
+##
+# Backup Generated: general
+# Once configured, you can run the backup with the following command:
+#
+# $ backup perform -t general [-c <path_to_configuration_file>]
+#
+Backup::Model.new(:general, 'Description for general') do
+  Dotenv.load
+
+  root_path = File.dirname(__FILE__)
+  archive :code do |archive|
+    archive.root root_path
+    archive.add "."
+    archive.exclude root_path + '/log'
+    archive.exclude root_path + '/tmp'
+  end
+
+  compress_with Gzip do
+
+  end
+
+  if ENV['SSL_PASSWORD']
+    encrypt_with OpenSSL do |encryption|
+      encryption.password = ENV['SSL_PASSWORD']
+      encryption.base64   = true
+      encryption.salt     = true
+    end
+  end
+
+  if File.exists? root_path + "/config/database.yml"
+    environment = 'production'
+    dbconfig = YAML::load(ERB.new(IO.read(File.join(root_path, 'config', 'database.yml'))).result)[environment]
+    if dbconfig['adapter'] == 'mysql2'
+      database MySQL do |db|
+        db.name               = dbconfig['database']
+        db.username           = dbconfig['username']
+        db.password           = dbconfig['password']
+        db.host               = dbconfig['host']
+        db.port               = dbconfig['port']
+        db.socket             = dbconfig['socket']
+      end
+    elsif dbconfig['adapter'] == 'postgresql'
+      database PostgreSQL do |db|
+        db.name               = dbconfig['database']
+        db.username           = dbconfig['username']
+        db.password           = dbconfig['password']
+        db.host               = dbconfig['host']
+        db.port               = dbconfig['port']
+        db.socket             = dbconfig['socket']
+      end
+    end
+  end
+
+  if File.exists? root_path + "/config/mongoid.yml"
+    environment = 'production'
+    dbconfig = YAML::load(ERB.new(IO.read(File.join(root_path, 'config', 'mongoid.yml'))).result)[environment]
+    if dbconfig
+      database MongoDB do |db|
+        db.name               = dbconfig['sessions']['default']['database']
+        db.username           = dbconfig['sessions']['default']['username']
+        db.password           = dbconfig['sessions']['default']['password']
+        #db.host               = dbconfig['host']
+        #db.port               = dbconfig['port']
+        db.ipv6               = false
+        db.lock               = false
+        db.oplog              = false
+      end
+    end
+  end
+
+  if ENV['LOCAL_PATH']
+    store_with Local do |local|
+      local.path = ENV['LOCAL_PATH']
+      local.keep = 5
+    end
+  end
+
+  if ENV['S3_ACCESS_KEY_ID'] && ENV['S3_SECRET_ACCESS_KEY'] && ENV['S3_BUCKET']
+    store_with S3 do |s3|
+      # AWS Credentials
+      s3.access_key_id     = ENV['S3_ACCESS_KEY_ID']
+      s3.secret_access_key = ENV['S3_SECRET_ACCESS_KEY']
+      # Or, to use a IAM Profile:
+      # s3.use_iam_profile = true
+
+      s3.region             = ENV['S3_REGION']
+      s3.bucket             = ENV['S3_BUCKET']
+      #s3.path               = ENV['S3_PATH']
+    end
+  end
+
+  if ENV['NOTIFY_MAIL_USER_NAME']
+    notify_by Mail do |mail|
+      mail.on_success           = true
+      mail.on_warning           = true
+      mail.on_failure           = true
+
+      mail.from                 = ENV['NOTIFY_MAIL_FROM']
+      mail.to                   = ENV['NOTIFY_MAIL_TO']
+      mail.address              = ENV['NOTIFY_MAIL_ADDRESS']
+      mail.port                 = ENV['NOTIFY_MAIL_PORT']
+      mail.domain               = ENV['NOTIFY_MAIL_DOMAIN']
+      mail.user_name            = ENV['NOTIFY_MAIL_USER_NAME']
+      mail.password             = ENV['NOTIFY_MAIL_PASSWORD']
+      mail.authentication       = ENV['NOTIFY_MAIL_AUTHENTICATION']
+      mail.encryption           = :starttls
+    end
+  end
+end

data/lib/generators/backup/rails/templates/schedule.rb

@@ -0,0 +1,4 @@
+
+every :day, :at => '3:30am' do
+  rake 'backup:backup'
+end

data/lib/tasks/backup.rake

@@ -0,0 +1,9 @@
+namespace "backup" do
+  task "backup" => :environment do
+    system "bundle exec backup perform -t general -c config/backup/config.rb -l tmp/backup/log -d tmp/backup/data --tmp-path=tmp/backup/tmp --cache-path=tmp/backup/cache"
+  end
+
+  task "restore" => :environment do
+    Backup::Config.load Rails.root.join + 'config/backup/config.rb'
+  end
+end

data/spec/bin/prepare_for_testing.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+require 'thor'
+
+class PrepareForTesting < Thor
+  include Thor::Actions
+
+  def self.source_root
+    File.dirname(__FILE__)
+  end
+
+  desc "Generate", "Generate rails apps for testing"
+  def generate
+    destination_root = File.dirname(__FILE__) + "/../../tmp"
+    dbname = "backup_rails"
+    username = "backup_rails"
+    password = "123123123"
+    inside destination_root do
+      rails_versions = %w(3.2.16)
+      rails_versions.each do |rails_version|
+        %w(sqlite3 mysql mongodb postgresql).each do |database_type|
+          path = "test_#{rails_version}_#{database_type}"
+          remove_dir path
+          run "gem install rails -v #{rails_version} --conservative"
+          case database_type
+          when 'sqlite3'
+            run "rails _#{rails_version}_ new #{path} -d sqlite3 -B"
+          when 'mysql'
+            run "rails _#{rails_version}_ new #{path} -d mysql -B"
+          when 'postgresql'
+            run "rails _#{rails_version}_ new #{path} -d postgresql -B"
+          when 'mongodb'
+            run "rails _#{rails_version}_ new #{path} -O -B"
+          end
+          inside path do
+            if %w(mysql postgresql).include? database_type
+              gsub_file "config/database.yml", /database:(.+)$/, "database: #{dbname}"
+              gsub_file "config/database.yml", /username:(.+)$/, "username: #{username}"
+              gsub_file "config/database.yml", /password:(.*)$/, "password: '#{password}'"
+            end
+            gsub_file "config/environments/development.rb", "config.action_mailer", "# config.action_mailer" 
+            append_file "Gemfile", "gem 'backup-rails', path: '../../'\n"
+
+            if database_type == "mongodb" 
+              if rails_version == "3.2.16"
+                append_file "Gemfile", "gem 'mongoid'\n"  
+              else
+                append_file "Gemfile", "gem 'mongoid', github: 'mongoid/mongoid'\n"
+              end
+            end
+
+            run "bundle install"
+            run "rails generate mongoid:config"  if database_type == "mongodb"
+            if database_type == 'mongodb'
+              gsub_file "config/mongoid.yml", /database: (.+)$/, "database: #{dbname}"
+              append_file "config/mongoid.yml", 
+<<-eos
+production:
+  sessions:
+    default:
+      hosts:
+        - localhost:27017
+      database: #{dbname}
+eos
+            end
+            run "rails generate scaffold post title:string body:text published_at:datetime"
+            run "rake db:drop"
+            run "rake db:create"
+            run "rake db:migrate"
+            remove_file "db/seeds.rb"
+            create_file "db/seeds.rb", "10.times.each {|i| Post.create!(title: 'Title!', body: 'fjasdfhiwue72h3jh', published_at: Time.now)}"
+            run "rake db:seed"
+
+            # dump
+            case database_type
+            when 'mysql'
+              run "mysqldump -u#{username} --password=#{password} #{dbname} > mysqldump.sql"
+            when 'postgresql'
+              run "export PGPASSWORD=#{password} && pg_dump --username=#{username} #{dbname} > pgsqldump.sql"
+            when 'mongodb'
+              run "mongodump --db #{dbname} --out mongodump"
+            end
+          end
+        end
+      end
+    end
+  end
+
+end
+
+PrepareForTesting.start

data/spec/lib/generators/backup/rails/install_generator_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+require "generators/backup/rails/install_generator"
+
+describe Backup::Rails::Generators::InstallGenerator do
+  let(:tmp_path) { File.expand_path("../../../../../../tmp", __FILE__) }
+
+  let(:dbname) { "backup_rails" }
+  let(:username) { "backup_rails" }
+  let(:password) { "123123123" }
+
+  let(:ssl_password) { "123123123" }
+  let(:backup_path) { tmp_path + "/backups" }
+
+  # Crypt variants
+  [false, true].each do |with_crypt|
+
+    # Database type variants
+    %w(sqlite3 mysql mongodb postgresql).each do |database_type|
+
+      # Storage type variants
+      %w(local S3).each do |storage_type|
+        context "Code + #{database_type.capitalize} => #{storage_type.capitalize} => With#{!with_crypt ? "out":""} crypt" do
+
+          # Rails version variants
+          %w(3.2.16).each do |rails_version|
+            context "(rails #{rails_version})" do
+              let(:test_rails_project_path) { "test_#{rails_version}_#{database_type}" }
+              
+              it "backups & restores" do
+                # prepare project
+                prepare_project
+
+                # rails generate backup_rails:install
+                install_config
+
+                # restore database
+                restore_database(database_type)
+
+                assert_file "Gemfile", /gem 'backup-rails'/
+                assert_file "config/backup/config.rb"
+                assert_file "config/backup/models/general.rb"
+                assert_file "config/schedule.rb"
+                assert_file ".env"
+
+                # fill .env
+                write_env(storage_type, with_crypt)
+
+                # backup
+                backup_project
+
+                # drop database
+                drop_database(database_type)
+
+                # check remote storage
+                check_remote_storage(storage_type)
+
+                # restore
+                restore_project(with_crypt)
+
+                # check code
+                expect(compare_dirs(tmp_path + '/test_generator', tmp_path + '/test_generator_restore')).to be_true
+
+                # check database
+                expect(check_database(database_type)).to be_true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+#require 'rails'
+#require 'backup-rails'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+class RSpec::Core::ExampleGroup
+  def self.run_all(reporter=nil)
+    run(reporter || RSpec::Mocks::Mock.new('reporter').as_null_object)
+  end
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  config.before(:each) do
+    @real_world = RSpec.world
+    RSpec.instance_variable_set(:@world, RSpec::Core::World.new)
+  end
+  config.after(:each) do
+    RSpec.instance_variable_set(:@world, @real_world)
+  end
+  config.order = :random
+
+  config.include CustomMatchers
+end

data/spec/support/custom_matchers.rb

@@ -0,0 +1,168 @@
+require 'mysql2'
+require 'mongoid'
+require 'dotenv'
+require 'fog'
+require 'pg'
+
+class Post
+  include Mongoid::Document
+  field :title
+end
+
+module CustomMatchers
+  def assert_file(relative, *contents)
+    absolute = File.expand_path(relative, tmp_path + "/test_generator")
+    expect(File).to be_exists(absolute), "Expected file #{relative.inspect} to exist, but does not"
+
+    read = File.read(absolute) if block_given? || !contents.empty?
+    yield read if block_given?
+
+    contents.each do |content|
+      case content
+        when String
+          expect(content).to eq read
+        when Regexp
+          expect(content).to match read
+      end
+    end
+  end
+
+  def sameFile path1, path2
+    return File.stat(path1).size == File.stat(path2).size
+  end
+
+  def compare_dirs dir1, dir2
+    return false  unless File.exists?(dir1) && File.exists?(dir2)
+    Dir.foreach(dir1) do |item|
+      next if item == "." or item == ".."
+      path1 = File.join(dir1, item)
+      path2 = File.join(dir1, item)
+      if File.directory?(path1)
+        next  if File.symlink? path1
+        return false  unless File.directory? path2
+
+        compare_dirs(path1, path2)
+      else
+        return false  unless File.file? path2
+        return false  unless sameFile(path1, path2)
+      end
+    end
+    true
+  end
+
+  def check_database database_type
+    case database_type
+    when 'mysql'
+      client = Mysql2::Client.new(:host => "localhost", :username => username, database: dbname, password: password)
+      return client.query("select * from posts").count == 10
+    when 'mongodb'
+      Mongoid.configure.connect_to("backup_rails")
+      return Post.count == 10
+    when 'postgresql'
+      conn = PG::Connection.new(dbname: dbname, user: username, password: password)
+      return conn.exec("select * from posts").values.size == 10
+    when 'sqlite3'
+      return true
+    end
+  end
+
+  def restore_database database_type
+    output = ""
+    output += drop_database database_type
+    case database_type
+    when 'mysql'
+      output += run "echo \"create database #{dbname}\" | mysql -u #{username} --password=#{password}"
+      output += run "cd #{tmp_path}/test_generator && mysql -u #{username} --password=#{password} #{dbname} < mysqldump.sql"
+    when 'mongodb'
+      output += run "cd #{tmp_path}/test_generator && mongorestore --db backup_rails mongodump/backup_rails"
+    when 'postgresql'
+      output += run "export PGPASSWORD=#{password} && createdb -U#{username} #{dbname}", false
+      output += run "cd #{tmp_path}/test_generator && export PGPASSWORD=#{password} && psql -U#{username} #{dbname} < pgsqldump.sql"
+    end
+    output
+  end
+
+  def drop_database database_type
+    output = ""
+    case database_type
+    when 'mysql'
+      output += run "echo \"drop database #{dbname}\" | mysql -u #{username} --password=#{password}", false
+    when 'mongodb'
+      output += run "cd #{tmp_path}/test_generator && mongo backup_rails --eval \"db.dropDatabase()\"", false
+    when 'postgresql'
+      output += run "export PGPASSWORD=#{password} && dropdb -U#{username} #{dbname}", false
+    end
+    output
+  end
+
+  def write_env storage_type, with_crypt
+    Dotenv.load
+    File.open(tmp_path + "/test_generator/.env", "w") do |f|
+      f.write("SSL_PASSWORD=#{ssl_password}\n")  if with_crypt
+      case storage_type
+      when 'local'
+        f.write("LOCAL_PATH=#{backup_path}")
+      when 'S3'
+        f.write("S3_ACCESS_KEY_ID=\"#{ENV['S3_ACCESS_KEY_ID']}\"\n")
+        f.write("S3_SECRET_ACCESS_KEY=\"#{ENV['S3_SECRET_ACCESS_KEY']}\"\n")
+        f.write("S3_REGION=\"#{ENV['S3_REGION']}\"\n")
+        f.write("S3_BUCKET=\"#{ENV['S3_BUCKET']}\"\n")
+        f.write("S3_PATH=\"#{ENV['S3_PATH']}\"\n")
+      end
+    end
+  end
+
+  def check_remote_storage storage_type
+    case storage_type
+    when 'S3'
+      connection = Fog::Storage.new({
+        :provider                 => 'AWS',
+        :aws_access_key_id        => ENV['S3_ACCESS_KEY_ID'],
+        :aws_secret_access_key    => ENV['S3_SECRET_ACCESS_KEY']
+      })
+      dir = connection.directories.detect { | dir | dir.key == ENV["S3_BUCKET"] }
+      file = dir.files.max_by {|f| f.last_modified }
+      file_path = File.expand_path(file.key, tmp_path)
+      path = File.dirname(file_path)
+      run "mkdir -p #{path}"
+      File.open(file_path, "wb") do |f|
+        f.write file.body
+      end
+    end
+  end
+
+  def restore_project with_crypt
+    run "cd #{tmp_path} && rm -fr test_generator_restore"
+    if with_crypt
+      archive_path = Dir[backup_path + "/general/*/general.tar.enc"].first
+      run "cd #{tmp_path} && ../bin/backup_rails restore #{archive_path} #{tmp_path}/test_generator_restore --ssl_password=#{ssl_password}"
+    else
+      archive_path = Dir[backup_path + "/general/*/general.tar"].first
+      run "cd #{tmp_path} && ../bin/backup_rails restore #{archive_path} #{tmp_path}/test_generator_restore"
+    end
+  end
+
+  def prepare_project
+    run "cd #{tmp_path} && rm -fr test_generator && cp -r #{test_rails_project_path} test_generator"
+  end
+
+  def install_config
+    run "cd #{tmp_path}/test_generator && rails generate backup:rails:install"
+  end
+
+  def run command, check_exitstatus=true
+    output = %x(#{command})
+    p output  unless $?.success?
+    $?.success?.should be_true, "Error run command: #{command}"  if check_exitstatus
+    output
+  end
+
+  def backup_project
+    # remove backup dir
+    run "rm -fr #{backup_path}"
+
+    output = run "cd #{tmp_path}/test_generator && bundle exec rake backup:backup"
+    expect(output).to_not match /\[warn\]/
+    expect(output).to_not match /\[error\]/
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: backup-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Oleg Bavaev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: backup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: whenever
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 2.5.2
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+description: Backup rails project with backup & whenever gems
+email:
+- jesoba7@gmail.com
+executables:
+- backup_rails
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- backup-rails.gemspec
+- bin/backup_rails
+- lib/backup-rails.rb
+- lib/backup-rails/version.rb
+- lib/generators/backup/rails/install_generator.rb
+- lib/generators/backup/rails/templates/general.rb
+- lib/generators/backup/rails/templates/schedule.rb
+- lib/tasks/backup.rake
+- spec/bin/prepare_for_testing.rb
+- spec/lib/generators/backup/rails/install_generator_spec.rb
+- spec/spec_helper.rb
+- spec/support/custom_matchers.rb
+homepage: https://github.com/jesson/backup-rails
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Backup rails project
+test_files:
+- spec/bin/prepare_for_testing.rb
+- spec/lib/generators/backup/rails/install_generator_spec.rb
+- spec/spec_helper.rb
+- spec/support/custom_matchers.rb
+has_rdoc: