fezzik 0.8.0.beta2 → 0.8.0.beta3

data/Gemfile

@@ -1,2 +1,2 @@
-source :rubygems
+source "https://rubygems.org"
 gemspec

data/README.md

@@ -5,9 +5,13 @@ This is useful for many tasks, including deployment.
 
 It wraps a rake-based rsync workflow and tries to keep things simple.
 
+If upgrading to 0.8 from an earlier version of Fezzik, see [Upgrading](#upgrading).
+
 ## Install
 
-    gem install fezzik
+```
+gem install fezzik
+```
 
 ## Basic setup
 
@@ -17,27 +21,60 @@ Require Fezzik in your project Rakefile and define a destination:
 require "fezzik"
 
 Fezzik.destination :prod do
-  set :user, "root"
-  set :domain, "myapp.com"
+  Fezzik.set :user, "root"
+  Fezzik.set :domain, "myapp.com"
 end
 ```
 
-Write some rake tasks that will execute on the specified destination:
+A host task is similar to a normal Rake task, but will run once for every host defined by `:domain`. The body
+of a host task exposes two methods:
+
+```
+run <command> Run a shell command on the remote host
+host          The domain that the currently running host task is targeting
+```
+
+Write some host tasks that will execute on the specified destination:
 
 ```ruby
 namespace :fezzik do
-  remote_task :touch do
-    run "touch /tmp/test_file"
+  Fezzik.host_task :echo do
+    run "echo 'Running on #{host}'"
   end
 end
 ```
 
-Run your remote_tasks with fezzik:
+Run your host tasks with fezzik by passing a destination and list of tasks to run:
 
 ```
-$ fez prod touch
+$ fez prod echo
 ```
 
+### host_task
+
+The `host_task` method is similar to Rake's `task` in functionality, but has a slightly different API due to
+its additional options. A host task is defined with a name and three (optional) options: `:args`, `:deps`,
+and `:roles`. `:args` and `:deps` correspond to Rake's task arguments and task dependencies, and `:roles` is a
+Fezzik-specific option explained later.
+
+A Rake task that looks like this:
+
+```ruby
+task :echo, [:arg1, :arg2] => [:dep1, :dep2] do |t, args|
+  ...
+end
+```
+
+would look like this as a host task:
+
+```ruby
+Fezzik.host_task :echo, :args => [:arg1, :arg2],
+                        :deps => [:dep1, :dep2] do |t, args|
+  ...
+end
+```
+
+
 ## Deployments
 
 One of the more useful things you can use Fezzik for is handling deployments.
@@ -48,25 +85,24 @@ require "fezzik"
 # Fezzik will automatically load any .rake files it finds in this directory.
 Fezzik.init(:tasks => "config/tasks")
 
-# Fezzik wraps rake/remote_task, which is the same rake plugin used by Vlad the Deployer.
-# See http://hitsquad.rubyforge.org/vlad/doco/variables_txt.html for a full list of variables it supports.
-
-set :app, "myapp"
-set :deploy_to, "/opt/#{app}"
-set :release_path, "#{deploy_to}/releases/#{Time.now.strftime("%Y%m%d%H%M")}"
-set :local_path, Dir.pwd
-set :user, "root"
+# The only special settings are `:domain` and `:user`. The rest are purely convention. All settings can be
+# retrieved in your tasks with `get` (e.g., `Fezzik.get :current_path`).
+Fezzik.set :app, "myapp"
+Fezzik.set :user, "root"
+Fezzik.set :deploy_to, "/opt/#{app}"
+Fezzik.set :release_path, "#{deploy_to}/releases/#{Time.now.strftime("%Y%m%d%H%M")}"
+Fezzik.set :current_path, "#{deploy_to}/current"
 
 Fezzik.destination :staging do
-  set :domain, "myapp-staging.com"
+  Fezzik.set :domain, "myapp-staging.com"
 end
 
 Fezzik.destination :prod do
-  set :domain, "myapp.com"
+  Fezzik.set :domain, "myapp.com"
 end
 ```
 
-Fezzik comes bundled with some useful rake tasks for common things like deployment.
+Fezzik comes bundled with some useful tasks for common things like deployment.
 You can download the ones you need:
 
 ```
@@ -82,13 +118,13 @@ project.
 namespace :fezzik do
   ...
   desc "runs the executable in project/bin"
-  remote_task :start do
-    puts "starting from #{Fezzik::Util.capture_output { run "readlink #{current_path}" }}"
-    run "cd #{current_path} && ./bin/run_app.sh"
+  host_task :start do
+    puts "starting from #{(run "readlink #{Fezzik.get :current_path}", :output => capture)[:stdout] }}"
+    run "cd #{Fezzik.get :current_path} && ./bin/run_app.sh"
   end
 
   desc "kills the application by searching for the specified process name"
-  remote_task :stop do
+  host_task :stop do
     puts "stopping app"
     run "(kill `ps aux | grep 'myapp' | grep -v grep | awk '{print $2}'` || true)"
   end
@@ -101,7 +137,7 @@ Deploy win!
 ```
 $ fez prod deploy
 ...
-myapp deployed!
+[out|myapp.com] myapp deployed!
 [success]
 ```
 
@@ -111,13 +147,13 @@ Configuration often changes when you deploy your project. Fezzik lets you set en
 
 ```
 $ cd config/tasks
-$ fez get environment
-    [new] environment.rake
+$ fez get deploy
+    [new] deploy.rake
 ```
 
 ```ruby
 Fezzik.destination :prod do
-  set :domain, "myapp.com"
+  Fezzik.set :domain, "myapp.com"
   Fezzik.env :rack_env, "production"
 end
 ```
@@ -128,17 +164,16 @@ project directly.
 
 ```ruby
   desc "runs the executable in project/bin"
-  remote_task :start do
-    puts "starting from #{Fezzik::Util.capture_output { run "readlink #{current_path}" }}"
-    run "cd #{current_path} && (source environment.sh || true) && ./bin/run_app.sh"
+  Fezzik.host_task :start do
+    run "cd #{Fezzik.get :current_path} && (source environment.sh || true) && ./bin/run_app.sh"
   end
 ```
 
-You can assign different environments to a subset of the hosts you deploy to.
+You can assign different environments to subsets of hosts:
 
 ```ruby
 Fezzik.destination :prod do
-  set :domain, ["myapp1.com", "myapp2.com"]
+  Fezzik.set :domain, ["myapp1.com", "myapp2.com"]
   Fezzik.env :rack_env, "production"
   Fezzik.env :is_canary, "true", :hosts => ["myapp1.com"]
 end
@@ -149,37 +184,45 @@ This can be useful if you have common environment variables shared across destin
 
 ```ruby
 Fezzik.destination :staging, :prod do
-  env :unicorn_workers, 4
+  Fezzik.env :unicorn_workers, 4
 end
 ```
 
 You can access the environment settings in your tasks, if you like. It's a hash.
 
 ```ruby
-task :inspect_environment do
+task :inspect_all_environments do
   puts Fezzik.environments.inspect
 end
 ```
 
+To access the environment for the currently targeted host:
+
+```ruby
+Fezzik.host_task :inspect_environment do
+  puts Fezzik.environemnts[host].inspect
+end
+```
+
 
 ## Roles
 
-Fezzik supports role deployments. Roles allow you to assign remote_tasks different configurations according
+Fezzik supports role deployments. Roles allow you to assign host tasks different configurations according
 to their purpose. For example, you might want to perform your initial package installations as root, but run
 your app as an unprivileged user.
 
 ```ruby
 Fezzik.destination :prod do
-  set :domain, "myapp.com"
+  Fezzik.set :domain, "myapp.com"
   Fezzik.role :root_user, :user => "root"
   Fezzik.role :run_user, :user => "app"
 end
 
-remote_task :install, :roles => :root_user
+Fezzik.host_task :install, :roles => :root_user
   # Install all the things.
 end
 
-remote_task :run, :roles => :run_user
+Fezzik.host_task :run, :roles => :run_user
   # Run all the things.
 end
 ```
@@ -188,7 +231,7 @@ Or, you might have different domains for database deployment and app deployment.
 
 ```ruby
 Fezzik.destination :prod do
-  set :user, "root"
+  Fezzik.set :user, "root"
   Fezzik.role :db, :domain => "db.myapp.com"
   Fezzik.role :app, :domain => "myapp.com"
 end
@@ -205,13 +248,13 @@ end
 ```
 
 The `Fezzik.role` method accepts a role name and a hash of values that you want assigned with the
-`set :var, value` syntax. These will override the global or destination settings when that remote_task is
+`set :var, value` syntax. These will override the global or destination settings when a host task is
 run.
 
 
 ## Utilities
 
-Fezzik exposes some functions that can be useful when running remote tasks.
+Fezzik exposes some functions that can be useful when running host tasks.
 
 ### Override hosts from command line
 
@@ -222,33 +265,30 @@ $ domain="example1.com,example2.com" fez prod deploy
 Set the "domain" environment variable to override the domains set in your destination block. Useful for running
 one-off tasks against a subset of your hosts.
 
-### Capture or redirect output
+### Capture or modify output
 
-```ruby
-Fezzik::Util.capture_output(&block)
-```
+The output of `run` can be captured or modified instead of printing directly with the host prefix.
 
-Use this function if you would like to hide or capture the normal output that the "run" command prints.
+It can return a hash of `:stdout, :stderr`, or it can stream the raw output without prefixing each host.
 
 ```ruby
-remote_task :print_hello
-  # Nothing is printed to stdout
-  server_output = Fezzik::Util.capture_output { run "echo 'hello'"}
+# prints "[out|myapp.com] hi"
+run "echo 'hi'"
 
-  # prints "hello"
-  puts server_output
-end
+# prints "hi"
+run "echo 'hi'", :output => :raw
+
+# output == { :stdout => "hi" :stderr => "" }
+output = run "echo 'hi'", :output => :capture
 ```
 
-### Inspect the target destination
+### A note on `puts`
 
-You can see which destination fezzik is operating on from within your tasks.
+Ruby's `puts` is not thread-safe. In particular, running multiple `puts` in parallel can result in the
+newlines being separated from the rest of the string.
 
-```ruby
-task :print_destination
-  puts Fezzik.target_destination
-end
-```
+As a helper, any `puts` used from within a host task will call an overridden thread-safe version of `puts`. If
+`$stdout.puts` or `$stderr.puts` is used instead, the normal thread-unsafe method will be called.
 
 
 ## DSL
@@ -258,6 +298,9 @@ the following functions:
 
 ```
 destination
+host_task
+set
+get
 env
 role
 capture_output
@@ -269,19 +312,24 @@ This lets you write your configuration more tersely:
 include Fezzik::DSL
 
 destination :prod do
+  set :domain "myapp.com"
   env :rack_env, "production"
   role :root_user, :user => "root"
 end
+
+host_task :echo do
+  run "echo 'Running on #{host}'"
+end
 ```
 
 
-## Tasks
+## Included Tasks
 
-Fezzik has a number of useful tasks other than deploy.rake and environment.rake. These can also be downloaded
+Fezzik has a number of useful tasks other than those defined in deploy.rake. These can also be downloaded
 with `$ fez get <task>` and placed in the directory you specify with `Fezzik.init(:tasks => "config/tasks")`.
 
 These tasks are meant to be starting points. For example, if you want to save your environment files in a
-place that's not your project root you can simply edit the task in environment.rake.
+place that's not your project root you can simply edit the task in deploy.rake.
 
 If you write a recipe that would be useful to other developers, please submit a pull request!
 
@@ -318,8 +366,8 @@ $ fez get rollback
     [new] rollback.rake
 ```
 
-Emergency! Rollback! Every deployment you make is saved on the server by default.
-You can move between these deployments (to roll back, for example), with the rollback.rb recipe.
+Emergency! Rollback! Every deployment you make is saved on the server if you use the default tasks defined in
+deploy.rake. You can move between these deployments (to roll back, for example), with rollback.rake.
 
 ```
 $ fez prod rollback
@@ -332,3 +380,47 @@ configuring for root@myapp.com
 Rollback to release (0):
 ```
 
+### Rake passthroughs
+
+Because Fezzik is built on Rake it passes through some options directly to Rake. You can use these with the
+`fez` command as if you were running `rake` directly:
+
+```
+--trace    Turn on invoke/execute tracing, enable full backtrace.
+--dry-run  Do a dry run without executing actions.
+```
+
+<a name="upgrading"></a>
+## Upgrading
+
+### 0.8.0
+
+Fezzik 0.8 replaces much of its internal piping with [Weave](https://github.com/cespare/weave), an excellent
+parallel SSH library. This allows for cleaner output and faster task execution due to using a shared
+connection pool, but necessarily introduces a few breaking changes. These are detailed below.
+
+### Breaking changes
+
+- The method `target_host` is gone and has been replaced by using `host` in a host task. The old method `host`
+  has been replaced with the new one defined in host tasks. There should no longer be a reason to use the old
+  `host` method.
+- The `current_path` setting is no longer set automatically. To continue using it in your deployments, define
+  it manually:
+
+    ```ruby
+    Fezzik.set :current_path, "#{Fezzik.get :deploy_to}/current`.
+    ```
+
+- The helper method `rsync` no longer exists. Instead of `rsync "..."` use `system("rsync -az ...")`
+
+### Deprecations
+
+- The `remote_task` method is deprecated. Use `host_task` instead.
+- Using settings defined by `Fezzik.set` as top-level method calls is deprecated.  Instead of `domain`, use
+  `Fezzik.get :domain` instead.
+- Fezzik::Util.capture_output is deprecated. Pass options directly to `run` instead:
+
+    ```ruby
+    run "echo 'hi'", :output => :capture
+    run "echo 'hi'", :output => :raw
+    ```

data/bin/fez

@@ -7,15 +7,14 @@ require "fezzik"
 module Fezzik
   RAKE_AT_LEAST_090 = defined?(Rake::VERSION) &&
       Gem.loaded_specs["rake"].version >= Gem::Version.create("0.9.0")
-end
 
-# Required for using rake/remote-task with rake >= 0.9.x
-# TODO(caleb): Still necessary w/out RRT?
-include Rake::DSL if Fezzik::RAKE_AT_LEAST_090
+  # Required for using rake/remote-task with rake >= 0.9.x
+  # TODO(caleb): Still necessary w/out RRT?
+  include Rake::DSL if Fezzik::RAKE_AT_LEAST_090
 
-Fezzik.activated = true
+  Fezzik.activated = true
 
-USAGE = <<EOF
+  USAGE = <<EOF
 Version #{Fezzik::VERSION}
 fez <destination> <tasks>  # Run deployment tasks on destination servers
 fez get <tasks>            # Download tasks to use in your project
@@ -26,105 +25,146 @@ fez --task-names           # Print all tasks names
 fez --destinations         # Print all destinations
 EOF
 
-def print_usage_and_exit
-  puts USAGE
-  exit
-end
+  COLORS = { :red => 1, :green => 2 }
+  def self.color_string(string, color)
+    return string unless STDOUT.isatty
+    "\e[01;#{COLORS[color]+30}m#{string}\e[m"
+  end
+  private_class_method :color_string
 
-def print_version_and_exit
-  puts "Version #{Fezzik::VERSION}"
-  exit
-end
+  def self.capture_output(&block)
+    output = StringIO.new
+    $stdout = output
+    block.call
+    output.string
+  ensure
+    $stdout = STDOUT
+  end
+  private_class_method :capture_output
 
-def print_destinations_and_exit
-  Rake.application.init
-  Rake.application.load_rakefile
-  puts Fezzik.destinations.to_a.join("\n")
-  exit 0
-end
+  def self.print_usage_and_exit
+    puts USAGE
+    exit
+  end
+  private_class_method :print_usage_and_exit
 
-def display_tasks_and_exit(hide_descriptions = false)
-  if Fezzik::RAKE_AT_LEAST_090
-    Rake::TaskManager.record_task_metadata = true
-    Rake::application.options.show_tasks = :tasks
+  def self.print_version_and_exit
+    puts "Version #{Fezzik::VERSION}"
+    exit
   end
-  Rake.application.init
-  Rake.application.load_rakefile
-  Rake.application.options.show_task_pattern = /^fezzik:/
-  output = Fezzik::Util.capture_output { Rake.application.display_tasks_and_comments }
-  output.gsub!(/^rake fezzik:/, "fez <destination> ")
-  output.gsub!(/^fez <destination> (\S+).*$/, "\\1") if hide_descriptions
-  output.strip.empty? ? $stderr.puts("(No Fezzik tasks with descriptions are defined.)") : puts(output)
-  exit 0
-end
+  private_class_method :print_version_and_exit
 
-TASKS_URL = "https://raw.github.com/dmacdougall/fezzik/master/tasks"
-def download_tasks_and_exit
-  OPTIONS[1..-1].each do |task|
-    task += ".rake" unless task =~ /\.rake$/
-    system("curl -f #{TASKS_URL}/#{task} -o #{task} > /dev/null 2>&1")
-    if $? == 0
-      puts Fezzik.color_string("    [new]", :green) + "  #{task}"
-    else
-      puts Fezzik.color_string("    [fail]", :red) + " #{task}"
-    end
+  def self.print_destinations_and_exit
+    Rake.application.init
+    Rake.application.load_rakefile
+    puts Fezzik.destinations.to_a.join("\n")
+    exit 0
   end
-  exit 0
-end
+  private_class_method :print_destinations_and_exit
 
-def run_fezzik_tasks
-  ENV["fezzik_destination"] = OPTIONS[0]
-  Fezzik.init
-  Rake.application.init
-  Rake.application.load_rakefile
-  set :domain, ENV["domain"].split(",") if ENV["domain"]
-  begin
-    host_list = Array(domain).join("\n    ")
-    puts "Targeting hosts:"
-    puts "    #{host_list}"
-  rescue NameError => e
-    puts "Invalid destination: #{Fezzik.target_destination}"
-    puts "Make sure this destination is configured and includes `set :domain, \"yourdomain.com\"`"
-    puts Fezzik.color_string("[fail]", :red)
-    exit 1
+  def self.display_tasks_and_exit(hide_descriptions = false)
+    if Fezzik::RAKE_AT_LEAST_090
+      Rake::TaskManager.record_task_metadata = true
+      Rake::application.options.show_tasks = :tasks
+    end
+    Rake.application.init
+    Rake.application.load_rakefile
+    Rake.application.options.show_task_pattern = /^fezzik:/
+    output = capture_output { Rake.application.display_tasks_and_comments }
+    output.gsub!(/^rake fezzik:/, "fez <destination> ")
+    output.gsub!(/^fez <destination> (\S+).*$/, "\\1") if hide_descriptions
+    output.strip.empty? ? $stderr.puts("(No Fezzik tasks with descriptions are defined.)") : puts(output)
+    exit 0
   end
-  begin
-    tasks = OPTIONS[1..-1]
-    tasks.each do |task_with_params|
-      task_name, params = Fezzik::Util.split_task_and_params(task_with_params)
-      Rake::Task["fezzik:#{task_name}"].invoke(*params)
+  private_class_method :display_tasks_and_exit
+
+  TASKS_URL = "https://raw.github.com/dmacdougall/fezzik/master/tasks"
+  def self.download_tasks_and_exit
+    OPTIONS[1..-1].each do |task|
+      task += ".rake" unless task =~ /\.rake$/
+      system("curl -f #{TASKS_URL}/#{task} -o #{task} > /dev/null 2>&1")
+      if $? == 0
+        puts color_string("    [new]", :green) + "  #{task}"
+      else
+        puts color_string("    [fail]", :red) + " #{task}"
+      end
     end
-    puts Fezzik.color_string("[success]", :green)
-  rescue SystemExit => e
-    if e.status == 0
-      puts Fezzik.color_string("[success]", :green)
+    exit 0
+  end
+  private_class_method :download_tasks_and_exit
+
+  def self.split_task_and_params(task_with_params)
+    params_match = /(.+)\[(.+)\]/.match(task_with_params)
+    if params_match
+      task = params_match[1]
+      params = params_match[2].split(",")
     else
-      puts Fezzik.color_string("[fail]", :red)
-      exit e.status
+      task = task_with_params
+      params = nil
     end
-  rescue StandardError => e
-    puts e.message
-    puts e.backtrace
-    puts Fezzik.color_string("[fail]", :red)
-    fail
+    [task, params]
   end
-end
+  private_class_method :split_task_and_params
+
+  def self.run_fezzik_tasks
+    ENV["fezzik_destination"] = OPTIONS[0]
+    Fezzik.init
+    Rake.application.init
+    Rake.application.load_rakefile
+    set :domain, ENV["domain"].split(",") if ENV["domain"]
+    begin
+      host_list = Array(get :domain).join("\n    ")
+      puts "Targeting hosts:"
+      puts "    #{host_list}"
+    rescue NameError => e
+      puts "Invalid destination: #{Fezzik.target_destination}"
+      puts "Make sure this destination is configured and includes `set :domain, \"yourdomain.com\"`"
+      puts color_string("[fail]", :red)
+      exit 1
+    end
+    begin
+      tasks = OPTIONS[1..-1]
+      tasks.each do |task_with_params|
+        task_name, params = split_task_and_params(task_with_params)
+        Rake::Task["fezzik:#{task_name}"].invoke(*params)
+      end
+      puts color_string("[success]", :green)
+    rescue SystemExit => e
+      if e.status == 0
+        puts color_string("[success]", :green)
+      else
+        puts color_string("[fail]", :red)
+        exit e.status
+      end
+    rescue StandardError => e
+      puts e.message
+      puts e.backtrace
+      puts color_string("[fail]", :red)
+      exit 1
+    end
+  end
+  private_class_method :run_fezzik_tasks
+
+  OPTIONS = ARGV.dup
+  # Rake directly inspects ARGV and will crash if it doesn't recognize a flag that was passed to fez.
+  ARGV.clear
+  # Pass these options through to Rake.
+  # TODO: Pass full trace options through (e.g., --trace=STDOUT)
+  ARGV << "--trace" if OPTIONS.delete("--trace")
+  ARGV << "--dry-run" if OPTIONS.delete("--dry-run")
 
-# Rake directly inspects ARGV and will crash if it doesn't recognize a flag that was passed to fez.
-OPTIONS = ARGV.dup
-ARGV.clear
-
-# Pass these options through to Rake.
-ARGV << "--trace" if OPTIONS.delete("--trace")
-ARGV << "--dry-run" if OPTIONS.delete("--dry-run")
-
-case OPTIONS[0]
-when nil then abort USAGE
-when "-h", "--help" then print_usage_and_exit
-when "-v", "--version" then print_version_and_exit
-when "-T", "--tasks" then display_tasks_and_exit
-when "get" then download_tasks_and_exit
-when "--task-names" then display_tasks_and_exit(hide_descriptions = true)
-when "--destinations" then print_destinations_and_exit
-else run_fezzik_tasks
+  def self.main
+    case OPTIONS[0]
+    when nil then abort USAGE
+    when "-h", "--help" then print_usage_and_exit
+    when "-v", "--version" then print_version_and_exit
+    when "-T", "--tasks" then display_tasks_and_exit
+    when "get" then download_tasks_and_exit
+    when "--task-names" then display_tasks_and_exit(hide_descriptions = true)
+    when "--destinations" then print_destinations_and_exit
+    else run_fezzik_tasks
+    end
+  end
 end
+
+Fezzik.main()

data/example/Gemfile

@@ -1,3 +1,3 @@
-source :rubygems
+source "https://rubygems.org"
 gem "fezzik", :path => ".."
 gem "rake"

data/example/Rakefile

@@ -1,12 +1,13 @@
 require "fezzik"
 include Fezzik::DSL
+include Rake::DSL
 
 Fezzik.init(:tasks => "../tasks")
 
 set :app, "test"
-set :deploy_to, "/opt/#{app}"
-set :release_path, "#{deploy_to}/releases/#{Time.now.strftime("%Y%m%d%H%M")}"
-set :local_path, Dir.pwd
+set :deploy_to, "/opt/#{get :app}"
+set :release_path, "#{get :deploy_to}/releases/#{Time.now.strftime("%Y%m%d%H%M")}"
+set :current_path, "#{get :deploy_to}/current"
 set :user, "root"
 
 destination :vagrant do
@@ -24,44 +25,44 @@ end
 
 namespace :fezzik do
   desc "Print information on the destination and environment"
-  remote_task :info do
+  host_task :info do
     puts "Destination: #{Fezzik.target_destination.inspect}"
     puts "Environment: #{Fezzik.environments.inspect}"
   end
 
   desc "An example of appending..."
-  remote_task :append do
+  host_task :append do
     run "echo hi"
   end
 
   desc "...new actions to an existing task"
-  remote_task :append do
+  host_task :append do
     run "echo bye"
   end
 
   desc "Tasks can take arguments"
-  remote_task :args, :arg1, :arg2 do |t, args|
+  host_task :argtest, :args => [:arg1, :arg2] do |t, args|
     puts "args: #{args.inspect}"
   end
 
   desc "Tasks may print out the host and user."
-  remote_task :host do
+  host_task :host do
     puts "#{user}@#{host}"
   end
 
   desc "Tasks can depend on other tasks"
-  remote_task :deps => :append do
+  host_task :depstest, :deps => :append do
     puts "some other task just ran"
   end
 
   desc "If a server command fails the block should exist and fezzik should indicate failure"
-  remote_task :fails do
+  host_task :fails do
     run "cd i-dont-exist"
     run "echo 'should not print'"
   end
 
   desc "Use roles to override settings"
-  remote_task :roles, :roles => [:role1, :role2] do
+  host_task :roles, :roles => [:role1, :role2] do
     puts "role_var: #{get :role_var}"
   end
 end

data/example/run_app.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+yes &> /dev/null &
+echo $! > /tmp/app.pid

data/lib/fezzik.rb

@@ -6,7 +6,6 @@ require "set"
 
 require "fezzik/host_task"
 require "fezzik/base"
-require "fezzik/colors"
 require "fezzik/dsl"
 require "fezzik/environment"
 require "fezzik/role"

data/lib/fezzik/base.rb

@@ -14,7 +14,8 @@ module Fezzik
     end
 
     Object.send :define_method, name do
-      # TODO: Add deprecation note for setting/accessing global settings
+      warn "WARN [Fezzik]: accessing #{name} at the top-level is deprecated as of 0.8.0," +
+           " use Fezzik.get(:#{name}) instead"
       Fezzik.get name
     end
   end
@@ -24,11 +25,10 @@ module Fezzik
     @@settings[name]
   end
 
-  # TODO(caleb): Private method?
   def self.clear(name) @@settings.delete(name) end
 
-  # TODO: add deprecation warning for remote_task
   def self.remote_task(*args, &block)
+    warn "WARN [Fezzik]: remote_task is deprecated as of 0.8.0, use host_task instead"
     roles = (Hash === args.last && args.last[:roles]) ? args.pop[:roles] : []
     name, args, deps = Rake.application.resolve_args(args)
     host_task(name, { :args => Array(args), :deps => Array(deps), :roles => Array(roles) }, &block)
@@ -50,7 +50,9 @@ module Fezzik
     @target_destination = ENV["fezzik_destination"].to_sym rescue nil
     unless options[:tasks].nil?
       $stderr.puts "Loading Fezzik tasks from #{@options[:tasks]}"
-      Dir[File.join(File.expand_path(@options[:tasks]), "**", "*.rake")].sort.each { |lib| import lib }
+      Dir[File.join(File.expand_path(@options[:tasks]), "**", "*.rake")].sort.each do |lib|
+        Rake.application.add_import(lib)
+      end
     end
   end
 

data/lib/fezzik/role.rb

@@ -30,4 +30,5 @@ module Fezzik
     to_clear.each { |setting| Fezzik.clear setting }
     to_set.each { |setting, value| Fezzik.set setting, value }
   end
+  private_class_method :override_settings
 end

data/lib/fezzik/util.rb

@@ -1,24 +1,14 @@
 module Fezzik
   module Util
     def self.capture_output(&block)
+      warn "WARN [Fezzik]: Fezzik::Util.capture_output is deprecated as of 0.8.0," +
+           " use `run \"...\", :output => capture` instead"
       output = StringIO.new
-      Thread.current[:stdout] = output
+      $stdout = output
       block.call
       output.string
     ensure
-      Thread.current[:stdout] = STDOUT
-    end
-
-    def self.split_task_and_params(task_with_params)
-      params_match = /(.+)\[(.+)\]/.match(task_with_params)
-      if params_match
-        task = params_match[1]
-        params = params_match[2].split(",")
-      else
-        task = task_with_params
-        params = nil
-      end
-      [task, params]
+      $stdout = STDOUT
     end
   end
 end

data/lib/fezzik/version.rb

@@ -1,3 +1,3 @@
 module Fezzik
-  VERSION = "0.8.0.beta2"
+  VERSION = "0.8.0.beta3"
 end

data/tasks/command.rake

@@ -31,6 +31,8 @@ namespace :fezzik do
   end
 
   desc "run a single command on destination servers"
-  remote_task(:command_execute, :command) { |t, args| run args[:command], :continue_on_failure => true }
+  host_task(:command_execute, :args => :command) do |t, args|
+    run args[:command], :continue_on_failure => true
+  end
 end
 

data/tasks/deploy.rake

@@ -1,60 +1,79 @@
 require "fileutils"
+require "fezzik"
+
+include Fezzik::DSL
 
 namespace :fezzik do
+  desc "writes environment files on the server"
+  host_task :write_environment do
+    puts "writing environment files"
+    environment = Fezzik.environments[host]
+    staging_path = "/tmp/#{get :app}/environments/#{host}"
+    FileUtils.mkdir_p staging_path
+    File.open("#{staging_path}/environment.rb", "w") do |f|
+      environment.each do |key, value|
+        quote = value.is_a?(Numeric) ? '' : '"'
+        f.puts "#{key.to_s.upcase} = #{quote}#{value}#{quote}"
+      end
+    end
+    File.open("#{staging_path}/environment.sh", "w") do |f|
+      environment.each { |key, value| f.puts %[export #{key.to_s.upcase}="#{value}"] }
+    end
+    system "rsync -az #{staging_path}/environment.* #{user}@#{host}:#{get :release_path}"
+  end
+
   desc "stages the project for deployment in /tmp"
   task :stage do
-    puts "staging project in /tmp/#{app}"
-    FileUtils.rm_rf "/tmp/#{app}"
-    FileUtils.mkdir_p "/tmp/#{app}/staged"
+    puts "staging project in /tmp/#{get :app}"
+    FileUtils.rm_rf "/tmp/#{get :app}"
+    FileUtils.mkdir_p "/tmp/#{get :app}/staged"
     # Use rsync to preserve executability and follow symlinks.
-    system("rsync -aqE #{local_path}/. /tmp/#{app}/staged")
+    system("rsync -aqE ./ /tmp/#{get :app}/staged")
   end
 
   desc "performs any necessary setup on the destination servers prior to deployment"
-  remote_task :setup do
+  host_task :setup do
     puts "setting up servers"
-    run "mkdir -p #{deploy_to}/releases"
+    run "mkdir -p #{get :deploy_to}/releases"
   end
 
   desc "rsyncs the project from its staging location to each destination server"
-  remote_task :push => [:stage, :setup] do
-    puts "pushing to #{target_host}:#{release_path}"
+  host_task :push, :deps => [:stage, :setup] do
+    puts "pushing to #{user}@#{host}:#{get :release_path}"
     # Copy on top of previous release to optimize rsync
-    rsync "-q", "--copy-dest=#{current_path}", "/tmp/#{app}/staged/", "#{target_host}:#{release_path}"
+    system "rsync -azq --copy-dest=#{get :current_path} /tmp/#{get :app}/staged/" +
+           " #{user}@#{host}:#{get :release_path}"
   end
 
   desc "symlinks the latest deployment to /deploy_path/project/current"
-  remote_task :symlink do
-    puts "symlinking current to #{release_path}"
-    run "cd #{deploy_to} && ln -fns #{release_path} current"
+  host_task :symlink do
+    puts "symlinking current to #{get :release_path}"
+    run "cd #{get :deploy_to} && ln -fns #{get :release_path} current"
   end
 
   desc "runs the executable in project/bin"
-  remote_task :start do
-    puts "starting from #{Fezzik::Util.capture_output { run "readlink #{current_path}" }}"
-    run "cd #{current_path} && (source environment.sh || true) && ./bin/run_app.sh"
+  host_task :start do
+    # A very simple run_app.sh might contain the following:
+    #     #!/bin/sh
+    #
+    #     yes &> /dev/null &
+    #     echo $! > /tmp/app.pid
+    puts "starting from #{(run "readlink #{get :current_path}", :output => :capture)[:stdout] }"
+    run "cd #{get :current_path} && source environment.sh && ./run_app.sh"
   end
 
   desc "kills the application by searching for the specified process name"
-  remote_task :stop do
-    # Replace YOUR_APP_NAME with whatever is run from your bin/run_app.sh file.
-    # If you'd like to do this nicer you can save the PID of your process with `echo $! > app.pid`
-    # in the start task and read the PID to kill here in the stop task.
-    # puts "stopping app"
-    # run "(kill -9 `ps aux | grep 'YOUR_APP_NAME' | grep -v grep | awk '{print $2}'` || true)"
+  host_task :stop do
+    puts "stopping app"
+    run "cd #{get :current_path} && touch /tmp/app.pid && kill `cat /tmp/app.pid` || true && rm /tmp/app.pid"
   end
 
   desc "restarts the application"
-  remote_task :restart do
-    Rake::Task["fezzik:stop"].invoke
-    Rake::Task["fezzik:start"].invoke
+  host_task :restart, :deps => [:stop, :start] do
   end
 
   desc "full deployment pipeline"
-  task :deploy do
-    Rake::Task["fezzik:push"].invoke
-    Rake::Task["fezzik:symlink"].invoke
-    Rake::Task["fezzik:restart"].invoke
-    puts "#{app} deployed!"
+  task :deploy => [:push, :write_environment, :symlink, :restart] do
+    puts "#{get :app} deployed!"
   end
 end

data/tasks/rollback.rake

@@ -8,12 +8,14 @@
 namespace :fezzik do
   desc "interactively roll back deployment"
   task :rollback do
-    target_domain = domain.is_a?(Array) ? domain.first : domain
-    releases = `ssh #{target_domain} "cd #{File.dirname(release_path)} && ls"`.split(/\s+/).reverse
-    current_release = File.basename(`ssh #{target_domain} "cd #{deploy_to} && readlink current"`).strip
+    target_domain = Array(get :domain).first
+    releases = `ssh #{target_domain} "cd #{File.dirname(get :release_path)} && ls"`.split(/\s+/).reverse
+    current_release = File.basename(`ssh #{target_domain} "cd #{get :deploy_to} && readlink current"`).strip
     puts "=== Releases ==="
     puts "0: Abort"
-    releases.each_index { |i| puts "#{i+1}: #{releases[i]} #{releases[i] == current_release ? "(current)" : ""}" }
+    releases.each_index do |i|
+      puts "#{i+1}: #{releases[i]} #{releases[i] == current_release ? "(current)" : ""}"
+    end
     print "Rollback to release (0): "
     STDOUT.flush
     release_num = STDIN.gets.chomp.to_i
@@ -29,10 +31,10 @@ namespace :fezzik do
 
   desc "rolls back deployment to the previous release"
   task :rollback_one do
-    target_domain = domain.is_a?(Array) ? domain.first : domain
-    current_release = File.basename(`ssh #{target_domain} "cd #{deploy_to} && readlink current"`).strip
+    target_domain = Array(get :domain).first
+    current_release = File.basename(`ssh #{target_domain} "cd #{get :deploy_to} && readlink current"`).strip
     previous_release = %x{
-        ssh #{target_domain} "cd #{File.dirname(release_path)} && ls | grep "#{current_release}" -B 1 | head -1"
+ssh #{target_domain} "cd #{File.dirname(get :release_path)} && ls | grep "#{current_release}" -B 1 | head -1"
     }.strip
 
     if previous_release == current_release
@@ -44,10 +46,10 @@ namespace :fezzik do
   end
 
   desc "rolls back deployment to a specific release"
-  remote_task :rollback_to_release, :selected_release do |t, args|
+  host_task :rollback_to_release, :args => :selected_release do |t, args|
     selected_release = args[:selected_release]
-    puts "rolling #{target_host} back to #{selected_release}"
-    run "cd #{deploy_to} && ln -fns #{File.dirname(release_path)}/#{selected_release} current"
+    puts "rolling #{host} back to #{selected_release}"
+    run "cd #{get :deploy_to} && ln -fns #{File.dirname(get :release_path)}/#{selected_release} current"
     Rake::Task["fezzik:restart"].invoke
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fezzik
 version: !ruby/object:Gem::Version
-  version: 0.8.0.beta2
+  version: 0.8.0.beta3
   prerelease: 6
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-22 00:00:00.000000000 Z
+date: 2013-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -93,10 +93,10 @@ files:
 - completions/_fez.zsh
 - example/Gemfile
 - example/Rakefile
+- example/run_app.sh
 - fezzik.gemspec
 - lib/fezzik.rb
 - lib/fezzik/base.rb
-- lib/fezzik/colors.rb
 - lib/fezzik/dsl.rb
 - lib/fezzik/environment.rb
 - lib/fezzik/host_task.rb
@@ -105,12 +105,10 @@ files:
 - lib/fezzik/version.rb
 - tasks/command.rake
 - tasks/deploy.rake
-- tasks/environment.rake
 - tasks/rollback.rake
 - test/integration/base_test.rb
 - test/integration/environment_test.rb
 - test/integration_test_helper.rb
-- weave_todo.md
 homepage: http://github.com/dmacdougall/fezzik
 licenses: []
 post_install_message: 
@@ -123,6 +121,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2670329324762576840
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -138,4 +139,3 @@ summary: Fezzik adds remote ssh capabilities to Rake. It simplifies running comm
   on remote servers and can be used for anything from deploying code to installing
   libraries remotely.
 test_files: []
-has_rdoc: 

data/lib/fezzik/colors.rb

@@ -1,7 +0,0 @@
-module Fezzik
-  COLORS = { :red => 1, :green => 2 }
-  def self.color_string(string, color)
-    return string unless STDOUT.isatty
-    "\e[01;#{COLORS[color]+30}m#{string}\e[m"
-  end
-end

data/tasks/environment.rake

@@ -1,45 +0,0 @@
-require "fileutils"
-
-# Any variables set in deploy.rb with `Fezzik.env` will be saved on the server in two files:
-# environment.sh and environment.rb. The first can be loaded into the shell environment before the run script
-# is called, and the second is made available to be required into your code. You can use your own
-# environment.rb file for development and it will be overwritten by this task when the code deploys.
-namespace :fezzik do
-  desc "saves variables set by `Fezzik.env` into a local staging area before deployment"
-  task :save_environment do
-    Fezzik.environments.each do |server, environment|
-      root_config_dir = "/tmp/#{app}/#{server}_config"
-      FileUtils.mkdir_p root_config_dir
-      File.open(File.join(root_config_dir, "environment.rb"), "w") do |file|
-        environment.each do |key, value|
-          quote = value.is_a?(Numeric) ? '' : '"'
-          file.puts "#{key.to_s.upcase} = #{quote}#{value}#{quote}"
-        end
-      end
-      File.open(File.join(root_config_dir, "environment.sh"), "w") do |file|
-        environment.each { |key, value| file.puts %[export #{key.to_s.upcase}="#{value}"] }
-      end
-    end
-  end
-
-  # Append to existing actions defined in deploy.rake. This works because we import .rake files alphabetically,
-  # so the tasks defined in deploy.rake will be executed before these defined in environment.rake.
-  # TODO: Can these be handled through dependencies?
-  # task :stage => :save_environment
-  # task :push => :push_config
-  task :stage do
-    Rake::Task["fezzik:save_environment"].invoke
-  end
-
-  task :push do
-    # Copy over the appropriate configs for the target
-    server = target_host.gsub(/^.*@/, "")
-    config_directory = "/tmp/#{app}/#{server}_config"
-    if File.directory?(config_directory)
-      ["environment.rb", "environment.sh"].each do |config_file|
-        rsync "-q", "#{config_directory}/#{config_file}",
-              "#{target_host}:#{release_path}/#{config_file}"
-      end
-    end
-  end
-end

data/weave_todo.md

@@ -1,21 +0,0 @@
-## Breaking changes in the weave branch
-
-* `target_host` is gone
-* `host` is now an alias for `target_host`, not a method
-* `rsync` no longer exists (unless we write a new helper function)
-
-## Other docs to write
-
-* Call `warn` for deprecation notices
-* document --trace and --dry-run passthrough flags
-* puts is not thread-safe; instead, use print "" + "\n" (NOTE: Caleb -- this isn't actually true; the `puts`
-  you get in a `remote_task` is a Weave wrapper, which is thread-safe. However, if you use `STDERR.puts` or
-  `STDOUT.puts` or `print` or anything else, it's not going to be threadsafe. This may be worth pointing out
-  in the docs.)
-* capture_output captures the host prefix on each line. Instead pass :capture => :output to `run`.
-  You can also use capture_output and pass :capture => raw
-* We no longer provide `current_path`, which is a RRT-ism. However, this was kind of a convention anyway --
-  RRT sets it to "current" and we generally leave that alone. In fact, if you look at the default deploy task
-  (https://github.com/dmacdougall/fezzik/blob/master/tasks/deploy.rake) you'll see that we use `current_path`
-  in some places and the string "current" in others. The new convention should just be `set :current_path,
-  "#{get :deploy_to}/current"` and then use `current_path` as a normal setting.