xlogin 0.14.1 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbc5c0255a1328038a84dc96b4e99c1b252c998ece79c03f7e23d22b7c5eba2d
-  data.tar.gz: a605c1f6a0bb730e3aab19c13401c902416aee1e985a34a4d3132c014bc36f43
+  metadata.gz: 547e74e0f0fa2ffc7c30a9d809e7459eea4776c7a902e7f30f1c2e109e7b9a6a
+  data.tar.gz: e810cb9efb8098ce1acd8063f7de24f63876676b03819a06a329a04e010c588c
 SHA512:
-  metadata.gz: c077a17025b8131927de93b9602bc1d8957f4545b38bf2ec58c95d460faf3320d55770c8efc65cce4796eeb11fa5d3e4d3bcd7acbd9b35b44e7beffc1da55b5e
-  data.tar.gz: 665cb8e5a6ebde87623135a31ca21d5f2e25408e31e4fc12560fa4ce6095459a686a32317c1a0dabb4eace83224b828999be069a5c84f225fa4dad9dc174a44b
+  metadata.gz: 17373511e6a0f038ca63e6c7721d45eb3e1f8ef2c8a0f02ae287a0eeb0af51bc59f302ae7aaf27ae2b0d8f6c99673426744c33a1cb052d13d3d6b63a81a130cf
+  data.tar.gz: f0258f43d91d1043c5cf55ead1e71aba4e25df7cee36c2f6f3e34b528f66c62702280bfa5802840ab985e3a03988b1f0c89da69cd50a09d27d02c2842a7eae68

data/lib/xlogin.rb

@@ -22,7 +22,7 @@ module Xlogin
 
   class << self
     def list(*patterns)
-      factory.list_inventory(*patterns)
+      factory.list_hostinfo(*patterns)
     end
 
     def find(*patterns)

data/lib/xlogin/cli.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'optparse'
 require 'parallel'
 require 'stringio'
@@ -7,21 +5,22 @@ require 'stringio'
 module Xlogin
   class CLI
 
-    DEFAULT_INVENTORY_FILE = File.join(ENV['HOME'], '.xloginrc')
-    DEFAULT_TEMPLATE_DIR   = File.join(ENV['HOME'], '.xlogin.d')
+    DEFAULT_INVENTORY = File.join(ENV['HOME'], '.xloginrc')
+    DEFAULT_TEMPLATE  = File.join(ENV['HOME'], '.xlogin.d')
 
     def self.run(args = ARGV)
       Xlogin::CLI.new.run(args)
     end
 
     def list(config)
-      puts Xlogin.list(*config[:pattern]).map{ |e| e[:name] }.sort.uniq
+      puts Xlogin.list(*config[:patterns]).map{ |e| e[:name] }.sort.uniq
     end
 
     def tty(config)
-      info = Xlogin.list(*config[:pattern]).shift
+      info = Xlogin.find(*config[:patterns])
       puts "Trying #{info[:name]}...", "Escape character is '^]'."
-      session, _ = exec(config.merge(pattern: info[:name], jobs: 1))
+
+      session, _ = exec(config.merge(patterns: info[:name], jobs: 1))
       session.interact!
     end
 
@@ -29,8 +28,9 @@ module Xlogin
       Signal.trap(:INT){ exit 0 }
 
       jobs  = config[:jobs] || 1
-      hosts = Xlogin.list(*config[:pattern])
+      hosts = Xlogin.list(*config[:patterns])
       width = hosts.map{ |e| e[:name].length }.max
+      raise "No host found: `#{config[:patterns].join(', ')}`" if hosts.empty?
 
       Parallel.map(hosts, in_threads: jobs) do |info|
         buffer  = StringIO.new
@@ -40,12 +40,12 @@ module Xlogin
         begin
           loggers  = []
           loggers << ((jobs > 1)? buffer : $stdout)
-          loggers << File.expand_path(File.join(config[:"log-dir"], "#{info[:name]}.log"), ENV['PWD']) if config[:"log-dir"]
+          loggers << File.expand_path(File.join(config[:logdir], "#{info[:name]}.log"), ENV['PWD']) if config[:logdir]
 
           session = Xlogin.get(info.merge(log: loggers))
           session.enable(session.config.enable) if session.config.enable && Xlogin.settings.enable?
 
-          command_lines = ['', *config[:exec].to_s.split(';').map(&:strip)]
+          command_lines = config[:command].flat_map { |e| e.to_s.split(';').map(&:strip) }
           command_lines.each{ |line| session.cmd(line) }
 
           buffer.string.lines.each{ |line| print prefix + line.gsub("\r", '') } if jobs > 1
