namxam-backup 2.4.5

data/lib/backup/core_ext/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end unless method_defined? :blank?
+end

data/lib/backup/environment/base.rb

@@ -0,0 +1,12 @@
+module Backup
+  module Environment
+    module Base
+      
+      def current_environment
+        return :rails if defined?(Rails.root)
+        return :unix
+      end
+      
+    end
+  end
+end

data/lib/backup/environment/rails_configuration.rb

@@ -0,0 +1,15 @@
+module Backup
+  module Environment
+    module RailsConfiguration
+      
+      if defined?(Rails.root)
+        # Sets BACKUP_PATH equal to Rails.root
+        BACKUP_PATH = Rails.root.to_s
+      
+        # Sets DB_CONNECTION_SETTINGS to false
+        DB_CONNECTION_SETTINGS = false
+      end
+    
+    end
+  end
+end

data/lib/backup/environment/unix_configuration.rb

@@ -0,0 +1,109 @@
+module Backup
+  module Environment
+    module UnixConfiguration
+      
+      require 'active_record'
+      
+      # Sets BACKUP_PATH
+      BACKUP_PATH = ENV['BACKUP_PATH'] || "/opt/backup"
+      
+      # Sets DB_CONNECTION_SETTINGS
+      DB_CONNECTION_SETTINGS = {
+        :adapter  => "sqlite3",
+        :database => "#{BACKUP_PATH}/backup.sqlite3",
+        :pool     => 5,
+        :timeout  => 5000 
+      }
+
+      module Commands
+        
+        def setup
+          unless File.directory?(BACKUP_PATH)
+            puts "Installing Backup in #{BACKUP_PATH}.."
+            %x{ #{sudo} mkdir -p #{File.join(BACKUP_PATH, 'config')} }
+            %x{ #{sudo} cp #{File.join(File.dirname(__FILE__), '..', '..', '..', 'setup', 'backup.sqlite3')} #{BACKUP_PATH} }
+            %x{ #{sudo} cp #{File.join(File.dirname(__FILE__), '..', '..', '..', 'setup', 'backup.rb')} #{File.join(BACKUP_PATH, 'config')} }
+            puts <<-MESSAGE
+              
+  ==============================================================
+  Backup has been set up!
+  ==============================================================
+
+  1: Set up some "Backup Settings" inside the configuration file!
+
+    #{BACKUP_PATH}/config/backup.rb
+
+
+  2: Run the backups!
+
+    sudo backup --run [trigger]
+
+
+  For a list of Backup commands:
+
+    sudo backup --help
+  
+
+  For More Information:
+
+    http://github.com/meskyanichi/backup
+
+  ==============================================================
+              
+            MESSAGE
+          else
+            puts "\nBackup is already installed in #{BACKUP_PATH}..\n"
+            puts "If you want to reset it, run:\n\nbackup --reset\n\n"
+            puts "This will reinstall it."
+            puts "Warning: All configuration will be lost!\n\n"
+          end
+        end
+
+        def reset
+          if File.directory?(BACKUP_PATH)
+            remove
+            setup
+          else
+            puts "Backup is not installed.\n"
+            puts "Run the following command to install it:\n\nbackup --setup"
+          end
+        end
+
+        def remove
+          puts "Removing Backup..\n"
+          %x{ #{sudo} rm -rf #{BACKUP_PATH} }
+        end
+      end
+      
+      module Helpers
+
+        def confirm_configuration_file_existence
+          unless File.exist?(File.join(BACKUP_PATH, 'config', 'backup.rb'))
+            puts "\nBackup could not find the Backup Configuration File."
+            puts "Did you set up Backup? Do so if you haven't yet:"
+            puts "\nbackup --setup\n "
+            exit
+          end
+        end
+
+        def sudo
+          if writable?(BACKUP_PATH)
+            ""
+          else
+            "sudo"
+          end
+        end
+
+        private
+        def writable?(f)
+          unless File.exists?(f)
+            writable?(File.dirname(f))
+          else
+            File.writable?(f)
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/backup/mail/base.rb

@@ -0,0 +1,97 @@
+module Backup
+  module Mail
+    class Base
+      
+      # Sets up the Mail Configuration for the Backup::Mail::Base class.
+      # This must be set in order to send emails
+      # It will dynamically add class methods (configuration) for each email that will be sent
+      def self.setup(config)
+        if config
+          (class << self; self; end).instance_eval do
+            config.attributes.each do |method, value|
+              define_method method do
+                value
+              end
+            end
+            config.get_smtp_configuration.attributes.each do |method, value|
+              define_method method do
+                value
+              end
+            end
+          end
+        end
+      end
+      
+      # Returns true if the "to" and "from" attributes are set
+      def self.setup?
+        return true if defined?(from) and defined?(to)
+        false
+      end
+      
+      # Delivers the backup details by email to the recipient
+      # Requires the Backup Object
+      def self.notify!(backup)
+        if self.setup? and backup.procedure.attributes['notify'].eql?(true)
+          require 'pony'
+
+          @backup = backup
+          self.parse_body
+          Pony.mail({
+            :subject  => "Backup for \"#{@backup.trigger}\" was successfully created!",
+            :body     => @content
+            }.merge(self.smtp_configuration))
+          puts "Sending notification to #{self.to}."
+        end
+      end
+            
+      # Retrieves SMTP configuration
+      def self.smtp_configuration
+        { :to       => self.to,
+          :from     => self.from,
+          :via      => :smtp,
+          :smtp     => {
+          :host     => self.host,
+          :port     => self.port,
+          :user     => self.username,
+          :password => self.password,
+          :auth     => self.authentication,
+          :domain   => self.domain,
+          :tls      => self.tls
+        }}
+      end
+      
+      def self.parse_body
+        File.open(File.join(File.dirname(__FILE__), 'mail.txt'), 'r') do |file|
+          self.gsub_content(file.readlines)
+        end
+      end
+      
+      def self.gsub_content(lines)
+        container = @backup.procedure.get_storage_configuration.attributes['container']
+        bucket  = @backup.procedure.get_storage_configuration.attributes['bucket']
+        path    = @backup.procedure.get_storage_configuration.attributes['path']
+        ip      = @backup.procedure.get_storage_configuration.attributes['ip']
+        
+        lines.each do |line|
+          line.gsub!(':trigger',   @backup.trigger)
+          line.gsub!(':day',       Time.now.strftime("%A (%d)"))
+          line.gsub!(':month',     Time.now.strftime("%B"))
+          line.gsub!(':year',      Time.now.strftime("%Y"))
+          line.gsub!(':time',      Time.now.strftime("%r"))
+          line.gsub!(':adapter',   @backup.procedure.adapter_name.to_s)
+          line.gsub!(':location',  container || bucket || path)
+          line.gsub!(':backup',    @backup.final_file)
+          case @backup.procedure.storage_name.to_sym
+            when :cloudfiles        then line.gsub!(':remote', "on Rackspace Cloudfiles")
+            when :s3                then line.gsub!(':remote', "on Amazon S3")
+            when :local             then line.gsub!(':remote', "on the local server")
+            when :scp, :sftp, :ftp  then line.gsub!(':remote', "on the remote server (#{ip})")
+          end
+          @content ||= String.new
+          @content << line
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/mail/mail.txt

@@ -0,0 +1,7 @@
+A backup was successfully created for the trigger: ":trigger"!
+
+The backup was created on ":day of :month :year at :time", using the ":adapter" adapter.
+
+The Backup was stored in ":location" :remote.
+
+The following backup was stored: ":backup"

data/lib/backup/record/base.rb

@@ -0,0 +1,65 @@
+module Backup
+  module Record
+    class Base < ActiveRecord::Base
+      
+      if DB_CONNECTION_SETTINGS
+        establish_connection(DB_CONNECTION_SETTINGS)
+      end
+      
+      set_table_name 'backup'
+      
+      default_scope :order => 'created_at desc'
+
+      # Callbacks
+      after_save :clean_backups
+      
+      # Attributes
+      attr_accessor :adapter_config, :keep_backups
+      
+      # Receives the options hash and stores it
+      def load_adapter(adapter)
+        self.adapter_config = adapter
+        self.trigger        = adapter.procedure.trigger
+        self.adapter        = adapter.procedure.adapter_name.to_s
+        self.filename       = adapter.final_file
+        self.keep_backups   = adapter.procedure.attributes['keep_backups']
+        
+        # TODO calculate md5sum of file
+        load_specific_settings(adapter) if respond_to?(:load_specific_settings)
+      end
+      
+      # Destroys all backups for the specified trigger from Remote Server (FTP)
+      def self.destroy_all_backups(procedure, trigger)
+        backups = self.all(:conditions => {:trigger => trigger})
+        unless backups.empty?
+          # Derived classes must implement this method!
+          self.destroy_backups(procedure, backups)
+          
+          puts "\nAll \"#{procedure.trigger}\" backups destroyed.\n\n"
+        end
+      end
+      
+      private
+      
+        # Maintains the backup file amount on the remote server
+        # This is invoked after a successful record save
+        # This deletes the oldest files when the backup limit has been exceeded
+        def clean_backups
+          if keep_backups.is_a?(Integer)
+            backups = self.class.all(:conditions => {:trigger => trigger})
+            backups_to_destroy = backups[keep_backups, backups.size] || []
+            
+            unless backups_to_destroy.empty?
+              # Derived classes must implement this method!
+              self.class.destroy_backups(adapter_config.procedure, backups_to_destroy)
+              
+              puts "\nBackup storage for \"#{trigger}\" is limited to #{keep_backups} backups."
+              puts "\nThe #{keep_backups} most recent backups are now stored on the remote server.\n\n"
+            end
+          end
+        end
+        
+    end
+  end
+end
+

data/lib/backup/record/cloudfiles.rb

@@ -0,0 +1,28 @@
+require 'backup/connection/cloudfiles'
+
+module Backup
+  module Record
+    class CloudFiles < Backup::Record::Base
+
+      alias_attribute :container, :bucket
+
+      def load_specific_settings(adapter)
+        self.container = adapter.procedure.get_storage_configuration.attributes['container']
+      end
+
+      private
+
+        def self.destroy_backups(procedure, backups)
+          cf = Backup::Connection::CloudFiles.new
+          cf.static_initialize(procedure)
+          cf.connect
+          backups.each do |backup|
+            puts "\nDestroying backup \"#{backup.filename}\" from container \"#{backup.container}\"."
+            cf.destroy(backup.filename, backup.container)
+            backup.destroy
+          end
+        end
+
+    end
+  end
+end

data/lib/backup/record/dropbox.rb

@@ -0,0 +1,27 @@
+require 'backup/connection/dropbox'
+
+module Backup
+  module Record
+    class Dropbox < Backup::Record::Base
+      def load_specific_settings(adapter)
+      end
+
+      private
+
+      def self.destroy_backups(procedure, backups)
+        dropbox = Backup::Connection::Dropbox.new
+        dropbox.static_initialize(procedure)
+        session = dropbox.session
+        backups.each do |backup|
+          puts "\nDestroying backup \"#{backup.filename}\"."
+          path_to_file = File.join(dropbox.path, backup.filename)
+          begin
+            session.delete(path_to_file, :mode => :dropbox)
+          rescue ::Dropbox::FileNotFoundError => e
+            puts "\n Backup with name '#{backup.filename}' was not found in '#{dropbox.path}'"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/backup/record/ftp.rb

@@ -0,0 +1,39 @@
+require 'net/ftp'
+
+module Backup
+  module Record
+    class FTP < Backup::Record::Base
+      
+      attr_accessor :ip, :user, :password
+      
+      def load_specific_settings(adapter)
+        %w(ip user password path).each do |method|
+          send(:"#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          ip        = procedure.get_storage_configuration.attributes['ip']
+          user      = procedure.get_storage_configuration.attributes['user']
+          password  = procedure.get_storage_configuration.attributes['password']
+
+          Net::FTP.open(ip, user, password) do |ftp|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              begin
+                ftp.chdir(backup.path)
+                ftp.delete(backup.filename)
+                backup.destroy
+              rescue
+                puts "Could not find backup #{backup.path}/#{backup.filename}."
+                backup.destroy
+              end
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/record/local.rb

@@ -0,0 +1,26 @@
+module Backup
+  module Record
+    class Local < Backup::Record::Base
+      
+      def load_specific_settings(adapter)
+        self.path = adapter.procedure.get_storage_configuration.attributes['path']
+      end
+      
+      private
+        
+        class << self
+          include Backup::CommandHelper
+        
+          def destroy_backups(procedure, backups)
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              run "rm #{File.join(backup.path, backup.filename)}"
+              backup.destroy
+            end
+          end
+        end
+        
+    end
+  end
+end
+

data/lib/backup/record/s3.rb

@@ -0,0 +1,25 @@
+require 'backup/connection/s3'
+
+module Backup
+  module Record
+    class S3 < Backup::Record::Base
+      
+      def load_specific_settings(adapter)
+        self.bucket = adapter.procedure.get_storage_configuration.attributes['bucket']
+      end
+      
+      private
+        
+        def self.destroy_backups(procedure, backups)
+          s3 = Backup::Connection::S3.new
+          s3.static_initialize(procedure)
+          backups.each do |backup|
+            puts "\nDestroying backup \"#{backup.filename}\" from bucket \"#{backup.bucket}\"."
+            s3.destroy(backup.filename, backup.bucket)
+            backup.destroy
+          end
+        end
+        
+    end
+  end
+end