backup 3.2.0 → 3.3.0

data/lib/backup/database/postgresql.rb

@@ -28,33 +28,16 @@ module Backup
       # Additional "pg_dump" options
       attr_accessor :additional_options
 
-      ##
-      # Path to pg_dump utility (optional)
-      attr_accessor :pg_dump_utility
-
-      attr_deprecate :utility_path, :version => '3.0.21',
-          :message => 'Use PostgreSQL#pg_dump_utility instead.',
-          :action => lambda {|klass, val| klass.pg_dump_utility = val }
-
-      ##
-      # 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(model, &block)
-        super(model)
-
-        @skip_tables        ||= Array.new
-        @only_tables        ||= Array.new
-        @additional_options ||= Array.new
-
+      def initialize(model, database_id = nil, &block)
+        super
         instance_eval(&block) if block_given?
-
-        @pg_dump_utility ||= utility(:pg_dump)
       end
 
       ##
-      # Performs the pgdump command and outputs the
-      # data to the specified path based on the 'trigger'
+      # Performs the mysqldump command and outputs the dump file
+      # in the +dump_path+ using +dump_filename+.
+      #
+      #   <trigger>/databases/PostgreSQL[-<database_id>].sql[.gz]
       def perform!
         super
 
@@ -62,84 +45,75 @@ module Backup
         dump_ext = 'sql'
 
         pipeline << pgdump
-        if @model.compressor
-          @model.compressor.compress_with do |command, ext|
-            pipeline << command
-            dump_ext << ext
-          end
-        end
+
+        model.compressor.compress_with do |command, ext|
+          pipeline << command
+          dump_ext << ext
+        end if model.compressor
 
         pipeline << "#{ utility(:cat) } > " +
-            "'#{ File.join(@dump_path, name) }.#{ dump_ext }'"
+            "'#{ File.join(dump_path, dump_filename) }.#{ dump_ext }'"
+
         pipeline.run
         if pipeline.success?
-          Logger.info "#{ database_name } Complete!"
+          log!(:finished)
         else
           raise Errors::Database::PipelineError,
-              "#{ database_name } Dump Failed!\n" +
-              pipeline.error_messages
+              "#{ database_name } Dump Failed!\n" + pipeline.error_messages
         end
       end
 
-      ##
-      # Builds the full pgdump string based on all attributes
       def pgdump
-        "#{password_options}" +
-        "#{ pg_dump_utility } #{ username_options } #{ connectivity_options } " +
+        "#{ password_option }" +
+        "#{ utility(:pg_dump) } #{ username_option } #{ connectivity_options } " +
         "#{ user_options } #{ tables_to_dump } #{ tables_to_skip } #{ name }"
       end
 
-      ##
-      # Builds the password syntax PostgreSQL uses to authenticate the user
-      # to perform database dumping
-      def password_options
-        password.to_s.empty? ? '' : "PGPASSWORD='#{password}' "
+      def password_option
+        "PGPASSWORD='#{ password }' " if password
       end
 
-      ##
-      # Builds the credentials PostgreSQL syntax to authenticate the user
-      # to perform the database dumping process
-      def username_options
-        username.to_s.empty? ? '' : "--username='#{username}'"
+      def username_option
+        "--username='#{ username }'" if 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).to_s.empty?
-          "--#{option}='#{send(option)}'".gsub('--socket=', '--host=')
-        end.compact.join(' ')
+        return "--host='#{ socket }'" if socket
+
+        opts = []
+        opts << "--host='#{ host }'" if host
+        opts << "--port='#{ port }'" if port
+        opts.join(' ')
       end
 
-      ##
-      # Builds a PostgreSQL compatible string for the additional options
-      # specified by the user
       def user_options
-        additional_options.join(' ')
+        Array(additional_options).join(' ')
       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}'"
+        Array(only_tables).map do |table|
+          "--table='#{ table }'"
         end.join(' ')
       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}'"
+        Array(skip_tables).map do |table|
+          "--exclude-table='#{ table }'"
         end.join(' ')
       end
 
+      attr_deprecate :utility_path, :version => '3.0.21',
+          :message => 'Use Backup::Utilities.configure instead.',
+          :action => lambda {|klass, val|
+            Utilities.configure { pg_dump val }
+          }
+
+      attr_deprecate :pg_dump_utility, :version => '3.3.0',
+          :message => 'Use Backup::Utilities.configure instead.',
+          :action => lambda {|klass, val|
+            Utilities.configure { pg_dump val }
+          }
+
     end
   end
 end

