blower 3.4 → 4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e2038dcb8532a933ded5b0e986f5c219a4d5749b
-  data.tar.gz: cf04e56b0a72200cfeceefeecbd4b2688e0f8b17
+  metadata.gz: 347f6e63c590bd170c7e942416850924fd0a10f9
+  data.tar.gz: 8389ddabdcc2e0bb4144806433b82b9a0a1f3eb0
 SHA512:
-  metadata.gz: 1de9c6423f7b5e3692c46b49ea69801a080ff8c770a49d5add4b447c1cee61fdb8a49f35ee1357651dd07ba524d8795898bc37a3c1b44fac33c5ed523569991d
-  data.tar.gz: a4bd0455c23e6ae2024d92e02f8ca958a139f1c2965b5f5dc8c66135ff72b23abdae682f0a113ee4c6c7f30e4fb265853c53b10e72c32dfa73cc3c721c9f88c5
+  metadata.gz: 5dfd5196f69a28330ab5b560c3c2a94379b3c6aabedabe81e17aacfd27ffec190bd62bedd33aaa0969f379f61a6c34324fac39903b52465aa43970e9be3ceb39
+  data.tar.gz: 9e0c0317df8fecb554f59a088d5d298ee4025678434f0feea924cb66d81f9f94b34b0c6775ba3371e4b29e2aa8e404af24b38a58059d1891c512fc5ac2d6d10a

data/bin/blow

@@ -3,7 +3,7 @@ require 'blower'
 require 'pathname'
 require 'optparse'
 
-$LOGLEVEL = :info
+path = []
 
 OptionParser.new do |opts|
   opts.banner = "Usage: blow [options] task..."
@@ -11,18 +11,27 @@ OptionParser.new do |opts|
     Dir.chdir v
   end
   opts.on "-l LEVEL", "Minimal log level" do |v|
-    $LOGLEVEL = v.downcase.to_sym
+    Blower::Logger.level = v.downcase.to_sym
   end
   opts.on "-I DIR", "Add directory to search path" do |v|
-    $LOGLEVEL = v.downcase.to_sym
+    path << v
   end
   opts.on "-v", "Show version and exit" do |v|
-    puts Blower::VERSION
+    puts "blow (blower) #{Blower::VERSION}"
     exit
   end
 end.order!
 
-context = Blower::Context.new([".", Dir.pwd])
+$: << File.join(Dir.pwd, "lib")
+
+path.unshift Dir.pwd
+
+context = Blower::Context.new(path)
+
+if File.directory?(File.join(Dir.pwd, "lib"))
+  context.path << File.join(Dir.pwd, "lib")
+end
+
 context.run "Blowfile", optional: true
 begin
   until ARGV.empty?

data/lib/blower.rb

@@ -1,4 +1,11 @@
+
+# Top-level module for all things blower.
+module Blower
+end
+
+require 'blower/util'
 require 'blower/logger'
+require 'blower/errors'
 require 'blower/context'
 require 'blower/host'
 require 'blower/version'

data/lib/blower/context.rb

@@ -1,251 +1,306 @@
 require 'erb'
+require 'json'
 require 'forwardable'
 
 module Blower
 
   # Blower tasks are executed within a context.
   #
-  # The context can be used to share information between tasks, by storing it in instance variables.
+  # The context can be used to share information between tasks by storing it in instance variables.
   #
   class Context
     extend Forwardable
 
+    # YARD documentation macros
+
+    # @macro [new] onable
+    #   @param [Array] on The hosts to operate on. Defaults to the context's current host list.
+
+    # @macro [new] asable
+    #   @param [#to_s] as The remote user to operate as. Defaults to the context's current user if that is not nil, and the host's configured user otherwise.
+
+    # @macro [new] quietable
+    #   @param [Boolean] quiet Whether to suppress log messages.
+
+    # @macro [new] onceable
+    #   @param [String] once If non-nil, only perform the operation if it hasn't been done before as per #once.
+
     # Search path for tasks.
     attr_accessor :path
 
-    # The currently running task.
-    attr_accessor :task
-
     # The target hosts.
     attr_accessor :hosts
 
+    # Username override. If not-nil, this user is used for all remote accesses.
+    attr_accessor :user
+
+    # The file name of the currently running task.
+    # Context#cp interprets relative file names relative to this file name's directory component.
+    attr_accessor :file
+
+    # Create a new Context.
+    # @param [Array] path The search path for tasks.
     def initialize (path)
       @path = path
