backup 2.4.5.1 → 3.0.0.build.0

data/lib/backup/encryptor/base.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Backup
+  module Encryptor
+    class Base
+      include Backup::CLI
+      include Backup::Configuration::Helpers
+
+      ##
+      # Logs a message to the console and log file to inform
+      # the client that Backup is encrypting the archive
+      def log!
+        Logger.message "#{ self.class } started encrypting the archive."
+      end
+    end
+  end
+end

data/lib/backup/encryptor/gpg.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+##
+# Require the tempfile Ruby library when Backup::Encryptor::GPG is loaded
+require 'tempfile'
+
+module Backup
+  module Encryptor
+    class GPG < Base
+
+      ##
+      # The GPG Public key that'll be used to encrypt the backup
+      attr_accessor :key
+
+      ##
+      # Contains the GPG encryption key id which'll be extracted from the public key file
+      attr_accessor :encryption_key_id
+
+      ##
+      # Contains the temporary file with the public key
+      attr_accessor :tmp_file
+
+      ##
+      # Creates a new instance of Backup::Encryptor::GPG and
+      # sets the key to the provided GPG key. To enhance the DSL
+      # the user may use tabs and spaces to indent the multi-line key string
+      # since we gsub() every preceding 'space' and 'tab' on each line
+      def initialize(&block)
+        load_defaults!
+
+        instance_eval(&block) if block_given?
+
+        @key = key.gsub(/^(\s|\t)+/, '')
+      end
+
+      ##
+      # Performs the encrypting of the backup file and will
+      # remove the unencrypted backup file, as well as the temp file
+      def perform!
+        log!
+        write_tmp_file!
+        extract_encryption_key_id!
+
+        run("#{ utility(:gpg) } #{ options } -o '#{ Backup::Model.file }.gpg' '#{ Backup::Model.file }'")
+
+        rm(Backup::Model.file)
+        tmp_file.unlink
+
+        Backup::Model.extension += '.gpg'
+      end
+
+    private
+
+      ##
+      # GPG options
+      # Sets the gpg mode to 'encrypt' and passes in the encryption_key_id
+      def options
+        "-e --trust-model always -r '#{ encryption_key_id }'"
+      end
+
+      ##
+      # Creates a new temp file and writes the provided public gpg key to it
+      def write_tmp_file!
+        @tmp_file = Tempfile.new('backup.pub')
+        @tmp_file.write(key)
+        @tmp_file.close
+      end
+
+      ##
+      # Extracts the 'encryption key id' from the '@tmp_file'
+      # and stores it in '@encryption_key_id'
+      def extract_encryption_key_id!
+        @encryption_key_id = run("#{ utility(:gpg) } --import '#{tmp_file.path}' 2>&1").match(/<(.+)>/)[1]
+      end
+
+    end
+  end
+end

data/lib/backup/encryptor/open_ssl.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Backup
+  module Encryptor
+    class OpenSSL < Base
+
+      ##
+      # The password that'll be used to encrypt the backup. This
+      # password will be required to decrypt the backup later on.
+      attr_accessor :password
+
+      ##
+      # Determines whether the 'base64' should be used or not
+      attr_writer :base64
+
+      ##
+      # Determines whether the 'salt' flag should be used
+      attr_writer :salt
+
+      ##
+      # Creates a new instance of Backup::Encryptor::OpenSSL and
+      # sets the password attribute to what was provided
+      def initialize(&block)
+        load_defaults!
+
+        @base64 ||= false
+        @salt   ||= false
+
+        instance_eval(&block) if block_given?
+      end
+
+      ##
+      # Performs the encryption of the backup file
+      def perform!
+        log!
+        run("#{ utility(:openssl) } #{ options } -in '#{ Backup::Model.file }' -out '#{ Backup::Model.file }.enc' -k '#{ password }'")
+        rm(Backup::Model.file)
+        Backup::Model.extension += '.enc'
+      end
+
+    private
+
+      ##
+      # Backup::Encryptor::OpenSSL uses the 256bit AES encryption cipher.
+      # 256bit AES is what the US Government uses to encrypt information at the "Top Secret" level.
+      def options
+        (['aes-256-cbc'] + base64 + salt).join("\s")
+      end
+
+      ##
+      # Returns '-a' if @base64 is set to 'true'.
+      # This option will make the encrypted output base64 encoded,
+      # this makes the encrypted file readable using text editors
+      def base64
+        return ['-base64'] if @base64; []
+      end
+
+      ##
+      # Returns '-salt' if @salt is set to 'true'.
+      # This options adds strength to the encryption
+      def salt
+        return ['-salt'] if @salt; []
+      end
+
+    end
+  end
+end

