rubypond-s3backup-manager 0.0.8 → 0.0.9

data/README.rdoc

@@ -0,0 +1,8 @@
+= s3backup-manager
+
+The beginnings of a system for managing offsite encrypted backups using
+AmazonS3.
+
+== Copyright
+
+Copyright (c) 2009 Glenn Gillen. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+spec_data = File.open('s3backup-manager.gemspec').read
+spec = nil
+Thread.new do
+  spec = eval("$SAFE = 3\n#{spec_data}")
+end.join
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+task :default => :spec
+
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "s3backup-manager #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = Dir['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', 'spec/spec.opts']
+  t.rcov = false
+  # t.rcov_dir = '../doc/output/coverage'
+  # t.rcov_opts = ['--exclude', 'spec\/spec,bin\/spec,examples,\/var\/lib\/gems,\.autotest']
+end

data/config/config.yml

@@ -0,0 +1,4 @@
+aws_access_key_id: 
+aws_secret_access_key: 
+encryption_secret: 
+collection_prefix: 

data/config/schedule.yml

@@ -0,0 +1,24 @@
+monthly_run_day: 7
+weekly_run_day: Sun
+daily_run_time: 04:13
+hourly_run_minute: 47
+
+hourlies:
+  database:
+    adapter: postgres
+    database: longpockets_production
+dailies:
+  filesystem: /var/www/apps/rubypond
+  filesystem: /var/www/apps/longpockets
+  filesystem: /var/www/apps/cms
+  
+weeklies:
+  database: 
+    adapter: postgres
+    database: rubypond_production
+    
+  database: 
+    adapter: couchdb
+    database: rubypond_production
+
+monthlies:

data/lib/adapters/mysql_adapter.rb

@@ -0,0 +1,23 @@
+module MysqlAdapter
+  
+  def dump_all_databases_to_file(filename)
+    # `mysqldump --user=root --password=yourrootsqlpassword --lock-all-tables \
+    #       --all-databases > #{filename}`
+  end
+  
+  def dump_database_to_file(database, filename)
+    # `mysqldump --opt -h hostname -u user -p password #{database} > #{filename}`
+  end
+  
+  def restore_database_from_file(database, filename)
+    # `mysql - u user_name -p your_password #{database} < #{filename}`
+  end
+  
+  private
+    def get_all_databases
+      # `mysql -u root -h localhost -ppassword -Bse 'show databases'`
+    end
+    
+    def recreate_database(database)
+    end
+end

data/lib/adapters/postgres_adapter.rb

@@ -0,0 +1,24 @@
+module S3BackupManager
+  module PostgresAdapter
+  
+    def dump_database_to_file(filename, options = {})
+      database = options[:database]
+      username = options[:username]
+      system "sudo -u #{username} vacuumdb -z #{database} >/dev/null 2>&1"
+      exit(1) unless $?.success?
+      system "sudo -u #{username} pg_dump --blobs --format=t #{database} > #{filename}"
+      exit(1) unless $?.success?
+    end
+  
+    def restore_database_from_file(database, filename)
+      `sudo -u postgres pg_restore --format=t -d #{database} #{filename}`
+    end
+
+    private
+      def recreate_database(database)
+        `sudo -u postgres dropdb #{database}`
+        `sudo -u postgres createdb --encoding=UNICODE #{database}`
+      end
+    
+  end
+end

data/lib/controllers/backup_manager.rb

@@ -0,0 +1,64 @@
+%w{rubygems sinatra haml sass}.each do |lib|
+  require lib
+end
+
+Dir["models/*"].each do |model|
+  require model
+end
+
+get '/' do
+  @buckets = Bucket.find_all
+  haml :index
+end
+
+get '/new' do
+  haml :new
+end
+
+post '/' do
+  begin
+    Bucket.create!(params[:collection_name])
+    flash[:notice] = "Successfully created new backup collection"
+    redirect "/"
+  rescue AWS::S3::InvalidBucketName => exception
+    flash[:error] = exception.message
+    haml :new
+  end
+end
+
+get '/:id' do
+  haml :show
+end
+
+get '/:id/files' do
+  haml :files
+end
+
+get '/:id/databases' do
+  hamls :databases
+end
+
+get '/stylesheet.css' do
+  content_type 'text/css', :charset => 'utf-8'
+  sass :stylesheet
+end
+
+def flash
+  session[:flash] = {} if session[:flash] && session[:flash].class != Hash
+  session[:flash] ||= {}
+end
+
+template :layout do
+%Q{
+!!!
+%html
+  %head
+    %title My Title Here
+  %body
+    - if flash
+      - flash.each do |type,message|
+        %p{ :class=> "message #{type}" }= message
+      - flash.clear
+    = yield
+}
+end