-      @hosts = []
-      @have_seen = {}
       @data = {}
-      @basename = "blow"
+      @hosts = []
     end
 
-    def set (hash, &block)
-      if block
-        begin
-          old_data, @data = @data, @data.dup
-          set(hash)
-          block.()
-        ensure
-          @data = old_data
-        end
-      else
-        @data.merge! hash
-        hash.each do |var, val|
-          define_singleton_method(var) { @data[var] }
-        end
-      end
+    # Return a context variable.
+    # @param name The name of the variable.
+    # @param default The value to return if the variable is not set.
+    def get (name, default = nil)
+      @data.fetch(name, default)
     end
 
-    def get (var)
-      @data[var]
+    # Remove context variables
+    # @param names The names to remove from the variables.
+    def unset (*names)
+      names.each do |name|
+        @data.delete name
+      end
     end
 
-    def log
-      Logger.instance
+    # Merge the hash into the context variables.
+    # @param [Hash] hash The values to merge into the context variables.
+    def set (hash)
+      @data.merge! hash
     end
 
-    def add_host (spec)
-      host = Host.new(*spec) unless spec.is_a?(Host)
-      @hosts << host
-      host
+    # Yield with the hash temporary merged into the context variables.
+    # Only variables specifically named in +hash+ will be reset when the yield returns.
+    # @param [Hash] hash The values to merge into the context variables.
+    # @return Whatever the yielded-to block returns.
+    # @macro quietable
+    def with (hash, quiet: false)
+      old_values = data.values_at(hash.keys)
+      log.debug "with #{hash}", quiet: quiet do
+        set hash
+        yield
+      end
+    ensure
+      hash.keys.each.with_index do |key, i|
+        @data[key] = old_values[i]
+      end
     end
 
-    # Execute the block once for each host and return nil.
-    def each (hosts = @hosts, &block)
-      Kernel.fail "No hosts left" if hosts.empty?
-      hosts.each(&block)
+    # Yield with a temporary host list
+    # @macro quietable
+    def on (*hosts, quiet: false)
+      let :@hosts => hosts.flatten do
+        log.info "on #{@hosts.map(&:name).join(", ")}", quiet: quiet do
+          yield
+        end
+      end
     end
 
-    # Execute the block once for each host and return nil.
-    def with (hosts = @hosts, &block)
-      ctx = clone
-      ctx.hosts = hosts.map do |spec|
-        spec.is_a?(Host) ? spec : Host.new(*spec)
+    # Yield with a temporary username override
+    # @macro quietable
+    def as (user, quiet: false)
+      let :@user => user do
+        log.info "as #{user}", quiet: quiet do
+          yield
+        end
       end
-      ctx.instance_exec(&block)
     end
 
-    def with_each (hosts = @hosts, &block)
-      each do |host|
-        with host, &block
+    # Find and execute a task. For each entry in the search path, it checks for +path/task.rb+, +path/task/blow.rb+,
+    # and finally for bare +path/task+. The search stops at the first match.
+    # If found, the task is executed within the context, with +@file+ bound to the task's file name.
+    # @param [String] task The name of the task.
+    # @macro quietable
+    # @macro onceable
+    # @raise [TaskNotFound] If no task is found.
+    # @raise Whatever the task itself raises.
+    # @return The result of evaluating the task file.
+    def run (task, optional: false, quiet: false, once: nil)
+      once once, quiet: quiet do
+        log.info "run #{task}", quiet: quiet do
+          file = find_task(task)
+          code = File.read(file)
+          let :@file => file do
+            instance_eval(code, file)
+          end
+        end
       end
+    rescue TaskNotFound => e
+      return if optional
+      raise e
     end
 
-    # Execute the block once for each host and return a hash of the results.
-    def hashmap (hosts = @hosts, &block)
-      result = {}
-      threads = []
-      log.nest do
-        each hosts do |host|
-          threads << Thread.new do
-            result[host] = block.(host)
+    # Execute a shell command on each host
+    # @macro onable
+    # @macro asable
+    # @macro quietable
+    # @macro onceable
+    def sh (command, as: user, on: hosts, quiet: false, once: nil)
+      self.once once, quiet: quiet do
+        log.info "sh #{command}", quiet: quiet do
+          hash_map(hosts) do |host|
+            host.sh command, as: as, quiet: quiet
           end
         end
