dump 1.0.4 → 1.0.5

data/lib/dump_rake/dump_writer.rb

@@ -1,4 +1,5 @@
 class DumpRake
+  # Creating dump
   class DumpWriter < Dump
     attr_reader :stream, :config
 
@@ -79,21 +80,21 @@ class DumpRake
 
     def write_assets
       assets = assets_to_dump
-      if assets.present?
-        config[:assets] = {}
-        Dir.chdir(DumpRake::RailsRoot) do
-          assets = Dir[*assets].uniq
-          assets.with_progress('Assets') do |asset|
-            paths = Dir[File.join(asset, '**/*')]
-            files = paths.select{ |path| File.file?(path) }
-            config[:assets][asset] = {:total => paths.length, :files => files.length}
-            assets_root_link do |tmpdir, prefix|
-              paths.with_progress(asset) do |entry|
-                begin
-                  Archive::Tar::Minitar.pack_file(File.join(prefix, entry), stream)
-                rescue => e
-                  $stderr.puts "Skipped asset due to error #{e}"
-                end
+      return if assets.blank?
+
+      config[:assets] = {}
+      Dir.chdir(DumpRake::RailsRoot) do
+        assets = Dir[*assets].uniq
+        assets.with_progress('Assets') do |asset|
+          paths = Dir[File.join(asset, '**/*')]
+          files = paths.select{ |path| File.file?(path) }
+          config[:assets][asset] = {:total => paths.length, :files => files.length}
+          assets_root_link do |_tmpdir, prefix|
+            paths.with_progress(asset) do |entry|
+              begin
+                Archive::Tar::Minitar.pack_file(File.join(prefix, entry), stream)
+              rescue => e
+                $stderr.puts "Skipped asset due to error #{e}"
               end
             end
           end
@@ -108,12 +109,10 @@ class DumpRake
     end
 
     def assets_to_dump
-      begin
-        Rake::Task['assets'].invoke
-        DumpRake::Env[:assets].split(DumpRake::Assets::SPLITTER)
-      rescue
-        []
-      end
+      Rake::Task['assets'].invoke
+      DumpRake::Env[:assets].split(DumpRake::Assets::SPLITTER)
+    rescue
+      []
     end
   end
 end

data/lib/dump_rake/env.rb

@@ -3,6 +3,7 @@
 require 'dump_rake/env/filter'
 
 class DumpRake
+  # Working with environment variables
   module Env
     DICTIONARY = {
       :desc => %w[DESC DESCRIPTION],
@@ -69,7 +70,7 @@ class DumpRake
       end
 
       def filter(key, splitter = nil)
-        @filters ||= Hash.new{ |hash, key| hash[key] = Filter.new(*key) }
+        @filters ||= Hash.new{ |h, k| h[k] = Filter.new(*k) }
         @filters[[self[key], splitter]]
       end
 
@@ -90,7 +91,7 @@ class DumpRake
           :select => [:like, :tags],
           :assets => [:assets],
           :restore_options => [:migrate_down, :restore_schema, :restore_tables, :restore_assets],
-          :transfer_options => [:transfer_via]
+          :transfer_options => [:transfer_via],
         }
 
         m[:versions] = m[:select] | [:summary]
@@ -108,12 +109,13 @@ class DumpRake
       end
 
       def for_command(command, strings = false)
-        variables = variable_names_for_command(command)
-        variables.inject({}) do |env, variable|
-          value = self[variable]
-          env[strings ? DICTIONARY[variable].first : variable] = value if value
-          env
+        env = {}
+        variable_names_for_command(command).each do |variable|
+          if (value = self[variable])
+            env[strings ? DICTIONARY[variable].first : variable] = value
+          end
         end
+        env
       end
 
       def stringify!(hash)
@@ -124,9 +126,9 @@ class DumpRake
 
       def explain_variables_for_command(command)
         ".\n" <<
