fezzik 0.7.4 → 0.8.0.beta1

data/bin/fez

@@ -4,8 +4,14 @@ require "rubygems"
 require "rake"
 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
-include Rake::DSL
+# TODO(caleb): Still necessary w/out RRT?
+include Rake::DSL if Fezzik::RAKE_AT_LEAST_090
 
 Fezzik.activated = true
 
@@ -13,7 +19,11 @@ USAGE = <<EOF
 Version #{Fezzik::VERSION}
 fez <destination> <tasks>  # Run deployment tasks on destination servers
 fez get <tasks>            # Download tasks to use in your project
-fez -T                     # Display all tasks
+fez -v, --version          # Print version number
+fez -h, --help             # Print this help message
+fez -T                     # Print all tasks with descriptions
+fez --task-names           # Print all tasks names
+fez --destinations         # Print all destinations
 EOF
 
 def print_usage_and_exit
@@ -26,19 +36,31 @@ def print_version_and_exit
   exit
 end
 
-def display_tasks_and_exit
+def print_destinations_and_exit
+  Rake.application.init
+  Rake.application.load_rakefile
+  puts Fezzik.destinations.to_a.join("\n")
+  exit 0
+end
+
+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
+  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> ")
-  puts output.strip.empty? ? "(No Fezzik tasks with descriptions are defined.)" : output
+  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
 
 TASKS_URL = "https://raw.github.com/dmacdougall/fezzik/master/tasks"
 def download_tasks_and_exit
-  ARGV[1..-1].each do |task|
+  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
@@ -51,7 +73,7 @@ def download_tasks_and_exit
 end
 
 def run_fezzik_tasks
-  ENV["fezzik_destination"] = ARGV[0]
+  ENV["fezzik_destination"] = OPTIONS[0]
   Fezzik.init
   Rake.application.init
   Rake.application.load_rakefile
@@ -60,20 +82,27 @@ def run_fezzik_tasks
     host_list = Array(domain).join("\n    ")
     puts "Targeting hosts:"
     puts "    #{host_list}"
-  rescue Rake::ConfigurationError => e
+  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
   end
   begin
-    tasks = ARGV[1..-1]
+    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)
+      Rake::Task["fezzik:#{task_name}"].invoke(*params)
     end
     puts Fezzik.color_string("[success]", :green)
-  rescue SystemExit, Rake::CommandFailedError => e
+  rescue SystemExit => e
+    if e.status == 0
+      puts Fezzik.color_string("[success]", :green)
+    else
+      puts Fezzik.color_string("[fail]", :red)
+      exit e.status
+    end
+  rescue Fezzik::CommandFailedError => e
     puts Fezzik.color_string("[fail]", :red)
     exit 1
   rescue StandardError => e
@@ -84,11 +113,21 @@ def run_fezzik_tasks
   end
 end
 
-case ARGV[0]
+# 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
 end

data/completions/_fez.bash

@@ -0,0 +1,14 @@
+_fez()
+{
+  local cur prev completion
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  prev="${COMP_WORDS[COMP_CWORD-1]}"
+  if [ $prev == "fez" ]; then
+    completion="--destinations"
+  else
+    completion="--task-names"
+  fi
+  COMPREPLY=( $(compgen -W "$(fez ${completion} 2> /dev/null | GREP_OPTIONS='' grep -v '(in')" -- ${cur}) )
+  return 0
+}
+complete -F _fez fez

data/completions/_fez.zsh

@@ -0,0 +1,7 @@
+#compdef fez
+
+if [[ "${words[-2]}" == "fez" ]] ; then
+  compadd $(fez --destinations 2> /dev/null | GREP_OPTIONS='' grep -v '(in')
+else
+  compadd $(fez --task-names 2> /dev/null | GREP_OPTIONS='' grep -v '(in')
+fi

data/example/Gemfile

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

data/example/Rakefile

