blower 2.0.0 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43a7308c9eaa1ad35d5a1c3942fad1850b32f3dc
-  data.tar.gz: 0d43517ed6d42111fd7aa0eabe3f30275ee1d227
+  metadata.gz: 1346720ababac71f881dae28ba20012eaa110361
+  data.tar.gz: 567937a547591d6bcaaafc55f10d3c515fd78969
 SHA512:
-  metadata.gz: dd7de8fa74c568387e02af7afde83fa52d719a9ccb8658eae7a26ef9fa483b924654bb7bf9fe5f0b97d08b595a7652f72c4994810424b833058d14feb3dbed89
-  data.tar.gz: 200326faec848b91ea49c5422f8fb74843c17de9ac622559fd927e19099628a1a5de6d10573655ae5b4bd67056c9cca459b97758a4d3c160867bec3ba486a422
+  metadata.gz: e94f4c1b1074a20ff18fd7bf416af1fe52436e473eba52c7a53ea642c46fdbae5dc9a48f2b3e30c4458f49ccab4c69010426494978590be4751824708571dd06
+  data.tar.gz: 7013297bf513abbb9b364dc429f78fa71d21916bb6c773816eeb1ba71aa23fa183aee0bf885ca6ace9968475dee576b2b9bc5cf44f4db5aeb264f7523d8c2b73

data/bin/blow

@@ -3,18 +3,25 @@ require 'blower'
 require 'pathname'
 require 'optparse'
 
+$LOGLEVEL = :info
+
 OptionParser.new do |opts|
   opts.banner = "Usage: blow [options] task..."
   opts.on "-d DIR", "Change directory" do |v|
     Dir.chdir v
   end
+  opts.on "-l LEVEL", "Minimal log level" do |l|
+    $LOGLEVEL = l.downcase.to_sym
+  end
 end.order!
 
+context = Blower::Context.new([".", Dir.pwd])
+context.run "Blowfile", optional: true
 begin
-  context = Blower::Context.new([".", Dir.pwd])
-  context.target = nil
-  context.run "Blowfile"
-  ARGV.each do |arg|
-    context.run arg
+  until ARGV.empty?
+    context.run ARGV.shift
   end
+rescue RuntimeError => e
+  puts e.message.colorize(:red)
+  exit 1
 end

data/lib/blower/context.rb

@@ -2,77 +2,138 @@ 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.
+  #
   class Context
     extend Forwardable
 
+    # Search path for tasks.
     attr_accessor :path
-    attr_accessor :location
-    attr_accessor :target
+
+    # The target hosts.
+    attr_accessor :hosts
 
     def initialize (path)
       @path = path
+      @hosts = []
       @have_seen = {}
     end
 
-    def log (message, level, &block)
-      message = "(on #{target.name}) " + message if target.respond_to?(:name)
-      Logger.instance.log(message, level, &block)
+    def log
+      Logger.instance
+    end
+
+    def add_host (spec)
+      host = Host.new(*spec) unless spec.is_a?(Host)
+      @hosts << host
+    end
+
+    # Execute the block on one host.
+    # @param host Host to use. If nil, a random host is picked.
+    def one_host (host = nil, &block)
+      map [host || target.hosts.sample], &block
     end
 
-    def stage (message, &block)
-      log message, :info, &block
+    # Execute the block once for each host.
+    # Each block executes in a copy of the context.
+    def each (hosts = @hosts, &block)
+      map(hosts, &block)
+      nil
     end
 
-    def one_host (name = nil, &block)
-      each_host [name || target.hosts.sample], &block
+    # Execute the block once for each host.
+    # Each block executes in a copy of the context.
+    def map (hosts = @hosts, &block)
+      Kernel.fail "No hosts left" if hosts.empty?
+      hosts.map do |host|
+        Thread.new do
+          block.(host)
+        end
+      end.map(&:join)
     end
 
-    def each_host (hosts = target, parallel: true, &block)
-      hosts.each do |host|
-        ctx = dup
-        ctx.target = host
-        ctx.instance_exec(&block)
+    # Reboot each host and waits for them to come back up.
+    # @param command The reboot command. A string.
+    def reboot (command = "reboot")
+      each do
+        begin
+          sh command
+        rescue IOError
+        end
+        log.debug "Waiting for server to go away..."
+        sleep 0.1 while ping(true)
+        log.debug "Waiting for server to come back..."
+        sleep 1.0 until ping(true)
       end
     end
 
-    def reboot
-      begin
-        sh "shutdown -r now"
-      rescue IOError
-        sleep 0.1 while ping
-        sleep 1.0 until ping
+    # Execute a shell command on each host.
+    def sh (command, quiet = false)
+      log.info "sh: #{command}" unless quiet
+      map do |host|
+        status = host.sh(command)
+        fail host, "#{command}: exit status #{status}" if status != 0
       end
     end
 
