dabcup 0.1.2

data/LICENSE

@@ -0,0 +1,50 @@
+Dabcup is copyrighted free software by Alexis Bernard <alexis [at] obloh [dot] com>.
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/README.rdoc

@@ -0,0 +1,14 @@
+== What is it?
+Dabcup is a tool in order to handle databases backups easily. You can centralize
+all you backup policies on a single server, and then store dumps to many different
+hosts (SSH, S3, FTP).
+
+== How does it work?
+You just need to describe your policies in a simple configuration (see conf/dabcup.yml)
+and then run the command: `dabcup foo dump` to backup your database 'foo'.
+
+== How to install it?
+You need Ruby plus the following gems: aws-s3 and net-ssh.
+
+sudo apt-get install ruby rubygems
+sudo gem install aws-s3 net-ssh

data/bin/dabcup

@@ -0,0 +1,18 @@
+#! /usr/bin/env ruby
+
+require 'pathname'
+
+app_dir = Pathname.new(__FILE__).realpath().dirname().dirname()
+lib_dir = File.join(app_dir, 'lib')
+$LOAD_PATH << lib_dir
+
+require 'yaml'
+require 'dabcup'
+
+begin
+  require 'rubygems'
+rescue LoadError => ex
+end
+
+app = Dabcup::App.new(app_dir)
+app.main(ARGV)

data/config/dabcup.yml

@@ -0,0 +1,16 @@
+# Sample config file for dabcup.
+
+foo:
+  dump: pg_dump -U postgres foo -f %{dump_path}
+  restore: pg_restore -U postgres -d foo -f %{dump_path}
+  storage: file:///home/foo/dumps
+  spare_storage: s3://MY_KEY:MY_SECRET@MY_BUCKET.s3.amazonaws.com
+  retention: 10
+
+bar:
+  tunnel: ssh://me@sql.my-site.com
+  dump: mysqldump my_db > %{dump_path}
+  storage: ftp://bar:password@backup.my-site.com/dumps
+  spare_storage: sftp://bar@other-backup.my-site.com:/home/bar/dumps
+  retention: 10
+

data/lib/dabcup.rb

@@ -0,0 +1,16 @@
+module Dabcup
+  def self.time_to_name(time)
+    time.strftime('%Y-%m-%dT%H:%M:%S') + '.dump'
+  end
+  
+  class Error < StandardError
+  end
+end
+
+require 'tmpdir'
+
+require 'dabcup/app'
+require 'dabcup/database'
+require 'dabcup/storage'
+require 'dabcup/operation'
+require 'dabcup/help'

data/lib/dabcup/app.rb

@@ -0,0 +1,60 @@
+require 'logger'
+
+module Dabcup
+  class App
+    DABCUP_PATH = File.expand_path('~/.dabcup')
+    CONFIG_PATHS = ['dabcup.yml', '~/.dabcup/profiles.yml', '/etc/dabcup/profiles.yml'].freeze
+
+    attr_reader :config
+    attr_reader :profiles
+
+
+    def initialize(app_dir)
+      @app_dir = app_dir
+    end
+    
+    def main(args)
+      if args.size < 1
+        puts "Try 'dabcup help'."
+      elsif ['help', '-h', '--help', '?'].include?(args[0])
+        help(args)
+      else
+        run(args)
+      end
+    #rescue Dabcup::Error => ex
+    #  $stderr.puts ex.message
+    #rescue => ex
+    #  $stderr.puts ex.message
+    #  $stderr.puts 'See log for more informations.'
+    #  Dabcup::fatal(ex)
+    end
+    
+    def run(args)
+      database_name, operation_name = args[0 .. 1]
+      raise Dabcup::Error.new("Database '#{database_name}' doesn't exist.") unless config[database_name]
+      database = Database.new(database_name, config[database_name])
+      operation = Operation.build(operation_name, database)
+      operation.run(args)
+    ensure
+      operation.terminate if operation
+    end
+    
+    def help(args)
+      puts Dabcup::Help.message(args[1])
+    end
+    
+    private
+    
+    def load_yaml(file_path)
+      File.open(File.expand_path(file_path)) do |stream| YAML.load(stream) end
+    end
+    
+    def config_path
+      CONFIG_PATHS.find { |path| File.exists?(path) }
+    end
+    
+    def config
+      @config ||= YAML.load_file(config_path)
+    end
+  end
+end