-        threads.each(&:join)
       end
-      result
     end
 
-    # Reboot each host and waits for them to come back up.
-    # @param command The reboot command. A string.
-    def reboot (command = "reboot")
-      if f = get(:sh_command)
-        command = f.(command)
-      end
-      each do |host|
-        log.info "rebooting: #{host.name}"
-        begin
-          host.sh command, user: @user
-        rescue IOError
-        end
-        log.debug "rebooting: #{host.name}: waiting for shutdown..."
-        sleep 0.1 while host.ping
-      end
-      each do |host|
-        log.debug "rebooting: #{host.name}: waiting for return..."
-        sleep 1.0 until host.ping
-      end
-    end
-
-    # Execute a shell command on each host.
-    def sh (command, quiet: false)
-      log.info "sh: #{command}" unless quiet
-      if f = get(:sh_command)
-        command = f.(command)
-      end
-      win = true
-      hashmap do |host|
-        out = ""
-        status = host.sh(command, out, user: @user)
-        if status != 0
-          fail host, "#{command}: exit status #{status}"
-          nil
-        else
-          out
+    # Copy a file or readable to the host filesystems.
+    # @overload cp(readable, to, as: user, on: hosts, quiet: false)
+    #   @param [#read] from An object from which to read the contents of the new file.
+    #   @param [String] to The file name to write the string to.
+    #   @macro onable
+    #   @macro asable
+    #   @macro quietable
+    #   @macro onceable
+    # @overload cp(filename, to, as: user, on: hosts, quiet: false)
+    #   @param [String] from The name of the local file to copy.
+    #   @param [String] to The file name to write the string to.
+    #   @macro onable
+    #   @macro asable
+    #   @macro quietable
+    #   @macro onceable
+    def cp (from, to, as: user, on: hosts, quiet: false, once: nil)
+      self.once once, quiet: quiet do
+        log.info "cp: #{from} -> #{to}", quiet: quiet do
+          Dir.chdir File.dirname(file) do
+            hash_map(hosts) do |host|
+              host.cp from, to, as: as, quiet: quiet
+            end
+          end
         end
       end
     end
 
-    # Execute a command on the remote host.
-    # @return false if the command exits with a non-zero status
-    def sh? (command, quiet: false)
-      log.info "sh?: #{command}" unless quiet
-      if f = get(:sh_command)
-        command = f.(command)
-      end
-      hashmap do |host|
-        host.sh(command, user: @user) == 0
+    # Reads a remote file from each host.
+    # @param [String] filename The file to read.
+    # @return [Hash] A hash of +Host+ objects to +Strings+ of the file contents.
+    # @macro onable
+    # @macro asable
+    # @macro quietable
+    def read (filename, as: user, on: hosts, quiet: false)
+      log.info "read: #{filename}", quiet: quiet do
+        hash_map(hosts) do |host|
+          host.read filename, as: as
+        end
       end
     end
 
-    # Execute a command on the remote host.
-    # @return false if the command exits with a non-zero status
-    def ping (quiet: false, **args)
-      log.debug "ping" unless quiet
-      win = true
-      each do |host|
-        win &&= host.ping(**args)
+    # Writes a string to a file on the host filesystems.
+    # @param [String] string The string to write.
+    # @param [String] to The file name to write the string to.
+    # @macro onable
+    # @macro asable
+    # @macro quietable
+    # @macro onceable
+    def write (string, to, as: user, on: hosts, quiet: false, once: nil)
+      self.once once, quiet: quiet do
+        log.info "write: #{string.bytesize} bytes -> #{to}", quiet: quiet do
+          hash_map(hosts) do |host|
+            host.write string, to, as: as, quiet: quiet
+          end
+        end
       end
-      win
     end
 
-    def fail (host, message)
-      @hosts -= [host]
+    # Renders and installs files from ERB templates. Files are under +from+ in ERB format. +from/foo/bar.conf.erb+ is
+    # rendered and written to +to/foo/bar.conf+. Non-ERB files are ignored.
+    # @param [String] from The directory to search for .erb files.
+    # @param [String] to The remote directory to put files in.
+    # @macro onable
+    # @macro asable
+    # @macro quietable
+    # @macro onceable
+    def render (from, to, as: user, on: hosts, quiet: false, once: nil)
+      self.once once, quiet: quiet do
+        Dir.chdir File.dirname(file) do
+          (Dir["#{from}**/*.erb"] + Dir["#{from}**/.*.erb"]).each do |path|
+            template = ERB.new(File.read(path))
+            to_path = to + path[from.length..-5]
+            log.info "render: #{path} -> #{to_path}", quiet: quiet do
+              hash_map(hosts) do |host|
+                host.cp StringIO.new(template.result(binding)), to_path, as: as, quiet: quiet
+              end
+            end
+          end
+        end
+      end
     end
 
