backupii 0.1.0.pre.alpha.1

data/lib/backup/database/redis.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Backup
+  module Database
+    class Redis < Base
+      class Error < Backup::Error; end
+
+      MODES = %i[copy sync].freeze
+
+      ##
+      # Mode of operation.
+      #
+      # [:copy]
+      #   Copies the redis dump file specified by {#rdb_path}.
+      #   This data will be current as of the last RDB Snapshot
+      #   performed by the server (per your redis.conf settings).
+      #   You may set {#invoke_save} to +true+ to have Backup issue
+      #   a +SAVE+ command to update the dump file with the current
+      #   data before performing the copy.
+      #
+      # [:sync]
+      #   Performs a dump of your redis data using +redis-cli --rdb -+.
+      #   Redis implements this internally using a +SYNC+ command.
+      #   The operation is analogous to requesting a +BGSAVE+, then having the
+      #   dump returned. This mode is capable of dumping data from a local or
+      #   remote server. Requires Redis v2.6 or better.
+      #
+      # Defaults to +:copy+.
+      attr_accessor :mode
+
+      ##
+      # Full path to the redis dump file.
+      #
+      # Required when {#mode} is +:copy+.
+      attr_accessor :rdb_path
+
+      ##
+      # Perform a +SAVE+ command using the +redis-cli+ utility
+      # before copying the dump file specified by {#rdb_path}.
+      #
+      # Only valid when {#mode} is +:copy+.
+      attr_accessor :invoke_save
+
+      ##
+      # Connectivity options for the +redis-cli+ utility.
+      attr_accessor :host, :port, :socket
+
+      ##
+      # Password for the +redis-cli+ utility.
+      attr_accessor :password
+
+      ##
+      # Additional options for the +redis-cli+ utility.
+      attr_accessor :additional_options
+
+      def initialize(model, database_id = nil, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @mode ||= :copy
+
+        raise Error, "'#{mode}' is not a valid mode" unless MODES.include?(mode)
+
+        if mode == :copy && rdb_path.nil?
+          raise Error, "`rdb_path` must be set when `mode` is :copy"
+        end
+      end
+
+      ##
+      # Performs the dump based on {#mode} and stores the Redis dump file
+      # to the +dump_path+ using the +dump_filename+.
+      #
+      #   <trigger>/databases/Redis[-<database_id>].rdb[.gz]
+      def perform!
+        super
+
+        case mode
+        when :sync
+          # messages output by `redis-cli --rdb` on $stderr
+          Logger.configure do
+            ignore_warning(%r{Transfer finished with success})
+            ignore_warning(%r{SYNC sent to master})
+          end
+          sync!
+        when :copy
+          save! if invoke_save
+          copy!
+        end
+
+        log!(:finished)
+      end
+
+      private
+
+      def sync!
+        pipeline = Pipeline.new
+        dump_ext = "rdb".dup
+
+        pipeline << "#{redis_cli_cmd} --rdb -"
+
+        if model.compressor
+          model.compressor.compress_with do |command, ext|
+            pipeline << command
+            dump_ext << ext
+          end
+        end
+
+        pipeline << "#{utility(:cat)} > " \
+          "'#{File.join(dump_path, dump_filename)}.#{dump_ext}'"
+
+        pipeline.run
+
+        unless pipeline.success?
+          raise Error, "Dump Failed!\n" + pipeline.error_messages
+        end
+      end
+
+      def save!
+        resp = run("#{redis_cli_cmd} SAVE")
+        unless resp =~ %r{OK$}
+          raise Error, <<-EOS
+            Failed to invoke the `SAVE` command
+            Response was: #{resp}
+          EOS
+        end
+      rescue Error
+        if resp =~ %r{save already in progress}
+          unless (attempts ||= "0".dup).next! == "5"
+            sleep 5
+            retry
+          end
+        end
+        raise
+      end
+
+      def copy!
+        unless File.exist?(rdb_path)
+          raise Error, <<-EOS
+            Redis database dump not found
+            `rdb_path` was '#{rdb_path}'
+          EOS
+        end
+
+        dst_path = File.join(dump_path, dump_filename + ".rdb")
+        if model.compressor
+          model.compressor.compress_with do |command, ext|
+            run("#{command} -c '#{rdb_path}' > '#{dst_path + ext}'")
+          end
+        else
+          FileUtils.cp(rdb_path, dst_path)
+        end
+      end
+
+      def redis_cli_cmd
+        "#{utility("redis-cli")} #{password_option} " \
+          "#{connectivity_options} #{user_options}"
+      end
+
+      def password_option
+        return unless password
+
+        "-a '#{password}'"
+      end
+
+      def connectivity_options
+        return "-s '#{socket}'" if socket
+
+        opts = []
+        opts << "-h '#{host}'" if host
+        opts << "-p '#{port}'" if port
+        opts.join(" ")
+      end
+
+      def user_options
+        Array(additional_options).join(" ")
+      end
+    end
+  end
+end

data/lib/backup/database/riak.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Backup
+  module Database
+    class Riak < Base
+      ##
+      # Node is the node from which to perform the backup.
+      # Default: riak@127.0.0.1
+      attr_accessor :node
+
+      ##
+      # Cookie is the Erlang cookie/shared secret used to connect to the node.
+      # Default: riak
+      attr_accessor :cookie
+
+      ##
+      # Username for the riak instance
+      # Default: riak
+      attr_accessor :user
+
+      def initialize(model, database_id = nil, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @node   ||= "riak@127.0.0.1"
+        @cookie ||= "riak"
+        @user   ||= "riak"
+      end
+
+      ##
+      # Performs the dump using `riak-admin backup`.
+      #
+      # This will be stored in the final backup package as
+      # <trigger>/databases/<dump_filename>-<node>[.gz]
+      def perform!
+        super
+
+        dump_file = File.join(dump_path, dump_filename)
+        with_riak_owned_dump_path do
+          run("#{riakadmin} backup #{node} #{cookie} '#{dump_file}' node")
+        end
+
+        if model.compressor
+          model.compressor.compress_with do |command, ext|
+            # `riak-admin` appends `node` to the filename.
+            dump_file << "-#{node}"
+            run("#{command} -c '#{dump_file}' > '#{dump_file + ext}'")
+            FileUtils.rm_f(dump_file)
+          end
+        end
+
+        log!(:finished)
+      end
+
+      private
+
+      ##
+      # The `riak-admin backup` command is run as the riak +user+,
+      # so +user+ must have write priviledges to the +dump_path+.
+      #
+      # Note that the riak +user+ must also have access to +dump_path+.
+      # This means Backup's +tmp_path+ can not be under the home directory of
+      # the user running Backup, since the absence of the execute bit on their
+      # home directory would deny +user+ access.
+      def with_riak_owned_dump_path
+        run "#{utility(:sudo)} -n #{utility(:chown)} #{user} '#{dump_path}'"
+        yield
+      ensure
+        # reclaim ownership
+        run "#{utility(:sudo)} -n #{utility(:chown)} -R " \
+          "#{Config.user} '#{dump_path}'"
+      end
+
+      ##
+      # `riak-admin` must be run as the riak +user+.
+      # It will do this itself, but without `-n` and emits a message on STDERR.
+      def riakadmin
+        "#{utility(:sudo)} -n -u #{user} #{utility("riak-admin")}"
+      end
+    end
+  end
+end

data/lib/backup/database/sqlite.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Backup
+  module Database
+    class SQLite < Base
+      class Error < Backup::Error; end
+
+      ##
+      # Path to the sqlite3 file
+      attr_accessor :path
+
+      ##
+      # Path to sqlite utility (optional)
+      attr_accessor :sqlitedump_utility
+
+      ##
+      # Creates a new instance of the SQLite adapter object
+      def initialize(model, database_id = nil, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @sqlitedump_utility ||= utility(:sqlitedump)
+      end
+
+      ##
+      # Performs the sqlitedump command and outputs the
+      # data to the specified path based on the 'trigger'
+      def perform!
+        super
+
+        dump = "echo '.dump' | #{sqlitedump_utility} #{path}"
+
+        pipeline = Pipeline.new
+        dump_ext = "sql".dup
+
+        pipeline << dump
+        if model.compressor
+          model.compressor.compress_with do |command, ext|
+            pipeline << command
+            dump_ext << ext
+          end
+        end
+
+        pipeline << "cat > '#{File.join(dump_path, dump_filename)}.#{dump_ext}'"
+
+        pipeline.run
+
+        if pipeline.success?
+          log!(:finished)
+        else
+          raise Error,
+            "#{database_name} Dump Failed!\n" + pipeline.error_messages
+        end
+      end
+    end
+  end
+end

data/lib/backup/encryptor/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Backup
+  module Encryptor
+    class Base
+      include Utilities::Helpers
+      include Config::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.info "Using #{encryptor_name} to encrypt the archive."
+      end
+    end
+  end
+end