rehabilitate 0.3.2

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gem 'echoe', '4.3.1'
+gem 'commander', '4.0.3'
+gem 'pluginfactory', '1.0.7'
+gem 'log4r', '1.1.8'
+gem 'net-ssh', '2.0.23'
+gem 'net-scp', '1.0.4'
+gem 'fog', '0.3.25'

data/Gemfile.lock

@@ -0,0 +1,46 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    commander (4.0.3)
+      highline (>= 1.5.0)
+    echoe (4.3.1)
+      gemcutter
+      rubyforge
+    excon (0.2.4)
+    fog (0.3.25)
+      builder
+      excon (>= 0.2.4)
+      formatador (>= 0.0.16)
+      json
+      mime-types
+      net-ssh (~> 2.0.23)
+      nokogiri (~> 1.4.3.1)
+      ruby-hmac
+    formatador (0.0.16)
+    gemcutter (0.6.1)
+    highline (1.6.1)
+    json (1.4.6)
+    json_pure (1.4.6)
+    log4r (1.1.8)
+    mime-types (1.16)
+    net-scp (1.0.4)
+      net-ssh (>= 1.99.1)
+    net-ssh (2.0.23)
+    nokogiri (1.4.3.1)
+    pluginfactory (1.0.7)
+    ruby-hmac (0.4.0)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  commander (= 4.0.3)
+  echoe (= 4.3.1)
+  fog (= 0.3.25)
+  log4r (= 1.1.8)
+  net-scp (= 1.0.4)
+  net-ssh (= 2.0.23)
+  pluginfactory (= 1.0.7)

data/Manifest

@@ -0,0 +1,14 @@
+Gemfile
+Gemfile.lock
+Manifest
+README.mdown
+Rakefile
+rehabilitate.gemspec
+bin/rehabilitate
+lib/rehabilitate.rb
+lib/rehabilitate/plugin.rb
+lib/rehabilitate/plugins/lzop.rb
+lib/rehabilitate/plugins/postgresql.rb
+lib/rehabilitate/plugins/s3.rb
+lib/rehabilitate/plugins/scp.rb
+lib/rehabilitate/plugins/splitter.rb

data/README.mdown

@@ -0,0 +1,33 @@
+Rehabilitate
+============
+
+More to come, here's the comnandline output:
+
+    NAME:
+
+      Backups
+
+    DESCRIPTION:
+
+      A backup system that can be given commands to be run before and after a backup or restore
+
+    COMMANDS:
+      
+      help                 Display global or [command] help documentation.                
+      list                 List backups from a location           
+      restore              Restore a backup from a location to a database or directory            
+      save                 Save a backup from a database to a location    
+
+    GLOBAL OPTIONS:
+      
+      -d, --debug 
+          More verbose logging and nothing is actually run
+      
+      -h, --help 
+          Display help documentation
+      
+      -v, --version 
+          Display version information
+      
+      -t, --trace 
+          Display backtrace when an error occurs

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('rehabilitate', '0.3.2') do |p|
+  p.description     = "Backup stuff"
+  p.url             = "https://github.com/fearoffish/rehabilitate"
+  p.author          = "Jamie van Dyke"
+  p.email           = "jamie@fearoffish.com"
+  p.ignore_pattern  = ["tmp/*", "script/*", "testing/*"]
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/bin/rehabilitate