-    def sh (command)
-      log "execute #{command}", :debug
-      target.sh(command)
+    # 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
+      win = true
+      map do |host|
+        status = host.sh(command)
+        win = false if status != 0
+      end
+      win
     end
 
+    # Execute a command on the remote host.
+    # @return false if the command exits with a non-zero status
+    def ping (quiet = false)
+      log.info "ping" unless quiet
+      win = true
+      map do |host|
+        win &&= host.ping
+      end
+      win
+    end
+
+    def fail (host, message)
+      @hosts -= [host]
+    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 "upload #{Array(from).join(", ")} -> #{to}", :debug
-      target.cp(from, to)
+      log.info "cp: #{from} -> #{to}"
+      map do |host|
+        host.cp(from, to)
+      end
     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 "upload data to #{to}", :debug
       target.cp(StringIO.new(string), to)
     end
 
-    def sh? (command)
-      log "execute #{command}", :debug
-      target.sh(command)
-    rescue Blower::Host::ExecuteError
-      false
-    end
-
+    # Capture the output a command on the remote host.
+    # @return (String) The combined stdout and stderr of the command.
     def capture (command)
       stdout = ""
       target.sh(command, stdout)
       stdout
     end
 
-    def run (task)
+    # 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)
@@ -88,16 +149,22 @@ module Blower
         break unless files.empty?
       end
       if files.empty?
-        fail "can't find #{task}"
+        if optional
+          return
+        else
+          fail "can't find #{task}"
+        end
       else
-        begin
-          old_task, @task = @task, task
-          files.each do |file|
-            @have_seen[file] = true
-            instance_eval(File.read(file), file)
+        log.info "Running #{task}" do
+          begin
+            old_task, @task = @task, task
+            files.each do |file|
+              @have_seen[file] = true
+              instance_eval(File.read(file), file)
+            end
+          ensure
+            @task = old_task
           end
-        ensure
-          @task = old_task
         end
       end
     end

data/lib/blower/host.rb

@@ -2,6 +2,7 @@ require 'net/ssh'
 require 'net/scp'
 require 'monitor'
 require 'colorize'
+require 'timeout'
 
 module Blower
 
@@ -11,7 +12,6 @@ module Blower
 
     attr_accessor :name
     attr_accessor :user
-    attr_accessor :data
 
     def_delegators :data, :[], :[]=
 
@@ -29,10 +29,6 @@ module Blower
       super()
     end
 
-    def log
-      Logger.instance
-    end
-
     def ping
       Timeout.timeout(1) do
         TCPSocket.new(name, 22).close
@@ -48,8 +44,10 @@ module Blower
       synchronize do
         if from.is_a?(String) || from.is_a?(Array)
           to += "/" if to[-1] != "/" && from.is_a?(Array)
-          IO.popen(["rsync", "-z", "-r", "--progress", *from, "#{@user}@#{@name}:#{to}"],
-                   in: :close, err: %i(child out)) do |io|
+          command = ["rsync", "-e", "ssh -oStrictHostKeyChecking=no", "-zz", "-r", "--progress", *from,
+                     "#{@user}@#{@name}:#{to}"]
+          log.trace command.shelljoin
+          IO.popen(command, in: :close, err: %i(child out)) do |io|
             until io.eof?
               begin
                 output << io.read_nonblock(100)
@@ -58,53 +56,74 @@ module Blower
                 retry
               end
             end
+            io.close
+            if !$?.success?
+              log.fatal "exit status #{$?.exitstatus}: #{command}"
+              log.raw output
+            end
           end
-        elsif from.is_a?(StringIO) or from.is_a?(IO)
-          log.info "string -> #{to}" unless quiet
+        elsif from.respond_to?(:read)
           ssh.scp.upload!(from, to)
         else
           fail "Don't know how to copy a #{from.class}: #{from}"
         end
       end
       true
-    rescue => e
-      false
     end
 
     def sh (command, output = "")
       synchronize do
+        log.debug command
         result = nil
         ch = ssh.open_channel do |ch|
           ch.exec(command) do |_, success|
             fail "failed to execute command" unless success
             ch.on_data do |_, data|
+              log.trace "received #{data.bytesize} bytes stdout"
               output << data
             end
             ch.on_extended_data do |_, _, data|
+              log.trace "received #{data.bytesize} bytes stderr"
               output << data.colorize(:red)
             end
-            ch.on_request("exit-status") { |_, data| result = data.read_long }
+            ch.on_request("exit-status") do |_, data|
+              result = data.read_long
+              log.trace "received exit-status #{result}"
+            end
           end
         end
         ch.wait
         if result != 0