data/lib/dabcup/database.rb

@@ -0,0 +1,59 @@
+require 'open3'
+require 'net/ssh'
+
+module Dabcup
+  class Database
+    attr_reader :name
+    attr_reader :config
+    attr_reader :main_storage
+    attr_reader :spare_storage
+    
+    def initialize(name, config)
+      @name = name
+      @config = config
+      @main_storage = Dabcup::Storage.new(config['storage'])
+      @spare_storage = Dabcup::Storage.new(config['spare_storage']) if config['spare_storage']
+      extend(Tunnel) if tunnel
+    end
+
+    def tunnel
+      @tunnel ||= Addressable::URI.parse(config['tunnel']) if config['tunnel']
+    end
+
+    def via_ssh?
+      tunnel != nil
+    end
+    
+    def dump(dump_path)
+      system(config['dump'], :dump_path => File.expand_path(dump_path))
+    end
+    
+    def system(command, interpolation = {})
+      command = command % interpolation
+      # TODO Found a nice way to get the exit status.
+      stdin, stdout, stderr = Open3.popen3(command + "; echo $?")
+      raise Dabcup::Error.new("Failed to execute '#{command}', stderr is '#{stderr.read}'.") if not stderr.eof?
+      [stdin, stdout, stderr]
+    end
+
+    def retention
+      config['retention']
+    end
+  end
+
+  module Tunnel
+    def system(command, interpolation = {})
+      command = command % interpolation
+      stdout = ssh.exec!(command)
+    end
+    
+    def ssh
+      @ssh ||= Net::SSH.start(tunnel.host, tunnel.user, :password => tunnel.password)
+    end
+    
+    def disconnect
+      @ssh.close if @ssh
+    end
+  end
+end
+

data/lib/dabcup/help.rb

@@ -0,0 +1,86 @@
+class Dabcup::Help
+  def self.message(name)
+    @@messages[name]
+  end
+  
+  default_help = <<__HELP__
+Usage:
+  dabcup <profile> <operation> [parameters]
+
+Operations:
+  clean
+  clear
+  delete
+  get
+  list
+  populate
+  restore
+  store
+
+Try 'dabcup help <operation>' to get details.
+Visit http://dabcup.obloh.com for more informations.
+__HELP__
+ 
+  @@messages = Hash.new(default_help)
+  
+  @@messages['clean'] = <<__HELP__
+Removes old dumps from the storage and the spare storage. Clean rules are
+specified int the 'keep' section of your profile.
+
+my-profile:
+  keep:
+    days_of_week: 1     # Keeps all dumps of the first day of the week
+    less_days_than: 50  # Keep dumps younger than 50 days
+
+dabcup <profile> clean
+__HELP__
+
+  @@messages['clear'] = <<__HELP__
+Delete all dumps from the main and the spare storages. Use safely this operation
+because no confirmation is asked.
+
+dabcup <profile> clear
+__HELP__
+  
+  @@messages['delete'] = <<__HELP__
+Deletes the specified dump.
+
+dabcup <profile> <dump>
+__HELP__
+  
+  @@messages['get'] = <<__HELP__
+Retrieves the specified dump from the main or the spare storage. The local path
+represents where you want to retrieve the dump. If not specified the dump will
+be downloaded into the current directory.
+
+dabcup <profile> get <dump> [<local_path>]
+__HELP__
+
+  @@messages['list'] = <<__HELP__
+Lists dumps of the both storages. The flags 'M' and 'S' means if the dump is
+in the main and/or the spare storage.
+
+dabcup <profile> list
+__HELP__
+
+  @@messages['populate'] = <<__HELP__
+The purpose of this operation is only to help you to test clean rules. It 
+populates the main and the spare storages with n backups. Each backup get back a
+day before.
+
+dabcup <profile> populate <n>
+__HELP__
+  
+  @@messages['restore'] = <<__HELP__
+Download the specified dump from the storage, or the spare storage,
+and restore it to the database. Use 'list' operation to see dumps.
+
+dabcup <profile> restore <dump>
+__HELP__
+
+  @@messages['store'] = <<__HELP__
+Dump the database, and upload it to the storage, and sare storage it set.
+
+dabcup <profile> store
+__HELP__
+end

