backup 1.3.4 → 2.0.0

data/lib/backup/backup_record/ssh.rb

@@ -1,90 +0,0 @@
-require 'net/ssh'
-
-module Backup
-  module BackupRecord
-    class SSH < ActiveRecord::Base
-        
-      # Establishes a connection with the SQLite3
-      # local database to avoid conflict with users
-      # Production database.
-      establish_connection(
-        :adapter  => "sqlite3",
-        :database => "db/backup.sqlite3",
-        :pool     => 5,
-        :timeout  => 5000 )
-      
-      # Scopes
-      default_scope :order => 'created_at desc'
-      
-      # Callbacks
-      after_save :destroy_old_backups
-      
-      # Attributes
-      attr_accessor :options, :keep_backups, :ip, :user
-      
-      # Receives the options hash and stores it
-      # Sets the S3 values
-      def set_options(options)
-        self.options      = options
-        self.backup_file  = options[:backup_file]
-        self.backup_path  = options[:ssh][:path]
-        self.keep_backups = options[:keep_backups]
-        self.adapter      = options[:adapter]
-        self.index        = options[:index]
-        self.ip           = options[:ssh][:ip]
-        self.user         = options[:ssh][:user]
-      end
-      
-      # This will only be triggered by the rake task
-      # rake backup:db:destroy:ssh
-      # 
-      # This will loop through all the configured adapters
-      # and destroy all "Backup" database records for the
-      # SSH table and delete all backed up files from the
-      # remote server on which they are stored.
-      def self.destroy_all_backups(adapter, options, index)
-        backups = Backup::BackupRecord::SSH.all(:conditions => {:adapter => adapter, :index => index})
-        unless backups.empty?
-          Net::SSH.start(options['ssh']['ip'], options['ssh']['user']) do |ssh|
-            # Loop through all backups that should be destroyed and remove them from remote server.
-            backups.each do |backup|
-              puts "Destroying old backup: #{backup.backup_file}.."
-              ssh.exec("rm #{File.join(backup.backup_path, backup.backup_file)}")
-              backup.destroy
-            end
-          end
-        end
-      end
-
-      private
-        
-        # Destroys backups when the backup limit has been reached
-        # This is determined by the "keep_backups:" parameter
-        # First all backups will be fetched. 
-        def destroy_old_backups
-          if keep_backups.is_a?(Integer)
-            backups = Backup::BackupRecord::SSH.all(:conditions => {:adapter => adapter, :index => index})
-            backups_to_destroy = Array.new
-            backups.each_with_index do |backup, index|
-              if index >= keep_backups then
-                backups_to_destroy << backup
-              end
-            end
-          
-            if backups_to_destroy
-              # Establish a connection with the remote server through SSH
-              Net::SSH.start(ip, user) do |ssh|
-                # Loop through all backups that should be destroyed and remove them from remote server.
-                backups_to_destroy.each do |backup|
-                  puts "Destroying old backup: #{backup.backup_file}.."
-                  ssh.exec("rm #{File.join(backup.backup_path, backup.backup_file)}")
-                  backup.destroy
-                end
-              end
-            end
-          end
-        end
-        
-    end
-  end
-end

data/lib/backup/base.rb

