blower 2.2.0 → 3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cfbaaa18cbeed95710091e851f7869055d0adb3
-  data.tar.gz: 5dba28a766c20b2c622a814687fe6defdc825982
+  metadata.gz: 326c39aae83c23c79f60751abeabe1a8eea19870
+  data.tar.gz: e3fa37856f16d53884cc4f79ff7bc762dacc0633
 SHA512:
-  metadata.gz: 720985c8137a5283d7b9909c767b39342d06b87ed8d83866f595ac44f18ccd86b6ce7286aca31bc4a54ba3246f148d5ddf63fc43b6351510d3d5100df84aa668
-  data.tar.gz: f6b2a4d82dc3ffc7ff803a082a8f1374e52b20f7f95c843aa8265197613f63dbec6d89d20962354da9441535bf5cd5458acab48d68408bbd5646fc426f621bec
+  metadata.gz: 1705364adfc1bcfa70d7b12cdeccae35d6ba391b2f08192ab1e1380f29bd2495e4945634268237486f8ac250c843752876de2c7574b30ba34634fe4e3b22e3fd
+  data.tar.gz: d091fe3d25f24af89309b01cb716e97961d9165528c9abbe5f3441dc2b6343096eb25ecc9babb5562ad0b28633c5e99d34eecb7ef6c29f2eec49459399d7e2e7

data/lib/blower/context.rb

@@ -1,3 +1,4 @@
+require 'erb'
 require 'forwardable'
 
 module Blower
@@ -12,6 +13,9 @@ module Blower
     # Search path for tasks.
     attr_accessor :path
 
+    # The currently running task.
+    attr_accessor :task
+
     # The target hosts.
     attr_accessor :hosts
 
@@ -19,6 +23,28 @@ module Blower
       @path = path
       @hosts = []
       @have_seen = {}
+      @data = {}
+    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
+    end
+
+    def get (var)
+      @data[var]
     end
 
     def log
@@ -34,50 +60,70 @@ module Blower
     # Execute the block once for each host and return nil.
     def each (hosts = @hosts, &block)
       Kernel.fail "No hosts left" if hosts.empty?
-      Enumerator.new do |y|
-        hosts.each do |host|
-          y << host
-        end
-      end.each(&block)
+      hosts.each(&block)
+    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)
+      end
+      ctx.instance_exec(&block)
+    end
+
+    def with_each (hosts = @hosts, &block)
+      each do |host|
+        with host, &block
+      end
     end
 
     # Execute the block once for each host and return a hash of the results.
     def hashmap (hosts = @hosts, &block)
       result = {}
       threads = []
-      each hosts do |host|
-        threads << Thread.new do
-          result[host] = block.(host)
+      log.nest do
+        each hosts do |host|
+          threads << Thread.new do
+            result[host] = block.(host)
+          end
         end
+        threads.each(&:join)
       end
-      threads.each(&:join)
       result
     end
 
     # Reboot each host and waits for them to come back up.
     # @param command The reboot command. A string.
     def reboot (command = "reboot")
-      each do
+      if f = get(:sh_command)
+        command = f.(command)
+      end
+      each do |host|
+        log.info "rebooting: #{host.name}"
         begin
-          sh command
+          host.sh command, user: @user
         rescue IOError
         end
-        log.debug "Waiting for server to go away..."
-        sleep 0.1 while ping(true)
+        log.debug "rebooting: #{host.name}: waiting for shutdown..."
+        sleep 0.1 while host.ping
       end
-      each do
-        log.debug "Waiting for server to come back..."
-        sleep 1.0 until ping(true)
+      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)
+    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)
+        status = host.sh(command, out, user: @user)
         if status != 0
           fail host, "#{command}: exit status #{status}"
           nil
@@ -89,20 +135,20 @@ module Blower
 
     # Execute a command on the remote host.
     # @return false if the command exits with a non-zero status
-    def sh? (command, quiet = false)
+    def sh? (command, quiet: false)
       log.info "sh?: #{command}" unless quiet
-      win = true
-      each do |host|
-        status = host.sh(command)
-        win = false if status != 0
+      if f = get(:sh_command)
+        command = f.(command)
+      end
+      hashmap do |host|
+        host.sh(command, user: @user) == 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
+    def ping (quiet: false)
+      log.debug "ping" unless quiet
       win = true
       each do |host|
         win &&= host.ping
@@ -114,22 +160,48 @@ module Blower
       @hosts -= [host]
     end
 
+    def rebase_path (path)
+      path.gsub(/^(?!\/)/, File.dirname(@file))
+    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)
+        host.cp(from, to, rsync_command: get(:rsync_command))
       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 "upload data to #{to}", :debug