data/lib/dabcup/operation.rb

@@ -0,0 +1,29 @@
+require 'dabcup/operation/base'
+require 'dabcup/operation/clean'
+require 'dabcup/operation/clear'
+require 'dabcup/operation/remove'
+require 'dabcup/operation/get'
+require 'dabcup/operation/list'
+require 'dabcup/operation/populate'
+require 'dabcup/operation/restore'
+require 'dabcup/operation/dump'
+
+module Dabcup
+  module Operation
+    def self.build(name, config)
+      case name
+      when 'dump' then Dabcup::Operation::Dump.new(config)
+      when 'restore' then Dabcup::Operation::Restore.new(config)
+      when 'list' then Dabcup::Operation::List.new(config)
+      when 'get' then Dabcup::Operation::Get.new(config)
+      when 'remove' then Dabcup::Operation::Remove.new(config)
+      when 'clear' then Dabcup::Operation::Clear.new(config)
+      when 'clean' then Dabcup::Operation::Clean.new(config)
+      when 'populate' then Dabcup::Operation::Populate.new(config)
+      when 'test' then Dabcup::Operation::Test.new(config)
+      else
+        raise Dabcup::Error.new("Unknow operation '#{name}'.")
+      end
+    end
+  end
+end

data/lib/dabcup/operation/base.rb

@@ -0,0 +1,54 @@
+module Dabcup
+  module Operation
+    class Base
+      attr_reader :database
+      extend Forwardable
+      def_delegators :database, :main_storage, :spare_storage
+
+      def initialize(database)
+        @database = database
+      end
+
+      def run
+        raise NotImplementedError.new("Sorry")
+      end
+
+      def terminate
+        main_storage.disconnect if main_storage
+        spare_storage.disconnect if spare_storage
+      end
+
+      # Try to returns the best directory path to dump the database.
+      def best_dumps_path
+        if database.via_ssh?
+          return main_storage.path if same_ssh_as_database?(main_storage)
+        else
+          return main_storage.path if main_storage.local?
+        end
+        Dir.tmpdir
+      end
+
+      # Try to returns the best local directory path.
+      def best_local_dumps_path
+        return spare_storage.path if spare_storage.local?
+        Dir.tmpdir
+      end
+
+      def remove_local_dump?
+        !main_storage.local? && (spare_storage && !spare_storage.local?)
+      end
+
+      def same_ssh_as_database?(storage)
+        return false if not storage.driver.is_a?(Dabcup::Storage::Driver::SFTP)
+        storage.driver.host == database.tunnel.host
+      end
+
+      def check
+        return if not database.via_ssh?
+        if not same_ssh_as_database?(main_storage)
+          raise Error.new("When dumping via SSH the main storage must be local to the database.")
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/operation/clean.rb

@@ -0,0 +1,19 @@
+module Dabcup
+  module Operation
+    class Clean < Base
+      def run(args)
+        clean_storage(main_storage)
+        clean_storage(spare_storage) if spare_storage
+      end
+
+      private
+
+      def clean_storage(storage)
+        if (retention = database.retention.to_i) < 1
+          raise Error.new("Retention must be greater than zero")
+        end
+        storage.delete(storage.list[0 .. -retention-1])
+      end
+    end
+  end
+end

data/lib/dabcup/operation/clear.rb