@@ -1,92 +0,0 @@
-module Backup
-  class Base
-    
-    attr_accessor :options, :backup_time
-    
-    def initialize(options = {})
-      self.options      = options
-      self.backup_time  = Time.now.strftime("%Y%m%d%H%M%S") 
-    end
-    
-    private
-      
-      # Sets up the default paths and stores them in the options hash
-      # It also ensures the directory to where the temporary files are stored
-      # exists. If it doesn't it'll be created
-      # It will store the backup_path and the backup_file names
-      # The backup_file name is prefixed with the timestamp of the initialize time.
-      def setup_paths(path, type = nil)
-        %x{ mkdir -p #{RAILS_ROOT}/tmp/backups/#{path} }
-        options[:backup_path] = "#{RAILS_ROOT}/tmp/backups/#{path}"
-        
-        if options[:file].is_a?(Array)
-          options[:backup_file] = "#{backup_time}-#{options[:file].first}.#{type}"
-        else
-          options[:backup_file] = "#{backup_time}-#{options[:file]}.#{type}"
-        end
-      end
-    
-      # Initializes one of the transfer methods
-      # Currently there are two transfer methods available
-      #
-      # - Amazon S3
-      # - SSH
-      def transfer
-        case options[:use]
-          when :s3  then Backup::Transfer::S3.new(options)
-          when :ssh then Backup::Transfer::SSH.new(options)
-        end
-      end
-      
-      # Records a backup to the "backup.sqlite3" database
-      # Will destroy any old backups that exceed the amount of
-      # backups that are allowed to be stored on either S3 or any
-      # remote server through SSH.
-      def record        
-        case options[:use]
-          when :s3
-            backup = Backup::BackupRecord::S3.new
-            backup.set_options(options)
-            backup.save
-          
-          when :ssh
-            backup = Backup::BackupRecord::SSH.new
-            backup.set_options(options)
-            backup.save
-        end
-      end
-      
-      # Encrypts the backup file
-      # Only if the encrypt option is specified inside the .yml config file
-      # Otherwise, the encryption will be not be executed.
-      # Encryption is OPTIONAL.
-      def encrypt
-        unless options[:encrypt].blank?
-          Backup::Encrypt.new(options).run
-          options[:backup_file] = "#{options[:backup_file]}.enc"
-        end
-      end
-      
-      # Removes files that were stored in the tmp/backups/* directory of the Rails application
-      # It completely cleans up the backup folders so theres no trash stored on the production server
-      def remove_temp_files
-        %x{ rm #{File.join(options[:backup_path], "*")} }
-      end
-      
-      # Removes files that were generated for the transfer
-      # This can remove either a single file or an array of files
-      # Depending on whether the options[:file] is an Array or a String
-      def remove_original_file
-        unless options[:keep_original_files].eql?(true)
-          if options[:file].is_a?(Array)
-            options[:file].each do |file|
-              %x{ rm #{File.join(options[:path], file)} }          
-            end
-          else
-            %x{ rm #{File.join(options[:path], options[:file])} }
-          end
-        end
-      end
-      
-  end
-end

data/lib/backup/connection/base.rb

@@ -1,13 +0,0 @@
-module Backup
-  module Connection
-    class Base
-      
-      attr_accessor :options
-      
-      def initialize(options)
-        self.options = options
-      end
-
-    end
-  end
-end

data/lib/backup/connection/ssh.rb

@@ -1,19 +0,0 @@
-module Backup
-  module Connection
-    class SSH < Backup::Connection::Base
-      
-      def initialize(options = {})
-        super(options)
-      end
-      
-      # Initializes the transfer to the specified server using SSH.
-      # This will first ensure there is a directory, if there is not, a new one will be created
-      # After the directory has been confirmed, the transfer process will be initialized.
-      def transfer
-        %x{ ssh #{options[:ssh][:user]}@#{options[:ssh][:ip]} mkdir -p #{options[:ssh][:path]} }
-        %x{ scp #{File.join(options[:backup_path], options[:backup_file])} #{options[:ssh][:user]}@#{options[:ssh][:ip]}:#{options[:ssh][:path]} }
-      end
-
-    end
-  end 
-end

data/lib/backup/encrypt.rb

@@ -1,18 +0,0 @@
-module Backup
-  class Encrypt
-    
-    attr_accessor :options
-    
-    def initialize(options = {})
-      self.options = options
-    end
-    
-    # Encrypts the backup file
-    def run
-      unencrypted_file  = File.join(options[:backup_path], options[:backup_file])
-      encrypted_file    = File.join(options[:backup_path], options[:backup_file] + '.enc')
-      %x{ openssl enc -des-cbc -in #{unencrypted_file} -out #{encrypted_file} -k #{options[:encrypt]} }
-    end
-    
-  end  
-end

data/lib/backup/transfer/base.rb

@@ -1,13 +0,0 @@
-module Backup
-  module Transfer
-    class Base
-      
-      attr_accessor :options
-      
-      def initialize(options)
-        self.options = options
-      end
-      
-    end
-  end
-end

data/lib/backup/transfer/s3.rb

@@ -1,36 +0,0 @@
-require 'aws/s3'
-
-module Backup
-  module Transfer
-    class S3 < Backup::Transfer::Base
-    
-      def initialize(options)
-        super(default_options.merge(options))
-        
-        # Creates a new instance of the Amazon S3 Wrapper Class/Object
-        # Passes in the options hash and lets the wrapper extract only the
-        # necessary information that is required to establish a link to Amazon S3.
-        s3 = Backup::Connection::S3.new(options)
-        
-        # Connects to Amazon S3 using the credentials provided and
-        # stored in the options has by the user
-        s3.connect
-        
-        # Initializes the file transfer to Amazon S3
-        s3.transfer
-      end
-      
-      private
-      
-        # Set default options
-        def default_options
-          {:s3 => {
-              :access_key_id      => '',
-              :secret_access_key  => '',
-              :bucket             => ''
-            }}
-        end
-      
-    end
-  end
-end

data/lib/backup/transfer/ssh.rb

@@ -1,30 +0,0 @@
-module Backup
-  module Transfer
-    class SSH < Backup::Transfer::Base
-      
-      def initialize(options)
-        super(default_options.merge(options))
-        
-        # Creates a new instance of the SSH Wrapper Class/Object
-        # Passes in the options hash and lets the wrapper extract only the
-        # necessary information that is required to later transfer the specified file through SSH.
-        ssh = Backup::Connection::SSH.new(options)
-        
-        # Initializes the file transfer to the specified server through SSH.
-        ssh.transfer
-      end
-      
-      private
-      
-        # Set default options
-        def default_options
-          {:ssh => {
-            :user => "",
-            :ip   => "",
-            :path => "/var/backups/"
-          }}
-        end
-
-    end
-  end
-end