Fingertips-fingertips-backup 0.1.0

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name        = "fingertips-backup"
+    s.description = "A simple tool to backup MySQL databases and files to an Amazon EBS instance through an EC2 instance."
+    s.summary     = "A simple tool to backup a webserver."
+    s.homepage    = "http://fingertips.github.com"
+    
+    s.authors = ["Eloy Duran"]
+    s.email   = "eloy@fngtps.com"
+    
+    s.add_dependency 'Fingertips-executioner'
+    s.add_dependency 'aws-s3'
+  end
+rescue LoadError
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 0
+:major: 0

data/bin/fingertips-backup

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+if config = ARGV.first
+  $:.unshift(File.expand_path('../../lib', __FILE__)) if $0 == __FILE__
+  require 'backup'
+  Fingertips::Backup.new(config).run!
+else
+  puts "Usage: #{$0} /path/to/config.yml"
+  exit 1
+end

data/lib/backup.rb

@@ -0,0 +1,112 @@
+require "yaml"
+
+require "rubygems"
+require "executioner"
+require "aws/s3"
+
+require "logger"
+require "ec2"
+
+module Fingertips
+  class Backup
+    include Executioner
+    Executioner::SEARCH_PATHS << '/usr/local/mysql/bin'
+    executable :mysql
+    executable :mysqldump
+    executable :rsync
+    executable :ssh, :switch_stdout_and_stderr => true
+    
+    MYSQL_DUMP_DIR = '/tmp/mysql_backup_dumps'
+    
+    attr_reader :config, :ec2, :logger, :s3
+    attr_accessor :ec2_instance_id
+    
+    def initialize(config_file)
+      @logger = Executioner.logger = Fingertips::Logger.new
+      @config = YAML.load(File.read(config_file))
+      @ec2    = Fingertips::EC2.new(@config['ec2']['zone'], @config['ec2']['private_key_file'], @config['ec2']['certificate_file'], @config['java_home'])
+      @s3     = AWS::S3::Base.establish_connection!(:access_key_id => @config['s3']['access_key_id'], :secret_access_key => @config['s3']['secret_access_key'])
+    rescue Exception => e
+      failed(e)
+    end
+    
+    def finished
+      @logger.debug "The backup finished."
+      publish_log!
+    end
+    
+    def failed(exception)
+      @logger.debug "#{exception.message} #{exception.backtrace.join("\n")}"
+      @logger.debug "[!] The backup has failed."
+      publish_log!
+      raise exception
+    end
+    
+    def write_feed!
+      @logger.write_feed(@config['log_feed'])
+    end
+    
+    def publish_log!
+      write_feed!
+      AWS::S3::S3Object.store('backup_feed.xml', File.open(@config['log_feed']), @config['s3']['bucket'], :content_type => 'application/atom+xml', :access => :public_read)
+    end
+    
+    def run!
+      begin
+        create_mysql_dump!
+        bring_backup_volume_online!
+        sync!
+      rescue Exception => e
+        failed(e)
+      ensure
+        take_backup_volume_offline! if ec2_instance_id
+      end
+      finished
+    end
+    
+    def bring_backup_volume_online!
+      launch_ec2_instance!
+      attach_backup_volume!
+      mount_backup_volume!
+    end
+    
+    def launch_ec2_instance!
+      @ec2_instance_id = @ec2.run_instance(@config['ec2']['ami'], @config['ec2']['keypair_name'])
+      sleep 5 until @ec2.running?(@ec2_instance_id)
+    end
+    
+    def attach_backup_volume!
+      @ec2.attach_volume(@config['ec2']['ebs'], ec2_instance_id, "/dev/sdh")
+      sleep 2.5 until @ec2.attached?(@config['ec2']['ebs'])
+    end
+    
+    def mount_backup_volume!
+      ssh "-o 'StrictHostKeyChecking=no' -i '#{@config['ec2']['keypair_file']}' root@#{ec2_host} 'mkdir /mnt/data-store && mount /dev/sdh /mnt/data-store'"
+    end
+    
+    def take_backup_volume_offline!
+      @ec2.terminate_instance @ec2_instance_id
+    end
+    
+    def ec2_host
+      @ec2_host ||= @ec2.host_of_instance(ec2_instance_id)
+    end
+    
+    def mysql_databases
+      @mysql_databases ||= mysql('-u root --batch --skip-column-names -e "show databases"').strip.split("\n")
+    end
+    
+    def create_mysql_dump!
+      FileUtils.rm_rf(MYSQL_DUMP_DIR)
+      FileUtils.mkdir_p(MYSQL_DUMP_DIR)
+      
+      mysql_databases.each do |database|
+        mysqldump("-u root #{database} --add-drop-table > '#{File.join(MYSQL_DUMP_DIR, database)}.sql'")
+      end
+    end
+    
+    def sync!
+      rsync "-avz -e \"ssh -i '#{@config['ec2']['keypair_file']}'\" '#{MYSQL_DUMP_DIR}' '#{@config['backup'].join("' '")}' root@#{ec2_host}:/mnt/data-store"
+    end
+  end
+end

