interu-backup 3.0.16

data/lib/backup/database/postgresql.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+
+module Backup
+  module Database
+    class PostgreSQL < Base
+
+      ##
+      # Name of the database that needs to get dumped
+      attr_accessor :name
+
+      ##
+      # Credentials for the specified database
+      attr_accessor :username, :password
+
+      ##
+      # Connectivity options
+      attr_accessor :host, :port, :socket
+
+      ##
+      # Tables to skip while dumping the database
+      attr_accessor :skip_tables
+
+      ##
+      # Tables to dump, tables that aren't specified won't get dumped
+      attr_accessor :only_tables
+
+      ##
+      # Additional "pg_dump" options
+      attr_accessor :additional_options
+
+      ##
+      # Creates a new instance of the PostgreSQL adapter object
+      # Sets the PGPASSWORD environment variable to the password
+      # so it doesn't prompt and hang in the process
+      def initialize(&block)
+        load_defaults!
+
+        @skip_tables        ||= Array.new
+        @only_tables        ||= Array.new
+        @additional_options ||= Array.new
+
+        instance_eval(&block)
+        prepare!
+        ENV['PGPASSWORD'] = password
+      end
+
+      ##
+      # Builds the PostgreSQL syntax for specifying which tables to skip
+      # during the dumping of the database
+      def tables_to_skip
+        skip_tables.map do |table|
+          "--exclude-table='#{table}'"
+        end.join("\s")
+      end
+
+      ##
+      # Builds the PostgreSQL syntax for specifying which tables to dump
+      # during the dumping of the database
+      def tables_to_dump
+        only_tables.map do |table|
+          "--table='#{table}'"
+        end.join("\s")
+      end
+
+      ##
+      # Builds the credentials PostgreSQL syntax to authenticate the user
+      # to perform the database dumping process
+      def credential_options
+        return '' unless username.is_a?(String) and not username.empty?
+        "--username='#{username}'"
+      end
+
+      ##
+      # Builds the PostgreSQL connectivity options syntax to connect the user
+      # to perform the database dumping process, socket gets gsub'd to host since
+      # that's the option PostgreSQL takes for socket connections as well. In case
+      # both the host and the socket are specified, the socket will take priority over the host
+      def connectivity_options
+        %w[host port socket].map do |option|
+          next if send(option).nil? or (send(option).respond_to?(:empty?) and send(option).empty?)
+          "--#{option}='#{send(option)}'".gsub('--socket=', '--host=')
+        end.compact.join("\s")
+      end
+
+      ##
+      # Builds a PostgreSQL compatible string for the additional options
+      # specified by the user
+      def options
+        additional_options.join("\s")
+      end
+
+      ##
+      # 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 }"
+      end
+
+      ##
+      # Performs the pgdump command and outputs the
+      # data to the specified path based on the 'trigger'
+      # and resets the 'PGPASSWORD' environment variable to nil
+      def perform!
+        log!
+        run("#{pgdump} > '#{File.join(dump_path, name)}.sql'")
+        ENV['PGPASSWORD'] = nil
+      end
+
+    end
+  end
+end

data/lib/backup/database/redis.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+module Backup
+  module Database
+    class Redis < Base
+
+      ##
+      # Name of and path to the database that needs to get dumped
+      attr_accessor :name, :path
+
+      ##
+      # Credentials for the specified database
+      attr_accessor :password
+
+      ##
+      # Determines whether Backup should invoke the SAVE command through
+      # the 'redis-cli' utility to persist the most recent data before
+      # copying over the dump file
+      attr_accessor :invoke_save
+
+      ##
+      # Connectivity options
+      attr_accessor :host, :port, :socket
+
+      ##
+      # Additional "redis-cli" options
+      attr_accessor :additional_options
+
+      ##
+      # Creates a new instance of the Redis database object
+      def initialize(&block)
+        load_defaults!
+
+        @additional_options ||= Array.new
+
+        instance_eval(&block)
+        prepare!
+      end
+
+      ##
+      # Builds the Redis credentials syntax to authenticate the user
+      # to perform the database dumping process
+      def credential_options
+        return "-a '#{password}'" if password; String.new
+      end
+
+      ##
+      # Builds the Redis connectivity options syntax to connect the user
+      # to perform the database dumping process
+      def connectivity_options
+        %w[host port socket].map do |option|
+          next if send(option).nil?; "-#{option[0,1]} '#{send(option)}'"
+        end.compact.join("\s")
+      end
+
+      ##
+      # Builds a Redis compatible string for the
+      # additional options specified by the user
+      def additional_options
+        @additional_options.join("\s")
+      end
+
+      ##
+      # Returns the Redis database file name
+      def database
+        "#{ name }.rdb"
+      end
+
+      ##
+      # Performs the Redis backup by using the 'cp' unix utility
+      # to copy the persisted Redis dump file to the Backup archive.
+      # Additionally, when 'invoke_save' is set to true, it'll tell
+      # the Redis server to persist the current state to the dump file
+      # before copying the dump to get the most recent updates in to the backup
+      def perform!
+        log!
+
+        invoke_save! if invoke_save
+        copy!
+      end
+
+      ##
+      # Tells Redis to persist the current state of the
+      # in-memory database to the persisted dump file
+      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 "Please check if the server is running, the credentials (if any) are correct, and the host/port/socket are correct."
+        end
+      end
+
+      ##
+      # Performs the copy command to copy over the Redis dump file to the Backup archive
+      def copy!
+        unless File.exist?(File.join(path, database))
+          Logger.error "Redis database dump not found in '#{ File.join(path, database) }'"
+          exit
+        end
+
+        run("#{ utility(:cp) } '#{ File.join(path, database) }' '#{ File.join(dump_path, database) }'")
+      end
+    end
+  end
+end