-    def rebase_path (path)
-      path.gsub(/^(?!\/|.\/)/, File.dirname(@file) + "/")
+    # Ping each host by trying to connect to port 22
+    # @macro onable
+    # @macro quietable
+    def ping (on: hosts, quiet: false)
+      log.info "ping", quiet: quiet do
+        hash_map(hosts) do |host|
+          host.ping
+        end
+      end
     end
 
-    # Copy a file or readable to the host filesystem.
-    # @param from An object that responds to read, or a string which names a file, or an array of either.
-    # @param to A string.
-    def cp (from, to)
-      log.info "cp: #{from} -> #{to}"
-      from = rebase_path(from)
-      each do |host|
-        host.cp(from, to, rsync_command: get(:rsync_command))
+    # Execute a block only once per host.
+    # It is usually preferable to make tasks idempotent, but when that isn't
+    # possible, +once+ will only execute the block on hosts where a block
+    # with the same key hasn't previously been successfully executed.
+    # @param [String] key Uniquely identifies the block.
+    # @param [String] store File to store +once+'s state in.
+    # @macro quietable
+    def once (key, store: "/var/cache/blower.json", quiet: false)
+      return yield unless key
+      log.info "once: #{key}", quiet: quiet do
+        hash_map(hosts) do |host|
+          done = begin
+            JSON.parse(host.read(store, quiet: true))
+          rescue => e
+            {}
+          end
+          unless done[key]
+            on [host] do
+              yield
+            end
+            done[key] = true
+            host.write(done.to_json, store, quiet: true)
+          end
+        end
       end
     end
 
-    def as (user)
-      old_user, @user = @user, user
-      yield
-    ensure
-      @user = old_user
-    end
-
-    # Writes a string to a file on the host filesystem.
-    # @param string The string to write.
-    # @param to A string.
-    def write (string, to)
-      log.info "write: -> #{to}"
-      each do |host|
-        host.cp(StringIO.new(string), to, user: @user, sh_command: get(:sh_command))
-      end
-    end
-
-    def render (from, to)
-      from = rebase_path(from)
-    	(Dir["#{from}**/*.erb"] + Dir["#{from}**/.*.erb"]).each do |path|
-    		template = ERB.new(File.read(path))
-    		to_path = to + path[from.length..-5]
-        log.info "render: #{path} -> #{to_path}"
-    		each do |host|
-    			host.cp StringIO.new(template.result(binding)), to_path, user: @user, sh_command: get(:sh_command)
-    		end
-    	end
-    end
-
-    # Run a task.
-    # @param task (String) The name of the task
-    def run (task, optional: false)
-      files = []
-      @path.each do |dir|
-        name = File.join(dir, task)
-        name += ".rb" unless File.exist?(name)
-        if File.directory?(name)
-          dirtask = File.join(name, @basename)
-          dirtask += ".rb" unless File.exist?(dirtask)
-          name = dirtask
-          blowfile = File.join(name, "Blowfile")
-          files << blowfile if File.exist?(blowfile) && !@have_seen[blowfile]
+    private
+
+    def hash_map (hosts = self.hosts)
+      {}.tap do |result|
+        each(hosts) do |host|
+          result[host] = yield(host)
         end
-        files << name if File.exist?(name)
-        break unless files.empty?
-      end
-      if files.empty?
-        if optional
-          return
-        else
-          raise "can't find #{task}"
+      end
+    end
+
+    def each (hosts = self.hosts)
+      fail "No hosts" if hosts.empty?
+      [hosts].flatten.each do |host|
+        begin
+          yield host
+        rescue => e
+          host.log.error e.message
+          hosts.delete host
         end