data/lib/models/bucket.rb

@@ -0,0 +1,78 @@
+module S3BackupManager
+  module BucketError
+    class NoNameError < StandardError; end
+    class NoConfigError < StandardError; end
+    class NoBucketFoundError < StandardError; end
+  end
+
+  class Bucket
+    attr_accessor :name
+    attr_accessor :s3_bucket
+  
+    def initialize(name)
+      @name = name
+    end
+  
+    def self.find_all
+      connect!
+      AWS::S3::Service.buckets.select{|b| b.name =~ %r{^#{config["collection_prefix"]}_}}.map{|b| b.name.sub(%r{^#{config["collection_prefix"]}_},"")}
+    end
+  
+    def self.find(id)    
+      connect!
+      bucket = AWS::S3::Bucket.find(expand_name(id))
+      initialize_with_bucket(id, bucket)
+    rescue AWS::S3::CurrentBucketNotSpecified
+      raise BucketError::NoNameError
+    rescue AWS::S3::NoSuchBucket
+      raise BucketError::NoBucketFoundError
+    end
+  
+    def self.create!(name)
+      raise BucketError::NoNameError.new if name.nil? || name.strip == ""
+      connect!
+      AWS::S3::Bucket.create("#{config["collection_prefix"]}_#{name}")
+    end
+  
+    def store(filename, data)
+      AWS::S3::S3Object.store(filename, data, bucket_name)
+    end
+  
+    def retrieve(filename)
+      AWS::S3::S3Object.value(filename, bucket_name)
+    end
+  
+    def files
+      @s3_bucket.objects
+    end
+
+    private
+      def self.initialize_with_bucket(name, bucket)
+        this_bucket = new(name)
+        this_bucket.s3_bucket = bucket
+        this_bucket
+      end
+      
+      def self.config
+        YAML.load_file("/etc/s3backup-manager/config.yml")
+      rescue Errno::ENOENT
+        raise S3BackupManager::BucketError::NoConfigError.new(
+          "No configuration file could be found at /etc/s3backup-manager/config.yml")
+      end
+    
+      def self.expand_name(name)
+        "#{config["collection_prefix"]}_#{name}"
+      end
+    
+      def self.connect!
+        AWS::S3::Base.establish_connection!(
+          :access_key_id     => config["aws_access_key_id"],
+          :secret_access_key => config["aws_secret_access_key"]
+        )
+      end
+
+      def bucket_name
+        Bucket.expand_name(name)
+      end    
+  end
+end

data/lib/models/database_backup.rb

@@ -0,0 +1,43 @@
+module S3BackupManager
+  class DatabaseBackup < FileBackup
+    def initialize(opts = {})
+      @options = opts
+      super
+      case @options[:adapter]
+      when "postgres"
+        self.extend S3BackupManager::PostgresAdapter
+      when "mysql"
+        self.extend ::S3BackupManager::MysqlAdapter
+      when "couchdb"
+        self.extend ::S3BackupManager::PostgresAdapter
+      end
+      self
+    end
+    
+    def files
+      bucket.files.select{|f| f.key.match(%r{^databases/})}
+    end
+  
+    def backup(database)
+      filename = "/tmp/#{database}"
+      dump_database_to_file(filename, @options.merge(:database => database))
+      super(filename, "databases/#{@options[:adapter]}")
+    end
+
+    def restore(database, timestamp)
+      filename = "#{@options[:adapter]}/#{timestamp}/#{database}"
+      @dumped_filename = "/tmp/#{random_string}"
+      super(filename, timestamp, @dumped_filename, "databases")
+      restore_database_from_file(@dumped_filename, @options)
+      db_cleanup!
+    end
+    
+    private
+      def db_cleanup!
+        if @dumped_filename
+          File.delete(@dumped_filename) 
+          @dumped_filename = nil
+        end
+      end
+  end
+end

data/lib/models/file_backup.rb

@@ -0,0 +1,110 @@
+module S3BackupManager
+  module FileBackupError
+    class NoBucketError < StandardError; end
+  end
+  
+  class FileBackup
+    attr_accessor :bucket
+  
+    def initialize(opts = {})
+      @bucket = Bucket.find(opts[:bucket])
+      super()
+    end
+  
+    def files
+      bucket.files.select{|f| f.key.match(%r{^filesystem/})}
+    end
+  
+    def backup(file, directory = "filesystem")
+      stored_file_name = "#{Time.now.strftime("%Y%m%d%H%M%S")}/#{File.basename(file)}"
+      encrypted_file = encrypt(pack(file))
+      bucket.store("#{directory}/#{stored_file_name}", open(encrypted_file))    
+      cleanup!
+    end
+  
+    def restore(file, timestamp, destination, directory = "filesystem")
+      if file.match(timestamp)
+        data = bucket.retrieve("#{directory}/#{file}")
+      else
+        data = bucket.retrieve("#{directory}/#{timestamp}/#{file}")
+      end
+      decrypted_file = decrypt(file, timestamp, data)
+      unpack(decrypted_file, destination)
+      cleanup!
+    end
+  
+    private
+      def cleanup!
+        if @encrypted_filename
+          File.delete(@encrypted_filename) 
+          @encrypted_filename = nil
+        end
+        if @packed_filename
+          File.delete(@packed_filename)
+          @packed_filename = nil
+        end
+        if @decrypted_filename
+          File.delete(@decrypted_filename) 
+          @decrypted_filename = nil
+        end
+      end
+    
+      def encrypt(file)
+        aes = OpenSSL::Cipher::Cipher.new("AES-256-CBC")
+        aes.encrypt
+        aes.key = Digest::SHA256.digest(FileBackup.config["encryption_secret"])
+        aes.iv = Digest::SHA256.digest(Time.now.strftime("%Y%m%d"))
+      
+        @encrypted_filename = "#{random_string}_#{File.basename(file)}"
+        File.open(@encrypted_filename, 'w') do |enc|
+           File.open(file) do |f|
+             loop do
+               r = f.read(4096)
+               break unless r
+               cipher = aes.update(r)
+               enc << cipher
+             end
+           end
+           enc << aes.final
+        end
+        @encrypted_filename
+      end
+      
+      def decrypt(filename, timestamp, data)
+        aes = OpenSSL::Cipher::Cipher.new("AES-256-CBC")
+        aes.decrypt
+        aes.key = Digest::SHA256.digest(FileBackup.config["encryption_secret"])
+        aes.iv = Digest::SHA256.digest(timestamp[0...8])
+        @decrypted_filename = "#{random_string}_#{File.basename(filename)}"
+        File.open(@decrypted_filename, 'w') do |dec|
+          dec.write aes.update(data)
+          dec.write aes.final
+        end
+        @decrypted_filename
+      end
+    
+      def pack(file)
+        @packed_filename = "#{random_string}_#{File.basename(file)}.tgz"
+        tgz = Zlib::GzipWriter.new(File.open(@packed_filename, 'wb'))
+        Archive::Tar::Minitar.pack("#{file}", tgz, recurse_directories = true)
+        @packed_filename
+      end
+      
+      def unpack(file, destination)
+        tgz = Zlib::GzipReader.new(File.open(file, 'rb'))
+        Archive::Tar::Minitar.unpack(tgz, destination)
+      end
+    
+      def random_string
+        o =  [('a'..'z'),('A'..'Z')].map{|i| i.to_a}.flatten
+        (0..50).map{ o[rand(o.length)]  }.join
+      end
+    
+      def self.config
+          YAML.load_file("/etc/s3backup-manager/config.yml")
+        rescue Errno::ENOENT
+          raise S3BackupManager::BucketError::NoConfigError.new(
+            "No configuration file could be found at /etc/s3backup-manager/config.yml")
+      end
+  end
+end

data/lib/models/schedule.rb

@@ -0,0 +1,30 @@
+class Schedule
+  
+  def self.find_pending
+    if Time.now.min == config["hourly_run_minute"]
+      run_hourlies
+    end
+    if Time.now.strftime("%H:%M") == config["daily_run_time"]
+      run_dailies
+    end
+    # if Time.n
+  end
+  
+  private
+    def self.run_hourlies
+    end
+    
+    def self.run_dailies
+    end
+
+    def self.run_monthlies
+    end
+    
+    def self.run_weeklies
+    end
+  
+    def self.config
+      YAML.load_file("#{File.dirname(__FILE__)}/../config/schedule.yml")
+    end
+  
+end

data/lib/s3backup-manager.rb

@@ -0,0 +1,13 @@
+require 'aws/s3'
+require 'zlib'
+require 'archive/tar/minitar'
+require 'yaml'
+
+Dir["#{File.dirname(__FILE__)}/adapters/*"].each do |lib|
+  require lib
+end
+
+require "#{File.dirname(__FILE__)}/models/bucket"
+require "#{File.dirname(__FILE__)}/models/file_backup"
+require "#{File.dirname(__FILE__)}/models/database_backup"
+require "#{File.dirname(__FILE__)}/models/schedule"

data/spec/adapters/mysql_adapter_spec.rb

@@ -0,0 +1,14 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+describe MysqlAdapter do
+  before(:each) do
+  end
+  
+  it "should dump the database to a file" do
+    pending
+  end
+  
+  it "should import the file into the database" do
+    pending
+  end
+end

data/spec/adapters/postgres_adapter_spec.rb

@@ -0,0 +1,14 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+describe PostgresAdapter do
+  before(:each) do
+  end
+  
+  it "should dump the database to a file" do
+    pending
+  end
+  
+  it "should import the file into the database" do
+    pending
+  end
+end

data/spec/fixtures/test_backup_file.txt

@@ -0,0 +1 @@
+my test data

data/spec/lib/mocks.rb

@@ -0,0 +1,67 @@
+module S3BackupManager
+  module Mocks
+    
+    def mock_bucket
+      stub_aws
+      stub_bucket_find
+      @bucket.stub!(:store)
+    end
+    
+    def mock_filesystem_files
+      @lines = mock("lines")
+      @lines.stub!(:each).and_yield(["my data here"])
+      @lines.stub!(:write)
+    end
+    
+    def mock_filebackup_dependencies
+      mock_filesystem_files
+      @encrypter = mock("aes", :key= => nil, :iv= => nil, :final => nil)
+      @encrypter.stub!(:encrypt)
+      @encrypter.stub!(:decrypt)
+      OpenSSL::Cipher::Cipher.stub!(:new).with("AES-256-CBC").and_return(@encrypter)
+      
+      FileBackup.stub!(:open)
+      File.stub!(:delete)
+      Zlib::GzipWriter.stub!(:new)
+      Zlib::GzipReader.stub!(:new)
+      Archive::Tar::Minitar.stub!(:pack)
+    end
+    
+    def mock_backup_files
+      files = [mock("aws_object", :key => "filesystem/filename1.txt"),
+               mock("aws_object", :key => "filesystem/filename2.txt"),
+               mock("aws_object", :key => "filesystem/filename3.txt"),
+               mock("aws_object", :key => "databases/db1.txt"),
+               mock("aws_object", :key => "databases/db2.txt")]
+      @bucket.stub!(:files).and_return(files)
+    end
+    
+    def stub_aws
+      stub_bucket_config
+      stub_aws_connection
+    end
+    
+    def stub_bucket_config
+      YAML.stub!(:load_file).with(
+        "/etc/s3backup-manager/config.yml").and_return(
+        {"aws_access_key_id" => "unique_key_id",
+         "aws_secret_access_key" => "sekret_keyz",
+         "encryption_secret" => "hrrmm_how_secret?",
+         "collection_prefix" => "backup_collection_name"})
+    end
+    
+    def stub_aws_connection
+      AWS::S3::Base.stub!(:establish_connection!)
+    end
+    
+    def stub_bucket_find
+      @bucket = mock("bucket")
+      Bucket.stub!(:find).and_return(@bucket)
+    end
+    
+    def stub_aws_find
+      AWS::S3::Bucket.stub!(:find).and_return(mock("aws_bucket"))
+    end
+    
+  end
+end

data/spec/models/bucket_spec.rb

@@ -0,0 +1,83 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+describe Bucket do
+  
+  describe "when there is no configuration file" do
+    it "should raise a config file missing error" do
+      lambda do 
+        Bucket.find_all
+      end.should raise_error(S3BackupManager::BucketError::NoConfigError)
+    end
+  end
+  
+  describe "when there is a configuration file" do
+    before(:each) do
+      stub_aws
+      AWS::S3::Service.stub!(:buckets).and_return([
+        mock("bucket", :name => "backup_collection_name_bucket_1"),
+        mock("bucket", :name => "backup_collection_name_bucket_2"),
+        mock("bucket", :name => "backup_collection_name_bucket_3")
+        ])
+    end
+    
+    it "should connect using the credentials in the file" do
+      AWS::S3::Base.should_receive(:establish_connection!).with(
+        :access_key_id     => "unique_key_id",
+        :secret_access_key => "sekret_keyz")
+      Bucket.find_all
+    end
+    
+    it "should it should find a bucket by name" do
+      AWS::S3::Bucket.should_receive(:find).with("backup_collection_name_bucket_name")
+      Bucket.find("bucket_name")
+    end
+    
+    it "should find all buckets and strip off collection prefix" do
+      Bucket.find_all.should be_include("bucket_1")
+    end
+    
+    describe "when creating a new bucket" do
+      it "should create it" do
+        AWS::S3::Bucket.should_receive(:create).with(
+          "backup_collection_name_new_bucket")
+        Bucket.create!("new_bucket")
+      end
+
+      it "should raise an error if no name provided" do
+        lambda do
+          Bucket.create!("")
+        end.should raise_error(S3BackupManager::BucketError::NoNameError)
+      end
+    end
+
+    describe "when managing files in a bucket" do
+      before(:each) do
+        @bucket = Bucket.new("test_bucket")
+        AWS::S3::S3Object.stub!(:store)
+        AWS::S3::S3Object.stub!(:value)
+      end
+
+      it "should store the data" do
+        AWS::S3::S3Object.should_receive(:store).with(
+          "filename.txt","some data here", "backup_collection_name_test_bucket")
+        @bucket.store("filename.txt","some data here")
+      end
+      
+      it "should retrieve the data" do
+        AWS::S3::S3Object.should_receive(:value).with(
+          "filename.txt", "backup_collection_name_test_bucket").and_return(
+          "some data returned")
+        @bucket.retrieve("filename.txt").should == "some data returned"
+      end
+      
+      it "should list the files in a bucket" do
+        AWS::S3::Bucket.stub!(:find).with(
+          "backup_collection_name_bucket_name").and_return(
+          mock("bucket", :objects => ["file 1", "file 2"]))
+        @bucket = Bucket.find("bucket_name")
+        @bucket.files.should be_include("file 2")
+      end
+    end
+  end
+
+end

data/spec/models/database_backup_spec.rb

@@ -0,0 +1,26 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+describe DatabaseBackup do
+  before(:each) do
+  end
+  
+  it "should return just database files" do
+    pending
+  end
+  
+  it "should dump the database to a file" do
+    pending
+  end
+  
+  it "should backup the dumped file" do
+    pending
+  end
+  
+  it "should restore the backup to a file" do
+    pending
+  end
+  
+  it "should import the file into the database" do
+    pending
+  end
+end

data/spec/models/file_backup_spec.rb

@@ -0,0 +1,71 @@
+require "#{File.dirname(__FILE__)}/../spec_helper.rb"
+
+describe FileBackup do
+  before(:each) do
+    mock_bucket
+    mock_backup_files
+    mock_filebackup_dependencies
+    @file_backup = FileBackup.new(:bucket => "test_bucket")
+    @file_backup.stub!(:open)
+  end
+  
+  it "should return just filesystem files" do    
+    @file_backup.files.detect{|f| f.key =~ /filename1/}.should be
+    @file_backup.files.detect{|f| f.key =~ /filename2/}.should be
+  end
+  
+  it "should pack the file/directory into a tarball" do
+    tgz_mock = mock("tgz")
+    Zlib::GzipWriter.should_receive(:new).and_return(tgz_mock)
+    Archive::Tar::Minitar.should_receive(:pack).with(
+      "somefile.txt", tgz_mock, true)
+    @file_backup.backup("somefile.txt")
+  end
+  
+  it "should encrypt the data" do
+    @encrypter.should_receive(:encrypt)
+    # @encrypter.should_receive(:update)
+    @file_backup.backup("#{File.dirname(__FILE__)}/../fixtures/test_backup_file.txt")
+  end
+  
+  it "should decrypt the data" do
+    pending
+  end
+  
+  it "should unpack the tarball into a file/directory" do
+    pending
+  end
+  
+  it "should backup the packed & encrypted file in the bucket" do
+    pending
+  end
+  
+  it "should restore the file/directory" do
+    pending
+  end
+  
+  it "should cleanup any temporary files" do
+    pending
+  end
+  
+  it "should timestamp the backups" do
+    pending
+  end
+  
+  it "should encrypt using the configured secret" do
+    pending
+  end
+  
+  it "should encrypt using the current day as an initialization vector" do
+    pending
+  end
+  
+  it "should decrypt using the configured secret" do
+    pending
+  end
+  
+  it "should decrypt using the backup day as an initialization vector" do
+    pending
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'spec'
+require "#{File.dirname(__FILE__)}/../lib/s3backup-manager.rb"
+Dir[File.join(File.dirname(__FILE__)+'/lib/*.rb')].sort.each { |lib| require lib }
+
+include S3BackupManager
+include S3BackupManager::Mocks

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubypond-s3backup-manager
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors: 
 - Glenn Gillen
@@ -42,8 +42,36 @@ extensions: []
 
 extra_rdoc_files: []
 
-files: []
-
+files: 
+- README.rdoc
+- Rakefile
+- lib/adapters/mysql_adapter.rb
+- lib/adapters/postgres_adapter.rb
+- lib/controllers/backup_manager.rb
+- lib/models/bucket.rb
+- lib/models/database_backup.rb
+- lib/models/file_backup.rb
+- lib/models/schedule.rb
+- lib/s3backup-manager.rb
+- bin/s3backup
+- bin/s3backup_monitor
+- bin/s3restore
+- config/config.yml
+- config/schedule.yml
+- spec/adapters
+- spec/adapters/couchdb_adapter_spec.rb
+- spec/adapters/mysql_adapter_spec.rb
+- spec/adapters/postgres_adapter_spec.rb
+- spec/fixtures
+- spec/fixtures/test_backup_file.txt
+- spec/lib
+- spec/lib/mocks.rb
+- spec/models
+- spec/models/bucket_spec.rb
+- spec/models/database_backup_spec.rb
+- spec/models/file_backup_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
 has_rdoc: "false"
 homepage: http://github.com/rubypond/s3backup-manager
 post_install_message: 
@@ -71,5 +99,18 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Scripts and daemon to manage encrypted backups on AmazonS3
-test_files: []
-
+test_files: 
+- spec/adapters
+- spec/adapters/couchdb_adapter_spec.rb
+- spec/adapters/mysql_adapter_spec.rb
+- spec/adapters/postgres_adapter_spec.rb
+- spec/fixtures
+- spec/fixtures/test_backup_file.txt
+- spec/lib
+- spec/lib/mocks.rb
+- spec/models
+- spec/models/bucket_spec.rb
+- spec/models/database_backup_spec.rb
+- spec/models/file_backup_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb