backup 2.4.5.1 → 3.0.0.build.0

data/generators/backup_update/templates/migrations/update_backup_tables.rb

@@ -1,27 +0,0 @@
-class UpdateBackupTables < ActiveRecord::Migration
-  def self.up
-    change_table :backup do |t|
-      t.rename :storage, :type # will use STI from now
-      t.string :md5sum
-    end
-    
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::FTP' WHERE type='ftp'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::Local' WHERE type='local'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::S3' WHERE type='s3'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::SCP' WHERE type='scp'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='Backup::Record::SFTP' WHERE type='sftp'"
-  end
-
-  def self.down
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='ftp' WHERE type='Backup::Record::FTP'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='local' WHERE type='Backup::Record::Local'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='s3' WHERE type='Backup::Record::S3'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='scp' WHERE type='Backup::Record::SCP'"
-    ActiveRecord::Base.connection.execute "UPDATE backup SET type='sftp' WHERE type='Backup::Record::SFTP'"
-    
-    change_table :backup do |t|
-      t.rename :type, :storage
-      t.remove :md5sum
-    end
-  end
-end

data/lib/backup/adapters/archive.rb

@@ -1,34 +0,0 @@
-module Backup
-  module Adapters
-    class Archive < Backup::Adapters::Base
-      
-      attr_accessor :files, :exclude
-      
-      private
-
-        # Archives and Compresses all files
-        def perform
-          log system_messages[:archiving]; log system_messages[:compressing]
-          run "tar -czf #{File.join(tmp_path, compressed_file)} #{exclude_files} #{tar_files}"
-        end
-        
-        def load_settings
-          self.files   = procedure.get_adapter_configuration.attributes['files']
-          self.exclude = procedure.get_adapter_configuration.attributes['exclude']
-        end
-
-        def performed_file_extension
-          ".tar"
-        end
-        
-        def tar_files
-          [*files].map{|f| f.gsub(' ', '\ ')}.join(' ')
-        end
-
-        def exclude_files
-          [*exclude].compact.map{|x| "--exclude=#{x}"}.join(' ')
-        end
-
-    end
-  end
-end

data/lib/backup/adapters/base.rb

