backup 1.3.4 → 2.0.0

data/generators/backup/templates/migrations/create_backup_tables.rb

@@ -0,0 +1,24 @@
+class CreateBackupTables < ActiveRecord::Migration
+  def self.up
+    create_table :backup_s3 do |t|
+      t.string :trigger
+      t.string :adapter
+      t.string :filename
+      t.string :bucket
+      t.timestamps
+    end
+    
+    create_table :backup_scp do |t|
+      t.string :trigger
+      t.string :adapter
+      t.string :filename
+      t.string :path
+      t.timestamps          
+    end
+  end
+
+  def self.down
+    drop_table :backup_s3
+    drop_table :backup_scp
+  end
+end

data/generators/backup/templates/tasks/backup.rake

@@ -0,0 +1,42 @@
+namespace :backup do
+
+  desc "Run Backup Procedure."
+  task :run => :environment do
+    Backup::Setup.new(ENV['trigger'], @backup_procedures).initialize_adapter
+  end
+  
+  desc "Truncates all records for the specified \"trigger\", excluding the physical files on s3 or the remote server."
+  task :truncate => :environment do
+    backup = Backup::Setup.new(ENV['trigger'], @backup_procedures)
+    case backup.procedure.storage_name.to_sym
+      when :s3  then Backup::Record::S3.destroy_all(:trigger => ENV['trigger'])
+      when :scp then Backup::Record::SCP.destroy_all(:trigger => ENV['trigger'])
+    end
+  end
+  
+  desc "Truncates everything."
+  task :truncate_all => :environment do
+    Backup::Record::S3.destroy_all
+    Backup::Record::SCP.destroy_all
+  end
+  
+  desc "Destroys all records for the specified \"trigger\", including the physical files on s3 or the remote server."
+  task :destroy => :environment do
+    backup = Backup::Setup.new(ENV['trigger'], @backup_procedures)
+    case backup.procedure.storage_name.to_sym
+      when :s3  then Backup::Record::S3.destroy_all_backups(backup.procedure, ENV['trigger'])
+      when :scp then Backup::Record::SCP.destroy_all_backups(backup.procedure, ENV['trigger'])
+    end
+  end
+  
+  desc "Destroys all records for the specified \"trigger\", including the physical files on s3 or the remote server."
+  task :destroy_all => :environment do
+    @backup_procedures.each do |backup_procedure|
+      case backup_procedure.storage_name.to_sym
+        when :s3  then Backup::Record::S3.destroy_all_backups(backup_procedure, backup_procedure.trigger)
+        when :scp then Backup::Record::SCP.destroy_all_backups(backup_procedure, backup_procedure.trigger)
+      end
+    end
+  end
+  
+end

data/lib/backup.rb

@@ -1,16 +1,68 @@
-require 'backup/base'
-require 'backup/encrypt'
-require 'backup/adapter/sqlite3'
-require 'backup/adapter/mysql'
-require 'backup/adapter/assets'
-require 'backup/adapter/custom'
-require 'backup/transfer/base'
-require 'backup/transfer/s3'
-require 'backup/transfer/ssh'
-require 'backup/connection/base'
+# Connectivity and Record Gems
+require 'net/ssh'
+require 'net/scp'
+require 'aws/s3'
+require 'sqlite3'
+
+# Load in Adapters
+require 'backup/adapters/base'
+require 'backup/adapters/mysql'
+require 'backup/adapters/archive'
+
+# Load in Connectors
 require 'backup/connection/s3'
-require 'backup/connection/ssh'
-require 'backup/backup_record/s3'
 
+# Load in Storage
+require 'backup/storage/s3'
+require 'backup/storage/scp'
+
+# Load in Backup Recorders
+require 'backup/record/s3'
+require 'backup/record/scp'
+
+# Load in Configuration
+require 'backup/configuration/base'
+require 'backup/configuration/adapter'
+require 'backup/configuration/storage'
+require 'backup/configuration/helpers'
+
+# Load Backup Configuration Helpers
+include Backup::Configuration::Helpers
+
+# Load in User Configured Backup Procedures if the file exists
+if File.exist?(File.join(RAILS_ROOT, 'config', 'backup.rb'))
+  require File.join(RAILS_ROOT, 'config', 'backup.rb')
+end
+
+# Backup Module
 module Backup
+  class Setup
+  
+    attr_accessor :trigger, :procedures, :procedure
+  
+    def initialize(trigger, procedures)
+      self.trigger    = trigger
+      self.procedures = procedures
+      self.procedure  = find_triggered_procedure
+    end
+    
+    def initialize_adapter
+      case procedure.adapter_name.to_sym
+        when :mysql   then Backup::Adapters::MySQL.new(trigger, procedure)
+        when :archive then Backup::Adapters::Archive.new(trigger, procedure)
+        else raise "Unknown Adapter: \"#{procedure.adapter_name}\""
+      end
+    end
+    
+    def find_triggered_procedure
+      procedures.each do |procedure|
+        if procedure.trigger.eql?(trigger)
+          return procedure
+        end
+      end
+      available_triggers = procedures.each.map {|procedure| "- #{procedure.trigger}\n" }
+      raise "Could not find a backup procedure with the trigger \"#{trigger}\". \nHere's a list of available triggers:\n#{available_triggers}"
+    end
+
+  end
 end