@@ -0,0 +1,10 @@
+module Dabcup
+  module Operation
+    class Clear < Base
+      def run(args)
+        main_storage.clear
+        spare_storage.clear if spare_storage
+      end
+    end
+  end
+end

data/lib/dabcup/operation/dump.rb

@@ -0,0 +1,50 @@
+module Dabcup
+  module Operation
+    class Dump < Base
+      def run(args)
+        database.dump(dump_path)
+        copy_dump_to_main_storage
+        copy_dump_to_spare_storage
+      ensure
+        path = local_dump_path || dump_path
+        File.delete(path) if remove_local_dump? && File.exists?(path)
+      end
+
+      private
+
+      def copy_dump_to_main_storage
+        unless main_storage.exists?(dump_name)
+          retrieve_dump_from_remote_database if retrieve_dump_from_remote_database?
+          main_storage.put(dump_path, dump_name)
+        end
+      end
+
+      def copy_dump_to_spare_storage
+        if spare_storage && !spare_storage.exists?(dump_name)
+          main_storage.get(dump_name, local_dump_path) unless File.exists?(local_dump_path)
+          spare_storage.put(local_dump_path, dump_name) unless spare_storage.exists?(dump_name)
+        end
+      end
+
+      def dump_name
+        @dump_name ||= database.name + '_' + Dabcup::time_to_name(Time.now)
+      end
+
+      def dump_path
+        @dump_path ||= File.join(best_dumps_path, dump_name)
+      end
+
+      def local_dump_path
+        File.exists?(dump_path) ? dump_path : File.join(best_local_dumps_path, dump_name)
+      end
+
+      def retrieve_dump_from_remote_database
+        Storage::Driver.build(database.tunnel.to_s + '/tmp').get(dump_name, local_dump_path)
+      end
+
+      def retrieve_dump_from_remote_database?
+        database.via_ssh? && !same_ssh_as_database?(main_storage)
+      end
+    end
+  end
+end

data/lib/dabcup/operation/get.rb

@@ -0,0 +1,20 @@
+module Dabcup
+  module Operation
+    class Get < Base
+      def run(args)
+        raise Dabcup::Error.new("Not enough arguments. Try 'dabcup help get'.") if args.size < 3
+        dump_name = args[2]
+        local_path = args[3] || dump_name
+        local_path = File.join(local_path, dump_name) if File.directory?(local_path)
+        local_path = File.expand_path(local_path)
+        if main_storage.exists?(dump_name)
+          main_storage.get(dump_name, local_path)
+        elsif spare_storage.exists?(dump_name)
+          spare_storage.get(dump_name, local_path)
+        else
+          raise Dabcup::Error.new("Dump '#{dump_name}' not found.")
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/operation/list.rb

@@ -0,0 +1,23 @@
+module Dabcup
+  module Operation
+    class List < Base
+      def run(args)
+        max_length = 0
+        main_dumps = main_storage.list
+        spare_dumps = spare_storage ? spare_storage.list : []
+        # Intersection of main_dumps and spare_dumps
+        dumps = main_dumps + spare_dumps.select do |dump| not main_dumps.include?(dump) end
+        # Get length of the longest name
+        max_length= (dumps.map {|d| d.name}.max {|l, r| l <=> r} || '').size
+        # Prints names, sizes and flags
+        dumps.each do |dump|
+          name_str = dump.name.ljust(max_length + 2)
+          size_str = (dump.size / 1024).to_s.rjust(8)
+          location = main_dumps.include?(dump) ? 'M' : ' '
+          location += spare_dumps.include?(dump) ? 'S' : ' '
+          puts "#{name_str}#{size_str} KB #{location}"
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/operation/populate.rb

