backup-agoddard 3.0.27

data/lib/backup/configuration/store.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'ostruct'
+
+module Backup
+  module Configuration
+    class Store < OpenStruct
+
+      ##
+      # Returns an Array of all attribute method names
+      # that default values were set for.
+      def _attributes
+        @table.keys
+      end
+
+      ##
+      # Used only within the specs
+      def reset!
+        @table.clear
+      end
+
+    end
+  end
+end

data/lib/backup/database/base.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Backup
+  module Database
+    class Base
+      include Backup::CLI::Helpers
+      include Backup::Configuration::Helpers
+
+      ##
+      # Creates a new instance of the MongoDB database object
+      # * Called using super(model) from subclasses *
+      def initialize(model)
+        @model = model
+        load_defaults!
+      end
+
+      ##
+      # Super method for all child (database) objects. Every database object's #perform!
+      # method should call #super before anything else to prepare
+      def perform!
+        prepare!
+        log!
+      end
+
+      private
+
+      ##
+      # Defines the @dump_path and ensures it exists by creating it
+      def prepare!
+        @dump_path = File.join(
+          Config.tmp_path,
+          @model.trigger,
+          'databases',
+          self.class.name.split('::').last
+        )
+        FileUtils.mkdir_p(@dump_path)
+      end
+
+      ##
+      # Return the database name, with Backup namespace removed
+      def database_name
+        self.class.to_s.sub('Backup::', '')
+      end
+
+      ##
+      # Logs a message to the console and log file to inform
+      # the client that Backup is dumping the database
+      def log!
+        Logger.message "#{ database_name } started dumping and archiving '#{ name }'."
+      end
+    end
+  end
+end

data/lib/backup/database/mongodb.rb

