simple_backup 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 395191b038aacd9796ee4de7eaceeb967cf5d0af
+  data.tar.gz: 5e3e87f048a2d0e56cf3736d66fbec5b20feb45c
+SHA512:
+  metadata.gz: 0d808a36f27b75acd742c449e45d53f87b8ccb56f447cc15a1268794eebe5258b73a581a88f8f1df2f62adf9643f76ca3d8d702b1550425bda3c8bd1eacf6d69
+  data.tar.gz: 5b698daddf93a0356c0c5437b8daf8a51d3df5aca6d5c8b955bd644c98de395ed7d713a98e0b05ff81f6d9ab1d0eba8e4196c2a28576841a5dc721f17748bc7f

data/.gitignore

@@ -0,0 +1,2 @@
+/pkg/
+/Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/backup_example.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'simple_backup'
+
+SimpleBackup.run do
+#  log_level           :debug
+  backup_dir          '/backup'
+  high_usage_treshold 0.9
+  check_disk_path     '/'
+  check_disk_path     '/backup'
+  check_disk_path     '/home/app'
+
+  apps do
+    keep_last 9
+
+    app '/home/app/app-1', type: :capistrano
+    app '/home/app/app-2', type: :bare
+  end
+
+  mysql do
+    keep_last 9
+
+    host 'localhost'
+    port 3306
+    user 'backup'
+    pass 'backup'
+    db   'test1'
+    db   'test2', exclude_tables: ['t_test1']
+  end
+
+  mailer do
+    subject_prefix '[BACKUP]'
+
+    from 'backup@localhost'
+    to   'root@localhost'
+    cc   'root@localhost'
+    bcc  'root@localhost'
+  end
+end

data/lib/simple_backup/dsl.rb

@@ -0,0 +1,121 @@
+module SimpleBackup
+  TIMESTAMP = Time.new.strftime('%Y%m%d%H%M%S')
+  @@status = :failed
+
+  def self.status
+    @@status
+  end
+
+  def self.run(&block)
+    Logger::info "Backup #{TIMESTAMP} started"
+
+    dsl = DSL.new
+
+    Logger::scope_start :info, "Configuration"
+    dsl.instance_eval(&block)
+    dsl.prepare
+    Logger::scope_end
+
+    dsl.run
+    dsl.cleanup
+    @@status = :succeed
+
+    Logger::info "Backup #{TIMESTAMP} finished"
+  rescue StandardError => e
+    self.handle_exception(e)
+  ensure
+    dsl.notify
+    Logger::info "Notifications for backup #{TIMESTAMP} finished"
+  end
+
+  def self.handle_exception(e)
+    Logger::error "#{e.class} => #{e.message}"
+    Logger::error "Backup #{TIMESTAMP} failed"
+    STDERR.puts "Error @ #{Time.new.strftime('%Y-%m-%dT%H:%M:%S')}"
+    STDERR.puts "#{e.inspect}"
+    STDERR.puts e.backtrace
+  end
+
+  class DSL
+    def initialize
+      @storage = Storage.new
+    end
+
+    def prepare
+      if @apps_block
+        @apps = Engine::Apps.new
+        @apps.storage = @storage
+        @apps.instance_eval(&@apps_block)
+      end
+
+      if @mysql_block
+        @mysql = Engine::MySQL.new
+        @mysql.storage = @storage
+        @mysql.instance_eval(&@mysql_block)
+      end
+    end
+
+    def run
+      usage = Utils::Disk::usage
+      Logger::error "Disk high usage treshold exceeded #{usage[:high_usage]}" if usage[:high_usage_exceeded]
+
+      Logger::scope_start :info, "Backup job"
+      @apps.backup if @apps
+      @mysql.backup if @mysql
+      Logger::scope_end
+    end
+
+    def cleanup
+      Logger::scope_start :info, "Cleanup job"
+      @apps.cleanup if @apps
+      @mysql.cleanup if @mysql
+      Logger::scope_end
+    end
+
+    def notify
+      @mailer.send if @mailer
+    rescue StandardError => e
+      SimpleBackup.handle_exception(e)
+    end
+
+    def sources
+      sources = {}
+      sources[:apps] = @apps.sources
+      sources[:mysql] = @mysql.sources
+
+      sources
+    end
+
+    def log_level(level)
+      Logger::level = level
+    end
+
+    def backup_dir(dir)
+      @storage.dir = dir
+    end
+
+    def high_usage_treshold(value)
+      Logger::info "Setting high_usage_treshold to #{value}"
+      Utils::Disk.high_usage_treshold = value
+    end
+
+    def check_disk_path(path)
+      Logger::info "Adding disk path '#{path}' to usage check"
+      Utils::Disk.add_path(path)
+    end
+
+    def apps(&block)
+      @apps_block = block
+    end
+
+    def mysql(&block)
+      @mysql_block = block
+    end
+
+    def mailer(&block)
+      @mailer = Mailer.new(self, @storage)
+      @mailer.instance_eval(&block)
+    end
+  end
+end
+

