backup_checksum 3.0.23

data/lib/backup/dependency.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+module Backup
+
+  ##
+  # A little self-contained gem manager for Backup.
+  # Rather than specifying hard dependencies in the gemspec, forcing users
+  # to install gems they do not want/need, Backup will notify them when a gem
+  # has not been installed, or when the gem's version is incorrect, and provide the
+  # command to install the gem. These dependencies are dynamically loaded in the Gemfile
+  class Dependency
+
+    ##
+    # Returns a hash of dependencies that Backup requires
+    # in order to run every available feature
+    def self.all
+      {
+        'fog' => {
+          :require => 'fog',
+          :version => '>= 0.11.0',
+          :for     => 'Amazon S3, Rackspace Cloud Files (S3, CloudFiles Storages)'
+        },
+
+        'dropbox-sdk' => {
+          :require => 'dropbox_sdk',
+          :version => '~> 1.2.0',
+          :for     => 'Dropbox Web Service (Dropbox Storage)'
+        },
+
+        'net-sftp' => {
+          :require => 'net/sftp',
+          :version => '~> 2.0.5',
+          :for     => 'SFTP Protocol (SFTP Storage)'
+        },
+
+        'net-scp' => {
+          :require => 'net/scp',
+          :version => '~> 1.0.4',
+          :for     => 'SCP Protocol (SCP Storage)'
+        },
+
+        'net-ssh' => {
+          :require => 'net/ssh',
+          :version => '~> 2.1.4',
+          :for     => 'SSH Protocol (SSH Storage)'
+        },
+
+        'mail' => {
+          :require => 'mail',
+          :version => '>= 2.4.0',
+          :for     => 'Sending Emails (Mail Notifier)'
+        },
+
+        'twitter' => {
+          :require => 'twitter',
+          :version => '>= 1.7.1',
+          :for     => 'Sending Twitter Updates (Twitter Notifier)'
+        },
+
+        'httparty' => {
+          :require => 'httparty',
+          :version => '~> 0.7.4',
+          :for     => 'Sending Http Updates'
+        },
+
+        'json' => {
+          :require => 'json',
+          :version => '~> 1.5.1',
+          :for     => 'Parsing JSON for HTTParty'
+        },
+
+        'prowler' => {
+          :require => 'prowler',
+          :version => '>= 1.3.1',
+          :for     => 'Sending iOS push notifications (Prowl Notifier)'
+        },
+
+        'hipchat' => {
+          :require => 'hipchat',
+          :version => '~> 0.4.1',
+          :for => 'Sending notifications to Hipchat'
+        },
+
+        'parallel' => {
+          :require => 'parallel',
+          :version => '~> 0.5.12',
+          :for => 'Adding concurrency to Cloud-based syncers.'
+        }
+      }
+    end
+
+    ##
+    # Attempts to load the specified gem (by name and version).
+    # If the gem with the correct version cannot be found, it'll display a message
+    # to the user with instructions on how to install the required gem
+    def self.load(name)
+      begin
+        gem(name, all[name][:version])
+        require(all[name][:require])
+      rescue LoadError
+        Logger.error Errors::Dependency::LoadError.new(<<-EOS)
+          Dependency missing
+          Dependency required for:
+          #{all[name][:for]}
+          To install the gem, issue the following command:
+          > gem install #{name} -v '#{all[name][:version]}'
+          Please try again after installing the missing dependency.
+        EOS
+        exit 1
+      end
+    end
+
+  end
+end

data/lib/backup/encryptor/base.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Backup
+  module Encryptor
+    class Base
+      include Backup::CLI::Helpers
+      include Backup::Configuration::Helpers
+
+      def initialize
+        load_defaults!
+      end
+
+      private
+
+      ##
+      # Return the encryptor name, with Backup namespace removed
+      def encryptor_name
+        self.class.to_s.sub('Backup::', '')
+      end
+
+      ##
+      # Logs a message to the console and log file to inform
+      # the client that Backup is encrypting the archive
+      def log!
+        Logger.message "Using #{ encryptor_name } to encrypt the archive."
+      end
+    end
+  end
+end