data/lib/backup/database/redis.rb

@@ -5,85 +5,76 @@ module Backup
     class Redis < Base
 
       ##
-      # Name of and path to the database that needs to get dumped
-      attr_accessor :name, :path
+      # Name of the redis dump file.
+      #
+      # This is set in `redis.conf` as `dbfilename`.
+      # This must be set to the name of that file without the `.rdb` extension.
+      # Default: 'dump'
+      attr_accessor :name
 
       ##
-      # Credentials for the specified database
+      # Path to the redis dump file.
+      #
+      # This is set in `redis.conf` as `dir`.
+      attr_accessor :path
+
+      ##
+      # Password for the redis-cli utility to perform the `SAVE` command
+      # if +invoke_save+ is set `true`.
       attr_accessor :password
 
       ##
-      # Connectivity options
+      # Connectivity options for the +invoke_save+ option.
       attr_accessor :host, :port, :socket
 
       ##
-      # 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
+      # Determines whether Backup should invoke the `SAVE` command through
+      # the `redis-cli` utility to persist the most recent data before
+      # copying the dump file specified by +path+ and +name+.
       attr_accessor :invoke_save
 
       ##
       # Additional "redis-cli" options
       attr_accessor :additional_options
 
-      ##
-      # Path to the redis-cli utility (optional)
-      attr_accessor :redis_cli_utility
-
-      attr_deprecate :utility_path, :version => '3.0.21',
-          :message => 'Use Redis#redis_cli_utility instead.',
-          :action => lambda {|klass, val| klass.redis_cli_utility = val }
-
-      ##
-      # Creates a new instance of the Redis database object
-      def initialize(model, &block)
-        super(model)
-
-        @additional_options ||= Array.new
-
+      def initialize(model, database_id = nil, &block)
+        super
         instance_eval(&block) if block_given?
 
         @name ||= 'dump'
-        @redis_cli_utility ||= utility('redis-cli')
       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
+      # Copies and optionally compresses the Redis dump file to the
+      # +dump_path+ using the +dump_filename+.
+      #
+      #   <trigger>/databases/Redis[-<database_id>].rdb[.gz]
+      #
+      # If +invoke_save+ is true, `redis-cli SAVE` will be invoked.
       def perform!
         super
 
         invoke_save! if invoke_save
         copy!
+
+        log!(:finished)
       end
 
       private
 
-      ##
-      # Tells Redis to persist the current state of the
-      # in-memory database to the persisted dump file
       def invoke_save!
-        response = run("#{ redis_cli_utility } #{ credential_options } " +
-                       "#{ connectivity_options } #{ user_options } SAVE")
-        unless response =~ /OK/
+        resp = run(redis_save_cmd)
+        unless resp =~ /OK$/
           raise Errors::Database::Redis::CommandError, <<-EOS
             Could not invoke the Redis SAVE command.
-            The #{ database } file might not contain the most recent data.
-            Please check if the server is running, the credentials (if any) are correct,
-            and the host/port/socket are correct.
-
-            Redis CLI response: #{ response }
+            Command was: #{ redis_save_cmd }
+            Response was: #{ resp }
           EOS
         end
       end
 
-      ##
-      # Performs the copy command to copy over the Redis dump file to the Backup archive
       def copy!
-        src_path = File.join(path, database)
+        src_path = File.join(path, name + '.rdb')
         unless File.exist?(src_path)
           raise Errors::Database::Redis::NotFoundError, <<-EOS
             Redis database dump not found
@@ -91,46 +82,50 @@ module Backup
           EOS
         end
 
-        dst_path = File.join(@dump_path, database)
-        if @model.compressor
-          @model.compressor.compress_with do |command, ext|
-            run("#{ command } -c #{ src_path } > #{ dst_path + ext }")
+        dst_path = File.join(dump_path, dump_filename + '.rdb')
+        if model.compressor
+          model.compressor.compress_with do |command, ext|
+            run("#{ command } -c '#{ src_path }' > '#{ dst_path + ext }'")
           end
         else
           FileUtils.cp(src_path, dst_path)
         end
       end
 
-      ##
-      # Returns the Redis database file name
-      def database
-        "#{ name }.rdb"
+      def redis_save_cmd
+        "#{ utility('redis-cli') } #{ password_option } " +
+        "#{ connectivity_options } #{ user_options } SAVE"
       end
 