data/lib/backup/finder.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Backup
+  class Finder
+    attr_accessor :trigger, :config
+
+    ##
+    # Initializes a new Backup::Finder object
+    # and stores the path to the configuration file
+    def initialize(trigger, config)
+      @trigger = trigger.to_sym
+      @config  = config
+    end
+
+    ##
+    # Tries to find and load the configuration file and return the proper
+    # backup model configuration (specified by the 'trigger')
+    def find
+      unless File.exist?(config)
+        puts "Could not find a configuration file in '#{config}'."; exit
+      end
+
+      ##
+      # Loads the backup configuration file
+      instance_eval(File.read(config))
+
+      ##
+      # Iterates through all the instantiated backup models and returns
+      # the one that matches the specified 'trigger'
+      Backup::Model.all.each do |model|
+        if model.trigger.eql?(trigger)
+          return Backup::Model.current = model
+        end
+      end
+
+      puts "Could not find trigger '#{trigger}' in '#{config}'."; exit
+    end
+  end
+end

data/lib/backup/logger.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+module Backup
+  class Logger
+
+    ##
+    # Outputs a messages to the console and writes it to the backup.log
+    def self.message(string)
+      puts    loggify(:message, string, :green)
+      to_file loggify(:message, string)
+    end
+
+    ##
+    # Outputs an error to the console and writes it to the backup.log
+    def self.error(string)
+      puts    loggify(:error, string, :red)
+      to_file loggify(:error, string)
+    end
+
+    ##
+    # Outputs a notice to the console and writes it to the backup.log
+    def self.warn(string)
+      puts    loggify(:warning, string, :yellow)
+      to_file loggify(:warning, string)
+    end
+
+    ##
+    # Returns the time in [YYYY/MM/DD HH:MM:SS] format
+    def self.time
+      Time.now.strftime("%Y/%m/%d %H:%M:%S")
+    end
+
+    ##
+    # Builds the string in a log format with the date/time, the type (colorized)
+    # based on whether it's a message, notice or error, and the message itself.
+    # ANSI color codes are only used in the console, and are not written to the log
+    # since it doesn't do anything and just adds more unnecessary bloat to the log file
+    def self.loggify(type, string, color = false)
+      return "[#{time}][#{type}] #{string}" unless color
+      "[#{time}][#{send(color, type)}] #{string}"
+    end
+
+    ##
+    # Writes (appends) a string to the backup.log file
+    def self.to_file(string)
+      File.open(File.join(LOG_PATH, 'backup.log'), 'a') do |file|
+        file.write("#{string}\n")
+      end
+    end
+
+    ##
+    # Invokes the #colorize method with the provided string
+    # and the color code "32" (for green)
+    def self.green(string)
+      colorize(string, 32)
+    end
+
+    ##
+    # Invokes the #colorize method with the provided string
+    # and the color code "33" (for yellow)
+    def self.yellow(string)
+      colorize(string, 33)
+    end
+
+    ##
+    # Invokes the #colorize method the with provided string
+    # and the color code "31" (for red)
+    def self.red(string)
+      colorize(string, 31)
+    end
+
+    ##
+    # Wraps the provided string in colorizing tags to provide
+    # easier to view output to the client
+    def self.colorize(string, code)
+      "\e[#{code}m#{string}\e[0m"
+    end
+
+  end
+end

data/lib/backup/model.rb