-        variable_names_for_command(command).map do |variable_name|
-          "  #{DICTIONARY[variable_name].join(', ')} — #{EXPLANATIONS[variable_name]}\n"
-        end.join('')
+          variable_names_for_command(command).map do |variable_name|
+            "  #{DICTIONARY[variable_name].join(', ')} — #{EXPLANATIONS[variable_name]}\n"
+          end.join('')
       end
 
     private

data/lib/dump_rake/env/filter.rb

@@ -2,6 +2,9 @@
 
 class DumpRake
   module Env
+    # Filter strings by simple pattern:
+    #   'a,b,c' will pass only 'a', 'b' and 'c'
+    #   '-a,b,c' will pass everything except 'a', 'b' and 'c'
     class Filter
       attr_reader :invert, :values, :transparent
       def initialize(s, splitter = nil)

data/lib/dump_rake/rails_root.rb

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 
+# Get rails app root (Rails.root or RAILS_ROOT or Dir.pwd)
 class DumpRake
   RailsRoot = case
   when defined?(Rails)

data/lib/dump_rake/table_manipulation.rb

@@ -1,4 +1,5 @@
 class DumpRake
+  # Methods to work with db using ActiveRecord
   module TableManipulation
   protected
 
@@ -7,36 +8,33 @@ class DumpRake
     end
 
     def verify_connection
-      ActiveRecord::Base.connection.verify!(0)
+      connection.verify!(0)
     end
 
-
     def quote_table_name(table)
-      ActiveRecord::Base.connection.quote_table_name(table)
+      connection.quote_table_name(table)
     end
 
     def quote_column_name(column)
-      ActiveRecord::Base.connection.quote_column_name(column)
+      connection.quote_column_name(column)
     end
 
     def quote_value(value)
-      ActiveRecord::Base.connection.quote(value)
+      connection.quote(value)
     end
 
-
     def clear_table(table_sql)
-      ActiveRecord::Base.connection.delete("DELETE FROM #{table_sql}", 'Clearing table')
+      connection.delete("DELETE FROM #{table_sql}", 'Clearing table')
     end
 
     def insert_into_table(table_sql, columns_sql, values_sql)
       values_sql = values_sql.join(',') if values_sql.is_a?(Array)
-      ActiveRecord::Base.connection.insert("INSERT INTO #{table_sql} #{columns_sql} VALUES #{values_sql}", 'Loading dump')
+      connection.insert("INSERT INTO #{table_sql} #{columns_sql} VALUES #{values_sql}", 'Loading dump')
     end
 
     def fix_sequence!(table)
-      if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-        ActiveRecord::Base.connection.reset_pk_sequence!(table)
-      end
+      return unless connection.respond_to?(:reset_pk_sequence!)
+      connection.reset_pk_sequence!(table)
     end
 
     def join_for_sql(quoted)
@@ -51,9 +49,8 @@ class DumpRake
       join_for_sql(values.map{ |value| quote_value(value) })
     end
 
-
     def avaliable_tables
-      ActiveRecord::Base.connection.tables
+      connection.tables
     end
 
     def tables_to_dump
@@ -67,7 +64,7 @@ class DumpRake
     end
 
     def table_row_count(table)
-      ActiveRecord::Base.connection.select_value("SELECT COUNT(*) FROM #{quote_table_name(table)}").to_i
+      connection.select_value("SELECT COUNT(*) FROM #{quote_table_name(table)}").to_i
     end
 
     CHUNK_SIZE_MIN = 100 unless const_defined?(:CHUNK_SIZE_MIN)
@@ -87,7 +84,7 @@ class DumpRake
     end
 
     def table_columns(table)
-      ActiveRecord::Base.connection.columns(table)
+      connection.columns(table)
     end
 
     def table_has_primary_column?(table)
@@ -95,7 +92,7 @@ class DumpRake
       table_columns(table).any?{ |column| column.name == table_primary_key(table) && column.type == :integer }
     end
 
-    def table_primary_key(table)
+    def table_primary_key(_table)
       'id'
     end
 