-          log.fatal "failed on #{name}"
+          log.fatal "exit status #{result}: #{command}"
           log.raw output
-          exit 1
         end
         result
       end
     end
 
+    # Execute the block with self as a parameter.
+    # Exists to confirm with the HostGroup interface.
     def each (&block)
       block.(self)
     end
 
     private
 
+    attr_accessor :data
+
+    def log
+      Logger.instance.with_prefix("(on #{name})")
+    end
+
     def ssh
-      @ssh = nil if @ssh && @ssh.closed?
-      @ssh ||= Net::SSH.start(name, user)
+      if @ssh && @ssh.closed?
+        log.trace "Discovered the connection to ssh:#{name}@#{user} was lost"
+        @ssh = nil
+      end
+      @ssh ||= begin
+        log.trace "Connecting to ssh:#{name}@#{user}"
+        Net::SSH.start(name, user)
+      end
     end
 
   end

data/lib/blower/logger.rb

@@ -2,37 +2,75 @@ require "singleton"
 
 module Blower
 
+  # Colorized logger.
+  #
+  # Prints messages to STDOUT, colorizing them according to the specified log level.
+  #
+  # The logging methods accept an optional block. Inside the block, log messages will
+  # be indented by two spaces. This works recursively.
   class Logger
     include MonitorMixin
     include Singleton
 
     COLORS = {
-      trace: :light_black,
-      debug: :light_black,
-      info: :blue,
-      warn: :yellow,
-      error: :red,
-      fatal: :magenta,
+      trace: {color: :light_black},
+      debug: {color: :default},
+      info:  {color: :blue},
+      warn:  {color: :yellow},
+      error: {color: :red},
+      fatal: {color: :light_white, background: :red},
     }
 
-    def initialize
+    RANKS = {
+      all: 100,
+      trace: 60,
+      debug: 50,
+      info:  40,
+      warn:  30,
+      error: 20,
+      fatal: 10,
+      off: 0,
+    }
+
+    def initialize (prefix = nil)
       @indent = 0
+      @prefix = prefix
       super()
     end
 
+    def with_prefix (string)
+      self.class.send(:new, "#{@prefix}#{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
+
+    # Log a level-less event
+    # @deprecated
     def raw (a=nil, *b, &c); log(a, nil, *b, &c); end
 
+    private
+
     def log (message = nil, level = :info, &block)
-      if message
-        synchronize do
+      if message && (level.nil? || RANKS[level] <= RANKS[$LOGLEVEL])
+        Logger.instance.synchronize do
           message = message.colorize(COLORS[level]) if level
-          puts "  " * @indent + message
+          puts "  " * @indent + (@prefix ? @prefix + " " : "") + message
         end
       end
       begin
@@ -45,8 +83,4 @@ module Blower
 
   end
 
-  def self.log (*args, &block)
-    Logger.instance.log(*args, &block)
-  end
-
 end

data/lib/blower/version.rb

@@ -1,3 +1,3 @@
 module Blower
-  VERSION = "2.0.0"
+  VERSION = "2.1.2"
 end

data/lib/blower.rb

@@ -1,6 +1,5 @@
 require 'blower/logger'
 require 'blower/context'
 require 'blower/host'
-require 'blower/host_group'
 require 'blower/mock_host'
 require 'blower/version'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blower
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.2
 platform: ruby
 authors:
 - Nathan Baum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-05 00:00:00.000000000 Z
+date: 2015-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Really simple server orchestration
 email: n@p12a.org.uk
 executables:
@@ -63,7 +77,6 @@ files:
 - lib/blower.rb
 - lib/blower/context.rb
 - lib/blower/host.rb
-- lib/blower/host_group.rb
 - lib/blower/logger.rb
 - lib/blower/mock_host.rb
 - lib/blower/version.rb
@@ -92,3 +105,4 @@ signing_key:
 specification_version: 4
 summary: Really simple server orchestration
 test_files: []
+has_rdoc: 

data/lib/blower/host_group.rb

@@ -1,36 +0,0 @@
-module Blower
-
-  class HostGroup
-
-    attr_accessor :hosts
-    attr_accessor :root
-    attr_accessor :location
-
-    def initialize (hosts)
-      @hosts = hosts
-    end
-
-    def sh (command = nil, *args, &block)
-      each do |host|
-        command = block.() if block
-        host.sh(command)
-      end
-    end
-
-    def cp (from, to)
-      each do |host|
-        host.cp(from, to)
-      end
-    end
-
-    def each (&block)
-      hosts.map do |host|
-        Thread.new do
-          block.(host)
-        end
-      end.map(&:join)
-    end
-
-  end
-
-end