-      else
-        log.debug "Running #{task}" do
-          begin
-            old_task, @task = @task, task
-            files.each do |file|
-              @have_seen[file] = true
-              begin
-                old_file, @file = @file, file
-                instance_eval(File.read(file), file)
-              ensure
-                @file = old_file
-              end
-            end
-          ensure
-            @task = old_task
-          end
+      end
+      fail "No hosts remaining" if hosts.empty?
+    end
+
+    def find_task (name)
+      log.debug "Searching for task #{name}" do
+        path.each do |path|
+          log.trace "checking #{File.join(path, name + ".rb")}"
+          file = File.join(path, name + ".rb")
+          return file if File.exists?(file)
+          log.trace "checking #{File.join(path, name, "/blow.rb")}"
+          file = File.join(path, name, "/blow.rb")
+          return file if File.exists?(file)
+          log.trace "checking #{File.join(path, name)}"
+          file = File.join(path, name)
+          return file if File.exists?(file)
         end
       end
+      fail TaskNotFound, "Task not found: #{name}"
     end
 
   end

data/lib/blower/errors.rb

@@ -0,0 +1,17 @@
+
+module Blower
+
+  # Raised when a task isn't found.
+  class TaskNotFound < RuntimeError; end
+
+  # Raised when a command returns a non-zero exit status.
+  class FailedCommand < RuntimeError; end
+
+  class ExecuteError < RuntimeError
+    attr_accessor :status
+    def initialize (status)
+      @status = status
+    end
+  end
+
+end

data/lib/blower/host.rb

@@ -10,46 +10,56 @@ module Blower
     include MonitorMixin
     extend Forwardable
 
-    attr_accessor :name
+    # The default remote user.
     attr_accessor :user
+
+    # The host adress.
     attr_accessor :address
 
     def_delegators :data, :[], :[]=
 
-    class ExecuteError < Exception
-      attr_accessor :status
-      def initialize (status)
-        @status = status
-      end
-    end
-
-    def initialize (name, data: {}, user: "root")
-      @address = @name = name
+    def initialize (address, data: {}, user: "root")
+      @address = address
       @user = user
       @data = data
       super()
     end
 
-    def ping (retries: 0)
+    def name
+      to_s
+    end
+
+    # Represent the host as a string.
+    def to_s
+      "#{@user}@#{@address}"
+    end
+
+    # Attempt to connect to port 22 on the host.
+    # @return +true+
+    # @raise If it doesn't connect within 1 second.
+    # @api private
+    def ping ()
+      log.debug "Pinging"
       Timeout.timeout(1) do
         TCPSocket.new(address, 22).close
       end
       true
     rescue Timeout::Error, Errno::ECONNREFUSED
-      return false if retries == 0
-      retries -= 1
-      retry
+      fail "Failed to ping #{self}"
     end
 
-    def cp (froms, to, output = "", user: nil, rsync_command: nil, sh_command: nil)
+    # Copy files or directories to the host.
+    # @api private
+    def cp (froms, to, as: nil, quiet: false)
+      as ||= @user
+      output = ""
       synchronize do
         [froms].flatten.each do |from|
           if from.is_a?(String)
             to += "/" if to[-1] != "/" && from.is_a?(Array)
             command = ["rsync", "-e", "ssh -oStrictHostKeyChecking=no", "-r"]
-            command += ["--rsync-path=#{rsync_command.()}"] if rsync_command
-            command += [*from, "#{user || @user}@#{@address}:#{to}"]
-            log.trace command.shelljoin
+            command += [*from, "#{as}@#{@address}:#{to}"]
+            log.trace command.shelljoin, quiet: quiet
             IO.popen(command, in: :close, err: %i(child out)) do |io|
               until io.eof?
                 begin
@@ -61,15 +71,14 @@ module Blower
               end
               io.close
               if !$?.success?
-                log.fatal "exit status #{$?.exitstatus}: #{command}"
-                log.fatal output
+                log.fatal "exit status #{$?.exitstatus}: #{command}", quiet: quiet
+                log.fatal output, quiet: quiet
                 fail "failed to copy files"
               end
             end
           elsif from.respond_to?(:read)
             cmd = "echo #{from.read.shellescape} > #{to.shellescape}"
-            cmd = sh_command.(cmd) if sh_command
-            sh cmd
+            sh cmd, quiet: quiet
           else
             fail "Don't know how to copy a #{from.class}: #{from}"
           end
@@ -78,61 +87,70 @@ module Blower
       true
     end
 
