backup 3.0.16 → 3.0.18

data/lib/backup/configuration/storage/ftp.rb

@@ -18,6 +18,10 @@ module Backup
           # Path to store backups to
           attr_accessor :path
 
+          ##
+          # use passive mode?
+          attr_accessor :passive_mode
+
         end
       end
     end

data/lib/backup/configuration/storage/local.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Backup
+  module Configuration
+    module Storage
+      class Local < Base
+        class << self
+
+          ##
+          # Path to store backups to
+          attr_accessor :path
+
+        end
+      end
+    end
+  end
+end

data/lib/backup/configuration/storage/ninefold.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+module Backup
+  module Configuration
+    module Storage
+      class Ninefold < Base
+        class << self
+
+          ##
+          # Ninefold Credentials
+          attr_accessor :storage_token, :storage_secret
+
+          ##
+          # Ninefold path
+          attr_accessor :path
+        end
+      end
+    end
+  end
+end

data/lib/backup/configuration/storage/rsync.rb

@@ -18,6 +18,10 @@ module Backup
           # Path to store backups to
           attr_accessor :path
 
+          ##
+          # Flag to use local backups
+          attr_accessor :local
+
         end
       end
     end

data/lib/backup/database/postgresql.rb

@@ -65,11 +65,19 @@ module Backup
       ##
       # Builds the credentials PostgreSQL syntax to authenticate the user
       # to perform the database dumping process
-      def credential_options
+      def username_options
         return '' unless username.is_a?(String) and not username.empty?
         "--username='#{username}'"
       end
 
+      ##
+      # Builds the password syntax PostgreSQL uses to authenticate the user
+      # to perform database dumping
+      def password_options
+        return '' unless password.is_a?(String) and not username.empty?
+        "PGPASSWORD='#{password}'"
+      end
+
       ##
       # Builds the PostgreSQL connectivity options syntax to connect the user
       # to perform the database dumping process, socket gets gsub'd to host since
@@ -92,8 +100,9 @@ module Backup
       ##
       # Builds the full pgdump string based on all attributes
       def pgdump
-        "#{ utility(:pg_dump) } #{ credential_options } #{ connectivity_options } " +
-        "#{ options } #{ tables_to_dump } #{ tables_to_skip } #{ name }"
+        ("#{password_options} " +
+        "#{ utility(:pg_dump) } #{ username_options } #{ connectivity_options } " +
+        "#{ options } #{ tables_to_dump } #{ tables_to_skip } #{ name }").strip
       end
 
       ##

data/lib/backup/database/redis.rb

@@ -85,7 +85,7 @@ module Backup
       def invoke_save!
         response = run("#{ utility('redis-cli') } #{ credential_options } #{ connectivity_options } #{ additional_options } SAVE")
         unless response =~ /OK/
-          Logger.error "Could not invoke the Redis SAVE command. The #{ database } file might not be contain the most recent data."
+          Logger.error "Could not invoke the Redis SAVE command. The #{ database } file might not contain the most recent data."
           Logger.error "Please check if the server is running, the credentials (if any) are correct, and the host/port/socket are correct."
         end
       end
@@ -98,7 +98,11 @@ module Backup
           exit
         end
 
+        # Temporarily remove a custom `utility_path` setting so that the system
+        # `cp` utility can be found, then restore the old value just in case.
+        old_path, self.utility_path = self.utility_path, nil
         run("#{ utility(:cp) } '#{ File.join(path, database) }' '#{ File.join(dump_path, database) }'")
+        self.utility_path = old_path
       end
     end
   end

data/lib/backup/dependency.rb

@@ -18,13 +18,13 @@ module Backup
       {
         'fog' => {
           :require => 'fog',
-          :version => '~> 0.7.0',
+          :version => '>= 0.11.0',
           :for     => 'Amazon S3, Rackspace Cloud Files (S3, CloudFiles Storages)'
         },
 
         'dropbox' => {
           :require => 'dropbox',
-          :version => '~> 1.2.3',
+          :version => '~> 1.3.0',
           :for     => 'Dropbox Web Service (Dropbox Storage)'
         },
 
@@ -42,19 +42,19 @@ module Backup
 
         'net-ssh' => {
           :require => 'net/ssh',
-          :version => '~> 2.1.3',
+          :version => '~> 2.1.4',
           :for     => 'SSH Protocol (SSH Storage)'
         },
 
         'mail' => {
           :require => 'mail',
-          :version => '~> 2.2.15',
+          :version => '~> 2.3.0',
           :for     => 'Sending Emails (Mail Notifier)'
         },
 
         'twitter' => {
           :require => 'twitter',
-          :version => '~> 1.1.2',
+          :version => '>= 1.7.1',
           :for     => 'Sending Twitter Updates (Twitter Notifier)'
         },
 
@@ -68,7 +68,7 @@ module Backup
           :require => 'json',
           :version => '~> 1.5.1',
           :for     => 'Parsing JSON for HTTParty'
-        }
+        },
       }
     end
 