data/lib/backup/encryptor/gpg.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module Backup
+  module Encryptor
+    class GPG < Base
+
+      ##
+      # The GPG Public key that'll be used to encrypt the backup
+      attr_accessor :key
+
+      ##
+      # Creates a new instance of Backup::Encryptor::GPG and
+      # sets the key to the provided GPG key. To enhance the DSL
+      # the user may use tabs and spaces to indent the multi-line key string
+      # since we gsub() every preceding 'space' and 'tab' on each line
+      def initialize(&block)
+        super
+
+        instance_eval(&block) if block_given?
+      end
+
+      ##
+      # This is called as part of the procedure run by the Packager.
+      # It sets up the needed encryption_key_email to pass to the gpg command,
+      # then yields the command to use as part of the packaging procedure.
+      # Once the packaging procedure is complete, it will return
+      # so that any clean-up may be performed after the yield.
+      def encrypt_with
+        log!
+        extract_encryption_key_email!
+
+        yield "#{ utility(:gpg) } #{ options }", '.gpg'
+      end
+
+      private
+
+      ##
+      # Imports the given encryption key to ensure it's available for use,
+      # and extracts the email address used to create the key.
+      # This is stored in '@encryption_key_email', to be used to specify
+      # the --recipient when performing encryption so this key is used.
+      def extract_encryption_key_email!
+        if @encryption_key_email.to_s.empty?
+          with_tmp_key_file do |tmp_file|
+            @encryption_key_email = run(
+              "#{ utility(:gpg) } --import '#{tmp_file}' 2>&1"
+            ).match(/<(.+)>/)[1]
+          end
+        end
+      end
+
+      ##
+      # GPG options
+      # Sets the gpg mode to 'encrypt' and passes in the encryption_key_email
+      def options
+        "-e --trust-model always -r '#{ @encryption_key_email }'"
+      end
+
+      ##
+      # Writes the provided public gpg key to a temp file,
+      # yields the path, then deletes the file when the block returns.
+      def with_tmp_key_file
+        tmp_file = Tempfile.new('backup.pub')
+        FileUtils.chown(Config.user, nil, tmp_file.path)
+        FileUtils.chmod(0600, tmp_file.path)
+        tmp_file.write(encryption_key)
+        tmp_file.close
+        yield tmp_file.path
+        tmp_file.delete
+      end
+
+      ##
+      # Returns the encryption key with preceding spaces and tabs removed
+      def encryption_key
+        key.gsub(/^[[:blank:]]+/, '')
+      end
+
+    end
+  end
+end

data/lib/backup/encryptor/open_ssl.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+module Backup
+  module Encryptor
+    class OpenSSL < Base
+
+      ##
+      # The password that'll be used to encrypt the backup. This
+      # password will be required to decrypt the backup later on.
+      attr_accessor :password
+
+      ##
+      # The password file to use to encrypt the backup.
+      attr_accessor :password_file
+
+      ##
+      # Determines whether the 'base64' should be used or not
+      attr_accessor :base64
+
+      ##
+      # Determines whether the 'salt' flag should be used
+      attr_accessor :salt
+
+      ##
+      # Creates a new instance of Backup::Encryptor::OpenSSL and
+      # sets the password attribute to what was provided
+      def initialize(&block)
+        super
+
+        @base64        ||= false
+        @salt          ||= true
+        @password_file ||= nil
+
+        instance_eval(&block) if block_given?
+      end
+
+      ##
+      # This is called as part of the procedure run by the Packager.
+      # It sets up the needed options to pass to the openssl command,
+      # then yields the command to use as part of the packaging procedure.
+      # Once the packaging procedure is complete, it will return
+      # so that any clean-up may be performed after the yield.
+      def encrypt_with
+        log!
+        yield "#{ utility(:openssl) } #{ options }", '.enc'
+      end
+
+      private
+
+      ##
+      # Uses the 256bit AES encryption cipher, which is what the
+      # US Government uses to encrypt information at the "Top Secret" level.
+      #
+      # The -base64 option will make the encrypted output base64 encoded,
+      # this makes the encrypted file readable using text editors
+      #
+      # The -salt option adds strength to the encryption
+      #
+      # Always sets a password option, if even no password is given,
+      # but will prefer the password_file option if both are given.
+      def options
+        opts = ['aes-256-cbc']
+        opts << '-base64' if @base64
+        opts << '-salt'   if @salt
+        opts << ( @password_file.to_s.empty? ?
+                "-k '#{@password}'" : "-pass file:#{@password_file}" )
+        opts.join(' ')
+      end
+
+    end
+  end
+end