data/lib/ec2.rb

@@ -0,0 +1,84 @@
+require "rubygems"
+require "executioner"
+
+module Fingertips
+  class EC2
+    PRIVATE_KEY_FILE = '/Volumes/Fingertips Confidential/aws/fingertips/pk-6LN7EWTYKIDRU25OJYMTY6P75S43WA45.pem'
+    CERTIFICATE_FILE = '/Volumes/Fingertips Confidential/aws/fingertips/cert-6LN7EWTYKIDRU25OJYMTY6P75S43WA45.pem'
+    
+    HOME = '/opt/ec2'
+    BIN = File.join(HOME, 'bin')
+    
+    include Executioner
+    Executioner::SEARCH_PATHS << BIN
+    
+    attr_reader :zone, :private_key_file, :certificate_file, :java_home
+    
+    def initialize(zone, private_key_file, certificate_file, java_home)
+      @zone, @private_key_file, @certificate_file, @java_home = zone, private_key_file, certificate_file, java_home
+    end
+    
+    def env
+      @env ||= {
+        'JAVA_HOME'       => @java_home,
+        'EC2_HOME'        => HOME,
+        'EC2_PRIVATE_KEY' => @private_key_file,
+        'EC2_CERT'        => @certificate_file,
+        'EC2_URL'         => "https://#{@zone[0..-2]}.ec2.amazonaws.com"
+      }
+    end
+    
+    # EC2
+    
+    def run_instance(ami, keypair_name, options = {})
+      ec2_run_instances("#{ami} -z #{@zone} -k #{keypair_name}", :env => env)[1][1]
+    end
+    
+    def describe_instance(instance_id)
+      ec2_describe_instances(instance_id, :env => env).detect { |line| line[1] == instance_id }
+    end
+    
+    def terminate_instance(instance_id)
+      ec2_terminate_instances(instance_id, :env => env)[0][3]
+    end
+    
+    def running?(instance_id)
+      describe_instance(instance_id)[5] == 'running'
+    end
+    
+    def host_of_instance(instance_id)
+      describe_instance(instance_id)[3]
+    end
+    
+    # EBS
+    
+    def attach_volume(volume_id, instance_id, device)
+      ec2_attach_volume("#{volume_id} -i #{instance_id} -d #{device}", :env => env)
+    end
+    
+    def describe_volume(volume_id)
+      ec2_describe_volumes(volume_id, :env => env).detect { |line| line[0] == 'ATTACHMENT' && line[1] == volume_id }
+    end
+    
+    def attached?(volume_id)
+      describe_volume(volume_id)[4] == 'attached'
+    end
+    
+    private
+    
+    executable 'ec2-run-instances'
+    executable 'ec2-describe-instances'
+    executable 'ec2-terminate-instances'
+    
+    executable 'ec2-attach-volume'
+    executable 'ec2-describe-volumes'
+    
+    def parse(text)
+      text.strip.split("\n").map { |line| line.split("\t") }
+    end
+    
+    def execute(command, options = {})
+      parse(super)
+    end
+  end
+end

data/lib/logger.rb

@@ -0,0 +1,48 @@
+require "builder"
+require "rss"
+
+module Fingertips
+  class Logger
+    class << self
+      attr_accessor :print
+    end
+    self.print = true
+    
+    attr_reader :logged
+    
+    def initialize
+      @logged = []
+    end
+    
+    def debug(message)
+      @logged << message
+      puts(message) if self.class.print
+    end
+
+    def feed
+      output = ''
+      xml = Builder::XmlMarkup.new(:target => output, :indent => 2)
+      xml.instruct!
+      xml.feed "xmlns" => "http://www.w3.org/2005/Atom" do
+        xml.id      "http://github.com/Fingertips/fingertips-backup"
+        xml.link    "rel" => "self", "href" => "http://github.com/Fingertips/fingertips-backup"
+        xml.updated Time.now.iso8601
+        xml.author  { xml.name "Backup" }
+        xml.title   "Backup feed"
+        
+        xml.entry do
+          xml.id      "http://github.com/Fingertips/fingertips-backup"
+          xml.updated Time.now.iso8601
+          xml.title   @logged.last
+          xml.summary @logged.last
+          xml.content @logged.join("\n")
+        end
+      end
+      output
+    end
+    
+    def write_feed(path)
+      File.open(path, 'w') { |f| f << feed }
+    end
+  end
+end

data/test/backup_test.rb

@@ -0,0 +1,222 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Fingertips::Backup, in general" do
+  before do
+    @config = YAML.load(fixture_read('config.yml'))
+    @backup = Fingertips::Backup.new(fixture('config.yml'))
+  end
+  
+  it "should have instantiated a Logger and assigned it to Executioner" do
+    @backup.logger.should.be.instance_of Fingertips::Logger
+    Executioner.logger.should.be @backup.logger
+  end
+  
+  it "should return the config" do
+    @backup.config.should == @config
+  end
+  
+  it "should return a configured Fingertips::EC2 instance" do
+    @backup.ec2.should.be.instance_of Fingertips::EC2
+    @backup.ec2.zone.should == @config['ec2']['zone']
+    @backup.ec2.private_key_file.should == @config['ec2']['private_key_file']
+    @backup.ec2.certificate_file.should == @config['ec2']['certificate_file']
+  end
+  
+  it "should return a configured AWS::S3 connection" do
+    @backup.s3.should.be.instance_of AWS::S3::Connection
+    @backup.s3.access_key_id.should == @config['s3']['access_key_id']
+    @backup.s3.secret_access_key.should == @config['s3']['secret_access_key']
+  end
+  
+  it "should return a list of all MySQL databases" do
+    databases = @backup.mysql_databases
+    databases.should.include 'information_schema'
+    databases.should == `mysql -u root --batch --skip-column-names -e "show databases"`.strip.split("\n")
+  end
+  
+  it "should return the host of the EC2 instance" do
+    @backup.ec2_instance_id = 'i-nonexistant'
+    @backup.ec2.expects(:host_of_instance).with('i-nonexistant').returns('instance.amazon.com')
+    @backup.ec2_host.should == 'instance.amazon.com'
+  end
+  
+  it "should perform a full run and report that the backup finished" do
+    @backup.expects(:create_mysql_dump!)
+    @backup.expects(:bring_backup_volume_online!)
+    @backup.ec2_instance_id = 'i-nonexistant'
+    @backup.expects(:sync!)
+    @backup.expects(:take_backup_volume_offline!)
+    @backup.expects(:finished)
+    
+    @backup.run!
+  end
+  
+  it "should catch any type of exception that was raised during initialization and call #failed" do
+    Fingertips::Backup.any_instance.expects(:failed).with { |exception| exception.backtrace.to_s.include?('initialize') }
+    backup = Fingertips::Backup.new(nil)
+  end
+  
+  it "should catch any type of exception that was raised during the run and terminate the EC2 instance if one was launched and call #failed" do
+    @backup.stubs(:finished)
+    
+    @backup.ec2_instance_id = 'i-nonexistant'
+    @backup.stubs(:create_mysql_dump!).raises 'oh noes!'
+    @backup.expects(:failed).with { |exception| exception.message == 'oh noes!' }
+    @backup.expects(:take_backup_volume_offline!)
+    @backup.run!
+  end
+  
+  it "should report that the backup failed and re-raise the exception" do
+    exception = nil
+    begin; raise 'oh noes!'; rescue Exception => e; exception = e; end
+    
+    @backup.expects(:publish_log!)
+    lambda { @backup.failed(exception) }.should.raise exception.class
+    @backup.logger.logged.first.should.include 'oh noes!'
+    @backup.logger.logged.last.should == "[!] The backup has failed."
+  end
+  
+  it "should report that the backup has finished" do
+    @backup.expects(:publish_log!)
+    @backup.finished
+    @backup.logger.logged.last.should == "The backup finished."
+  end
+  
+  it "should write the feed of the current log" do
+    @backup.logger.expects(:write_feed).with(@config['log_feed'])
+    @backup.write_feed!
+  end
+  
+  it "should push the log to S3" do
+    @backup.expects(:write_feed!)
+    
+    file = stub('Feed file')
+    File.expects(:open).with(@config['log_feed']).returns(file)
+    
+    AWS::S3::S3Object.expects(:store).with('backup_feed.xml', file, @config['s3']['bucket'], :content_type => 'application/atom+xml', :access => :public_read)
+    
+    @backup.publish_log!
+  end
+end
+
+describe "Fingertips::Backup, concerning the MySQL backup" do
+  before do
+    @backup = Fingertips::Backup.new(fixture('config.yml'))
+    @backup.stubs(:mysql_databases).returns(%w{ information_schema })
+  end
+  
+  after do
+    FileUtils.rm_rf(Fingertips::Backup::MYSQL_DUMP_DIR)
+  end
+  
+  it "should first remove the tmp mysql dump dir" do
+    # have to use at_least_once because it's also called in the after filter
+    FileUtils.expects(:rm_rf).with(Fingertips::Backup::MYSQL_DUMP_DIR).at_least_once
+    @backup.create_mysql_dump!
+  end
+  
+  it "should create the tmp mysql dump dir" do
+    @backup.create_mysql_dump!
+    File.should.exist Fingertips::Backup::MYSQL_DUMP_DIR
+    File.should.be.directory Fingertips::Backup::MYSQL_DUMP_DIR
+  end
+  
+  it "should dump each database into its own file" do
+    @backup.create_mysql_dump!
+    
+    actual = strip_comments(`mysqldump -u root information_schema --add-drop-table`)
+    dump = strip_comments(File.read(File.join(Fingertips::Backup::MYSQL_DUMP_DIR, 'information_schema.sql')))
+    
+    actual.should == dump
+  end
+  
+  private
+  
+  def strip_comments(sql)
+    sql.gsub(/^--.*?$/, '').strip
+  end
+end
+
+describe "Fingertips::Backup, concerning the EBS volume" do
+  before do
+    @backup = Fingertips::Backup.new(fixture('config.yml'))
+    @config = @backup.config
+    @ec2 = @backup.ec2
+    
+    @backup.stubs(:sleep)
+    
+    @ec2.stubs(:run_instance).returns("i-nonexistant")
+    @ec2.stubs(:running?).returns(true)
+    
+    @ec2.stubs(:attach_volume)
+    @ec2.stubs(:attached?).returns(true)
+  end
+  
+  it "should run an EC2 instance and wait till it's online" do
+    @backup.stubs(:mount_backup_volume!)
+    
+    @ec2.expects(:run_instance).with('ami-nonexistant', 'fingertips').returns("i-nonexistant")
+    
+    @ec2.expects(:running?).with do |id|
+      # next time it's queried it will be running
+      def @ec2.running?(id)
+        true
+      end
+      
+      id == "i-nonexistant"
+    end.returns(false)
+    @backup.expects(:sleep).with(5).once
+    
+    @backup.launch_ec2_instance!
+    @backup.ec2_instance_id.should == "i-nonexistant"
+  end
+  
+  it "should attach the existing EBS instance and wait till it's online" do
+    @backup.ec2_instance_id = 'i-nonexistant'
+    @ec2.expects(:attach_volume).with("vol-nonexistant", "i-nonexistant", "/dev/sdh")
+    
+    @ec2.expects(:attached?).with do |id|
+      # next time it's queried it will be attached
+      def @ec2.attached?(id)
+        true
+      end
+      
+      id == "vol-nonexistant"
+    end.returns(false)
+    @backup.expects(:sleep).with(2.5).once
+    
+    @backup.attach_backup_volume!
+  end
+  
+  it "should mount the attached EBS volume on the running instance" do
+    @backup.stubs(:ec2_host).returns('instance.amazon.com')
+    @backup.expects(:ssh).with("-o 'StrictHostKeyChecking=no' -i '#{@config['ec2']['keypair_file']}' root@instance.amazon.com 'mkdir /mnt/data-store && mount /dev/sdh /mnt/data-store'")
+    @backup.mount_backup_volume!
+  end
+  
+  it "should run all steps to bring the backup volume online" do
+    @backup.expects(:launch_ec2_instance!)
+    @backup.expects(:attach_backup_volume!)
+    @backup.expects(:mount_backup_volume!)
+    
+    @backup.bring_backup_volume_online!
+  end
+  
+  it "should take the backup volume offline by terminating the EC2 instance" do
+    @backup.ec2_instance_id = 'i-nonexistant'
+    @backup.ec2.expects(:terminate_instance).with('i-nonexistant')
+    @backup.take_backup_volume_offline!
+  end
+end
+
+describe "Fingertips::Backup, concerning syncing" do
+  before do
+    @backup = Fingertips::Backup.new(fixture('config.yml'))
+    @backup.stubs(:ec2_host).returns('instance.amazon.com')
+  end
+  
+  it "should sync all configured paths and the mysql dump dir to the backup volume" do
+    @backup.expects(:rsync).with("-avz -e \"ssh -i '#{@backup.config['ec2']['keypair_file']}'\" '#{Fingertips::Backup::MYSQL_DUMP_DIR}' '/var/www/apps' '/root' root@instance.amazon.com:/mnt/data-store")
+    @backup.sync!
+  end
+end

data/test/ec2_test.rb

@@ -0,0 +1,80 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Fingertips::EC2, in general" do
+  before do
+    @ami = 'ami-nonexistant'
+    @instance = Fingertips::EC2.new('eu-west-1a', '/path/to/private_key_file', '/path/to/certificate_file', '/Library/Java/Home')
+  end
+  
+  it "should return the right env variables to be able to use the Amazon CLI tools" do
+    @instance.env.should == {
+      'JAVA_HOME'         => '/Library/Java/Home',
+      'EC2_HOME'        => '/opt/ec2',
+      'EC2_PRIVATE_KEY' => '/path/to/private_key_file',
+      'EC2_CERT'        => '/path/to/certificate_file',
+      'EC2_URL'         => 'https://eu-west-1.ec2.amazonaws.com'
+    }
+  end
+  
+  it "should return an array of lines splitted at tabs" do
+    @instance.send(:parse, "    line1item1\tline1item2\nline2item1\tline2item2   ").should ==
+      [['line1item1', 'line1item2'], ['line2item1', 'line2item2']]
+  end
+  
+  it "should override #execute so it returns the response parsed" do
+    @instance.send(:execute, 'ls').should == @instance.send(:parse, `ls`)
+  end
+end
+
+describe "Fingertips::EC2, concerning the pre-defined commands" do
+  before do
+    @instance = Fingertips::EC2.new('eu-west-1a', '/path/to/private_key_file', '/path/to/certificate_file', '/Library/Java/Home')
+    @options = { :switch_stdout_and_stderr => false, :env => @instance.env }
+  end
+  
+  it "should run an instance of the given AMI with the given options and return the instance ID" do
+    expect_call('run-instances', "ami-nonexistant -z eu-west-1a -k fingertips")
+    @instance.run_instance('ami-nonexistant', 'fingertips').should == 'i-0992a760'
+  end
+  
+  it "should return the status of an instance" do
+    expect_call('describe-instances', 'i-nonexistant')
+    @instance.describe_instance("i-nonexistant").should == @instance.send(:parse, fixture_read('describe-instances'))[1]
+  end
+  
+  it "should terminate an instance" do
+    expect_call('terminate-instances', 'i-nonexistant')
+    @instance.terminate_instance('i-nonexistant').should == 'shutting-down'
+  end
+  
+  it "should return if an instance is running" do
+    expect_call('describe-instances', 'i-nonexistant')
+    @instance.running?('i-nonexistant').should.be true
+  end
+  
+  it "should return the public host address of an instance" do
+    expect_call('describe-instances', 'i-nonexistant')
+    @instance.host_of_instance('i-nonexistant').should == 'ec2-174-129-88-205.compute-1.amazonaws.com'
+  end
+  
+  it "should attach an EBS volume to an EC2 instance" do
+    expect_call('attach-volume', 'vol-nonexistant -i i-nonexistant -d /dev/sdh')
+    @instance.attach_volume('vol-nonexistant', 'i-nonexistant', '/dev/sdh')
+  end
+  
+  it "should return the status of a volume" do
+    expect_call('describe-volumes', 'vol-nonexistant')
+    @instance.describe_volume('vol-nonexistant').should == @instance.send(:parse, fixture_read('describe-volumes'))[1]
+  end
+  
+  it "should return if a volume is attached" do
+    expect_call('describe-volumes', 'vol-nonexistant')
+    @instance.attached?('vol-nonexistant').should.be true
+  end
+  
+  private
+  
+  def expect_call(name, args)
+    @instance.expects(:execute).with("/opt/ec2/bin/ec2-#{name} #{args}", @options).returns(@instance.send(:parse, fixture_read(name)))
+  end
+end

