interu-backup 3.0.16

data/lib/backup/notifier/templates/notify_failure.erb

@@ -0,0 +1,33 @@
+
+There seemed to be a problem backing up <%= @model.label %> (<%= @model.trigger %>).
+
+===========================================================================
+Exception that got raised:
+<%= @exception.class %> - <%= @exception.to_s %>
+===========================================================================
+<%= @exception.backtrace.join("\n") %>
+===========================================================================
+
+
+You are running Backup version:
+<%= Backup::Version.current %>
+
+You are running Ruby version:
+<%= RUBY_VERSION %> (patchlevel <%= RUBY_PATCHLEVEL %>)
+
+On platform:
+<%= RUBY_PLATFORM %>
+
+---------------------------------------------------------------------------
+
+View all Backup gem releases here:
+http://rubygems.org/gems/backup
+
+View the Backup git repository here:
+https://github.com/meskyanichi/backup
+
+View the Backup issues here:
+https://github.com/meskyanichi/backup/issues
+
+View the Backup wiki here:
+https://github.com/meskyanichi/backup/wiki

data/lib/backup/notifier/templates/notify_success.erb

@@ -0,0 +1,16 @@
+
+Backup <%= @model.label %> (<%= @model.trigger %>) finished without any errors!
+
+---------------------------------------------------------------------------
+
+View all Backup gem releases here:
+http://rubygems.org/gems/backup
+
+View the Backup git repository here:
+https://github.com/meskyanichi/backup
+
+View the Backup issues here:
+https://github.com/meskyanichi/backup/issues
+
+View the Backup wiki here:
+https://github.com/meskyanichi/backup/wiki

data/lib/backup/notifier/twitter.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+##
+# Only load the Twitter gem when using Twitter notifications
+Backup::Dependency.load('twitter')
+
+module Backup
+  module Notifier
+    class Twitter < Base
+
+      ##
+      # Container for the Twitter Client object
+      attr_accessor :twitter_client
+
+      ##
+      # Container for the Model object
+      attr_accessor :model
+
+      ##
+      # Twitter consumer key credentials
+      attr_accessor :consumer_key, :consumer_secret
+
+      ##
+      # OAuth credentials
+      attr_accessor :oauth_token, :oauth_token_secret
+
+      ##
+      # Instantiates a new Backup::Notifier::Twitter object
+      def initialize(&block)
+        load_defaults!
+
+        instance_eval(&block) if block_given?
+
+        set_defaults!
+      end
+
+      ##
+      # Performs the notification
+      # Takes an exception object that might've been created if an exception occurred.
+      # If this is the case it'll invoke notify_failure!(exception), otherwise, if no
+      # error was raised, it'll go ahead and notify_success!
+      #
+      # If'll only perform these if on_success is true or on_failure is true
+      def perform!(model, exception = false)
+        @model = model
+
+        if notify_on_success? and exception.eql?(false)
+          log!
+          notify_success!
+        elsif notify_on_failure? and not exception.eql?(false)
+          log!
+          notify_failure!(exception)
+        end
+      end
+
+    private
+
+      ##
+      # Sends a tweet informing the user that the backup operation
+      # proceeded without any errors
+      def notify_success!
+        twitter_client.update("[Backup::Succeeded] #{model.label} (#{ File.basename(Backup::Model.file) })")
+      end
+
+      ##
+      # Sends a tweet informing the user that the backup operation
+      # raised an exception
+      def notify_failure!(exception)
+        twitter_client.update("[Backup::Failed] #{model.label} (#{ File.basename(Backup::Model.file) })")
+      end
+
+      ##
+      # Configures the Twitter object by passing in the @consumer_key, @consumer_secret
+      # @oauth_token and @oauth_token_secret. Instantiates and sets the @twitter_client object
+      def set_defaults!
+        ::Twitter.configure do |config|
+          config.consumer_key       = @consumer_key
+          config.consumer_secret    = @consumer_secret
+          config.oauth_token        = @oauth_token
+          config.oauth_token_secret = @oauth_token_secret
+        end
+        @twitter_client = ::Twitter.client
+      end
+
+    end
+  end
+end