-      ##
-      # Builds the Redis credentials syntax to authenticate the user
-      # to perform the database dumping process
-      def credential_options
-        password.to_s.empty? ? '' : "-a '#{password}'"
+      def password_option
+        "-a '#{ password }'" if password
       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).to_s.empty?
-          "-#{option[0,1]} '#{send(option)}'"
-        end.compact.join(' ')
+        return "-s '#{ socket }'" if socket
+
+        opts = []
+        opts << "-h '#{ host }'" if host
+        opts << "-p '#{ port }'" if port
+        opts.join(' ')
       end
 
-      ##
-      # Builds a Redis compatible string for the
-      # additional options specified by the user
       def user_options
-        @additional_options.join(' ')
+        Array(additional_options).join(' ')
       end
 
+      attr_deprecate :utility_path, :version => '3.0.21',
+          :message => 'Use Backup::Utilities.configure instead.',
+          :action => lambda {|klass, val|
+            Utilities.configure { redis_cli val }
+          }
+
+      attr_deprecate :redis_cli_utility, :version => '3.3.0',
+          :message => 'Use Backup::Utilities.configure instead.',
+          :action => lambda {|klass, val|
+            Utilities.configure { redis_cli val }
+          }
+
     end
   end
 end

data/lib/backup/database/riak.rb

@@ -4,77 +4,98 @@ module Backup
   module Database
     class Riak < Base
 
-      ##
-      # Name is the name of the backup
-      attr_accessor :name
-
       ##
       # 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
 
       ##
-      # Path to riak-admin utility (optional)
-      attr_accessor :riak_admin_utility
-
-      ##
-      # Username for the riak instance (optional)
+      # Username for the riak instance
+      # Default: riak
       attr_accessor :user
 
-      ##
-      # Group for the riak instance (optional)
-      attr_accessor :group
-
-      attr_deprecate :utility_path, :version => '3.0.21',
-          :message => 'Use Riak#riak_admin_utility instead.',
-          :action => lambda {|klass, val| klass.riak_admin_utility = val }
-
-      ##
-      # Creates a new instance of the Riak adapter object
-      def initialize(model, &block)
-        super(model)
-
+      def initialize(model, database_id = nil, &block)
+        super
         instance_eval(&block) if block_given?
 
-        @riak_admin_utility ||= utility('riak-admin')
-        @user               ||= 'riak'
-        @group              ||= 'riak'
+        @node   ||= 'riak@127.0.0.1'
+        @cookie ||= 'riak'
+        @user   ||= 'riak'
       end
 
       ##
-      # Performs the `riak-admin` command which creates a single dump file in
-      # @dump_path based on the `name` and `node`.
+      # Performs the dump using `riak-admin backup`.
       #
-      # `riak-admin` will append the `node` to the filename.
-      # i.e. <tmp_path>/<trigger>/databases/Riak/<name>-<node>
+      # This will be stored in the final backup package as
+      # <trigger>/databases/<dump_filename>-<node>[.gz]
       def perform!
         super
-        # ensure riak-admin user has permissions to write backup file
-        FileUtils.chown_R(@user, @group, @dump_path)
-
-        backup_file = File.join(@dump_path, name)
-        run("#{ riakadmin } #{ backup_file } node")
-
-        if @model.compressor
-          @model.compressor.compress_with do |command, ext|
-            backup_file << "-#{ node }"
-            run("#{ command } -c #{ backup_file } > #{ backup_file + ext }")
-            FileUtils.rm_f(backup_file)
-          end
+
+        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
 
       ##
-      # Builds the full riak-admin string based on all attributes
+      # 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
-        "#{ riak_admin_utility } backup #{ node } #{ cookie }"
+        "#{ utility(:sudo) } -n -u #{ user } #{ utility('riak-admin') }"
       end
 
+      attr_deprecate :utility_path, :version => '3.0.21',
+          :message => 'Use Backup::Utilities.configure instead.',
+          :action => lambda {|klass, val|
+            Utilities.configure { riak_admin val }
+          }
+
+      attr_deprecate :riak_admin_utility, :version => '3.3.0',
+          :message => 'Use Backup::Utilities.configure instead.',
+          :action => lambda {|klass, val|
+            Utilities.configure { riak_admin val }
+          }
+
+      attr_deprecate :name, :version => '3.3.0',
+          :message => "If you wish to add an identifier to the dump filename,\n" +
+          "use a +database_id+ when defining the database in your Model.\n" +
+          "e.g. database Riak, :my_id do |db|"
+
+      attr_deprecate :group, :version => '3.3.0'
+
     end
   end
 end