sliday_backup 0.1

data/lib/sliday_backup/database/postgresql.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+module SlidayBackup
+  module Database
+    class PostgreSQL < Base
+      class Error < SlidayBackup::Error; end
+
+      ##
+      # Name of the database that needs to get dumped.
+      # To dump all databases, set this to `:all` or leave blank.
+      # +username+ must be a PostgreSQL superuser to run `pg_dumpall`.
+      attr_accessor :name
+
+      ##
+      # Credentials for the specified database
+      attr_accessor :username, :password
+
+      ##
+      # If set the pg_dump(all) command is executed as the given user
+      attr_accessor :sudo_user
+
+      ##
+      # Connectivity options
+      attr_accessor :host, :port, :socket
+
+      ##
+      # Tables to skip while dumping the database.
+      # If `name` is set to :all (or not specified), these are ignored.
+      attr_accessor :skip_tables
+
+      ##
+      # Tables to dump. This in only valid if `name` is specified.
+      # If none are given, the entire database will be dumped.
+      attr_accessor :only_tables
+
+      ##
+      # Additional "pg_dump" or "pg_dumpall" options
+      attr_accessor :additional_options
+
+      def initialize(model, database_id = nil, &block)
+        super
+        instance_eval(&block) if block_given?
+
+        @name ||= :all
+      end
+
+      ##
+      # Performs the pgdump command and outputs the dump file
+      # in the +dump_path+ using +dump_filename+.
+      #
+      #   <trigger>/databases/PostgreSQL[-<database_id>].sql[.gz]
+      def perform!
+        super
+
+        pipeline = Pipeline.new
+        dump_ext = 'sql'
+
+        pipeline << (dump_all? ? pgdumpall : pgdump)
+
+        model.compressor.compress_with do |command, ext|
+          pipeline << command
+          dump_ext << ext
+        end if model.compressor
+
+        pipeline << "#{ utility(:cat) } > " +
+            "'#{ File.join(dump_path, dump_filename) }.#{ dump_ext }'"
+
+        pipeline.run
+        if pipeline.success?
+          log!(:finished)
+        else
+          raise Error, "Dump Failed!\n" + pipeline.error_messages
+        end
+      end
+
+      def pgdump
+        "#{ password_option }" +
+        "#{ sudo_option }" +
+        "#{ utility(:pg_dump) } #{ username_option } #{ connectivity_options } " +
+        "#{ user_options } #{ tables_to_dump } #{ tables_to_skip } #{ name }"
+      end
+
+      def pgdumpall
+        "#{ password_option }" +
+        "#{ sudo_option }" +
+        "#{ utility(:pg_dumpall) } #{ username_option } " +
+        "#{ connectivity_options } #{ user_options }"
+      end
+
+      def password_option
+        "PGPASSWORD=#{ Shellwords.escape(password) } " if password
+      end
+
+      def sudo_option
+        "#{ utility(:sudo) } -n -u #{ sudo_user } " if sudo_user
+      end
+
+      def username_option
+        "--username=#{ Shellwords.escape(username) }" if username
+      end
+
+      def connectivity_options
+        return "--host='#{ socket }'" if socket
+
+        opts = []
+        opts << "--host='#{ host }'" if host
+        opts << "--port='#{ port }'" if port
+        opts.join(' ')
+      end
+
+      def user_options
+        Array(additional_options).join(' ')
+      end
+
+      def tables_to_dump
+        Array(only_tables).map do |table|
+          "--table='#{ table }'"
+        end.join(' ')
+      end
+
+      def tables_to_skip
+        Array(skip_tables).map do |table|
+          "--exclude-table='#{ table }'"
+        end.join(' ')
+      end
+
+      def dump_all?
+        name == :all
+      end
+
+    end
+  end
+end

data/lib/sliday_backup/database/redis.rb

@@ -0,0 +1,179 @@
+# encoding: utf-8
+
+module SlidayBackup
+  module Database
+    class Redis < Base
+      class Error < SlidayBackup::Error; end
+
+      MODES = [:copy, :sync]
+
+      ##
+      # 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 SlidayBackup 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
+
+        unless MODES.include?(mode)
+          raise Error, "'#{ mode }' is not a valid mode"
+        end
+
+        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(/Transfer finished with success/)
+            ignore_warning(/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'
+
+        pipeline << "#{ redis_cli_cmd } --rdb -"
+
+        model.compressor.compress_with do |command, ext|
+          pipeline << command
+          dump_ext << ext
+        end if model.compressor
+
+        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 =~ /OK$/
+          raise Error, <<-EOS
+            Failed to invoke the `SAVE` command
+            Response was: #{ resp }
+          EOS
+        end
+
+      rescue Error
+        if resp =~ /save already in progress/
+          unless (attempts ||= '0').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
+        "-a '#{ password }'" if 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/sliday_backup/database/riak.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+
+module SlidayBackup
+  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
+
+        model.compressor.compress_with do |command, ext|
+          dump_file << "-#{ node }" # `riak-admin` appends `node` to the filename.
+          run("#{ command } -c '#{ dump_file }' > '#{ dump_file + ext }'")
+          FileUtils.rm_f(dump_file)
+        end if model.compressor
+
+        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 SlidayBackup's +tmp_path+ can not be under the home directory of
+      # the user running SlidayBackup, 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/sliday_backup/database/sqlite.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+module SlidayBackup
+  module Database
+    class SQLite < Base
+      class Error < SlidayBackup::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'
+
+        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