xlogin 0.5.14 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e757e206fe886bf5b5f4ed56e8b7a47cf6837c9
-  data.tar.gz: 43ea824dfd4a8131b795b81bc1fd342de46155e9
+  metadata.gz: 07769f0169bc78d592d032d9e1fead22b33f486a
+  data.tar.gz: 701a5526bd5592fc5018970a4854c75e9f100333
 SHA512:
-  metadata.gz: 235201b50907672f266709c6036802d3c3fbbdfa96436f4eb0ee24b40268bb273ceba8ac77598c3bbf01faa242ae12fc889524bc658edefb1c3968f5933a3e4f
-  data.tar.gz: 4851153be8d9c4208daf7283e35646f1d557830a2bb82540d031ce479589d6f56040035d43ad62e206c26df9c50bbab9bb9ea46cdc1160c266eeab8120c64791
+  metadata.gz: 867923f469e68e5ddaf5dd7b657f0331094cedccbc1040d452d83ea96da7aef1b643916d543f1ae68a71e825ad390e1d27d559b281be1d1579f23d94dd418516
+  data.tar.gz: ff5c63bca0182e256274611bcb62d026c9a41b997d4157ad98bbe0eba75a24857b621dc749aac9bb4b6c75797e95fa8eb5ed644640c1bb074587a0ab807ea577

data/bin/xlogin

@@ -1,12 +1,5 @@
 #! /usr/bin/env ruby
 
-appdir = File.dirname(File.symlink?(__FILE__)? File.readlink(__FILE__) : __FILE__)
-
-require 'bundler'
-ENV['BUNDLE_GEMFILE'] = File.join(appdir, '..', 'Gemfile')
-
-Bundler.require
-
 require 'xlogin'
 require 'xlogin/cli'
 

data/lib/xlogin.rb

@@ -1,62 +1,62 @@
 $:.unshift File.dirname(__FILE__)
 
-require 'xlogin/firmware'
-require 'xlogin/firmware_factory'
+require 'xlogin/factory'
 require 'xlogin/version'
 
 module Xlogin
 
-  DEFAULT_SOURCE_FILE    = File.join(ENV['HOME'], '.xloginrc')
+  DEFAULT_INVENTORY_FILE = File.join(ENV['HOME'], '.xloginrc')
   DEFAULT_TEMPLATE_DIR   = File.join(ENV['HOME'], '.xlogin.d')
   BUILTIN_TEMPLATE_FILES = Dir.glob(File.join(File.dirname(__FILE__), 'xlogin', 'templates', '*.rb'))
 
-  class HostNotFound       < StandardError; end
+  class SessionNotFound    < StandardError; end
   class TemplateNotFound   < StandardError; end
   class AuthorizationError < StandardError; end
 
   class << self
 
-    def authorize(boolean = false, &block)
-      @authorized = boolean == true || (block && block.call == true)
+    def factory
+      @factory ||= Xlogin::Factory.instance
     end
 
-    def authorized?
-      @authorized == true
-    end
+    def get(hostname, args = {})
+      session = factory.build_from_hostname(hostname, args)
 
-    def factory
-      @factory ||= Xlogin::FirmwareFactory.instance
+      if block_given?
+        begin yield session ensure session.close end
+      else
+        session
+      end
     end
 
-    def init(&block)
-      instance_eval(&block)
+    def configure(&block)
+      instance_eval(&block) if block
 
-      factory.source(DEFAULT_SOURCE_FILE) if factory.list.empty?
+      source(DEFAULT_INVENTORY_FILE) if factory.list.empty?
       if factory.list_templates.empty?
-        unless File.exist?(DEFAULT_TEMPLATE_DIR)
+        unless Dir.exist?(DEFAULT_TEMPLATE_DIR)
           FileUtils.mkdir_p(DEFAULT_TEMPLATE_DIR)
           Xlogin::BUILTIN_TEMPLATE_FILES.each { |file| FileUtils.cp(file, DEFAULT_TEMPLATE_DIR) }
         end
-        factory.load_template_files(*Dir.glob(File.join(DEFAULT_TEMPLATE_DIR, '*.rb')))
+        template_dir(DEFAULT_TEMPLATE_DIR)
       end
     end
 
-    def source(source_file)
-      factory.source(source_file)
+    def authorized?
+      @authorized == true
     end
 
-    def template(*template_files)
-      factory.load_template_files(*template_files)
+    private
+    def authorize(boolean = false, &block)
+      @authorized = boolean == true || (block && block.call == true)
     end
 
-    def get(hostname, args = {})
-      session = factory.build_from_hostname(hostname, args)
+    def source(source_file)
+      factory.source(source_file)
+    end
 
-      if block_given?
-        begin yield session ensure session.close end
-      else
-        session
-      end
+    def template(*template_files)
+      factory.set_template(*template_files)
     end
 
     def template_dir(*template_dirs)
@@ -65,12 +65,6 @@ module Xlogin
       end
     end
 
-    def configure(name)
-      template = factory.get_template(name) || Xlogin::Firmware.new
-      yield template if block_given?
-      factory.set_template(name, template)
-    end
-
   end
 
 end

data/lib/xlogin/cli.rb