@@ -60,33 +60,36 @@ module Xlogin
 
     def run(args)
       config = Hash.new
-      config[:env]       = {}
+      config[:env]       = []
+      config[:inventory] = []
+      config[:template]  = []
+      config[:command]   = []
       config[:runner]    = self.method(:tty)
-      config[:inventory] = DEFAULT_INVENTORY_FILE
-      config[:template]  = DEFAULT_TEMPLATE_DIR
 
       parser = OptionParser.new
       parser.banner  = "#{File.basename($0)} HOST_PATTERN [Options]"
       parser.version = Xlogin::VERSION
 
-      parser.on('-i PATH', '--inventory', String, 'The PATH to the inventory file.')
-      parser.on('-t PATH', '--template',  String, 'The PATH to the template file or directory.')
-      parser.on('-L PATH', '--log-dir',   String, 'The PATH to the log directory.'){ |v| v || '.' }
+      parser.on('-i PATH', '--inventory', String, 'The PATH to the inventory file.')            { |v| config[:inventory] << v }
+      parser.on('-t PATH', '--template',  String, 'The PATH to the template file or directory.'){ |v| config[:template]  << v }
+      parser.on('-L PATH', '--log-dir',   String, 'The PATH to the log directory.')             { |v| config[:logdir]     = v }
 
       parser.on('-l',         '--list',   TrueClass, 'List the inventory.')       { |v| config[:runner] = self.method(:list) }
-      parser.on('-e COMMAND', '--exec',   String,    'Execute commands and quit.'){ |v| config[:runner] = self.method(:exec); v }
+      parser.on('-e COMMAND', '--exec',   String,    'Execute commands and quit.'){ |v| config[:runner] = self.method(:exec); config[:command] << v }
 
-      parser.on('-E KEY=VAL', '--env',    /(\w+=\w+)+/, 'Environment variables.')
-      parser.on('-j NUM',     '--jobs',   Integer,      'The NUM of jobs to execute in parallel.')
+      parser.on('-E KEY=VAL', '--env',    /(\w+=\w+)+/, 'Environment variables.')                 { |v| config[:env] << v }
+      parser.on('-j NUM',     '--jobs',   Integer,      'The NUM of jobs to execute in parallel.'){ |v| config[:jobs] = v }
 
-      config[:pattern] = parser.parse!(args, into: config)
+      config[:patterns]  = parser.parse!(args)
+      config[:inventory] << DEFAULT_INVENTORY if config[:inventory].empty?
+      config[:template]  << DEFAULT_TEMPLATE  if config[:template].empty?
 
       Xlogin.configure do
-        set      Hash[config[:env].map{ |v| v.split('=') }]
-        source   File.expand_path(config[:inventory], ENV['PWD'])
-        template File.expand_path(config[:template],  ENV['PWD'])
+        set Hash[config[:env].map{ |v| v.split('=') }]
+
+        source   *config[:inventory].map{ |e| File.expand_path(e, ENV['PWD']) }
+        template *config[:template].map { |e| File.expand_path(e, ENV['PWD']) }
       end
-      raise "No host found: `#{args.join(', ')}`" if Xlogin.list(*config[:pattern]).empty?
 
       config[:runner].call(config)
     rescue => e

data/lib/xlogin/factory.rb

@@ -1,4 +1,5 @@
 require 'addressable/uri'
+require 'net/ssh/gateway'
 require 'singleton'
 require 'thread'
 require 'xlogin/session_pool'
@@ -16,15 +17,16 @@ module Xlogin
       @mutex     = Mutex.new
     end
 
-    def set_inventory(name, **opts)
-      @inventory[name] = (get_inventory(name) || {name: name}).merge(opts)
+    def set_hostinfo(name, **opts)
+      @inventory[name] = (get_hostinfo(name) || {name: name}).merge(opts)
     end
 
-    def get_inventory(name)
+    def get_hostinfo(name)
       @inventory[name]
     end
 
-    def list_inventory(*patterns)
+    def list_hostinfo(*patterns)
+      return [] if patterns == [nil]
       return @inventory.values if patterns.empty?
 
       values1 = patterns.map do |pattern|
@@ -94,31 +96,25 @@ module Xlogin
     end
 
     def build_from_hostname(args, **opts)
-      hostinfo = get_inventory(args)
+      hostinfo = get_hostinfo(args)
       raise Xlogin::Error.new("Host not found: '#{args}'") unless hostinfo
 
-      build(hostinfo.merge(name: args, **opts))
+      build(**hostinfo.merge(**opts))
     end
 
     def method_missing(method_name, *args, **opts, &block)
