yad 0.0.4

data/lib/yad/scm/git.rb

@@ -0,0 +1,62 @@
+module Yad
+  module Scm
+    class Git
+      def self.build_checkout_command(repository, destination_directory, options = {})
+        default_options = { :revision => 'origin/master', :enable_submodules => true }
+        options = default_options.merge(options)
+
+        commands = ["([ -d #{destination_directory}/cached-copy/.git ] && echo 'Existing repository found' || git clone #{repository} #{destination_directory}/cached-copy)",
+                    "cd #{destination_directory}/cached-copy",
+                    "git fetch",
+                    "git reset --hard #{options[:revision]}"
+                   ]
+
+        if options[:enable_submodules]
+          commands << [ "git submodule -q init",
+                        "git submodule -q update"
+                      ]
+        end
+        commands.join(" && ")
+      end
+
+      def self.build_export_command(source_directory, destination_directory)
+        "mkdir -p #{destination_directory} && rsync -a -f '- .git' #{source_directory}/cached-copy/ #{destination_directory}"
+      end
+      
+      def self.build_inline_revision_identifier_command(scm_directory, options = {})
+        default_options = { :revision => 'origin/master' }
+        options = default_options.merge(options)
+        "`cd #{scm_directory}/cached-copy && git rev-parse #{options[:revision]}`"
+      end
+
+      def self.define_tasks
+        return if @tasks_already_defined
+        @tasks_already_defined = true
+        namespace :yad do
+          namespace :scm do
+            
+            desc "Updates the source code on the application servers and exports it as the latest release"
+            remote_task :update, :roles => :app do
+              begin
+                options = Rake::RemoteTask.get_options_hash(:revision, :enable_submodules)
+                checkout_command = Yad::Scm::Git.build_checkout_command(repository, scm_path, options)
+                export_command = Yad::Scm::Git.build_export_command(scm_path, release_path)
+                cmd = Yad::Core.build_update_source_code_command(checkout_command, export_command, release_path)
+                run(cmd)
+                puts("source code updated on #{target_host}")
+              rescue => e
+                cmd = Yad::Core.build_remove_directory_command(release_path)
+                run(cmd)
+                raise e
+              end
+            end
+            
+          end
+        end
+
+      end
+      
+    end # class Git
+    
+  end # module Scm
+end # module Yad

data/lib/yad/web/apache.rb

@@ -0,0 +1,62 @@
+module Yad
+  module Web
+    class Apache
+      def self.build_start_command(options = {})
+        default_options = { :apache_command => 'apachectl' }
+        options = default_options.merge(options)
+        "#{options[:apache_command]} start"
+      end
+
+      def self.build_stop_command(options = {})
+        default_options = { :apache_command => 'apachectl' }
+        options = default_options.merge(options)
+        "#{options[:apache_command]} stop"
+      end
+
+      def self.build_restart_command(options = {})
+        default_options = { :apache_command => 'apachectl' }
+        options = default_options.merge(options)
+        "#{options[:apache_command]} restart"
+      end
+      
+      def self.define_tasks
+        return if @tasks_already_defined
+        @tasks_already_defined = true
+        namespace :yad do
+          namespace :web do
+            
+            desc "Starts the web server"
+            remote_task :start, :roles => :web do
+              options = Rake::RemoteTask.get_options_hash(:apache_command)
+              cmd = Yad::Web::Apache.build_start_command(options)
+              use_sudo_for_apache = Rake::RemoteTask.fetch(:use_sudo_for_apache, true)
+              if use_sudo_for_apache
+                sudo(cmd)
+              else
+                run(cmd)
+              end
+              puts("Apache started on #{target_host}")
+            end
+
+            desc "Stops the web server"
+            remote_task :stop, :roles => :web do
+              options = Rake::RemoteTask.get_options_hash(:apache_command)
+              cmd = Yad::Web::Apache.build_stop_command(options)
+              use_sudo_for_apache = Rake::RemoteTask.fetch(:use_sudo_for_apache, true)
+              if use_sudo_for_apache
+                sudo(cmd)
+              else
+                run(cmd)
+              end
+              puts("Apache stopped on #{target_host}")
+            end
+            
+          end
+        end
+
+      end
+      
+    end # class Apache
+    
+  end # module Web
+end # module Yad