@@ -81,13 +81,12 @@ module Backup
         gem(name, all[name][:version])
         require(all[name][:require])
       rescue LoadError
-        Backup::Logger.error("Dependency missing. Please install #{name} version #{all[name][:version]} and try again.")
-        puts "\n\s\sgem install #{name} -v '#{all[name][:version]}'\n\n"
-        puts "Dependency required for:"
+        Backup::Logger.error("Dependency missing.")
+        puts "\nDependency required for:"
         puts "\n\s\s#{all[name][:for]}"
-        puts "\nTrying to install the #{name} gem for you.. please wait."
-        puts "Once installed, retry the backup procedure.\n\n"
-        puts run("#{ utility(:gem) } install #{name} -v '#{all[name][:version]}'")
+        puts "\nTo install the gem, issue the following command:"
+        puts "\n\s\sgem install #{name} -v '#{all[name][:version]}'"
+        puts "\nPlease try again after installing the missing dependency."
         exit
       end
     end

data/lib/backup/encryptor/gpg.rb

@@ -62,6 +62,8 @@ module Backup
       # Creates a new temp file and writes the provided public gpg key to it
       def write_tmp_file!
         @tmp_file = Tempfile.new('backup.pub')
+        FileUtils.chown(USER, nil, @tmp_file.path)
+        FileUtils.chmod(0600, @tmp_file.path)
         @tmp_file.write(key)
         @tmp_file.close
       end

data/lib/backup/exception/command_failed.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+module Backup
+  module Exception
+    class CommandFailed < StandardError
+    end
+  end
+end

data/lib/backup/finder.rb

@@ -4,25 +4,24 @@ module Backup
   class Finder
     attr_accessor :trigger, :config
 
+    ##
+    # The wildcard character to match triggers
+    # Can be used alone or in mask (e.g. web_* )
+    WILDCARD = '*'
+
     ##
     # Initializes a new Backup::Finder object
     # and stores the path to the configuration file
-    def initialize(trigger, config)
+    def initialize(trigger, config = CONFIG_FILE)
       @trigger = trigger.to_sym
       @config  = config
     end
 
     ##
-    # Tries to find and load the configuration file and return the proper
+    # Tries to find and return the proper
     # backup model configuration (specified by the 'trigger')
     def find
-      unless File.exist?(config)
-        puts "Could not find a configuration file in '#{config}'."; exit
-      end
-
-      ##
-      # Loads the backup configuration file
-      instance_eval(File.read(config))
+      load_config!
 
       ##
       # Iterates through all the instantiated backup models and returns
@@ -35,5 +34,46 @@ module Backup
 
       puts "Could not find trigger '#{trigger}' in '#{config}'."; exit
     end
+
+    ##
+    # Tries to find and return the all triggers
+    # matching wildcard (specified by the 'trigger')
+    def matching
+      ##
+      # Define the TIME constants unless defined
+      ::Backup.send(:const_set, :TIME, Time.now.strftime("%Y.%m.%d.%H.%M.%S")) unless defined? Backup::TIME
+
+      ##
+      # Parses the backup configuration file
+      load_config!
+
+      triggers = Backup::Model.all.map{|model| model.trigger.to_s }
+
+      ##
+      # Removes the TIME constant
+      ::Backup.send(:remove_const, :TIME) if defined? Backup::TIME
+
+      ##
+      # Make regexp replacing wildcard character by (.+)
+      wildcard = %r{^#{trigger.to_s.gsub(WILDCARD, '(.+)')}$}
+
+      ##
+      # Returns all trigger names matching wildcard
+      triggers.select { |trigger| trigger =~ wildcard }
+    end
+
+    private
+
+    ##
+    # Tries to find and load the configuration file
+    def load_config!
+      unless File.exist?(config)
+        puts "Could not find a configuration file in '#{config}'."; exit
+      end
+
+      ##
+      # Loads the backup configuration file
+      instance_eval(File.read(config))
+    end
   end
 end

data/lib/backup/notifier/mail.rb

@@ -56,6 +56,11 @@ module Backup
       # Example: true
       attr_accessor :enable_starttls_auto
 
+      ##
+      # OpenSSL Verify Mode
+      # Example: none - Only use this option for a self-signed and/or wildcard certificate
+      attr_accessor :openssl_verify_mode
+
       ##
       # Instantiates a new Backup::Notifier::Mail object
       def initialize(&block)
@@ -116,7 +121,8 @@ module Backup
           :user_name            => @user_name,
           :password             => @password,
           :authentication       => @authentication,
-          :enable_starttls_auto => @enable_starttls_auto
+          :enable_starttls_auto => @enable_starttls_auto,
+          :openssl_verify_mode  => @openssl_verify_mode
         }
 
         ::Mail.defaults do

data/lib/backup/notifier/twitter.rb