data/test/fixtures/attach-volume

@@ -0,0 +1 @@
+ATTACHMENT	vol-21e70e48	i-ad2f19c4	/dev/sdh	attaching	2009-07-09T13:46:45+0000

data/test/fixtures/config.yml

@@ -0,0 +1,17 @@
+java_home: /Library/Java/Home
+log_feed: /var/www/backup_feed/backup_feed.xml
+s3:
+  bucket: backup_feed
+  access_key_id: ANID
+  secret_access_key: SOSECRET
+ec2:
+  zone: eu-west-1a
+  ebs: vol-nonexistant
+  ami: ami-nonexistant
+  keypair_name: fingertips
+  keypair_file: /Volumes/Fingertips Confidential/aws/fingertips/keys/fingertips
+  private_key_file: /Volumes/Fingertips Confidential/aws/fingertips/pk-6LN7EWTYKIDRU25OJYMTY6P75S43WA45.pem
+  certificate_file: /Volumes/Fingertips Confidential/aws/fingertips/cert-6LN7EWTYKIDRU25OJYMTY6P75S43WA45.pem
+backup:
+  - /var/www/apps
+  - /root

data/test/fixtures/describe-instances

@@ -0,0 +1,2 @@
+RESERVATION	r-bfda9cd6	895951156444	default
+INSTANCE	i-nonexistant	ami-0d729464	ec2-174-129-88-205.compute-1.amazonaws.com	domU-12-31-39-00-84-B7.compute-1.internal	running	fingertips	0		m1.small	2009-07-08T13:06:22+0000	us-east-1b	aki-a71cf9ce	ari-a51cf9cc		monitoring-disabled