-      super unless args.size == 2 && %r{^\S+://\S+} =~ args[1]
+      super unless args.size == 2 && Addressable::URI::URIREGEX =~ args[1]
 
-      type = method_name.to_s.downcase
       name = args[0]
       uri  = args[1]
-      set_inventory(name, type: type, uri: uri, **opts)
+      type = method_name.to_s.downcase
+      set_hostinfo(name.to_s, type: type, uri: uri, **opts)
     end
 
     private
     def uri(**opts)
       return Addressable::URI.parse(opts[:uri].strip) if opts.key?(:uri)
-
-      scheme   = opts[:scheme].strip
-      address  = opts.values_at(:host, :port).compact.map(&:strip).join(':')
-      userinfo = opts[:userinfo].strip
-      userinfo ||= opts.values_at(:username, :password).compact.map(&:strip).join(':')
-
-      Addressable::URI.parse("#{scheme}://" + [userinfo, address].compact.join('@'))
+      Addressable::URI.new(**opts)
     rescue
       raise Xlogin::Error.new("Invalid target - '#{opts}'")
     end

data/lib/xlogin/rake_task.rb

@@ -1,7 +1,6 @@
 require 'time'
 require 'rake'
 require 'rake/tasklib'
-require 'ostruct'
 require 'stringio'
 require 'colorize'
 
@@ -17,7 +16,7 @@ module Xlogin
 
         task 'all' => hostnames unless opts[:all] == false
         hostnames.each do |hostname|
-          desc "#{description} @#{hostname}" if opts[:all] == false
+          desc "#{description} with #{hostname}"
           RakeTask.new(hostname, &block)
         end
       end
@@ -32,8 +31,8 @@ module Xlogin
     end
 
     attr_reader   :name
-    attr_accessor :lock
     attr_accessor :log
+    attr_accessor :lock
     attr_accessor :timeout
     attr_accessor :silent
     attr_accessor :fail_on_error
@@ -49,8 +48,8 @@ module Xlogin
       define
     end
 
-    def name_with_scope
-      [*Rake.application.current_scope.to_a.reverse, name].join(':')
+    def name_with_scope(separator = ':')
+      [*Rake.application.current_scope.to_a.reverse, name].join(separator)
     end
 
     def run(&block)
@@ -78,47 +77,41 @@ module Xlogin
     end
 
     def run_task
-      buffer = StringIO.new
-
-      logger = log ? [log] : []
-      logger.push buffer
-      logger.push $stdout if !silent && !Rake.application.options.always_multitask
+      buffer  = StringIO.new
+      loggers = []
+      loggers << log     if log
+      loggers << $stdout if !silent && !Rake.application.options.always_multitask
+      loggers << buffer
 
-      session = Xlogin.get(name, log: logger, timeout: timeout)
+      session = Xlogin.get(name, log: loggers, timeout: timeout)
 
       @runner.call(session)
-      $stdout.print format_log(buffer.string) if !silent && Rake.application.options.always_multitask
+      $stdout.print log_text(buffer.string) if !silent && Rake.application.options.always_multitask
 
       return true
     rescue => e
       RakeTask.shutdown! if fail_on_error
 
-      buffer.puts("\n[ERROR] #{e}".colorize(color: :white, background: :red))
-      $stderr.print "\n" + format_log(buffer.string.chomp).colorize(color: :light_red)
-      $stderr.print "\n"
+      session.comment(e.to_s, prefix: "[ERROR]", chomp: true, color: :white, background: :red)
+      $stderr.print log_text(buffer.string + "\n").colorize(color: :light_red) if Rake.application.options.always_multitask
 
       return false
     ensure
       session.close rescue nil
     end
 
-    def format_log(text)
-      text.lines.map do |line|
-        "#{Time.now.iso8601} - #{name}\t|#{line.gsub(/^\s*[\r]+/, '')}"
-      end.join
+    def log_text(text)
+      text.lines.map{ |line| "#{Time.now.iso8601} - #{name}\t|#{line.gsub(/^\s*[\r]+/, '')}" }.join
     end
 
   end
 
   module SessionModule
-    def log_message(text, prefix: "[INFO]", chomp: false, **color)
-      default_color = { color: :green }
 
-      log("\n")
-      log(Time.now.iso8601.colorize(**color) + ' ') if !Rake.application.options.always_multitask
-
-      log("#{prefix} #{text}".colorize(**default_color.merge(color)))
+    def comment(line, prefix: "[INFO]", chomp: false, **color)
+      write_log("#{prefix} #{line}".colorize(**color))
       cmd('') unless chomp
     end
+
   end
 end

data/lib/xlogin/session.rb

@@ -1,8 +1,4 @@
-require 'addressable/uri'
-require 'delegate'
 require 'fileutils'
-require 'net/ssh/gateway'
-require 'ostruct'
 require 'stringio'
 require 'thread'
 
@@ -25,13 +21,11 @@ module Xlogin
       @tunnel   = opts[:tunnel] || opts[:via]
       @config   = ReadOnlyStruct.new(opts)
       @template = template
-      @username, @password = uri.userinfo.to_s.split(':')
-
-      max_retry = @config.retry || 1
+      @loggers  = [@config.log].flatten.uniq.reduce({}){ |a, e| a.merge(e => build_log(e)) }
       @host, @port = Xlogin.factory.open_tunnel(@tunnel, @host, @port) if @tunnel
 
-      @mutex   = Mutex.new
-      @loggers = [@config.log].flatten.uniq.reduce({}){ |a, e| a.merge(e => build_logger(e)) }
+      max_retry = @config.retry || 1
+      username, password = uri.userinfo.to_s.split(':')
 
       begin
         args = Hash.new
@@ -43,8 +37,8 @@ module Xlogin
         else
           args['Host'    ] = @host
           args['Port'    ] = @port
-          args['Username'] = @username
-          args['Password'] = @password
+          args['Username'] = username
+          args['Password'] = password
         end
 
         super(args)
@@ -64,43 +58,54 @@ module Xlogin
     end
 
     def prompt_pattern
-      Regexp.union(*@template.prompt.map(&:first))
+      Regexp.union(*@template.prompts.map(&:first))
     end
 
     def duplicate(type: @template.name, **args)
       template = Xlogin::Factory.instance.get_template(type)
+      raise Xlogin::Error.new("Template not found: '#{type}'") unless template
+
       template.build(@uri, **@config.to_h.merge(args))
     end
 
-    def puts(*args, &block)
-      args = args.flat_map{ |arg| instance_exec(arg, &@template.interrupt!) }.compact if @template.interrupt!
-      args.empty? ? super('', &block) : super(*args, &block)
+    def puts(string = '', &block)
+      super(string, &block)
     end
 
-    def waitfor(*args, &block)
-      args = [prompt_pattern] if args.empty?
-      @mutex.synchronize{ _waitfor(*args, &block) }
+    def print(string = '', &block)
+      string = instance_exec(string, &@template.interrupt!) if @template.interrupt!
+      super(string, &block)
     end
 
-    def close
-      logout if respond_to?(:logout)
-      @mutex.synchronize do
-        @loggers.each do |_, logger|
-          next if logger.nil? || [$stdout, $stderr].include?(logger)
-          logger.close
-        end
+    def waitfor(*args, &block)
+      return waitfor(prompt_pattern) if args.empty?
 
-        Xlogin.factory.close_tunnel(@tunnel, @port) if @tunnel
-        super
+      line = super(*args) do |recv|
+        write_log(recv)
+        block.call(recv) if block
       end
+
+      _, process = @template.prompts.find{ |r, p| r =~ line && p }
+      if process
+        instance_eval(&process)
+        line += waitfor(*args, &block)
+      end
+
+      return line
     end
 
-    def log(text)
-      @loggers.each{ |_, logger| logger.syswrite(text) if logger }
+    def close
+      @loggers.each do |_, logger|
+        next if [$stdout, $stderr, nil].include?(logger)
+        logger.close
+      end
+
+      Xlogin.factory.close_tunnel(@tunnel, @port) if @tunnel
+      super
     end
 
     def enable_log(log = $stdout)
-      @loggers.update(log => build_logger(log))
+      @loggers.update(log => build_log(log))
       if block_given?
         yield
         disable_log(log)
@@ -116,23 +121,11 @@ module Xlogin
     end
 
     private
-    def _waitfor(*args, &block)
-      __waitfor = method(:waitfor).super_method
-      line = __waitfor.call(*args) do |recv|
-        log(recv)
-        block.call(recv) if block
-      end
-
-      _, process = @template.prompt.find{ |r, p| r =~ line && p }
-      if process
-        instance_eval(&process)
-        line += _waitfor(*args, &block)
-      end
-
-      return line
+    def write_log(text)
+      @loggers.each{ |_, logger| logger.syswrite(text) if logger }
     end
 
-    def build_logger(log)
+    def build_log(log)
       case log
       when String
         FileUtils.mkdir_p(File.dirname(log))

data/lib/xlogin/session_pool.rb

@@ -37,8 +37,8 @@ module Xlogin
     end
 
     def close
-      while @queue.empty?
-        session, _, _ = @queue.deq
+      until @queue.empty?
+        session, _ = @queue.deq
         destroy(session)
       end
     end
@@ -58,10 +58,10 @@ module Xlogin
       end
 
       begin
-        raise IOError if session.sock.closed?
+        raise IOError if session&.sock&.closed?
       rescue IOError, EOFError, Errno::ECONNABORTED, Errno::ECONNREFUSED, Errno::ECONNRESET
         destroy(session)
-        session = deq
+        return deq
       end
 
       session

data/lib/xlogin/spec.rb

@@ -2,7 +2,7 @@ module Xlogin
   class ExpectationError < StandardError
 
     def initialize(expect, actual)
-      super("Expected to match #{expect}")
+      super(expect)
       @actual = actual
     end
 
@@ -14,28 +14,22 @@ module Xlogin
 
   class Expectation
 
-    def initialize(session, *args)
-      @session = session
-      @args = args
+    def initialize(result)
+      @result = result
     end
 
     def to_match(regexp)
-      return if match(regexp)
-      raise ExpectationError.new(@expect, @actual)
-    end
+      regexp = Regexp.new(regexp.to_s) unless regexp.kind_of?(Regexp)
+      return if @result =~ regexp
 
-    def not_to_match(regexp)
-      return unless match(regexp)
-      raise ExpectationError.new(@expect, @actual)
+      raise ExpectationError.new("Expected to match #{regexp}", @result)
     end
 
-    private
-    def match(regexp)
-      regexp  = Regexp.new(regexp.to_s) unless regexp.kind_of?(Regexp)
-      @expect = regexp.inspect
+    def not_to_match(regexp)
+      regexp = Regexp.new(regexp.to_s) unless regexp.kind_of?(Regexp)
+      return if @result !~ regexp
 
-      @actual ||= @session.cmd(*@args)
-      @actual =~ regexp
+      raise ExpectationError.new("Expected not to match #{regexp}", @result)
     end
 
   end
@@ -43,9 +37,8 @@ module Xlogin
   module SessionModule
 
     def expect(*args)
-      Expectation.new(self, *args)
+      Expectation.new(cmd(*args))
     end
-    alias_method :exp, :expect
 
   end
 end

data/lib/xlogin/template.rb

@@ -8,54 +8,44 @@ module Xlogin
     DEFAULT_PROMPT   = /[$%#>] ?\z/n
     RESERVED_METHODS = %i( login logout enable disable )
 
-    attr_reader :name, :scopes, :methods
+    attr_reader :name, :methods
 
     def initialize(name)
       @name    = name
-      @scopes  = Hash.new
-      @timeout = DEFAULT_TIMEOUT
       @prompts = Array.new
       @methods = Hash.new
+      @timeout = DEFAULT_TIMEOUT
       @interrupt = nil
     end
 
-    def timeout(val = nil)
-      @timeout = val.to_i if val
-      @timeout
+    def prompt(expect, &block)
+      @prompts << [Regexp.new(expect.to_s), block]
     end
 
-    def prompt(expect = nil, &block)
-      return [[DEFAULT_PROMPT, nil]] if expect.nil? && @prompts.empty?
-      @prompts << [Regexp.new(expect.to_s), block] if expect
+    def prompts
+      @prompts << [DEFAULT_PROMPT, nil] if @prompts.empty?
       @prompts
     end
 
-    def scope(name = nil, &block)
-      @scopes[name] = block
+    def bind(name, &block)
+      @methods[name] = block
     end
 
-    def bind(name = nil, &block)
-      @methods[name] = block
+    def timeout(val = nil)
+      @timeout = val.to_i if val
+      @timeout
     end
 
     def interrupt!(&block)
-      return @interrupt unless block
-      @interrupt = block
+      @interrupt = block if block
+      @interrupt
     end
 
     def build(uri, **opts)
       klass = Class.new(Xlogin.const_get(uri.scheme.capitalize))
       klass.class_exec(self) do |template|
-        scopes = [*opts[:scope]].compact
-        scopes.each{ |scope| template.instance_eval(&template.scopes[scope]) }
-
         template.methods.each do |name, block|
-          case name.to_s
-          when 'enable'
-            define_method(name){ |args = nil| instance_exec(args || opts[:enable], &block) }
-          else
-            define_method(name, &block)
-          end
+          define_method(name, &block)
         end
       end
 

data/lib/xlogin/version.rb

@@ -1,3 +1,3 @@
 module Xlogin
-	VERSION = "0.14.1"
+	VERSION = "0.14.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xlogin
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.2
 platform: ruby
 authors:
 - haccht
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-27 00:00:00.000000000 Z
+date: 2020-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-telnet