@@ -1,167 +0,0 @@
-require 'tempfile'
-
-module Backup
-  module Adapters
-    class Base
-
-      include Backup::CommandHelper
-      
-      attr_accessor :procedure, :timestamp, :options, :tmp_path, :encrypt_with_password, :encrypt_with_gpg_public_key, :keep_backups, :trigger
-
-      # IMPORTANT
-      # final_file must have the value of the final filename result
-      # so if a file gets compressed, then the file could look like this:
-      #   myfile.gz
-      #
-      # and if a file afterwards gets encrypted, the file will look like:
-      #   myfile.gz.enc (with a password)
-      #   myfile.gz.gpg (with a gpg public key)
-      #
-      #
-      # It is important that, whatever the final filename of the file will be, that :final_file will contain it.
-      attr_accessor :performed_file, :compressed_file, :encrypted_file, :final_file
-
-      # Initializes the Backup Process
-      # 
-      # This will first load in any prefixed settings from the Backup::Adapters::Base
-      # Then it will add it's own settings.
-      # 
-      # First it will call the 'perform' method. This method is concerned with the backup, and must
-      # be implemented by derived classes!
-      # Then it will optionally encrypt the backed up file
-      # Then it will store it to the specified storage location
-      # Then it will record the data to the database
-      # Once this is all done, all the temporary files will be removed
-      # 
-      # Wrapped inside of begin/ensure/end block to ensure the deletion of any files in the tmp directory
-      def initialize(trigger, procedure)
-        self.trigger                     = trigger
-        self.procedure                   = procedure
-        self.timestamp                   = Time.now.strftime("%Y%m%d%H%M%S")
-        self.tmp_path                    = File.join(BACKUP_PATH.gsub(' ', '\ '), 'tmp', 'backup', trigger)
-        self.encrypt_with_password       = procedure.attributes['encrypt_with_password']
-        self.encrypt_with_gpg_public_key = procedure.attributes['encrypt_with_gpg_public_key']
-        self.keep_backups                = procedure.attributes['keep_backups']
-
-        self.performed_file   = "#{timestamp}.#{trigger.gsub(' ', '-')}#{performed_file_extension}"
-        self.compressed_file  = "#{performed_file}.gz"
-        self.final_file       = compressed_file
-
-        begin
-          create_tmp_folder
-          load_settings # if respond_to?(:load_settings)
-          handle_before_backup
-          perform
-          encrypt
-          store
-          handle_after_backup
-          record
-          notify
-        ensure
-          remove_tmp_files
-        end
-      end
-      
-      # Creates the temporary folder for the specified adapter
-      def create_tmp_folder
-        #need to create with universal privlages as some backup tasks might create this path under sudo
-        run "mkdir -m 0777 -p #{tmp_path.sub(/\/[^\/]+$/, '')}"  #this is the parent to the tmp_path
-        run "mkdir -m 0777 -p #{tmp_path}"                       #the temp path dir
-      end
-      
-      # TODO make methods in derived classes public? respond_to cannot identify private methods
-      def load_settings
-      end
-      
-      def skip_backup(msg)
-        log "Terminating backup early because: #{msg}"
-        exit 1
-      end
-
-      # Removes the files inside the temporary folder
-      def remove_tmp_files
-        run "rm -r #{File.join(tmp_path)}" if File.exists?(tmp_path) #just in case there isn't one because the process was skipped
-      end
-      
-      def handle_before_backup
-        return unless self.procedure.before_backup_block
-        log system_messages[:before_backup_hook]
-        #run it through this instance so the block is run as a part of this adapter...which means it has access to all sorts of sutff
-        self.instance_eval &self.procedure.before_backup_block
-      end
-      
-      def handle_after_backup
-        return unless self.procedure.after_backup_block
-        log system_messages[:after_backup_hook]
-        #run it through this instance so the block is run as a part of this adapter...which means it has access to all sorts of sutff
-        self.instance_eval &self.procedure.after_backup_block
-      end
-
-      # Encrypts the archive file
-      def encrypt
-        if encrypt_with_gpg_public_key.is_a?(String) && encrypt_with_password.is_a?(String)
-          puts "both 'encrypt_with_gpg_public_key' and 'encrypt_with_password' are set.  Please choose one or the other.  Exiting."
-          exit 1
-        end
-        
-        if encrypt_with_gpg_public_key.is_a?(String)
-          if `which gpg` == ''
-            puts "Encrypting with a GPG public key requires that gpg be in your public path.  gpg was not found.  Exiting"
-            exit 1
-          end
-          log system_messages[:encrypting_w_key]
-          self.encrypted_file   = "#{self.final_file}.gpg"
-
-          # tmp_file = Tempfile.new('backup.pub'){ |tmp_file| tmp_file << encrypt_with_gpg_public_key }
-          tmp_file = Tempfile.new('backup.pub')
-          tmp_file << encrypt_with_gpg_public_key
-          tmp_file.close       
-          # that will either say the key was added OR that it wasn't needed, but either way we need to parse for the uid
-          # which will be wrapped in '<' and '>' like <someone_famous@me.com>
-          encryptionKeyId = `gpg --import #{tmp_file.path} 2>&1`.match(/<(.+)>/)[1] 
-          run "gpg -e --trust-model always -o #{File.join(tmp_path, encrypted_file)} -r '#{encryptionKeyId}' #{File.join(tmp_path, compressed_file)}"
-        elsif encrypt_with_password.is_a?(String)
-          log system_messages[:encrypting_w_pass]
-          self.encrypted_file   = "#{self.final_file}.enc"
-          run "openssl enc -des-cbc -in #{File.join(tmp_path, compressed_file)} -out #{File.join(tmp_path, encrypted_file)} -k #{encrypt_with_password}"
-        end
-        self.final_file = encrypted_file if encrypted_file
-      end
-      
-      # Initializes the storing process
-      def store
-        procedure.initialize_storage(self)
-      end
-      
-      # Records data on every individual file to the database
-      def record
-        record = procedure.initialize_record
-        record.load_adapter(self)
-        record.save
-      end
-      
-      # Delivers a notification by email regarding the successfully stored backup
-      def notify
-        if Backup::Mail::Base.setup?
-          Backup::Mail::Base.notify!(self)
-        end
-      end
-      
-      def system_messages
-        { :compressing        => "Compressing backup..",
-          :archiving          => "Archiving backup..",
-          :encrypting_w_pass  => "Encrypting backup with password..",
-          :encrypting_w_key   => "Encrypting backup with gpg public key..",
-          :mysqldump          => "Creating MySQL dump..",
-          :mongo_dump         => "Creating MongoDB dump..",
-          :mongo_copy         => "Creating MongoDB disk level copy..",
-          :before_backup_hook => "Running before backup hook..",
-          :after_backup_hook  => "Running after backup hook..",
-          :pgdump             => "Creating PostgreSQL dump..",
-          :sqlite             => "Copying and compressing SQLite database..",
-          :commands           => "Executing commands.." }
-      end
-      
-    end
-  end
-end

data/lib/backup/adapters/custom.rb