data/lib/simple_backup/engine/abstract.rb

@@ -0,0 +1,42 @@
+module SimpleBackup
+  module Engine
+    class Abstract
+      @keep_last = 5
+
+      def storage=(storage)
+        @storage = storage.space(self.class.name.split('::').last)
+      end
+
+      def keep_last(value)
+        @keep_last = value.to_i
+        @keep_last = 5 unless @keep_last > 0
+      end
+
+      def cleanup
+        path = @storage.dir.path
+
+        backups = Dir.glob(File.join(path, '**/*.tar.gz')).map do |file|
+          file if file.match(/.*\.tar\.gz/)
+        end.compact.sort
+
+        to_persist = backups
+        to_persist = backups.slice(@keep_last * -1, @keep_last) if backups.length > @keep_last
+        to_remove = backups - to_persist
+
+        to_remove.each do |file|
+          Logger::info "Removing old backup #{file}"
+          FileUtils.rm(file)
+        end
+      end
+
+      def sources
+        raise NotImplementedError
+      end
+
+      def backup
+        raise NotImplementedError
+      end
+    end
+  end
+end
+

data/lib/simple_backup/engine/app_strategy/abstract.rb

@@ -0,0 +1,13 @@
+module SimpleBackup
+  module Engine
+    module AppStrategy
+      class Abstract
+        attr_accessor :storage
+
+        def backup(name, path, attr)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/simple_backup/engine/app_strategy/bare.rb

@@ -0,0 +1,29 @@
+module SimpleBackup
+  module Engine
+    module AppStrategy
+      class Bare < Abstract
+        def backup(name, path, attr)
+          app_elements = get_path_entries(path).map do |p|
+            if p.match(/^\.\.?$/)
+              nil
+            else
+              File.join(path, p)
+            end
+          end.compact
+
+          @storage.backup do |dir|
+            FileUtils.cp_r app_elements, dir
+          end
+        end
+
+        private
+        def get_path_entries(path)
+          Dir.entries(path)
+        rescue Errno::ENOENT
+          Logger::warning "App path does not exists"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/simple_backup/engine/app_strategy/capistrano.rb

@@ -0,0 +1,44 @@
+module SimpleBackup
+  module Engine
+    module AppStrategy
+      class Capistrano < Abstract
+        def backup(name, path, attr)
+          shared = get_shared_path(path, attr)
+          current = get_current_path(path, attr)
+
+          paths = [current, shared].compact
+
+          if paths.empty?
+            Logger::warning "No capistrano paths for application"
+            return false
+          end
+
+          @storage.backup do |dir|
+            FileUtils.cp_r paths, dir
+          end
+
+          true
+        end
+
+        private
+        def get_current_path(path, attr)
+          current = Dir.new(File.join(path, attr[:current] || 'current') + '/')
+          Logger::debug "Capistrano current path: #{current.path}"
+          current
+        rescue Errno::ENOENT
+          Logger::warning "No capistrano current path for application"
+          nil
+        end
+
+        def get_shared_path(path, attr)
+          shared = Dir.new(File.join(path, attr[:shared] || 'shared'))
+          Logger::debug "Capistrano shared path: #{shared.path}"
+          shared
+        rescue Errno::ENOENT
+          Logger::warning "No capistrano shared path for application"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/simple_backup/engine/app_strategy/factory.rb

