backup-gundua 2.3.1.1

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

@@ -0,0 +1,21 @@
+module Backup
+  module Configuration
+    class Adapter
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(files exclude user password database 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
+

data/lib/backup/configuration/base.rb

@@ -0,0 +1,55 @@
+module Backup
+  module Configuration
+    class Base
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(encrypt_with_password keep_backups notify)
+      
+      attr_accessor :trigger, :storage_name, :adapter_name
+
+      def initialize(trigger)
+        @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
+
+      # 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
+      end
+  
+      def get_storage_configuration
+        @storage_configuration
+      end
+    end
+  end
+end

data/lib/backup/configuration/helpers.rb

@@ -0,0 +1,24 @@
+module Backup
+  module Configuration
+    module Helpers
+      
+      # A helper method for the config/backup.rb configuration file
+      # Expects a trigger in argument one (STRING)
+      # Expects a block of settings
+      def backup(trigger, &block)
+        backup = Backup::Configuration::Base.new(trigger)
+        backup.instance_eval &block
+        @backup_procedures ||= Array.new
+        @backup_procedures << backup
+      end
+      
+      # A helper method for the config/mail.rb configuration file
+      # Takes a block containing the mail options
+      def notifier_settings(&block)
+        @mail_configuration = Backup::Configuration::Mail.new
+        @mail_configuration.instance_eval &block
+      end
+      
+    end
+  end
+end

data/lib/backup/configuration/mail.rb

@@ -0,0 +1,20 @@
+module Backup
+  module Configuration
+    class Mail
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(from to smtp)
+
+      def initialize
+        @smtp_configuration = Backup::Configuration::SMTP.new
+      end
+
+      def smtp(&block)
+        @smtp_configuration.instance_eval &block
+      end
+    
+      def get_smtp_configuration
+        @smtp_configuration
+      end
+    end
+  end
+end

data/lib/backup/configuration/smtp.rb

@@ -0,0 +1,8 @@
+module Backup
+  module Configuration
+    class SMTP
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(host port username password authentication domain tls)
+    end
+  end
+end

data/lib/backup/configuration/storage.rb

@@ -0,0 +1,8 @@
+module Backup
+  module Configuration
+    class Storage
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(ip user password path access_key_id secret_access_key use_ssl bucket)
+    end
+  end
+end

data/lib/backup/connection/s3.rb

@@ -0,0 +1,85 @@
+module Backup
+  module Connection
+    class S3
+      
+      attr_accessor :adapter, :procedure, :access_key_id, :secret_access_key, :s3_bucket, :use_ssl, :final_file, :tmp_path
+      
+      # Initializes the S3 connection, setting the values using the S3 adapter
+      def initialize(adapter = false)
+        if adapter
+          self.adapter            = adapter
+          self.procedure          = adapter.procedure
+          self.final_file         = adapter.final_file
+          self.tmp_path           = adapter.tmp_path.gsub('\ ', ' ')
+          load_storage_configuration_attributes
+        end
+      end
+      
+      # Sets values from a procedure, rather than from the adapter object
+      def static_initialize(procedure)
+        self.procedure = procedure
+        load_storage_configuration_attributes(true)
+      end
+      
+      # Establishes a connection with Amazon S3 using the credentials provided by the user
+      def connect
+        AWS::S3::Base.establish_connection!(
+          :access_key_id     => access_key_id,
+          :secret_access_key => secret_access_key,
+          :use_ssl           => use_ssl
+        )
+      end
+      
+      # Wrapper for the Service object
+      def service
+        AWS::S3::Service
+      end
+      
+      # Wrapper for the Bucket object
+      def bucket
+        AWS::S3::Bucket
+      end
+      
+      # Wrapper for the Object object
+      def object
+        AWS::S3::S3Object
+      end
+      
+      # Initializes the file transfer to Amazon S3
+      # This can only run after a connection has been made using the #connect method 
+      def store
+        puts "Storing \"#{final_file}\" to bucket \"#{s3_bucket}\" on Amazon S3."
+        object.store(
+          final_file,
+          open(File.join(tmp_path, final_file)),
+          s3_bucket )
+      end
+      
+      # Destroys file from a bucket on Amazon S3
+      def destroy(file, bucket)
+        object.delete(
+          file,
+          bucket )
+      end
+      
+      private
+      
+        def load_storage_configuration_attributes(static = false)          
+          %w(access_key_id secret_access_key use_ssl).each do |attribute|
+            if static
+              send("#{attribute}=", procedure.get_storage_configuration.attributes[attribute])
+            else
+              send("#{attribute}=", adapter.procedure.get_storage_configuration.attributes[attribute])
+            end
+          end
+          
+          if static
+            self.s3_bucket = procedure.get_storage_configuration.attributes['bucket']
+          else
+            self.s3_bucket = adapter.procedure.get_storage_configuration.attributes['bucket']
+          end
+        end
+        
+    end
+  end 
+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_ENV)
+        return :unix
+      end
+      
+    end
+  end
+end

data/lib/backup/environment/rails.rb

@@ -0,0 +1,17 @@
+module Backup
+  module Environment
+    module Rails
+      
+      if defined? RAILS_ENV
+        
+        # Sets BACKUP_PATH equal to RAILS_ROOT
+        BACKUP_PATH = RAILS_ROOT
+      
+        # Sets DB_CONNECTION_SETTINGS to false
+        DB_CONNECTION_SETTINGS = false
+    
+      end
+    
+    end
+  end
+end

data/lib/backup/environment/unix.rb

@@ -0,0 +1,94 @@
+module Backup
+  module Environment
+    module Unix
+      
+      require 'active_record'
+      require 'optparse'
+      
+      # Sets BACKUP_PATH equal to /opt/backup
+      BACKUP_PATH = "/opt/backup"
+      
+      # Sets DB_CONNECTION_SETTINGS
+      DB_CONNECTION_SETTINGS = {
+        :adapter  => "sqlite3",
+        :database => "/opt/backup/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!
+
+    /opt/backup/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
+        
+      end
+    
+    end
+  end
+end

data/lib/backup/mail/base.rb

@@ -0,0 +1,93 @@
+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)
+          @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
+        options = {
+          :to     => self.to,
+          :from     => self.from,
+          :via      => :smtp,
+          :smtp     => {
+          :host     => self.host,
+          :port     => self.port,
+          :domain   => self.domain,
+          :tls      => self.tls
+        }}
+        options[:smtp].merge(:auth => self.authentication, :user => self.username, :password => self.password) if self.responds_to? :authentication
+
+      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)
+        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',  bucket || path)
+          line.gsub!(':backup',    @backup.final_file)
+          case @backup.procedure.storage_name.to_sym
+            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/ftp.rb

@@ -0,0 +1,37 @@
+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,24 @@
+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)
+          s3.connect
+          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