@@ -0,0 +1,249 @@
+# encoding: utf-8
+
+module Backup
+  class Model
+    include Backup::CLI
+
+    ##
+    # The trigger is used as an identifier for
+    # initializing the backup process
+    attr_accessor :trigger
+
+    ##
+    # The label is used for a more friendly user output
+    attr_accessor :label
+
+    ##
+    # The databases attribute holds an array of database objects
+    attr_accessor :databases
+
+    ##
+    # The archives attr_accessor holds an array of archive objects
+    attr_accessor :archives
+
+    ##
+    # The encryptors attr_accessor holds an array of encryptor objects
+    attr_accessor :encryptors
+
+    ##
+    # The compressors attr_accessor holds an array of compressor objects
+    attr_accessor :compressors
+
+    ##
+    # The notifiers attr_accessor holds an array of notifier objects
+    attr_accessor :notifiers
+
+    ##
+    # The storages attribute holds an array of storage objects
+    attr_accessor :storages
+
+    ##
+    # The time when the backup initiated (in format: 2011.02.20.03.29.59)
+    attr_accessor :time
+
+    class << self
+      ##
+      # The Backup::Model.all class method keeps track of all the models
+      # that have been instantiated. It returns the @all class variable,
+      # which contains an array of all the models
+      attr_accessor :all
+
+      ##
+      # Contains the current file extension (this changes from time to time after a file
+      # gets compressed or encrypted so we can keep track of the correct file when new
+      # extensions get appended to the current file name)
+      attr_accessor :extension
+
+      ##
+      # Contains the currently-in-use model. This attribute should get set by Backup::Finder.
+      # Use Backup::Model.current to retrieve the actual data of the model
+      attr_accessor :current
+
+      ##
+      # Returns the full path to the current file (including the current extension).
+      # To just return the filename and extension without the path, use File.basename(Backup::Model.file)
+      def file
+        File.join(TMP_PATH, "#{ TIME }.#{ TRIGGER }.#{ Backup::Model.extension }")
+      end
+
+      ##
+      # Returns the temporary trigger path of the current model
+      # e.g. /Users/Michael/tmp/backup/my_trigger
+      def tmp_path
+        File.join(TMP_PATH, TRIGGER)
+      end
+    end
+
+    ##
+    # Accessible through "Backup::Model.all", it stores an array of Backup::Model instances.
+    # Everytime a new Backup::Model gets instantiated it gets pushed into this array
+    @all = Array.new
+
+    ##
+    # Contains the current file extension (should change after each compression or encryption)
+    @extension = 'tar'
+
+    ##
+    # Takes a trigger, label and the configuration block and instantiates the model.
+    # The TIME (time of execution) gets stored in the @time attribute.
+    # After the instance has evaluated the configuration block and properly set the
+    # configuration for the model, it will append the newly created "model" instance
+    # to the @all class variable (Array) so it can be accessed by Backup::Finder
+    # and any other location
+    def initialize(trigger, label, &block)
+      @trigger     = trigger
+      @label       = label
+      @time        = TIME
+
+      @databases   = Array.new
+      @archives    = Array.new
+      @encryptors  = Array.new
+      @compressors = Array.new
+      @storages    = Array.new
+      @notifiers   = Array.new
+
+      instance_eval(&block)
+      Backup::Model.all << self
+    end
+
+    ##
+    # Adds a database to the array of databases
+    # to dump during the backup process
+    def database(database, &block)
+      @databases << Backup::Database.const_get(
+        last_constant(database)
+      ).new(&block)
+    end
+
+    ##
+    # Adds an archive to the array of archives
+    # to store during the backup process
+    def archive(name, &block)
+      @archives << Backup::Archive.new(name, &block)
+    end
+
+    ##
+    # Adds an encryptor to the array of encryptors
+    # to use during the backup process
+    def encrypt_with(name, &block)
+      @encryptors << Backup::Encryptor.const_get(
+        last_constant(name)
+      ).new(&block)
+    end
+
+    ##
+    # Adds a compressor to the array of compressors
+    # to use during the backup process
+    def compress_with(name, &block)
+      @compressors << Backup::Compressor.const_get(
+        last_constant(name)
+      ).new(&block)
+    end
+
+    ##
+    # Adds a notifier to the array of notifiers
+    # to use during the backup process
+    def notify_by(name, &block)
+      @notifiers << Backup::Notifier.const_get(
+        last_constant(name)
+      ).new(&block)
+    end
+
+    ##
+    # Adds a storage method to the array of storage
+    # methods to use during the backup process
+    def store_with(storage, &block)
+      @storages << Backup::Storage.const_get(
+        last_constant(storage)
+      ).new(&block)
+    end
+
+    ##
+    # Performs the backup process
+    ##
+    # [Databases]
+    # Runs all (if any) database objects to dump the databases
+    ##
+    # [Archives]
+    # Runs all (if any) archive objects to package all their
+    # paths in to a single tar file and places it in the backup folder
+    ##
+    # [Package]
+    # After all the database dumps and archives are placed inside
+    # the folder, it'll make a single .tar package (archive) out of it
+    ##
+    # [Encryption]
+    # Optionally encrypts the packaged file with one or more encryptors
+    ##
+    # [Compression]
+    # Optionally compresses the packaged file with one or more compressors
+    ##
+    # [Storages]
+    # Runs all (if any) storage objects to store the backups to remote locations
+    # and (if configured) it'll cycle the files on the remote location to limit the
+    # amount of backups stored on each individual location
+    ##
+    # [Notifiers]
+    # Runs all (if any) notifier objects when a backup proces finished with or without
+    # any errors.
+    ##
+    # [Cleaning]
+    # After the whole backup process finishes, it'll go ahead and remove any temporary
+    # file that it produced. If an exception(error) is raised during this process which
+    # breaks the process, it'll always ensure it removes the temporary files regardless
+    # to avoid mass consumption of storage space on the machine
+    def perform!
+      begin
+        databases.each   { |d| d.perform! }
+        archives.each    { |a| a.perform! }
+        package!
+        encryptors.each  { |e| e.perform! }
+        compressors.each { |c| c.perform! }
+        storages.each    { |s| s.perform! }
+        notifiers.each   { |n| n.perform!(self) }
+        clean!
+      rescue Exception => exception
+        clean!
+        notifiers.each   { |n| n.perform!(self, exception) }
+        show_exception!(exception)
+      end
+    end
+
+  private
+
+    ##
+    # After all the databases and archives have been dumped and sorted,
+    # these files will be bundled in to a .tar archive (uncompressed) so it
+    # becomes a single (transferrable) packaged file.
+    def package!
+      Logger.message "Backup started packaging everything to a single archive file."
+      run("#{ utility(:tar) } -c -C '#{ TMP_PATH }' '#{ TRIGGER }' > '#{ File.join(TMP_PATH, "#{TIME}.#{TRIGGER}.tar") }'")
+    end
+
+    ##
+    # Cleans up the temporary files that were created after the backup process finishes
+    def clean!
+      Logger.message "Backup started cleaning up the temporary files."
+      run("#{ utility(:rm) } -rf '#{ File.join(TMP_PATH, TRIGGER) }' '#{ File.join(TMP_PATH, "#{TIME}.#{TRIGGER}.#{Backup::Model.extension}") }'")
+    end
+
+    ##
+    # Returns the string representation of the last value of a nested constant
+    # example:
+    #  Backup::Model::MySQL
+    # becomes and returns:
+    #  "MySQL"
+    def last_constant(constant)
+      constant.to_s.split("::").last
+    end
+
+    ##
+    # Formats an exception
+    def show_exception!(exception)
+      puts ("=" * 75) + "\nException that got raised:\n#{exception}\n" + ("=" * 75) + "\n" + exception.backtrace.join("\n")
+      puts ("=" * 75) + "\n\nYou are running Backup version \"#{Backup::Version.current}\" and Ruby version \"#{ENV['RUBY_VERSION']}\".\n"
+      puts "If you've setup a \"Notification\" in your configuration file, the above error will have been sent."
+    end
+
+  end
+end