whiskey_disk 0.6.22 → 0.6.23

data/Rakefile

@@ -4,12 +4,85 @@ require 'rake/testtask'
 desc 'Default: run unit tests.'
 task :default => :test
 
-desc 'Test RubyCloud'
+desc 'Test whiskey_disk'
 task :test do
   files = Dir['spec/**/*_spec.rb'].join(" ")
   system("bacon #{files}")
 end
 
+namespace :integration do
+  def say(mesg)
+    STDERR.puts mesg
+  end
+
+  def vagrant_path
+    File.expand_path(File.join(File.dirname(__FILE__), 'scenarios', 'setup', 'vagrant'))
+  end
+
+  def root_path
+    File.expand_path(File.dirname(__FILE__))
+  end
+
+  def pidfile
+    File.join(vagrant_path, 'pids', 'git-daemon.pid')
+  end
+
+  def start_git_daemon
+    stop_git_daemon
+    say "Starting git daemon..."
+    run(root_path, "git daemon --base-path=#{root_path}/scenarios/git_repositories/ --reuseaddr --verbose --detach --pid-file=#{pidfile}")
+  end
+
+  def stop_git_daemon
+    return unless File.exists?(pidfile)
+    pid = File.read(pidfile).chomp
+    return if pid == ''
+    say "Stopping git daemon..."
+    run(root_path, "kill #{pid}")
+  end
+
+  def start_vm
+    say "Bringing up vagrant vm..."
+    run(vagrant_path, 'vagrant up')
+    copy_ssh_config
+  end
+
+  def stop_vm
+    say "Shutting down vagrant vm..."
+    run(vagrant_path, 'vagrant halt')
+  end
+
+  def copy_ssh_config
+    say "Capturing vagrant ssh_config data..."
+    run(vagrant_path, "vagrant ssh_config > #{vagrant_path}/ssh_config")
+  end
+
+  def run(path, cmd)
+    Dir.chdir(path)
+    say "running: #{cmd} [cwd: #{Dir.pwd}]"
+    system(cmd)
+  end
+
+  desc 'Start a vagrant VM and git-daemon server to support running integration specs'
+  task :up do
+    start_vm
+    start_git_daemon
+  end
+
+  desc 'Shut down integration vagrant VM and git-daemon server'
+  task :down do
+    stop_git_daemon
+    stop_vm
+  end
+
+  desc 'Completely remove the vagrant VM files used by the integration spec suite'
+  task :destroy do
+    stop_git_daemon
+    stop_vm
+    run(vagrant_path, 'vagrant destroy')
+  end
+end
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
@@ -20,12 +93,13 @@ begin
     gemspec.homepage = "http://github.com/flogic/whiskey_disk"
     gemspec.authors = ["Rick Bradley"]
     gemspec.add_dependency('rake')
-    
+
     # I've decided that the integration spec shizzle shouldn't go into the gem
-    gemspec.files.exclude 'scenarios', 'spec/integration'
-    gemspec.test_files.exclude 'scenarios', 'spec/integration'
+    rejected = %w(scenarios spec/integration)
+    gemspec.files.reject {|f| rejected.include?(f) }
+    gemspec.test_files.reject {|f| rejected.include?(f) }
   end
-  Jeweler::GemcutterTasks.new  
+  Jeweler::GemcutterTasks.new
 rescue LoadError
   # if you get here, you need Jeweler installed to do packaging and gem installation, yo.
 end

data/VERSION

@@ -1 +1 @@
-0.6.22
+0.6.23

data/lib/whiskey_disk.rb

@@ -1,320 +1,323 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'whiskey_disk', 'config'))
 
 class WhiskeyDisk