@@ -0,0 +1,67 @@
+require "fezzik"
+include Fezzik::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 :user, "root"
+
+destination :vagrant do
+  set :user, "vagrant"
+  set :domain, "fezzik-vagrant"
+
+  env :foo, "bar"
+  env :baz, "baz"
+  env :baz, "qux", :hosts => "localhost"
+
+  set :role_var, nil
+  role :role1, :role_var => "apple"
+  role :role2, :role_var => "banana"
+end
+
+namespace :fezzik do
+  desc "Print information on the destination and environment"
+  remote_task :info do
+    puts "Destination: #{Fezzik.target_destination.inspect}"
+    puts "Environment: #{Fezzik.environments.inspect}"
+  end
+
+  desc "An example of appending..."
+  remote_task :append do
+    run "echo hi"
+  end
+
+  desc "...new actions to an existing task"
+  remote_task :append do
+    run "echo bye"
+  end
+
+  desc "Tasks can take arguments"
+  remote_task :args, :arg1, :arg2 do |t, args|
+    puts "args: #{args.inspect}"
+  end
+
+  desc "Tasks may print out the host and user."
+  remote_task :host do
+    puts "#{user}@#{host}"
+  end
+
+  desc "Tasks can depend on other tasks"
+  remote_task :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
+    run "cd i-dont-exist"
+    run "echo 'should not print'"
+  end
+
+  desc "Use roles to override settings"
+  remote_task :roles, :roles => [:role1, :role2] do
+    puts "role_var: #{get :role_var}"
+  end
+end

data/fezzik.gemspec

@@ -13,15 +13,18 @@ Gem::Specification.new do |s|
   s.email = "dmacdougall@gmail.com"
 
   s.description = "A light deployment system that gets out of your way"
-  s.summary = "Fezzik is a small wrapper around rake/remote_task. It simplifies running commands on" +
-      "remote servers and can be used for anything from deploying code to installing libraries remotely."
+  s.summary =<<EOS
+Fezzik adds remote ssh capabilities to Rake. It simplifies running commands on remote servers and can be used
+for anything from deploying code to installing libraries remotely.
+EOS
   s.homepage = "http://github.com/dmacdougall/fezzik"
   s.rubyforge_project = "fezzik"
 
   s.executables = %w(fez)
   s.files = `git ls-files`.split("\n")
 
-  s.add_dependency("rake-remote_task", "~>2.0.2")
+  s.add_dependency "rake"
+  s.add_dependency "weave", "=0.1.0"
 
   s.add_development_dependency("scope", "~>0.2.3")
   s.add_development_dependency("vagrant", "~>1.0.5")

data/lib/fezzik.rb

@@ -1,13 +1,14 @@
 require "stringio"
 require "thread"
 require "rake"
-require "rake/remote_task"
+require "weave"
+require "set"
+
+require "fezzik/host_task"
 require "fezzik/base"
 require "fezzik/colors"
 require "fezzik/dsl"
 require "fezzik/environment"
 require "fezzik/role"
-require "fezzik/io"
-require "fezzik/thread_local_io"
 require "fezzik/util"
 require "fezzik/version"

data/lib/fezzik/base.rb

@@ -2,20 +2,66 @@ module Fezzik
   def self.activated=(value) @activated = value end
   def self.activated?() @activated || false end
 
+  def self.set(name, value)
+    @@settings ||= {}
+
+    value = Array(value) if name == :domain
+
+    @@settings[name] = value
+
+    if Object.public_instance_methods.include? name.to_sym
+      Object.send :alias_method, :"old_#{name}", name
+    end
+
+    Object.send :define_method, name do
+      # TODO: Add deprecation note for setting/accessing global settings
+      Fezzik.get name
+    end
+  end
+
+  def self.get(name)
+    raise "Fezzik: No such setting: #{name}" unless @@settings.has_key?(name)
+    @@settings[name]
+  end
+
+  def self.remote_task(*args, &block)
+    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)
+  end
+
+  def self.host_task(name, options = {}, &block)
+    options = {
+      :args => [],
+      :deps => [],
+      :roles => []
+    }.merge(options)
+    t = HostTask.define_task(name, { options[:args] => options[:deps] }, &block)
+    t.roles += options[:roles]
+  end
+
   def self.init(options={})
     @options = options
     @target_destination = ENV["fezzik_destination"].to_sym rescue nil
     unless options[:tasks].nil?
-      puts "Loading Fezzik tasks from #{@options[:tasks]}"
-      Dir[File.join(Dir.pwd, "#{@options[:tasks]}/**/*.rake")].sort.each { |lib| import lib }
+      $stderr.puts "Loading Fezzik tasks from #{@options[:tasks]}"
+      Dir[File.join(File.expand_path(@options[:tasks]), "**", "*.rake")].sort.each { |lib| import lib }
     end
   end
 
   def self.destination(*names, &block)
+    @destinations ||= Set.new
+    @destinations.merge(names)
     block.call if names.include?(@target_destination)
   end
 
   def self.target_destination
     @target_destination ||= nil
   end
+
+  def self.destinations
+    @destinations ||= Set.new
+  end
+
+  class CommandFailedError < StandardError; end
 end

data/lib/fezzik/dsl.rb

@@ -1,13 +1,12 @@
 module Fezzik
   module DSL