-      target.cp(StringIO.new(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.
@@ -153,15 +225,20 @@ module Blower
         if optional
           return
         else
-          fail "can't find #{task}"
+          raise "can't find #{task}"
         end
       else
-        log.info "Running #{task}" do
+        log.debug "Running #{task}" do
           begin
             old_task, @task = @task, task
             files.each do |file|
               @have_seen[file] = true
-              instance_eval(File.read(file), file)
+              begin
+                old_file, @file = @file, file
+                instance_eval(File.read(file), file)
+              ensure
+                @file = old_file
+              end
             end
           ensure
             @task = old_task

data/lib/blower/host.rb

@@ -12,6 +12,7 @@ module Blower
 
     attr_accessor :name
     attr_accessor :user
+    attr_accessor :address
 
     def_delegators :data, :[], :[]=
 
@@ -22,90 +23,99 @@ module Blower
       end
     end
 
-    def initialize (name, user = "root")
-      @name = name
+    def initialize (name, data: {}, user: "root")
+      @address = @name = name
       @user = user
-      @data = {}
+      @data = data
       super()
     end
 
     def ping
       Timeout.timeout(1) do
-        TCPSocket.new(name, 22).close
+        TCPSocket.new(address, 22).close
       end
       true
-    rescue Timeout::ExitException
+    rescue Timeout::Error
       false
     rescue Errno::ECONNREFUSED
       false
     end
 
-    def cp (from, to, output = "")
+    def cp (froms, to, output = "", user: nil, rsync_command: nil, sh_command: nil)
       synchronize do
-        if from.is_a?(String) || from.is_a?(Array)
-          to += "/" if to[-1] != "/" && from.is_a?(Array)
-          command = ["rsync", "-e", "ssh -oStrictHostKeyChecking=no", "-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)
-              rescue IO::WaitReadable
-                IO.select([io])
-                retry
+        [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
+            IO.popen(command, in: :close, err: %i(child out)) do |io|
+              until io.eof?
+                begin
+                  output << io.read_nonblock(100)
+                rescue IO::WaitReadable
+                  IO.select([io])
+                  retry
+                end
+              end
+              io.close
+              if !$?.success?
+                log.fatal "exit status #{$?.exitstatus}: #{command}"
+                log.fatal output
+                fail "failed to copy files"
               end
             end
-            io.close
-            if !$?.success?
-              log.fatal "exit status #{$?.exitstatus}: #{command}"
-              log.raw output
-            end
+          elsif from.respond_to?(:read)
+            cmd = "echo #{from.read.shellescape} > #{to.shellescape}"
+            cmd = sh_command.(cmd) if sh_command
+            sh cmd
+          else
+            fail "Don't know how to copy a #{from.class}: #{from}"
           end
-        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
     end
 
-    def sh (command, output = "")
+    def sh (command, output = "", user: nil)
       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") do |_, data|
-              result = data.read_long
-              log.trace "received exit-status #{result}"
+        ch = ssh(user || @user).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"
+                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") do |_, data|
+                result = data.read_long
+                log.trace "received exit-status #{result}"
+              end
             end
           end
         end
         ch.wait
         if result != 0
           log.fatal "exit status #{result}: #{command}"
-          log.raw output
+          log.fatal output
         end
         result
       end
     end
 
-    # Execute the block with self as a parameter.
-    # Exists to conform with the HostGroup interface.
-    def each (&block)
-      block.(self)
-    end
+    # # Execute the block with self as a parameter.
+    # # Exists to conform with the HostGroup interface.
+    # def each (&block)
+    #   block.(self)
+    # end
 
     private
 
@@ -115,14 +125,15 @@ module Blower
       Logger.instance.with_prefix("(on #{name})")
     end
 
-    def ssh
-      if @ssh && @ssh.closed?
-        log.trace "Discovered the connection to ssh:#{name}@#{user} was lost"
-        @ssh = nil
+    def ssh (user)
+      @sessions ||= {}
+      if @sessions[user] && @sessions[user].closed?
+        log.trace "Discovered the connection to ssh:#{user}@#{name} was lost"
+        @sessions[user] = nil
       end
-      @ssh ||= begin
-        log.trace "Connecting to ssh:#{name}@#{user}"
-        Net::SSH.start(name, user)
+      @sessions[user] ||= begin
+        log.trace "Connecting to ssh:#{user}@#{name}"
+        Net::SSH.start(address, user)
       end
     end
 

data/lib/blower/logger.rb

@@ -32,8 +32,9 @@ module Blower
       off: 0,
     }
 
+    @@indent = 0
+
     def initialize (prefix = nil)
-      @indent = 0
       @prefix = prefix
       super()
     end
@@ -60,9 +61,23 @@ module Blower
     # 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
+    def nest (&c)
+      log(nil, nil, &c)
+    end
+
+    def task (message, &block)
+      STDOUT.write "  " * @@indent + (@prefix ? @prefix + " " : "") + message + "... "
+      begin
+        @@indent += 1
+        block.() if block
+      ensure
+        @@indent -= 1
+      end
+      puts "OK".colorize({color: :green})
+    rescue => e
+      puts "ERROR".colorize({color: :red})
+      raise e
+    end
 
     private
 
@@ -70,15 +85,17 @@ module Blower
       if message && (level.nil? || RANKS[level] <= RANKS[$LOGLEVEL])
         Logger.instance.synchronize do
           message = message.colorize(COLORS[level]) if level
-          puts "  " * @indent + (@prefix ? @prefix + " " : "") + message
+          puts "  " * @@indent + (@prefix ? @prefix + " " : "") + message
+        end
+        begin
+          @@indent += 1
+          block.() if block
+        ensure
+          @@indent -= 1
         end
+      else
+        block.() if block
       end
-      begin
-        @indent += 1
-        block.()
-      ensure
-        @indent -= 1
-      end if block
     end
 
   end

data/lib/blower/version.rb

@@ -1,3 +1,3 @@
 module Blower
-  VERSION = "2.2.0"
+  VERSION = "3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: blower
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: '3.1'
 platform: ruby
 authors:
 - Nathan Baum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-07 00:00:00.000000000 Z
+date: 2016-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh