dmitryv-backup 2.4.0

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,138 @@
+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}.#{procedure.compressor_class::ARCHIVE_EXTENSION}"
+        self.final_file       = compressed_file
+
+        begin
+          create_tmp_folder
+          load_settings # if respond_to?(:load_settings)
+          perform
+          encrypt
+          store
+          record
+          notify
+        ensure
+          remove_tmp_files
+        end
+      end
+      
+      # Creates the temporary folder for the specified adapter
+      def create_tmp_folder
+        run "mkdir -p #{tmp_path}"
+      end
+      
+      # TODO make methods in derived classes public? respond_to cannot identify private methods
+      def load_settings
+      end
+
+      # Removes the files inside the temporary folder
+      def remove_tmp_files
+        run "rm #{File.join(tmp_path, '*')}"
+      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 <sweetspot-backup2007@6bar8.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..",
+          :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/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} | #{procedure.compressor_class::COMPRESS_COMMAND} #{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

data/lib/backup/adapters/sqlite.rb

@@ -0,0 +1,25 @@
+module Backup
+  module Adapters
+    class SQLite < Base
+      
+      attr_accessor :database
+      
+      private
+
+        # Compress the sqlite file
+        def perform
+          log system_messages[:sqlite]
+          run "gzip -c --best #{database} > #{File.join(tmp_path, compressed_file)}"
+        end
+        
+        def load_settings
+          self.database = procedure.get_adapter_configuration.attributes['database']
+        end
+        
+        def performed_file_extension
+          ""
+        end
+
+    end
+  end
+end

data/lib/backup/command_helper.rb

@@ -0,0 +1,11 @@
+module Backup
+  module CommandHelper
+    def run(command)
+      Kernel.system command
+    end
+ 
+    def log(command)
+      puts "Backup (#{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}) => #{command}"
+    end
+  end
+end

data/lib/backup/compressors/base.rb

@@ -0,0 +1,7 @@
+module Backup
+  module Compressors
+    class Base
+
+    end
+  end
+end

data/lib/backup/compressors/gzip.rb

@@ -0,0 +1,9 @@
+module Backup
+  module Compressors
+    class Gzip < Base
+      ARCHIVE_EXTENSION = 'gz'
+      COMPRESS_COMMAND = 'gzip -f --best > '
+
+    end
+  end
+end

data/lib/backup/compressors/seven_zip.rb

@@ -0,0 +1,9 @@
+module Backup
+  module Compressors
+    class SevenZip < Base
+      ARCHIVE_EXTENSION = '7z'
+      COMPRESS_COMMAND = '7za a -si -m0=PPMd -t7z '
+
+    end
+  end
+end

data/lib/backup/configuration/adapter.rb

@@ -0,0 +1,21 @@
+module Backup
+  module Configuration
+    class Adapter
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(files exclude user password database tables skip_tables commands additional_options)
+
+      def initialize
+        @options = Backup::Configuration::AdapterOptions.new
+      end
+
+      def options(&block)
+        @options.instance_eval &block
+      end
+      
+      def get_options
+        @options
+      end
+
+    end
+  end
+end

data/lib/backup/configuration/adapter_options.rb

@@ -0,0 +1,8 @@
+module Backup
+  module Configuration
+    class AdapterOptions
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(host port socket)
+    end
+  end
+end

data/lib/backup/configuration/attributes.rb

@@ -0,0 +1,19 @@
+module Backup
+  module Configuration
+    module Attributes
+      
+      def generate_attributes(*attrs)
+        define_method :attributes do
+          @attributes ||= {}
+        end
+        
+        attrs.flatten.each do |att|
+          define_method att do |value|
+            self.attributes[att.to_s] = value
+          end
+        end
+      end
+    end
+  end
+end
+