data/lib/backup/adapters/archive.rb

@@ -0,0 +1,53 @@
+module Backup
+  module Adapters
+    class Archive < Backup::Adapters::Base
+      
+      attr_accessor :archived_file, :compressed_file, :encrypted_file, :user, :password, :database
+      
+      # Initializes the Backup Process
+      def initialize(trigger, procedure)
+        super
+        load_settings
+        
+        targz
+        encrypt
+        store
+        record
+        remove_tmp_files
+      end
+      
+      private
+        
+        # Archives and Compresses all files
+        def targz
+          files = procedure.get_adapter_configuration.attributes['files']
+          if files.is_a?(Array)
+            %x{ tar -czf #{File.join(tmp_path, compressed_file)} #{files.map{|f| f.gsub(' ', '\ ')}.join(' ')} }
+          elsif files.is_a?(String)
+            %x{ tar -czf #{File.join(tmp_path, compressed_file)} #{files.gsub(' ', '\ ')} }
+          end
+        end
+        
+        # Encrypts the Archive
+        def encrypt
+          if encrypt_with_password.is_a?(String)
+            %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
+        end
+        
+        # Loads the initial settings
+        def load_settings
+          self.user     = procedure.get_adapter_configuration.attributes['user']
+          self.password = procedure.get_adapter_configuration.attributes['password']
+          self.database = procedure.get_adapter_configuration.attributes['database']
+
+          self.archived_file    = "#{timestamp}.archive.#{trigger.gsub(' ', '-')}.tar"      
+          self.compressed_file  = "#{archived_file}.gz"
+          self.encrypted_file   = "#{compressed_file}.enc"
+          self.final_file       = compressed_file
+        end
+        
+    end
+  end
+end

data/lib/backup/adapters/base.rb

@@ -0,0 +1,65 @@
+module Backup
+  module Adapters
+    class Base
+
+      attr_accessor :procedure, :timestamp, :options, :tmp_path, :encrypt_with_password, :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
+      #
+      # It is important that, whatever the final filename of the file will be, that :final_file will contain it.
+      attr_accessor :final_file
+
+      def initialize(trigger, procedure)
+        self.trigger                = trigger
+        self.procedure              = procedure
+        self.timestamp              = Time.now.strftime("%Y%m%d%H%M%S")
+        self.tmp_path               = "#{RAILS_ROOT.gsub(' ', '\ ')}/tmp/backup/#{procedure.adapter_name}"
+        self.encrypt_with_password  = procedure.attributes['encrypt_with_password']
+        self.keep_backups           = procedure.attributes['keep_backups']
+        create_tmp_folder
+      end
+      
+      # Creates the temporary folder for the specified adapter
+      def create_tmp_folder
+        %x{ mkdir -p #{tmp_path} }
+      end
+
+      # Removes the files inside the temporary folder
+      def remove_tmp_files
+        %x{ rm #{tmp_path}/* }
+      end
+
+      # Initializes the storing process depending on the store settings
+      # Options:
+      #  Amazon (S3)
+      #  Remote Server (SCP)
+      def store
+        case procedure.storage_name.to_sym
+          when :s3  then Backup::Storage::S3.new(self)
+          when :scp then Backup::Storage::SCP.new(self)
+        end
+      end
+      
+      # Records data on every individual file to the backup.sqlite3 local database
+      def record
+        case procedure.storage_name.to_sym
+          when :s3
+            record = Backup::Record::S3.new
+            record.load_adapter(self)
+            record.save
+          when :scp
+            record = Backup::Record::SCP.new
+            record.load_adapter(self)
+            record.save
+        end
+      end
+      
+    end
+  end
+end

data/lib/backup/adapters/mysql.rb

@@ -0,0 +1,48 @@
+module Backup
+  module Adapters
+    class MySQL < Backup::Adapters::Base
+      
+      attr_accessor :dumped_file, :compressed_file, :encrypted_file, :user, :password, :database
+      
+      # Initializes the Backup Process
+      def initialize(trigger, procedure)
+        super
+        load_settings
+        
+        mysqldump
+        encrypt
+        store
+        record
+        remove_tmp_files
+      end
+      
+      private
+        
+        # Dumps and Compresses the MySQL file 
+        def mysqldump
+          %x{ mysqldump -u #{user} --password='#{password}' #{database} | gzip -f --best > #{File.join(tmp_path, compressed_file)} }
+        end
+        
+        # Encrypts the MySQL file
+        def encrypt
+          if encrypt_with_password.is_a?(String)
+            %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
+        end
+        
+        # Loads the initial settings
+        def load_settings
+          self.user     = procedure.get_adapter_configuration.attributes['user']
+          self.password = procedure.get_adapter_configuration.attributes['password']
+          self.database = procedure.get_adapter_configuration.attributes['database']
+
+          self.dumped_file      = "#{timestamp}.#{database}.sql"      
+          self.compressed_file  = "#{dumped_file}.gz"
+          self.encrypted_file   = "#{compressed_file}.enc"
+          self.final_file       = compressed_file
+        end
+        
+    end
+  end
+end

data/lib/backup/configuration/adapter.rb

@@ -0,0 +1,17 @@
+module Backup
+  module Configuration
+    class Adapter
+      attr_accessor :attributes 
+      
+      %w(files user password database).each do |method|
+        define_method method do |value|
+          attributes[method] = value
+        end
+      end
+
+      def initialize
+        @attributes = {}
+      end
+    end
+  end
+end

data/lib/backup/configuration/base.rb

@@ -0,0 +1,38 @@
+module Backup
+  module Configuration
+    class Base
+      attr_accessor :attributes, :trigger, :storage_name, :adapter_name
+
+      %w(encrypt_with_password keep_backups).each do |method|
+        define_method method do |value|
+          attributes[method] = value
+        end
+      end
+
+      def initialize(trigger)
+        @attributes = {}
+        @trigger = trigger
+        @adapter_configuration = Backup::Configuration::Adapter.new
+        @storage_configuration = Backup::Configuration::Storage.new
+      end
+
+      def adapter(adapter, &block)
+        @adapter_name = adapter
+        @adapter_configuration.instance_eval &block
+      end
+  
+      def storage(storage, &block)
+        @storage_name = storage
+        @storage_configuration.instance_eval &block
+      end
+  
+      def get_adapter_configuration
+        @adapter_configuration
+      end
+  
+      def get_storage_configuration
+        @storage_configuration
+      end
+    end
+  end
+end

data/lib/backup/configuration/helpers.rb

@@ -0,0 +1,12 @@
+module Backup
+  module Configuration
+    module Helpers
+      def backup(trigger, &block)
+        backup = Backup::Configuration::Base.new(trigger)
+        backup.instance_eval &block
+        @backup_procedures ||= Array.new
+        @backup_procedures << backup
+      end
+    end
+  end
+end

data/lib/backup/configuration/storage.rb

@@ -0,0 +1,17 @@
+module Backup
+  module Configuration
+    class Storage
+      attr_accessor :attributes 
+
+      %w(ip user password path access_key_id secret_access_key bucket).each do |method|
+        define_method method do |value|
+          attributes[method] = value
+        end
+      end
+
+      def initialize
+        @attributes = {}
+      end
+    end
+  end
+end

data/lib/backup/connection/s3.rb

@@ -1,18 +1,32 @@
 module Backup
   module Connection
-    class S3 < Backup::Connection::Base
+    class S3
       
-      def initialize(options = {})
-        options.symbolize_keys!
-        options[:s3].symbolize_keys!
-        super(options)
+      attr_accessor :adapter, :access_key_id, :secret_access_key, :s3_bucket, :final_file, :tmp_path
+      
+      # Initializes the S3 connection, setting the values using the S3 adapter
+      def initialize(adapter = false)
+        if adapter
+          self.final_file         = adapter.final_file
+          self.tmp_path           = adapter.tmp_path.gsub('\ ', ' ')
+          self.access_key_id      = adapter.procedure.get_storage_configuration.attributes['access_key_id']
+          self.secret_access_key  = adapter.procedure.get_storage_configuration.attributes['secret_access_key']
+          self.s3_bucket          = adapter.procedure.get_storage_configuration.attributes['bucket']
+        end
+      end
+      
+      # Sets values from a procedure, rather than from the adapter object
+      def static_initialize(procedure)
+        self.access_key_id      = procedure.get_storage_configuration.attributes['access_key_id']
+        self.secret_access_key  = procedure.get_storage_configuration.attributes['secret_access_key']
+        self.s3_bucket          = procedure.get_storage_configuration.attributes['bucket']
       end
       
       # Establishes a connection with Amazon S3 using the credentials provided by the user
       def connect
         AWS::S3::Base.establish_connection!(
-          :access_key_id     => options[:s3][:access_key_id], 
-          :secret_access_key => options[:s3][:secret_access_key]
+          :access_key_id     => access_key_id,
+          :secret_access_key => secret_access_key
         )
       end
       
@@ -33,17 +47,18 @@ module Backup
       
       # Initializes the file transfer to Amazon S3
       # This can only run after a connection has been made using the #connect method 
-      def transfer
+      def store
+        puts "Storing \"#{final_file}\" to bucket \"#{s3_bucket}\" on Amazon S3."
         object.store(
-          options[:backup_file],
-          open(File.join(options[:backup_path], options[:backup_file])),
-          options[:s3][:bucket] )
+          final_file,
+          open(File.join(tmp_path, final_file)),
+          s3_bucket )
       end
       
       # Destroys file from a bucket on Amazon S3
-      def destroy(backup_file, bucket)
+      def destroy(file, bucket)
         object.delete(
-          backup_file,
+          file,
           bucket )
       end