-  class << self
-    attr_writer :configuration
-    attr_reader :results
-    
-    def reset
-      @configuration = nil
-      @buffer = nil
-      @staleness_checks = nil
-      @results = nil
-    end
-    
-    def buffer
-      @buffer ||= []
-    end
-    
-    def configuration
-      @configuration ||= WhiskeyDisk::Config.fetch
-    end
-    
-    def [](key)
-      configuration[key.to_s]
-    end
-    
-    def check_staleness?
-      WhiskeyDisk::Config.check_staleness?
-    end
-    
-    def enable_staleness_checks
-      @staleness_checks = true
-    end
-    
-    def staleness_checks_enabled?
-      !!@staleness_checks
-    end    
+  attr_writer :configuration, :config
+  attr_reader :results
+  
+  def initialize(options = {})
+    @staleness_checks = true if options[:staleness_checks]
+  end
+  
+  def buffer
+    @buffer ||= []
+  end
+  
+  def config
+    @config ||= WhiskeyDisk::Config.new
+  end
+  
+  def configuration
+    @configuration ||= config.fetch
+  end
+  
+  def debugging?
+    config.debug?
+  end
+  
+  def setting(key)
+    configuration[key.to_s]
+  end
+  
+  def check_staleness?
+    config.check_staleness?
+  end
+  
+  def staleness_checks_enabled?
+    !!@staleness_checks
+  end    
 
-    def enqueue(command)
-      buffer << command
-    end
-    
-    def remote?(domain)
-      return false unless domain
-      return false if domain == 'local'
-      limit = WhiskeyDisk::Config.domain_limit 
-      return false if limit and domain_limit_match?(domain, limit)
+  def enqueue(command)
+    buffer << command
+  end
+  
+  def remote?(domain)
+    return false unless domain
+    return false if domain == 'local'
+    limit = config.domain_limit 
+    return false if limit and domain_limit_match?(domain, limit)
 
-      true
-    end
-    
-    def has_config_repo?
-      ! (self[:config_repository].nil? or self[:config_repository] == '')
-    end
-    
-    def project_name_specified?
-      self[:project] != 'unnamed_project'
-    end
+    true
+  end
+  
+  def has_config_repo?
+    ! (setting(:config_repository).nil? or setting(:config_repository) == '')
+  end
+  
+  def project_name_specified?
+    setting(:project) != 'unnamed_project'
+  end
 
-    def branch
-      (self[:branch] and self[:branch] != '') ? self[:branch] : 'master'
-    end
-    
-    def config_branch
-      (self[:config_branch] and self[:config_branch] != '') ? self[:config_branch] : 'master'
+  def branch
+    (setting(:branch) and setting(:branch) != '') ? setting(:branch) : 'master'
+  end
+  
+  def config_branch
+    (setting(:config_branch) and setting(:config_branch) != '') ? setting(:config_branch) : 'master'
+  end
+  
+  def env_vars
+    return '' unless setting(:rake_env)
+    setting(:rake_env).keys.inject('') do |buffer,k| 
+      buffer += "#{k}='#{setting(:rake_env)[k]}' "
+      buffer
     end
-    
-    def env_vars
-      return '' unless self[:rake_env]
-      self[:rake_env].keys.inject('') do |buffer,k| 
-        buffer += "#{k}='#{self[:rake_env][k]}' "
-        buffer
-      end
+  end
+  
+  def parent_path(path)
+    File.split(path).first
+  end
+  
+  def tail_path(path)
+    File.split(path).last
+  end
+  
+  def needs(*keys)
+    keys.each do |key|
+      raise "No value for '#{key}' declared in configuration files [#{config.configuration_file}]" unless setting(key)
     end
+  end
+
+  def apply_staleness_check(commands)
+    needs(:deploy_to, :repository)
     
-    def parent_path(path)
-      File.split(path).first
-    end
+    check = "cd #{setting(:deploy_to)}; " +
+            "ml=\`git log -1 --pretty=format:%H\`; " +
+            "mr=\`git ls-remote #{setting(:repository)} refs/heads/#{branch}\`; "
     
-    def tail_path(path)
-      File.split(path).last
+    if setting(:deploy_config_to)
+      check += "cd #{setting(:deploy_config_to)}; " +
+               "cl=\`git log -1 --pretty=format:%H\`; " +
+               "cr=\`git ls-remote #{setting(:config_repository)} refs/heads/#{config_branch}\`; "
     end
     
-    def needs(*keys)
-      keys.each do |key|
-        raise "No value for '#{key}' declared in configuration files [#{WhiskeyDisk::Config.configuration_file}]" unless self[key]
-      end
-    end
+    check += "if [[ $ml != ${mr%%\t*} ]] " +
+             (setting(:deploy_config_to) ? "|| [[ $cl != ${cr%%\t*} ]]" : '') +
+             "; then #{commands}; else echo \"No changes to deploy.\"; fi"
+  end
+  
+  def join_commands
+    buffer.collect {|c| "{ #{c} ; }"}.join(' && ')
+  end
+  
+  def bundle
+    return '' if buffer.empty?
+    (staleness_checks_enabled? and check_staleness?) ? apply_staleness_check(join_commands) : join_commands
+  end
 
