squidward 0.5

data/bin/squidward

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+$LOAD_PATH.unshift(File.dirname(Pathname.new(__FILE__).realpath) + '/../')
+
+require 'lib/squidward'
+require 'lib/squidward/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Squidward::Command.run!(command, args)

data/lib/squidward.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+%w{aws/s3 fileutils logger md5 base64 yaml sdbtools pstore}.each &method(:require)
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'squidward/command'
+
+# These are the default constants used along the code to refer to the squidward folders 
+CONF_PATH, SETTINGS_FILE, TEMP_PATH, LOG_FILE = "~/.squidward", ".settings", "temp", "squidward.log"
+
+# Default module that contains the whole application
+module Squidward
+  # Commands container, if you can't call this a command pattern implentation, there's no such thing 
+  module Command   
+    class << self
+      # Runs the given command and performs the proper invocation based on the user input.
+      # This method is the core dispatcher for the whole application.
+      def run!(command, args)
+        command, method = command.gsub(/-/,'_').split(/:/)
+        klass, method = eval("Squidward::Command::#{command.capitalize}"), (method or :index).to_sym
+
+        instance = klass.new
+        instance.send(method, args)
+      rescue 
+        puts("Unknown command. Run 'squidward help' for usage information.")
+      end
+    end
+  end
+end

data/lib/squidward/command.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'commands/base'
+Dir["#{File.dirname(__FILE__)}/commands/*"].each { |c| require c }

data/lib/squidward/commands/base.rb

@@ -0,0 +1,107 @@
+module Squidward
+  module Command
+    # Base command from where all the other commands inherit
+    # it contains the most used methods (stout, sterror, etc) and 
+    # also handles the configuration, hence AWS credentials
+    class Base
+      # Creates a new instance and prompts the user for the 
+      # credentials if they aren't stored
+      def initialize()
+        unless (@credentials = read_credentials)
+          @credentials = ask_for_credentials
+          store_credentials(@credentials)
+        end
+      end
+      
+      # Gets the AWS Credentials from the user
+      def ask_for_credentials
+        puts "Enter your AWS credentials."
+
+        print "Access Key ID: "
+        user = ask
+
+        print "Secret Access Key: "
+        password = ask_for_password
+
+        return [user, password]
+      end
+      
+      # Turns off the standard output while writting the password
+      def echo_off
+        system "stty -echo"
+      end
+      
+      # Turns on the standard output after writting the password
+      def echo_on
+        system "stty echo"
+      end
+      
+      # Gets trimmed input from the user
+      def ask
+        gets.strip
+      end
+
+      # Gets trimmed input from the user but with echoing off
+      def ask_for_password
+        echo_off
+        password = ask
+        puts
+        echo_on
+        return password
+      end
+      
+      # Reads the configuration from the profile, if the reload parameter is set to true, it will 
+      # read it again, if not it will just return what it's already in-memory.
+      def configuration(reload = false)
+        # if the user asks not to reload we should send what we've got except we don't got anything
+        return @configuration if (@configuration and not reload)
+        path = File.expand_path File.join(CONF_PATH, SETTINGS_FILE)
+        # if the configuration file isn't created yet it should create it
+        return {} unless File.exists?(path)
+        @configuration = YAML.load_file(path)
+      end
+      
+      # Reads credentials from the configuration file
+      def read_credentials
+        conf = self.configuration
+        return nil unless conf[:credentials]
+        return [conf[:credentials][:access_key], conf[:credentials][:secret_key]]
+      end
+
+      # Dumps configuration file contents to the user profile
+      def store_configuration(new_configuration)
+        FileUtils.mkpath(File.expand_path(CONF_PATH))
+        File.open(File.expand_path(File.join(CONF_PATH, SETTINGS_FILE)), "w+") do |io|
+          YAML::dump(new_configuration, io)
+        end
+      end
+      
+      # Stores the users credentials on the configuration.
+      def store_credentials(credentials)
+        conf = configuration
+        conf[:credentials] = {}
+        conf[:credentials][:access_key], conf[:credentials][:secret_key] = credentials[0], credentials[1]
+        store_configuration(conf)
+      end
+      
+      # Nice and clean way of echoing
+      def display(msg, newline=true)
+        if newline
+          puts(msg)
+        else
+          print(msg)
+          STDOUT.flush
+        end
+      end
+      
+      # Logger singleton
+      def logger
+        return @logger if @logger
+        @logger = Logger.new(File.expand_path(File.join(CONF_PATH, LOG_FILE)))
+        @logger.level = Logger::INFO
+        @logger.formatter = Proc.new {|s, t, n, msg| "[#{t}] [#{s}] #{msg}\n"}
+        @logger
+      end
+    end
+  end
+end