@@ -0,0 +1,20 @@
+require 'simple_backup/engine/app_strategy/abstract'
+
+module SimpleBackup
+  module Engine
+    module AppStrategy
+      class Factory
+        @@types = [:bare, :capistrano]
+
+        def self.create(type)
+          raise Exception::TypeDoesNotExists.new "Strategy type '#{type}' does not exists" unless @@types.include?(type)
+          file = "simple_backup/engine/app_strategy/#{type.to_s}"
+
+          require file
+          strategy = Object.const_get("SimpleBackup::Engine::AppStrategy::#{type.to_s.capitalize}")
+          strategy.new
+        end
+      end
+    end
+  end
+end

data/lib/simple_backup/engine/apps.rb

@@ -0,0 +1,63 @@
+require 'simple_backup/engine/app_strategy/factory'
+
+module SimpleBackup
+  module Engine
+    class Apps < Abstract
+      def initialize
+        @apps = {}
+        @strategies = {}
+      end
+
+      def app(path, attr = {})
+        Logger::debug "Adding application #{path} #{attr}"
+        raise Exception::AppAlreadyDefined.new "Application '#{path}' is already defined" if @apps.has_key?(path)
+
+        @apps[path] = attr
+      end
+
+      def backup
+        @apps.each do |path, attr|
+          next unless app_exists(path)
+          backup_app(path, attr)
+        end
+      end
+
+      def sources
+        sources = []
+        @apps.each do |path, attr|
+          sources << path
+        end
+
+        sources
+      end
+
+      private
+      def backup_app(path, attr)
+        name = path.split('/').last
+        Logger::scope_start :info, "Backup of application #{name} started"
+        Logger::debug "name: #{name}, attr: #{attr}"
+
+        strategy = get_strategy(attr[:type])
+        strategy.storage = @storage.space(name)
+        is_backuped = strategy.backup(name, path, attr)
+
+        Logger::scope_end :info, "Backup of application #{name} finished" if is_backuped
+        Logger::scope_end :info, "Backup of application #{name} skipped" unless is_backuped
+      end
+
+      def app_exists(path)
+        Dir.new(path)
+        true
+      rescue Errno::ENOENT
+        Logger::warning "App path '#{path}' does not exists"
+        false
+      end
+
+      def get_strategy(type)
+        return @strategies[type] if @strategies.has_key?(type)
+
+        AppStrategy::Factory.create(type)
+      end
+    end
+  end
+end

data/lib/simple_backup/engine/mysql.rb

@@ -0,0 +1,104 @@
+require 'mysql2'
+
+module SimpleBackup
+  module Engine
+    class MySQL < Abstract
+      def initialize
+        @host = 'localhost'
+        @port = 3306
+        @user = nil
+        @pass = nil
+        @dbs = {}
+      end
+
+      def host(host)
+        @host = host
+      end
+
+      def port(port)
+        @port = port
+      end
+
+      def user(user)
+        @user = user
+      end
+
+      def pass(pass)
+        @pass = pass
+      end
+
+      def db(name, attr = {})
+        Logger::debug "Adding database #{name} #{attr}"
+        raise Exception::AppAlreadyDefined.new "Database '#{name}' is already defined" if @dbs.has_key?(name)
+
+        @dbs[name] = attr
+      end
+
+      def backup
+        @conn = Mysql2::Client.new(host: @host, username: @user, password: @pass, port: @port)
+
+        prepare_tables
+        return if @dbs.empty?
+
+        @storage.backup do |dir|
+          @dbs.each do |db, attr|
+            dump_db(dir, db, attr)
+          end
+        end
+      ensure
+        @conn.close unless @conn.nil?
+      end
+
+      def sources
+        sources = []
+        @dbs.each do |db, attr|
+          sources << db
+        end
+
+        sources
+      end
+
+      private
+      def prepare_tables
+        @existing_dbs = []
+        @conn.query("SHOW DATABASES").each do |row|
+          @existing_dbs << row['Database']
+        end
+
+        dbs = {}
+        @dbs.each do |db, attr|
+          dbs[db] = attr if check_database_exists?(db)
+        end
+
+        @dbs = dbs
+        @dbs.each do |db, attr|
+          tables = []
+          @conn.query("SHOW TABLES FROM #{db}").each do |row|
+            tables << row["Tables_in_#{db}"]
+          end
+          tables = tables - attr[:exclude_tables] if attr[:exclude_tables]
+
+          @dbs[db][:tables] ||= tables
+        end
+      end
+
+      def check_database_exists?(db)
+        if @existing_dbs.include?(db)
+          return true
+        end
+        Logger::warning "Database '#{db}' does not exists"
+      end
+
+      def dump_db(dir, db, attr)
+        Logger::scope_start :info, "Backup of mysql database #{db} started"
+
+        file = File.join(dir, db) + '.sql'
+        cmd = "mysqldump --flush-logs --flush-privileges --order-by-primary --complete-insert -C -h #{@host} -u #{@user} -p#{@pass} #{db} #{attr[:tables].join(' ')} > #{file}"
+        Logger::debug "Running command: #{cmd}"
+        `#{cmd}`
+
+        Logger::scope_end :info, "Backup of mysql database #{db} finished"
+      end
+    end
+  end
+end