-    def apply_staleness_check(commands)
-      needs(:deploy_to, :repository)
-      
-      check = "cd #{self[:deploy_to]}; " +
-              "ml=\`git log -1 --pretty=format:%H\`; " +
-              "mr=\`git ls-remote #{self[:repository]} refs/heads/#{branch}\`; "
-      
-      if self[:deploy_config_to]
-        check += "cd #{self[:deploy_config_to]}; " +
-                 "cl=\`git log -1 --pretty=format:%H\`; " +
-                 "cr=\`git ls-remote #{self[:config_repository]} refs/heads/#{config_branch}\`; "
-      end
-      
-      check += "if [[ $ml != ${mr%%\t*} ]] " +
-               (self[:deploy_config_to] ? "|| [[ $cl != ${cr%%\t*} ]]" : '') +
-               "; then #{commands}; else echo \"No changes to deploy.\"; fi"
-    end
-    
-    def join_commands
-      buffer.collect {|c| "{ #{c} ; }"}.join(' && ')
-    end
-    
-    def bundle
-      return '' if buffer.empty?
-      (staleness_checks_enabled? and check_staleness?) ? apply_staleness_check(join_commands) : join_commands
-    end
+  def domain_limit_match?(domain, limit)
+    domain.sub(%r{^.*@}, '') == limit
+  end
+  
+  def domain_of_interest?(domain)
+    return true unless limit = config.domain_limit
+    domain_limit_match?(domain, limit)
+  end
+  
+  def encode_roles(roles)
+    return '' unless roles and !roles.empty?
+    "export WD_ROLES='#{roles.join(':')}'; "
+  end
 
-    def domain_limit_match?(domain, limit)
-      domain.sub(%r{^.*@}, '') == limit
-    end
-    
-    def domain_of_interest?(domain)
-      return true unless limit = WhiskeyDisk::Config.domain_limit
-      domain_limit_match?(domain, limit)
-    end
-    
-    def encode_roles(roles)
-      return '' unless roles and !roles.empty?
-      "export WD_ROLES='#{roles.join(':')}'; "
-    end
+  def build_command(domain, cmd)
+    "#{'set -x; ' if debugging?}" + encode_roles(domain['roles']) + cmd
+  end
+  
+  def run(domain, cmd)
+    ssh(domain, cmd)
+  end
 
-    def build_command(domain, cmd)
-      "#{'set -x; ' if Config.debug?}" + encode_roles(domain[:roles]) + cmd
-    end
-    
-    def run(domain, cmd)
-      ssh(domain, cmd)
-    end
+  def ssh(domain, cmd)
+    args = []
+    args << domain['name']
+    args << '-v' if debugging?
+    args += domain['ssh_options'] if domain['ssh_options']
+    args << build_command(domain, cmd)
 
-    def ssh(domain, cmd)
-      puts "Running command on [#{domain}]: [#{cmd}]" if Config.debug?
-      args = [domain[:name], build_command(domain, cmd)]
-      args.unshift '-v' if Config.debug?
-      system('ssh', *args)
-    end
-    
-    def shell(domain, cmd)
-      puts "Running command locally: [#{cmd}]" if Config.debug?
-      system('bash', '-c', build_command(domain, cmd))
-    end
-    
-    def flush
-      needs(:domain)
-      self[:domain].each do |domain|
-        next unless domain_of_interest?(domain[:name])
-        puts "Deploying #{domain[:name]}..."
-        status = remote?(domain[:name]) ? run(domain, bundle) : shell(domain, bundle)
-        record_result(domain[:name], status)
-      end
-    end
-    
-    def record_result(domain, status)
-      @results ||= []
-      @results << { :domain => domain, :status => status }
+    puts "Running: ssh #{args.join(' ')}" if debugging?
+    system('ssh', *args)
+  end
+  
+  def shell(domain, cmd)
+    puts "Running command locally: [#{cmd}]" if debugging?
+    system('bash', '-c', build_command(domain, cmd))
+  end
+  
+  def flush
+    needs(:domain)
+    setting(:domain).each do |domain|
+      next unless domain_of_interest?(domain['name'])
+      puts "Deploying #{domain['name']}..."
+      status = remote?(domain['name']) ? run(domain, bundle) : shell(domain, bundle)
+      record_result(domain['name'], status)
     end