@@ -79,7 +79,7 @@ module Backup
           config.oauth_token        = @oauth_token
           config.oauth_token_secret = @oauth_token_secret
         end
-        @twitter_client = ::Twitter.client
+        @twitter_client = ::Twitter::Client.new
       end
 
     end

data/lib/backup/storage/dropbox.rb

@@ -4,14 +4,14 @@
 # Only load the Dropbox gem when the Backup::Storage::Dropbox class is loaded
 Backup::Dependency.load('dropbox')
 
+##
+# Only load the timeout library when the Backup::Storage::Dropbox class is loaded
+require 'timeout'
+
 module Backup
   module Storage
     class Dropbox < Base
 
-      ##
-      # Dropbox user credentials
-      attr_accessor :email, :password
-
       ##
       # Dropbox API credentials
       attr_accessor :api_key, :api_secret
@@ -29,7 +29,7 @@ module Backup
       # First it sets the defaults (if any exist) and then evaluates
       # the configuration block which may overwrite these defaults
       def initialize(&block)
-        load_defaults!
+        load_defaults!(:except => ['password', 'email'])
 
         @path ||= 'backups'
 
@@ -55,18 +55,27 @@ module Backup
     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.
+      # The initial connection to Dropbox will provide the user with an authorization url.
+      # The user must open this URL and confirm that the authorization successfully took place.
+      # If this is the case, then the user hits 'enter' and the session will be properly established.
+      # Immediately after establishing the session, the session will be serialized and written to a cache file
+      # in Backup::CACHE_PATH. The cached file will be used from that point on to re-establish a connection with
+      # Dropbox at a later time. This allows the user to avoid having to go to a new Dropbox URL to authorize over and over again.
       def connection
-        session                      = ::Dropbox::Session.new(api_key, api_secret)
-        session.mode                 = :dropbox
-        session.authorizing_user     = email
-        session.authorizing_password = password
-        session.authorize!
-        session
+        if cache_exists?
+          begin
+            cached_session = ::Dropbox::Session.deserialize(File.read(cached_file))
+            if cached_session.authorized?
+              Logger.message "Session data loaded from cache!"
+              return cached_session
+            end
+          rescue ArgumentError => error
+            Logger.warn "Could not read session data from cache. Cache data might be corrupt."
+          end
+        end
+
+        Logger.message "Creating a new session!"
+        create_write_and_return_new_session!
       end
 
       ##
@@ -86,6 +95,74 @@ module Backup
         end
       end
 
+      ##
+      # Create a new session, write a serialized version of it to the
+      # .cache directory, and return the session object
+      def create_write_and_return_new_session!
+        session      = ::Dropbox::Session.new(api_key, api_secret)
+        session.mode = :dropbox
+        Logger.message "Open the following URL in a browser to authorize a session for your Dropbox account:"
+        Logger.message ""
+        Logger.message "\s\s#{session.authorize_url}"
+        Logger.message ""
+        Logger.message "Once Dropbox says you're authorized, hit enter to proceed."
+        Timeout::timeout(180) { STDIN.gets }
+        begin
+          session.authorize
+        rescue OAuth::Unauthorized => error
+          Logger.error "Authorization failed!"
+          raise error
+        end
+        Logger.message "Authorized!"
+
+        Logger.message "Caching session data to file: #{cached_file}.."
+        write_cache!(session)
+        Logger.message "Cache data written! You will no longer need to manually authorize this Dropbox account via an URL on this machine."
+        Logger.message "Note: If you run Backup with this Dropbox account on other machines, you will need to either authorize them the same way,"
+        Logger.message "\s\sor simply copy over #{cached_file} to the cache directory"
+        Logger.message "\s\son your other machines to use this Dropbox account there as well."
+
+        session
+      end
+
+      ##
+      # Returns the path to the cached file
+      def cached_file
+        File.join(Backup::CACHE_PATH, "#{api_key + api_secret}")
+      end
+
+      ##
+      # Checks to see if the cache file exists
+      def cache_exists?
+        File.exist?(cached_file)
+      end
+
+      ##
+      # Serializes and writes the Dropbox session to a cache file
+      def write_cache!(session)
+        File.open(cached_file, "w") do |cache_file|
+          cache_file.write(session.serialize)
+        end
+      end
+
+    public # DEPRECATED METHODS #############################################
+
+      def email
+        Logger.warn "[DEPRECATED] Backup::Storage::Dropbox.email is deprecated and will be removed at some point."
+      end
+
+      def email=(value)
+        Logger.warn "[DEPRECATED] Backup::Storage::Dropbox.email= is deprecated and will be removed at some point."
+      end
+
+      def password
+        Logger.warn "[DEPRECATED] Backup::Storage::Dropbox.password is deprecated and will be removed at some point."
+      end
+
+      def password=(value)
+        Logger.warn "[DEPRECATED] Backup::Storage::Dropbox.password= is deprecated and will be removed at some point."
+      end
+
     end
   end
 end