backupii 0.1.0.pre.alpha.1

data/lib/backup/compressor/gzip.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Backup
+  module Compressor
+    class Gzip < Base
+      class Error < Backup::Error; end
+      extend Utilities::Helpers
+
+      ##
+      # Specify the level of compression to use.
+      #
+      # Values should be a single digit from 1 to 9.
+      # Note that setting the level to either extreme may or may not
+      # give the desired result. Be sure to check the documentation
+      # for the compressor being used.
+      #
+      # The default `level` is 6.
+      attr_accessor :level
+
+      ##
+      # Use the `--rsyncable` option with `gzip`.
+      #
+      # This option directs `gzip` to compress data using an algorithm that
+      # allows `rsync` to efficiently detect changes. This is especially useful
+      # when used to compress `Archive` or `Database` backups that will be
+      # stored using Backup's `RSync` Storage option.
+      #
+      # The `--rsyncable` option is only available on patched versions of
+      # `gzip`. While most distributions apply this patch, this option may not
+      # be available on your system. If it's not available, Backup will log a
+      # warning and continue to use the compressor without this option.
+      attr_accessor :rsyncable
+
+      ##
+      # Determine if +--rsyncable+ is supported and cache the result.
+      def self.has_rsyncable?
+        return @has_rsyncable unless @has_rsyncable.nil?
+
+        cmd = "#{utility(:gzip)} --rsyncable --version >/dev/null 2>&1; echo $?"
+        @has_rsyncable = `#{cmd}`.chomp == "0"
+      end
+
+      ##
+      # Creates a new instance of Backup::Compressor::Gzip
+      def initialize(&block)
+        load_defaults!
+
+        @level ||= false
+        @rsyncable ||= false
+
+        instance_eval(&block) if block_given?
+
+        @cmd = "#{utility(:gzip)}#{options}"
+        @ext = ".gz"
+      end
+
+      private
+
+      def options
+        opts = String.new
+        opts << " -#{@level}" if @level
+        if @rsyncable
+          if self.class.has_rsyncable?
+            opts << " --rsyncable"
+          else
+            Logger.warn Error.new(<<-EOS)
+              'rsyncable' option ignored.
+              Your system's 'gzip' does not support the `--rsyncable` option.
+            EOS
+          end
+        end
+        opts
+      end
+    end
+  end
+end

data/lib/backup/config/dsl.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Backup
+  module Config
+    # Context for loading user config.rb and model files.
+    class DSL
+      class Error < Backup::Error; end
+      Model = Backup::Model
+
+      class << self
+        private
+
+        # List the available database, storage, syncer, compressor, encryptor
+        # and notifier constants. These are used to define constant names within
+        # Backup::Config::DSL so that users may use a constant instead of a
+        # string. Nested namespaces are represented using Hashs. Deep nesting
+        # supported.
+        #
+        # Example, instead of:
+        #  database "MySQL" do |mysql|
+        #  sync_with "RSync::Local" do |rsync|
+        #
+        # You can do:
+        #  database MySQL do |mysql|
+        #  sync_with RSync::Local do |rsync|
+        #
+        def add_dsl_constants
+          create_modules(
+            DSL,
+            [ # Databases
+              %w[MySQL PostgreSQL MongoDB Redis Riak OpenLDAP SQLite],
+              # Storages
+              %w[S3 CloudFiles Dropbox FTP SFTP SCP RSync Local Qiniu],
+              # Compressors
+              %w[Gzip Bzip2 Custom],
+              # Encryptors
+              %w[OpenSSL GPG],
+              # Syncers
+              [
+                { "Cloud" => %w[CloudFiles S3] },
+                { "RSync" => %w[Push Pull Local] }
+              ],
+              # Notifiers
+              %w[Mail Twitter Campfire Prowl Hipchat PagerDuty Pushover
+                 HttpPost Nagios Slack FlowDock Zabbix Ses DataDog Command]
+            ]
+          )
+        end
+
+        def create_modules(scope, names)
+          names.flatten.each do |name|
+            if name.is_a?(Hash)
+              name.each do |key, val|
+                create_modules(get_or_create_empty_module(scope, key), [val])
+              end
+            else
+              get_or_create_empty_module(scope, name)
+            end
+          end
+        end
+
+        def get_or_create_empty_module(scope, const)
+          if scope.const_defined?(const)
+            scope.const_get(const)
+          else
+            scope.const_set(const, Module.new)
+          end
+        end
+      end
+
+      add_dsl_constants # add constants on load
+
+      attr_reader :_config_options
+
+      def initialize
+        @_config_options = {}
+      end
+
+      # Allow users to set command line path options in config.rb
+      [:root_path, :data_path, :tmp_path].each do |name|
+        define_method name do |path|
+          _config_options[name] = path
+        end
+      end
+
+      # Allows users to create preconfigured models.
+      def preconfigure(name, &block)
+        unless name.is_a?(String) && name =~ %r{^[A-Z]}
+          raise Error, "Preconfigured model names must be given as a string " \
+                        "and start with a capital letter."
+        end
+
+        if DSL.const_defined?(name)
+          raise Error, "'#{name}' is already in use " \
+                        "and can not be used for a preconfigured model."
+        end
+
+        DSL.const_set(name, Class.new(Model))
+        DSL.const_get(name).preconfigure(&block)
+      end
+    end
+  end
+end