+  end
+  
+  def record_result(domain, status)
+    @results ||= []
+    @results << { 'domain' => domain, 'status' => status }
+  end
 
-    def summarize_results(results)
-      successes = failures = 0
-      results.each do |result|
-        puts "#{result[:domain]} => #{result[:status] ? 'succeeded' : 'failed'}."
-        if result[:status]
-          successes += 1 
-        else
-          failures += 1
-        end
-      end
-      [successes + failures, successes, failures]
-    end
-    
-    def summarize
-      puts "\nResults:"
-      if results and not results.empty?
-        total, successes, failures = summarize_results(results)
-        puts "Total: #{total} deployment#{total == 1 ? '' : 's'}, " +
-          "#{successes} success#{successes == 1 ? '' : 'es'}, " +
-          "#{failures} failure#{failures == 1 ? '' : 's'}."
+  def summarize_results(results)
+    successes = failures = 0
+    results.each do |result|
+      puts "#{result['domain']} => #{result['status'] ? 'succeeded' : 'failed'}."
+      if result['status']
+        successes += 1 
       else
-        puts "No deployments to report."
-      end       
-    end
-    
-    def success?
-      return true if !results or results.empty?
-      results.all? {|result| result[:status] }
-    end
-    
-    def if_file_present(path, cmd)
-      "if [ -e #{path} ]; then #{cmd}; fi"
-    end
-    
-    def if_task_defined(task, cmd)
-      %Q(rakep=`#{env_vars} rake -P` && if [[ `echo "${rakep}" | grep #{task}` != "" ]]; then #{cmd}; fi )
-    end
-    
-    def safe_branch_checkout(path, my_branch)
-      %Q(cd #{path} && git checkout -b #{my_branch} origin/#{my_branch} || git checkout #{my_branch} origin/#{my_branch} || git checkout #{my_branch})
-    end
-    
-    def clone_repository(repo, path, my_branch)
-      enqueue "cd #{parent_path(path)}"
-      enqueue("if [ -e #{path} ]; then echo 'Repository already cloned to [#{path}].  Skipping.'; " +
-              "else git clone #{repo} #{tail_path(path)} && #{safe_branch_checkout(path, my_branch)}; fi")
-    end
-   
-    def refresh_checkout(path, repo_branch)
-      enqueue "cd #{path}"
-      enqueue "git fetch origin +refs/heads/#{repo_branch}:refs/remotes/origin/#{repo_branch} #{'&>/dev/null' unless Config.debug?}"
-      enqueue "git checkout #{repo_branch} #{'&>/dev/null' unless Config.debug?}"
-      enqueue "git reset --hard origin/#{repo_branch} #{'&>/dev/null' unless Config.debug?}"
+        failures += 1
+      end
     end
+    [successes + failures, successes, failures]
+  end
+  
+  def summarize
+    puts "\nResults:"
+    if results and not results.empty?
+      total, successes, failures = summarize_results(results)
+      puts "Total: #{total} deployment#{total == 1 ? '' : 's'}, " +
+        "#{successes} success#{successes == 1 ? '' : 'es'}, " +
+        "#{failures} failure#{failures == 1 ? '' : 's'}."
+    else
+      puts "No deployments to report."
+    end       
+  end
+  
+  def success?
+    return true if !results or results.empty?
+    results.all? {|result| result['status'] }
+  end
+  
+  def if_file_present(path, cmd)
+    "if [ -e #{path} ]; then #{cmd}; fi"
+  end
+  
+  def if_task_defined(task, cmd)
+    %Q(rakep=`#{env_vars} rake -P` && if [[ `echo "${rakep}" | grep #{task}` != "" ]]; then #{cmd}; fi )
+  end
+  
+  def safe_branch_checkout(path, my_branch)
+    %Q(cd #{path} && git checkout -b #{my_branch} origin/#{my_branch} || git checkout #{my_branch} origin/#{my_branch} || git checkout #{my_branch})
+  end
+  
+  def clone_repository(repo, path, my_branch)
+    enqueue "cd #{parent_path(path)}"
+    enqueue("if [ -e #{path} ]; then echo 'Repository already cloned to [#{path}].  Skipping.'; " +
+            "else git clone #{repo} #{tail_path(path)} && #{safe_branch_checkout(path, my_branch)}; fi")
+  end
+ 
+  def refresh_checkout(path, repo_branch)
+    enqueue "cd #{path}"
+    enqueue "git fetch origin +refs/heads/#{repo_branch}:refs/remotes/origin/#{repo_branch} #{'&>/dev/null' unless debugging?}"
+    enqueue "git checkout #{repo_branch} #{'&>/dev/null' unless debugging?}"
+    enqueue "git reset --hard origin/#{repo_branch} #{'&>/dev/null' unless debugging?}"
+  end
 
-    def run_rake_task(path, task_name)
-      enqueue "echo Running rake #{task_name}..."
-      enqueue "cd #{path}"
-      enqueue(if_file_present("#{self[:deploy_to]}/Rakefile", 
-        if_task_defined(task_name, "#{env_vars} rake #{'--trace' if Config.debug?} #{task_name} to=#{self[:environment]}")))
-    end
-    
-    def build_path(path)
-      return path if path =~ %r{^/}
-      File.join(self[:deploy_to], path)
-    end
+  def run_rake_task(path, task_name)
+    enqueue "echo Running rake #{task_name}..."
+    enqueue "cd #{path}"
+    enqueue(if_file_present("#{setting(:deploy_to)}/Rakefile", 
+      if_task_defined(task_name, "#{env_vars} rake #{'--trace' if debugging?} #{task_name} to=#{setting(:environment)}")))
+  end
+  
+  def build_path(path)
+    return path if path =~ %r{^/}
+    File.join(setting(:deploy_to), path)
+  end
 
-    def run_script(script)
-      return unless script
-      enqueue(%Q<cd #{self[:deploy_to]}; echo "Running post script..."; #{env_vars} bash #{'-x' if Config.debug?} #{build_path(script)}>)
-    end
+  def run_script(script)
+    return unless script
+    enqueue(%Q<cd #{setting(:deploy_to)}; echo "Running post script..."; #{env_vars} bash #{'-x' if debugging?} #{build_path(script)}>)
+  end
 
-    def ensure_main_parent_path_is_present
-      needs(:deploy_to)
-      enqueue "mkdir -p #{parent_path(self[:deploy_to])}"
-    end
-    
-    def ensure_config_parent_path_is_present
-      needs(:deploy_config_to)
-      enqueue "mkdir -p #{parent_path(self[:deploy_config_to])}"
-    end
+  def ensure_main_parent_path_is_present
+    needs(:deploy_to)
+    enqueue "mkdir -p #{parent_path(setting(:deploy_to))}"
+  end
+  
+  def ensure_config_parent_path_is_present
+    needs(:deploy_config_to)
+    enqueue "mkdir -p #{parent_path(setting(:deploy_config_to))}"
+  end
 
-    def checkout_main_repository
-      needs(:deploy_to, :repository)
-      clone_repository(self[:repository], self[:deploy_to], branch)
-    end
-    
-    def checkout_configuration_repository
-      needs(:deploy_config_to, :config_repository)
-      clone_repository(self[:config_repository], self[:deploy_config_to], config_branch)
-    end
-    
-    def snapshot_git_revision
-      needs(:deploy_to)
-      enqueue "cd #{self[:deploy_to]}"
-      enqueue %Q{ml=\`git log -1 --pretty=format:%H\`}
-    end
-    
-    def initialize_git_changes
-      needs(:deploy_to)
-      enqueue "rm -f #{self[:deploy_to]}/.whiskey_disk_git_changes"
-      snapshot_git_revision
-    end
-    
-    def initialize_rsync_changes
-      needs(:deploy_to)
-      enqueue "rm -f #{self[:deploy_to]}/.whiskey_disk_rsync_changes"
-    end
-    
-    def initialize_all_changes
-      needs(:deploy_to)
-      initialize_git_changes
-      initialize_rsync_changes
-    end
-    
-    def capture_git_changes
-      needs(:deploy_to)
-      enqueue "git diff --name-only ${ml}..HEAD > #{self[:deploy_to]}/.whiskey_disk_git_changes"
-    end
-    
-    def update_main_repository_checkout
-      needs(:deploy_to)
-      initialize_git_changes
-      refresh_checkout(self[:deploy_to], branch)
-      capture_git_changes
-    end
-    
-    def update_configuration_repository_checkout
-      needs(:deploy_config_to)
-      initialize_rsync_changes
-      refresh_checkout(self[:deploy_config_to], config_branch)
-    end
-    
-    def refresh_configuration
-      needs(:deploy_to, :deploy_config_to)
-      raise "Must specify project name when using a configuration repository." unless project_name_specified?
-      enqueue "echo Rsyncing configuration..."
-      enqueue("rsync -a#{'v --progress' if Config.debug?} " + '--log-format="%t [%p] %i %n" ' +
-              "#{self[:deploy_config_to]}/#{self[:project]}/#{self[:config_target]}/ #{self[:deploy_to]}/ " + 
-              "> #{self[:deploy_to]}/.whiskey_disk_rsync_changes")
-    end
-    
-    def run_post_setup_hooks
-      needs(:deploy_to)
-      run_script(self[:post_setup_script])
-      run_rake_task(self[:deploy_to], "deploy:post_setup")
-    end
-    
-    def run_post_deploy_hooks
-      needs(:deploy_to)
-      run_script(self[:post_deploy_script])
-      run_rake_task(self[:deploy_to], "deploy:post_deploy")
-    end
+  def checkout_main_repository
+    needs(:deploy_to, :repository)
+    clone_repository(setting(:repository), setting(:deploy_to), branch)
+  end
+  
+  def checkout_configuration_repository
+    needs(:deploy_config_to, :config_repository)
+    clone_repository(setting(:config_repository), setting(:deploy_config_to), config_branch)
+  end
+  
+  def snapshot_git_revision
+    needs(:deploy_to)
+    enqueue "cd #{setting(:deploy_to)}"
+    enqueue %Q{ml=\`git log -1 --pretty=format:%H\`}
+  end
+  
+  def initialize_git_changes
+    needs(:deploy_to)
+    enqueue "rm -f #{setting(:deploy_to)}/.whiskey_disk_git_changes"
+    snapshot_git_revision
+  end
+  
+  def initialize_rsync_changes
+    needs(:deploy_to)
+    enqueue "rm -f #{setting(:deploy_to)}/.whiskey_disk_rsync_changes"
+  end
+  
+  def initialize_all_changes
+    needs(:deploy_to)
+    initialize_git_changes
+    initialize_rsync_changes
+  end
+  
+  def capture_git_changes
+    needs(:deploy_to)
+    enqueue "git diff --name-only ${ml}..HEAD > #{setting(:deploy_to)}/.whiskey_disk_git_changes"
+  end
+  
+  def update_main_repository_checkout
+    needs(:deploy_to)
+    initialize_git_changes
+    refresh_checkout(setting(:deploy_to), branch)
+    capture_git_changes
+  end
+  
+  def update_configuration_repository_checkout
+    needs(:deploy_config_to)
+    initialize_rsync_changes
+    refresh_checkout(setting(:deploy_config_to), config_branch)
+  end
+  
+  def refresh_configuration
+    needs(:deploy_to, :deploy_config_to)
+    raise "Must specify project name when using a configuration repository." unless project_name_specified?
+    enqueue "echo Rsyncing configuration..."
+    enqueue("rsync -a#{'v --progress' if debugging?} " + '--log-format="%t [%p] %i %n" ' +
+            "#{setting(:deploy_config_to)}/#{setting(:project)}/#{setting(:config_target)}/ #{setting(:deploy_to)}/ " + 
+            "> #{setting(:deploy_to)}/.whiskey_disk_rsync_changes")
+  end
+  
+  def run_post_setup_hooks
+    needs(:deploy_to)
+    run_script(setting(:post_setup_script))
+    run_rake_task(setting(:deploy_to), "deploy:post_setup")
+  end
+  
+  def run_post_deploy_hooks
+    needs(:deploy_to)
+    run_script(setting(:post_deploy_script))
+    run_rake_task(setting(:deploy_to), "deploy:post_deploy")
   end
 end