namxam-backup 2.4.5

data/lib/backup/adapters/archive.rb

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,167 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,139 @@
+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

@@ -0,0 +1,60 @@
+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

data/lib/backup/adapters/postgresql.rb

@@ -0,0 +1,56 @@
+module Backup
+  module Adapters
+    class PostgreSQL < Backup::Adapters::Base
+
+      attr_accessor :user, :password, :database, :skip_tables, :host, :port, :socket, :additional_options
+      
+      private
+
+        # Dumps and Compresses the PostgreSQL file 
+        def perform
+          log system_messages[:pgdump]; log system_messages[:compressing]
+          ENV['PGPASSWORD'] = password
+          run "#{pg_dump} -U #{user} #{options} #{additional_options} #{tables_to_skip} #{database} | gzip -f --best > #{File.join(tmp_path, compressed_file)}"
+          ENV['PGPASSWORD'] = nil
+        end
+
+        def pg_dump
+          # try to determine the full path, and fall back to pg_dump if not found
+          cmd = `which pg_dump`.chomp
+          cmd = 'pg_dump' if cmd.empty?
+          cmd
+        end
+        
+        def performed_file_extension
+          ".sql"
+        end
+
+        # Loads the initial settings
+        def load_settings
+          %w(user password database 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 PostgreSQL syntax
+        def options
+          options = String.new
+          options += " --port='#{port}' "     unless port.blank?
+          options += " --host='#{host}' "     unless host.blank?
+          options += " --host='#{socket}' "   unless socket.blank?  unless options.include?('--host=')
+          options
+        end
+        
+        # Returns a list of tables to skip in PostgreSQL syntax
+        def tables_to_skip
+          return "" unless skip_tables
+          [*skip_tables].map {|table| " -T \"#{table}\" "}
+        end
+
+    end
+  end
+end