@@ -0,0 +1,20 @@
+module Dabcup
+  module Operation
+    class Populate < Base
+      def run(args)
+        now = Time.now
+        days_before = args[2].to_i
+        local_file_name = Dabcup::Database::dump_name(database)
+        local_file_path = File.join(Dir.tmpdir, local_file_name)
+        database.dump(local_file_path)
+        for day_before in (0 .. days_before)
+          remote_file_name = Dabcup::Database::dump_name(database, now - (day_before * 24 * 3600))
+          main_storage.put(local_file_path, remote_file_name)
+          spare_storage.put(local_file_path, remote_file_name) if spare_storage
+        end
+        ensure
+          File.delete(local_file_path) if local_file_path and File.exists?(local_file_path)
+      end
+    end
+  end
+end

data/lib/dabcup/operation/remove.rb

@@ -0,0 +1,15 @@
+module Dabcup
+  module Operation
+    class Remove < Base
+      def run(args)
+        raise Dabcup::Error.new("Not enough arguments. Try 'dabcup help delete'") if args.size < 3
+        remove_from_storage(main_storage, args[2])
+        remove_from_storage(spare_storage, args[2])
+      end
+
+      def remove_from_storage(storage, name)
+        storage.delete(name) if storage.exists?(name)
+      end
+    end
+  end
+end

data/lib/dabcup/operation/restore.rb

@@ -0,0 +1,41 @@
+module Dabcup
+  module Operation
+    class Restore < Base
+      def run(args)
+        database.via_ssh? ? restore_with_ssh(args) : restore_without_ssh(args)
+      end
+
+      def restore_without_ssh(args)
+        raise Dabcup::Error.new("Not enough arguments. Try 'dabcup help restore'") if args.size < 3
+        dump_name = args[2]
+        dump_path = File.join(Dir.tmpdir, dump_name)
+        if main_storage.exists?(dump_name)
+          main_storage.get(dump_name, dump_path)
+        elsif spare_storage and spare_storage.exists?(dump_name)
+          spare_storage.get(dump_name, dump_path)
+        else
+          raise Dabcup::Error.new("Dump '#{dump_name}' not found.")
+        end
+        database.restore(dump_path)
+      end
+
+      def retore_with_ssh(args)
+        raise Dabcup::Error.new("Not enough arguments. Try 'dabcup help restore'") if args.size < 3
+        dump_name = args[2]
+        dump_path = File.join(main_storage.path, dump_name)
+        local_dump_path = nil
+        if not main_storage.exists?(dump_name)
+          if spare_storage.is_a?(Dabcup::Storage::Local)
+            local_dump_path = File.join(spare_storage.path, dump_name)
+          else
+            spare_storage.get(dump_name, local_dump_path)
+          end
+          main_storage.put(dump_path, dump_name) if not main_storage.exists?(dump_name)
+        end
+        database.restore(dump_path)
+      ensure
+        #File.delete(local_dump_path) if local_dump_path and File.exists?(local_dump_path)
+      end
+    end
+  end
+end

data/lib/dabcup/storage.rb

@@ -0,0 +1,99 @@
+require 'time'
+require 'net/ftp'
+require 'fileutils'
+
+require 'dabcup/storage/driver/base'
+require 'dabcup/storage/driver/local'
+require 'dabcup/storage/driver/sftp'
+require 'dabcup/storage/driver/ftp'
+require 'dabcup/storage/driver/s3'
+
+require 'dabcup/storage/dump'
+
+module Dabcup
+  class Storage
+    attr_reader :rules, :driver
+
+    def initialize(url)
+      @driver = Driver.build(url)
+    end 
+
+    def path
+      @driver.path
+    end
+
+    def disconnect
+      @driver.disconnect
+    end
+
+    def local?
+      @driver.local?
+    end
+
+    def put(local_path, remote_name)
+      @driver.put(local_path, remote_name)
+    end
+
+    def get(remote_name, local_path)
+      @driver.get(remote_name, local_path)
+    end
+
+    def list
+      dumps = @driver.list.inject([]) { |array, dump| dump.valid? ? array << dump : array }
+      dumps.sort { |left, right| left.created_at <=> right.created_at }
+    end
+    
+    def delete(dump_or_string_or_array)
+      file_names = array_of_dumps_names(dump_or_string_or_array)
+      file_names.each { |file_name| @driver.delete(file_name) }
+    end
+    
+    def clear
+      delete(list)
+    end
+    
+    def exists?(name)
+      list.any? { |dump| dump.name == name }
+    end
+    
+    def dump_name?(name)
+      return false
+    end
+
+    def find_by_name(file_name)
+      list.find { |dump| dump.name == file_name }
+    end
+    
+    def name
+      "#{@login}@#{@host}:#{port}:#{@path}"
+    end
+    
+    def default_port(port)
+      @port = port if @port.nil? or @port.empty?
+    end
+    
+    # Returns an array of String representing dumps names.
+    # If the argument is an array it must contains only String or Dump objects.
+    def array_of_dumps_names(dump_or_string_or_array)
+      case dump_or_string_or_array
+      when String
+        [dump_or_string_or_array]
+      when Dump
+        [dump_or_string_or_array.name]
+      when Array
+        dump_or_string_or_array.map do |dump_or_string|
+          case dump_or_string
+          when String
+            dump_or_string
+          when Dump
+            dump_or_string.name
+          else
+            raise ArgumentError.new("Expecting an array of String or Dump instead of #{dump_or_string.class}")
+          end
+        end
+      else
+        raise ArgumentError.new("Expecting a String or Dump or and Array instead of #{dump_or_string_or_array.class}")
+      end
+    end
+  end
+end