@@ -105,9 +102,9 @@ class DumpRake
         primary_key = table_primary_key(table)
         quoted_primary_key = "#{quote_table_name(table)}.#{quote_column_name(primary_key)}"
         select_where_primary_key =
-          "SELECT * FROM #{quote_table_name(table)}" +
-            " WHERE #{quoted_primary_key} %s" +
-            " ORDER BY #{quoted_primary_key} ASC" +
+          "SELECT * FROM #{quote_table_name(table)}" \
+            " WHERE #{quoted_primary_key} %s" \
+            " ORDER BY #{quoted_primary_key} ASC" \
             " LIMIT #{chunk_size}"
         rows = select_all_by_sql(select_where_primary_key % '>= 0')
         until rows.blank?
@@ -125,7 +122,13 @@ class DumpRake
     end
 
     def select_all_by_sql(sql)
-      ActiveRecord::Base.connection.select_all(sql)
+      connection.select_all(sql)
+    end
+
+  private
+
+    def connection
+      ActiveRecord::Base.connection
     end
   end
 end

data/lib/generators/assets_config/assets_config_generator.rb

@@ -1,5 +1,6 @@
 case
 when defined?(Rails::Generator::Base)
+  # Generator for rails < 3
   class AssetsConfigGenerator < Rails::Generator::Base
     def manifest
       record do |m|
@@ -8,6 +9,7 @@ when defined?(Rails::Generator::Base)
     end
   end
 when defined?(Rails::Generators::Base)
+  # Generator for rails >= 3
   class AssetsConfigGenerator < Rails::Generators::Base
     def create_assets_config
       create_file 'config/assets', File.read(File.join(File.dirname(__FILE__), 'templates/assets'))

data/lib/tasks/assets.rake

@@ -1,4 +1,3 @@
-$: << File.join(File.dirname(__FILE__), '../../lib')
 require 'dump_rake'
 
 task :assets do
@@ -6,7 +5,7 @@ task :assets do
 end
 
 namespace :assets do
-  desc "Delete assets" << DumpRake::Env.explain_variables_for_command(:assets)
+  desc 'Delete assets' << DumpRake::Env.explain_variables_for_command(:assets)
   task :delete => :assets do
     ENV['ASSETS'].split(':').each do |asset|
       DumpRake::Assets.glob_asset_children(asset, '*').each do |child|

data/lib/tasks/dump.rake

@@ -1,26 +1,25 @@
-$: << File.join(File.dirname(__FILE__), '../../lib')
 require 'dump_rake'
 
-desc "Short for dump:create" << DumpRake::Env.explain_variables_for_command(:create)
+desc 'Short for dump:create' << DumpRake::Env.explain_variables_for_command(:create)
 task :dump => 'dump:create'
 
 namespace :dump do
-  desc "Show avaliable versions" << DumpRake::Env.explain_variables_for_command(:versions)
+  desc 'Show avaliable versions' << DumpRake::Env.explain_variables_for_command(:versions)
   task :versions => :environment do
     DumpRake.versions(DumpRake::Env.for_command(:versions))
   end
 
-  desc "Create dump" << DumpRake::Env.explain_variables_for_command(:create)
+  desc 'Create dump' << DumpRake::Env.explain_variables_for_command(:create)
   task :create => :environment do
     DumpRake.create(DumpRake::Env.for_command(:create))
   end
 
-  desc "Restore dump" << DumpRake::Env.explain_variables_for_command(:restore)
+  desc 'Restore dump' << DumpRake::Env.explain_variables_for_command(:restore)
   task :restore => :environment do
     DumpRake.restore(DumpRake::Env.for_command(:restore))
   end
 
-  desc "Cleanup dumps" << DumpRake::Env.explain_variables_for_command(:cleanup)
+  desc 'Cleanup dumps' << DumpRake::Env.explain_variables_for_command(:cleanup)
   task :cleanup => :environment do
     DumpRake.cleanup(DumpRake::Env.for_command(:cleanup))
   end

data/recipes/dump.rb

