backup-wakiki 2.4.1

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,96 @@
+require 'pony'
+
+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
+          PersonMailer.deliver_backup_notification(@backup.trigger, @content, :stream => :support)
+          # 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)
+        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,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,26 @@
+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)
+          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

data/lib/backup/record/scp.rb

@@ -0,0 +1,33 @@
+require 'net/scp'
+
+module Backup
+  module Record
+    class SCP < 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::SSH.start(ip, user, :password => password) do |ssh|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              ssh.exec("rm #{File.join(backup.path, backup.filename)}")
+              backup.destroy
+            end
+          end
+        end
+        
+    end
+  end
+end

data/lib/backup/record/sftp.rb

@@ -0,0 +1,38 @@
+require 'net/sftp'
+
+module Backup
+  module Record
+    class SFTP < 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::SFTP.start(ip, user, :password => password) do |sftp|
+            backups.each do |backup|
+              puts "\nDestroying backup \"#{backup.filename}\" from path \"#{backup.path}\"."
+              begin
+                sftp.remove!(File.join(backup.path, 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/storage/ftp.rb

@@ -0,0 +1,38 @@
+require 'net/ftp'
+
+module Backup
+  module Storage
+    class FTP
+      
+      attr_accessor :user, :password, :ip, :path, :tmp_path, :final_file
+      
+      # Stores the backup file on the remote server using FTP
+      def initialize(adapter)
+        %w(ip user password path).each do |method|
+          send("#{method}=", adapter.procedure.get_storage_configuration.attributes[method])
+        end
+        
+        final_file = adapter.final_file
+        tmp_path   = adapter.tmp_path
+        
+        Net::FTP.open(ip, user, password) do |ftp|
+          begin
+            ftp.chdir(path)
+          rescue
+            puts "Could not find or access \"#{path}\" on \"#{ip}\", please ensure this directory exists and is accessible by the user \"#{user}\"."
+            exit
+          end
+          
+          begin
+            puts "Storing \"#{final_file}\" to path \"#{path}\" on remote server (#{ip})."
+            ftp.putbinaryfile(File.join(tmp_path, final_file).gsub('\ ', ' '), File.join(path, final_file))
+          rescue
+            puts "Could not save file to backup server. Is the \"#{path}\" directory writable?"
+            exit
+          end
+        end
+      end
+      
+    end
+  end
+end