vlad 2.0.0 → 2.1.0

data/.autotest

@@ -1,12 +1,13 @@
 # -*- ruby -*-
 
 require 'autotest/restart'
+require 'autotest/rcov'
 
 Autotest.add_hook :initialize do |at|
   at.testlib = "minitest/autorun"
 #   at.extra_files << "../some/external/dependency.rb"
 #
-#   at.libs << ":../some/external"
+  at.libs << ":../../rake-remote_task/dev/lib"
 #
 #   at.add_exception 'vendor'
 #

data/History.txt

@@ -1,3 +1,32 @@
+=== 2.1.0 / 2010-07-15
+
+* 1 major enhancement:
+
+  * Split out rake_remote_task.rb and vlad_test_case.rb (in rake-remote_task gem).
+
+* 4 minor enhancements:
+
+  * Added :type config option, defaulting to rails
+  * Moved VladTestCase to Rake::TestCase (in rake-remote_task gem).
+  * Moved all Vlad exceptions to Rake (in rake-remote_task gem).
+  * Refactored rails specific values out of core. (raggi)
+
+* 2 bug fixes:
+
+  * Clarified Rake.clear_tasks in faq
+  * Fixed output from vlad:invoke (pnc)
+
+=== 2.0.0 / 2009-08-18
+
+* 1 major enhancement:
+
+  * Removed all extra modules that we don't support in core anymore.
+
+* 2 minor enhancements:
+
+  * Added test to show that false is a valid variable value.
+  * Moved vlad_test_case from test to lib to support 3rd party vlad modules.
+
 === 1.4.0 / 2009-06-23
 
 * 1 major enhancement:

data/Manifest.txt

@@ -11,15 +11,13 @@ doco/getting_started.txt
 doco/migration.txt
 doco/perforce.txt
 doco/variables.txt
-lib/rake_remote_task.rb
 lib/vlad.rb
 lib/vlad/apache.rb
 lib/vlad/core.rb
 lib/vlad/maintenance.rb
 lib/vlad/passenger.rb
+lib/vlad/rails.rb
 lib/vlad/subversion.rb
-lib/vlad_test_case.rb
-test/test_rake_remote_task.rb
 test/test_vlad.rb
 test/test_vlad_subversion.rb
 vladdemo.sh

data/Rakefile

@@ -5,6 +5,8 @@ require 'hoe'
 
 Hoe.plugin :seattlerb
 
+Hoe.add_include_dirs "../../rake-remote_task/dev/lib"
+
 Hoe.spec 'vlad' do
   self.rubyforge_name = 'hitsquad'
 
@@ -13,6 +15,7 @@ Hoe.spec 'vlad' do
   developer 'Wilson Bilkovich', 'wilson@supremetyrant.com'
 
   extra_deps << ['rake',  '~> 0.8.0']
+  extra_deps << ['rake-remote_task',  '~> 2.0']
   extra_deps << ['open4', '~> 0.9.0']
 
   # TODO: remove 1.9
@@ -21,6 +24,8 @@ end
 
 desc "quick little hack to see what the state of the nation looks like"
 task :debug do
+  $: << 'lib'
+  require 'vlad'
   Vlad.load :config => "lib/vlad/subversion.rb"
   set :repository, "repository path"
   set :deploy_to,  "deploy path"
@@ -29,17 +34,4 @@ task :debug do
   Rake::Task['vlad:debug'].invoke
 end
 
-task :mana_from_heaven do
-  # vlad = vlad + rake + open4
-  # rake sans-contrib = 2035.98356718206
-  vlad  = `flog -s lib`.to_f + 2350.30744806517 + 502.363818023761
-  cap   = 11480.3919695285
-  ratio = cap / vlad
-  target = cap / Math::PI
-
-  puts "%14.8f = %s" % [vlad, "vlad"]
-  puts "%14.8f = %s" % [ratio, "ratio"]
-  puts "%14.8f = %s" % [target - vlad, "needed delta"]
-end
-
 # vim: syntax=ruby

data/doco/faq.txt