data/lib/backup/dependency.rb

@@ -0,0 +1,96 @@
+# 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
+    extend Backup::CLI
+
+    ##
+    # Returns a hash of dependencies that Backup requires
+    # in order to run every available feature
+    def self.all
+      {
+        'fog' => {
+          :require => 'fog',
+          :version => '~> 0.7.0',
+          :for     => 'Amazon S3, Rackspace Cloud Files (S3, CloudFiles Storages)'
+        },
+
+        'dropbox' => {
+          :require => 'dropbox',
+          :version => '~> 1.2.3',
+          :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.3',
+          :for     => 'SSH Protocol (SSH Storage)'
+        },
+
+        'mail' => {
+          :require => 'mail',
+          :version => '~> 2.2.15',
+          :for     => 'Sending Emails (Mail Notifier)'
+        },
+
+        'twitter' => {
+          :require => 'twitter',
+          :version => '~> 1.1.2',
+          :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'
+        }
+      }
+    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
+        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:"
+        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]}'")
+        exit
+      end
+    end
+
+  end
+end

data/lib/backup/encryptor/base.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Backup
+  module Encryptor
+    class Base
+      include Backup::CLI
+      include Backup::Configuration::Helpers
+
+      ##
+      # Logs a message to the console and log file to inform
+      # the client that Backup is encrypting the archive
+      def log!
+        Logger.message "#{ self.class } started encrypting the archive."
+      end
+    end
+  end
+end

data/lib/backup/encryptor/gpg.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+##
+# Require the tempfile Ruby library when Backup::Encryptor::GPG is loaded
+require 'tempfile'
+
+module Backup
+  module Encryptor
+    class GPG < Base
+
+      ##
+      # The GPG Public key that'll be used to encrypt the backup
+      attr_accessor :key
+
+      ##
+      # Contains the GPG encryption key id which'll be extracted from the public key file
+      attr_accessor :encryption_key_id
+
+      ##
+      # Contains the temporary file with the public key
+      attr_accessor :tmp_file
+
+      ##
+      # 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)
+        load_defaults!
+
+        instance_eval(&block) if block_given?
+
+        @key = key.gsub(/^[[:blank:]]+/, '')
+      end
+
+      ##
+      # Performs the encrypting of the backup file and will
+      # remove the unencrypted backup file, as well as the temp file
+      def perform!
+        log!
+        write_tmp_file!
+        extract_encryption_key_id!
+
+        run("#{ utility(:gpg) } #{ options } -o '#{ Backup::Model.file }.gpg' '#{ Backup::Model.file }'")
+
+        rm(Backup::Model.file)
+        tmp_file.unlink
+
+        Backup::Model.extension += '.gpg'
+      end
+
+    private
+
+      ##
+      # GPG options
+      # Sets the gpg mode to 'encrypt' and passes in the encryption_key_id
+      def options
+        "-e --trust-model always -r '#{ encryption_key_id }'"
+      end
+
+      ##
+      # Creates a new temp file and writes the provided public gpg key to it
+      def write_tmp_file!
+        @tmp_file = Tempfile.new('backup.pub')
+        @tmp_file.write(key)
+        @tmp_file.close
+      end
+
+      ##
+      # Extracts the 'encryption key id' from the '@tmp_file'
+      # and stores it in '@encryption_key_id'
+      def extract_encryption_key_id!
+        @encryption_key_id = run("#{ utility(:gpg) } --import '#{tmp_file.path}' 2>&1").match(/<(.+)>/)[1]
+      end
+
+    end
+  end
+end

data/lib/backup/encryptor/open_ssl.rb

@@ -0,0 +1,67 @@
+# 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
+
+      ##
+      # Determines whether the 'base64' should be used or not
+      attr_writer :base64
+
+      ##
+      # Determines whether the 'salt' flag should be used
+      attr_writer :salt
+
+      ##
+      # Creates a new instance of Backup::Encryptor::OpenSSL and
+      # sets the password attribute to what was provided
+      def initialize(&block)
+        load_defaults!
+
+        @base64 ||= false
+        @salt   ||= false
+
+        instance_eval(&block) if block_given?
+      end
+
+      ##
+      # Performs the encryption of the backup file
+      def perform!
+        log!
+        run("#{ utility(:openssl) } #{ options } -in '#{ Backup::Model.file }' -out '#{ Backup::Model.file }.enc' -k '#{ password }'")
+        rm(Backup::Model.file)
+        Backup::Model.extension += '.enc'
+      end
+
+    private
+
+      ##
+      # Backup::Encryptor::OpenSSL uses the 256bit AES encryption cipher.
+      # 256bit AES is what the US Government uses to encrypt information at the "Top Secret" level.
+      def options
+        (['aes-256-cbc'] + base64 + salt).join("\s")
+      end
+
+      ##
+      # Returns '-a' if @base64 is set to 'true'.
+      # This option will make the encrypted output base64 encoded,
+      # this makes the encrypted file readable using text editors
+      def base64
+        return ['-base64'] if @base64; []
+      end
+
+      ##
+      # Returns '-salt' if @salt is set to 'true'.
+      # This options adds strength to the encryption
+      def salt
+        return ['-salt'] if @salt; []
+      end
+
+    end
+  end
+end