data/test/fixtures/describe-volumes

@@ -0,0 +1,2 @@
+VOLUME	vol-nonexistant	1		us-east-1d	in-use	2009-07-09T13:41:40+0000
+ATTACHMENT	vol-nonexistant	i-ad2f19c4	/dev/sdh	attached	2009-07-09T13:46:45+0000

data/test/fixtures/run-instances

@@ -0,0 +1,2 @@
+RESERVATION	r-ffd09796	895951156444	default
+INSTANCE	i-0992a760	ami-0d729464			pending	fingertips	0		m1.small	2009-07-07T14:52:22+0000	us-east-1b	aki-a71cf9cari-a51cf9cc		monitoring-disabled

data/test/fixtures/terminate-instances

@@ -0,0 +1 @@
+INSTANCE	i-7b576012	running	shutting-down

data/test/logger_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Fingertips::Logger" do
+  TMP_FEED = '/tmp/backup_feed'
+  
+  before do
+    @logger = Fingertips::Logger.new
+    @logger.debug "foo"
+    @logger.debug "bar"
+    @logger.debug "baz"
+  end
+  
+  after do
+    FileUtils.rm_rf TMP_FEED
+  end
+  
+  it "should store any debug messages" do
+    @logger.logged.should == %w{ foo bar baz }
+  end
+  
+  it "should create a feed" do
+    @logger.feed.should.include "foo\nbar\nbaz"
+  end
+  
+  it "should write the feed to a given path" do
+    now = Time.now
+    Time.stubs(:now).returns(now)
+    
+    @logger.write_feed(TMP_FEED)
+    File.read(TMP_FEED).should == @logger.feed
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require "test/spec"
+require "mocha"
+
+$:.unshift File.expand_path('../../lib', __FILE__)
+require "backup"
+
+Fingertips::Logger.print = false
+
+FIXTURES = File.expand_path('../fixtures', __FILE__)
+
+class Test::Unit::TestCase
+  def fixture(fixture)
+    File.join(FIXTURES, fixture)
+  end
+  
+  def fixture_read(fixture)
+    File.read(self.fixture(fixture))
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: Fingertips-fingertips-backup
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-18 00:00:00 -07:00
+default_executable: fingertips-backup
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: Fingertips-executioner
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: aws-s3
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A simple tool to backup MySQL databases and files to an Amazon EBS instance through an EC2 instance.
+email: eloy@fngtps.com
+executables: 
+- fingertips-backup
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Rakefile
+- VERSION.yml
+- bin/fingertips-backup
+- lib/backup.rb
+- lib/ec2.rb
+- lib/logger.rb
+- test/backup_test.rb
+- test/ec2_test.rb
+- test/fixtures/attach-volume
+- test/fixtures/config.yml
+- test/fixtures/describe-instances
+- test/fixtures/describe-volumes
+- test/fixtures/run-instances
+- test/fixtures/terminate-instances
+- test/logger_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://fingertips.github.com
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: A simple tool to backup a webserver.
+test_files: 
+- test/backup_test.rb
+- test/ec2_test.rb
+- test/logger_test.rb
+- test/test_helper.rb