@@ -54,8 +54,13 @@ To prepend on a task, add a dependency:
 === Q: How can I replace a rake task instead of just adding to it?
 === A: Use Rake.clear_tasks str_or_regexp
 
+NOTE: Rake.clear_tasks was moved to Hoe so it could be used more generally.
+
+  require 'hoe/rake'
+  
   namespace :vlad do
-    # Clear existing update task so that we can redefine instead of adding to it.
+    # Clear existing update task so that we can redefine instead of
+    # adding to it.
     Rake.clear_tasks('vlad:update') 
   
     remote_task :update, :roles => :app do

data/lib/vlad/core.rb

@@ -40,7 +40,7 @@ namespace :vlad do
 
   remote_task :setup_app, :roles => :app do
     dirs = [deploy_to, releases_path, scm_path, shared_path]
-    dirs += %w(system log pids).map { |d| File.join(shared_path, d) }
+    dirs += shared_paths.keys.map { |d| File.join(shared_path, d) }
     run "umask #{umask} && mkdir -p #{dirs.join(' ')}"
   end
 
@@ -56,8 +56,8 @@ namespace :vlad do
             "#{source.checkout revision, scm_path}",
             "#{source.export revision, release_path}",
             "chmod -R g+w #{latest_release}",
-            "rm -rf #{latest_release}/log #{latest_release}/public/system #{latest_release}/tmp/pids",
-            "mkdir -p #{latest_release}/db #{latest_release}/tmp"
+            "rm -rf #{shared_paths.values.map { |p| File.join(latest_release, p) }.join(' ')}",
+            "mkdir -p #{mkdirs.map { |d| File.join(latest_release, d) }.join(' ')}"
           ].join(" && ")
       Rake::Task['vlad:update_symlinks'].invoke
 
@@ -76,28 +76,10 @@ namespace :vlad do
   desc "Updates the symlinks for shared paths".cleanup
 
   remote_task :update_symlinks, :roles => :app do
-    run [ "ln -s #{shared_path}/log #{latest_release}/log",
-          "ln -s #{shared_path}/system #{latest_release}/public/system",
-          "ln -s #{shared_path}/pids #{latest_release}/tmp/pids" ].join(" && ")
-  end
-
-  desc "Run the migrate rake task for the the app. By default this is run in
-    the latest app directory.  You can run migrations for the current app
-    directory by setting :migrate_target to :current.  Additional environment
-    variables can be passed to rake via the migrate_env variable.".cleanup
-
-  # No application files are on the DB machine, also migrations should only be
-  # run once.
-  remote_task :migrate, :roles => :app do
-    break unless target_host == Rake::RemoteTask.hosts_for(:app).first
-
-    directory = case migrate_target.to_sym
-                when :current then current_path
-                when :latest  then current_release
-                else raise ArgumentError, "unknown migration target #{migrate_target.inspect}"
-                end
-
-    run "cd #{directory}; #{rake_cmd} RAILS_ENV=#{rails_env} db:migrate #{migrate_args}"
+    ops = shared_paths.map do |sp, rp|
+      "ln -s #{shared_path}/#{sp} #{latest_release}/#{rp}"
+    end
+    run ops.join(' && ')
   end
 
   desc "Invoke a single command on every remote server. This is useful for
@@ -112,7 +94,7 @@ namespace :vlad do
   remote_task :invoke do
     command = ENV["COMMAND"]
     abort "Please specify a command to execute on the remote servers (via the COMMAND environment variable)" unless command
-    puts run(command)
+    run(command)
   end
 
   desc "Copy arbitrary files to the currently deployed version using

data/lib/vlad/rails.rb