@@ -1,12 +1,9 @@
 #! /usr/bin/env ruby
 
-require 'fileutils'
 require 'optparse'
 require 'ostruct'
 require 'parallel'
-require 'readline'
 require 'stringio'
-require 'thread'
 
 module Xlogin
   class CLI
@@ -14,21 +11,29 @@ module Xlogin
     DEFAULT_INVENTORY_PATH = File.join(ENV['HOME'], '.xloginrc')
     DEFAULT_TEMPLATE_DIR   = File.join(ENV['HOME'], '.xlogin.d')
 
+    def self.run(args = ARGV)
+      config = getopts(args)
+      client = Xlogin::CLI.new
+
+      task = config.task.downcase.tr('-', '_')
+      Xlogin::CLI.usage("Task not defined - #{task}") unless client.respond_to?(task)
+      client.method(task).call(config)
+    end
+
     def self.getopts(args)
       config = OpenStruct.new(
-        func: 'tty',
+        task: 'tty',
         inventory: DEFAULT_INVENTORY_PATH,
         parallels: 5,
         templates: [],
-        hostexprs: [],
         hostlist:  [],
       )
 
       parser = OptionParser.new
       parser.banner += ' HOST-PATTERN'
 
-      parser.on('-f FUNCTION',  '--func', String, 'Execute the FUNCTION (default: tty).')   { |v| config.func = v }
-      parser.on('-a ARGUMENTS', '--args', String, 'The ARGUMENTS to pass to the function.') { |v| config.args = v }
+      parser.on('-m TASK', '--task', String, 'Execute the TASK(default: tty).') { |v| config.task = v }
+      parser.on('-a ARGS', '--args', String, 'The ARGS to pass to the task.')   { |v| config.args = v }
 
       parser.on('-i PATH',      '--inventory',    String, 'The PATH to the inventory file (default: $HOME/.xloginrc).') { |v| config.inventory = v }
       parser.on('-t PATH',      '--template',     String, 'The PATH to the template file.')       { |v| config.templates << v }
@@ -36,66 +41,48 @@ module Xlogin
       parser.on('-l [DIRECTORY]', '--log',        String, 'The DIRECTORY to the output log file (default: $PWD/log).') { |v| config.logdir = v || Dir.pwd }
 
       parser.on('-p NUM', '--parallels',  Integer,   'The NUM of the threads. (default: 5).') { |v| config.parallels  = v }
-      parser.on('-e',     '--enable',     TrueClass, 'Try to gain enable priviledge.')        { |v| config.autoenable = v }
+      parser.on('-e',     '--enable',     TrueClass, 'Try to gain enable priviledge.')        { |v| config.enable = v }
       parser.on('-y',     '--assume-yes', TrueClass, 'Always answer "yes" if confirmed.')     { |v| config.assume_yes = v }
       parser.on('-h',     '--help', 'Show this message.') { Xlogin::CLI.usage }
 
       self.class.module_eval do
         define_method(:usage) do |message = nil|
-          puts message, '' if message
+          puts message if message
           puts parser.to_s
           exit 1
         end
       end
 
-      config.hostexprs = parser.parse(args)
-      config.templates = Dir.glob(File.join(DEFAULT_TEMPLATE_DIR, '*.rb')) if config.templates.empty?
-
-      Xlogin.init do
+      config.templates += Dir.glob(File.join(DEFAULT_TEMPLATE_DIR, '*.rb')) if config.templates.empty?
+      Xlogin.configure do
         source(config.inventory)
         template(*config.templates)
         authorize(config.assume_yes)
       end
 
-      factory = Xlogin::FirmwareFactory.instance
-      config.hostlist += config.hostexprs.flat_map { |expr| factory.list(expr) }
-      config
-    end
-
-    def self.run(args = ARGV)
-      config = getopts(args)
-      client = Xlogin::CLI.new
-      func   = config.func.gsub(/([a-z\d])([A-Z])/, '\1_\2').gsub(/[-_]+/, '_').downcase
-
-      Xlogin::CLI.usage("Function not found - #{config.func}") unless client.respond_to?(func)
-      client.method(func).call(config)
-    end
-
-    def list(config)
-      if config.hostexprs.empty?
-        factory = Xlogin::FirmwareFactory.instance
-        config.hostlist = factory.list
+      config.hostlist += parser.parse(args).flat_map do |target|
+        hostlist = Xlogin.factory.list(target)
+        hostlist.tap { |e| raise "Invalid inventory - #{target}" if e.empty? }
       end
 
-      length = config.hostlist.map { |e| e[:name].length }.max
-      matrix = config.hostlist.map { |e| "#{e[:name].to_s.ljust(length)} #{e[:type]}" }.sort
-      puts matrix
+      config.parallels = [config.parallels, config.hostlist.size].min
+      config
     end
 
     def tty(config)
-      Xlogin::CLI.usage('Invalid parametors: ' + config.hostexprs.join(' ')) if config.hostlist.empty?
+      config.hostlist = [config.hostlist.shift].compact
+      Xlogin::CLI.usage('Invalid inventory.') if config.hostlist.empty?
 
       puts "Trying #{config.hostlist.first[:name]}..."
       puts "Escape character is '^]'."
 