data/lib/squidward/commands/bucket.rb

@@ -0,0 +1,13 @@
+module Squidward
+  module Command
+    # Handles all the command related to AWS S3's buckets
+    class Bucket < Base
+      # Sets the destination bucket for the backups to be uploaded on S3
+      def set(args)
+        new_configuration = configuration
+        new_configuration[:default_bucket] = args[0]
+        store_configuration(new_configuration)
+      end
+    end
+  end
+end

data/lib/squidward/commands/credentials.rb

@@ -0,0 +1,13 @@
+module Squidward
+  module Command
+    # Handles all the commands related to credentials
+    class Credentials < Base
+      # Removes the stored credentials from the current configuration
+      def clear(args = nil)
+        new_configuration = configuration
+        new_configuration[:credentials] = nil
+        store_configuration(new_configuration)
+      end
+    end
+  end
+end

data/lib/squidward/commands/domain.rb

@@ -0,0 +1,24 @@
+module Squidward
+  module Command
+    # Handles everything related to AWS SimpleDB Domains for Backup
+    class Domain < Base
+      # Configures a SimpleDB domain for backup. When given the second parameter is 
+      # the virtual path inside the bucket to be stored.
+      def backup(args)
+        domain, vpath = args
+        conf = self.configuration
+        conf[:domains] = (conf[:domains] or []) + [{:domain => domain, :vpath => vpath}]
+        store_configuration(conf)
+      end
+      
+      # Removes a SimpleDB domain already being backed up from the current user profile
+      # so it doesn't run anymore.      
+      def remove(args)
+        domain, vpath = args
+        conf = self.configuration
+        conf[:domains] = conf[:domains].reject{|d| d[:domain].downcase.strip == domain.downcase.strip}
+        store_configuration(conf)
+      end
+    end
+  end
+end

data/lib/squidward/commands/help.rb

@@ -0,0 +1,79 @@
+module Squidward
+  module Command
+    class Help < Base
+      class HelpGroup < Array
+        attr_reader :title
+
+        def initialize(title)
+          @title = title
+        end
+
+        def command(name, description)
+          self << [name, description]
+        end
+
+        def space
+          self << ['', '']
+        end
+      end
+
+      def self.groups
+        @groups ||= []
+      end
+
+      def self.group(title, &block)
+        groups << begin
+          group = HelpGroup.new(title)
+          yield group
+          group
+        end
+      end
+
+      def self.create_default_groups!
+        group 'General Commands' do |group|
+          group.command 'help',                             'show this usage'
+          group.command 'version',                          'show gem version'
+          group.space
+          group.command 'bucket:set <name>',                'set the S3 bucket where the files will be uploaded (default: backup, created when missing)'
+          group.space
+          group.command 'credentials:clear',                'clear the credentials stored on your settings'
+          group.space
+          group.command 'domain:backup <domain> [vpath] ',  'add aws_simpledb domain for backup [optional vpath a virtual path inside the bucket]'
+          group.command 'domain:remove <domain>',           'remove aws_simpledb domain from backup list'
+          group.space
+          group.command 'run',                              'run the process by taking one by one the domains configured on your settings'        
+          group.space
+          group.command 'info',                             'display your current settings'
+          group.command 'logs',                             'display lastest information from the log file'
+        end
+      end
+
+      def index(args)
+        display usage
+      end
+
+      def usage
+        longest_command_length = self.class.groups.map do |group|
+          group.map { |g| g.first.length }
+        end.flatten.max
+
+        self.class.groups.inject(StringIO.new) do |output, group|
+          output.puts "=== %s" % group.title
+          output.puts
+
+          group.each do |command, description|
+            if command.empty?
+              output.puts
+            else
+              output.puts "%-*s # %s" % [longest_command_length, command, description]
+            end
+          end
+          output.puts
+          output
+        end.string
+      end
+    end
+  end
+end
+
+Squidward::Command::Help.create_default_groups!