data/lib/backup/storage/base.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Backup
+  module Storage
+    class Base
+      include Backup::Configuration::Helpers
+
+      ##
+      # The time when the backup initiated (in format: 2011.02.20.03.29.59)
+      attr_accessor :time
+
+      ##
+      # Sets the limit to how many backups to keep in the remote location.
+      # If the limit exceeds it will remove the oldest backup to make room for the newest
+      attr_accessor :keep
+
+      ##
+      # Returns the local path
+      def local_path
+        TMP_PATH
+      end
+
+      ##
+      # Returns the local archive filename
+      def local_file
+        @local_file ||= File.basename(Backup::Model.file)
+      end
+
+      ##
+      # Returns the name of the file that's stored on the remote location
+      def remote_file
+        @remote_file ||= local_file
+      end
+
+      ##
+      # Provider defaults to false and will be overridden when using
+      # a service-based storage such as Amazon S3, Rackspace Cloud Files or Dropbox
+      def provider
+        false
+      end
+
+      ##
+      # Checks the persisted storage data by type (S3, CloudFiles, SCP, etc)
+      # to see if the amount of stored backups is greater than the amount of
+      # backups allowed. If this is the case it'll invoke the #remove! method
+      # on each of the oldest backups that exceed the storage limit (specified by @keep).
+      # After that it'll re-assign the objects variable with an array of objects that still remain
+      # after the removal of the older objects and files (that exceeded the @keep range). And finally
+      # these remaining objects will be converted to YAML format and are written back to the YAML file
+      def cycle!
+        type           = self.class.name.split("::").last
+        storage_object = Backup::Storage::Object.new(type)
+        objects        = [self] + storage_object.load
+        if keep.is_a?(Integer) and keep > 0 and objects.count > keep
+          objects_to_remove = objects[keep..-1]
+          objects_to_remove.each do |object|
+            Logger.message "#{ self.class } started removing (cycling) \"#{ object.remote_file }\"."
+            object.send(:remove!)
+          end
+          objects = objects - objects_to_remove
+        end
+        storage_object.write(objects)
+      end
+
+    end
+  end
+end

data/lib/backup/storage/cloudfiles.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+##
+# Only load the Fog gem when the Backup::Storage::CloudFiles class is loaded
+Backup::Dependency.load('fog')
+
+module Backup
+  module Storage
+    class CloudFiles < Base
+
+      ##
+      # Rackspace Cloud Files Credentials
+      attr_accessor :username, :api_key
+
+      ##
+      # Rackspace Cloud Files container name and path
+      attr_accessor :container, :path
+
+      ##
+      # Creates a new instance of the Rackspace Cloud Files storage object
+      # First it sets the defaults (if any exist) and then evaluates
+      # the configuration block which may overwrite these defaults
+      def initialize(&block)
+        load_defaults!
+
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+
+        @time = TIME
+      end
+
+      ##
+      # This is the remote path to where the backup files will be stored
+      def remote_path
+        File.join(path, TRIGGER)
+      end
+
+      ##
+      # This is the provider that Fog uses for the Cloud Files Storage
+      def provider
+        'Rackspace'
+      end
+
+      ##
+      # Performs the backup transfer
+      def perform!
+        transfer!
+        cycle!
+      end
+
+    private
+
+      ##
+      # Establishes a connection to Rackspace Cloud Files and returns the Fog object.
+      # Not doing any instance variable caching because this object gets persisted in YAML
+      # format to a file and will issues. This, however has no impact on performance since it only
+      # gets invoked once per object for a #transfer! and once for a remove! Backups run in the
+      # background anyway so even if it were a bit slower it shouldn't matter.
+      def connection
+        Fog::Storage.new(
+          :provider           => provider,
+          :rackspace_username => username,
+          :rackspace_api_key  => api_key
+        )
+      end
+
+      ##
+      # Transfers the archived file to the specified Cloud Files container
+      def transfer!
+        begin
+          Logger.message("#{ self.class } started transferring \"#{ remote_file }\".")
+          connection.put_object(
+            container,
+            File.join(remote_path, remote_file),
+            File.open(File.join(local_path, local_file))
+          )
+        rescue Excon::Errors::SocketError => e
+          puts "\nAn error occurred while trying to transfer the backup."
+          puts "Make sure the container exists and try again.\n\n"
+          exit
+        end
+      end
+
+      ##
+      # Removes the transferred archive file from the Cloud Files container
+      def remove!
+        begin
+          connection.delete_object(container, File.join(remote_path, remote_file))
+        rescue Excon::Errors::SocketError; end
+      end
+
+    end
+  end
+end