@@ -0,0 +1,34 @@
+namespace :vlad do
+  set :rails_env,      "production"
+  set :migrate_args,   ""
+  set :migrate_target, :latest
+  set :mkdirs,         %w(tmp db)
+  set :shared_paths, {
+    'log'    => 'log',
+    'system' => 'public/system',
+    'pids'   => 'tmp/pids',
+  }
+
+  desc "Run the migrate rake task for the the app. By default this is run in
+    the latest app directory.  You can run migrations for the current app
+    directory by setting :migrate_target to :current.  Additional environment
+    variables can be passed to rake via the migrate_env variable.".cleanup
+
+  # No application files are on the DB machine, also migrations should only be
+  # run once.
+  remote_task :migrate, :roles => :app do
+    break unless target_host == Rake::RemoteTask.hosts_for(:app).first
+
+    directory = case migrate_target.to_sym
+                when :current then current_path
+                when :latest  then current_release
+                else
+                  raise(ArgumentError,
+                        "unknown migration target #{migrate_target.inspect}")
+                end
+
+    run ["cd #{directory}",
+         "#{rake_cmd} RAILS_ENV=#{rails_env} db:migrate #{migrate_args}"
+        ].join(" ")
+  end
+end

data/lib/vlad.rb

@@ -1,11 +1,12 @@
 require 'rubygems'
 require 'thread'
-require 'rake_remote_task'
+require 'rake/remote_task'
 
 $TESTING ||= false
 
 ##
-# Vlad the Deployer - Pragmatic application deployment automation, without mercy.
+# Vlad the Deployer - Pragmatic application deployment automation,
+# without mercy.
 #
 # Please read doco/getting_started.txt or http://rubyhitsquad.com/
 #
@@ -20,23 +21,7 @@ module Vlad
 
   ##
   # This is the version of Vlad you are running.
-  VERSION = '2.0.0'
-
-  ##
-  # Base error class for all Vlad errors.
-  class Error < RuntimeError; end
-
-  ##
-  # Raised when you have incorrectly configured Vlad.
-  class ConfigurationError < Error; end
-
-  ##
-  # Raised when a remote command fails.
-  class CommandFailedError < Error; end
-
-  ##
-  # Raised when an environment variable hasn't been set.
-  class FetchError < Error; end
+  VERSION = '2.1.0'
 
   ##
   # Loads tasks file +tasks_file+ and various recipe styles as a hash
@@ -56,13 +41,15 @@ module Vlad
   # fit for you. All it does is a fancy-pants require. Require
   # whatever files you need as you see fit straight from your
   # Rakefile. YAY for simple and clean!
+
   def self.load options = {}
     options = {:config => options} if String === options