data/lib/squidward/commands/info.rb

@@ -0,0 +1,26 @@
+module Squidward
+  module Command
+    # Handles the echoing of the current configuration (pretty basic tough)
+    class Info < Base
+      # Goes thru the settings and echos their values.
+      def index(args = nil)
+        display("=== Current Settings")
+        display("Amazon Web Services Account:  #{configuration[:credentials][:access_key]}")
+        display("Amazon S3 Bucket:             #{configuration[:default_bucket]}")
+        display("")
+        if (configuration[:domains] and configuration[:domains].size > 0)
+          display("Configured Domains:           ", false)  
+          first = true
+          configuration[:domains].each do |domain|
+            spaces = (not first) ? " " * 30 : ""
+            display(spaces + "#{domain[:domain]} is being uploaded to #{domain[:vpath] or "<bucket_root>"}")
+            first = false
+          end
+        else
+          display("Configured Domains:           You currently have no domains configuration for backup")
+        end
+        display("")
+      end
+    end
+  end
+end

data/lib/squidward/commands/logs.rb

@@ -0,0 +1,11 @@
+module Squidward
+  module Command
+    # Handles the information related to the log being genereated by the application
+    class Logs < Base
+      # Echoes to the stdout the latest 25 lines of the log
+      def index(args = nil)
+        system "tail -n 25 #{File.expand_path(File.join(CONF_PATH, LOG_FILE))}"
+      end
+    end
+  end
+end

data/lib/squidward/commands/run.rb

@@ -0,0 +1,86 @@
+module Squidward
+  module Command
+    # Core class of the whole application. It simply runs everything once it has been configured.
+    class Run < Base
+      def initialize()
+        super
+        aws_config = {}
+        aws_config[:access_key_id], aws_config[:secret_access_key] = @credentials
+        AWS::S3::Base.establish_connection!(aws_config)
+      end
+      
+      # Runs the backup for each configured simpledb domain
+      def index(args = {})
+        ensure_bucket!(bucket)
+        domains.each do |domain|
+          internal_run(domain)
+        end
+      end
+      
+      # If the configured bucket does not exists on AWS S3 it will create it, 
+      # else it will just retrieve it.
+      def ensure_bucket!(bucket_name)
+        begin 
+           AWS::S3::Bucket.find(bucket_name) 
+        rescue
+          AWS::S3::Bucket.create(bucket_name) 
+        end
+      end
+      
+      # Performs a backup for a specific domain
+      def internal_run(pair = {})
+        domain_name, virtual_path = pair[:domain], (pair[:vpath] or "")
+        return unless database.domain_exists?(pair[:domain])
+        dump_file = dump_domain(domain_name)
+        dump_file_md5 = Base64.encode64(compute_md5(dump_file).digest)
+        upload_to = File.join(virtual_path, generate_dump_filename(domain_name))
+        AWS::S3::S3Object.store("#{upload_to}.tar.gz", open(dump_file), bucket, :content_md5 => dump_file_md5)
+        File.delete(dump_file)
+      end
+
+      # Dumps the domain contents to YAML file
+      def dump_domain(domain_name)
+        temp_folder = File.expand_path(File.join(CONF_PATH, TEMP_PATH))
+        FileUtils.mkpath(temp_folder)
+        temp_file = File.join(temp_folder, generate_dump_filename(domain_name))
+        results = database.domain(domain_name).selection().results
+        File.open(temp_file, "w+") { |io| YAML::dump(results, io) }
+        `tar -czf "#{temp_file}.tar.gz" -C "#{File.dirname(temp_file)}" "#{File.basename(temp_file)}"`
+        File.delete(temp_file)
+        return "#{temp_file}.tar.gz"
+      end
+      
+      # Generates a unique filename for the current domain backup
+      def generate_dump_filename(domain_name)
+        "#{domain_name}-#{Time.now.utc.strftime("%Y%m%d%H%M%S%Z%Y")}"
+      end
+
+      # Singleton instance of the database
+      def database
+        @database ||= SDBTools::Database.new(@credentials[0],  @credentials[1], :logger => self.logger)
+      end
+      
+      # Returns every configured domain for the current user
+      def domains
+        return self.configuration[:domains]
+      end
+
+      # Returns the bucket configured for the current user
+      def bucket
+        return (self.configuration[:default_bucket] or "backup")
+      end
+      
+      # Computes the MD5 for the uploaded file, in-case you 
+      # wanna do corruption detection
+      def compute_md5(filename)
+        md5_digest = Digest::MD5.new
+        File.open(filename, 'r') do |file|
+          file.each_line do |line|
+            md5_digest << line
+          end
+        end
+        return md5_digest
+      end
+    end
+  end
+end