data/lib/dabcup/storage/driver/base.rb

@@ -0,0 +1,66 @@
+require 'addressable/uri'
+require 'forwardable'
+
+module Dabcup
+  class Storage
+    module Driver
+      def self.build(url)
+        if url.include?('file://')
+          Dabcup::Storage::Driver::Local.new(url)
+        elsif url.include?('ssh://')
+          Dabcup::Storage::Driver::SFTP.new(url)
+        elsif url.include?('ftp://')
+          Dabcup::Storage::Driver::FTP.new(url)
+        elsif url.include?('s3://')
+          Dabcup::Storage::Driver::S3.new(url)
+        elsif url.include?('ftp://')
+          Dabcup::Storage::Driver::FTP.new(url)
+        else
+          raise "No driver found for '#{url}'"
+        end
+      end
+
+      class Base
+        attr_reader :uri
+        extend Forwardable
+        def_delegators :@uri, :host, :port, :user, :password, :path
+        
+        def initialize(uri)
+          @uri = Addressable::URI.parse(uri)
+        end
+
+        ################################
+        ##### Methods to implement #####
+        ################################
+
+        def disconnect
+          raise NotImplementedError
+        end
+
+        def put(local_path, remote_name)
+          raise NotImplementedError
+        end
+
+        def get(remote_name, local_path)
+          raise NotImplementedError
+        end
+
+        def list
+          raise NotImplementedError
+        end
+
+        def delete(dump_name)
+          raise NotImplementedError
+        end
+
+        def protocol
+          raise NotImplementedError
+        end
+
+        def local?
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/storage/driver/ftp.rb

@@ -0,0 +1,72 @@
+module Dabcup
+  class Storage
+    module Driver
+      class FTP < Base
+        def put(local_path, remote_name)
+          remote_path = File.join(path, remote_name)
+          ftp.putbinaryfile(local_path, remote_path)
+        end
+
+        def get(remote_name, local_path)
+          remote_path = File.join(path, remote_name)
+          ftp.getbinaryfile(remote_path, local_path)
+        end
+
+        def list
+          dumps = []
+          lines = ftp.list(path)
+          lines.collect do |str|
+            fields = str.split(' ')
+            next unless Dump.valid_name?(fields[8])
+            dumps << Dabcup::Storage::Dump.new(:name => fields[8], :size => fields[4].to_i)
+          end
+          dumps
+        end
+
+        def delete(file_name)
+          file_path = File.join(path, file_name)
+          ftp.delete(file_path)
+        end
+
+        def ftp
+          unless @ftp
+            @ftp = Net::FTP.new
+            @ftp.connect(host, port || 21)
+            @ftp.login(user, password)
+            mkdirs
+          end
+          @ftp
+        end
+
+        def disconnect
+          @ftp.close if @ftp
+        end
+
+        def local?
+          false
+        end
+
+        def mkdirs
+          dirs = []
+          path = path
+          first_exception = nil
+          begin
+            ftp.nlst(path)
+          rescue Net::FTPTempError => ex
+            dirs << path
+            path = File.dirname(path)
+            first_exception = ex unless first_exception
+            if path == '.'
+              raise first_exception
+            else
+              retry
+            end
+          end
+          dirs.reverse.each do |dir|
+            ftp.mkdir(dir)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/storage/driver/local.rb