-      config.hostlist = [config.hostlist.shift]
       login(config) do |session|
         session.interact!
       end
     end
 
-    def command(config)
-      Xlogin::CLI.usage('Invalid parametors') if config.hostlist.empty? or config.args.nil?
+    def exec(config)
+      Xlogin::CLI.usage('Invalid inventory.') if config.hostlist.empty?
 
       login(config) do |session|
         command_lines = ['', *config.args.split(';')]
@@ -103,8 +90,8 @@ module Xlogin
       end
     end
 
-    def command_load(config)
-      Xlogin::CLI.usage('Invalid parametors') if config.hostlist.empty? or config.args.nil?
+    def load(config)
+      Xlogin::CLI.usage('Invalid inventory.') if config.hostlist.empty?
 
       login(config) do |session|
         command_lines = ['', *IO.readlines(config.args.to_s)]
@@ -112,39 +99,38 @@ module Xlogin
       end
     end
 
+    def list(config)
+      config.hostlist += Xlogin.factory.list('all') if config.hostlist.empty?
+      width = config.hostlist.map { |e| e[:name].length }.max
+      puts config.hostlist.map { |e| "#{e[:name].to_s.ljust(width)} #{e[:type]}" }.sort
+    end
+
     private
     def login(config, &block)
-      FileUtils.mkdir_p(config.logdir) if config.logdir
-      config.parallels = [config.parallels, config.hostlist.size].min
+      display = Mutex.new
+      buffer  = StringIO.new
 
-      display  = Mutex.new
-      Parallel.map(config.hostlist, in_thread: config.parallels) do |host|
+      Parallel.map(config.hostlist, in_thread: config.parallels) do |hostinfo|
         begin
-          hostname = host[:name]
-          buffer   = StringIO.new
+          hostname = hostinfo[:name]
 
           loggers  = []
           loggers << buffer  if config.parallels != 1
           loggers << $stdout if config.parallels == 1
           loggers << File.join(config.logdir, "#{hostname}.log") if config.logdir
 
-          session = Xlogin.get(hostname, log: loggers)
-          session.enable(session.enable_password) if config.autoenable && session.respond_to?(:enable)
-          block.call(session)
-
-          if config.parallels > 1
-            output = buffer.string.lines.map { |line| "#{hostname}: #{line}" }.join
-            display.synchronize { $stdout.puts output }
-          end
+          session = Xlogin.factory.build(hostinfo.merge(log: loggers))
+          session.enable(session.opts.enable) if config.enable && session.respond_to?(:enable)
 
+          block.call(session)
         rescue => e
-          if config.parallels > 1
-            output = "\n#{hostname}: [Error] #{e}"
-            display.synchronize { $stderr.puts output }
-          else
-            output = "\n[Error] #{e}"
-            display.synchronize { $stderr.puts output }
-          end
+          lines = (config.parallels > 1)? "\n#{hostname}\t[Error] #{e}" : "\n[Error] #{e}"
+          display.synchronize { $stderr.puts lines }
+        end
+
+        if config.parallels > 1
+          lines = buffer.string.lines.map { |line| "#{hostname}\t" + line.gsub("\r", '') }
+          display.synchronize { $stdout.puts lines }
         end
       end
     end

data/lib/xlogin/delegator.rb

@@ -1,61 +1,53 @@
 require 'uri'
 
 module Xlogin
-  class Firmware
-
-    module FirmwareDelegator
-      def run(uri, opts = {})
-        uri = URI(uri.to_s)
-
-        if hostname = opts.delete(:delegate)
-          target = Xlogin.factory.get(hostname)
-          target_os  = Xlogin.factory.get_template(target[:type])
-          target_uri = URI(target[:uri])
-
-          login    = @methods.fetch(:login)
-          delegate = @methods.fetch(:delegate)
-
-          userinfo = uri.userinfo.dup
-          uri.userinfo = ''
-
-          session = target_os.run(uri, opts)
-          session.instance_exec(*userinfo.split(':'), &login)
-          session.instance_exec(target_uri, opts, &delegate)
-          session
-        else
-          session = super(uri, opts)
-        end
+  class Template
+
+    module RelayTemplate
+      def build(uri, **params) 
+        login_host = params.delete(:relay)
+        return super(uri, **params) unless login_host
+
+        login_info = Xlogin.factory.get(login_host)
+        login_os   = Xlogin.factory.get_template(login_info[:type])
+        login_uri  = URI(login_info[:uri])
+
+        login    = @methods.fetch(:login)
+        delegate = @methods.fetch(:delegate)
+
+        relay_uri = URI(uri.to_s)
+        userinfo_cache = relay_uri.userinfo.dup
+        relay_uri.userinfo = ''
+
+        session = login_os.build(relay_uri, **params)
+        session.instance_exec(*userinfo_cache.split(':'), &login)
+        session.instance_exec(login_uri, **params, &delegate)
+        session
       end
     end
 
-    prepend FirmwareDelegator
+    prepend RelayTemplate
+
 
     ### Usage:
     ## Write xloginrc file
     #