data/lib/simple_backup/engine.rb

@@ -0,0 +1,3 @@
+require 'simple_backup/engine/abstract'
+require 'simple_backup/engine/apps'
+require 'simple_backup/engine/mysql'

data/lib/simple_backup/exception/app_already_defined.rb

@@ -0,0 +1,6 @@
+module SimpleBackup
+  module Exception
+    class AppAlreadyDefined < Base
+    end
+  end
+end

data/lib/simple_backup/exception/apps_dir_does_not_exists.rb

@@ -0,0 +1,6 @@
+module SimpleBackup
+  module Exception
+    class AppsDirDoesNotExists < Base
+    end
+  end
+end

data/lib/simple_backup/exception/base.rb

@@ -0,0 +1,6 @@
+module SimpleBackup
+  module Exception
+    class Base < ::RuntimeError
+    end
+  end
+end

data/lib/simple_backup/exception/cant_create_dir.rb

@@ -0,0 +1,6 @@
+module SimpleBackup
+  module Exception
+    class CantCreateDir < Base
+    end
+  end
+end

data/lib/simple_backup/exception/type_does_not_exists.rb

@@ -0,0 +1,6 @@
+module SimpleBackup
+  module Exception
+    class TypeDoesNotExists < Base
+    end
+  end
+end

data/lib/simple_backup/exception.rb

@@ -0,0 +1,5 @@
+require 'simple_backup/exception/base'
+require 'simple_backup/exception/apps_dir_does_not_exists'
+require 'simple_backup/exception/app_already_defined'
+require 'simple_backup/exception/cant_create_dir'
+require 'simple_backup/exception/type_does_not_exists'

data/lib/simple_backup/logger.rb