data/lib/squidward/commands/version.rb

@@ -0,0 +1,15 @@
+module Squidward
+  module Command
+    # Gem Versioning Helper and also displays current version to the user
+    class Version < Base
+      GEM_VERSION = "0.5"
+      
+      # Displays current gem version to the user
+      def index(args = nil)
+        display("squidward-#{GEM_VERSION}")
+      end
+    end
+  end
+end
+    
+  

data/rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'lib/squidward'
+require 'rake'
+require 'spec'
+require 'mocha'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+task :default => [:specs]
+
+task :specs do
+  Spec::Rake::SpecTask.new('specs_run') do |t|
+    t.spec_files = FileList['spec/**/*.rb']
+    t.rcov = true
+    t.rcov_opts = ['--text-report', '--exclude', ".bundle,.gem,spec,Library,#{ENV['GEM_HOME']}", '--sort', 'coverage' ]
+    t.spec_opts = ['-cfn']
+  end
+  Rake::Task['specs_run'].invoke
+end
+
+namespace :dist do  
+  spec = Gem::Specification.new do |s|
+    s.name              = 'squidward'
+    s.version           = Gem::Version.new(Squidward::Command::Version::GEM_VERSION)
+    s.summary           = "Backup tool for taking SimpleDB domains to compressed files inside Amazon S3"
+    s.description       = "A dead simple tool for doing backups of simpledb domains."
+    s.email             = 'johnny.halife@me.com'
+    s.author            = 'Johnny G. Halife'
+    s.homepage          = 'http://squidward.heroku.com'
+
+    s.files              = %w(rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+    s.executables        = "squidward"
+    s.default_executable = "squidward"
+    
+    s.platform          = Gem::Platform::RUBY
+    s.has_rdoc          = true
+    s.rdoc_options      << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+
+    s.require_path      = "lib"
+    s.bindir            = "bin"    
+
+    # Dependencies
+    s.add_dependency 'aws-s3'
+    s.add_dependency 'sdbtools'
+  end
+  
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+  end
+end

data/spec/commands/base_test.rb

@@ -0,0 +1,76 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "base commands functionality" do
+  
+  it "should prompt for AWS Credentials when they do not exist" do
+    Squidward::Command::Base.any_instance.expects(:read_credentials).returns(false)
+    Squidward::Command::Base.any_instance.expects(:ask_for_credentials).returns(["access_key", "secret_key"])
+    Squidward::Command::Base.any_instance.expects(:store_credentials).with(["access_key", "secret_key"])
+    my_command = Squidward::Command::Base.new()
+  end
+  
+  it "should ask for credentials" do
+    Squidward::Command::Base.any_instance.expects(:read_credentials).returns(true)
+    my_command = Squidward::Command::Base.new()
+    my_command.expects(:puts).with("Enter your AWS credentials.")
+    my_command.expects(:print).with("Access Key ID: ")
+    my_command.expects(:print).with("Secret Access Key: ")
+    my_command.expects(:ask).returns("user")
+    my_command.expects(:ask_for_password).returns("password")
+    my_command.ask_for_credentials.should == ["user", "password"]
+  end
+  
+  it "when asking for password should turn off echo and turn it on" do
+    Squidward::Command::Base.any_instance.expects(:read_credentials).returns(true)
+    my_command = Squidward::Command::Base.new()
+    my_command.expects(:echo_off)
+    my_command.expects(:echo_on)
+    my_command.expects(:puts)
+    my_command.expects(:ask).returns("password")
+    my_command.ask_for_password.should == "password"
+  end
+  
+  it "should read the configuration when its prompted for config (no relaod)" do
+    Squidward::Command::Base.any_instance.expects(:read_credentials).returns(true)
+    configuration_path = File.expand_path(File.join(CONF_PATH, SETTINGS_FILE))
+    File.expects(:exists?).with(configuration_path).returns(true)
+    YAML::expects(:load_file).with(configuration_path)
+    my_command = Squidward::Command::Base.new()
+    my_command.configuration
+  end
+  
+  it "should return the existing configuration when its prompted for config (no relaod)" do
+    Squidward::Command::Base.any_instance.expects(:read_credentials).returns(true)
+    configuration_path = File.expand_path(File.join(CONF_PATH, SETTINGS_FILE))
+    File.expects(:exists?).with(configuration_path).returns(true)
+    YAML::expects(:load_file).with(configuration_path).returns({:key => "value"})
+    my_command = Squidward::Command::Base.new()
+    my_command.configuration
+    # I'm doing it twice and it should work the second time (returns the cached copy)
+    my_command.configuration
+  end
+  
+  it "should store configuration" do
+    Squidward::Command::Base.any_instance.expects(:read_credentials).returns(true)
+    File.expects(:open).with(File.expand_path(File.join(CONF_PATH, SETTINGS_FILE)), "w+")
+    FileUtils.expects(:mkpath).with(File.expand_path(CONF_PATH))
+    my_command = Squidward::Command::Base.new()
+    my_command.store_configuration({})
+  end
+  
+  it "should read credentials when already there" do
+    Squidward::Command::Base.any_instance.expects(:configuration).returns({:credentials => {:secret_key => "secret", :access_key => "access"}}).twice
+    my_command = Squidward::Command::Base.new()
+    my_command.read_credentials.should == ["access", "secret"]
+  end 
+  
+  it "should store credentials after getting them" do
+    Squidward::Command::Base.any_instance.expects(:read_credentials).returns(false)
+    Squidward::Command::Base.any_instance.expects(:ask_for_credentials).returns(["access_key", "secret_key"])
+    Squidward::Command::Base.any_instance.expects(:configuration).returns({:credentials => {}})
+    Squidward::Command::Base.any_instance.expects(:store_configuration).returns()
+    my_command = Squidward::Command::Base.new()
+  end
+end

data/spec/commands/bucket_test.rb

@@ -0,0 +1,20 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "runner command functionality" do
+  before do 
+    Squidward::Command::Bucket.any_instance.expects(:read_credentials).returns(["access_key", "secret_key"])
+  end
+  
+  it "should inherit the Base functionality" do
+    my_command = Squidward::Command::Bucket.new()
+  end
+  
+  it "should set backup default bucket" do
+    my_command = Squidward::Command::Bucket.new()
+    my_command.expects(:configuration).returns({})
+    my_command.expects(:store_configuration).with({:default_bucket => "backup"})
+    my_command.set(["backup"])
+  end
+end

data/spec/commands/credentials_test.rb

@@ -0,0 +1,12 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "runner command functionality" do
+  it "should clear the stored credentials" do
+    my_command = Squidward::Command::Credentials.new()
+    my_command.expects(:configuration).returns({:credentials => ["foo", "bar"]})
+    my_command.expects(:store_configuration).with({:credentials => nil})
+    my_command.clear
+  end
+end

data/spec/commands/domain_test.rb

@@ -0,0 +1,28 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "domain command functionality" do
+  it "should inherit the Base functionality" do
+    Squidward::Command::Domain.any_instance.expects(:read_credentials).returns(true)
+    my_command = Squidward::Command::Domain.new()
+  end
+  
+  it "should store backup for domain" do
+    existing_domains = [{:domain => "domain", :vpath => "vpath"}]
+    Squidward::Command::Domain.any_instance.expects(:read_credentials).returns(true)
+    Squidward::Command::Domain.any_instance.expects(:configuration).returns({:domains => existing_domains})
+    Squidward::Command::Domain.any_instance.expects(:store_configuration).with({:domains => existing_domains + [{:domain => "domain_name", :vpath => "virtual_path"}]})
+    my_command = Squidward::Command::Domain.new()
+    my_command.backup(["domain_name", "virtual_path"])
+  end 
+  
+  it "should remove existing backup from the configuration and store new config" do
+    existing_domains = [{:domain => "domain", :vpath => "vpath"}]
+    Squidward::Command::Domain.any_instance.expects(:read_credentials).returns(true)
+    Squidward::Command::Domain.any_instance.expects(:configuration).returns({:domains => existing_domains})
+    Squidward::Command::Domain.any_instance.expects(:store_configuration).with({:domains => []})
+    my_command = Squidward::Command::Domain.new()
+    my_command.remove("domain")
+  end
+end

data/spec/commands/logs_test.rb

@@ -0,0 +1,19 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "runner command functionality" do
+  before do 
+    Squidward::Command::Logs.any_instance.expects(:read_credentials).returns(["access_key", "secret_key"])
+  end
+  
+  it "should inherit the Base functionality" do
+    my_command = Squidward::Command::Logs.new()
+  end
+  
+  it "should set backup default bucket" do
+    my_command = Squidward::Command::Logs.new()
+    my_command.expects(:system).with("tail -n 25 #{File.expand_path(File.join(CONF_PATH, LOG_FILE))}")
+    my_command.index
+  end
+end

data/spec/commands/run_test.rb

@@ -0,0 +1,133 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "runner command functionality" do
+  before do 
+    Squidward::Command::Run.any_instance.expects(:read_credentials).returns(["access_key", "secret_key"])
+    AWS::S3::Base.expects(:establish_connection!).with(:access_key_id => "access_key", :secret_access_key => "secret_key")
+  end
+  
+  it "should inherit the Base functionality" do
+    my_command = Squidward::Command::Run.new()
+  end
+  
+  it "should return services to run from the configuration" do
+    configuration = {:domains => [{:domain => "domain1", :vpath => "path2"}, 
+                                 {:domain => "domain2", :vpath => "path2"}]}
+
+     my_command = Squidward::Command::Run.new() 
+     my_command.expects(:configuration).returns(configuration)
+     my_command.domains.should == configuration[:domains]
+  end
+  
+  it "should return services to run from the configuration" do
+    configuration = {:default_bucket => "backup"}
+    my_command = Squidward::Command::Run.new() 
+    my_command.expects(:configuration).returns(configuration)
+    my_command.bucket.should == configuration[:default_bucket]
+  end
+  
+  it "should return services to run from the configuration" do
+     my_command = Squidward::Command::Run.new() 
+     my_command.expects(:configuration).returns({})
+     my_command.bucket.should == "backup"
+  end
+  
+  it "should run the backup for each domain (and ensure the destination bucket exists)" do
+    my_command = Squidward::Command::Run.new()
+    my_command.expects(:ensure_bucket!).returns("backup.squidward.full").once    
+    my_command.expects(:domains).returns([{:domain => "domain1", :vpath => "bucket1"}])
+    my_command.expects(:internal_run).with({:domain => "domain1", :vpath => "bucket1"})
+    my_command.index
+  end
+
+  it "should run the backup for each domain (and avoide creating the destination bucket when it exists)" do
+    my_command = Squidward::Command::Run.new()
+    my_command.expects(:bucket).returns("backup.squidward.full")
+    my_command.expects(:ensure_bucket!).with("backup.squidward.full")
+    my_command.expects(:domains).returns([{:domain => "domain1", :vpath => "bucket1"}])
+    my_command.expects(:internal_run).with({:domain => "domain1", :vpath => "bucket1"})
+    my_command.index
+  end
+
+  it "should dump a domain and return the file path to the dump result" do
+    FileUtils.expects(:mkpath).with(File.expand_path(File.join(CONF_PATH, TEMP_PATH))).returns("temp-path")
+    dump_file = File.expand_path(File.join(CONF_PATH, TEMP_PATH, "dump"))
+    
+    my_command = Squidward::Command::Run.new()
+    my_command.expects(:generate_dump_filename).returns("dump")
+    
+    (mock_selection = mock).expects(:results).returns([])
+    (mock_domain = mock).expects(:selection).returns(mock_selection)    
+    (mock_db = mock).expects(:domain).with("custom-domain").returns(mock_domain)
+    my_command.expects(:database).returns(mock_db)
+    
+    File.expects(:open).with(dump_file, "w+")
+    File.expects(:delete).with(dump_file)
+    
+    my_command.expects(:`).with("tar -czf \"#{dump_file}.tar.gz\" -C \"#{File.dirname(dump_file)}\" \"#{File.basename(dump_file)}\"")  
+    my_command.dump_domain("custom-domain").should == "#{dump_file}.tar.gz"
+  end
+
+  it "should generate the filename for the dumped file" do
+    now = Time.now
+    Time.expects(:now).returns(now).twice
+    my_command = Squidward::Command::Run.new()
+    my_command.generate_dump_filename("my-domain").should == "my-domain-#{Time.now.utc.strftime("%Y%m%d%H%M%S%Z%Y")}"
+  end
+  
+  it "should do anything if domain does not exist" do
+    my_command = Squidward::Command::Run.new()
+    (mock_db = mock).expects(:domain_exists?).with("domain1").returns(false)
+    my_command.expects(:database).returns(mock_db)
+    my_command.internal_run(:domain => "domain1", :vpath => "/sdb/")
+  end
+
+  it "should do full blown backup of a single domain when it exists" do
+    my_command = Squidward::Command::Run.new()
+    my_command.expects(:bucket).returns("my_bucket")
+    
+    my_command.expects(:generate_dump_filename).with("domain").returns("dump")
+    
+    # the domain already exists
+    (mock_db = mock).expects(:domain_exists?).with("domain").returns(true)
+    my_command.expects(:database).returns(mock_db)
+    
+    # ask the library to dump the files
+    my_command.expects(:dump_domain).with("domain").returns("mock/path/to/file.tar.gz")
+    
+    # generate md5-base64 for the file
+    (mock_digest = mock).expects(:digest).returns("digest")
+    my_command.expects(:compute_md5).with("mock/path/to/file.tar.gz").returns(mock_digest)
+    Base64.expects(:encode64).with("digest").returns("base64digest")
+    
+    # mock the file opening
+    my_command.expects(:open).with("mock/path/to/file.tar.gz").returns("contents")
+    
+    AWS::S3::S3Object.expects(:store).with("/sdb/dump.tar.gz", "contents", "my_bucket", :content_md5 => "base64digest")
+    
+    File.expects(:delete).with("mock/path/to/file.tar.gz")
+    my_command.internal_run(:domain => "domain", :vpath => "/sdb/")
+  end
+
+  it "should hold a singleton instance of the database" do
+   (mock_logger = mock).expects(:info)
+   Squidward::Command::Run.any_instance.expects(:logger).returns(mock_logger)
+   my_command = Squidward::Command::Run.new()
+   my_command.database.nil?.should == false 
+  end
+  
+  it "should look up for the bucket when calling ensure if it exists" do
+    my_command = Squidward::Command::Run.new()
+    AWS::S3::Bucket.expects(:find).with("my_bucket").returns(mock)
+    my_command.ensure_bucket!("my_bucket").nil?.should == false
+  end
+  
+  it "should create the bucket when it does not exist" do
+    my_command = Squidward::Command::Run.new()
+    AWS::S3::Bucket.expects(:find).with("my_bucket").raises(StandardError)
+    AWS::S3::Bucket.expects(:create).with("my_bucket").returns(mock)
+    my_command.ensure_bucket!("my_bucket").nil?.should == false
+  end
+end

data/spec/commands/version_test.rb

@@ -0,0 +1,15 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "runner command functionality" do
+  before do 
+    Squidward::Command::Version.any_instance.expects(:read_credentials).returns(["access_key", "secret_key"])
+  end
+
+  it "should show version string as {gem_name}-{version}" do
+    my_command = Squidward::Command::Version.new()
+    my_command.expects(:display).with("squidward-#{Squidward::Command::Version::GEM_VERSION}")
+    my_command.index
+  end
+end

data/spec/mock_command.rb

@@ -0,0 +1,7 @@
+class Squidward::Command::Mock
+  def index
+  end
+  
+  def mock_method
+  end
+end

data/spec/spec_config.rb

@@ -0,0 +1,11 @@
+require 'spec'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'lib/squidward'
+
+require 'mock_command'
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

data/spec/squidward_test.rb

@@ -0,0 +1,28 @@
+# enabling the load of files from root (on RSpec)
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../')
+require 'spec_config'
+
+describe "launcher behavior" do  
+  it "should invoke the proper command and method" do
+    (command = mock).expects(:run)
+    Squidward::Command::Mock.expects(:new).returns(command)
+    Squidward::Command.run!("mock:run", nil)
+  end
+  
+  it "should invoke index method as the default method when not provided" do
+    (command = mock).expects(:index)
+    Squidward::Command::Mock.expects(:new).returns(command)    
+    Squidward::Command.run!("mock", nil)
+  end
+  
+  it "should raise missing command when the method is invalid" do    
+    Squidward::Command.expects(:puts).with("Unknown command. Run 'squidward help' for usage information.")
+    Squidward::Command.run!("invalid", nil)
+  end
+  
+  it "should raise missing command when the command action does not exist" do
+    Squidward::Command.expects(:puts).with("Unknown command. Run 'squidward help' for usage information.")
+    Squidward::Command::Mock.expects(:new).returns(mock)
+    Squidward::Command.run!("mock:non-existing", nil)
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: squidward
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 5
+  version: "0.5"
+platform: ruby
+authors: 
+- Johnny G. Halife
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-26 00:00:00 -03:00
+default_executable: squidward
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: aws-s3
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sdbtools
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: A dead simple tool for doing backups of simpledb domains.
+email: johnny.halife@me.com
+executables: 
+- squidward
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rakefile
+- bin/squidward
+- lib/squidward/command.rb
+- lib/squidward/commands/base.rb
+- lib/squidward/commands/bucket.rb
+- lib/squidward/commands/credentials.rb
+- lib/squidward/commands/domain.rb
+- lib/squidward/commands/help.rb
+- lib/squidward/commands/info.rb
+- lib/squidward/commands/logs.rb
+- lib/squidward/commands/run.rb
+- lib/squidward/commands/version.rb
+- lib/squidward.rb
+- spec/commands/base_test.rb
+- spec/commands/bucket_test.rb
+- spec/commands/credentials_test.rb
+- spec/commands/domain_test.rb
+- spec/commands/logs_test.rb
+- spec/commands/run_test.rb
+- spec/commands/version_test.rb
+- spec/mock_command.rb
+- spec/spec_config.rb
+- spec/squidward_test.rb
+has_rdoc: true
+homepage: http://squidward.heroku.com
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- -A cattr_accessor=object
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Backup tool for taking SimpleDB domains to compressed files inside Amazon S3
+test_files: []
+