yolo_backup 0.0.0

data/.ruby-gemset

@@ -0,0 +1 @@
+yolo-backup

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p194

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    yolo_backup (0.0.0)
+      activesupport (~> 3.2)
+      sys-filesystem (~> 1.1)
+      thor (~> 0.18)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
+      multi_json (~> 1.0)
+    diff-lcs (1.2.4)
+    ffi (1.8.1)
+    i18n (0.6.1)
+    multi_json (1.7.3)
+    rake (10.0.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    sys-filesystem (1.1.0)
+      ffi
+    thor (0.18.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 10.0)
+  rspec (~> 2.12)
+  simplecov (~> 0.7)
+  yolo_backup!

data/README.md

@@ -0,0 +1,11 @@
+# yolo_backup
+
+yolo_backup allows you to create incremental backups of multiple servers using rsync over SSH. You can specify which backups to keep (daily, weekly, monthly, …) on a per-server basis.
+
+## Setup
+
+### Configuration
+
+yolo_backup automatically loads `/etc/yolo_backup.yml`. If you would like to use a different path, use the `--config` parameter.
+
+Take a look at the [example configuration](docs/configuration_example.yml) to see what's possible.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+require 'rake'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+
+desc 'Run all specs'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end

data/docs/configuration_example.yml

@@ -0,0 +1,47 @@
+storages:
+  default:
+    path: "/var/backups/%{hostname}"
+  external:
+    path: "/mnt/external/backups/%{hostname}"
+
+rotations:
+  default:
+    daily: 10
+    monthly: 12
+    yearly: 3
+  extended:
+    hourly: 24
+    daily: 10
+    monthly: 12
+    yearly: 5
+
+exclude_sets:
+  # be sure to define a default exclude set!
+  default:
+    - '/dev/*'
+    - '/proc/*'
+    - '/sys/*'
+    - '/tmp/*'
+    - '/run/*'
+    - '/mnt/*'
+    - '/media/*'
+    - '/lost+found'
+  alternative:
+    - '/dev/*'
+    - '/proc/*'
+    - '/sys/*'
+    - '/run/*'
+    - '/lost+found'
+    - '/var/log/*'
+
+servers:
+  peter:
+    ssh_port: 2222
+    rotation: extended
+    excludes: # additional excludes
+      - '/home/dont_backup_this_user/'
+  nasibisibusi:
+    ssh_host: 'nasi.bisi.busi.example.com'
+    ssh_key: '/home/example/.ssh/id_dsa'
+    storage: external
+    exclude_set: alternative

data/lib/yolo_backup.rb

@@ -0,0 +1,6 @@
+require 'active_support/all'
+
+require 'yolo_backup/version'
+
+module YOLOBackup
+end

data/lib/yolo_backup/backup_runner.rb

@@ -0,0 +1,39 @@
+require 'yolo_backup/backup_runner/job'
+require 'yolo_backup/helper/log'
+
+module YOLOBackup
+  class BackupRunner
+    include Helper::Log
+
+    class Error < StandardError; end
+    class UnknownServerError < Error; end
+
+    OPTIONS = %w{servers verbose}
+
+    OPTIONS.each do |option|
+      attr_accessor option
+    end
+
+    alias_method :verbose?, :verbose
+
+    def initialize(options)
+      OPTIONS.each do |option|
+        send("#{option}=", options[option]) if options[option]
+      end
+    end
+
+    def backup(server_name = nil)
+      if server_name.nil?
+        servers.keys.each do |server_name|
+          backup(server_name)
+        end
+      else
+        raise UnknownServerError, "Server #{server_name} not defined" unless servers.key?(server_name)
+        server = servers[server_name]
+        log "Backup of #{server} requested" if verbose?
+        job = Job.new 'server' => server, 'verbose' => verbose?
+        job.start
+      end
+    end
+  end
+end

data/lib/yolo_backup/backup_runner/backend.rb

@@ -0,0 +1,6 @@
+module YOLOBackup
+  class BackupRunner
+    class Backend
+    end
+  end
+end

data/lib/yolo_backup/backup_runner/backend/rsync.rb

@@ -0,0 +1,31 @@
+require 'yolo_backup/backup_runner/backend'
+
+class YOLOBackup::BackupRunner::Backend::Rsync < YOLOBackup::BackupRunner::Backend
+  class Error < StandardError; end
+
+  DEFAULT_RSYNC_OPTIONS = '-aAX --numeric-ids'
+
+  attr_reader :server
+
+  def initialize(server)
+    @server = server
+  end
+
+  def start_backup
+    server.storage.initiate_backup(server) do |path|
+      options = [DEFAULT_RSYNC_OPTIONS]
+      if server.latest_backup
+        latest_backup = File.expand_path("#{path}/../#{server.latest_backup}")
+        options << "--link-dest='#{latest_backup}'"
+      end
+      ssh_options = []
+      ssh_options << "-i '#{server.ssh_key}'" unless server.ssh_key.nil?
+      ssh_options << "-p '#{server.ssh_port}'" unless server.ssh_port.nil?
+      options << "-e \"ssh #{ssh_options.join(' ')}\""
+      command = "rsync #{options.join(' ')} #{server.ssh_user || 'root'}@#{server.ssh_host || server}:/ '#{path}'"
+      puts command
+      output = `#{command}`
+      raise Error, "rsync command failed: #{$?}" unless $?.success?
+    end
+  end
+end

data/lib/yolo_backup/backup_runner/job.rb

@@ -0,0 +1,61 @@
+require 'yolo_backup/helper/log'
+require 'yolo_backup/backup_runner/backend/rsync'
+
+module YOLOBackup
+  class BackupRunner
+    class Job
+      include Helper::Log
+
+      OPTIONS = %w{server verbose}
+
+      OPTIONS.each do |option|
+        attr_accessor option
+      end
+
+      alias_method :verbose?, :verbose
+
+      def initialize(options)
+        OPTIONS.each do |option|
+          send("#{option}=", options[option]) if options[option]
+        end
+      end
+
+      def start
+        if backup_required?
+          log "Latest backup (#{server.latest_backup}) is older than maximum backup age (#{maximum_backup_age})" if verbose?
+          log "Starting backup of #{server}"
+          backend.start_backup
+          log "Backup completed" if verbose?
+          log "Cleaning up old backups" if verbose?
+          log "Deleted #{server.cleanup_backups.length} backups" if verbose?
+        else
+          log "Backup not required (latest backup = #{server.latest_backup}, maximum backup age = #{maximum_backup_age})" if verbose?
+        end
+      end
+
+      def backup_required?
+        latest_backup = server.latest_backup
+        return latest_backup.nil? || latest_backup < maximum_backup_age
+      end
+
+      def maximum_backup_age
+        case server.rotation.minimum_unit
+        when 'hourly'
+          1.hour.ago
+        when 'daily'
+          1.day.ago
+        when 'weekly'
+          1.week.ago
+        when 'monthly'
+          1.month.ago
+        when 'yearly'
+          1.year.ago
+        end
+      end
+
+      def backend
+        @backend ||= YOLOBackup::BackupRunner::Backend::Rsync.new(server)
+      end
+    end
+  end
+end

data/lib/yolo_backup/cli.rb

@@ -0,0 +1,111 @@
+require 'thor'
+require 'yaml'
+
+require 'yolo_backup/storage_pool/file'
+require 'yolo_backup/rotation_plan'
+require 'yolo_backup/backup_runner'
+require 'yolo_backup/server'
+require 'yolo_backup/exclude_set'
+
+module YOLOBackup
+  class CLI < Thor
+    DEFAULT_CONFIG_FILE = '/etc/yolo_backup.yml'
+    DEFAULT_STORAGE_POOL_NAME = 'default'
+    DEFAULT_ROTATION_PLAN_NAME = 'default'
+    DEFAULT_EXCLUDE_SET_NAME = 'default'
+
+    class_option :verbose, :type => :boolean
+    class_option :config, :type => :string, :banner => "path to config file (default #{DEFAULT_CONFIG_FILE})"
+
+    desc 'status', 'Display backup status and statistics'
+    def status(storage = nil)
+      storage_pools.values.each do |storage_pool|
+        puts "#{storage_pool}:"
+        if storage_pool.ready?
+          storage_pool.statistics.tap do |stats|
+            puts "  Capacity:  #{'%4d' % (stats[:capacity] / 1000 / 1000 / 1000)} GB"
+            puts "  Available: #{'%4d' % (stats[:available] / 1000 / 1000 / 1000)} GB"
+          end
+        else
+          puts "  STORAGE NOT READY" unless storage_pool.ready?
+        end
+      end
+    end
+
+    desc 'backup [SERVER]', 'Start backup process'
+    def backup(server = nil)
+      backup_runner = BackupRunner.new('servers' => servers, 'verbose' => verbose?)
+      backup_runner.backup(server)
+    end
+
+    private
+    def verbose?
+      !!options[:verbose]
+    end
+
+    def config
+      @config ||= YAML::load(File.open(options[:config] || DEFAULT_CONFIG_FILE))
+    end
+
+    def storage_pools
+      return @storage_pools unless @storage_pools.nil?
+
+      (@storage_pools = {}).tap do |storage_pools|
+        config['storages'].each do |name, options|
+          storage_pools[name] = StoragePool::File.new(name, options)
+        end
+      end
+    end
+
+    def rotation_plans
+      return @rotation_plans unless @rotation_plans.nil?
+
+      (@rotation_plans = {}).tap do |rotation_plans|
+        config['rotations'].each do |name, options|
+          rotation_plans[name] = RotationPlan.new(name, options)
+        end
+      end
+    end
+
+    def exclude_sets
+      return @exclude_sets unless @exclude_sets.nil?
+
+      (@exclude_sets = {}).tap do |exclude_sets|
+        config['exclude_sets'].each do |name, options|
+          exclude_sets[name] = ExcludeSet.new(name, options)
+        end
+      end
+    end
+
+    def servers
+      return @servers unless @servers.nil?
+
+      (@servers = {}).tap do |servers|
+        config['servers'].each do |name, options|
+          options['storage'] = storage_by_name(options['storage'])
+          options['rotation'] = rotation_by_name(options['rotation'])
+          options['excludes'] = (options['excludes'] || []) + exlude_set_by_name(options['exclude_set']).excludes
+          servers[name] = Server.new(name, options)
+        end
+      end
+    end
+
+    def storage_by_name(name = nil)
+      name ||= DEFAULT_STORAGE_POOL_NAME
+      raise "Storage #{name} not defined" unless storage_pools.key?(name)
+      storage_pools[name]
+    end
+
+    def rotation_by_name(name = nil)
+      name ||= DEFAULT_ROTATION_PLAN_NAME
+      raise "Rotation plan #{name} not defined" unless rotation_plans.key?(name)
+      rotation_plans[name]
+    end
+
+    def exlude_set_by_name(name = nil)
+      name ||= DEFAULT_EXCLUDE_SET_NAME
+      raise "Exclude set #{name} not defined" unless exclude_sets.key?(name)
+      exclude_sets[name]
+    end
+  end
+end

data/lib/yolo_backup/core_ext/string.rb

@@ -0,0 +1,21 @@
+class String
+  INTERPOLATION_PATTERN = Regexp.union(
+    /%%/,
+    /%\{(\w+)\}/
+  )
+  def interpolate(values)
+    self.gsub(INTERPOLATION_PATTERN) do |match|
+      if match == '%%'
+        '%'
+      else
+        key = ($1 || $2).to_sym
+        unless values.key?(key)
+          raise "Mission interpolation argument: #{key}"
+        end
+        value = values[key]
+        value = value.call(values) if value.respond_to?(:call)
+        $3 ? sprintf("%#{$3}", value) : value
+      end
+    end
+  end
+end

data/lib/yolo_backup/exclude_set.rb

@@ -0,0 +1,14 @@
+module YOLOBackup
+  class ExcludeSet
+    attr_reader :name, :excludes
+
+    def initialize(name, excludes)
+      @name = name
+      @excludes = excludes
+    end
+
+    def to_s
+      "#{name} (#{excludes.join(', ')})"
+    end
+  end
+end

data/lib/yolo_backup/helper/log.rb

@@ -0,0 +1,9 @@
+module YOLOBackup
+  module Helper
+    module Log
+      def log(msg)
+        puts "#{Time.now.iso8601} [#{self.class.name}] #{msg}"
+      end
+    end
+  end
+end

data/lib/yolo_backup/rotation_plan.rb

@@ -0,0 +1,24 @@
+module YOLOBackup
+  class RotationPlan
+    SCHEDULE_OPTIONS = %w{ hourly daily weekly monthly yearly }
+
+    SCHEDULE_OPTIONS.each do |option|
+      attr_accessor option
+    end
+
+    attr_reader :name
+
+    def initialize(name, options)
+      @name = name
+      SCHEDULE_OPTIONS.each do |option|
+        send("#{option}=", options[option]) if options.key?(option)
+      end
+    end
+
+    def minimum_unit
+      SCHEDULE_OPTIONS.each do |option|
+        return option if send(option).to_i > 0
+      end
+    end
+  end
+end

data/lib/yolo_backup/server.rb

@@ -0,0 +1,30 @@
+module YOLOBackup
+  class Server
+    OPTIONS = %w{ excludes rotation ssh_host ssh_key ssh_port ssh_user storage }
+
+    OPTIONS.each do |option|
+      attr_accessor option
+    end
+
+    attr_reader :name
+
+    def initialize(name, options)
+      @name = name
+      OPTIONS.each do |option|
+        send("#{option}=", options[option]) if options.key?(option)
+      end
+    end
+
+    def latest_backup
+      storage.latest_backup(self)
+    end
+
+    def cleanup_backups
+      storage.cleanup(self)
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/lib/yolo_backup/storage_pool.rb

@@ -0,0 +1,9 @@
+module YOLOBackup
+  class StoragePool
+    attr_reader :name
+
+    def initialize(name, options=nil)
+      @name = name
+    end
+  end
+end

data/lib/yolo_backup/storage_pool/file.rb

@@ -0,0 +1,70 @@
+require 'time'
+require 'sys/filesystem'
+
+require 'yolo_backup/storage_pool'
+require 'yolo_backup/core_ext/string'
+
+class YOLOBackup::StoragePool::File < YOLOBackup::StoragePool
+  require 'yolo_backup/storage_pool/file/cleaner'
+
+  OPTIONS = %w{ path }
+
+  attr_accessor :path
+
+  def initialize(name, options = nil)
+    super
+    OPTIONS.each do |key|
+      send("#{key}=", options[key]) if options[key]
+    end
+  end
+
+  def to_s
+    "#{name} (#{wildcard_path})"
+  end
+
+  def statistics
+    stats = Sys::Filesystem.stat(base_path)
+    {
+      capacity: stats.blocks * stats.block_size,
+      available: stats.blocks_available * stats.block_size
+    }
+  end
+
+  def ready?
+    ::File.directory?(base_path) && ::File.readable?(base_path)
+  end
+
+  def latest_backup(server)
+    server_path = server_path(server)
+    return nil unless ::File.directory?(server_path) && ::File.symlink?("#{server_path}/latest") && ::File.directory?("#{server_path}/latest")
+    target = ::File.basename(::File.readlink("#{server_path}/latest"))
+    Time.parse(target)
+  end
+
+  def initiate_backup(server, &block)
+    server_path = server_path(server)
+    path = "#{server_path}/#{Time.now.iso8601}/"
+    yield(path)
+    latest_path = "#{server_path}/latest"
+    ::File.unlink(latest_path) if ::File.symlink?(latest_path)
+    ::File.symlink(path, latest_path)
+  end
+
+  def cleanup(server)
+    cleaner = Cleaner.new(self, server)
+    cleaner.cleanup
+  end
+
+  private
+  def wildcard_path
+    path.interpolate :hostname => '*'
+  end
+
+  def base_path
+    path.interpolate(:hostname => '')
+  end
+
+  def server_path(hostname)
+    path.interpolate(:hostname => hostname)
+  end
+end

data/lib/yolo_backup/storage_pool/file/cleaner.rb

@@ -0,0 +1,71 @@
+require 'fileutils'
+
+require 'yolo_backup/storage_pool/file'
+
+class YOLOBackup::StoragePool::File::Cleaner
+  attr_reader :storage_pool, :server
+
+  def initialize(storage_pool, server)
+    @storage_pool = storage_pool
+    @server = server
+  end
+
+  def cleanup
+    unused_backups = all_backups - required_backups
+    unused_backups.each do |unused_backup|
+      path = "#{server_path}/#{unused_backup.iso8601}"
+      p path
+      FileUtils.rm_r path, :force => true
+    end
+    unused_backups
+  end
+
+  private
+  def required_backups
+    required_backups = {}
+    all_backups.each do |date|
+      {
+        :year => :yearly,
+        :month => :monthly,
+        :week => :weekly,
+        :day => :daily,
+        :hour => :hourly
+      }.each do |accuracy, schedule_option_name|
+        keep_count = server.rotation.send("#{schedule_option_name}").to_i
+        next if keep_count.nil? || keep_count.zero?
+        if required_backups[accuracy].nil?
+          required_backups[accuracy] = [date]
+        elsif !same_date(date, required_backups[accuracy].last, accuracy)
+          required_backups[accuracy] << date
+        end
+        if required_backups[accuracy].length > keep_count
+          required_backups[accuracy].shift
+        end
+      end
+    end
+    required_backups = required_backups.values.flatten
+    required_backups << server.latest_backup
+    required_backups.uniq
+  end
+
+  def all_backups
+    backups = []
+    Dir.chdir(server_path) do
+      Dir.entries('.').sort.each do |file|
+        next if ['.', '..'].include?(file)
+        next unless ::File.directory?(file) && !::File.symlink?(file)
+        backups << Time.parse(file)
+      end
+    end
+    backups
+  end
+
+  def server_path
+    storage_pool.path.interpolate(:hostname => server)
+  end
+
+  def same_date(time1, time2, accuracy)
+    end_of = "end_of_#{accuracy}"
+    time1.send(end_of) == time2.send(end_of)
+  end
+end

data/lib/yolo_backup/version.rb

@@ -0,0 +1,3 @@
+module YOLOBackup
+  VERSION = '0.0.0'
+end

data/yolo_backup.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'yolo_backup/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'yolo_backup'
+  s.version     = YOLOBackup::VERSION
+  s.authors     = ['Nils Caspar']
+  s.email       = 'ncaspar@me.com'
+  s.homepage    = 'http://github.org/pencil/yolo_backup'
+  s.license     = 'MIT'
+  s.summary     = 'A simple Ruby script to create incremental backups of multiple servers using rsync over SSH.'
+  s.description = 'yolo_backup allows you to create incremental backups of multiple servers using rsync over SSH. You can specify which backups to keep (daily, weekly, monthly, …) on a per-server basis.'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 2.12'
+  s.add_development_dependency 'simplecov', '~> 0.7'
+
+  s.add_dependency 'thor', '~> 0.18'
+  s.add_dependency 'sys-filesystem', '~> 1.1'
+  s.add_dependency 'activesupport', '~> 3.2'
+
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: yolo_backup
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Nils Caspar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: sys-filesystem
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: yolo_backup allows you to create incremental backups of multiple servers
+  using rsync over SSH. You can specify which backups to keep (daily, weekly, monthly,
+  …) on a per-server basis.
+email: ncaspar@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- docs/configuration_example.yml
+- lib/yolo_backup.rb
+- lib/yolo_backup/backup_runner.rb
+- lib/yolo_backup/backup_runner/backend.rb
+- lib/yolo_backup/backup_runner/backend/rsync.rb
+- lib/yolo_backup/backup_runner/job.rb
+- lib/yolo_backup/cli.rb
+- lib/yolo_backup/core_ext/string.rb
+- lib/yolo_backup/exclude_set.rb
+- lib/yolo_backup/helper/log.rb
+- lib/yolo_backup/rotation_plan.rb
+- lib/yolo_backup/server.rb
+- lib/yolo_backup/storage_pool.rb
+- lib/yolo_backup/storage_pool/file.rb
+- lib/yolo_backup/storage_pool/file/cleaner.rb
+- lib/yolo_backup/version.rb
+- yolo_backup.gemspec
+homepage: http://github.org/pencil/yolo_backup
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple Ruby script to create incremental backups of multiple servers using
+  rsync over SSH.
+test_files: []