-    # This is necessary to override Rake::RemoteTask's globally eval'ed method definitions.
-    def self.included(klass)
-      klass.class_eval do
-        def role(*args) Fezzik.role(*args) end
-      end
-    end
     def destination(*names, &block) Fezzik.destination(*names, &block) end
     def env(*args) Fezzik.env(*args) end
     def capture_output(&block) Fezzik::Util.capture_output(&block) end
+    def set(name, value) Fezzik.set(name, value) end
+    def get(name) Fezzik.get(name) end
+    def remote_task(*args, &block) Fezzik.remote_task(*args, &block) end
+    def host_task(name, options = {}, &block) Fezzik.host_task(name, options, &block) end
+    def role(*args) Fezzik.role(*args) end
   end
 end

data/lib/fezzik/environment.rb

@@ -1,7 +1,7 @@
 module Fezzik
   def self.env(key, value, options={})
     options = {
-      :hosts => Array(domain).map { |domain| domain.gsub(/^.*@/, "") } # strip user off the front
+      :hosts => Fezzik.get(:domain)
     }.merge(options)
     options[:hosts] = Array(options[:hosts])
     @environments ||= Hash.new { |h, k| h[k] = {} }

data/lib/fezzik/host_task.rb

@@ -0,0 +1,49 @@
+module Fezzik
+  class HostTask < Rake::Task
+    attr_accessor :roles
+
+    def initialize(task_name, app)
+      super
+      @roles = []
+      @host_actions = []
+    end
+
+    def enhance(deps = nil, &block)
+      @host_actions << block if block_given?
+      super(deps)
+    end
+
+    def execute(args = nil)
+      return if Rake.application.options.dryrun
+
+      if @roles.empty?
+        hosts = Fezzik.get(:domain).map { |domain| "#{Fezzik.get(:user)}@#{domain}" }
+        @@connection_pool ||= Weave.connect(hosts)
+        @host_actions.each do |action|
+          begin
+            @@connection_pool.execute(:args => [self, args], &action)
+          rescue Weave::Error => e
+            STDERR.puts "Error running command in HostTask '#{@name}':"
+            abort e.message
+          end
+        end
+      else
+        @roles.each do |role|
+          Fezzik.with_role(role) do
+            hosts = Fezzik.get(:domain).map { |domain| "#{Fezzik.get(:user)}@#{domain}" }
+            @@role_connection_pools ||= {}
+            @@role_connection_pools[role] ||= Weave.connect(hosts)
+            @host_actions.each do |action|
+              begin
+                @@role_connection_pools[role].execute(:args => [self, args], &action)
+              rescue Weave::Error => e
+                STDERR.puts "Error running command in HostTask '#{@name}' with role '#{role}':"
+                abort e.message
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fezzik/role.rb

@@ -6,6 +6,8 @@ module Fezzik
 
   def self.roles() @roles ||= {} end
 
+  # TODO: Consider allowing roles that don't override an existing setting.
+  # Right now you have to do: set :foo nil; role :foo_role {:foo => :bar}
   def self.with_role(role_name, &block)
     return block.call if roles[role_name].nil?
 
@@ -19,21 +21,6 @@ module Fezzik
   end
 
   def self.override_settings(settings)
-    settings.each { |setting, value| self.send(:set, setting, value) }
-  end
-end
-
-module Rake
-  class RemoteTask
-    def defined_target_hosts?() true end
-    def target_hosts() domain end
-
-    alias remote_task_execute execute
-    def execute(args = nil)
-      return Fezzik::Util.with_prepended_user { remote_task_execute(args) } if options[:roles].empty?
-      options[:roles].each do |role|
-        Fezzik.with_role(role) { Fezzik::Util.with_prepended_user { remote_task_execute(args) } }
-      end
-    end
+    settings.each { |setting, value| Fezzik.set setting, value }
   end
 end

data/lib/fezzik/util.rb

@@ -20,21 +20,5 @@ module Fezzik
       end
       [task, params]
     end
-
-    # Blocks passed to this function will ensure `domain` is always an Array. In addition, if `user` is set it
-    # will automatically prepend the value of `user` to the front of any domains missing a username. This allows a
-    # fezzik user to write the following in their configuration and have it "just work":
-    #     set :domain, ["example.com", "test@example2.com"]
-    #     set :user, "root"
-    # `domain` will be equal to ["root@example.com", "test@example2.com"]
-    def self.with_prepended_user(&block)
-      old_domain = domain
-      begin
-        set :domain, Array(domain).map { |d| (defined?(user) && !d.include?("@")) ? "#{user}@#{d}" : d }
-        block.call
-      ensure
-        set :domain, old_domain
-      end
-    end
   end
 end