@@ -0,0 +1,230 @@
+# encoding: utf-8
+
+module Backup
+  module Database
+    class MongoDB < 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
+
+      ##
+      # IPv6 support (disabled by default)
+      attr_accessor :ipv6
+
+      ##
+      # Collections to dump, collections that aren't specified won't get dumped
+      attr_accessor :only_collections
+
+      ##
+      # Additional "mongodump" options
+      attr_accessor :additional_options
+
+      ##
+      # Path to the mongodump utility (optional)
+      attr_accessor :mongodump_utility
+
+      attr_deprecate :utility_path, :version => '3.0.21',
+          :message => 'Use MongoDB#mongodump_utility instead.',
+          :action => lambda {|klass, val| klass.mongodump_utility = val }
+
+      ##
+      # Path to the mongo utility (optional)
+      attr_accessor :mongo_utility
+
+      ##
+      # 'lock' dump meaning wrapping mongodump with fsync & lock
+      attr_accessor :lock
+
+      ##
+      # Creates a new instance of the MongoDB database object
+      def initialize(model, &block)
+        super(model)
+
+        @only_collections   ||= Array.new
+        @additional_options ||= Array.new
+        @ipv6               ||= false
+        @lock               ||= false
+
+        instance_eval(&block) if block_given?
+
+        @mongodump_utility  ||= utility(:mongodump)
+        @mongo_utility      ||= utility(:mongo)
+      end
+
+      ##
+      # Performs the mongodump command and outputs the data to the
+      # specified path based on the 'trigger'. If the user hasn't specified any
+      # specific collections to dump, it'll dump everything. If the user has specified
+      # collections to dump, it'll loop through the array of collections and invoke the
+      # 'mongodump' command once per collection
+      def perform!
+        super
+
+        lock_database if @lock
+        @only_collections.empty? ? dump! : specific_collection_dump!
+
+      rescue => err
+        raise Errors::Database::MongoDBError.wrap(err, 'Database Dump Failed!')
+      ensure
+        unlock_database if @lock
+        package! unless err
+      end
+
+      private
+
+      ##
+      # Builds and runs the mongodump command
+      def dump!
+        run(mongodump)
+      end
+
+      ##
+      # For each collection in the @only_collections array, it'll
+      # build the whole 'mongodump' command, append the '--collection' option,
+      # and run the command built command
+      def specific_collection_dump!
+        @only_collections.each do |collection|
+          run("#{mongodump} --collection='#{collection}'")
+        end
+      end
+
+      ##
+      # Builds the full mongodump string based on all attributes
+      def mongodump
+        "#{ mongodump_utility } #{ database } #{ credential_options } " +
+        "#{ connectivity_options } #{ ipv6_option } #{ user_options } #{ dump_directory }"
+      end
+
+      ##
+      # If a compressor is configured, packages the dump_path into a
+      # single compressed tar archive, then removes the dump_path.
+      # e.g.
+      #   if the database was dumped to:
+      #     ~/Backup/.tmp/databases/MongoDB/
+      #   then it will be packaged into:
+      #     ~/Backup/.tmp/databases/MongoDB-<timestamp>.tar.gz
+      def package!
+        return unless @model.compressor
+
+        pipeline  = Pipeline.new
+        base_dir  = File.dirname(@dump_path)
+        dump_dir  = File.basename(@dump_path)
+        timestamp = Time.now.to_i.to_s[-5, 5]
+        outfile   = @dump_path + '-' + timestamp + '.tar'
+
+        Logger.message(
+          "#{ database_name } started compressing and packaging:\n" +
+          "  '#{ @dump_path }'"
+        )
+
+        pipeline << "#{ utility(:tar) } -cf - -C '#{ base_dir }' '#{ dump_dir }'"
+        @model.compressor.compress_with do |command, ext|
+          pipeline << command
+          outfile << ext
+        end
+        pipeline << "cat > #{ outfile }"
+
+        pipeline.run
+        if pipeline.success?
+          Logger.message(
+            "#{ database_name } completed compressing and packaging:\n" +
+            "  '#{ outfile }'"
+          )
+          FileUtils.rm_rf(@dump_path)
+        else
+          raise Errors::Database::PipelineError,
+            "#{ database_name } Failed to create compressed dump package:\n" +
+            "'#{ outfile }'\n" +
+            pipeline.error_messages
+        end
+      end
+
+      ##
+      # Returns the MongoDB database selector syntax
+      def database
+        "--db='#{ name }'" if name
+      end
+
+      ##
+      # Builds the MongoDB credentials syntax to authenticate the user
+      # to perform the database dumping process
+      def credential_options
+        %w[username password].map do |option|
+          next if send(option).to_s.empty?
+          "--#{option}='#{send(option)}'"
+        end.compact.join(' ')
+      end
+
+      ##
+      # Builds the MongoDB connectivity options syntax to connect the user
+      # to perform the database dumping process
+      def connectivity_options
+        %w[host port].map do |option|
+          next if send(option).to_s.empty?
+          "--#{option}='#{send(option)}'"
+        end.compact.join(' ')
+      end
+
+      ##
+      # Returns the mongodump syntax for enabling ipv6
+      def ipv6_option
+        @ipv6 ? '--ipv6' : ''
+      end
+
+      ##
+      # Builds a MongoDB compatible string for the
+      # additional options specified by the user
+      def user_options
+        @additional_options.join(' ')
+      end
+
+      ##
+      # Returns the MongoDB syntax for determining where to output all the database dumps,
+      # e.g. ~/Backup/.tmp/databases/MongoDB/<databases here>/<database collections>
+      def dump_directory
+        "--out='#{ @dump_path }'"
+      end
+
+      ##
+      # Locks and FSyncs the database to bring it up to sync
+      # and ensure no 'write operations' are performed during the
+      # dump process
+      def lock_database
+        lock_command = <<-EOS.gsub(/^ +/, ' ')
+          echo 'use admin
+          db.runCommand({"fsync" : 1, "lock" : 1})' | #{ "#{ mongo_utility } #{ mongo_uri }" }
+        EOS
+
+        run(lock_command)
+      end
+
+      ##
+      # Unlocks the (locked) database
+      def unlock_database
+        unlock_command = <<-EOS.gsub(/^ +/, ' ')
+          echo 'use admin
+          db.$cmd.sys.unlock.findOne()' | #{ "#{ mongo_utility } #{ mongo_uri }" }
+        EOS
+
+        run(unlock_command)
+      end
+
+      ##
+      # Builds a Mongo URI based on the provided attributes
+      def mongo_uri
+        ["#{ host }:#{ port }#{ ('/' + name) if name }",
+         credential_options, ipv6_option].join(' ').strip
+      end
+
+    end
+  end
+end