-    # vyos       'vyos01',          'telnet://user:pass@host:port'
-    # consolesrv 'vyos01::console', 'telnet://console_user:console_pass@console_host:console_port', delegate: 'vyos01'
+    # vyos      'vyos01',        'telnet://user:pass@host:port'
+    # relay_srv 'vyos01::relay', 'telnet://relay_user:relay_pass@relay_host:relay_port', relay: 'vyos01'
     #
     ## Write firmware definition
     #
     # require 'timeout'
-    # Xlogin.configure :consolesrv do |os|
-    #   os.bind(:login) do |*args|
-    #    username, password = *args
-    #    waitfor(/login:\s*\z/)    && puts(username)
-    #    waitfor(/Password:\s*\z/) && puts(password)
-    #  end
+    # login do |*args|
+    #   username, password = *args
+    #   waitfor(/login:\s*\z/)    && puts(username)
+    #   waitfor(/Password:\s*\z/) && puts(password)
+    # end
     #
-    #  os.bind(:delegate) do |uri, opts|
-    #    begin
-    #      waittime = 3
-    #      Timeout.timeout(waittime) do
-    #        login(*uri.userinfo.split(':'))
-    #      end
-    #    rescue Timeout::Error
-    #    end
-    #  end
-    #end
+    # delegate do |uri, opts|
+    #   cmd("telnet #{uri.host}")
+    #   login(*uri.userinfo.split(':'))
+    # end
 
   end
 end

data/lib/xlogin/{firmware_factory.rb → factory.rb}

@@ -1,10 +1,8 @@
-require 'uri'
 require 'singleton'
-require 'stringio'
-require 'xlogin/firmware'
+require 'xlogin/template'
 
 module Xlogin
-  class FirmwareFactory
+  class Factory
 
     include Singleton
 
@@ -14,40 +12,18 @@ module Xlogin
       @group     = nil
     end
 
-    def load_template_files(*files)
-      files.each do |file|
-        file = File.expand_path(file)
-        next unless File.exist?(file) && file =~ /.rb$/
-
-        name = File.basename(file, '.rb').scan(/\w+/).join.downcase
-        Xlogin.configure(name) { |firmware| firmware.instance_eval(IO.read(file)) }
-      end
-    end
-
-    def get_template(name)
-      @templates[name.to_s.downcase]
-    end
-
-    def set_template(name, template)
-      @templates[name.to_s.downcase] = template
-    end
-
-    def list_templates
-      @templates.keys
-    end
-
     def source(file)
       file = File.expand_path(file)
-      return unless File.exist?(file)
-      instance_eval(IO.read(file))
+      instance_eval(IO.read(file)) if File.exist?(file)
     end
 
     def get(name)
       @database[name]
     end
 
-    def set(**opts)
-      @database[opts[:name]] = opts
+    def set(**params)
+      name = params[:name]
+      @database[name] = params if name
     end
 
     def list(name = nil)
@@ -56,34 +32,50 @@ module Xlogin
       @database.values_at(*keys)
     end
 
+    def get_template(name)
+      @templates[name.to_s.downcase] ||= Xlogin::Template.new
+    end
+
+    def set_template(*files)
+      files.each do |file|
+        file = File.expand_path(file)
+        next unless File.exist?(file) && file =~ /.rb$/
+
+        name = File.basename(file, '.rb').scan(/\w+/).join('_')
+        template = get_template(name)
+        template.instance_eval(IO.read(file))
+        @templates[name.to_s.downcase] = template
+      end
+    end
+
+    def list_templates
+      @templates.keys
+    end
+
     def group(group_name)
       current_group = @group
-      @group = [current_group, group_name].compact.join(':')
+      @group = [current_group, group_name.to_s].compact.join(':')
       yield
       @group = current_group
     end
 
-    def build(args)
-      type = args.delete(:type)
+    def build(type:, uri:, **params)
       template = get_template(type)
-      raise Xlogin::TemplateNotFound.new("template not found: '#{type}'") unless template
-
-      uri  = args.delete(:uri)
-      opts = args.reduce({}) { |a, (k, v)| a.merge(k.to_s.downcase.to_sym => v) }
-      raise Xlogin::HostNotFound.new("connection not defined: '#{arg}'") unless uri
+      raise Xlogin::SessionNotFound.new("Target not defined") unless uri
+      raise Xlogin::TemplateNotFound.new("Template not found: '#{type}'") unless template
 
-      template.dup.run(uri, opts)
+      template.build(uri, **params)
     end
 
-    def build_from_hostname(hostname, **args)
+    def build_from_hostname(hostname, **params)
       hostinfo = get(hostname)
-      raise Xlogin::HostNotFound.new("host not found: '#{hostname}'") unless hostinfo
+      raise Xlogin::SessionNotFound.new("Host not found: '#{hostname}'") unless hostinfo
 
-      build(hostinfo.merge(args))
+      build(hostinfo.merge(**params))
     end
 
     def method_missing(method_name, *args, &block)
-      super unless caller_locations.first.label =~ /source/ and args.size >= 2
+      super unless caller_locations.first.label == 'source' and args.size >= 2
 
       type = method_name.to_s.downcase
       name = [@group, args.shift].compact.join(':')

data/lib/xlogin/rake_task.rb

