backup-agent 1.0.9 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 097cb7442ca1df2a35da304073f1f8eb27a1fc4b
-  data.tar.gz: b4f5c9696a060679a9791fc7ae0925b4b998833a
+  metadata.gz: 4f391904e3b281dd04dc9b8f5983c56a9da2f387
+  data.tar.gz: 774815f802892ee300d8e5dc87e34f3f7fe8bfee
 SHA512:
-  metadata.gz: 9e2554db02299bc6cc2bf813e8cf1e4b0bf49901860d01f52667e6b173787fd8ef3e376043688977add913e2796ec12e1ad217f76c33119084864190d533ffad
-  data.tar.gz: bbf52beb7a833e7fe33d47778f6fc84d6b3cf70a6fad797e6727364176e627ab9a5ef8fc1ff07563d081db72fa6bc9c6d673c5e0a7ef420d4920812377094585
+  metadata.gz: d8dbb5c1a4593f3dfd7b928a655a7c13f8c4b6ad9a60a3b40838e1af04583b034305d90ffbc2434ae6eaecb793c2e252998d3ffd311d7975d8ee2a994887a446
+  data.tar.gz: aeef30268dae8a1955d4045e8a195a20efa31c4fb70cfeacc68770d06f0c1feeb3ac9bd4bbc89b6b67787a1ea34de0593dca44181455039be4f463e782488369