data/lib/backup/database/mysql.rb

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+module Backup
+  module Database
+    class MySQL < Base
+
+      ##
+      # Name of the database that needs to get dumped
+      # To dump all databases, set this to `:all` or leave blank.
+      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 "mysqldump" options
+      attr_accessor :additional_options
+
+      ##
+      # Path to mysqldump utility (optional)
+      attr_accessor :mysqldump_utility
+
+      attr_deprecate :utility_path, :version => '3.0.21',
+          :message => 'Use MySQL#mysqldump_utility instead.',
+          :action => lambda {|klass, val| klass.mysqldump_utility = val }
+
+      ##
+      # Creates a new instance of the MySQL adapter object
+      def initialize(model, &block)
+        super(model)
+
+        @skip_tables        ||= Array.new
+        @only_tables        ||= Array.new
+        @additional_options ||= Array.new
+
+        instance_eval(&block) if block_given?
+
+        @name ||= :all
+        @mysqldump_utility ||= utility(:mysqldump)
+      end
+
+      ##
+      # Performs the mysqldump command and outputs the
+      # data to the specified path based on the 'trigger'
+      def perform!
+        super
+
+        pipeline = Pipeline.new
+        dump_ext = 'sql'
+
+        pipeline << mysqldump
+        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?
+          Logger.message "#{ database_name } Complete!"
+        else
+          raise Errors::Database::PipelineError,
+              "#{ database_name } Dump Failed!\n" +
+              pipeline.error_messages
+        end
+      end
+
+      private
+
+      ##
+      # Builds the full mysqldump string based on all attributes
+      def mysqldump
+        "#{ mysqldump_utility } #{ credential_options } #{ connectivity_options } " +
+        "#{ user_options } #{ db_name } #{ tables_to_dump } #{ tables_to_skip }"
+      end
+
+      ##
+      # Returns the filename to use for dumping the database(s)
+      def dump_filename
+        dump_all? ? 'all-databases' : name
+      end
+
+      ##
+      # Builds the credentials MySQL syntax to authenticate the user
+      # to perform the database dumping process
+      def credential_options
+        %w[username password].map do |option|
+          next if send(option).to_s.empty?
+          "--#{option}='#{send(option)}'".gsub('--username', '--user')
+        end.compact.join(' ')
+      end
+
+      ##
+      # Builds the MySQL 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}='#{send(option)}'"
+        end.compact.join(' ')
+      end
+
+      ##
+      # Builds a MySQL compatible string for the additional options
+      # specified by the user
+      def user_options
+        additional_options.join(' ')
+      end
+
+      ##
+      # Returns the database name to use in the mysqldump command.
+      # When dumping all databases, the database name is replaced
+      # with the command option to dump all databases.
+      def db_name
+        dump_all? ? '--all-databases' : name
+      end
+
+      ##
+      # Builds the MySQL syntax for specifying which tables to dump
+      # during the dumping of the database
+      def tables_to_dump
+        only_tables.join(' ') unless dump_all?
+      end
+
+      ##
+      # Builds the MySQL syntax for specifying which tables to skip
+      # during the dumping of the database
+      def tables_to_skip
+        skip_tables.map do |table|
+          table = (dump_all? || table['.']) ? table : "#{ name }.#{ table }"
+          "--ignore-table='#{ table }'"
+        end.join(' ')
+      end
+
+      ##
+      # Return true if we're dumping all databases.
+      # `name` will be set to :all if it is not set,
+      # so this will be true by default
+      def dump_all?
+        name == :all
+      end
+
+    end
+  end
+end