data/lib/backup/errors.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+
+module Backup
+  ##
+  # - automatically defines module namespaces referenced under Backup::Errors
+  # - any constant name referenced that ends with 'Error' will be created
+  #   as a subclass of Backup::Errors::Error
+  # e.g.
+  #   err = Backup::Errors::Foo::Bar::FooError.new('error message')
+  #   err.message => "Foo::Bar::FooError: error message"
+  #
+  module ErrorsHelper
+    def const_missing(const)
+      if const.to_s.end_with?('Error')
+        module_eval("class #{const} < Backup::Errors::Error; end")
+      else
+        module_eval("module #{const}; extend Backup::ErrorsHelper; end")
+      end
+      const_get(const)
+    end
+  end
+
+  ##
+  # provides cascading errors with formatted messages
+  # see the specs for details
+  #
+  # e.g.
+  # module Backup
+  #   begin
+  #     begin
+  #       begin
+  #         raise Errors::ZoneAError, 'an error occurred in Zone A'
+  #       rescue => err
+  #         raise Errors::ZoneBError.wrap(err, <<-EOS)
+  #           an error occurred in Zone B
+  #
+  #           the following error should give a reason
+  #         EOS
+  #       end
+  #     rescue => err
+  #       raise Errors::ZoneCError.wrap(err)
+  #     end
+  #   rescue => err
+  #     puts Errors::ZoneDError.wrap(err, 'an error occurred in Zone D')
+  #   end
+  # end
+  #
+  # Outputs:
+  #   ZoneDError: an error occurred in Zone D
+  #     Reason: ZoneCError
+  #     ZoneBError: an error occurred in Zone B
+  #
+  #     the following error should give a reason
+  #     Reason: ZoneAError
+  #     an error occurred in Zone A
+  #
+  module Errors
+    extend ErrorsHelper
+
+    class Error < StandardError
+
+      def self.wrap(orig_err, msg = nil)
+        new(msg, orig_err)
+      end
+
+      def initialize(msg = nil, orig_err = nil)
+        super(msg)
+        set_backtrace(orig_err.backtrace) if @orig_err = orig_err
+      end
+
+      def to_s
+        return @to_s if @to_s
+        orig_to_s = super()
+
+        if orig_to_s == self.class.to_s
+          msg = orig_err_msg ?
+              "#{orig_err_class}: #{orig_err_msg}" : orig_err_class
+        else
+          msg = format_msg(orig_to_s)
+          msg << "\n  Reason: #{orig_err_class}" + (orig_err_msg ?
+              "\n  #{orig_err_msg}" : ' (no message given)') if @orig_err
+        end
+
+        @to_s = msg ? msg_prefix + msg : class_name
+      end
+
+      private
+
+      def msg_prefix
+        @msg_prefix ||= class_name + ': '
+      end
+
+      def orig_msg
+        @orig_msg ||= to_s.sub(msg_prefix, '')
+      end
+
+      def class_name
+        @class_name ||= self.class.to_s.sub('Backup::Errors::', '')
+      end
+
+      def orig_err_class
+        return unless @orig_err
+
+        @orig_err_class ||= @orig_err.is_a?(Errors::Error) ?
+            @orig_err.send(:class_name) : @orig_err.class.to_s
+      end
+
+      def orig_err_msg
+        return unless @orig_err
+        return @orig_err_msg unless @orig_err_msg.nil?
+
+        msg = @orig_err.is_a?(Errors::Error) ?
+            @orig_err.send(:orig_msg) : @orig_err.to_s
+        @orig_err_msg = (msg == orig_err_class) ?
+            false : format_msg(msg)
+      end
+
+      def format_msg(msg)
+        msg.gsub(/^ */, '  ').strip
+      end
+    end
+
+  end
+end