-    order = [:core, :app, :config, :scm, :web]
+    order = [:core, :type, :app, :config, :scm, :web]
     order += options.keys - order
 
     recipes = {
       :app    => :passenger,
+      :type   => :rails,
       :config => 'config/deploy.rb',
       :core   => :core,
       :scm    => :subversion,

data/test/test_vlad.rb

@@ -1,112 +1,111 @@
-require 'vlad_test_case'
-require 'vlad'
+require 'rake/test_case'
 
 $TESTING = true
 
-class TestVlad < VladTestCase
+class TestVlad < Rake::TestCase
   def test_all_hosts
     util_set_hosts
-    assert_equal %w[app.example.com db.example.com], @vlad.all_hosts
+    assert_equal %w[app.example.com db.example.com], @rake.all_hosts
   end
 
   def test_fetch
     set :foo, 5
-    assert_equal 5, @vlad.fetch(:foo)
+    assert_equal 5, @rake.fetch(:foo)
   end
 
   def test_fetch_with_default
-    assert_equal 5, @vlad.fetch(:not_here, 5)
+    assert_equal 5, @rake.fetch(:not_here, 5)
   end
 
   def test_host
-    @vlad.host "test.example.com", :app, :db
+    @rake.host "test.example.com", :app, :db
     expected = {"test.example.com" => {}}
-    assert_equal expected, @vlad.roles[:app]
-    assert_equal expected, @vlad.roles[:db]
+    assert_equal expected, @rake.roles[:app]
+    assert_equal expected, @rake.roles[:db]
   end
 
   def test_host_invalid
-    assert_raises(ArgumentError) { @vlad.host nil, :web }
+    assert_raises(ArgumentError) { @rake.host nil, :web }
   end
 
   def test_host_multiple_hosts
-    @vlad.host "test.example.com", :app, :db
-    @vlad.host "yarr.example.com", :app, :db, :no_release => true
+    @rake.host "test.example.com", :app, :db
+    @rake.host "yarr.example.com", :app, :db, :no_release => true
 
     expected = {
       "test.example.com" => {},
       "yarr.example.com" => {:no_release => true}
     }
 
-    assert_equal expected, @vlad.roles[:app]
-    assert_equal expected, @vlad.roles[:db]
-    refute_equal(@vlad.roles[:db]["test.example.com"].object_id,
-                 @vlad.roles[:app]["test.example.com"].object_id)
+    assert_equal expected, @rake.roles[:app]
+    assert_equal expected, @rake.roles[:db]
+    refute_equal(@rake.roles[:db]["test.example.com"].object_id,
+                 @rake.roles[:app]["test.example.com"].object_id)
   end
 
   def test_hosts_for_array_of_roles
     util_set_hosts
-    assert_equal %w[app.example.com db.example.com], @vlad.hosts_for([:app, :db])
+    assert_equal %w[app.example.com db.example.com], @rake.hosts_for([:app, :db])
   end
 
   def test_hosts_for_one_role
     util_set_hosts
-    @vlad.host "app2.example.com", :app
-    assert_equal %w[app.example.com app2.example.com], @vlad.hosts_for(:app)
+    @rake.host "app2.example.com", :app
+    assert_equal %w[app.example.com app2.example.com], @rake.hosts_for(:app)
   end
 
   def test_hosts_for_multiple_roles
     util_set_hosts
-    assert_equal %w[app.example.com db.example.com], @vlad.hosts_for(:app, :db)
+    assert_equal %w[app.example.com db.example.com], @rake.hosts_for(:app, :db)
   end
 
   def test_hosts_for_unique
     util_set_hosts
-    @vlad.host "app.example.com", :web
-    assert_equal %w[app.example.com db.example.com], @vlad.hosts_for(:app, :db, :web)
+    @rake.host "app.example.com", :web
+    assert_equal %w[app.example.com db.example.com], @rake.hosts_for(:app, :db, :web)
   end
 
   def test_initialize
-    @vlad.set_defaults # ensure these three are virginal
-    assert_raises(Vlad::ConfigurationError) { @vlad.repository }
-    assert_raises(Vlad::ConfigurationError) { @vlad.deploy_to }
-    assert_raises(Vlad::ConfigurationError) { @vlad.domain }
+    @rake.set_defaults # ensure these three are virginal
+    assert_raises(Rake::ConfigurationError) { @rake.repository }
+    assert_raises(Rake::ConfigurationError) { @rake.deploy_to }
+    assert_raises(Rake::ConfigurationError) { @rake.domain }
   end
 
   def test_role
-    @vlad.role :app, "test.example.com"
+    @rake.role :app, "test.example.com"
     expected = {"test.example.com" => {}}
-    assert_equal expected, @vlad.roles[:app]
+    assert_equal expected, @rake.roles[:app]
   end
 
   def test_role_multiple_hosts
-    @vlad.role :app, "test.example.com"
-    @vlad.role :app, "yarr.example.com", :no_release => true
+    @rake.role :app, "test.example.com"
+    @rake.role :app, "yarr.example.com", :no_release => true
     expected = {
       "test.example.com" => {},
       "yarr.example.com" => {:no_release => true}
     }
-    assert_equal expected, @vlad.roles[:app]
+    assert_equal expected, @rake.roles[:app]
   end
 
   def test_role_multiple_roles
-    @vlad.role :app, "test.example.com", :primary => true
-    @vlad.role :db, "yarr.example.com", :no_release => true
+    @rake.role :app, "test.example.com", :primary => true
+    @rake.role :db, "yarr.example.com", :no_release => true
     expected_db = { "yarr.example.com" => {:no_release => true} }
-    assert_equal expected_db, @vlad.roles[:db]
+    assert_equal expected_db, @rake.roles[:db]
     expected_app = { "test.example.com" => {:primary => true} }
-    assert_equal expected_app, @vlad.roles[:app]
+    assert_equal expected_app, @rake.roles[:app]
   end
 
   def test_remote_task
-    t = @vlad.remote_task(:test_task) { 5 }
+    t = @rake.remote_task(:test_task) { 5 }
     assert_equal @task_count + 1, Rake.application.tasks.size
     assert_equal({ :roles => [] }, t.options)
   end
 
   def test_remote_task_all_hosts_by_default
     util_set_hosts
-    t = @vlad.remote_task(:test_task) { 5 }
+    t = @rake.remote_task(:test_task) { 5 }
     assert_equal %w[app.example.com db.example.com], t.target_hosts
   end
 
@@ -114,31 +113,31 @@ class TestVlad < VladTestCase
     old_env_hosts = ENV["HOSTS"]
     ENV["HOSTS"] = 'other1.example.com,   other2.example.com'
     util_set_hosts
-    t = @vlad.remote_task(:test_task) { 5 }
+    t = @rake.remote_task(:test_task) { 5 }
     assert_equal %w[other1.example.com other2.example.com], t.target_hosts
-  ensure 
+  ensure
     ENV["HOSTS"] = old_env_hosts
   end
 
   def test_remote_task_body_set
     set(:some_variable, 5)
-    @vlad.host 'www.example.com', :app
-    @vlad.remote_task(:some_task) do $some_task_result = some_variable end
+    @rake.host 'www.example.com', :app
+    @rake.remote_task(:some_task) do $some_task_result = some_variable end
 
     Rake::Task['some_task'].execute nil
-    assert_equal @vlad.fetch(:some_variable), $some_task_result
+    assert_equal @rake.fetch(:some_variable), $some_task_result
   end
 
   def test_remote_task_with_options
-    t = @vlad.remote_task :test_task, :roles => [:app, :db] do
+    t = @rake.remote_task :test_task, :roles => [:app, :db] do
       fail "should not run"
     end
     assert_equal({:roles => [:app, :db]}, t.options)
   end
 
   def test_remote_task_before_host_declaration
-    t = @vlad.remote_task :test_task, :roles => :web do 5 end
-    @vlad.host 'www.example.com', :web
+    t = @rake.remote_task :test_task, :roles => :web do 5 end
+    @rake.host 'www.example.com', :web
     assert_equal %w[www.example.com], t.target_hosts
   end
 
@@ -161,30 +160,30 @@ class TestVlad < VladTestCase
 
   def test_set
     set :win, 5
-    assert_equal 5, @vlad.win
+    assert_equal 5, @rake.win
   end
 
   def test_set_lazy_block_evaluation
     set(:lose) { raise "lose" }
-    assert_raises(RuntimeError) { @vlad.lose }
+    assert_raises(RuntimeError) { @rake.lose }
   end
 
   def test_set_with_block
     x = 1
     set(:win) { x += 2 }
 
-    assert_equal 3, @vlad.win
-    assert_equal 3, @vlad.win
+    assert_equal 3, @rake.win
+    assert_equal 3, @rake.win
   end
 
   def test_set_with_reference
-    @vlad.instance_eval do
+    @rake.instance_eval do
       set(:var_one) { var_two }
       set(:var_two) { var_three }
       set(:var_three) { 5 }
     end
 
-    assert_equal 5, @vlad.var_one
+    assert_equal 5, @rake.var_one
   end
 
   def test_set_with_block_and_value
@@ -196,7 +195,7 @@ class TestVlad < VladTestCase
 
   def test_set_with_nil
     set(:win, nil)
-    assert_equal nil, @vlad.win
+    assert_equal nil, @rake.win
   end
 
   def test_set_with_reserved_name

data/test/test_vlad_subversion.rb

@@ -1,8 +1,7 @@
-require 'vlad_test_case'
 require 'vlad'
 require 'vlad/subversion'
 
-class TestVladSubversion < VladTestCase
+class TestVladSubversion < MiniTest::Unit::TestCase
   def setup
     super
     @scm = Vlad::Subversion.new