@@ -1,343 +1 @@
-# encoding: UTF-8
-
-Capistrano::Configuration.instance(:i_need_this!).load do
-  $: << File.join(File.dirname(__FILE__), '../lib')
-  require 'fileutils'
-  require 'shellwords'
-
-  require 'dump_rake/continious_timeout'
-  require 'dump_rake/env'
-
-  begin
-    nil.blank?
-  rescue
-    Object.class_eval do
-      def blank?
-        respond_to?(:empty?) ? empty? : !self
-      end
-      def present?
-        !blank?
-      end
-    end
-  end
-
-  namespace :dump do
-    def dump_command(command, env = {})
-      rake = env.delete(:rake) || 'rake'
-
-      # stringify_keys! from activesupport
-      DumpRake::Env.stringify!(env)
-
-      env.update(DumpRake::Env.for_command(command, true))
-
-      cmd = %W[-s dump:#{command}]
-      cmd += env.sort.map{ |key, value| "#{key}=#{value}" }
-      "#{rake} #{cmd.shelljoin}"
-    end
-
-    def fetch_rails_env
-      fetch(:rails_env, "production")
-    end
-
-    def got_rsync?
-      `which rsync`
-      $?.success?
-    end
-
-    def do_transfer_via(via, direction, from, to)
-      case via
-      when :rsync
-        if run_local('which rsync').present? && $?.success?
-          execute_on_servers do |servers|
-            commands = servers.map do |server|
-              target = sessions[server]
-              user = target.options[:user] || fetch(:user, nil)
-              host = target.host
-              port = target.options[:port]
-              full_host = "#{"#{user}@" if user.present?}#{host}"
-
-              ssh = port.present? ? "ssh -p #{port}" : 'ssh'
-              cmd = %W[rsync -P -e #{ssh} --timeout=15]
-              case direction
-              when :up
-                cmd << from << "#{full_host}:#{to}"
-              when :down
-                cmd << "#{full_host}:#{from}" << to
-              else
-                raise "Don't know how to transfer in direction #{direction}"
-              end
-              cmd.shelljoin
-            end
-            commands.each do |cmd|
-              logger.info cmd if logger
-
-              3.times do
-                break if system(cmd)
-                break unless [10, 11, 12, 23, 30, 35].include?($?.exitstatus)
-              end
-              raise "rsync returned #{$?.exitstatus}" unless $?.success?
-            end
-          end
-        end
-      when :sftp, :scp
-        ContiniousTimeout.timeout 15 do |thread|
-          transfer(direction, from, to, :via => via) do |channel, path, transfered, total|
-            thread.defer
-            progress = if transfered < total
-              "\e[1m%5.1f%%\e[0m" % (transfered * 100.0 / total)
-            else
-              "100%"
-            end
-            $stderr << "\rTransfering: #{progress}"
-          end
-        end
-      else
-        raise "Unknown transfer method #{via}"
-      end
-    end
-
-    def do_transfer(direction, from, to)
-      if via = DumpRake::Env[:transfer_via]
-        case via.downcase
-        when 'rsync'
-          do_transfer_via(:rsync, direction, from, to)
-        when 'sftp'
-          do_transfer_via(:sftp, direction, from, to)
-        when 'scp'
-          do_transfer_via(:scp, direction, from, to)
-        else
-          raise "Unknown transfer method #{via}"
-        end
-      else
-        if got_rsync?
-          do_transfer_via(:rsync, direction, from, to)
-        else
-          $stderr.puts "To transfer using rsync — make rsync binary accessible and verify that remote host can work with rsync through ssh"
-          begin
-            do_transfer_via(:sftp, direction, from, to)
-          rescue => e
-            $stderr.puts e
-            do_transfer_via(:scp, direction, from, to)
-          end
-        end
-      end
-    end
-
-    def with_additional_tags(*tags)
-      tags = [tags, DumpRake::Env[:tags]].flatten.select(&:present?).join(',')
-      DumpRake::Env.with_env(:tags => tags) do
-        yield
-      end
-    end
-
-    def print_and_return_or_fail
-      out = yield
-      raise 'Failed creating dump' if out.blank?
-      print out
-      out.strip
-    end
-
-    def run_local(cmd)
-      `#{cmd}`
-    end
-
-    def run_remote(cmd)
-      output = ''
-      run(cmd) do |channel, io, data|
-        case io
-        when :out
-          output << data
-        when :err
-          $stderr << data
-        end
-      end
-      output
-    end
-
-    def last_part_of_last_line(out)
-      if line = out.strip.split(/\s*[\n\r]\s*/).last
-        line.split("\t").last
-      end
-    end
-
-    def fetch_rake
-      fetch(:rake, nil)
-    end
-
-    def auto_backup?
-      !DumpRake::Env.no?(:backup)
-    end
-
-    namespace :local do
-      desc "Shorthand for dump:local:create" << DumpRake::Env.explain_variables_for_command(:create)
-      task :default, :roles => :db, :only => {:primary => true} do
-        create
-      end
-
-      desc "Create local dump" << DumpRake::Env.explain_variables_for_command(:create)
-      task :create, :roles => :db, :only => {:primary => true} do
-        print_and_return_or_fail do
-          with_additional_tags('local') do
-            run_local(dump_command(:create))
-          end
-        end
-      end
-
-      desc "Restore local dump" << DumpRake::Env.explain_variables_for_command(:restore)
-      task :restore, :roles => :db, :only => {:primary => true} do
-        run_local(dump_command(:restore))
-      end
-
-      desc "Versions of local dumps" << DumpRake::Env.explain_variables_for_command(:versions)
-      task :versions, :roles => :db, :only => {:primary => true} do
-        print run_local(dump_command(:versions, :show_size => true))
-      end
-
-      desc "Cleanup local dumps" << DumpRake::Env.explain_variables_for_command(:cleanup)
-      task :cleanup, :roles => :db, :only => {:primary => true} do
-        print run_local(dump_command(:cleanup))
-      end
-
-      desc "Upload dump" << DumpRake::Env.explain_variables_for_command(:transfer)
-      task :upload, :roles => :db, :only => {:primary => true} do
-        file = DumpRake::Env.with_env(:summary => nil) do
-          last_part_of_last_line(run_local(dump_command(:versions)))
-        end
-        if file
-          do_transfer :up, "dump/#{file}", "#{current_path}/dump/#{file}"
-        end
-      end
-    end
-
-    namespace :remote do
-      desc "Shorthand for dump:remote:create" << DumpRake::Env.explain_variables_for_command(:create)
-      task :default, :roles => :db, :only => {:primary => true} do
-        remote.create
-      end
-
-      desc "Create remote dump" << DumpRake::Env.explain_variables_for_command(:create)
-      task :create, :roles => :db, :only => {:primary => true} do
-        print_and_return_or_fail do
-          with_additional_tags('remote') do
-            run_remote("cd #{current_path}; #{dump_command(:create, :rake => fetch_rake, :RAILS_ENV => fetch_rails_env, :PROGRESS_TTY => '+')}")
-          end
-        end
-      end
-
-      desc "Restore remote dump" << DumpRake::Env.explain_variables_for_command(:restore)
-      task :restore, :roles => :db, :only => {:primary => true} do
-        run_remote("cd #{current_path}; #{dump_command(:restore, :rake => fetch_rake, :RAILS_ENV => fetch_rails_env, :PROGRESS_TTY => '+')}")
-      end
-
-      desc "Versions of remote dumps" << DumpRake::Env.explain_variables_for_command(:versions)
-      task :versions, :roles => :db, :only => {:primary => true} do
-        print run_remote("cd #{current_path}; #{dump_command(:versions, :rake => fetch_rake, :RAILS_ENV => fetch_rails_env, :PROGRESS_TTY => '+', :show_size => true)}")
-      end
-
-      desc "Cleanup of remote dumps" << DumpRake::Env.explain_variables_for_command(:cleanup)
-      task :cleanup, :roles => :db, :only => {:primary => true} do
-        print run_remote("cd #{current_path}; #{dump_command(:cleanup, :rake => fetch_rake, :RAILS_ENV => fetch_rails_env, :PROGRESS_TTY => '+')}")
-      end
-
-      desc "Download dump" << DumpRake::Env.explain_variables_for_command(:transfer)
-      task :download, :roles => :db, :only => {:primary => true} do
-        file = DumpRake::Env.with_env(:summary => nil) do
-          last_part_of_last_line(run_remote("cd #{current_path}; #{dump_command(:versions, :rake => fetch_rake, :RAILS_ENV => fetch_rails_env, :PROGRESS_TTY => '+')}"))
-        end
-        if file
-          FileUtils.mkpath('dump')
-          do_transfer :down, "#{current_path}/dump/#{file}", "dump/#{file}"
-        end
-      end
-    end
-
-    desc "Shorthand for dump:local:upload" << DumpRake::Env.explain_variables_for_command(:transfer)
-    task :upload, :roles => :db, :only => {:primary => true} do
-      local.upload
-    end
-
-    desc "Shorthand for dump:remote:download" << DumpRake::Env.explain_variables_for_command(:transfer)
-    task :download, :roles => :db, :only => {:primary => true} do
-      remote:download
-    end
-
-    namespace :mirror do
-      desc "Creates local dump, uploads and restores on remote" << DumpRake::Env.explain_variables_for_command(:mirror)
-      task :up, :roles => :db, :only => {:primary => true} do
-        auto_backup = if auto_backup?
-          with_additional_tags('auto-backup') do
-            remote.create
-          end
-        end
-        if !auto_backup? || auto_backup.present?
-          file = with_additional_tags('mirror') do
-            local.create
-          end
-          if file.present?
-            DumpRake::Env.with_clean_env(:like => file) do
-              local.upload
-              remote.restore
-            end
-          end
-        end
-      end
-
-      desc "Creates remote dump, downloads and restores on local" << DumpRake::Env.explain_variables_for_command(:mirror)
-      task :down, :roles => :db, :only => {:primary => true} do
-        auto_backup = if auto_backup?
-          with_additional_tags('auto-backup') do
-            local.create
-          end
-        end
-        if !auto_backup? || auto_backup.present?
-          file = with_additional_tags('mirror') do
-            remote.create
-          end
-          if file.present?
-            DumpRake::Env.with_clean_env(:like => file) do
-              remote.download
-              local.restore
-            end
-          end
-        end
-      end
-    end
-
-    namespace :backup do
-      desc "Shorthand for dump:backup:create" << DumpRake::Env.explain_variables_for_command(:backup)
-      task :default, :roles => :db, :only => {:primary => true} do
-        create
-      end
-
-      desc "Creates remote dump and downloads to local (desc defaults to 'backup')" << DumpRake::Env.explain_variables_for_command(:backup)
-      task :create, :roles => :db, :only => {:primary => true} do
-        file = with_additional_tags('backup') do
-          remote.create
-        end
-        if file.present?
-          DumpRake::Env.with_clean_env(:like => file) do
-            remote.download
-          end
-        end
-      end
-
-      desc "Uploads dump with backup tag and restores it on remote" << DumpRake::Env.explain_variables_for_command(:backup_restore)
-      task :restore, :roles => :db, :only => {:primary => true} do
-        file = with_additional_tags('backup') do
-          last_part_of_last_line(run_local(dump_command(:versions)))
-        end
-        if file.present?
-          DumpRake::Env.with_clean_env(:like => file) do
-            local.upload
-            remote.restore
-          end
-        end
-      end
-    end
-  end
-
-  after 'deploy:update_code' do
-    from, to = %W[#{shared_path}/dump #{release_path}/dump]
-    run "mkdir -p #{from}; rm -rf #{to}; ln -s #{from} #{to}"
-  end
-end
+require 'dump/capistrano'