@@ -0,0 +1,52 @@
+module Dabcup
+  class Storage
+    module Driver
+      class Local < Base
+        def protocol
+          'file'
+        end
+
+        def initialize(url)
+          super(url)
+          @path = File.expand_path(url.sub('file://', ''))
+        end
+
+        def put(local_path, remote_name)
+          remote_path = File.join(@path, remote_name)
+          FileUtils.copy(local_path, remote_path)
+        end
+
+        def get(remote_name, local_path)
+          connect
+          remote_path = File.join(@path, remote_name)
+          FileUtils.copy(remote_path, local_path)
+        end
+
+        def list
+          dumps = []
+          Dir.foreach(@path) do |name|
+            dumps << Dump.new(:name => name, :size => File.size(File.join(@path, name)))
+          end
+          dumps
+        end
+
+        def delete(file_name)
+          file_path = File.join(@path, file_name)
+          File.delete(file_path)
+        end
+
+        def connect
+          FileUtils.mkpath(@path) if not File.exist?(@path)
+          raise DabcupError.new("The path '#{@path}' is not a directory.") if not File.directory?(@path)
+        end
+
+        def disconnect
+        end
+
+        def local?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/storage/driver/s3.rb

@@ -0,0 +1,71 @@
+module Dabcup
+  class Storage
+    module Driver
+      # Amazon S3
+      class S3 < Base
+        def initialize(uri)
+          super(uri)
+          require 'aws/s3'
+        rescue LoadError => ex
+          raise Dabcup::Error.new("The library aws-s3 is missing. Get it via 'gem install aws-s3' and set RUBYOPT=rubygems.")
+        end
+
+        def protocol
+          's3'
+        end
+
+        def put(local_path, remote_path)
+          connect
+          File.open(local_path) do |file|
+            AWS::S3::S3Object.store(remote_path, file, bucket)
+          end
+        end
+
+        def get(remote_path, local_path)
+          connect
+          File.open(local_path, 'w') do |file|
+            AWS::S3::S3Object.stream(remote_path, bucket) do |stream|
+              file.write(stream)
+            end
+          end
+        end
+
+        def list
+          connect
+          AWS::S3::Bucket.find(bucket).objects.collect do |obj|
+            Dump.new(:name => obj.key.to_s, :size => obj.size)
+          end
+        end
+
+        def delete(file_name)
+          connect
+          AWS::S3::S3Object.delete(file_name, bucket)
+        end
+
+        def connect
+          return if AWS::S3::Base.connected?
+          AWS::S3::Base.establish_connection!(:access_key_id => uri.user, :secret_access_key => uri.password)
+          create_bucket
+        end
+
+        def disconnect
+          AWS::S3::Base.disconnect!
+        end
+
+        def bucket
+          @bucket ||= uri.host.split('.').first
+        end
+        
+        def local?
+          false
+        end
+
+        def create_bucket
+          AWS::S3::Bucket.list.each do |bucket|
+            return if bucket.name == bucket
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/storage/driver/sftp.rb

