backup 2.3.1 → 2.3.2.pre

data/lib/backup/adapters/custom.rb

@@ -2,78 +2,40 @@ module Backup
   module Adapters
     class Custom < Backup::Adapters::Base
       
-      attr_accessor :archived_file, :compressed_file, :encrypted_file, :commands
+      attr_accessor :commands
       
-      # 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 execute any given commands
-      # Then it will archive and compress every folder/file
-      # 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)
-        super
-        load_settings
-        
-        begin
+      private
+
+        # Execute any given commands, then archive and compress every folder/file
+        def perform
           execute_commands
           targz
-          encrypt
-          store
-          record
-          notify
-        ensure
-          remove_tmp_files
         end
-      end
-      
-      private
         
         # Executes the commands
         def execute_commands
-          if commands.is_a?(Array)
-            puts system_messages[:commands]
-            commands.each do |command|
-              %x{ #{command.gsub(':tmp_path', tmp_path)} }
-            end
-          elsif commands.is_a?(String)
-            puts system_messages[:commands]
-            %x{ #{commands.gsub(':tmp_path', tmp_path)} }
+          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
-          puts system_messages[:archiving]; puts system_messages[:compressing]
-          %x{ tar -czf #{File.join(tmp_path, compressed_file)} #{File.join(tmp_path, '*')} }
+          log system_messages[:archiving]; log system_messages[:compressing]
+          run "tar -czf #{File.join(tmp_path, compressed_file)} #{File.join(tmp_path, '*')}"
         end
         
-        # Encrypts the archive file
-        def encrypt
-          if encrypt_with_password.is_a?(String)
-            puts system_messages[:encrypting]
-            %x{ openssl enc -des-cbc -in #{File.join(tmp_path, compressed_file)} -out #{File.join(tmp_path, encrypted_file)} -k #{encrypt_with_password} }
-            self.final_file = encrypted_file
-          end
+        def performed_file_extension
+          ".tar"
         end
-        
+
         # Loads the initial settings
         def load_settings
-          self.trigger  = procedure.trigger
           self.commands = procedure.get_adapter_configuration.attributes['commands']
-          
-          self.archived_file    = "#{timestamp}.#{trigger.gsub(' ', '-')}.tar"      
-          self.compressed_file  = "#{archived_file}.gz"
-          self.encrypted_file   = "#{compressed_file}.enc"
-          self.final_file       = compressed_file
         end
                 
     end
   end
-end
+end

data/lib/backup/adapters/mysql.rb

@@ -2,68 +2,36 @@ module Backup
   module Adapters
     class MySQL < Backup::Adapters::Base
       
-      attr_accessor :dumped_file, :compressed_file, :encrypted_file, :user, :password, :database, :skip_tables, :host, :port, :socket, :additional_options
-      
-      # 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 create a compressed MySQL dump 
-      # 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)
-        super
-        load_settings
-        
-        begin
-          mysqldump
-          encrypt
-          store
-          record
-          notify
-        ensure
-          remove_tmp_files
-        end
-      end
+      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
-          puts system_messages[:mysqldump]; puts system_messages[:compressing]
-          %x{ mysqldump -u #{user} --password='#{password}' #{options} #{additional_options} #{database} #{tables_to_skip} | gzip -f --best > #{File.join(tmp_path, compressed_file)} }
+          # 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
         
-        # Encrypts the MySQL file
-        def encrypt
-          if encrypt_with_password.is_a?(String)
-            puts system_messages[:encrypting]
-            %x{ openssl enc -des-cbc -in #{File.join(tmp_path, compressed_file)} -out #{File.join(tmp_path, encrypted_file)} -k #{encrypt_with_password} }
-            self.final_file = encrypted_file
-          end
+        def performed_file_extension
+          ".sql"
         end
-        
+
         # Loads the initial settings
         def load_settings
-          self.trigger  = procedure.trigger
-          
-          %w(user password database skip_tables additional_options).each do |attribute|
+          %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
-
-          self.dumped_file      = "#{timestamp}.#{trigger.gsub(' ', '-')}.sql"      
-          self.compressed_file  = "#{dumped_file}.gz"
-          self.encrypted_file   = "#{compressed_file}.enc"
-          self.final_file       = compressed_file
         end
         
         # Returns a list of options in MySQL syntax
@@ -77,15 +45,16 @@ module Backup
         
         # Returns a list of tables to skip in MySQL syntax
         def tables_to_skip
-          if skip_tables.is_a?(Array)
-            skip_tables.map {|table| " --ignore-table='#{database}.#{table}' "}
-          elsif skip_tables.is_a?(String)
-            " --ignore-table='#{database}.#{skip_tables}' "
-          else
-            ""
-          end
+          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
+end

data/lib/backup/adapters/postgresql.rb

@@ -2,56 +2,31 @@ module Backup
   module Adapters
     class PostgreSQL < Backup::Adapters::Base
 
-      attr_accessor :dumped_file, :compressed_file, :encrypted_file, :user, :password, :database, :skip_tables, :host, :port, :socket, :additional_options
-      
-      # 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 create a compressed PostgreSQL dump 
-      # 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)
-        super
-        load_settings
-
-        begin
-          pg_dump
-          encrypt
-          store
-          record
-          notify
-        ensure
-          remove_tmp_files
-        end
-      end
+      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
-            puts system_messages[:pgdump]; puts system_messages[:compressing]
-           %x{ pg_dump -U #{user} #{options} #{additional_options} #{tables_to_skip} #{database} | gzip -f --best > #{File.join(tmp_path, compressed_file)} }
+          # 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
         
-        # Encrypts the PostgreSQL file
-        def encrypt
-          if encrypt_with_password.is_a?(String)
-            puts system_messages[:encrypting]
-            %x{ openssl enc -des-cbc -in #{File.join(tmp_path, compressed_file)} -out #{File.join(tmp_path, encrypted_file)} -k #{encrypt_with_password} }
-            self.final_file = encrypted_file
-          end
+        def performed_file_extension
+          ".sql"
         end
-        
+
         # Loads the initial settings
         def load_settings
-          self.trigger  = procedure.trigger
-          
           %w(user password database skip_tables additional_options).each do |attribute|
             send(:"#{attribute}=", procedure.get_adapter_configuration.attributes[attribute])
           end
@@ -59,11 +34,6 @@ module Backup
           %w(host port socket).each do |attribute|
             send(:"#{attribute}=", procedure.get_adapter_configuration.get_options.attributes[attribute])
           end
-
-          self.dumped_file      = "#{timestamp}.#{trigger.gsub(' ', '-')}.sql"      
-          self.compressed_file  = "#{dumped_file}.gz"
-          self.encrypted_file   = "#{compressed_file}.enc"
-          self.final_file       = compressed_file
         end
         
         # Returns a list of options in PostgreSQL syntax
@@ -77,15 +47,10 @@ module Backup
         
         # Returns a list of tables to skip in PostgreSQL syntax
         def tables_to_skip
-          if skip_tables.is_a?(Array)
-            skip_tables.map {|table| " -T \"#{table}\" "}
-          elsif skip_tables.is_a?(String)
-            " -T \"#{skip_tables}\" "
-          else
-            ""
-          end
+          return "" unless skip_tables
+          [*skip_tables].map {|table| " -T \"#{table}\" "}
         end
 
     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 => #{command}"
+    end
+  end
+end

data/lib/backup/configuration/adapter.rb

@@ -1,18 +1,11 @@
 module Backup
   module Configuration
     class Adapter
-      
-      attr_accessor :attributes 
-      
-      %w(files user password database skip_tables commands additional_options).each do |method|
-        define_method method do |value|
-          attributes[method] = value
-        end
-      end
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(files exclude user password database tables skip_tables commands additional_options)
 
       def initialize
-        @attributes = {}
-        @options    = Backup::Configuration::AdapterOptions.new
+        @options = Backup::Configuration::AdapterOptions.new
       end
 
       def options(&block)
@@ -25,4 +18,4 @@ module Backup
 
     end
   end
-end
+end

data/lib/backup/configuration/adapter_options.rb

@@ -1,19 +1,8 @@
 module Backup
   module Configuration
     class AdapterOptions
-      
-      attr_accessor :attributes 
-      
-      %w(host port socket).each do |method|
-        define_method method do |value|
-          attributes[method] = value
-        end
-      end
-
-      def initialize
-        @attributes = {}
-      end
-      
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(host port socket)
     end
   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
+

data/lib/backup/configuration/base.rb

@@ -1,16 +1,12 @@
 module Backup
   module Configuration
     class Base
-      attr_accessor :attributes, :trigger, :storage_name, :adapter_name
-
-      %w(encrypt_with_password keep_backups notify).each do |method|
-        define_method method do |value|
-          attributes[method] = value
-        end
-      end
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(encrypt_with_password keep_backups notify)
+      
+      attr_accessor :trigger, :storage_name, :adapter_name
 
       def initialize(trigger)
-        @attributes = {}
         @trigger = trigger
         @adapter_configuration = Backup::Configuration::Adapter.new
         @storage_configuration = Backup::Configuration::Storage.new
@@ -25,6 +21,27 @@ module Backup
         @storage_name = storage
         @storage_configuration.instance_eval &block
       end
+
+      # Initializes the storing process depending on the store settings
+      def initialize_storage(adapter)
+        case @storage_name.to_sym
+          when :s3    then Backup::Storage::S3.new(adapter)
+          when :scp   then Backup::Storage::SCP.new(adapter)
+          when :ftp   then Backup::Storage::FTP.new(adapter)
+          when :sftp  then Backup::Storage::SFTP.new(adapter)
+          when :local then Backup::Storage::Local.new(adapter)
+        end
+      end
+
+      def initialize_record
+        case @storage_name.to_sym
+          when :s3    then Backup::Record::S3.new
+          when :scp   then Backup::Record::SCP.new
+          when :ftp   then Backup::Record::FTP.new
+          when :sftp  then Backup::Record::SFTP.new
+          when :local then Backup::Record::Local.new
+        end        
+      end
   
       def get_adapter_configuration
         @adapter_configuration
@@ -35,4 +52,4 @@ module Backup
       end
     end
   end
-end
+end