-    def sh (command, output = "", user: nil)
+    # Write a string to a host file.
+    # @api private
+    def write (string, to, as: nil, quiet: false)
+      cp StringIO.new(string), to, as: as, quiet: quiet
+    end
+
+    # Read a host file.
+    # @api private
+    def read (filename, as: nil, quiet: false)
+      sh "cat #{filename.shellescape}", as: as, quiet: quiet
+    end
+
+    # Execute a command on the host and return its output.
+    # @api private
+    def sh (command, as: nil, quiet: false)
+      as ||= @user
+      output = ""
       synchronize do
-        log.debug command
+        log.debug "sh #{command}", quiet: quiet
         result = nil
-        ch = ssh(user || @user).open_channel do |ch|
+        ch = ssh(as).open_channel do |ch|
           ch.request_pty do |ch, success|
             "failed to acquire pty" unless success unless success
             ch.exec(command) do |_, success|
               fail "failed to execute command" unless success
               ch.on_data do |_, data|
-                log.trace "received #{data.bytesize} bytes stdout"
+                log.trace "received #{data.bytesize} bytes stdout", quiet: quiet
                 output << data
               end
               ch.on_extended_data do |_, _, data|
-                log.trace "received #{data.bytesize} bytes stderr"
+                log.trace "received #{data.bytesize} bytes stderr", quiet: quiet
                 output << data.colorize(:red)
               end
               ch.on_request("exit-status") do |_, data|
                 result = data.read_long
-                log.trace "received exit-status #{result}"
+                log.trace "received exit-status #{result}", quiet: quiet
               end
             end
           end
         end
         ch.wait
-        if result != 0
-          log.fatal "exit status #{result}: #{command}"
-          log.fatal output
-        end
-        result
+        fail FailedCommand, output if result != 0
+        output
       end
     end
 
-    # # Execute the block with self as a parameter.
-    # # Exists to conform with the HostGroup interface.
-    # def each (&block)
-    #   block.(self)
-    # end
+    # Produce a Logger prefixed with the host name.
+    # @api private
+    def log
+      @log ||= Logger.instance.with_prefix("on #{self}: ")
+    end
 
     private
 
     attr_accessor :data
 
-    def log
-      Logger.instance.with_prefix("(on #{name})")
-    end
-
     def ssh (user)
       @sessions ||= {}
       if @sessions[user] && @sessions[user].closed?
-        log.trace "Discovered the connection to ssh:#{user}@#{name} was lost"
+        log.warn "Discovered the connection to ssh:#{self} was lost"
         @sessions[user] = nil
       end
       @sessions[user] ||= begin
-        log.trace "Connecting to ssh:#{user}@#{name}"
+        log.debug "Connecting to ssh:#{self}"
         Net::SSH.start(address, user)
       end
     end

data/lib/blower/logger.rb

@@ -12,92 +12,94 @@ module Blower
     include MonitorMixin
     include Singleton
 
+    # Logging levels in ascending order of severity.
+    LEVELS = %i(all trace debug info warn error fatal none)
+
+    # Colorize specifications for log levels.
     COLORS = {
-      trace: {color: :light_black},
-      debug: {color: :default},
-      info:  {color: :blue},
-      warn:  {color: :yellow},
-      error: {color: :red},
-      fatal: {color: :light_white, background: :red},
+      trace: { color: :light_black },
+      debug: { color: :default },
+      info:  { color: :blue },
+      warn:  { color: :yellow },
+      error: { color: :red },
+      fatal: { color: :light_white, background: :red },
     }
 
-    RANKS = {
-      all: 100,
-      trace: 60,
-      debug: 50,
-      info:  40,
-      warn:  30,
-      error: 20,
-      fatal: 10,
-      off: 0,
-    }
+    class << self
+      # The minimum severity level for which messages will be displayed.
+      attr_accessor :level
+
+      # The current indentation level.
+      attr_accessor :indent
+    end
+
+    self.indent = 0
 
-    @@indent = 0
+    self.level = :info
 
-    def initialize (prefix = nil)
+    def initialize (prefix = "")
       @prefix = prefix
       super()
     end
 
+    # Return a logger with the specified prefix
     def with_prefix (string)
-      self.class.send(:new, "#{@prefix}#{string}")
+      Logger.send(:new, string)
     end
 