data/lib/backup/config/helpers.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module Backup
+  module Config
+    module Helpers
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def defaults
+          @defaults ||= Config::Defaults.new
+
+          if block_given?
+            yield @defaults
+          else
+            @defaults
+          end
+        end
+
+        # Used only within the specs
+        def clear_defaults!
+          defaults.reset!
+        end
+
+        def deprecations
+          @deprecations ||= {}
+        end
+
+        def log_deprecation_warning(name, deprecation)
+          msg = "#{self}##{name} has been deprecated as of " \
+            "backup v.#{deprecation[:version]}".dup
+          msg << "\n#{deprecation[:message]}" if deprecation[:message]
+          Logger.warn Config::Error.new(<<-EOS)
+            [DEPRECATION WARNING]
+            #{msg}
+          EOS
+        end
+
+        protected
+
+        ##
+        # Method to deprecate an attribute.
+        #
+        # :version
+        #   Must be set to the backup version which will first
+        #   introduce the deprecation.
+        #
+        # :action
+        #   If set, this Proc will be called with a reference to the
+        #   class instance and the value set on the deprecated accessor.
+        #   e.g. deprecation[:action].call(klass, value)
+        #   This should perform whatever action is neccessary, such as
+        #   transferring the value to a new accessor.
+        #
+        # :message
+        #   If set, this will be appended to #log_deprecation_warning
+        #
+        # Note that this replaces the `attr_accessor` method, or other
+        # method previously used to set the accessor being deprecated.
+        # #method_missing will handle any calls to `name=`.
+        #
+        def attr_deprecate(name, args = {})
+          deprecations[name] = {
+            version: nil,
+            message: nil,
+            action: nil
+          }.merge(args)
+        end
+      end # ClassMethods
+
+      private
+
+      ##
+      # Sets any pre-configured default values.
+      # If a default value was set for an invalid accessor,
+      # this will raise a NameError.
+      def load_defaults!
+        self.class.defaults._attributes.each do |name|
+          val = self.class.defaults.send(name)
+          val = val.dup rescue val
+          send(:"#{name}=", val)
+        end
+      end
+
+      ##
+      # Check missing methods for deprecated attribute accessors.
+      #
+      # If a value is set on an accessor that has been deprecated
+      # using #attr_deprecate, a warning will be issued and any
+      # :action (Proc) specified will be called with a reference to
+      # the class instance and the value set on the deprecated accessor.
+      # See #attr_deprecate and #log_deprecation_warning
+      #
+      # Note that OpenStruct (used for setting defaults) does not allow
+      # multiple arguments when assigning values for members.
+      # So, we won't allow it here either, even though an attr_accessor
+      # will accept and convert them into an Array. Therefore, setting
+      # an option value using multiple values, whether as a default or
+      # directly on the class' accessor, should not be supported.
+      # i.e. if an option will accept being set as an Array, then it
+      # should be explicitly set as such. e.g. option = [val1, val2]
+      #
+      def method_missing(name, *args)
+        deprecation = nil
+        if (method = name.to_s.chomp!("="))
+          if (len = args.count) != 1
+            raise ArgumentError,
+              "wrong number of arguments (#{len} for 1)", caller(1)
+          end
+          deprecation = self.class.deprecations[method.to_sym]
+        end
+
+        if deprecation
+          self.class.log_deprecation_warning(method, deprecation)
+          deprecation[:action].call(self, args[0]) if deprecation[:action]
+        else
+          super
+        end
+      end
+    end # Helpers
+
+    # Store for pre-configured defaults.
+    class Defaults < 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/config.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "backup/config/dsl"
+require "backup/config/helpers"
+
+module Backup
+  module Config
+    class Error < Backup::Error; end
+
+    DEFAULTS = {
+      config_file: "config.rb",
+      data_path: ".data",
+      tmp_path: ".tmp"
+    }.freeze
+
+    class << self
+      include Utilities::Helpers
+
+      attr_reader :user, :root_path, :config_file, :data_path, :tmp_path
+
+      # Loads the user's +config.rb+ and all model files.
+      def load(options = {})
+        update(options) # from the command line
+
+        unless File.exist?(config_file)
+          raise Error, "Could not find configuration file: '#{config_file}'."
+        end
+
+        config = File.read(config_file)
+        version = Backup::VERSION.split(".").first
+        unless config =~ %r{^# Backup v#{version}\.x Configuration$}
+          raise Error, <<-EOS
+            Invalid Configuration File
+            The configuration file at '#{config_file}'
+            does not appear to be a Backup v#{version}.x configuration file.
+            If you have upgraded to v#{version}.x from a previous version,
+            you need to upgrade your configuration file.
+            Please see the instructions for upgrading in the Backup documentation.
+          EOS
+        end
+
+        dsl = DSL.new
+        dsl.instance_eval(config, config_file)
+
+        update(dsl._config_options)  # from config.rb
+        update(options)              # command line takes precedence
+
+        dirs = Dir[File.join(File.dirname(config_file), "models", "*.rb")]
+        dirs.each do |model|
+          dsl.instance_eval(File.read(model), model)
+        end
+      end
+
+      def hostname
+        @hostname ||= run(utility(:hostname))
+      end
+
+      private
+
+      # If :root_path is set in the options, all paths will be updated.
+      # Otherwise, only the paths given will be updated.
+      def update(options = {})
+        root_path = options[:root_path].to_s.strip
+        new_root = root_path.empty? ? false : set_root_path(root_path)
+
+        DEFAULTS.each do |name, ending|
+          set_path_variable(name, options[name], ending, new_root)
+        end
+      end
+
+      # Sets the @root_path to the given +path+ and returns it.
+      # Raises an error if the given +path+ does not exist.
+      def set_root_path(path)
+        # allows #reset! to set the default @root_path,
+        # then use #update to set all other paths,
+        # without requiring that @root_path exist.
+        return @root_path if path == @root_path
+
+        path = File.expand_path(path)
+        unless File.directory?(path)
+          raise Error, <<-EOS
+            Root Path Not Found
+            When specifying a --root-path, the path must exist.
+            Path was: #{path}
+          EOS
+        end
+
+        @root_path = path
+      end
+
+      def set_path_variable(name, path, ending, root_path)
+        # strip any trailing '/' in case the user supplied this as part of
+        # an absolute path, so we can match it against File.expand_path()
+        path = path.to_s.sub(%r{/\s*$}, "").lstrip
+        new_path = false
+        # If no path is given, the variable will not be set/updated
+        # unless a root_path was given. In which case the value will
+        # be updated with our default ending.
+        if path.empty?
+          new_path = File.join(root_path, ending) if root_path
+        else
+          # When a path is given, the variable will be set/updated. If the path
+          # is relative, it will be joined with root_path (if given), or
+          # expanded relative to PWD.
+          new_path = File.expand_path(path)
+          unless path == new_path
+            new_path = File.join(root_path, path) if root_path
+          end
+        end
+        instance_variable_set(:"@#{name}", new_path) if new_path
+      end
+
+      def reset!
+        @user      = ENV["USER"] || Etc.getpwuid.name
+        @root_path = File.join(File.expand_path(ENV["HOME"] || ""), "Backup")
+        update(root_path: @root_path)
+      end
+    end
+
+    reset! # set defaults on load
+  end
+end

data/lib/backup/database/base.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Backup
+  module Database
+    class Error < Backup::Error; end
+
+    class Base
+      include Utilities::Helpers
+      include Config::Helpers
+
+      attr_reader :model, :database_id, :dump_path
+
+      ##
+      # If given, +database_id+ will be appended to the #dump_filename.
+      # This is required if multiple Databases of the same class are added to
+      # the model.
+      def initialize(model, database_id = nil)
+        @model = model
+        @database_id = database_id.to_s.gsub(%r{\W}, "_") if database_id
+        @dump_path = File.join(Config.tmp_path, model.trigger, "databases")
+        load_defaults!
+      end
+
+      def perform!
+        log!(:started)
+        prepare!
+      end
+
+      private
+
+      def prepare!
+        FileUtils.mkdir_p(dump_path)
+      end
+
+      ##
+      # Sets the base filename for the final dump file to be saved in
+      # +dump_path+, based on the class name. e.g. databases/MySQL.sql
+      #
+      # +database_id+ will be appended if it is defined.
+      # e.g. databases/MySQL-database_id.sql
+      #
+      # If multiple Databases of the same class are defined and no +database_id+
+      # is defined, the user will be warned and one will be auto-generated.
+      #
+      # Model#initialize calls this method *after* all defined databases have
+      # been initialized so `backup check` can report these warnings.
+      def dump_filename
+        @dump_filename ||=
+          begin
+            unless database_id
+              if model.databases.select { |d| d.class == self.class }.count > 1
+                sleep 1
+                @database_id = Time.now.to_i.to_s[-5, 5]
+                Logger.warn Error.new(<<-EOS)
+                Database Identifier Missing
+                When multiple Databases are configured in a single Backup Model
+                that have the same class (MySQL, PostgreSQL, etc.), the optional
+                +database_id+ must be specified to uniquely identify each instance.
+                e.g. database MySQL, :database_id do |db|
+                This will result in an output file in your final backup package like:
+                databases/MySQL-database_id.sql
+
+                Backup has auto-generated an identifier (#{database_id}) for this
+                database dump and will now continue.
+                EOS
+              end
+            end
+
+            self.class.name.split("::").last +
+              (database_id ? "-#{database_id}" : "")
+          end
+      end
+
+      def database_name
+        @database_name ||= self.class.to_s.sub("Backup::", "") +
+          (database_id ? " (#{database_id})" : "")
+      end
+
+      def log!(action)
+        msg =
+          case action
+          when :started then "Started..."
+          when :finished then "Finished!"
+          end
+        Logger.info "#{database_name} #{msg}"
+      end
+    end
+  end
+end