data/lib/backup/logger.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+module Backup
+  module Logger
+    class << self
+
+      attr_accessor :quiet
+
+      ##
+      # Outputs a messages to the console and writes it to the backup.log
+      def message(string)
+        to_console  loggify(string, :message, :green)
+        to_file     loggify(string, :message)
+      end
+
+      ##
+      # Outputs an error to the console and writes it to the backup.log
+      # Called when an Exception has caused the backup process to abort.
+      def error(string)
+        to_console  loggify(string, :error,   :red), true
+        to_file     loggify(string, :error)
+      end
+
+      ##
+      # Outputs a notice to the console and writes it to the backup.log
+      # Sets #has_warnings? true so :on_warning notifications will be sent
+      def warn(string)
+        @has_warnings = true
+        to_console  loggify(string, :warning, :yellow), true
+        to_file     loggify(string, :warning)
+      end
+
+      # Outputs the data as if it were a regular 'puts' command,
+      # but also logs it to the backup.log
+      def normal(string)
+        to_console  loggify(string)
+        to_file     loggify(string)
+      end
+
+      ##
+      # Silently logs data to the log file
+      def silent(string)
+        to_file     loggify(string, :silent)
+      end
+
+      ##
+      # Returns an Array of all messages written to the log file for this session
+      def messages
+        @messages ||= []
+      end
+
+      ##
+      # Returns true if any warnings have been issued
+      def has_warnings?
+        @has_warnings ||= false
+      end
+
+      def clear!
+        messages.clear
+        @has_warnings = false
+      end
+
+      def truncate!(max_bytes = 500_000)
+        log_file = File.join(Config.log_path, 'backup.log')
+        return unless File.exist?(log_file)
+
+        if File.stat(log_file).size > max_bytes
+          FileUtils.mv(log_file, log_file + '~')
+          File.open(log_file + '~', 'r') do |io_in|
+            File.open(log_file, 'w') do |io_out|
+              io_in.seek(-max_bytes, IO::SEEK_END) && io_in.gets
+              while line = io_in.gets
+                io_out.puts line
+              end
+            end
+          end
+          FileUtils.rm_f(log_file + '~')
+        end
+      end
+
+      private
+
+      ##
+      # Returns the time in [YYYY/MM/DD HH:MM:SS] format
+      def time
+        Time.now.strftime("%Y/%m/%d %H:%M:%S")
+      end
+
+      ##
+      # Receives a String, or an Object that responds to #to_s (e.g. an
+      # Exception), from one of the messaging methods and converts it into an
+      # Array of Strings, split on newline separators. Each line is then
+      # formatted into a log format based on the given options, and the Array
+      # returned to be passed to to_console() and/or to_file().
+      def loggify(string, type = false, color = false)
+        lines = string.to_s.split("\n")
+        if type
+          type = send(color, type) if color
+          time_now = time
+          lines.map {|line| "[#{time_now}][#{type}] #{line}" }
+        else
+          lines
+        end
+      end
+
+      ##
+      # Receives an Array of Strings to be written to the console.
+      def to_console(lines, stderr = false)
+        return if quiet
+        lines.each {|line| stderr ? Kernel.warn(line) : puts(line) }
+      end
+
+      ##
+      # Receives an Array of Strings to be written to the log file.
+      def to_file(lines)
+        File.open(File.join(Config.log_path, 'backup.log'), 'a') do |file|
+          lines.each {|line| file.puts line }
+        end
+        messages.push(*lines)
+      end
+
+      ##
+      # Invokes the #colorize method with the provided string
+      # and the color code "32" (for green)
+      def green(string)
+        colorize(string, 32)
+      end
+
+      ##
+      # Invokes the #colorize method with the provided string
+      # and the color code "33" (for yellow)
+      def yellow(string)
+        colorize(string, 33)
+      end
+
+      ##
+      # Invokes the #colorize method the with provided string
+      # and the color code "31" (for red)
+      def red(string)
+        colorize(string, 31)
+      end
+
+      ##
+      # Wraps the provided string in colorizing tags to provide
+      # easier to view output to the client
+      def colorize(string, code)
+        "\e[#{code}m#{string}\e[0m"
+      end
+
+    end
+  end
+end