-    # Log a trace level event
-    def trace (a=nil, *b, &c); log(a, :trace, *b, &c); end
-
-    # Log a debug level event
-    def debug (a=nil, *b, &c); log(a, :debug, *b, &c); end
-
-    # Log a info level event
-    def info (a=nil, *b, &c); log(a, :info, *b, &c); end
-
-    # Log a warn level event
-    def warn (a=nil, *b, &c); log(a, :warn, *b, &c); end
-
-    # Log a error level event
-    def error (a=nil, *b, &c); log(a, :error, *b, &c); end
-
-    # Log a fatal level event
-    def fatal (a=nil, *b, &c); log(a, :fatal, *b, &c); end
-
-    def nest (&c)
-      log(nil, nil, &c)
+    # Yield with a temporarily incremented indent counter
+    def with_indent ()
+      Logger.indent += 1
+      yield
+    ensure
+      Logger.indent -= 1
     end
 
-    def task (message, &block)
-      STDOUT.write "  " * @@indent + (@prefix ? @prefix + " " : "") + message + "... "
-      begin
-        @@indent += 1
-        block.() if block
-      ensure
-        @@indent -= 1
+    # Display a log message. The block, if specified, is executed in an indented region after the log message is shown.
+    # @api private
+    # @param [Symbol] level the severity level
+    # @param [#to_s] message the message to display
+    # @param block a block to execute with an indent after the message is displayed
+    # @return the value of block, or nil
+    def log (level, message, quiet: false, &block)
+      if !quiet && (LEVELS.index(level) >= LEVELS.index(Logger.level))
+        synchronize do
+          message = message.to_s.colorize(COLORS[level]) if level
+          message.split("\n").each do |line|
+            STDERR.puts "  " * Logger.indent + @prefix + line
+          end
+        end
+        with_indent(&block) if block
+      elsif block
+        block.()
       end
-      puts "OK".colorize({color: :green})
-    rescue => e
-      puts "ERROR".colorize({color: :red})
-      raise e
     end
 
-    private
-
-    def log (message = nil, level = :info, &block)
-      if message && (level.nil? || RANKS[level] <= RANKS[$LOGLEVEL])
-        Logger.instance.synchronize do
-          message = message.colorize(COLORS[level]) if level
-          puts "  " * @@indent + (@prefix ? @prefix + " " : "") + message
-        end
-        begin
-          @@indent += 1
-          block.() if block
-        ensure
-          @@indent -= 1
-        end
-      else
-        block.() if block
+    # Define a helper method for a given severity level.
+    # @!macro [attach] log_helper
+    #   @!method $1(message, &block)
+    #   Display a $1 log message, as if by calling log directly.
+    #   @param [#to_s] message the message to display
+    #   @param block a block to execute with an indent after the message is displayed
+    #   @return the value of block, or nil
+    def self.define_helper (level)
+      define_method(level) do |*args, **kwargs, &block|
+        log(level, *args, **kwargs, &block)
       end
     end
 
+    define_helper :trace
+    define_helper :debug
+    define_helper :info
+    define_helper :warn
+    define_helper :error
+    define_helper :fatal
+
   end
 
 end
+
+# Return the logger instance.
+def log
+  Blower::Logger.instance
+end

data/lib/blower/util.rb

@@ -0,0 +1,28 @@
+
+class Object
+
+  # Yield with temporary instance variable assignments.
+  # @param [Hash] bindings A hash of instance variable names to their temporary values.
+  # @return Whatever yielding returns
+  # @example Time
+  #  @foo = 1
+  #  let :@foo => 2 do
+  #    puts @foo        #=> outputs 2
+  #  end
+  #  puts @foo          #=> outputs 1
+  def let (bindings)
+    old_values = bindings.keys.map do |key|
+      instance_variable_get(key)
+    end
+    bindings.each do |key, value|
+      instance_variable_set(key, value)
+    end
+    yield
+  ensure
+    return unless old_values
+    bindings.keys.each.with_index do |key, i|
+      instance_variable_set(key, old_values[i])
+    end
+  end
+
+end

data/lib/blower/version.rb

@@ -1,3 +1,3 @@
 module Blower
-  VERSION = "3.4"
+  VERSION = "4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blower
 version: !ruby/object:Gem::Version
-  version: '3.4'
+  version: '4.0'
 platform: ruby
 authors:
 - Nathan Baum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-25 00:00:00.000000000 Z
+date: 2016-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -76,8 +76,10 @@ files:
 - bin/blow
 - lib/blower.rb
 - lib/blower/context.rb
+- lib/blower/errors.rb
 - lib/blower/host.rb
 - lib/blower/logger.rb
+- lib/blower/util.rb
 - lib/blower/version.rb
 homepage: http://www.github.org/nbaum/blower
 licenses: