blower 0.2.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52e337abe103b677ac90233cfd4f38121585fe0b
-  data.tar.gz: 47e87f53486d3b7ec27e2abc78d24098b5759e0d
+  metadata.gz: 43a7308c9eaa1ad35d5a1c3942fad1850b32f3dc
+  data.tar.gz: 0d43517ed6d42111fd7aa0eabe3f30275ee1d227
 SHA512:
-  metadata.gz: 6f250fa25824a1e5c003cadb0102f90305fd6e536b7a4602021a7222ddf7d3259e2870e4dc5d4efd5d1f617367474f541be6ec1f1d784b164c6f621a00bbec87
-  data.tar.gz: 518c595f5587dc82b6ef0b2fb831c095e237c407c614807e56e7e126d72d58a66c7a530552fd4ca1f3bf61ad990e271c472445a3c5bcfe944ae152d37f8edbda
+  metadata.gz: dd7de8fa74c568387e02af7afde83fa52d719a9ccb8658eae7a26ef9fa483b924654bb7bf9fe5f0b97d08b595a7652f72c4994810424b833058d14feb3dbed89
+  data.tar.gz: 200326faec848b91ea49c5422f8fb74843c17de9ac622559fd927e19099628a1a5de6d10573655ae5b4bd67056c9cca459b97758a4d3c160867bec3ba486a422

data/bin/blow

@@ -1,24 +1,20 @@
 #!/usr/bin/env ruby
-
 require 'blower'
+require 'pathname'
+require 'optparse'
 
-huff = Blower::Huff.new
-
-args = ARGV
-args = ["main"] if args.empty? && (File.exist?("main") || !Dir["main.*"].empty?)
-
-if args.empty?
-  huff.log.fail "Usage: blow TASK..."
-  exit 1
-end
-
-args = ["hosts.ini", *args] if File.exist?("hosts.ini")
+OptionParser.new do |opts|
+  opts.banner = "Usage: blow [options] task..."
+  opts.on "-d DIR", "Change directory" do |v|
+    Dir.chdir v
+  end
+end.order!
 
 begin
-  args.each do |arg|
-    huff.run arg
+  context = Blower::Context.new([".", Dir.pwd])
+  context.target = nil
+  context.run "Blowfile"
+  ARGV.each do |arg|
+    context.run arg
   end
-rescue RuntimeError => e
-  huff.log.fail e.message
-  exit 1
 end

data/lib/blower/context.rb

@@ -0,0 +1,107 @@
+require 'forwardable'
+
+module Blower
+
+  class Context
+    extend Forwardable
+
+    attr_accessor :path
+    attr_accessor :location
+    attr_accessor :target
+
+    def initialize (path)
+      @path = path
+      @have_seen = {}
+    end
+
+    def log (message, level, &block)
+      message = "(on #{target.name}) " + message if target.respond_to?(:name)
+      Logger.instance.log(message, level, &block)
+    end
+
+    def stage (message, &block)
+      log message, :info, &block
+    end
+
+    def one_host (name = nil, &block)
+      each_host [name || target.hosts.sample], &block
+    end
+
+    def each_host (hosts = target, parallel: true, &block)
+      hosts.each do |host|
+        ctx = dup
+        ctx.target = host
+        ctx.instance_exec(&block)
+      end
+    end
+
+    def reboot
+      begin
+        sh "shutdown -r now"
+      rescue IOError
+        sleep 0.1 while ping
+        sleep 1.0 until ping
+      end
+    end
+
+    def sh (command)
+      log "execute #{command}", :debug
+      target.sh(command)
+    end
+
+    def cp (from, to)
+      log "upload #{Array(from).join(", ")} -> #{to}", :debug
+      target.cp(from, to)
+    end
+
+    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
+
+    def capture (command)
+      stdout = ""
+      target.sh(command, stdout)
+      stdout
+    end
+
+    def run (task)
+      files = []
+      @path.each do |dir|
+        name = File.join(dir, task)
+        name += ".rb" unless File.exist?(name)
+        if File.directory?(name)
+          dirtask = File.join(name, File.basename(@task))
+          dirtask += ".rb" unless File.exist?(dirtask)
+          name = dirtask
+          blowfile = File.join(name, "Blowfile")
+          files << blowfile if File.exist?(blowfile) && !@have_seen[blowfile]
+        end
+        files << name if File.exist?(name)
+        break unless files.empty?
+      end
+      if files.empty?
+        fail "can't find #{task}"
+      else
+        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
+      end
+    end
+
+  end
+
+end

data/lib/blower/host.rb

@@ -0,0 +1,112 @@
+require 'net/ssh'
+require 'net/scp'
+require 'monitor'
+require 'colorize'
+
+module Blower
+
+  class Host
+    include MonitorMixin
+    extend Forwardable
+
+    attr_accessor :name
+    attr_accessor :user
+    attr_accessor :data
+
+    def_delegators :data, :[], :[]=
+
+    class ExecuteError < Exception
+      attr_accessor :status
+      def initialize (status)
+        @status = status
+      end
+    end
+
+    def initialize (name, user = "root")
+      @name = name
+      @user = user
+      @data = {}
+      super()
+    end
+
+    def log
+      Logger.instance
+    end
+
+    def ping
+      Timeout.timeout(1) do
+        TCPSocket.new(name, 22).close
+      end
+      true
+    rescue Timeout::ExitException
+      false
+    rescue Errno::ECONNREFUSED
+      false
+    end
+
+    def cp (from, to, output = "")
+      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|
+            until io.eof?
+              begin
+                output << io.read_nonblock(100)
+              rescue IO::WaitReadable
+                IO.select([io])
+                retry
+              end
+            end
+          end
+        elsif from.is_a?(StringIO) or from.is_a?(IO)
+          log.info "string -> #{to}" unless quiet
+          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
+        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|
+              output << data
+            end
+            ch.on_extended_data do |_, _, data|
+              output << data.colorize(:red)
+            end
+            ch.on_request("exit-status") { |_, data| result = data.read_long }
+          end
+        end
+        ch.wait
+        if result != 0
+          log.fatal "failed on #{name}"
+          log.raw output
+          exit 1
+        end
+        result
+      end
+    end
+
+    def each (&block)
+      block.(self)
+    end
+
+    private
+
+    def ssh
+      @ssh = nil if @ssh && @ssh.closed?
+      @ssh ||= Net::SSH.start(name, user)
+    end
+
+  end
+
+end

data/lib/blower/host_group.rb

@@ -0,0 +1,36 @@
+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

data/lib/blower/logger.rb

@@ -1,44 +1,52 @@
-require "colorize"
+require "singleton"
 
 module Blower
-class Logger
 
-  def initialize ()
-    @logdent = 0
-  end
-
-  def info (message, **keys, &block)
-    log(message, :blue, **keys, &block)
-  end
-
-  def warn (message, **keys, &block)
-    log(message, :yellow, STDERR, **keys, &block)
-  end
+  class Logger
+    include MonitorMixin
+    include Singleton
+
+    COLORS = {
+      trace: :light_black,
+      debug: :light_black,
+      info: :blue,
+      warn: :yellow,
+      error: :red,
+      fatal: :magenta,
+    }
+
+    def initialize
+      @indent = 0
+      super()
+    end
 
-  def fail (message, **keys, &block)
-    log(message, :red, STDERR, **keys, &block)
-  end
+    def trace (a=nil, *b, &c); log(a, :trace, *b, &c); end
+    def debug (a=nil, *b, &c); log(a, :debug, *b, &c); end
+    def info (a=nil, *b, &c); log(a, :info, *b, &c); end
+    def warn (a=nil, *b, &c); log(a, :warn, *b, &c); end
+    def error (a=nil, *b, &c); log(a, :error, *b, &c); end
+    def fatal (a=nil, *b, &c); log(a, :fatal, *b, &c); end
+    def raw (a=nil, *b, &c); log(a, nil, *b, &c); end
+
+    def log (message = nil, level = :info, &block)
+      if message
+        synchronize do
+          message = message.colorize(COLORS[level]) if level
+          puts "  " * @indent + message
+        end
+      end
+      begin
+        @indent += 1
+        block.()
+      ensure
+        @indent -= 1
+      end if block
+    end
 
-  def win (message, **keys, &block)
-    log(message, :green, **keys, &block)
   end
 
-  def log (message, color=nil, to=STDOUT, prefix: "", &block)
-    message.to_s.scan(/(?:[^\n\r]*[\n\r])|(?:[^\n\r]+$)/) do |line|
-      case line[-1]
-      when "\n", "\r"
-      else
-        line = line + "\n"
-      end
-      STDOUT.write "  " * @logdent + prefix + (color ? line.colorize(color) : line)
-    end
-    begin
-      @logdent +=1
-      block.()
-    ensure
-      @logdent -= 1
-    end if block
+  def self.log (*args, &block)
+    Logger.instance.log(*args, &block)
   end
 
 end
-end

data/lib/blower/mock_host.rb

@@ -0,0 +1,42 @@
+module Blower
+
+  class MockHost
+    extend Forwardable
+
+    attr_accessor :log
+    attr_accessor :data
+
+    def_delegators :data, :[], :[]=
+
+    def initialize (name)
+      @log = Logger.new("mock #{name.ljust(15)} | ")
+      @data = {}
+    end
+
+    def sh (command, stdout: nil, stdin: nil)
+      log.info command
+      sleep rand * 0.1
+    end
+
+    def cp (from, to, quiet: false)
+      if from.is_a?(String)
+        to += File.basename(from) if to[-1] == "/"
+        log.info "#{from} -> #{to}" unless quiet
+      elsif from.is_a?(Array)
+        to += "/" unless to[-1] == "/"
+        log.info "#{from.join(", ")} -> #{to}" unless quiet
+      elsif from.is_a?(StringIO) or from.is_a?(IO)
+        log.info "string -> #{to}" unless quiet
+      else
+        fail "Don't know how to copy a #{from.class}: #{from}"
+      end
+      sleep rand * 0.1
+    end
+
+    def each (&block)
+      block.(self)
+    end
+
+  end
+
+end

data/lib/blower/version.rb

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

data/lib/blower.rb

@@ -1,4 +1,6 @@
 require 'blower/logger'
-require 'blower/huff'
-require 'blower/puff'
+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: 0.2.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Nathan Baum
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-01 00:00:00.000000000 Z
+date: 2015-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-ssh
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
@@ -47,9 +61,11 @@ extra_rdoc_files: []
 files:
 - bin/blow
 - lib/blower.rb
-- lib/blower/huff.rb
+- lib/blower/context.rb
+- lib/blower/host.rb
+- lib/blower/host_group.rb
 - lib/blower/logger.rb
-- lib/blower/puff.rb
+- lib/blower/mock_host.rb
 - lib/blower/version.rb
 homepage: http://www.github.org/nbaum/blower
 licenses:

data/lib/blower/huff.rb

@@ -1,56 +0,0 @@
-module Blower
-class Huff
-
-  attr_accessor :hosts, :log, :puffs, :env
-
-  def initialize ()
-    @hosts = ["127.0.0.1"]
-    @log = Logger.new
-    @logdent = 0
-    @puffs = Hash.new { |h, k| h[k] = Puff.new(self, k) }
-    @env = {}
-  end
-
-  def hosts (hosts)
-    log.info "new hosts: #{hosts.join(", ")}"
-    @hosts = hosts
-  end
-
-  def ruby (task)
-    instance_eval(File.read(task), task)
-  end
-
-  def shell (task)
-    @hosts.each do |host|
-      log.info "running #{task} on #{host}" do
-        puffs[host].shell(task)
-      end
-    end
-  end
-
-  def inventory (task)
-    hosts File.read(task).split
-  end
-
-  def run (name)
-    name = name.to_s
-    task = File.exist?(name) ? name : Dir[name + ".*"].first
-    if !task
-      fail "Can't find #{name}"
-    elsif File.directory?(task)
-      Dir.chdir(task) do
-        run("main")
-      end
-    elsif task =~ /\.rb$/
-      ruby(task)
-    elsif task =~ /\.sh$/
-      shell(task)
-    elsif task =~ /\.ini$/
-      inventory(task)
-    else
-      fail "Don't know what to do with #{task}"
-    end
-  end
-
-end
-end

data/lib/blower/puff.rb

@@ -1,57 +0,0 @@
-require "net/ssh"
-require "shellwords"
-
-module Blower
-class Puff
-
-  attr_accessor :huff, :host, :log, :env
-
-  def initialize (huff, host)
-    @huff = huff
-    @log = huff.log
-    @host = host
-    @env = {}
-  end
-
-  def env2shell ()
-    huff.env.merge(@env).map do |name, value|
-      next unless name =~ /\A[A-Za-z\d_]+\z/
-      "#{name}=#{value.shellescape}"
-    end.join("\n") + "\n"
-  end
-
-  def shell (task)
-    Net::SSH.start(host, "root") do |ssh|
-      command = File.read(task)
-      status, signal = nil, nil
-      ssh.open_channel do |ch|
-        stdout, stderr = "", ""
-        ch.exec(env2shell + command) do |_, success|
-          fail "failed to execute command" unless success
-          ch.on_data do |_, data|
-            stdout << data
-            if i = stdout.rindex(/[\n\r]/)
-              data, stdout = stdout[0..i], (stdout[(i + 1)..-1] || "")
-              log.log data
-            end
-          end
-          ch.on_extended_data do |_, _, data|
-            stderr << data
-            if i = stderr.rindex(/[\n\r]/)
-              data, stderr = stderr[0..i], (stderr[(i + 1)..-1] || "")
-              log.fail data
-            end
-          end
-          ch.on_request("exit-status") { |_, data| status = data.read_long }
-          ch.on_request("exit-signal") { |_, data| signal = data.read_long }
-        end
-      end
-      ssh.loop
-      if status != 0
-        fail "exit status #{status}"
-      end
-    end
-  end
-
-end
-end