@@ -2,6 +2,7 @@ require 'rake'
 require 'rake/tasklib'
 require 'readline'
 require 'thread'
+require 'stringio'
 
 module Xlogin
   class RakeTask < Rake::TaskLib
@@ -9,167 +10,95 @@ module Xlogin
     class << self
       include Rake::DSL
 
-      def mutex
-        @mutex ||= Mutex.new
-      end
-
-      def load(file, &block)
-        Xlogin.factory.source(file)
-        hostnames = Xlogin.factory.list.map { |e| e[:name] }
-        bulk(hostnames, &block)
-      end
-
       def bulk(names, &block)
-        names = names.map(&:strip).grep(/^\s*[^#]/)
-        namecount = names.uniq.inject({}) { |a, e| a.merge(e => names.count(e)) }
-        duplicate = namecount.keys.select { |name| namecount[name] > 1 }
-        raise ArgumentError.new("Duplicate hosts found - #{duplicate.join(', ')}") unless duplicate.empty?
-
-        current_namespace do
-          description = Rake.application.last_description || "Run '#{RakeTask.current_namespace}'"
+        current_namespace do |path|
+          description = Rake.application.last_description
 
+          names = names.map(&:strip).grep(/^\s*[^#]/).uniq
           names.each do |name|
-            desc "#{description} (#{name})"
+            desc description || "Run '#{path}:#{name}'"
             RakeTask.new(name, &block)
           end
         end
       end
 
       def current_namespace
-        path = Rake.application.current_scope.path
-
-        if path.empty?
-          path = self.name.split('::').first.downcase
-          namespace(path) { yield } if block_given?
-        else
-          yield if block_given?
+        Rake.application.current_scope.path.tap do |path|
+          if path.empty?
+            path = self.name.split('::').first.downcase
+            namespace(path) { yield(path) } if block_given?
+          else
+            yield(path) if block_given?
+          end
         end
-
-        path
       end
     end
 
 
     attr_reader   :name
-    attr_accessor :xlogin_opts
-    attr_accessor :fail_on_error
+    attr_accessor :lock
+    attr_accessor :log
     attr_accessor :silent
-    attr_accessor :lockfile
-    attr_accessor :logfile
-    attr_accessor :uncomment
 
     def initialize(name)
-      @name          = name
-      @xlogin_opts   = Xlogin.factory.get(name) || {}
-      @session       = nil
-      @taskrunner    = nil
-
-      @fail_on_error = true
-      @silent        = Rake.application.options.silent
-      @lockfile      = nil
-      @logfile       = nil
-      @uncomment     = false
+      @name   = name
+      @runner = nil
+      @silent ||= Rake.application.options.silent
 
       yield(self) if block_given?
-      define
+      define_task
     end
 
     def start(&block)
-      @taskrunner = block
-    end
-
-    def safe_puts(*messages, **opts)
-      opts[:io] ||= $stdout
-      return if @silent && !opts[:force]
-      RakeTask.mutex.synchronize do
-        messages.flat_map { |message| message.to_s.lines }.each do |line|
-          line.gsub!("\r", "")
-          opts[:io].puts (Rake.application.options.always_multitask)? "#{name}\t#{line}" : line
-        end
-      end
+      @runner = block
     end
 
     private
-    def define
-      RakeTask.current_namespace do
-        desc Rake.application.last_description || "Run '#{RakeTask.current_namespace}'"
-        Rake.application.last_description = nil if uncomment
-
-        if lockfile
-          task(name => lockfile)
-          file(lockfile) do
-            run_task
-
-            mkdir_p(File.dirname(lockfile), verbose: Rake.application.options.trace)
-            touch(lockfile, verbose: Rake.application.options.trace)
+    def define_task
+      RakeTask.current_namespace do |path|
+        desc Rake.application.last_description || "Run '#{path}:#{name}'"
+
+        if lock
+          task(name => lock)
+          file(lock) do
+            invoke
+            mkdir_p(File.dirname(lock), verbose: Rake.application.options.trace)
+            touch(lock, verbose: Rake.application.options.trace)
           end
         else
-          task(name) do
-            run_task
-          end
+          task(name) { invoke }
         end
       end
     end
 
-    def run_task
-      raise ArgumentError.new("missing xlogin_opts to connect to #{name}") unless @xlogin_opts[:type] && @xlogin_opts[:uri]
+    def invoke
+      loggers = []
 
-      loggers = [@xlogin_opts[:log]].flatten.compact
-      loggers << $stdout unless silent || Rake.application.options.always_multitask
-
-      if logfile
-        mkdir_p(File.dirname(logfile), verbose: Rake.application.options.trace)
-        loggers << logfile
+      if log
+        mkdir_p(File.dirname(log), verbose: Rake.application.options.trace)
+        loggers << log
       end
 
-      @xlogin_opts[:log] = loggers unless loggers.empty?
-
-      begin
-        @session = Xlogin.factory.build(@xlogin_opts)
-        if @session && @taskrunner
-          @session.extend(SessionExt)
-
-          # pass RakeTask#safe_puts method to the session instance.
-          method_proc = method(:safe_puts)
-          @session.define_singleton_method(:safe_puts) { |*args| method_proc.call(*args) }
-
-          @taskrunner.call(@session) if @taskrunner && @session
+      if Rake.application.options.always_multitask
+        buffer = StringIO.new
+        loggers << buffer  unless silent
+
+        begin
+          session = Xlogin.factory.build_from_hostname(name, log: loggers)
+          @runner.call(session)
+          $stdout.puts buffer.string.lines.map { |line| "#{name}\t" + line.gsub("\r", '') }
+        rescue => e
+          $stdout.puts buffer.string.lines.map { |line| "#{name}\t" + line.gsub("\r", '') }
+          $stderr.puts "#{name}\t#{e}"
         end
-      rescue => e
-        raise e if fail_on_error
-        safe_puts(e, io: $stderr, force: true)
-      end
-    end
-
-    module SessionExt
-      def cmd(*args)
-        message = super(*args)
-        safe_puts(message, io: $stdout) if Rake.application.options.always_multitask
-        message = yield(message) if block_given?
-        message
-      end
-
-      def readline(command)
-        prompt = StringIO.new
-        safe_puts(cmd('').lines.last, io: prompt, force: true)
-
-        my_command = RakeTask.mutex.synchronize do
-          Readline.pre_input_hook = lambda do
-            Readline.insert_text(command)
-            Readline.redisplay
-          end
-
-          Readline.readline("\e[E\e[K#{prompt.string.chomp}", true)
-        end
-
-        case my_command.strip
-        when /^\s*#/, ''
-          # do nothing and skip this command
-        when command.strip
-          cmd(my_command)
-        else
-          cmd(my_command)
-          readline(command)
+      else
+        loggers << $stdout unless silent
+
+        begin
+          session = Xlogin.factory.build_from_hostname(name, log: loggers)
+          @runner.call(session)
+        rescue => e
+          $stderr.puts e
         end
       end
     end

data/lib/xlogin/session.rb

@@ -1,124 +1,148 @@
-require 'thread'
-require 'timeout'
+require 'fileutils'
+require 'net/ssh/gateway'
+require 'ostruct'
+require 'readline'
 require 'stringio'
 
 module Xlogin
-  module Session
+  module SessionModule
 
-    attr_reader   :opts
     attr_accessor :name
+    attr_accessor :opts
 
-    def configure_session(**opts)
-      @opts     = opts.dup
-      @host     = @opts[:host]
-      @name     = @opts[:name] || @host
-      @port     = @opts[:port]
-      @userinfo = @opts[:userinfo].to_s
-      raise ArgumentError.new('device hostname or port not specified.') unless @host && @port
+    def initialize(template, uri, **params)
+      @template = template
+      @scheme   = uri.scheme
+      @opts     = OpenStruct.new(params)
 
-      @prompts  = @opts[:prompts] || [[/[$%#>] ?\z/n, nil]]
-      @timeout  = @opts[:timeout] || 10
+      @host = uri.host
+      @name = uri.host
+      @port = uri.port
+      @port ||= case @scheme
+                when 'ssh'    then 22
+                when 'telnet' then 23
+                end
 
-      @loglist  = [@opts[:log]].flatten.compact
-      @logger   = update_logger
+      @username, @password = uri.userinfo.to_s.split(':')
+      raise ArgumentError.new('Device hostname or port not specified.') unless @host && @port
+
+      @output_logs = opts.log
+      @output_loggers = prebuild_loggers
+
+      ssh_tunnel(opts.via) if opts.via
+      max_retry = opts.retry || 1
+
+      begin
+        return super(
+          'Host'     => @host,
+          'Port'     => @port,
+          'Username' => @username,
+          'Password' => @password,
+          'Timeout'  => @template.timeout,
+          'Prompt'   => Regexp.union(*@template.prompt.map(&:first)),
+        )
+      rescue => e
+        $stdout.puts e
+        retry if (max_retry -= 1) > 0
+        raise e
+      end
     end
 
-    def enable(*args)
-      # do nothing here.
-      # write bind(:enable) proc in the firmware template to override.
+    def prompt
+      cmd('').lines.last.chomp
     end
 
-    def enable_password
-      opts[:enablepw]
+    def puts(line)
+      line = instance_exec(line, &@template.interrupt) if @template.interrupt
+      super(line)
     end
 
-    def waitfor(*expect, &block)
-      if expect.compact.empty?
-        super(Regexp.union(*@prompts.map(&:first))) do |recvdata|
-          @logger.call(recvdata)
-          block.call(recvdata) if block
-        end
-      else
-        line = super(*expect) do |recvdata|
-          @logger.call(recvdata)
-          block.call(recvdata) if block
-        end
-
-        _, process = @prompts.find { |r, p| r =~ line && p }
-        if process
-          instance_eval(&process)
-          line += waitfor(*expect, &block)
-        end
-        line
-      end
+    def method_missing(name, *args, &block)
+      process = @template.methods[name]
+      super unless process
+
+      instance_exec(*args, &process)
     end
 
-    def dup(**args)
-      self.class.new(**@opts.merge(args))
+    def respond_to_missing?(name, _)
+      @template.methods[name]
     end
 
-    def lock(timeout: @timeout)
-      @mutex ||= Mutex.new
+    def waitfor(*expect, &block)
+      return waitfor(Regexp.union(*@template.prompt.map(&:first)), &block) if expect.empty?
 
-      begin
-        Timeout.timeout(timeout) { @mutex.lock }
-        yield self
-      ensure
-        @mutex.unlock if @mutex.locked?
+      line = super(*expect) do |recvdata|
+        output(recvdata, &block)
       end
-    end
 
-    def with_retry(max_retry: 1)
-      begin
-        yield self
-      rescue => e
-        renew if respond_to?(:renew)
-        raise e if (max_retry -= 1) < 0
-        retry
+      _, process = @template.prompt.find { |r, p| r =~ line && p }
+      if process
+        instance_eval(&process)
+        line += waitfor(*expect, &block)
       end
+
+      line
     end
 
-    def enable_log(out = $stdout)
-      enabled = @loglist.include?(out)
-      unless enabled
-        @loglist.push(out)
-        update_logger
-      end
+    def dup
+      uri = URI::Generic.build(@scheme, [@username, @password].compact.join(':'), @host, @port)
+      self.class.new(@template, uri, **opts.to_h)
+    end
 
+    def enable_log(out = $stdout)
+      @output_loggers = prebuild_loggers(@output_logs + [out])
       if block_given?
         yield
-        disable_log(out) unless enabled
+        @output_loggers = prebuild_loggers
       end
     end
 
     def disable_log(out = $stdout)
-      enabled = @loglist.include?(out)
-      if enabled
-        @loglist.delete(out)
-        update_logger
-      end
-
+      @output_loggers = prebuild_loggers(@output_logs - [out])
       if block_given?
         yield
-        enable_log(out) if enabled
+        @output_loggers = prebuild_loggers
       end
     end
 
     private
-    def update_logger
-      loglist = [@loglist].flatten.uniq.map do |log|
-        case log
-        when String
-          log = File.open(log, 'a+')
-          log.binmode
-          log.sync = true
-          log
-        when IO, StringIO
-          log
-        end
+    def ssh_tunnel(gateway)
+      gateway_uri = URI(gateway)
+      username, password = *gateway_uri.userinfo.split(':')
+
+      case gateway_uri.scheme
+      when 'ssh'
+        gateway = Net::SSH::Gateway.new(
+          gateway_uri.host,
+          username,
+          password: password,
+          port: gateway_uri.port || 22
+        )
+
+        @port = gateway.open(@host, @port)
+        @host = '127.0.0.1'
       end
+    end
+
+    def output(text, &block)
+      [*@output_loggers, block].compact.each { |logger| logger.call(text) }
+    end
 
-      @logger = lambda { |c| loglist.compact.each { |o| o.syswrite c } }
+    def prebuild_loggers(output_logs = @output_logs)
+      [output_logs].flatten.compact.uniq.map do |output_log|
+        logger = case output_log
+                 when String
+                   FileUtils.mkdir_p(File.dirname(output_log))
+                   File.open(output_log, 'a+').tap do |file|
+                     file.binmode
+                     file.sync = true
+                   end
+                 when IO, StringIO
+                   output_log
+                 end
+        lambda { |c| logger.syswrite c if logger }
+      end
     end
+
   end
 end

data/lib/xlogin/ssh.rb

@@ -4,21 +4,7 @@ require 'xlogin/session'
 module Xlogin
   class Ssh < Net::SSH::Telnet
 
-    include Session
-
-    def initialize(**opts)
-      configure_session(opts.merge(port: opts[:port] || 22))
-      username, password = @userinfo.split(':')
-
-      super(
-        'Host'     => @host,
-        'Port'     => @port,
-        'Username' => username,
-        'Password' => password,
-        'Timeout'  => @timeout,
-        'Prompt'   => Regexp.union(*@prompts.map(&:first))
-      )
-    end
+    include SessionModule
 
     def interact!
       raise 'Not implemented'

data/lib/xlogin/telnet.rb

@@ -5,19 +5,20 @@ require 'xlogin/session'
 module Xlogin
   class Telnet < Net::Telnet
 
-    include Session
+    prepend SessionModule
 
-    def initialize(**opts)
-      configure_session(opts.merge(port: opts[:port] || 23))
+    alias_method :telnet_login, :login
+    undef_method :login
 
-      super(
-        'Host'    => @host,
-        'Port'    => @port,
-        'Timeout' => @timeout,
-        'Prompt'  => Regexp.union(*@prompts.map(&:first))
-      )
+    def initialize(params)
+      username = params.delete('Username')
+      password = params.delete('Password')
+      super(params)
 
-      login(*@userinfo.split(':')) if respond_to?(:login) && !@userinfo.empty?
+      if username || password
+        return login(username, password) if respond_to?(:login)
+        telnet_login(username, password)
+      end
     end
 
     def interact!
@@ -39,13 +40,13 @@ module Xlogin
             rescue IO::WaitReadable
             end
 
-            raise EOFError if bs == "\u001D" # <Ctrl-]> for quit
+            raise EOFError if bs == "\u001D" # <Ctrl-]> to force quit
             @sock.syswrite(bs)
           when @sock
             begin
               bs = fh.readpartial(1024)
               $stdout.syswrite(bs)
-              @logger.call(bs)
+              output(bs)
             rescue Errno::EAGAIN
               retry
             end

data/lib/xlogin/template.rb

@@ -0,0 +1,52 @@
+require 'uri'
+require 'xlogin/ssh'
+require 'xlogin/telnet'
+
+module Xlogin
+  class Template
+
+    DEFAULT_TIMEOUT  = 10
+    DEFAULT_PROMPT   = /[$%#>] ?\z/n
+    BINDABLE_METHODS = %i( login logout enable delegate )
+
+    attr_reader :methods
+
+    def initialize
+      @timeout = DEFAULT_TIMEOUT
+      @prompts = Array.new
+      @methods = Hash.new
+      @interrupt = nil
+    end
+
+    def timeout(val = nil)
+      @timeout = val.to_i if val
+      @timeout
+    end
+
+    def prompt(expect = nil, &block)
+      return [[DEFAULT_PROMPT, nil]] if expect.nil? && @prompts.empty?
+      @prompts << [Regexp.new(expect.to_s), block] if expect
+      @prompts
+    end
+
+    def bind(name = nil, &block)
+      @methods[name] = block
+    end
+
+    def interrupt(&block)
+      return @interrupt unless block
+      @interrupt = block
+    end
+
+    def build(uri, **params)
+      uri   = URI(uri.to_s)
+      klass = Class.new(Xlogin.const_get(uri.scheme.capitalize))
+      klass.new(self, uri, **params)
+    end
+
+    def method_missing(name, *, &block)
+      super unless BINDABLE_METHODS.include? name
+      bind(name) { |*args| instance_exec(*args, &block) }
+    end
+  end
+end

data/lib/xlogin/version.rb

@@ -1,3 +1,3 @@
 module Xlogin
-  VERSION = "0.5.14"
+  VERSION = "0.6.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xlogin
 version: !ruby/object:Gem::Version
-  version: 0.5.14
+  version: 0.6.1
 platform: ruby
 authors:
 - haccht
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-12 00:00:00.000000000 Z
+date: 2017-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-telnet
@@ -130,13 +130,12 @@ files:
 - lib/xlogin.rb
 - lib/xlogin/cli.rb
 - lib/xlogin/delegator.rb
-- lib/xlogin/firmware.rb
-- lib/xlogin/firmware_factory.rb
-- lib/xlogin/gateway.rb
+- lib/xlogin/factory.rb
 - lib/xlogin/rake_task.rb
 - lib/xlogin/session.rb
 - lib/xlogin/ssh.rb
 - lib/xlogin/telnet.rb
+- lib/xlogin/template.rb
 - lib/xlogin/templates/ios.rb
 - lib/xlogin/templates/iosxr.rb
 - lib/xlogin/templates/junos.rb

data/lib/xlogin/firmware.rb

@@ -1,64 +0,0 @@
-require 'uri'
-require 'xlogin/ssh'
-require 'xlogin/telnet'
-
-module Xlogin
-  class Firmware
-
-    def initialize
-      @timeout = 5
-      @prompts = Array.new
-
-      @hook = nil
-      @bind = Hash.new
-    end
-
-    def timeout(val)
-      @timeout = val.to_i
-    end
-
-    def prompt(expect, &block)
-      @prompts << [Regexp.new(expect.to_s), block]
-    end
-
-    def hook(&block)
-      @hook = block
-    end
-
-    def bind(name, &block)
-      @bind[name] = block
-    end
-
-    def run(uri, opts = {})
-      uri   = URI(uri.to_s)
-      klass = Class.new(Xlogin.const_get(uri.scheme.capitalize))
-
-      @bind.each do |name, block|
-        klass.class_exec(name.to_sym, block) do |name, block|
-          undef_method(name) if method_defined?(name)
-          define_method(name, &block)
-        end
-      end
-
-      if @hook
-        klass.class_exec(@hook) do |cmdhook|
-          alias_method :pass, :puts
-          define_method(:puts) do |command|
-            instance_exec(command, &cmdhook)
-          end
-        end
-      end
-
-      session = klass.new(
-        {
-          host:     uri.host,
-          port:     uri.port,
-          userinfo: uri.userinfo,
-          timeout:  @timeout,
-          prompts:  @prompts,
-        }.merge(opts)
-      )
-    end
-
-  end
-end

data/lib/xlogin/gateway.rb

@@ -1,35 +0,0 @@
-begin
-  require 'uri'
-  require 'net/ssh/gateway'
-
-  module Xlogin
-    module Session
-
-      alias_method :original_configure_session, :configure_session
-      def configure_session(**opts)
-        original_configure_session(**opts)
-
-        if uri = opts[:via]
-          gateway = URI(uri)
-          username, password = *gateway.userinfo.split(':')
-
-          case gateway.scheme
-          when 'ssh'
-            @gateway = Net::SSH::Gateway.new(
-              gateway.host,
-              username,
-              password: password,
-              port: gateway.port || 22
-            )
-
-            @port = @gateway.open(@host, @port)
-            @host = '127.0.0.1'
-          end
-        end
-      end
-    end
-
-  end
-rescue LoadError
-  $stderr.puts "WARN: 'gateway' option is not supported in your environment."
-end