@@ -0,0 +1,179 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2010 Jamie van Dyke
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# The idea behind rehabilitate is that rather than worry about a million different
+# ways of backing up, we output our backup to a file and do whatever we want
+# with it, utilising existing tools to augment that.
+# For example, to back up a postgresql database to a an ftp server we would
+# give backup the command to run for backing up and then give it an after command
+# to upload the file.
+#
+# example: rehabilitate save --driver postgresql --type scp --location user:pass@ftp.example.com
+
+require "rubygems"
+require "bundler/setup"
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib/rehabilitate"
+
+require 'rehabilitate'
+require 'commander/import'
+require 'log4r'
+require 'log4r/outputter/syslogoutputter'
+require 'tmpdir'
+require 'fileutils'
+
+include Log4r
+
+program :name, 'Rehabilitate'
+program :version, '0.3.2'
+program :description, 'A backup system that can be given commands to be run before and after a backup or restore'
+
+global_option('-d', '--debug', 'More verbose logging and nothing is actually run') { $DEBUG = true }
+
+$LOGGER = Log4r::Logger.new('rehabilitate')
+$LOGGER.outputters = SyslogOutputter.new("rehabilitate")
+$LOGGER.info "Starting backup"
+
+def location_from_options(options)
+  ARGV[((options.__hash__.keys.size * 2) + 1)..-1]
+end
+
+def setup_logger(quiet)
+  unless quiet
+    $LOGGER.outputters << Outputter.stdout
+  end
+end
+
+def cleanup(files)
+  $LOGGER.info "Cleaning up temporary files..."
+  files.flatten.compact.each do |file|
+    $LOGGER.info "Deleting #{file}"
+    FileUtils.rm(file)
+  end
+end
+
+begin
+
+command :save do |c|
+  c.syntax = 'rehabilitate save --driver DRIVER --storage TYPE --location LOCATION'
+  c.description = 'Save a backup from a database to a location'
+  c.example "Backup a postgresql database to scp",   "rehabilitate save --driver postgresql --storage scp --location \"user:pass@ftp.example.com\""
+  c.example "Backup a postgresql database to s3",     "rehabilitate save --driver postgresql --storage s3 --location \"access_id:secret_key@bucket/file\""
+  c.example "Backup a postgresql database to a dir",  "rehabilitate save --driver postgresql --storage dir --location \"/some/location\""
+  c.option '--driver STRING', String, 'Chooses a dbms type.'
+  c.option '--database STRING', String, 'Give the database name.'
+  c.option '--user STRING', String, 'Give the database username.'
+  c.option '--pass STRING', String, 'Give the database password.'
+  c.option '--host STRING', String, 'Give the database host.'
+  c.option '--storage STRING', [:scp, :dir, :s3], 'Choices are [scp, dir, s3].'
+  c.option '--location STRING', String, 'A location string which accompanies the type of backup e.g. "user:pass@ftp.example.com/dir".'
+  c.option '--compressor', String, "Compress the backup on the fly using a compression plugin."
+  c.option '--quiet', "Turn off outputting"
+  c.option '--skip-cleanup', "No deleting temporary files"
+  c.option '--tmp STRING', String, "Where to store temporary files. Default: #{Dir.tmpdir}"
+  c.option '--steps STRING', String, "A comma separated list of steps to perform"
+  c.option '--file FILE', String, "The filename to use when we skip backing up and just upload"
+  c.option '--split-size BYTES', Integer, "How many bytes should we split files by. Default: 4.5TB"
+  c.action do |args, options|
+    options.default :steps                => %w{ backup compress upload },
+                    :user                 => ENV['USER'],
+                    :driver               => 'postgresql',
+                    :host                 => 'localhost',
+                    :quiet                => false,
+                    :tmp                  => Dir.tmpdir,
+                    :compressor           => 'lzop',
+                    :split_size           => (4.5*1024*1024*1024*1024*10).to_i,
+                    :_base_backup_name    => "#{options.database}--#{Time.now.strftime("%Y-%m-%d_%H-%M")}",
+                    :_backup_files        => [],
+                    :_failure             => nil,
+                    :_tmp_files           => []
+    if options.file
+      options._backup_files = [options.file]
+    else
+      options._backup_files = ["#{options.tmp}/#{options._base_backup_name}"]
+    end
+    setup_logger(options.quiet)
+    (options.steps.is_a?(Array) ? options.steps : options.steps.split(",")).each do |cmd|
+      if options._failure
+        log "Quitting due to failure, use debug next time."
+      else
+        Backup.send(cmd, options)
+      end
+    end
+    cleanup(options._tmp_files) unless options.file or options.skip_cleanup
+  end
+end
+
+command :restore do |c|
+  c.syntax = 'rehabilitate restore --driver DRIVER --storage TYPE'
+  c.description = 'Restore a backup from a location to a database or directory'
+  c.example "List all the backups on a storage type and location", "rehabilitate restore --list --storage TYPE"
+  c.example "Restore a postgresql database from scp",   "rehabilitate restore --driver postgresql --storage scp --location \"user:pass@ftp.example.com\""
+  c.example "Restore a postgresql database from s3",    "rehabilitate restore --driver postgresql --storage s3 --location \"access_id:secret_key@bucket/file\""
+  c.example "Restore a postgresql database from a dir", "rehabilitate restore --driver postgresql --storage dir --location \"/some/location\""
+  c.option '--driver STRING', String, 'Chooses a dbms type.'
+  c.option '--database STRING', String, 'Give the database name.'
+  c.option '--user STRING', String, 'Give the database username.'
+  c.option '--pass STRING', String, 'Give the database password.'
+  c.option '--host STRING', String, 'Give the database host.'
+  c.option '--storage STRING', [:scp, :dir, :s3], 'Choices are [scp, dir, s3].'
+  c.option '--location STRING', String, 'A location string which accompanies the type of backup e.g. "user:pass@ftp.example.com/dir".'
+  c.option '--compressor', String, "Decompress the backup on the fly using a compression plugin."
+  c.option '--quiet', "Turn off outputting"
+  c.option '--skip-cleanup', "No deleting temporary files"
+  c.option '--steps STRING', String, "A comma separated list of steps to perform"
+  c.option '--file FILE', String, "The filename to use when we skip backing up and just upload"
+  c.option '--tmp STRING', String, "Where to store temporary files. Default: #{Dir.tmpdir}"
+  c.option '--number INTEGER', Integer, "The backup number to restore (taken from 'backup list')"
+  c.action do |args, options|
+    options.default :steps                => %w{ download uncompress restore },
+                    :user                 => ENV['USER'],
+                    :driver               => 'postgresql',
+                    :host                 => 'localhost',
+                    :quiet                => false,
+                    :tmp                  => Dir.tmpdir,
+                    :compressor           => 'lzop',
+                    :_base_backup_name    => "#{options.database}--#{Time.now.strftime("%Y-%m-%d_%H-%M")}",
+                    :_backup_files        => [],
+                    :_failure             => nil,
+                    :_tmp_files           => []
+    options._backup_files = ["#{options.tmp}/#{options._base_backup_name}"]
+    setup_logger(options.quiet)
+    (options.steps.is_a?(Array) ? options.steps : options.steps.split(",")).each do |cmd|
+      if options._failure
+        log "Quitting due to failure, use debug next time."
+      else
+        Backup.send(cmd, options)
+      end
+    end
+    cleanup(options._tmp_files) unless options.file or options.skip_cleanup
+  end
+end
+
+command :list do |c|
+  required_options = %w{ storage }
+  c.syntax = 'rehabilitate list --driver DRIVER --storage TYPE'
+  c.description = 'List backups from a location'
+  c.example "List all the backups on a storage type and location", "rehabilitate list --storage TYPE --location s3"
+  c.option '--list', 'Get a list of downloads on a storage device given'
+  c.option '--storage STRING', [:scp, :dir, :s3], 'Choices are [scp, dir, s3].'
+  c.option '--location STRING', String, 'A location string which accompanies the type of backup e.g. "user:pass@ftp.example.com/dir".'
+  c.action do |args, options|
+    options.default :driver               => 'postgresql',
+                    :_backup_files        => [],
+                    :_failure             => nil
+    options._backup_files = ["#{options.tmp}/#{options._base_backup_name}"]
+    setup_logger(options.quiet)
+    Backup.list(options)
+  end
+end
+
+$LOGGER.info "Backup complete"
+
+rescue => x
+  $LOGGER.debug "Backup failed with exception:"
+  $LOGGER.debug x.message
+end