data/{LICENSE.txt → LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2015 Yaroslav Konoplov
+Copyright (c) 2015, 2016, 2017 Yaroslav Konoplov
 
 MIT License
 

data/README.md

@@ -1,20 +1,4 @@
-```ruby
-require 'backup-agent'
-
-storage_config = Backup::S3Config.new do
-  set :access_key_id, 'xxx'
-  set :secret_access_key, 'yyy'
-  set :region, 'eu-central-1'
-end
-
-storage = Backup::S3Storage.new(storage_config, bucket: 'my-backups')
-
-Backup.perform storage do
-  set :mysql_host, 'xxx.yyy.xxx.yyy'
-end
-```
-
-## Gemfile
-```ruby
-gem 'backup-agent'
-```
+### TODO:
+* Update description in gemspec
+* Add ability to specify name with slashes in directory backup task
+* Release v2.1

data/backup-agent.gemspec

@@ -1,21 +1,23 @@
-# encoding: utf-8
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require File.expand_path("../lib/backup-agent/version", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name            = 'backup-agent'
-  s.version         = '1.0.9'
-  s.authors         = ['Yaroslav Konoplov']
-  s.email           = ['yaroslav@inbox.com']
-  s.summary         = 'Easy AWS S3 backup'
-  s.description     = 'Easy AWS S3 backup'
-  s.homepage        = 'http://github.com/yivo/backup-agent'
-  s.license         = 'MIT'
+  s.name            = "backup-agent"
+  s.version         = Backup::VERSION
+  s.authors         = ["Yaroslav Konoplov"]
+  s.email           = ["eahome00@gmail.com"]
+  s.summary         = "Easy AWS S3 backup"
+  s.description     = "Easy AWS S3 backup"
+  s.homepage        = "http://github.com/yivo/backup-agent"
+  s.license         = "MIT"
 
-  s.executables     = `git ls-files -z -- bin/*`.split("\x0").map{ |f| File.basename(f) }
   s.files           = `git ls-files -z`.split("\x0")
   s.test_files      = `git ls-files -z -- {test,spec,features}/*`.split("\x0")
-  s.require_paths   = ['lib']
+  s.require_paths   = ["lib"]
 
-  s.add_dependency 'aws-sdk'
-  s.add_dependency 'confo-config', '>= 1.0.0'
-  s.add_dependency 'activesupport', '>= 3.2.0'
+  s.add_dependency "aws-sdk",                "~> 2"
+  s.add_dependency "activesupport",          ">= 3.0", "< 6.0"
+  s.add_dependency "method-not-implemented", "~> 1.0"
 end

data/lib/backup-agent.rb

@@ -1,19 +1,34 @@
-puts "Ruby version #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+# encoding: UTF-8
+# frozen_string_literal: true
 
-%w( rubygems aws-sdk fileutils confo-config shellwords ).each { |el| require(el) }
+require "fileutils"
+require "tempfile"
+require "shellwords"
+require "open3"
+require "singleton"
+require "aws-sdk"
+require "method-not-implemented"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/filters"
+require "active_support/core_ext/string/multibyte"
+require "active_support/core_ext/numeric/time"
 
-%w( abstract_storage abstract_storage_config abstract_storage_object
-   s3_storage s3_config s3_object
-   features task performer ).each { |el| require_relative("backup-agent/#{el}") }
+["ruby", "tar", "gzip", "xz", "mysql", "mysqldump"].each do |x|
+  puts Open3.capture3(x, "--version")[0...2].map(&:squish).reject(&:blank?).join(' ')
+end
 
-module Backup
-  class << self
-    def perform(storage, &block)
-      Performer.new.perform_backup(storage, Task.new(&block))
-    end
+$LOAD_PATH << __dir__ unless $LOAD_PATH.include?(__dir__)
 
-    def features
-      @features ||= Features.new
-    end
-  end
-end
+require "backup-agent/dsl"
+require "backup-agent/credentials"
+require "backup-agent/performer"
+
+require "backup-agent/storages"
+require "backup-agent/storages/base"
+require "backup-agent/storages/local"
+require "backup-agent/storages/amazon-s3"
+
+require "backup-agent/tasks/directory"
+require "backup-agent/tasks/mysql"
+
+include Backup::DSL

data/lib/backup-agent/credentials.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Backup
+  class Credentials
+    include Singleton
+
+    def initialize
+      @groups = {}
+    end
+
+    # Usage: credentials(type: :name)
+    def [](pair)
+      @groups.fetch(pair.keys[0]).fetch(pair.values[0])
+    end
+
+    # define Class => [:type, :name, arguments...]
+    def define(definitions)
+      definitions.map do |klass, definition|
+        (@groups[definition[0]] ||= {})[definition[1]] = klass.new(*definition.drop(2))
+      end
+    end
+
+    def mysql(definitions)
+      definitions.map do |name, args|
+        define Backup::Tasks::MySQL::Credentials => [:mysql, name, *[args].flatten(1)]
+      end.flatten(1)
+    end
+
+    def amazon_s3(definitions)
+      definitions.map do |name, args|
+        define Backup::Storages::AmazonS3::Credentials => [:amazon_s3, name, *[args].flatten(1)]
+      end.flatten(1)
+    end
+  end
+end

data/lib/backup-agent/dsl.rb

@@ -0,0 +1,104 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Backup
+  module DSL
+    def echo(*args)
+      puts(*args)
+    end
+
+    def with(environment)
+      @current_command_environment = environment&.each_with_object({}) { |(k, v), m| m[k.to_s] = v.to_s }
+      yield
+    ensure
+      remove_instance_variable(:@current_command_environment)
+    end
+
+    def stdin(data, binmode: false)
+      @current_command_stdin_data         = data
+      @current_command_stdin_data_binmode = binmode
+      yield
+    ensure
+      remove_instance_variable(:@current_command_stdin_data)
+      remove_instance_variable(:@current_command_stdin_data_binmode)
+    end
+
+    def command(*args)
+      returned, msec = measure args.map(&:to_s).join(" ") do
+
+        if instance_variable_defined?(:@current_command_environment) && @current_command_environment
+          args.unshift(@current_command_environment)
+        end
+
+        stdout, stderr, exit_status = \
+          if instance_variable_defined?(:@current_command_stdin_data)
+            Open3.capture3 *args, \
+              stdin_data: @current_command_stdin_data,
+              binmode:    @current_command_stdin_data_binmode
+          else
+            Open3.capture3(*args)
+          end
+
+        fail stderr unless exit_status.success?
+        # echo stdout
+        stdout
+      end
+      returned
+    end
+
+    def measure(action)
+      echo "\n", action
+      started  = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      returned = yield
+      finished = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      echo "(#{ (finished - started).round(1) }ms)", "\n"
+      returned
+    end
+
+    def construct_filename(basename, extension_with_dot = nil)
+      [basename.gsub(/[^[[:alnum:]]]/i, "-")
+               .gsub(/[-–—]+/, "-")
+               .mb_chars.downcase.to_s,
+       "--#{Time.now.getutc.strftime("%Y-%m-%d--%H-%M-%S--UTC")}",
+       extension_with_dot.to_s.mb_chars.downcase.to_s].join("")
+    end
+
+    def storages(pair = nil, &block)
+      if pair
+        Backup::Storages.instance[pair]
+      elsif block
+        Backup::Storages.instance.instance_exec(&block)
+      else
+        Backup::Storages.instance
+      end
+    end
+
+    def credentials(pair = nil, &block)
+      if pair
+        Backup::Credentials.instance[pair]
+      elsif block
+        Backup::Credentials.instance.instance_exec(&block)
+      else
+        Backup::Credentials.instance
+      end
+    end
+
+    def backup(to:, &block)
+      storages = [to].flatten.map { |h| h.map { |k, v| self.storages(k => v) } }.flatten
+      Backup::Performer.new(storages).tap { |performer| performer.instance_eval(&block) }
+    end
+
+    def delete_backups_older_than(x)
+      cutoff_timestamp = Time.now.utc.to_i - x
+      storages.each do |storage|
+        storage.each do |object|
+          if object.last_modified.to_i < cutoff_timestamp
+            puts "Delete #{object.to_s} from #{storage.to_s}"
+            storage.delete(object.id)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/backup-agent/performer.rb

@@ -1,119 +1,29 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 module Backup
   class Performer
-    attr_reader :storage, :config
-
-    def perform_backup(storage, config)
-      @storage = storage
-      @config = config
-      @started_at = Time.now.utc
-      @timestamp = @started_at.strftime('%s - %A %d %B %Y %H:%M')
-      storage.open
-      make_tmp_dir
-      backup_mysql if Backup.features.mysql_installed?
-      backup_mongodb if Backup.features.mongodb_installed?
-      backup_directories
-      backup_files
-      cleanup_old_backups
-    ensure
-      remove_tmp_dir
-      storage.close
-    end
-
-  protected
-
-    def backup_directories
-      config.get(:directories).each do |name, dir|
-        dir_filename  = "#{name}.tar.xz"
-        dir_fileparam = Shellwords.escape(dir_filename)
-        cmd = "cd #{dir} && /usr/bin/env XZ_OPT=-9 tar -cJvf #{tmp_path}/#{dir_fileparam} ."
-        puts "Exec #{cmd}"
-        system(cmd)
-        storage.upload("#{@timestamp}/#{dir_filename}", "#{tmp_path}/#{dir_filename}")
-      end
-    end
-
-    def backup_files
-      config.get(:files).each do |name, files|
-        begin
-          files_tmp_path   = File.join(tmp_path, "#{name}-tmp")
-          file_bunch_name  = "#{name}.tar.xz"
-          file_bunch_param = Shellwords.escape(file_bunch_name)
-
-          FileUtils.mkdir_p(files_tmp_path)
-          FileUtils.cp(files.select { |el| File.exists?(el) }, files_tmp_path)
-
-          cmd = "cd #{files_tmp_path} && /usr/bin/env XZ_OPT=-3 tar -cJvf #{tmp_path}/#{file_bunch_param} ."
-          system(cmd)
-
-          storage.upload("#{@timestamp}/#{file_bunch_name}", "#{tmp_path}/#{file_bunch_name}")
-        ensure
-          FileUtils.remove_dir(files_tmp_path)
-        end
-      end
-    end
-
-    def backup_mysql
-      config.get(:mysql_databases).each do |db|
-        dump_path = "#{tmp_path}/#{ shell_escape(db) }.sql"
-        dump_cmd  = "mysqldump #{config.get(:mysql_connect)} #{config.get(:mysqldump_options).join(' ')} --databases #{db}"
-
-        exec with_env("#{dump_cmd} > #{dump_path}")
-        exec with_env("xz --compress -9 --keep --threads=0 --verbose #{dump_path}")
-
-        storage.upload("#{@timestamp}/#{ shell_escape(db) }.sql.xz", "#{dump_path}.xz")
-      end
+    def initialize(storages)
+      @storages = storages
     end
 
-    def backup_mongodb
-      mongo_dump_dir = File.join(tmp_path, 'mongo')
-      FileUtils.mkdir_p(mongo_dump_dir)
-
-      config.get(:mongo_databases).each do |db|
-        db_filename  = "Mongo Database #{db}.tar.xz"
-        db_fileparam = Shellwords.escape(db_filename)
-        dump = with_env "mongodump #{config.get(:mongo_connect)} -d #{db} -o #{mongo_dump_dir}"
-        cd   = "cd #{mongo_dump_dir}/#{db}"
-        tar  = with_env "XZ_OPT=-9 tar -cJvf #{tmp_path}/#{db_fileparam} ."
-
-        puts "Exec #{dump} && #{cd} && #{tar}"
-        system "#{dump} && #{cd} && #{tar}"
-
-        storage.upload("#{@timestamp}/#{db_filename}", "#{tmp_path}/#{db_filename}")
+    # task Task => [:foo, :bar, :baz]
+    def task(arg)
+      arg.each do |klass, args|
+        @storages.each { |storage| klass.new(*args).perform(storage) }
       end
-    ensure
-      FileUtils.remove_dir(mongo_dump_dir)
+      nil
     end
 
-    def cleanup_old_backups
-      cutoff_date = Time.now.utc.to_i - (config.get(:days_to_keep_backups) * 86400)
-      storage.each do |obj|
-        obj.delete if obj.last_modified.to_i < cutoff_date
+    def mysql(options)
+      if Symbol === options[:credentials]
+        options[:credentials] = credentials(mysql: options[:credentials])
       end
+      task Backup::Tasks::MySQL => [options]
     end
 
-    def make_tmp_dir
-      FileUtils.mkdir_p(tmp_path)
-    end
-
-    def remove_tmp_dir
-      FileUtils.remove_dir(tmp_path)
-    end
-
-    def tmp_path
-      "/tmp/backup-agent-#{@started_at.strftime('%d-%m-%Y-%H:%M')}"
-    end
-
-    def with_env(cmd)
-      "/usr/bin/env #{cmd}"
-    end
-
-    def shell_escape(x)
-      Shellwords.escape(x)
-    end
-
-    def exec(cmd)
-      puts "Exec #{cmd}"
-      system cmd
+    def directory(path, options = {})
+      task Backup::Tasks::Directory => [path, options]
     end
   end
 end

data/lib/backup-agent/storages.rb

@@ -0,0 +1,42 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Backup
+  class Storages
+    include Singleton
+    include Enumerable
+
+    def initialize
+      @groups = {}
+    end
+
+    def [](pair)
+      @groups.fetch(pair.keys[0]).fetch(pair.values[0])
+    end
+
+    def each
+      @groups.each do |type, storages|
+        storages.each { |name, storage| yield storage, type, name }
+      end
+    end
+
+    # register AmazonS3 => [:amazon_s3, :default, storage constructor arguments...]
+    def register(arg)
+      arg.map do |klass, rest|
+        (@groups[rest[0]] ||= {})[rest[1]] = klass.new(*rest.drop(2))
+      end
+    end
+
+    def local(definitions)
+      definitions.map do |name, args|
+        register Backup::Storages::Local => [:local, name, *[args].flatten(1)]
+      end.flatten(1)
+    end
+
+    def amazon_s3(definitions)
+      definitions.map do |name, options|
+        register Backup::Storages::AmazonS3 => [:amazon_s3, name, options.merge(credentials: credentials[amazon_s3: name])]
+      end.flatten(1)
+    end
+  end
+end

data/lib/backup-agent/storages/amazon-s3.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+#
+# Storage based on Amazon S3
+#
+class Backup::Storages
+  class AmazonS3 < Backup::Storages::Base
+    def initialize(region:, bucket:, credentials:)
+      @aws_s3_ruby_credentials = Aws::Credentials.new(credentials.access_key_id, credentials.secret_access_key)
+      @aws_s3_ruby_resource    = Aws::S3::Resource.new(region: region, credentials: @aws_s3_ruby_credentials)
+      @aws_s3_ruby_bucket      = @aws_s3_ruby_resource.bucket(bucket)
+    end
+
+    def store(id, file_to_upload)
+      aws_s3_ruby_object = @aws_s3_ruby_bucket.object(id)
+      aws_s3_ruby_object.upload_file(file_to_upload)
+      Backup::Storages::AmazonS3::Object.new(self, @aws_s3_ruby_bucket, aws_s3_ruby_object.key)
+    end
+
+    def delete(id)
+      @aws_s3_ruby_bucket.object(id).delete
+    end
+
+    def each
+      @aws_s3_ruby_bucket.objects.each do |aws_s3_ruby_object|
+        yield Backup::Storages::AmazonS3::Object.new(self, @aws_s3_ruby_bucket, aws_s3_ruby_object.key)
+      end
+    end
+
+    class Credentials
+      attr_reader :access_key_id, :secret_access_key
+
+      def initialize(access_key_id:, secret_access_key:)
+        @access_key_id     = access_key_id
+        @secret_access_key = secret_access_key
+      end
+    end
+
+    class Object < Backup::Storages::Base::Object
+      def initialize(storage, aws_s3_ruby_bucket, id)
+        super(storage, id)
+        @aws_s3_ruby_bucket = aws_s3_ruby_bucket
+      end
+
+      def last_modified
+        @aws_s3_ruby_bucket.object(id).last_modified.utc
+      end
+    end
+  end
+end

data/lib/backup-agent/storages/base.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+#
+# Base stuff for storages
+#
+class Backup::Storages
+  class Base
+    def store(id, path)
+      method_not_implemented
+    end
+
+    def delete(id)
+      method_not_implemented
+    end
+
+    def each
+      method_not_implemented
+    end
+
+    class Object
+      attr_reader :storage, :id
+
+      def initialize(storage, id)
+        @storage = storage
+        @id      = id
+      end
+
+      def last_modified
+        method_not_implemented
+      end
+
+      def to_s
+        id
+      end
+    end
+  end
+end

data/lib/backup-agent/storages/local.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+#
+# Storage based on some directory in local filesystem
+#
+class Backup::Storages
+  class Local < Backup::Storages::Base
+    attr_reader :directory
+
+    def initialize(directory:)
+      @directory = directory.gsub(/\/*\z/, "") # Ensure trailing slash
+    end
+
+    def store(relative_path, file_to_write)
+      FileUtils.mkdir_p(directory)
+      FileUtils.cp_r(file_to_write, File.join(directory, relative_path))
+      Backup::Storages::Local::Object.new(self, relative_path)
+    end
+
+    def delete(relative_path)
+      FileUtils.rm_f(File.join(directory, relative_path))
+    end
+
+    def each
+      Dir.glob File.join(directory, "**", "*") do |path|
+        yield Backup::Storages::Local::Object.new(self, path[directory.size+1..-1])
+      end
+    end
+
+    class Object < Backup::Storages::Base::Object
+      def last_modified
+        File.mtime(File.join(storage.directory, id)).utc
+      end
+    end
+  end
+end

data/lib/backup-agent/tasks/directory.rb

@@ -0,0 +1,61 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Backup::Tasks
+  class Directory
+    def initialize(path, options = {})
+      @path    = path
+      # @name    = options.fetch(:name)
+      @options = options
+
+      if options[:compressor]
+        @compressor = Symbol === options[:compressor] ? { type: options[:compressor] } : options[:compressor]
+      end
+    end
+
+    def perform(storage)
+      return if !File.readable?(@path) || !File.directory?(@path)
+
+      @options.fetch(:name, @path).tap do |x|
+        @filename = add_extension(construct_filename(File.basename(x, ".*")) + File.extname(x))
+      end
+
+      Tempfile.open do |tempfile|
+        with compression_environment do
+          command "tar", tar_flags, tempfile.path, "-C", @path, "."
+        end
+        storage.store(@filename, tempfile.path)
+      end
+    end
+
+    def compression_environment
+      case @compressor&.fetch(:type)
+        when :xz   then { XZ_OPT: "-#{@compressor.fetch(:level, 3)}" }
+        when :gzip then { GZIP:   "-#{@compressor.fetch(:level, 3)}" }
+      end
+    end
+
+    def tar_flags
+      flags = ["c"]
+
+      flags << "h" if @options.fetch(:symlinks, :follow) == :follow
+
+      case @compressor&.fetch(:type)
+        when :xz   then flags << "J"
+        when :gzip then flags << "z"
+      end
+
+      flags << "v"
+      flags << "f"
+      flags.join("")
+    end
+
+    def add_extension(name)
+      case @compressor&.fetch(:type)
+        when :xz   then name + ".tar.xz"
+        when :gzip then name + ".tar.gz"
+        else            name + ".tar"
+      end
+    end
+  end
+end

data/lib/backup-agent/tasks/mysql.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Backup::Tasks
+  class MySQL
+    attr_reader :host, :credentials, :options
+
+    def initialize(host:, credentials:, databases: :all, **options)
+      @host        = host
+      @credentials = credentials
+      @databases   = databases
+      @options     = options
+    end
+
+    def perform(storage)
+      databases.map do |db|
+        Tempfile.open do |tempfile|
+          command("mysqldump", *credentials.to_options, *host_options, *dump_options, "--databases", db).tap do |dump_sql|
+            stdin dump_sql do
+              command("xz", "--compress", "-9", "--format=xz", "--keep", "--threads=0", "--verbose", "--check=sha256").tap do |dump_xz|
+                tempfile.write(dump_xz)
+                storage.store(construct_filename(db, ".sql.xz"), tempfile.path)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def databases
+      if @databases == :all
+        command("mysql", *credentials.to_options, *host_options, "-e", "SHOW DATABASES;")
+            .split("\n")
+            .reject { |el| el =~ /database|information_schema|mysql|performance_schema|test|phpmyadmin|pma|sys/i }
+      else
+        [@databases].flatten.compact
+      end
+    end
+
+    def dump_options
+      @options.fetch(:dump_options) do
+        %W( --add-drop-table
+            --add-locks
+            --allow-keywords
+            --comments
+            --complete-insert
+            --create-options
+            --disable-keys
+            --extended-insert
+            --lock-tables
+            --quick
+            --quote-names
+            --routines
+            --set-charset
+            --dump-date
+            --tz-utc
+            --verbose )
+      end
+    end
+
+    def host_options
+      ["--host=#{@host}"]
+    end
+
+    class Credentials
+      def initialize(user:, password:)
+        @user     = user
+        @password = password
+      end
+
+      def stringify
+        "--user #{@user} #{stringify_password}"
+      end
+
+      def stringify_password
+        @password.nil? || @password.empty? ? "" : "--password=#{@password}"
+      end
+
+      def to_options
+        ["--user", @user, stringify_password]
+      end
+    end
+  end
+end

data/lib/backup-agent/version.rb

@@ -0,0 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Backup
+  VERSION = "2.0.0"
+end

data/test.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require File.expand_path('../lib/backup-agent', __FILE__)
+
+credentials do
+  mysql     localhost: { user: 'root', password: 'root' }
+  amazon_s3 default: { access_key_id: 'AKIAIJDU5HT7XT6HRINA', secret_access_key: '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' }
+end
+
+storages do
+  amazon_s3 default: { region: 'eu-central-1', bucket: 'perseidev-backups' }
+end
+
+backup to: { amazon_s3: :default, local: :default } do
+  mysql host: '127.0.0.1', credentials: :localhost, databases: :all
+  Dir['/var/www/*/current/public'].each { |dir| directory dir }
+end
+
+delete_backups_older_than 30.days

metadata

@@ -1,80 +1,86 @@
 --- !ruby/object:Gem::Specification
 name: backup-agent
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 2.0.0
 platform: ruby
 authors:
 - Yaroslav Konoplov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-29 00:00:00.000000000 Z
+date: 2017-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
-  name: confo-config
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: method-not-implemented
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '1.0'
 description: Easy AWS S3 backup
 email:
-- yaroslav@inbox.com
+- eahome00@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
-- Rakefile
 - backup-agent.gemspec
 - lib/backup-agent.rb
-- lib/backup-agent/abstract_storage.rb
-- lib/backup-agent/abstract_storage_config.rb
-- lib/backup-agent/abstract_storage_object.rb
-- lib/backup-agent/features.rb
+- lib/backup-agent/credentials.rb
+- lib/backup-agent/dsl.rb
 - lib/backup-agent/performer.rb
-- lib/backup-agent/s3_config.rb
-- lib/backup-agent/s3_object.rb
-- lib/backup-agent/s3_storage.rb
-- lib/backup-agent/task.rb
+- lib/backup-agent/storages.rb
+- lib/backup-agent/storages/amazon-s3.rb
+- lib/backup-agent/storages/base.rb
+- lib/backup-agent/storages/local.rb
+- lib/backup-agent/tasks/directory.rb
+- lib/backup-agent/tasks/mysql.rb
+- lib/backup-agent/version.rb
+- test.rb
 homepage: http://github.com/yivo/backup-agent
 licenses:
 - MIT
@@ -95,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Easy AWS S3 backup

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in confo.gemspec
-gemspec

data/Rakefile

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

data/lib/backup-agent/abstract_storage.rb

@@ -1,32 +0,0 @@
-module Backup
-  class AbstractStorage
-    include Enumerable
-
-    attr_reader :config, :env
-
-    def initialize(config, env = {})
-      @config = config
-      @env    = env
-    end
-
-    def open
-
-    end
-
-    def close
-
-    end
-
-    def upload(key, path)
-
-    end
-
-    def delete(key)
-
-    end
-
-    def each
-
-    end
-  end
-end

data/lib/backup-agent/abstract_storage_config.rb

@@ -1,5 +0,0 @@
-module Backup
-  class AbstractStorageConfig < Confo::Config
-
-  end
-end

data/lib/backup-agent/abstract_storage_object.rb

@@ -1,19 +0,0 @@
-module Backup
-  class AbstractStorageObject
-    attr_reader :storage, :key, :env
-
-    def initialize(storage, key, env = {})
-      @storage = storage
-      @key     = key
-      @env     = env
-    end
-
-    def last_modified
-
-    end
-
-    def delete
-
-    end
-  end
-end

data/lib/backup-agent/features.rb

@@ -1,30 +0,0 @@
-module Backup
-  class Features
-    def initialize
-      check_mysql
-      check_mongodb
-    end
-
-    def check_mysql
-      if @mysql_check.nil?
-        @mysql_check = system('/usr/bin/env mysql --version') ? true : (puts('MySQL is not installed'); false)
-      end
-      @mysql_check
-    end
-
-    def check_mongodb
-      if @mongodb_check.nil?
-        @mongodb_check = system('/usr/bin/env mongod --version') ? true : (puts('MongoDB is not installed'))
-      end
-      @mongodb_check
-    end
-
-    def mysql_installed?
-      !!@mysql_check
-    end
-
-    def mongodb_installed?
-      !!@mongodb_check
-    end
-  end
-end

data/lib/backup-agent/s3_config.rb

@@ -1,11 +0,0 @@
-module Backup
-  class S3Config < AbstractStorageConfig
-    def initialize(*)
-      set :access_key_id, nil
-      set :secret_access_key, nil
-      set :region, nil
-      set :bucket, nil
-      super
-    end
-  end
-end

data/lib/backup-agent/s3_object.rb

@@ -1,17 +0,0 @@
-module Backup
-  class S3Object < AbstractStorageObject
-    def initialize(*)
-      super
-      @object = env.fetch(:object)
-      @bucket = env.fetch(:bucket)
-    end
-
-    def last_modified
-      @object.last_modified
-    end
-
-    def delete
-      storage.delete(key)
-    end
-  end
-end

data/lib/backup-agent/s3_storage.rb

@@ -1,45 +0,0 @@
-module Backup
-  class S3Storage < AbstractStorage
-
-    def initialize(*)
-      super
-      @bucket_name = env.fetch(:bucket)
-    end
-
-    def s3
-      @s3 ||= begin
-        Aws.config.update(
-          region: config.region,
-          credentials: Aws::Credentials.new(config.access_key_id, config.secret_access_key)
-        )
-        Aws::S3::Resource.new
-      end
-    end
-
-    def bucket
-      s3.bucket(@bucket_name)
-    end
-
-    def open
-      s3
-    end
-
-    def upload(key, path)
-      bucket.object(key).upload_file(path)
-    end
-
-    def delete(key)
-      bucket.object(key).delete
-    end
-
-    def object(key)
-      S3Object.new(self, key, object: bucket.object(key), bucket: bucket)
-    end
-
-    def each
-      bucket.objects.each do |s3_obj|
-        yield S3Object.new(self, s3_obj.key, object: s3_obj, bucket: bucket)
-      end
-    end
-  end
-end

data/lib/backup-agent/task.rb

@@ -1,66 +0,0 @@
-module Backup
-  class Task < Confo::Config
-    def initialize(*)
-      set :mysql_user, 'root'
-      set :mysql_password, 'root'
-      set :mysql_host, 'localhost'
-      set :mysql_databases, -> do
-        `/usr/bin/env mysql #{get(:mysql_connect)} -e "SHOW DATABASES;"`
-          .split("\n")
-          .reject { |el| el =~ /Database|information_schema|mysql|performance_schema|test|phpmyadmin/ }
-      end
-
-      set :mysqldump_options, %w(
-        --add-drop-database
-        --add-drop-table
-        --add-locks
-        --allow-keywords
-        --comments
-        --complete-insert
-        --create-options
-        --debug-check
-        --debug-info
-        --extended-insert
-        --flush-privileges
-        --insert-ignore
-        --lock-tables
-        --quick
-        --quote-names
-        --set-charset
-        --dump-date
-        --secure-auth
-        --tz-utc
-        --disable-keys )
-
-      set :mysql_connect, -> do
-        pass       = get(:mysql_password)
-        pass_param = pass && !pass.empty? ? "--password=#{pass}" : ''
-        "--user #{get(:mysql_user)} #{pass_param} --host=#{get(:mysql_host)}"
-      end
-
-      set :mongo_databases, -> do
-        if `/usr/bin/env mongo --eval "db.getMongo().getDBNames()"` =~ /connecting to: (.*)/m
-          $1.split(/[\n,]/).reject(&:empty?)
-        else
-          []
-        end
-      end
-
-      set :mongo_host, 'localhost'
-      set :mongo_connect, -> { "-h #{get(:mongo_host)}" }
-
-      set :directories, -> {
-        Dir['/var/www/*'].each_with_object({}) do |el, memo|
-          if Dir.exists?(File.join(el, 'current/public/uploads'))
-            memo["Uploads #{File.basename(el)}"] = File.join(el, 'current/public/uploads')
-          end
-        end
-      }
-
-      set :files, {}
-
-      set :days_to_keep_backups, 30
-      super
-    end
-  end
-end