@@ -1,41 +0,0 @@
-module Backup
-  module Adapters
-    class Custom < Backup::Adapters::Base
-      
-      attr_accessor :commands
-      
-      private
-
-        # Execute any given commands, then archive and compress every folder/file
-        def perform
-          execute_commands
-          targz
-        end
-        
-        # Executes the commands
-        def execute_commands
-          return unless commands
-          log system_messages[:commands]
-          [*commands].each do |command|
-            run "#{command.gsub(':tmp_path', tmp_path)}"
-          end
-        end
-        
-        # Archives and Compresses
-        def targz
-          log system_messages[:archiving]; log system_messages[:compressing]
-          run "tar -czf #{File.join(tmp_path, compressed_file)} #{File.join(tmp_path, '*')}"
-        end
-        
-        def performed_file_extension
-          ".tar"
-        end
-
-        # Loads the initial settings
-        def load_settings
-          self.commands = procedure.get_adapter_configuration.attributes['commands']
-        end
-                
-    end
-  end
-end

data/lib/backup/adapters/mongo_db.rb

@@ -1,139 +0,0 @@
-module Backup
-  module Adapters
-    class MongoDB < Backup::Adapters::Base
-      require 'json'
-      
-      attr_accessor :user, :password, :database, :collections, :host, :port, :additional_options, :backup_method
-      
-      private
-      
-        BACKUP_METHOD_OPTIONS = [:mongodump, :disk_copy]
-
-        # Dumps and Compresses the Mongodump file 
-        def perform
-          tmp_mongo_dir = "mongodump-#{Time.now.strftime("%Y%m%d%H%M%S")}"
-          tmp_dump_dir = File.join(tmp_path, tmp_mongo_dir)
-
-          case self.backup_method.to_sym
-          when :mongodump
-            #this is the default options            
-            # PROS:
-            #   * non-locking
-            #   * much smaller archive sizes
-            #   * can specifically target different databases or collections to dump
-            #   * de-fragements the datastore
-            #   * don't need to run under sudo
-            #   * simple logic
-            # CONS:
-            #   * a bit longer to restore as you have to do an import
-            #   * does not include indexes or other meta data
-            log system_messages[:mongo_dump]
-            exit 1 unless run "#{mongodump} #{mongodump_options} #{collections_to_include} -o #{tmp_dump_dir} #{additional_options} > /dev/null 2>&1"
-          when :disk_copy
-            #this is a bit more complicated AND potentially a lot riskier:            
-            # PROS:
-            #   * byte level copy, so it includes all the indexes, meta data, etc
-            #   * fast recovery; you just copy the files into place and startup mongo
-            # CONS:
-            #   * locks the database, so ONLY use against a slave instance
-            #   * copies everything; cannot specify a collection or a database
-            #   * will probably need to run under sudo as the mongodb db_path file is probably under a different owner.  
-            #     If you do run under sudo, you will probably need to run rake RAILS_ENV=... if you aren't already
-            #   * the logic is a bit brittle...                  
-            log system_messages[:mongo_copy]
-
-            cmd = "#{mongo} #{mongo_disk_copy_options} --quiet --eval 'printjson(db.isMaster());' admin"
-            output = JSON.parse(run(cmd, :exit_on_failure => true))
-            if output['ismaster']
-              puts "You cannot run in disk_copy mode against a master instance.  This mode will lock the database.  Please use :mongodump instead."
-              exit 1
-            end
-            
-            begin
-              cmd = "#{mongo} #{mongo_disk_copy_options} --quiet --eval 'db.runCommand({fsync : 1, lock : 1}); printjson(db.runCommand({getCmdLineOpts:1}));' admin"
-              output = JSON.parse(run(cmd, :exit_on_failure => true))
-
-              #lets go find the dbpath.  it is either going to be in the argv just returned OR we are going to have to parse through the mongo config file
-              cmd = "mongo --quiet --eval 'printjson(db.runCommand({getCmdLineOpts:1}));' admin"
-              output = JSON.parse(run(cmd, :exit_on_failure => true))
-              #see if --dbpath was passed in
-              db_path = output['argv'][output['argv'].index('--dbpath') + 1] if output['argv'].index('--dbpath')            
-              #see if --config is passed in, and if so, lets parse it
-              db_path ||= $1 if output['argv'].index('--config') && File.read(output['argv'][output['argv'].index('--config') + 1]) =~ /dbpath\s*=\s*([^\s]*)/  
-              db_path ||= "/data/db/" #mongo's default path
-              run "cp -rp #{db_path} #{tmp_dump_dir}"              
-            ensure
-              #attempting to unlock
-              cmd = "#{mongo} #{mongo_disk_copy_options} --quiet --eval 'printjson(db.currentOp());' admin"
-              output = JSON.parse(run(cmd, :exit_on_failure => true))
-              (output['fsyncLock'] || 1).to_i.times do
-                run "#{mongo} #{mongo_disk_copy_options} --quiet --eval 'db.$cmd.sys.unlock.findOne();' admin"
-              end
-            end
-          else
-            puts "you did not enter a valid backup_method option.  Your choices are: #{BACKUP_METHOD_OPTIONS.join(', ')}"
-            exit 1
-          end          
-            
-          log system_messages[:compressing]
-          run "tar -cz -C #{tmp_path} -f #{File.join(tmp_path, compressed_file)} #{tmp_mongo_dir}"
-        end
-
-        def mongodump
-          cmd = run("which mongodump").chomp
-          cmd = 'mongodump' if cmd.empty?
-          cmd
-        end
-        
-        def mongo
-          cmd = run("which mongo").chomp
-          cmd = 'mongo' if cmd.empty?
-          cmd          
-        end
-        
-        def performed_file_extension
-          ".tar"
-        end
-
-        # Loads the initial settings
-        def load_settings
-          %w(user password database collections additional_options backup_method).each do |attribute|
-            send(:"#{attribute}=", procedure.get_adapter_configuration.attributes[attribute])
-          end
-          
-          %w(host port).each do |attribute|
-            send(:"#{attribute}=", procedure.get_adapter_configuration.get_options.attributes[attribute])
-          end
-          
-          self.backup_method ||= :mongodump
-        end
-        
-        # Returns a list of options in Mongodump syntax
-        def mongodump_options
-          options = String.new
-          options += " --username='#{user}' "     unless user.blank?
-          options += " --password='#{password}' " unless password.blank?
-          options += " --host='#{host}' "         unless host.blank?
-          options += " --port='#{port}' "         unless port.blank?
-          options += " --db='#{database}' "       unless database.blank?
-          options
-        end
-        
-        def mongo_disk_copy_options
-          options = String.new
-          options += " --username='#{user}' "     unless user.blank?
-          options += " --password='#{password}' " unless password.blank?
-          options += " --host='#{host}' "         unless host.blank?
-          options += " --port='#{port}' "         unless port.blank?
-          options          
-        end
-                
-        # Returns a list of collections to include in Mongodump syntax
-        def collections_to_include
-          return "" unless collections
-          "--collection #{[*collections].join(" ")}"
-        end
-                
-    end
-  end
-end