data/lib/fezzik/version.rb

@@ -1,3 +1,3 @@
 module Fezzik
-  VERSION = "0.7.4"
+  VERSION = "0.8.0.beta1"
 end

data/tasks/command.rake

@@ -23,7 +23,9 @@ namespace :fezzik do
       else
         begin
           Rake::Task["fezzik:command_execute"].invoke command
-        rescue Rake::CommandFailedError
+        rescue Fezzik::CommandFailedError => e
+          puts e.message
+          puts e.backtrace
         ensure
           Rake::Task["fezzik:command_execute"].reenable
         end

data/tasks/environment.rake

@@ -34,9 +34,12 @@ namespace :fezzik do
   task :push do
     # Copy over the appropriate configs for the target
     server = target_host.gsub(/^.*@/, "")
-    ["environment.rb", "environment.sh"].each do |config_file|
-      rsync "-q", "/tmp/#{app}/#{server}_config/#{config_file}",
-            "#{target_host}:#{release_path}/#{config_file}"
+    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

@@ -0,0 +1,13 @@
+## 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"
+* 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

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: fezzik
 version: !ruby/object:Gem::Version
-  version: 0.7.4
-  prerelease: 
+  version: 0.8.0.beta1
+  prerelease: 6
 platform: ruby
 authors:
 - Daniel MacDougall
@@ -10,24 +10,40 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-29 00:00:00.000000000 Z
+date: 2013-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rake-remote_task
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: weave
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: scope
   requirement: !ruby/object:Gem::Requirement
@@ -73,15 +89,18 @@ files:
 - Rakefile
 - Vagrantfile
 - bin/fez
+- completions/_fez.bash
+- completions/_fez.zsh
+- example/Gemfile
+- example/Rakefile
 - fezzik.gemspec
 - lib/fezzik.rb
 - lib/fezzik/base.rb
 - lib/fezzik/colors.rb
 - lib/fezzik/dsl.rb
 - lib/fezzik/environment.rb
-- lib/fezzik/io.rb
+- lib/fezzik/host_task.rb
 - lib/fezzik/role.rb
-- lib/fezzik/thread_local_io.rb
 - lib/fezzik/util.rb
 - lib/fezzik/version.rb
 - tasks/command.rake
@@ -91,6 +110,7 @@ files:
 - 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: 
@@ -103,9 +123,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 3198673685344171649
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -117,7 +134,7 @@ rubyforge_project: fezzik
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 2
-summary: Fezzik is a small wrapper around rake/remote_task. It simplifies running
-  commands onremote servers and can be used for anything from deploying code to installing
+summary: Fezzik adds remote ssh capabilities to Rake. It simplifies running commands
+  on remote servers and can be used for anything from deploying code to installing
   libraries remotely.
 test_files: []

data/lib/fezzik/io.rb

@@ -1,11 +0,0 @@
-# Synchronize 'puts' because it's annoying to have interleaved output when rake remote task is running
-# several things at once in multiple threads (for instance: commands on multiple servers or commands as
-# multiple users).
-#
-# TODO(dmac): Is this made obsolete by thread_local_io.rb?
-class IO
-  @@print_mutex = Mutex.new
-  alias :old_puts :puts
-  def puts(*args) @@print_mutex.synchronize { old_puts(*args) } end
-end
-

data/lib/fezzik/thread_local_io.rb

@@ -1,47 +0,0 @@
-# Overrides $stdout and allows it to be overridden by the thread-local variable Thread.current[:stdout].
-#
-# If Thread.current[:stdout] is set, the thread will write all output there. Otherwise the thread will
-# use $stdout as normal.
-#
-# Example usage:
-#
-# out = StringIO.new
-#
-# Thread.start do
-#   Thread.current[:stdout] = out
-#   puts "thread1"
-# end.join
-#
-# Thread.start do
-#   puts "thread2"
-# end.join
-#
-# puts out.string
-#
-# Output:
-#   thread2
-#   thread1
-
-module Fezzik
-  class ThreadLocalIO < IO
-    @@former_stdout = $stdout
-
-    def self.write(*args)
-      if Thread.current[:stdout]
-        Thread.current[:stdout].write(*args)
-      else
-        @@former_stdout.write(*args)
-      end
-    end
-
-    def self.flush
-      if Thread.current[:stdout]
-        Thread.current[:stdout].flush
-      else
-        @@former_stdout.flush
-      end
-    end
-  end
-end
-
-$stdout = Fezzik::ThreadLocalIO