data/lib/backup/storage/dropbox.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+##
+# Only load the Dropbox gem when the Backup::Storage::Dropbox class is loaded
+Backup::Dependency.load('dropbox')
+
+module Backup
+  module Storage
+    class Dropbox < Base
+
+      ##
+      # Dropbox user credentials
+      attr_accessor :email, :password
+
+      ##
+      # Dropbox API credentials
+      attr_accessor :api_key, :api_secret
+
+      ##
+      # Path to where the backups will be stored
+      attr_accessor :path
+
+      ##
+      # Dropbox connection timeout
+      attr_accessor :timeout
+
+      ##
+      # Creates a new instance of the Dropbox storage object
+      # First it sets the defaults (if any exist) and then evaluates
+      # the configuration block which may overwrite these defaults
+      def initialize(&block)
+        load_defaults!
+
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+
+        @timeout ||= 300
+        @time = TIME
+      end
+
+      ##
+      # This is the remote path to where the backup files will be stored
+      def remote_path
+        File.join(path, TRIGGER)
+      end
+
+      ##
+      # Performs the backup transfer
+      def perform!
+        transfer!
+        cycle!
+      end
+
+    private
+
+      ##
+      # Establishes a connection to Dropbox and returns the Dropbox::Session object.
+      # Not doing any instance variable caching because this object gets persisted in YAML
+      # format to a file and will issues. This, however has no impact on performance since it only
+      # gets invoked once per object for a #transfer! and once for a remove! Backups run in the
+      # background anyway so even if it were a bit slower it shouldn't matter.
+      def connection
+        session                      = ::Dropbox::Session.new(api_key, api_secret)
+        session.mode                 = :dropbox
+        session.authorizing_user     = email
+        session.authorizing_password = password
+        session.authorize!
+        session
+      end
+
+      ##
+      # Transfers the archived file to the specified Dropbox folder
+      def transfer!
+        Logger.message("#{ self.class } started transferring \"#{ remote_file }\".")
+        connection.upload(File.join(local_path, local_file), remote_path, :timeout => timeout)
+      end
+
+      ##
+      # Removes the transferred archive file from the Dropbox folder
+      def remove!
+        begin
+          connection.delete(File.join(remote_path, remote_file))
+        rescue ::Dropbox::FileNotFoundError
+          Logger.warn "File \"#{ File.join(remote_path, remote_file) }\" does not exist, skipping removal."
+        end
+      end
+
+    end
+  end
+end

data/lib/backup/storage/ftp.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+##
+# Only load the Net::FTP library/gem when the Backup::Storage::FTP class is loaded
+require 'net/ftp'
+
+module Backup
+  module Storage
+    class FTP < Base
+
+      ##
+      # Server credentials
+      attr_accessor :username, :password
+
+      ##
+      # Server IP Address and FTP port
+      attr_accessor :ip, :port
+
+      ##
+      # Path to store backups to
+      attr_accessor :path
+
+      ##
+      # Creates a new instance of the FTP storage object
+      # First it sets the defaults (if any exist) and then evaluates
+      # the configuration block which may overwrite these defaults
+      def initialize(&block)
+        load_defaults!
+
+        @port ||= 21
+        @path ||= 'backups'
+
+        instance_eval(&block) if block_given?
+
+        @time = TIME
+        @path = path.sub(/^\~\//, '')
+      end
+
+      ##
+      # This is the remote path to where the backup files will be stored
+      def remote_path
+        File.join(path, TRIGGER)
+      end
+
+      ##
+      # Performs the backup transfer
+      def perform!
+        transfer!
+        cycle!
+      end
+
+    private
+
+      ##
+      # Establishes a connection to the remote server and returns the Net::FTP object.
+      # Not doing any instance variable caching because this object gets persisted in YAML
+      # format to a file and will issues. This, however has no impact on performance since it only
+      # gets invoked once per object for a #transfer! and once for a remove! Backups run in the
+      # background anyway so even if it were a bit slower it shouldn't matter.
+      #
+      # Note *
+      # Since the FTP port is defined as a constant in the Net::FTP class, and might be required
+      # to change by the user, we dynamically remove and re-add the constant with the provided port value
+      def connection
+        if defined? Net::FTP::FTP_PORT
+          Net::FTP.send(:remove_const, :FTP_PORT)
+        end; Net::FTP.send(:const_set, :FTP_PORT, port)
+
+        Net::FTP.new(ip, username, password)
+      end
+
+      ##
+      # Transfers the archived file to the specified remote server
+      def transfer!
+        Logger.message("#{ self.class } started transferring \"#{ remote_file }\".")
+        create_remote_directories!
+        connection.put(
+          File.join(local_path, local_file),
+          File.join(remote_path, remote_file)
+        )
+      end
+
+      ##
+      # Removes the transferred archive file from the server
+      def remove!
+        begin
+          connection.delete(
+            File.join(remote_path, remote_file)
+          )
+        rescue Net::FTPPermError
+          Logger.warn "Could not remove file \"#{ File.join(remote_path, remote_file) }\"."
+        end
+      end
+
+      ##
+      # Creates (if they don't exist yet) all the directories on the remote
+      # server in order to upload the backup file. Net::FTP does not support
+      # paths to directories that don't yet exist when creating new directories.
+      # Instead, we split the parts up in to an array (for each '/') and loop through
+      # that to create the directories one by one. Net::FTP raises an exception when
+      # the directory it's trying ot create already exists, so we have rescue it
+      def create_remote_directories!
+        path_parts = Array.new
+        remote_path.split('/').each do |path_part|
+          path_parts << path_part
+          begin
+            connection.mkdir(path_parts.join('/'))
+          rescue Net::FTPPermError; end
+        end
+      end
+
+    end
+  end
+end