namxam-backup 2.4.5

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,14 @@
+module Backup
+  module CommandHelper
+    def run(command, opts={})
+      opts[:exit_on_failure] ||= false
+      output = `#{command}`
+      exit 1 if opts[:exit_on_failure] && !$?.success?
+      output
+    end
+ 
+    def log(command)
+      puts "Backup (#{Time.now.strftime("%Y-%m-%d %H:%M:%S %Z")}) => #{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 tables skip_tables commands additional_options backup_method)
+
+      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,75 @@
+module Backup
+  module Configuration
+    class Base
+      extend Backup::Configuration::Attributes
+      generate_attributes %w(encrypt_with_password encrypt_with_gpg_public_key keep_backups notify)
+      
+      attr_accessor :trigger, :storage_name, :adapter_name, :before_backup_block, :after_backup_block
+
+      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
+
+      def before_backup(&block)
+        @before_backup_block = block
+      end
+
+      def after_backup(&block)
+        @after_backup_block = block
+      end
+
+      def storage_class
+        case @storage_name.to_sym
+          when :cloudfiles then Backup::Storage::CloudFiles
+          when :s3         then Backup::Storage::S3
+          when :scp        then Backup::Storage::SCP
+          when :ftp        then Backup::Storage::FTP
+          when :sftp       then Backup::Storage::SFTP
+          when :local      then Backup::Storage::Local
+          when :dropbox    then Backup::Storage::Dropbox
+        end
+      end
+
+      def record_class
+        case @storage_name.to_sym
+          when :cloudfiles then Backup::Record::CloudFiles
+          when :s3         then Backup::Record::S3
+          when :scp        then Backup::Record::SCP
+          when :ftp        then Backup::Record::FTP
+          when :sftp       then Backup::Record::SFTP
+          when :local      then Backup::Record::Local
+          when :dropbox    then Backup::Record::Dropbox
+        end        
+      end
+
+      # Initializes the storing process depending on the store settings
+      def initialize_storage(adapter)
+        storage_class.new(adapter)
+      end
+
+      def initialize_record
+        record_class.new
+      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 host use_ssl bucket username api_key container)
+    end
+  end
+end

data/lib/backup/connection/cloudfiles.rb

@@ -0,0 +1,75 @@
+require 'cloudfiles'
+
+module Backup
+  module Connection
+    class CloudFiles
+
+      attr_accessor :adapter, :procedure, :api_key, :username, :cf_container, :final_file, :tmp_path
+
+      # Initializes the Cloud Files connection, setting the values using the
+      # Cloud Files 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 Rackspace Cloud Files using the
+      # credentials provided by the user
+      def connect
+        connection
+      end
+
+      # Wrapper for the Connection object
+      def connection
+        ::CloudFiles::Connection.new(username, api_key)
+      end
+
+      # Wrapper for the Container object
+      def container
+        connection.container(cf_container)
+      end
+
+      # Initializes the file transfer to Rackspace Cloud Files
+      # This can only run after a connection has been made using the #connect method
+      def store
+        object = container.create_object(final_file)
+        object.write(open(File.join(tmp_path, final_file)))
+      end
+
+      # Destroys file from a bucket on Amazon S3
+      def destroy(file, c)
+        c = connection.container(c)
+        c.delete_object(file)
+      end
+
+      private
+
+        def load_storage_configuration_attributes(static = false)
+          %w(api_key username).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.cf_container = procedure.get_storage_configuration.attributes['container']
+          else
+            self.cf_container = adapter.procedure.get_storage_configuration.attributes['container']
+          end
+        end
+    end
+  end
+end

data/lib/backup/connection/dropbox.rb

@@ -0,0 +1,62 @@
+require 'dropbox'
+
+module Backup
+  module Connection
+    class Dropbox
+
+      attr_accessor :adapter, :procedure, :final_file, :tmp_path, :api_key, :secret_access_key, :username, :password, :path
+
+      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
+
+      def static_initialize(procedure)
+        self.procedure = procedure
+        load_storage_configuration_attributes(true)
+      end
+
+      def session
+        @session ||= ::Dropbox::Session.new(api_key, secret_access_key)
+        unless @session.authorized?
+          @session.authorizing_user = username
+          @session.authorizing_password = password
+          @session.authorize!
+        end
+
+        @session
+      end
+
+      def connect
+        session
+      end
+
+      def path
+        @path || "backups"
+      end
+
+      def store
+        path_to_file = File.join(tmp_path, final_file)
+        session.upload(path_to_file, path, :mode => :dropbox)
+      end
+
+      private
+
+      def load_storage_configuration_attributes(static=false)
+        %w(api_key secret_access_key username password path).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
+      end
+    end
+  end
+end

data/lib/backup/connection/s3.rb

@@ -0,0 +1,88 @@
+require "fog"
+
+module Backup
+  module Connection
+    class S3
+      include Backup::CommandHelper
+      
+      MAX_S3_FILE_SIZE = 5368709120 - 1
+      
+      attr_accessor :adapter, :procedure, :access_key_id, :secret_access_key, :host, :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 connection
+        @_connection ||= Fog::AWS::Storage.new(
+          :aws_access_key_id => access_key_id,
+          :aws_secret_access_key => secret_access_key
+        )
+      end
+
+      # Initializes the file transfer to Amazon S3
+      # This can only run after a connection has been made using the #connect method 
+      def store
+        #TODO: need to add logic like this to restore: `cat /mnt/backups/part.xx >>restore.tgz`
+        tmp_file_path = File.join(tmp_path, final_file)
+        store_files = []
+        if File.stat(File.join(tmp_path, final_file)).size >= MAX_S3_FILE_SIZE
+          #we need to split!
+          `split -b #{MAX_S3_FILE_SIZE}  #{tmp_file_path} #{tmp_file_path}.`
+          store_files += `ls  #{tmp_file_path}.*`.split
+          log("Splitting '#{final_file}' into #{store_files.length} parts as it is too large for s3.")
+        else
+          store_files << tmp_file_path
+        end
+
+        #lets make sure it exists
+        self.connection.put_bucket(s3_bucket)
+        
+        store_files.each do |tmp_file|
+          file_name = File.basename(tmp_file)
+          log("Saving '#{file_name}' to s3 bucket '#{s3_bucket}'")
+          self.connection.put_object(s3_bucket, file_name, open(tmp_file))
+        end
+      end
+
+      # Destroys file from a bucket on Amazon S3
+      def destroy(file, bucket_as_string)
+        self.connection.put_bucket(s3_bucket)
+        connection.delete_object(s3_bucket, file)
+      end
+
+      private
+
+        def load_storage_configuration_attributes(static = false)          
+          %w(access_key_id secret_access_key use_ssl host).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