@@ -0,0 +1,84 @@
+require 'colorize'
+
+module SimpleBackup
+  class Logger
+    TIME_FORMAT = '%Y-%m-%dT%H:%M:%S'
+
+    @@buffer = []
+    @@scope = 0
+    @@level = :info
+    @@levels = {
+      debug: {weight: 3, color: :light_cyan},
+      info: {weight: 2, color: :green},
+      warning: {weight: 1, color: :light_yellow},
+      error: {weight: 0, color: :red}
+    }
+
+    banner = "LOG STARTED #{Time.new.strftime('%Y-%m-%dT%H:%M:%S')}"
+    banner2 = "SimpleBackup v#{SimpleBackup::Version::get}"
+
+    banner_length = 0
+    banner_length = banner.length if  banner.length > banner_length
+    banner_length = banner2.length if banner2.length > banner_length
+    banner_length = 80 if 80 > banner_length
+
+    border = '=' * ((banner_length - banner.length) / 2).ceil.to_i
+    @@buffer << "#{border}==[ #{banner} ]==#{border}"
+    border = '=' * ((banner_length - banner2.length) / 2).ceil.to_i
+    @@buffer << "#{border}==[ #{banner2} ]==#{border}"
+    puts @@buffer[0].green
+    puts @@buffer[1].green
+
+    def self.level=(level)
+      self.check_level(level)
+      @@level = level
+    end
+
+    def self.scope_start(level = nil, message = nil)
+      self.log level, message unless level.nil? and message.nil?
+      @@scope += 1
+    end
+
+    def self.scope_end(level = nil, message = nil)
+      self.log level, message unless level.nil? and message.nil?
+      @@scope -= 1
+    end
+
+    def self.debug(message)
+      self.log(:debug, message)
+    end
+
+    def self.info(message)
+      self.log(:info, message)
+    end
+
+    def self.warning(message)
+      self.log(:warning, message)
+    end
+
+    def self.error(message)
+      self.log(:error, message)
+    end
+
+    def self.log(level, message)
+      self.check_level(level)
+
+      color = @@levels[level][:color]
+      should_write = @@levels[level][:weight] <= @@levels[@@level][:weight]
+
+      scope_prefix = '..' * @@scope
+      message = "%s %7s: %s%s" % [Time.new.strftime(TIME_FORMAT), level.to_s.upcase, scope_prefix, message]
+      @@buffer << message
+
+      puts message.colorize(color: color) if should_write
+    end
+
+    def self.check_level(level)
+      raise "Unknown logging level #{level}" unless @@levels.has_key?(level)
+    end
+
+    def self.buffer
+      @@buffer
+    end
+  end
+end

data/lib/simple_backup/mailer.rb

@@ -0,0 +1,138 @@
+require 'mail'
+require 'socket'
+
+module SimpleBackup
+  class Mailer
+    def initialize(dsl, storage)
+      @dsl = dsl
+      @storage = storage
+
+      @to = []
+      @cc = []
+      @bcc = []
+      @hostname = Socket.gethostname
+    end
+
+    def subject_prefix(prefix)
+      @subject_prefix = prefix
+    end
+
+    def from(from)
+      @from = from
+    end
+
+    def to(to)
+      @to << to
+    end
+
+    def cc(cc)
+      @cc << cc
+    end
+
+    def bcc(bcc)
+      @bcc << bcc
+    end
+
+    def send
+      Logger::scope_start :info, "Sending e-mail notification"
+
+      Logger::info "Setting sender to: #{@from}"
+      from = @from
+      Logger::scope_start :info, "Adding recipients:"
+      to = @to
+      to.each do |mail|
+        Logger::info "to: #{mail}"
+      end
+      cc = @cc
+      cc.each do |mail|
+        Logger::info "cc: #{mail}"
+      end
+      bcc = @bcc
+      bcc.each do |mail|
+        Logger::info "bcc: #{mail}"
+      end
+      Logger::scope_end
+
+      @subject_prefix += '[FAILED]' if SimpleBackup.status == :failed
+
+      subject = "%s Backup %s for hostname %s" % [@subject_prefix, TIMESTAMP, @hostname]
+      Logger::debug "Subject: #{subject}"
+
+      body = get_body
+
+      mail = Mail.new do
+        from    from
+        to      to
+        cc      cc
+        bcc     bcc
+        subject subject.strip
+        body    body
+      end
+
+      mail.delivery_method :sendmail
+      Logger::debug "Setting delivery method to sendmail"
+
+      mail.deliver
+      Logger::info "Notification sent"
+
+      Logger::scope_end
+    end
+
+    private
+    def get_body
+      sources = ''
+      @dsl.sources.each do |type, srcs|
+        sources += "+ %s:\n" % type.to_s
+        srcs.each do |src|
+          sources += "  - %s\n" % src
+        end
+      end
+
+      backup_files = ''
+      @storage.created_files.each do |file|
+        backup_files += "- %s\n" % file
+      end
+
+      body = <<MAIL
+Hi,
+
+Backup #{TIMESTAMP} was created!
+
+Backup contains:
+#{sources}
+Created backup files:
+#{backup_files}
+Disk usage after backup:
+#{disk_usage}
+Backup log:
+------------
+#{Logger::buffer.join("\n")}
+------------
+
+Have a nice day,
+  Backuper
+
+-- 
+Mail was send automatically
+Do not respond!
+MAIL
+
+     body
+   end
+
+   def disk_usage
+     content = "%16s %25s %12s %12s %12s  %12s\n" % ['Mount', 'Filesystem', 'Size', 'Used', 'Available', 'Percent used']
+
+     usage = Utils::Disk::usage
+     usage[:mounts].each do |m|
+       percent_usage = (m[:percent] * 100).to_s
+       percent_usage = '(!!) ' + percent_usage if m[:high_usage_exceeded]
+       content += "%16s %25s %8s MiB %8s MiB %8s MiB  %11s%%\n" % [m[:mount], m[:fs], m[:size], m[:used], m[:available], percent_usage]
+     end
+
+     content += "\nHigh usage treshold exceeded!\nMax usage is #{usage[:high_usage]} where treshold is set to #{Utils::Disk::high_usage_treshold}\n" if usage[:high_usage_exceeded]
+
+     content
+   end
+  end
+end