data/spec/ext/rake/remote_task_spec.rb

@@ -0,0 +1,394 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'spec_helper')
+
+describe Rake::RemoteTask do
+  def create_example_task(options = {})
+    task = Rake::RemoteTask.remote_task(:test_task, options)
+    task.commands = []
+    task.output = []
+    task.error = []
+    task.action = nil
+    task
+  end
+
+  def capture_output
+    require 'stringio'
+    orig_stdout = $stdout.dup
+    orig_stderr = $stderr.dup
+    captured_stdout = StringIO.new
+    captured_stderr = StringIO.new
+    $stdout = captured_stdout
+    $stderr = captured_stderr
+    yield
+    captured_stdout.rewind
+    captured_stderr.rewind
+    return captured_stdout, captured_stderr
+  ensure
+    $stdout = orig_stdout
+    $stderr = orig_stderr
+  end
+
+  it "should list all remote hosts" do
+    set_example_hosts
+    Rake::RemoteTask.all_hosts.should eql(%w[app.example.com db.example.com])
+  end
+
+  it "should fetch variables that have been set" do
+    set :foo, 5
+    Rake::RemoteTask.fetch(:foo).should eql(5)
+  end
+
+  it "should fetch the given default when a variable is not set" do
+    Rake::RemoteTask.fetch(:not_here, 5).should eql(5)
+  end
+
+  it "should assign multiple roles to one remote host" do
+    Rake::RemoteTask.host "test.example.com", :app, :db
+    Rake::RemoteTask.roles[:app].should == { "test.example.com" => {} }
+    Rake::RemoteTask.roles[:db].should == { "test.example.com" => {} }
+  end
+
+  it "should error when the host name is invalid" do
+    lambda { Rake::RemoteTask.host nil, :web }.should raise_error(ArgumentError)
+  end
+
+  it "should assign multiple roles to multiple remote hosts" do
+    Rake::RemoteTask.host "test.example.com", :app, :db
+    Rake::RemoteTask.host "yarr.example.com", :app, :db, :no_release => true
+ 
+    expected = {
+      "test.example.com" => {},
+      "yarr.example.com" => {:no_release => true}
+    }
+    
+    Rake::RemoteTask.roles[:app].should == expected
+    Rake::RemoteTask.roles[:db].should == expected
+    Rake::RemoteTask.roles[:app]["test.example.com"].object_id.should_not eql(Rake::RemoteTask.roles[:db]["test.example.com"].object_id)
+  end
+
+  it "should get remote hosts for an array of roles" do
+    set_example_hosts
+    Rake::RemoteTask.hosts_for([:app, :db]).should eql(%w[app.example.com db.example.com])
+  end
+
+  it "should get remote hosts for one role" do
+    set_example_hosts
+    Rake::RemoteTask.host "app2.example.com", :app
+    Rake::RemoteTask.hosts_for(:app).should eql(%w[app.example.com app2.example.com])
+  end
+
+  it "should get remote hosts for multiple roles" do
+    set_example_hosts
+    Rake::RemoteTask.hosts_for(:app, :db).should eql(%w[app.example.com db.example.com])
+  end
+
+  it "should get a unique list of remote hosts for given roles" do
+    set_example_hosts
+    Rake::RemoteTask.host "app.example.com", :web
+    Rake::RemoteTask.hosts_for(:app, :db, :web).should eql(%w[app.example.com db.example.com])
+  end
+
+  it "should not set defaults for required configuration variables" do
+    Rake::RemoteTask.set_defaults
+    lambda { Rake::RemoteTask.repository }.should raise_error(Rake::RemoteTask::ConfigurationError)
+    lambda { Rake::RemoteTask.deploy_to }.should raise_error(Rake::RemoteTask::ConfigurationError)
+    lambda { Rake::RemoteTask.domain }.should raise_error(Rake::RemoteTask::ConfigurationError)
+  end
+
+  it "should assign a role for one remote host" do
+    Rake::RemoteTask.role :app, "test.example.com"
+    Rake::RemoteTask.roles[:app].should == { "test.example.com" => {} }
+  end
+  
+  it "should assign a role for multiple remote hosts" do
+    Rake::RemoteTask.role :app, "test.example.com", :primary => true
+    Rake::RemoteTask.role :db, "yarr.example.com", :no_release => true
+    Rake::RemoteTask.roles[:db].should == { "yarr.example.com" => { :no_release => true } }
+    Rake::RemoteTask.roles[:app].should == { "test.example.com" => { :primary => true } }
+  end
+
+  it "should increase the number of tasks when created" do
+    task = Rake::RemoteTask.remote_task(:test_task) { 5 }
+    Rake.application.tasks.size.should eql(@task_count + 1)
+  end
+
+  it "should assign an empty set of roles if none are supplied" do
+    task = Rake::RemoteTask.remote_task(:test_task) { 5 }
+    task.options.should == { :roles => [] }
+  end
+
+  it "should assign all remote hosts to a task by default" do
+    set_example_hosts
+    task = Rake::RemoteTask.remote_task(:test_task) { 5 }
+    task.target_hosts.should eql(%w[app.example.com db.example.com])
+  end
+
+  it "should override hosts from environment" do
+    old_env_hosts = ENV["HOSTS"]
+    ENV["HOSTS"] = 'other1.example.com,   other2.example.com'
+    set_example_hosts
+    task = Rake::RemoteTask.remote_task(:test_task) { 5 }
+    task.target_hosts.should eql(%w[other1.example.com other2.example.com])
+    ENV["HOSTS"] = old_env_hosts
+  end
+
+  it "should have access set variables within task body" do
+    set(:some_variable, 5)
+    Rake::RemoteTask.host 'www.example.com', :app
+    Rake::RemoteTask.remote_task(:some_task) do $some_task_result = some_variable end
+    Rake::Task['some_task'].execute nil
+    Rake::RemoteTask.fetch(:some_variable).should eql($some_task_result)
+  end
+
+  it "should assign roles when creating a task" do
+    task = Rake::RemoteTask.remote_task :test_task, :roles => [:app, :db] do
+      fail "should not run"
+    end
+    task.options.should == { :roles => [:app, :db] }
+  end
+
+  it "should allow hosts to be assigned to a role after a task for a role has been created" do
+    task = Rake::RemoteTask.remote_task :test_task, :roles => :web do 5 end
+    Rake::RemoteTask.host 'www.example.com', :web
+    task.target_hosts.should eql(%w[www.example.com])
+  end
+
+  it "should allow for roles to be overridden" do
+    host "db1", :db
+    host "db2", :db
+    host "db3", :db
+    host "master", :master_db
+ 
+    remote_task(:migrate_the_db, :roles => [:db]) { fail "bad!" }
+    task = Rake::Task["migrate_the_db"]
+    task.target_hosts.should eql(%w[db1 db2 db3])
+ 
+    task.options[:roles] = :master_db
+    task.target_hosts.should eql(%w[master])
+ 
+    task.options[:roles] = [:master_db]
+    task.target_hosts.should eql(%w[master])
+  end
+
+  it "should set variables" do
+    set :test, 5
+    Rake::RemoteTask.test.should eql(5)
+  end
+
+  it "should do lazy evaluation of set blocks" do
+    set(:test) { fail "lose" }
+    lambda { Rake::RemoteTask.test }.should raise_error(RuntimeError)
+  end
+
+  it "should evaluate a set block the first time" do
+    x = 1
+    set(:test) { x += 2 }
+    Rake::RemoteTask.test.should eql(3)
+    Rake::RemoteTask.test.should eql(3)
+  end
+
+  it "should have access to set variables within set blocks" do
+    Rake::RemoteTask.instance_eval do
+      set(:var_one) { var_two }
+      set(:var_two) { var_three }
+      set(:var_three) { 5 }
+    end
+    
+    Rake::RemoteTask.var_one.should eql(5)
+  end
+
+  it "should error when a value and a block is supplied with set" do
+    lambda { set(:test, 5) { 6 } }.should raise_error(ArgumentError, "cannot provide both a value and a block")
+  end
+
+  it "should allow a variable to be set to nil" do
+    set(:test, nil)
+    Rake::RemoteTask.test.should be_nil
+  end
+
+  it "should not allow variables with reserved names to be set" do
+    $TESTING = false
+    lambda { set(:all_hosts, []) }.should raise_error(ArgumentError, "cannot set reserved name: 'all_hosts'")
+    $TESTING = true
+  end
+  
+  it "should allow a variable to be set to false" do
+    set(:can_set_nil, nil)
+    set(:lies_are, false)
+
+    Rake::RemoteTask.can_set_nil.should be_nil
+    Rake::RemoteTask.lies_are.should be_false
+  end
+
+  it "should fetch false as a default for a variable" do
+    Rake::RemoteTask.fetch(:unknown, false).should be_false
+  end
+  
+  it "should be enhanced with prerequisites and actions when it has been created with a body" do
+    set_example_hosts
+    body = Proc.new { 5 }
+    task = Rake::RemoteTask.remote_task(:some_task => :foo, &body)
+    action = Rake::RemoteTask::Action.new(task, body)
+    task.remote_actions.should == [action]
+    action.task.should eql(task)
+    task.prerequisites.should eql(["foo"])
+  end
+
+  it "should not be enhanced with prerequisites or actions when it has been created without a body" do
+    set_example_hosts
+    task = create_example_task
+    task.remote_actions.should be_empty
+    task.prerequisites.should be_empty
+  end
+
+  it "should execute on all remote hosts when no role is given" do
+    set_example_hosts
+    set :some_variable, 1
+    x = 5
+    task = Rake::RemoteTask.remote_task(:some_task) { x += some_variable }
+    task.execute nil
+    task.some_variable.should eql(1)
+    x.should eql(7)
+  end
+  
+  it "should allow variables to be set inside of the body" do
+    host "app.example.com", :app
+    task = Rake::RemoteTask.remote_task(:target_task) { set(:test_target_host, target_host) }
+    task.execute nil
+    Rake::RemoteTask.fetch(:test_target_host).should eql("app.example.com")
+  end
+
+  it "should not excute with no remote hosts set" do
+    Rake::RemoteTask.host "app.example.com", :app
+    task = Rake::RemoteTask.remote_task(:flunk, :roles => :db) { fail "should not have run" }
+    lambda { task.execute nil }.should raise_error(Rake::RemoteTask::ConfigurationError,
+                                                   "No target hosts specified on task flunk for roles [:db]")
+  end
+
+  it "should not execute with no remote hosts for a given role" do
+    task = Rake::RemoteTask.remote_task(:flunk, :roles => :junk) { fail "should not have run" }
+    lambda { task.execute nil }.should raise_error(Rake::RemoteTask::ConfigurationError,
+                                                   "No target hosts specified on task flunk for roles [:junk]")
+  end
+
+  it "should execute on remote hosts with a given role" do
+    set_example_hosts
+    set :some_variable, 1
+    x = 5
+    task = Rake::RemoteTask.remote_task(:some_task, :roles => :db) { x += some_variable }
+    task.execute nil
+    task.some_variable.should eql(1)
+    x.should eql(6)
+  end
+
+  it "should build rsync commands" do
+    task = create_example_task
+    task.rsync 'localfile', 'app.example.com:remotefile'
+    task.commands.size.should eql(1)
+    task.commands.first.should eql(%w[rsync -azP --delete localfile app.example.com:remotefile])
+  end
+
+  it "should error when an rsync command fails" do
+    task = create_example_task
+    task.action = lambda { false }
+    lambda { task.rsync 'local', 'app.example.com:remote' }.should raise_error(Rake::RemoteTask::CommandFailedError,
+                                                                              "execution failed: rsync -azP --delete local app.example.com:remote")
+  end
+  
+  it "should build get commands" do
+    task = create_example_task
+    task.target_host = 'app.example.com'
+    lambda { task.get('tmp', 'remote1', 'remote2') }.should_not raise_error
+    task.commands.size.should eql(1)
+    task.commands.first.should eql(%w[rsync -azP --delete app.example.com:remote1 app.example.com:remote2 tmp])
+  end
+    
+  it "should build put commands" do
+    task = create_example_task
+    task.target_host = 'app.example.com'
+    lambda { task.put('dest') { 'whatever' } }.should_not raise_error
+    task.commands.size.should eql(1)
+    task.commands.first[3] = 'some_temp_file_name'
+    task.commands.first.should eql( %w[rsync -azP --delete some_temp_file_name app.example.com:dest])
+  end
+
+  it "should run remote commands" do
+    task = create_example_task
+    task.output << "file1\nfile2\n"
+    task.target_host = "app.example.com"
+    result = nil
+ 
+    out, err = capture_output do
+      result = task.run("ls")
+    end
+ 
+    task.commands.size.should eql(1)
+    task.commands.first.should eql(["ssh", "app.example.com", "ls"])
+
+    result.should eql("file1\nfile2\n")
+    out.read.should eql("file1\nfile2\n")
+    err.read.should eql('')
+  end
+
+  it "should error when a remote command fails" do
+    set_example_hosts
+    task = create_example_task
+    task.input = StringIO.new "file1\nfile2\n"
+    task.target_host =  'app.example.com'
+    task.action = lambda { 1 }
+    lambda { task.run("ls") }.should raise_error(Rake::RemoteTask::CommandFailedError,
+                                                 "execution failed with status 1: ssh app.example.com ls")
+    task.commands.size.should eql(1)
+  end
+  
+  it "should build remote sudo commands" do
+    task = create_example_task
+    task.target_host = "app.example.com"
+    task.sudo "ls" 
+    task.commands.size.should eql(1)
+    task.commands.first.should eql(["ssh", "app.example.com", "sudo -p Password: ls"])
+  end
+  
+  it "should run remote sudo commands" do
+    task = create_example_task
+    task.output << "file1\nfile2\n"
+    task.error << 'Password:'
+    task.target_host = "app.example.com"
+    def task.sudo_password() "my password" end # gets defined by set
+    result = nil
+ 
+    out, err = capture_output do
+      result = task.run("sudo ls")
+    end
+    
+    task.commands.size.should eql(1)
+    task.commands.first.should eql(['ssh', 'app.example.com', 'sudo ls'])
+    task.input.string.should eql("my password\n")
+ 
+    # WARN: Technically incorrect, the password line should be
+    # first... this is an artifact of changes to the IO code in run
+    # and the fact that we have a very simplistic (non-blocking)
+    # testing model.
+    result.should eql("file1\nfile2\nPassword:\n")
+    out.read.should eql("file1\nfile2\n")
+    err.read.should eql("Password:\n")
+  end
+
+  it "should get an options hash for a single option" do
+    set :my_option, 10
+    options = Rake::RemoteTask.get_options_hash(:my_option)
+    options.should ==({ :my_option => 10 })
+  end
+
+  it "should get an options hash for multiple options" do
+    set :my_option, 10
+    set :my_other_option, 'my other option value'
+    options = Rake::RemoteTask.get_options_hash(:my_option, :my_other_option)
+    options.should ==({ :my_option => 10, :my_other_option => 'my other option value' })
+  end
+  
+  it "should an empty options hash for an undefined option" do
+    options = Rake::RemoteTask.get_options_hash(:my_undefined_option)
+    options.should ==({})
+  end
+  
+end