@@ -0,0 +1,80 @@
+require('net/sftp')
+
+module Dabcup
+  class Storage
+    module Driver
+      class SFTP < Base
+        def protocol
+          'sftp'
+        end
+
+        def put(local_path, remote_name)
+          remote_path = File.join(uri.path, remote_name)
+          sftp.upload!(local_path, remote_path)
+        end
+
+        def get(remote_name, local_path)
+          remote_path = File.join(uri.path, remote_name)
+          sftp.download!(remote_path, local_path)
+        end
+
+        def list
+          dumps = []
+          handle = sftp.opendir!(uri.path)
+          while 1
+            request = sftp.readdir(handle).wait
+            break if request.response.eof?
+            raise Dabcup::Error.new("Failed to list files from #{@login}@#{@host}:#{uri.path}") unless request.response.ok?
+            request.response.data[:names].each do |file|
+              dumps << Dump.new(:name => file.name, :size => file.attributes.size)
+            end
+          end
+          dumps
+        end
+
+        def delete(file_name)
+          file_path = File.join(uri.path, file_name)
+          sftp.remove!(file_path)
+        end
+
+        def disconnect
+          @sftp.close(nil) if @sftp
+        end
+
+        def local?
+          false
+        end
+
+        # Create directories if necessary
+        def mkdirs
+          dirs = []
+          path = uri.path
+          first_exception = nil
+          # TODO: find an exists? method
+          begin
+            sftp.dir.entries(path)
+          rescue Net::SFTP::StatusException => ex
+            dirs << path
+            path = File.dirname(path)
+            first_exception ||= ex
+            if path == '.'
+              raise first_exception
+            else
+              retry
+            end
+          end
+          dirs.reverse.each { |dir| sftp.mkdir!(dir) }
+        end
+
+        def sftp
+          unless @sftp
+            @sftp = Net::SFTP.start(uri.host, uri.user, :password => uri.password)
+            @sftp.connect
+            mkdirs
+          end
+          @sftp
+        end
+      end
+    end
+  end
+end

data/lib/dabcup/storage/dump.rb

@@ -0,0 +1,34 @@
+module Dabcup
+  class Storage
+    class Dump
+      IGNORED_NAMES = %w(. ..).freeze
+
+      attr_accessor :name
+      attr_accessor :size
+
+      def self.valid_name?(name)
+        !IGNORED_NAMES.include?(name)
+      end
+
+      def initialize(attrs = {})
+        self.name = attrs[:name]
+        self.size = attrs[:size]
+      end
+
+      def created_at
+        Time.parse(name)
+      rescue ArgumentError
+        nil # Invalid date => ignore file name
+      end
+
+      def ==(dump)
+        dump && name == dump.name && size == dump.size
+      end
+
+      def valid?
+        self.class.valid_name?(name) && created_at != nil
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: dabcup
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Alexis Bernard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-08 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: aws-s3
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.6.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: net-sftp
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.5
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: addressable
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.5
+  type: :runtime
+  version_requirements: *id003
+description: You can centralize all you backup policies on a single server, and then store dumps to many different hosts (SSH, S3, FTP).
+email: alexis@obloh.com
+executables: 
+- dabcup
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/dabcup
+- lib/dabcup.rb
+- lib/dabcup/storage/driver/ftp.rb
+- lib/dabcup/storage/driver/sftp.rb
+- lib/dabcup/storage/driver/local.rb
+- lib/dabcup/storage/driver/s3.rb
+- lib/dabcup/storage/driver/base.rb
+- lib/dabcup/storage/dump.rb
+- lib/dabcup/help.rb
+- lib/dabcup/operation/get.rb
+- lib/dabcup/operation/restore.rb
+- lib/dabcup/operation/dump.rb
+- lib/dabcup/operation/clean.rb
+- lib/dabcup/operation/remove.rb
+- lib/dabcup/operation/list.rb
+- lib/dabcup/operation/clear.rb
+- lib/dabcup/operation/base.rb
+- lib/dabcup/operation/populate.rb
+- lib/dabcup/storage.rb
+- lib/dabcup/operation.rb
+- lib/dabcup/database.rb
+- lib/dabcup/app.rb
+- config/dabcup.yml
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://dabcup.rubyforge.org/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: dabcup
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Dabcup is a tool in order to handle databases backups easily
+test_files: []
+