data/lib/simple_backup/storage.rb

@@ -0,0 +1,96 @@
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+module SimpleBackup
+  class Storage
+    attr_accessor :dir
+
+    @@created_files = []
+
+    def dir=(dir)
+      @dir = get_dir(dir)
+
+      Logger::info "Backup dir set to '#{dir}'"
+    end
+
+    def space(space)
+      Logger::debug "Setting backup_dir for space '#{space}'"
+      storage = Storage.new
+      storage.dir = File.join(@dir.path, format_for_path(space))
+      storage
+    end
+
+    def backup
+      dir = get_dir(File.join(@dir, TIMESTAMP))
+      yield(dir)
+
+      targz = targz(dir)
+      backup_file = File.join(@dir, TIMESTAMP) + '.tar.gz'
+
+      File.open(backup_file, 'w') do |f|
+        f.write targz.string
+      end
+
+      FileUtils.rm_r dir.path
+
+      @@created_files.push backup_file
+      backup_file
+    end
+
+    def created_files
+      @@created_files
+    end
+
+    private
+    def get_dir(dir)
+      tries ||= 2
+      Dir.new(dir)
+    rescue Errno::ENOENT
+      recreate_dir(dir)
+      retry unless (tries -= 1).zero?
+    end
+
+    def recreate_dir(dir)
+      Dir.mkdir(dir, 0644)
+
+      Logger::warning "Recreated non-existing directory '#{dir}'"
+    rescue Errno::EACCES => e
+      raise Exception::CantCreateDir.new(e.message)
+    end
+
+    def format_for_path(value)
+      value.downcase.gsub(/[^a-zA-Z0-9\-\_\.]*/, '').gsub(/\s+/, '_')
+    end
+
+    def targz(dir)
+      path = dir.path
+      content = StringIO.new('');
+      Gem::Package::TarWriter.new(content) do |tar|
+        Dir[File.join(path, '**/*')].each do |file|
+          mode = File.stat(file).mode
+          relative_file = file.sub(/^#{Regexp::escape path}\/?/, '')
+
+          if File.directory?(file)
+            tar.mkdir(relative_file, mode)
+          else
+            tar.add_file relative_file, mode do |tf|
+              File.open(file, 'rb') do |f|
+                tf.write f.read
+              end
+            end
+          end
+        end
+      end
+
+      content.rewind
+
+      gz = StringIO.new('')
+      zip = Zlib::GzipWriter.new(gz)
+      zip.write content.string
+      zip.close
+
+      gz
+    end
+  end
+end

data/lib/simple_backup/utils.rb

@@ -0,0 +1,53 @@
+module SimpleBackup
+  module Utils
+    class Disk
+      @@high_usage_treshold = 0.9
+      @@paths = []
+
+      def self.high_usage_treshold=(value)
+        @@high_usage_treshold = value.to_f
+
+        raise ArgumentError.new "Backuper::Utils::Disk::high_usage_treshold must be a float greater than zero" if @@high_usage_treshold <= 0.0
+      end
+
+      def self.high_usage_treshold
+        @@high_usage_treshold
+      end
+
+      def self.add_path(path)
+        @@paths << path unless @@paths.include?(path)
+      end
+
+      def self.usage
+        df = `df -m #{@@paths.join(' ')} 2>/dev/null`.split("\n")
+        df.shift
+
+        max_percent = 0.0;
+        df.map! do |row|
+          row = row.split(' ')
+
+          percent_usage = (row[4].gsub('%', '').to_f / 100).round(2)
+          row = {
+            mount: row[5],
+            fs: row[0],
+            size: row[1],
+            used: row[2],
+            available: row[3],
+            percent: percent_usage,
+            high_usage_exceeded: percent_usage >= @@high_usage_treshold
+          }
+
+          max_percent = row[:percent] if row[:percent] > max_percent
+
+          row
+        end
+
+        {
+          mounts: df.uniq,
+          high_usage_exceeded: max_percent >= @@high_usage_treshold,
+          high_usage: max_percent
+        }
+      end
+    end
+  end
+end

data/lib/simple_backup/version.rb

@@ -0,0 +1,19 @@
+module SimpleBackup
+  class Version
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 0
+    PRE_RELEASE = nil
+
+    def self.get
+      version = "#{MAJOR}.#{MINOR}.#{PATCH}"
+      version += "-#{self.format(PRE_RELEASE)}" unless PRE_RELEASE.nil?
+
+      version
+    end
+
+    def self.format(value)
+      value.gsub(/a-zA-Z0-9\_ /, '').gsub(' ', '_').downcase
+    end
+  end
+end

data/lib/simple_backup.rb

@@ -0,0 +1,11 @@
+require 'simple_backup/utils'
+require 'simple_backup/version'
+require 'simple_backup/logger'
+require 'simple_backup/dsl'
+require 'simple_backup/storage'
+require 'simple_backup/engine'
+require 'simple_backup/mailer'
+require 'simple_backup/exception'
+
+module SimpleBackup
+end

data/simple_backup.gemspec

@@ -0,0 +1,21 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simple_backup/version'
+
+Gem::Specification.new do |spec|
+  spec.name     = 'simple_backup'
+  spec.version  = SimpleBackup::Version::get
+  spec.authors  = ['Tomasz Maczukin']
+  spec.email    = ['tomasz@maczukin.pl']
+  spec.summary  = 'Backup tool with simple DSL for configuration'
+  spec.homepage = 'https://github.com/tmaczukin/simple_backup'
+  spec.license  = 'MIT'
+
+  spec.files            = `git ls-files -z`.split("\x0")
+  spec.require_paths    = ['lib']
+
+  spec.add_development_dependency 'rake',     '~> 10.0'
+  spec.add_dependency             'colorize', '~> 0.7.5'
+  spec.add_dependency             'mail',     '~> 2.6.3'
+  spec.add_dependency             'mysql2',   '~> 0.3.18'
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: simple_backup
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Tomasz Maczukin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.5
+- !ruby/object:Gem::Dependency
+  name: mail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.6.3
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.18
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.18
+description: 
+email:
+- tomasz@maczukin.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Rakefile
+- backup_example.rb
+- lib/simple_backup.rb
+- lib/simple_backup/dsl.rb
+- lib/simple_backup/engine.rb
+- lib/simple_backup/engine/abstract.rb
+- lib/simple_backup/engine/app_strategy/abstract.rb
+- lib/simple_backup/engine/app_strategy/bare.rb
+- lib/simple_backup/engine/app_strategy/capistrano.rb
+- lib/simple_backup/engine/app_strategy/factory.rb
+- lib/simple_backup/engine/apps.rb
+- lib/simple_backup/engine/mysql.rb
+- lib/simple_backup/exception.rb
+- lib/simple_backup/exception/app_already_defined.rb
+- lib/simple_backup/exception/apps_dir_does_not_exists.rb
+- lib/simple_backup/exception/base.rb
+- lib/simple_backup/exception/cant_create_dir.rb
+- lib/simple_backup/exception/type_does_not_exists.rb
+- lib/simple_backup/logger.rb
+- lib/simple_backup/mailer.rb
+- lib/simple_backup/storage.rb
+- lib/simple_backup/utils.rb
+- lib/simple_backup/version.rb
+- simple_backup.gemspec
+homepage: https://github.com/tmaczukin/simple_backup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Backup tool with simple DSL for configuration
+test_files: []