data/lib/rehabilitate/plugin.rb

@@ -0,0 +1,13 @@
+require "pluginfactory"
+
+class Plugin
+  include PluginFactory
+    
+  def self::derivative_dirs
+     ["plugins"]
+  end
+  
+  def log(message)
+    $LOGGER.info message
+  end
+end

data/lib/rehabilitate/plugins/lzop.rb

@@ -0,0 +1,25 @@
+require 'plugin'
+
+class Lzop < Plugin
+  def compress(options)
+    options._backup_files.collect! do |backup_file|
+      new_backup_name = "#{backup_file}.tar.lzop"
+      log "Compressing files..."
+      log "cd #{options.tmp} && tar --use-compress-program=lzop -cf #{new_backup_name} #{backup_file.split("/").last}"
+      log %x[cd #{options.tmp} && tar --use-compress-program=lzop -cf #{new_backup_name} #{backup_file.split("/").last}]
+      options._tmp_files << new_backup_name
+      new_backup_name
+    end
+  end
+
+  def uncompress(options)
+    options._backup_files.collect! do |backup_file|
+      new_backup_name = "#{options.tmp}/#{File.basename(backup_file).gsub(".tar.lzop", "")}"
+      log "Uncompressing files to #{options.tmp}"
+      log %{ cd #{options.tmp} && lzop -dq < #{options._backup_files.first} | tar -xvf - }
+      log %x{ cd #{options.tmp} && lzop -dq < #{options._backup_files.first} | tar -xvf - }
+      options._tmp_files << new_backup_name
+      new_backup_name
+    end
+  end
+end

data/lib/rehabilitate/plugins/postgresql.rb

@@ -0,0 +1,30 @@
+require 'plugin'
+
+class Postgresql < Plugin
+  def backup(options)
+    options._backup_files.collect! do |backup_file|
+      new_backup_name = "#{backup_file}.sql"
+      log "Backing up database #{options.database}"
+      log %[pg_dump -h #{options.host} -U #{options.user} #{options.database} > #{new_backup_name}]
+      log %x[pg_dump -h #{options.host} -U #{options.user} #{options.database} > #{new_backup_name}]
+      options._failure = true if $? == 256
+      options._tmp_files << new_backup_name
+      new_backup_name
+    end
+  end
+
+  def restore(options)
+    options._backup_files.collect! do |backup_file|
+      log "Restoring database #{options.database}"
+      drop_table_sql =  File.join(options.tmp, 'droptables.sql')
+      log %[psql -t -h #{options.host} -U #{options.user} -d #{options.database} -c "SELECT 'DROP TABLE ' || n.nspname || '.' || c.relname || ' CASCADE;' FROM pg_catalog.pg_class AS c LEFT JOIN pg_catalog.pg_namespace AS n ON n.oid = c.relnamespace WHERE relkind = 'r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid)" > #{drop_table_sql} ]
+      log %x[psql -t -h #{options.host} -U #{options.user} -d #{options.database} -c "SELECT 'DROP TABLE ' || n.nspname || '.' || c.relname || ' CASCADE;' FROM pg_catalog.pg_class AS c LEFT JOIN pg_catalog.pg_namespace AS n ON n.oid = c.relnamespace WHERE relkind = 'r' AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND pg_catalog.pg_table_is_visible(c.oid)" > #{drop_table_sql} ]
+      log %[psql -h #{options.host} -U #{options.user} #{options.database} < #{drop_table_sql} ] unless $? == 256
+      log %x[psql -h #{options.host} -U #{options.user} #{options.database} < #{drop_table_sql} ] unless $? == 256
+      log %[psql -h #{options.host} -U #{options.user} #{options.database} < #{backup_file}] unless $? == 256
+      log %x[psql -h #{options.host} -U #{options.user} #{options.database} < #{backup_file}] unless $? == 256
+      options._tmp_files << drop_table_sql
+      options._failure = true if $? == 256
+    end
+  end
+end

data/lib/rehabilitate/plugins/s3.rb

@@ -0,0 +1,105 @@
+require 'plugin'
+require 'fog'
+require 'yaml'
+
+class S3 < Plugin
+  def list(options)
+    location = parse_upload_string(options.location)
+    s3 = setup_fog(location)
+
+    log "Listing bucket contents for #{location[:bucket]}"
+    dir = s3.directories.get(location[:bucket])
+    backups = sorted_backups(dir.files)
+    backups.each_with_index do |backup, i|
+      say "#{i}: #{prettify(backup)}"
+    end
+  end
+
+  def upload(options)
+    location = parse_upload_string(options.location)
+    s3 = setup_fog(location)
+    location[:dir] = "#{location[:dir]}/#{options._base_backup_name}"
+
+    log "Creating bucket #{location[:bucket]} if it doesn't exist"
+    s3.directories.create(:key => location[:bucket])
+    options._backup_files.collect! do |local_file|
+      if File.size(local_file) > options.split_size
+        splitter = Splitter.new
+        local_file = splitter.split(local_file, options)
+      else
+        [local_file]
+      end
+      local_file.each do |local_file|
+        log "Uploading #{local_file}"
+        log "   => #{local_file}"
+        log %x{ s3cmd --config /etc/s3cfg #{options.s3_options} put #{local_file} s3://#{location[:bucket]}/#{location[:dir]}/ }
+      end
+    end
+  end
+
+  def download(options)
+    log "S3 downloading backup"
+    log "Number #{options.number}"
+
+    location = parse_upload_string(options.location)
+    s3 = setup_fog(location)
+    local_file = ""
+    dir = s3.directories.get(location[:bucket])
+    backups = sorted_backups(dir.files)
+    if backups[options.number]
+      log "Restoring #{backups[options.number]}"
+      restore_key = backups[options.number]
+      output = %x{ s3cmd --config /etc/s3cfg get --recursive --skip-existing s3://#{location[:bucket]}/#{backups[options.number]} #{options.tmp}}
+      output.split("\n").each {|f| log f}
+    else
+      log "Invalid number specified, use --list first to get the id you want to restore"
+    end
+    backup_files =  Dir.glob("#{options.tmp}/#{backups[options.number].split("/").last}/*")
+    log "Joining #{backup_files.size} files..."
+    joiner = Splitter.new
+    joined = backup_files.size > 1 ? joiner.join(backup_files) : backup_files
+    options._tmp_files << joined
+    options._backup_files = joined.is_a?(Array) ? joined : [joined]
+  end
+
+private
+
+  # access_id:secret_key@bucket/file
+  def parse_upload_string(upload_string="")
+    location = {}
+
+    if upload_string && !upload_string.empty?
+      location[:access_key], remaining = upload_string.split(":")
+      location[:secret_id],  remaining = remaining.split("@")
+      location[:bucket]                = remaining.split("/").first
+      location[:dir]                   = remaining.split("/")[1..-1].join("/")
+    else
+      # use a ~/.fog file
+      fog_config = YAML.load(File.read(File.expand_path(ENV['FOG_RC'] || "~/.fog")))
+      location[:access_key] = fog_config[:default][:aws_access_key_id]
+      location[:secret_id]  = fog_config[:default][:aws_secret_access_key]
+      location[:bucket]     = fog_config[:default][:bucket]
+      location[:dir]        = fog_config[:default][:dir]
+    end
+    location
+  end
+
+  def setup_fog(location)
+    Fog::AWS::Storage.new(
+        :aws_access_key_id     => location[:access_key],
+        :aws_secret_access_key => location[:secret_id]
+    )
+  end
+
+  def sorted_backups(backups)
+    backups.collect do |f|
+      key = f.key
+      key.split("/")[0..-2].join("/")
+    end.sort.uniq
+  end
+
+  def prettify(backup_name)
+    env, db, date = backup_name.scan(/(.*?)\/(.*?)--(.*)/).flatten
+    "#{env} => #{ DateTime.strptime(date, "%Y-%m-%d_%H-%M").strftime("%Y-%m-%d %H-%M UTC") }"
+  end
+end

data/lib/rehabilitate/plugins/scp.rb

@@ -0,0 +1,35 @@
+require 'plugin'
+require 'uri'
+require 'net/ssh'
+require 'net/scp'
+
+class Scp < Plugin
+  def upload(options)
+    location = parse_upload_string(options.location)
+    remote_dir = "#{location[:dir]}/#{options._base_backup_name}"
+    log "Connecting to #{location[:host]} with user: #{location[:user]}:#{location[:pass]}"
+
+    options._backup_files.collect! do |local_file|
+      remote_file = "#{remote_dir}/#{File.basename(local_file)}"
+      log "Uploading '#{local_file}' to '#{remote_file}'"
+      Net::SCP.upload!( location[:host], 
+                        location[:user], 
+                        local_file, 
+                        remote_file,
+                        :password => location[:pass],
+                        :recursive => true )
+    end
+  end
+
+private
+
+  # e.g. user:pass@ftp.example.com/backup-dir
+  def parse_upload_string(upload_string)
+    location = {}
+    location[:user], remaining = upload_string.split(":")
+    location[:pass], remaining = remaining.split("@")
+    location[:host] = remaining.split("/").first
+    location[:dir]  = remaining.split("/")[1..-1].join("/")
+    location
+  end
+end

data/lib/rehabilitate/plugins/splitter.rb

@@ -0,0 +1,20 @@
+require 'plugin'
+
+class Splitter < Plugin
+  MAX_FILE_SIZE = (4.5*1024*1024*1024*1024*10).to_i #4.5TB
+
+  def join(files)
+    log %[ cat #{files.join(" ")} > #{files[0].split("-")[0..-2].join("-")} ]
+    log %x[ cat #{files.join(" ")} > #{files[0].split("-")[0..-2].join("-")} ]
+    files[0].split("-")[0..-2].join("-")
+  end
+
+  def split(file, options)
+    log "Splitting file (#{file})"
+    split_size = options.split_size || MAX_FILE_SIZE
+    log "  => #{split_size} byte pieces"
+
+    log %x{ split -b #{split_size} #{file} #{file}- }
+    Dir.glob("#{file}-??")
+  end
+end

data/lib/rehabilitate.rb

@@ -0,0 +1,39 @@
+require 'rehabilitate/plugin'
+require 'rehabilitate/plugins/splitter'
+
+class Rehabilitate
+  def self.backup(options)
+    driver = Plugin::create( options.driver )
+    driver.backup(options)
+  end
+
+  def self.restore(options)
+    driver = Plugin::create( options.driver )
+    driver.restore(options)
+  end
+
+  def self.compress(options)
+    driver = Plugin::create( options.compressor )
+    driver.compress(options)
+  end
+
+  def self.uncompress(options)
+    driver = Plugin::create( options.compressor )
+    driver.uncompress(options)
+  end
+
+  def self.upload(options)
+    driver = Plugin::create( options.storage )
+    driver.upload(options)
+  end
+
+  def self.download(options)
+    driver = Plugin::create( options.storage )
+    driver.download(options)
+  end
+
+  def self.list(options)
+    driver = Plugin::create( options.storage )
+    driver.list(options)
+  end
+end

data/rehabilitate.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rehabilitate}
+  s.version = "0.3.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jamie van Dyke"]
+  s.date = %q{2011-01-05}
+  s.default_executable = %q{rehabilitate}
+  s.description = %q{Backup stuff}
+  s.email = %q{jamie@fearoffish.com}
+  s.executables = ["rehabilitate"]
+  s.extra_rdoc_files = ["README.mdown", "bin/rehabilitate", "lib/rehabilitate.rb", "lib/rehabilitate/plugin.rb", "lib/rehabilitate/plugins/lzop.rb", "lib/rehabilitate/plugins/postgresql.rb", "lib/rehabilitate/plugins/s3.rb", "lib/rehabilitate/plugins/scp.rb", "lib/rehabilitate/plugins/splitter.rb"]
+  s.files = ["Gemfile", "Gemfile.lock", "Manifest", "README.mdown", "Rakefile", "rehabilitate.gemspec", "bin/rehabilitate", "lib/rehabilitate.rb", "lib/rehabilitate/plugin.rb", "lib/rehabilitate/plugins/lzop.rb", "lib/rehabilitate/plugins/postgresql.rb", "lib/rehabilitate/plugins/s3.rb", "lib/rehabilitate/plugins/scp.rb", "lib/rehabilitate/plugins/splitter.rb"]
+  s.homepage = %q{https://github.com/fearoffish/rehabilitate}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Rehabilitate", "--main", "README.mdown"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rehabilitate}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Backup stuff}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: rehabilitate
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 2
+  version: 0.3.2
+platform: ruby
+authors: 
+- Jamie van Dyke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-05 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: Backup stuff
+email: jamie@fearoffish.com
+executables: 
+- rehabilitate
+extensions: []
+
+extra_rdoc_files: 
+- README.mdown
+- bin/rehabilitate
+- lib/rehabilitate.rb
+- lib/rehabilitate/plugin.rb
+- lib/rehabilitate/plugins/lzop.rb
+- lib/rehabilitate/plugins/postgresql.rb
+- lib/rehabilitate/plugins/s3.rb
+- lib/rehabilitate/plugins/scp.rb
+- lib/rehabilitate/plugins/splitter.rb
+files: 
+- Gemfile
+- Gemfile.lock
+- Manifest
+- README.mdown
+- Rakefile
+- rehabilitate.gemspec
+- bin/rehabilitate
+- lib/rehabilitate.rb
+- lib/rehabilitate/plugin.rb
+- lib/rehabilitate/plugins/lzop.rb
+- lib/rehabilitate/plugins/postgresql.rb
+- lib/rehabilitate/plugins/s3.rb
+- lib/rehabilitate/plugins/scp.rb
+- lib/rehabilitate/plugins/splitter.rb
+has_rdoc: true
+homepage: https://github.com/fearoffish/rehabilitate
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Rehabilitate
+- --main
+- README.mdown
+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: 11
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: rehabilitate
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Backup stuff
+test_files: []
+