sweety_backy 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+.rvmrc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc_example

@@ -0,0 +1 @@
+rvm 1.8.7@sweety_backy

data/Gemfile

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

data/README.md

@@ -0,0 +1,121 @@
+# Sweety Backy
+
+Simple mechanism to **configure and execute backups** of folders and MySQL DBs and store them in **local folder** or **S3 bucket**.
+
+## State
+
+This is a **really beta** version which is working in my servers actually without problems but you have to use it under your own risk.
+
+## Other possibilities
+
+Please take a look of other **Ruby backups gems**:
+
+* http://ruby-toolbox.com/categories/backups.html
+
+## How install
+
+    gem install 'sweety_backy'
+    
+## How to use it
+    
+    sweety_backy <config_file>
+    
+### Config file
+
+It is a _yaml_ file with all this attributes
+
+    paths: <array of folder paths>
+    databases: <array of database names>
+    yearly: <quantity of yearly backups>
+    monthly: <quantity of monthly backups>
+    weekly: <quantity of weekly backups>
+    daily: <quantity of daily backups>
+    database_user: <database user with read privileges of all datases>
+    database_pass: <database user password>
+    storage_system: { 's3' | 'local' }
+    local_opts: (only if the storage_system is 'local')
+      path: <absoulte path to the root folder of the backups>
+    s3_opts: (only if the storage_system is 's3')
+      bucket: <bucket name>
+      path: <bucket path where the backups will be stored><
+      passwd_file: <path to the S3 credentials>
+    
+### S3 credentials file
+
+It is a _yaml_ file with two keys with the S3 credentials:
+
+    access_key_id: "XXX"
+    secret_access_key: "YYY"
+    
+### Example
+
+#### S3 config example
+
+    # ~/.s3.passwd
+    access_key_id: "XXX"
+    secret_access_key: "YYY"
+
+
+#### SweetyBacky config example    
+
+    # ~/.sweety_backy.conf
+    paths: [ "/Users/fguillen/Develop/Brico", "/Users/fguillen/Develop/Arduino" ]
+    databases: [ "test", "mysql" ]
+    yearly: 1
+    monthly: 2
+    weekly: 3
+    daily: 4
+    database_user: 'root'
+    database_pass: ''
+    storage_system: 's3'
+    s3_opts: 
+      bucket: 'sweety_backy'
+      path: 'fguillen'
+      passwd_file: '~/.s3.passwd'
+      
+#### Execute
+
+    sweety_backy ~/.sweety_backy.conf
+    
+#### Result
+
+This will generate a bunch of backups in the _sweety_backy_ bucket like these ones:
+
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Arduino.20110626.weekly.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Arduino.20110703.weekly.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Arduino.20110704.daily.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Arduino.20110705.daily.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Arduino.20110706.daily.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Arduino.20110707.daily.tar.gz
+
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Brico.20110626.weekly.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Brico.20110703.weekly.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Brico.20110704.daily.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Brico.20110705.daily.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Brico.20110706.daily.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/files/Users.fguillen.Develop.Brico.20110707.daily.tar.gz
+
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/test.20110626.weekly.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/test.20110703.weekly.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/test.20110704.daily.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/test.20110705.daily.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/test.20110706.daily.sql.tar.gz    
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/test.20110707.daily.sql.tar.gz
+
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/mysql.20110626.weekly.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/mysql.20110703.weekly.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/mysql.20110704.daily.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/mysql.20110705.daily.sql.tar.gz
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/mysql.20110706.daily.sql.tar.gz    
+    https://s3.amazonaws.com/sweety_backy/fguillen/databases/mysql.20110707.daily.sql.tar.gz
+    
+... and so on.
+
+### Cron execution example
+    
+    # every day at 02:00 am
+    00 02 * * * sweety_backy /home/fguillen/.sweety_backy.conf >> /var/log/sweety_backy.log 2>&1
+
+## License
+
+MIT License. (c) 2011 Fernando Guillen (http://fernandoguillen.info).

data/Rakefile

@@ -0,0 +1,31 @@
+# require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rake/testtask'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << '.'
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+namespace :test do
+  
+  desc "run s3 test in real"
+  task :s3 do
+    test_task = 
+      Rake::TestTask.new("s3_tests") do |t|
+        t.libs << '.'
+        t.test_files = FileList['test/s3/*_test.rb']
+        t.verbose = true
+      end
+  
+    task("s3_tests").execute
+  end
+  
+end

data/bin/sweety_backy

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# Use:
+#     sweety_backy /path/to/sweety_backy.conf
+
+begin
+  require 'sweety_backy'
+rescue LoadError
+  require 'rubygems'
+  require 'sweety_backy'
+end
+
+require 'benchmark'
+
+if( ARGV[0].nil? )
+  SweetyBacky::Utils.log "use: $ sweety_backy <config_file_path>"
+  exit 1
+end
+
+lapsus_time = 
+  Benchmark.realtime do
+    SweetyBacky::Utils.log "--------------------"
+    SweetyBacky::Utils.log "Starting SweetyBacky"
+    sb = SweetyBacky::Runner.new( ARGV[0] )
+    sb.run
+  end
+
+SweetyBacky::Utils.log "SweetyBacky on #{lapsus_time} seconds"

data/lib/sweety_backy.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require "s3"
+
+require "#{File.dirname(__FILE__)}/sweety_backy/version"
+require "#{File.dirname(__FILE__)}/sweety_backy/runner"
+require "#{File.dirname(__FILE__)}/sweety_backy/utils"
+require "#{File.dirname(__FILE__)}/sweety_backy/commander"
+require "#{File.dirname(__FILE__)}/sweety_backy/s3"
+require "#{File.dirname(__FILE__)}/sweety_backy/opts_reader"

data/lib/sweety_backy/commander.rb

@@ -0,0 +1,82 @@
+module SweetyBacky
+  module Commander    
+    def self.do_files_backup( path, backup_path, opts )
+      SweetyBacky::Utils.log "doing files backup of #{path} to #{backup_path}"
+    
+      FileUtils.mkdir_p( File.dirname( backup_path ) )
+      SweetyBacky::Utils::command( "tar -cz --directory #{path} --same-permissions --file #{backup_path} ." )
+    end
+  
+    def self.do_database_backup( database_name, backup_path, opts )
+      SweetyBacky::Utils.log "doing database backup #{database_name} on #{backup_path}"
+    
+      FileUtils.mkdir_p( File.dirname( backup_path ) )
+      tmp_sql_file_path = File.join( Dir::tmpdir, "#{File.basename( backup_path, '.tar.gz' )}" )
+      
+      database_pass = opts[:database_pass].empty? ? '' : "-p#{opts[:database_pass]}"
+      
+      SweetyBacky::Utils::command( "mysqldump -u#{opts[:database_user]} #{opts[:database_pass]} #{database_name} > #{tmp_sql_file_path}" )
+      SweetyBacky::Utils::command( "tar -cz --same-permissions --file #{backup_path} --directory #{File.dirname(tmp_sql_file_path)} #{File.basename(tmp_sql_file_path)}" )
+      
+      File.delete( tmp_sql_file_path )
+    end
+
+    def self.clear( opts )
+      clear_files( opts )
+      clear_databases( opts )
+    end
+  
+    def self.clear_files( opts )
+      SweetyBacky::Utils.log "cleaning files on #{opts[:working_path]}/files/"
+      
+      opts[:paths].each do |path|
+        SweetyBacky::Utils.log "cleaning file #{path}"
+        
+        [:yearly, :monthly, :weekly, :daily].each do |period|
+          paths_in( 
+            "#{opts[:working_path]}/files/#{SweetyBacky::Utils.namerize( path )}.*.#{period.to_s}.*",
+            opts
+          ).sort[0..(-1*(opts[period]+1))].each do |file_path|
+            SweetyBacky::Utils.log "removing: #{file_path}"
+            remove_path( file_path, opts )
+          end      
+        end
+      end
+    end
+    
+    def self.clear_databases( opts )
+      SweetyBacky::Utils.log "cleaning databases on #{opts[:working_path]}/databases/"
+      
+      opts[:databases].each do |database_name|
+        SweetyBacky::Utils.log "cleaning database #{database_name}"
+        
+        [:yearly, :monthly, :weekly, :daily].each do |period|
+          paths_in( 
+            "#{opts[:working_path]}/databases/#{database_name}.*.#{period.to_s}.*",
+            opts
+          ).sort[0..(-1*(opts[period]+1))].each do |file_path|
+            SweetyBacky::Utils.log "removing: #{file_path}"
+            remove_path( file_path, opts )
+          end      
+        end
+      end
+    end
+    
+    def self.paths_in( path, opts )
+      if( opts[:storage_system].to_sym == :s3 )
+        return SweetyBacky::S3.paths_in( path, opts[:s3_opts] )
+      else
+        return Dir.glob( path )
+      end
+    end
+    
+    def self.remove_path( path, opts )
+      if( opts[:storage_system].to_sym == :s3 )
+        SweetyBacky::S3.delete( path, opts[:s3_opts] )
+      else
+        File.delete( path )
+      end
+    end
+    
+  end
+end

data/lib/sweety_backy/opts_reader.rb

@@ -0,0 +1,47 @@
+module SweetyBacky
+  module OptsReader
+    def self.read_opts( conf_path )
+      SweetyBacky::Utils::log "conf_path: #{conf_path}"
+
+      opts = YAML.load( File.read( conf_path ) )
+      new_opts = {}
+      
+      # symbolize keys
+      opts.keys.each do |key|        
+        
+        if( opts[key].is_a? Hash )
+          new_opts[key.to_sym] = {}
+          opts[key].keys.each do |key2|
+            new_opts[key.to_sym][key2.to_sym] = opts[key][key2]
+          end
+        else
+          new_opts[key.to_sym] = opts[key]
+        end
+
+      end
+      
+      log_configuration( new_opts )
+
+      # TODO: test all options are ok
+
+      return new_opts
+    end
+        
+    def self.log_configuration( opts )
+      SweetyBacky::Utils::log "configuration:"
+      SweetyBacky::Utils::log "------------"
+      opts.each_pair do |key, value|
+        if( value.is_a? Array )
+          SweetyBacky::Utils::log "#{key}: #{value.join(' | ')}"
+        elsif( value.is_a? Hash )
+          value.each_pair do |key2, value2|
+            SweetyBacky::Utils::log "#{key} => #{key2}: #{value2}"
+          end
+        else
+          SweetyBacky::Utils::log "#{key}: #{value}"
+        end
+      end
+    end
+    
+  end
+end

data/lib/sweety_backy/runner.rb

@@ -0,0 +1,88 @@
+require 'rubygems'
+require 'fileutils'
+require 'tmpdir'
+require 'yaml'
+require File.dirname(__FILE__) + "/utils.rb"
+
+module SweetyBacky
+  class Runner
+    attr_reader :opts
+    
+    def initialize( path = nil )
+      if( !path.nil? )
+        config( SweetyBacky::OptsReader.read_opts( path ) )
+      end
+    end
+  
+    def config( opts )
+      @opts = {
+        :paths          => [],
+        :databases      => [],
+        :yearly         => 1,
+        :monthly        => 1,
+        :weekly         => 2,
+        :daily          => 4,
+        :storage_system => :local
+      }.merge( opts )
+      
+      if( @opts[:storage_system].to_sym == :s3 )
+        @opts[:working_path] = File.join( Dir::tmpdir, "sweety_backy_#{Time.now.to_i}" )
+      else
+        @opts[:working_path] = @opts[:local_opts][:path]
+      end
+    end
+    
+    def do_backup
+      do_files_backup
+      do_databases_backup
+    end
+    
+    def do_files_backup
+      @opts[:paths].each do |path|
+        backup_path = "#{@opts[:working_path]}/files/#{SweetyBacky::Utils.namerize( path )}.#{Date.today.strftime('%Y%m%d')}.#{SweetyBacky::Utils.period}.tar.gz"
+        SweetyBacky::Commander.do_files_backup( path, backup_path, @opts )
+        
+        if( @opts[:storage_system].to_sym == :s3 )
+          SweetyBacky::S3.upload(
+            backup_path,
+            "#{@opts[:s3_opts][:path]}/files/#{File.basename( backup_path )}",
+            @opts[:s3_opts]
+          )
+          
+          FileUtils.rm_rf backup_path
+        end
+      end
+    end
+    
+    def do_databases_backup
+      @opts[:databases].each do |database_name|
+        backup_path = "#{@opts[:working_path]}/databases/#{database_name}.#{Date.today.strftime('%Y%m%d')}.#{SweetyBacky::Utils.period}.sql.tar.gz"
+        SweetyBacky::Commander.do_database_backup( database_name, backup_path, @opts)
+        
+        if( @opts[:storage_system].to_sym == :s3 )
+          SweetyBacky::S3.upload(
+            backup_path,
+            "#{@opts[:s3_opts][:path]}/databases/#{File.basename( backup_path )}",
+            @opts[:s3_opts]
+          )
+          
+          FileUtils.rm_rf backup_path
+        end
+      end
+    end
+    
+    def run
+      begin
+        do_backup
+        SweetyBacky::Commander.clear( @opts )
+      rescue => e
+        SweetyBacky::Utils.log "ERROR: #{e}"
+        SweetyBacky::Utils.log "BACKTRACE: #{e.backtrace.join("\n")}"
+        SweetyBacky::Utils.log "I should send and email at this moment"
+      end
+    end
+  
+
+  end
+end
+

data/lib/sweety_backy/s3.rb

@@ -0,0 +1,56 @@
+module SweetyBacky
+  class S3
+    def self.upload( path, backup_path, opts )
+      SweetyBacky::Utils.log( "S3 uploading: #{path} to #{opts[:bucket]}/#{backup_path}" )
+      
+      s3 = ::S3::Service.new( read_s3_password( opts[:passwd_file] ) )
+      bucket = s3.bucket( opts[:bucket] )
+      
+      if !bucket.exists?
+        bucket = s3.buckets.build( opts[:bucket] )
+        bucket.save
+      end
+
+      object = bucket.objects.build( backup_path )
+      object.content = File.open( path )
+      object.save
+    end
+    
+    def self.object( path, opts )
+      s3 = ::S3::Service.new( read_s3_password( opts[:passwd_file] ) )
+      bucket = s3.buckets.find( opts[:bucket] )
+      object = bucket.objects.find( path )
+      
+      return object
+    end
+    
+    def self.paths_in( path, opts )
+      s3 = ::S3::Service.new( read_s3_password( opts[:passwd_file] ) )
+      bucket = s3.buckets.find( opts[:bucket] )
+      
+      regex = Regexp.escape( path ).gsub('\*', '.*').gsub('\?', '.')
+      
+      objects = bucket.objects.select { |e| e.key =~ /#{regex}/ }
+      paths = objects.map(&:key)
+      
+      return paths
+    end
+    
+    def self.read_s3_password( path )
+      opts = YAML.load( File.read( File.expand_path path ) )
+      new_opts = {}
+      
+      # symbolize keys
+      opts.keys.each do |key|
+        new_opts[key.to_sym] = opts[key]
+      end
+      
+      return new_opts
+    end
+    
+    def self.delete( path, opts )
+      SweetyBacky::S3.object( path, opts ).destroy
+    end
+    
+  end
+end

data/lib/sweety_backy/utils.rb

@@ -0,0 +1,42 @@
+module SweetyBacky
+  class Utils
+    
+    def self.period
+      return 'yearly'   if( is_last_day_of_year? )
+      return 'monthly'  if( is_last_day_of_month? )
+      return 'weekly'   if( is_last_day_of_week? )
+      return 'daily'
+    end
+    
+    def self.is_last_day_of_year?
+      return Date.new(Date.today.year, 12, -1) == Date.today
+    end
+    
+    def self.is_last_day_of_month?
+      return Date.new(Date.today.year, Date.today.month, -1) == Date.today
+    end
+  
+    def self.is_last_day_of_week?
+      return Date.today.cwday == 7
+    end
+  
+    def self.command( _command )
+      Utils.log "command: #{_command}"
+      
+      result = %x( #{_command} 2>&1 )
+    
+      raise "ERROR: on command: '#{_command}', result: '#{result}'"  if $?.exitstatus != 0
+    
+      return result
+    end
+  
+    def self.log( msg )
+      puts "#{Time.now.strftime("%Y-%m-%d %H:%M")}: #{msg}"
+    end
+    
+    def self.namerize( path )
+      path.gsub('/', '.').gsub(/^\./, '')
+    end
+    
+  end
+end

data/lib/sweety_backy/version.rb

@@ -0,0 +1,3 @@
+module SweetyBacky
+  VERSION = "0.0.2"
+end

data/sweety_backy.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sweety_backy"
+
+Gem::Specification.new do |s|
+  s.name        = "sweety_backy"
+  s.version     = SweetyBacky::VERSION
+  s.authors     = ["Fernando Guillen"]
+  s.email       = ["fguillen.mail@gmail.com"]
+  s.homepage    = ""
+  s.summary     = "Ruby backup mechanism"
+  s.description = "Simple mechanism to configure and execute backups of folders and MySQL DBs and store them in local folder or S3 bucket"
+
+  s.rubyforge_project = "SweetyBacky"
+  
+  s.add_development_dependency "bundler", ">= 1.0.0.rc.6"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "delorean"
+  
+  s.add_dependency "s3"
+
+  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"]
+end

data/test/commander_test.rb

@@ -0,0 +1,134 @@
+require "#{File.dirname(__FILE__)}/test_helper"
+
+class CommanderTest < Test::Unit::TestCase
+  
+  def setup
+    SweetyBacky::Utils.stubs(:log)
+    
+    # tmp dir
+    @tmp_dir = File.join( Dir::tmpdir, "sweety_backy_#{Time.now.to_i}" )
+    Dir.mkdir( @tmp_dir )  unless File.exists?(@tmp_dir)
+  end
+  
+  def teardown
+    FileUtils.rm_rf @tmp_dir  if File.exists?(@tmp_dir)
+  end
+  
+  def test_do_files_backup
+    SweetyBacky::Commander.do_files_backup( 
+      "#{FIXTURES_PATH}/path", 
+      "#{@tmp_dir}/back.tar.gz",
+      {}
+    )
+    
+    result = %x(tar -tzvf #{@tmp_dir}/back.tar.gz)
+
+    assert_match( "./", result )
+    assert_match( "./file1.txt", result )
+    assert_match( "./a/", result )
+    assert_match( "./b/file3.txt", result )
+  end
+  
+  def test_do_databases_backup
+    SweetyBacky::Commander.do_database_backup( 
+      "test",  
+      "#{@tmp_dir}/back.sql.tar.gz",
+      {
+        :database_user => "test", 
+        :database_pass => ""
+      }
+    )
+    
+    result = %x(tar -tzvf #{@tmp_dir}/back.sql.tar.gz)
+    
+    assert_match( /\sback.sql$/, result )
+  end
+
+  
+  def test_clear
+    opts = {
+      :paths        => [ 'name1', 'name2' ],
+      :databases    => [ 'name1', 'name2' ],
+      :yearly       => 1,
+      :monthly      => 2,
+      :weekly       => 3,
+      :daily        => 4,
+      :storage_system => :local,
+      :local_opts => {
+        :path => @tmp_dir
+      },
+      :working_path => @tmp_dir
+    }
+    
+    Dir.mkdir( "#{@tmp_dir}/files" )  unless File.exists?( "#{@tmp_dir}/files" )
+    Dir.mkdir( "#{@tmp_dir}/databases" )  unless File.exists?( "#{@tmp_dir}/databases" )
+    
+    [
+      'name1.20081231.yearly',
+      'name1.20081232.yearly',
+      'name2.20091231.yearly',
+      'name1.20100131.monthly',
+      'name1.20100228.monthly',
+      'name1.20100331.monthly',
+      'name2.20100430.monthly',
+      'name2.20100531.monthly',
+      'name2.20100630.monthly',
+      'name1.20100704.weekly',
+      'name1.20100711.weekly',
+      'name1.20100718.weekly',
+      'name1.20100725.weekly',
+      'name1.20100720.daily',
+      'name2.20100721.daily',
+      'name2.20100722.daily',
+      'name2.20100723.daily',
+      'name2.20100724.daily',
+      'name2.20100726.daily'
+    ].each do |file_part|
+      File.open( "#{@tmp_dir}/files/#{file_part}.tar.gz", 'w' ) { |f| f.write 'wadus' }
+      File.open( "#{@tmp_dir}/databases/#{file_part}.sql.tar.gz", 'w' ) { |f| f.write 'wadus' }
+    end
+    
+    # puts @tmp_dir
+    # exit 1
+    
+    SweetyBacky::Commander.clear( opts )
+    
+    files_keeped = Dir.glob( "#{@tmp_dir}/files/*" ).join( "\n" )
+    databases_keeped = Dir.glob( "#{@tmp_dir}/databases/*" ).join( "\n" )
+    
+    # files to keep
+    [
+      'name1.20081232.yearly',
+      'name2.20091231.yearly',
+      'name1.20100228.monthly',
+      'name1.20100331.monthly',
+      'name2.20100531.monthly',
+      'name2.20100630.monthly',
+      'name1.20100718.weekly',
+      'name1.20100725.weekly',
+      'name1.20100720.daily',
+      'name2.20100722.daily',
+      'name2.20100723.daily',
+      'name2.20100724.daily',
+      'name2.20100726.daily'
+    ].each do |file_part|
+      assert_match( "#{file_part}.tar.gz", files_keeped )
+      assert_match( "#{file_part}.sql.tar.gz", databases_keeped )
+    end
+    
+    # files to deleted
+    [
+      'name1.20081231.yearly',
+      'name1.20100131.monthly',
+      'name2.20100430.monthly',
+      'name1.20100704.weekly',
+      'name2.20100721.daily'
+    ].each do |file_part|
+      assert_no_match( /#{file_part}.tar.gz/, files_keeped )
+      assert_no_match( /#{file_part}.sql.tar.gz/, databases_keeped )
+    end
+  end
+
+    
+end
+

data/test/fixtures/config_s3.yml

@@ -0,0 +1,13 @@
+paths: [ "path1", "path2" ]
+databases: [ "db1", "db2" ]
+yearly: 1
+monthly: 2
+weekly: 3
+daily: 4
+database_user: 'database_user'
+database_pass: 'database_pass'
+storage_system: 's3'
+s3_opts: 
+  bucket: 'bucket_name'
+  path: 's3/path/path'
+  passwd_file: '/path/.s3.passwd'

data/test/fixtures/file.txt

@@ -0,0 +1 @@
+file

data/test/fixtures/path/a/file2.txt

@@ -0,0 +1 @@
+file2

data/test/fixtures/path/b/file3.txt

@@ -0,0 +1 @@
+file3

data/test/fixtures/path/file1.txt

@@ -0,0 +1 @@
+file1

data/test/fixtures/s3.passwd

@@ -0,0 +1,2 @@
+access_key_id: "access_key"
+secret_access_key: "secret_access"

data/test/opts_reader_test.rb

@@ -0,0 +1,25 @@
+require "#{File.dirname(__FILE__)}/test_helper"
+
+class OptsReaderTest < Test::Unit::TestCase
+  def setup
+    SweetyBacky::Utils.stubs(:log)
+  end
+    
+  def test_read_opts
+    opts = SweetyBacky::OptsReader.read_opts( "#{FIXTURES_PATH}/config_s3.yml" )
+    
+    assert_equal( [ "path1", "path2" ], opts[:paths] )
+    assert_equal( [ "db1", "db2" ], opts[:databases] )
+    assert_equal( 1, opts[:yearly] )
+    assert_equal( 2, opts[:monthly] )
+    assert_equal( 3, opts[:weekly] )
+    assert_equal( 4, opts[:daily] )
+    assert_equal( 'database_user', opts[:database_user] )
+    assert_equal( 'database_pass', opts[:database_pass] )
+    assert_equal( 'bucket_name', opts[:s3_opts][:bucket] )    
+    assert_equal( 's3/path/path', opts[:s3_opts][:path] )
+    assert_equal( '/path/.s3.passwd', opts[:s3_opts][:passwd_file] )
+  end
+  
+  
+end

data/test/runner_test.rb

@@ -0,0 +1,102 @@
+require "#{File.dirname(__FILE__)}/test_helper"
+
+class RunnerTest < Test::Unit::TestCase
+  
+  def setup
+    SweetyBacky::Utils.stubs(:log)
+
+    # tmp dir
+    @tmp_dir = File.join( Dir::tmpdir, "sweety_backy_#{Time.now.to_i}" )
+    Dir.mkdir( @tmp_dir )  unless File.exists?(@tmp_dir)
+    
+    # runner
+    @opts = {
+      :paths          => [ "#{FIXTURES_PATH}/path" ],
+      :databases      => [ "test" ],
+      :yearly         => 1,
+      :monthly        => 1,
+      :weekly         => 2,
+      :daily          => 4,
+      :database_user  => 'test',
+      :database_pass  => '',
+      :storage_system => :local,
+      :local_opts     => {
+        :path => @tmp_dir
+      }
+    }
+    
+    @runner = SweetyBacky::Runner.new
+    @runner.config( @opts )
+  end
+  
+  def teardown
+    FileUtils.rm_rf @tmp_dir  if File.exists?(@tmp_dir)
+  end
+  
+  def test_do_backup_yearly
+    Delorean.time_travel_to( '2009-12-31' ) do
+      @runner.do_backup
+    end
+    
+    assert( File.exists?( "#{@tmp_dir}/files/#{SweetyBacky::Utils.namerize( @opts[:paths][0] )}.20091231.yearly.tar.gz") )
+    assert( File.exists?( "#{@tmp_dir}/databases/test.20091231.yearly.sql.tar.gz") )
+  end
+  
+  def test_do_backup_monthly    
+    Delorean.time_travel_to( '2010-01-31' ) do
+      @runner.do_backup
+    end
+
+    assert( File.exists?( "#{@tmp_dir}/files/#{SweetyBacky::Utils.namerize( @opts[:paths][0] )}.20100131.monthly.tar.gz") )
+    assert( File.exists?( "#{@tmp_dir}/databases/test.20100131.monthly.sql.tar.gz") )
+  end
+  
+  def test_do_backup_weekly    
+    Delorean.time_travel_to( '2010-01-03' ) do
+      @runner.do_backup
+    end
+    
+    assert( File.exists?( "#{@tmp_dir}/files/#{SweetyBacky::Utils.namerize( @opts[:paths][0] )}.20100103.weekly.tar.gz") )
+    assert( File.exists?( "#{@tmp_dir}/databases/test.20100103.weekly.sql.tar.gz") )
+  end
+  
+  def test_do_backup_daily
+    Delorean.time_travel_to( '2010-01-04' ) do
+      @runner.do_backup
+    end
+    
+    assert( File.exists?( "#{@tmp_dir}/files/#{SweetyBacky::Utils.namerize( @opts[:paths][0] )}.20100104.daily.tar.gz") )
+    assert( File.exists?( "#{@tmp_dir}/databases/test.20100104.daily.sql.tar.gz") )
+  end
+
+  def test_run
+    @runner.expects(:do_backup)
+    SweetyBacky::Commander.expects(:clear)
+    
+    @runner.run
+  end
+  
+  def test_initialize_with_config_file
+    SweetyBacky::OptsReader.expects( :read_opts ).with( '/path/config.yml' ).returns( 
+      { 
+        :paths => [ 'pepe', 'juan' ],
+        :local_opts => {
+          :path => '/local/path'
+        }
+      }
+    )
+    
+    runner = SweetyBacky::Runner.new( "/path/config.yml" )
+    
+    assert_equal( [ "pepe", "juan" ], runner.opts[:paths] )
+    assert_equal( [], runner.opts[:databases] )
+    assert_equal( 1, runner.opts[:yearly] )
+    assert_equal( 1, runner.opts[:monthly] )
+    assert_equal( 2, runner.opts[:weekly] )
+    assert_equal( 4, runner.opts[:daily] )
+    assert_equal( :local, runner.opts[:storage_system] )
+    assert_equal( '/local/path', runner.opts[:local_opts][:path] )
+  end
+    
+end
+

data/test/s3/commander_s3_test.rb

@@ -0,0 +1,100 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class CommanderS3Test < Test::Unit::TestCase
+  
+  def setup
+    SweetyBacky::Utils.stubs(:log)
+
+    @opts = {
+      :paths        => [ 'name1', 'name2' ],
+      :databases    => [ 'name1', 'name2' ],
+      :yearly       => 1,
+      :monthly      => 2,
+      :weekly       => 3,
+      :daily        => 4,
+      :storage_system => :s3,
+      :s3_opts => {
+        :bucket       => 'sweety_backy_test',
+        :path         => 'test/path',
+        :passwd_file  => '~/.s3.passwd'
+      },
+      :working_path => @tmp_dir
+    }
+    
+    s3 = ::S3::Service.new( SweetyBacky::S3.read_s3_password( @opts[:s3_opts][:passwd_file] ) )
+        
+    @bucket = s3.buckets.build( @opts[:s3_opts][:bucket] )
+    @bucket.save
+  end
+
+  def teardown
+    @bucket.destroy( true )
+  end
+
+  def test_clear    
+    [
+      'name1.20081231.yearly',
+      'name1.20081232.yearly',
+      'name2.20091231.yearly',
+      'name1.20100131.monthly',
+      'name1.20100228.monthly',
+      'name1.20100331.monthly',
+      'name2.20100430.monthly',
+      'name2.20100531.monthly',
+      'name2.20100630.monthly',
+      'name1.20100704.weekly',
+      'name1.20100711.weekly',
+      'name1.20100718.weekly',
+      'name1.20100725.weekly',
+      'name1.20100720.daily',
+      'name2.20100721.daily',
+      'name2.20100722.daily',
+      'name2.20100723.daily',
+      'name2.20100724.daily',
+      'name2.20100726.daily'
+    ].each do |file_part|
+      SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "#{@opts[:s3_opts][:path]}/files/#{file_part}.tar.gz", @opts[:s3_opts] )
+      SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "#{@opts[:s3_opts][:path]}/databases/#{file_part}.sql.tar.gz", @opts[:s3_opts] )
+    end
+    
+    SweetyBacky::Commander.clear( @opts )
+    
+    files_keeped = SweetyBacky::S3.paths_in( "#{@opts[:s3_opts][:path]}/files/*", @opts[:s3_opts] ).join( "\n" )
+    databases_keeped = SweetyBacky::S3.paths_in( "#{@opts[:s3_opts][:path]}/databases/*", @opts[:s3_opts] ).join( "\n" )
+    
+    # files to keep
+    [
+      'name1.20081232.yearly',
+      'name2.20091231.yearly',
+      'name1.20100228.monthly',
+      'name1.20100331.monthly',
+      'name2.20100531.monthly',
+      'name2.20100630.monthly',
+      'name1.20100718.weekly',
+      'name1.20100725.weekly',
+      'name1.20100720.daily',
+      'name2.20100722.daily',
+      'name2.20100723.daily',
+      'name2.20100724.daily',
+      'name2.20100726.daily'
+    ].each do |file_part|
+      assert_match( "#{file_part}.tar.gz", files_keeped )
+      assert_match( "#{file_part}.sql.tar.gz", databases_keeped )
+    end
+    
+    # files to deleted
+    [
+      'name1.20081231.yearly',
+      'name1.20100131.monthly',
+      'name2.20100430.monthly',
+      'name1.20100704.weekly',
+      'name2.20100721.daily'
+    ].each do |file_part|
+      assert_no_match( /#{file_part}.tar.gz/, files_keeped )
+      assert_no_match( /#{file_part}.sql.tar.gz/, databases_keeped )
+    end
+  end
+
+    
+end
+

data/test/s3/runner_s3_test.rb

@@ -0,0 +1,59 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+class RunnerS3Test < Test::Unit::TestCase
+  
+  def setup
+    SweetyBacky::Utils.stubs(:log)
+    
+    # runner
+    @opts = {
+      :paths          => [ "#{FIXTURES_PATH}/path" ],
+      :databases      => [ "test" ],
+      :yearly         => 1,
+      :monthly        => 1,
+      :weekly         => 2,
+      :daily          => 4,
+      :database_user  => 'test',
+      :database_pass  => '',
+      :storage_system => :s3,
+      :s3_opts => {
+        :bucket             => 'sweety_backy_test',
+        :passwd_file        => '~/.s3.passwd',
+        :path               => 'test/path'
+      }
+    }
+    
+    @runner = SweetyBacky::Runner.new
+    @runner.config( @opts )
+    
+    s3 = ::S3::Service.new( SweetyBacky::S3.read_s3_password( @opts[:s3_opts][:passwd_file] ) )
+    @bucket = s3.buckets.build( @opts[:s3_opts][:bucket] )
+    @bucket.save
+  end
+
+  def teardown
+    @bucket.destroy( true )
+  end
+  
+  def test_do_backup_daily
+    SweetyBacky::Utils.stubs( :period ).returns( 'daily' )
+    
+    @runner.do_backup
+    
+    assert( 
+      @bucket.
+        object( 
+          "test/path/files/#{SweetyBacky::Utils.namerize( @opts[:paths][0] )}.#{Date.today.strftime('%Y%m%d')}.daily.tar.gz"
+        ).exists? 
+    )
+    
+    assert( 
+      @bucket.
+        object( 
+          "test/path/databases/test.#{Date.today.strftime('%Y%m%d')}.daily.sql.tar.gz"
+        ).exists? 
+    )
+  end
+    
+end
+

data/test/s3/s3_test.rb

@@ -0,0 +1,61 @@
+require "#{File.dirname(__FILE__)}/../test_helper"
+
+
+class S3Test < Test::Unit::TestCase
+  def setup
+    SweetyBacky::Utils.stubs(:log)
+
+    @opts = {
+      :bucket             => 'sweety_backy_test',
+      :path               => 'test_path',
+      :passwd_file        => '~/.s3.passwd'
+    }
+    
+    s3 = ::S3::Service.new( SweetyBacky::S3.read_s3_password( @opts[:passwd_file] ) )
+    @bucket = s3.buckets.build( @opts[:bucket] )
+    @bucket.save
+  end
+  
+  def teardown
+    @bucket.destroy( true )
+  end
+  
+  def test_upload
+    SweetyBacky::S3.upload(
+      "#{FIXTURES_PATH}/file.txt",
+      "test/path/file.txt",
+      @opts
+    )
+    
+    assert_equal(
+      File.read( "#{FIXTURES_PATH}/file.txt" ),
+      SweetyBacky::S3.object( "test/path/file.txt", @opts ).content
+    )
+  end
+  
+  def test_paths_in
+    SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "test/path/file1.txt", @opts )
+    SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "test/path/file2.txt", @opts )
+    SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "test/path/file3.txt", @opts )
+    SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "test/path/other_file.txt", @opts )
+    
+    paths = SweetyBacky::S3.paths_in( "test/path/file*.txt", @opts )
+    
+    assert_equal(3, paths.size)
+    assert( ( paths.include? "test/path/file1.txt" ) )
+    assert( ( paths.include? "test/path/file2.txt" ) )
+    assert( ( paths.include? "test/path/file3.txt" ) )
+    assert( ( !paths.include? "test/path/other_file.txt" ) )
+  end
+  
+  def test_delete
+    SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "test/path/file1.txt", @opts )
+    SweetyBacky::S3.upload( "#{FIXTURES_PATH}/file.txt", "test/path/file2.txt", @opts )
+    
+    SweetyBacky::S3.delete( "test/path/file2.txt", @opts )
+    
+    assert( @bucket.object( "test/path/file1.txt" ).exists? )
+    assert( !@bucket.object( "test/path/file2.txt" ).exists? )
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require "#{File.dirname(__FILE__)}/../lib/sweety_backy"
+
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'delorean'
+
+
+FIXTURES_PATH = File.expand_path "#{File.dirname(__FILE__)}/fixtures"

data/test/utils_test.rb

@@ -0,0 +1,24 @@
+require "#{File.dirname(__FILE__)}/test_helper"
+
+class UtilsTest < Test::Unit::TestCase
+  def setup
+    SweetyBacky::Utils.stubs(:log)
+  end
+  
+  def test_error_on_command
+    assert_raise RuntimeError do
+      SweetyBacky::Utils::command( 'command_not_exists' )
+    end
+  end
+  
+  def test_namerize
+    assert_equal( 
+      'Users.fguillen.Develop.Ruby.SweetyBacky.test.fixtures.path', 
+      SweetyBacky::Utils.namerize( '/Users/fguillen/Develop/Ruby/SweetyBacky/test/fixtures/path' ) 
+    )
+    
+    assert_equal( 'path', SweetyBacky::Utils.namerize( '/path' ) )
+    assert_equal( 'path', SweetyBacky::Utils.namerize( 'path' ) )
+  end
+  
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification 
+name: sweety_backy
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Fernando Guillen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-05 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15424057
+        segments: 
+        - 1
+        - 0
+        - 0
+        - rc
+        - 6
+        version: 1.0.0.rc.6
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: delorean
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: s3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: Simple mechanism to configure and execute backups of folders and MySQL DBs and store them in local folder or S3 bucket
+email: 
+- fguillen.mail@gmail.com
+executables: 
+- sweety_backy
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc_example
+- Gemfile
+- README.md
+- Rakefile
+- bin/sweety_backy
+- lib/sweety_backy.rb
+- lib/sweety_backy/commander.rb
+- lib/sweety_backy/opts_reader.rb
+- lib/sweety_backy/runner.rb
+- lib/sweety_backy/s3.rb
+- lib/sweety_backy/utils.rb
+- lib/sweety_backy/version.rb
+- server1/backups/databases/test.20100104.daily.sql.tar.gz
+- server1/backups/files/Users.fguillen.Develop.Ruby.SweetyBacky.test.fixtures.path.20100104.daily.tar.gz
+- sweety_backy.gemspec
+- test/commander_test.rb
+- test/fixtures/config_s3.yml
+- test/fixtures/file.txt
+- test/fixtures/path/a/file2.txt
+- test/fixtures/path/b/file3.txt
+- test/fixtures/path/file1.txt
+- test/fixtures/s3.passwd
+- test/opts_reader_test.rb
+- test/runner_test.rb
+- test/s3/commander_s3_test.rb
+- test/s3/runner_s3_test.rb
+- test/s3/s3_test.rb
+- test/test_helper.rb
+- test/utils_test.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: SweetyBacky
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby backup mechanism
+test_files: 
+- test/commander_test.rb
+- test/fixtures/config_s3.yml
+- test/fixtures/file.txt
+- test/fixtures/path/a/file2.txt
+- test/fixtures/path/b/file3.txt
+- test/fixtures/path/file1.txt
+- test/fixtures/s3.passwd
+- test/opts_reader_test.rb
+- test/runner_test.rb
+- test/s3/commander_s3_test.rb
+- test/s3/runner_s3_test.rb
+- test/s3/s3_test.rb
+- test/test_helper.rb
+- test/utils_test.rb