data/lib/backup/adapters/mysql.rb

@@ -1,60 +0,0 @@
-module Backup
-  module Adapters
-    class MySQL < Backup::Adapters::Base
-      
-      attr_accessor :user, :password, :database, :skip_tables, :host, :port, :socket, :additional_options, :tables
-      
-      private
-
-        # Dumps and Compresses the MySQL file 
-        def perform
-          log system_messages[:mysqldump]; log system_messages[:compressing]
-          run "#{mysqldump} -u #{user} --password='#{password}' #{options} #{additional_options} #{database} #{tables_to_include} #{tables_to_skip} | gzip -f --best > #{File.join(tmp_path, compressed_file)}"
-        end
-
-        def mysqldump
-          # try to determine the full path, and fall back to myqsldump if not found
-          cmd = `which mysqldump`.chomp
-          cmd = 'mysqldump' if cmd.empty?
-          cmd
-        end
-        
-        def performed_file_extension
-          ".sql"
-        end
-
-        # Loads the initial settings
-        def load_settings
-          %w(user password database tables skip_tables additional_options).each do |attribute|
-            send(:"#{attribute}=", procedure.get_adapter_configuration.attributes[attribute])
-          end
-          
-          %w(host port socket).each do |attribute|
-            send(:"#{attribute}=", procedure.get_adapter_configuration.get_options.attributes[attribute])
-          end
-        end
-        
-        # Returns a list of options in MySQL syntax
-        def options
-          options = String.new
-          options += " --host='#{host}' "     unless host.blank?
-          options += " --port='#{port}' "     unless port.blank?
-          options += " --socket='#{socket}' " unless socket.blank?
-          options
-        end
-        
-        # Returns a list of tables to skip in MySQL syntax
-        def tables_to_skip
-          return "" unless skip_tables
-          [*skip_tables].map {|table| " --ignore-table='#{database}.#{table}' "}
-        end
-        
-        # Returns a list of tables to include in MySQL syntax
-        def tables_to_include
-          return "" unless tables
-          [*tables].join(" ")
-        end
-                
-    end
-  end
-end