xlogin 0.1.0

data/lib/xlogin/delegator.rb

@@ -0,0 +1,38 @@
+require 'uri'
+
+module Xlogin
+  class Firmware
+
+    module FirmwareDelegator
+      def run(uri, opts = {})
+        if hostname = opts.delete(:delegate)
+          delegatee = FirmwareFactory.new.find(hostname)
+          firmware  = FirmwareFactory[delegatee[:type]]
+
+          firmware.on_exec do |args|
+            if args['String'].strip =~ /^kill-session(?:\(([\s\w]+)\))?$/
+              puts($1.to_s)
+              close
+            else
+              instance_exec(args, &@on_exec) if @on_exec
+              do_cmd(args)
+            end
+          end
+
+          login_method = firmware.instance_eval { @methods[:login] }
+          firmware.bind(:login,    &@methods[:login])
+          firmware.bind(:delegate, &@methods[:delegate])
+
+          session = firmware.run(uri, opts.merge(delegatee[:opts]))
+          session.delegate(URI(delegatee[:uri]), &login_method)
+          session
+        else
+          session = super(uri, opts)
+        end
+      end
+    end
+
+    prepend FirmwareDelegator
+
+  end
+end

data/lib/xlogin/firmware.rb

@@ -0,0 +1,83 @@
+require 'uri'
+require 'xlogin/telnet'
+
+module Xlogin
+  class Firmware
+
+    def initialize
+      @timeout = 5
+      @on_exec  = nil
+      @prompts = Array.new
+      @methods = Hash.new
+    end
+
+    def timeout(val)
+      @timeout = val.to_i
+    end
+
+    def on_exec(&block)
+      @on_exec = block
+    end
+
+    def prompt(expect, &block)
+      @prompts << [Regexp.new(expect.to_s), block]
+    end
+
+    def bind(name, &block)
+      @methods[name] = block
+    end
+
+    def run(uri, opts = {})
+      uri   = URI(uri.to_s)
+      klass = Class.new(Xlogin.const_get(uri.scheme.capitalize))
+      klass.class_exec(@methods) do |methods|
+        methods.each { |m, _| undef_method(m) if method_defined?(m) }
+      end
+
+      @methods.each do |name, block|
+        klass.class_exec(name, block) do |name, block|
+          undef_method(name) if respond_to?(name)
+          define_method(name, &block)
+        end
+      end
+
+      if @on_exec
+        klass.class_exec(@on_exec) do |on_exec|
+          alias_method :do_cmd, :cmd
+          define_method(:cmd) do |args|
+            args = {'String' => args.to_s} unless args.kind_of?(Hash)
+            instance_exec(args, &on_exec)
+          end
+        end
+      end
+
+      if grant = opts.delete(:grant)
+        open, password, close = grant.split(':')
+        klass.class_exec(open, password, close) do |open, password, close|
+          alias_method "original_#{open}".to_sym, open.to_sym
+          define_method(open) do |arg = password, &block|
+            send("original_#{open}", arg)
+            if block
+              resp = block.call
+              cmd(close)
+              resp
+            end
+          end
+          alias_method :enable, open
+        end
+      end
+
+      klass.new(
+        {
+          node:     uri.host,
+          port:     uri.port,
+          userinfo: uri.userinfo,
+          timeout:  @timeout,
+          prompts:  @prompts,
+          methods:  @methods,
+        }.merge(opts)
+      )
+    end
+
+  end
+end

data/lib/xlogin/firmware_factory.rb

@@ -0,0 +1,76 @@
+require 'uri'
+require 'stringio'
+require 'xlogin/firmware'
+
+module Xlogin
+  class FirmwareFactory
+
+    class << self
+      def [](name)
+        firmwares[name.to_s.downcase]
+      end
+
+      def register(name, firmware)
+        firmwares[name.to_s.downcase] = firmware
+      end
+
+      def register_file(file)
+        require file if file =~ /.rb$/
+      end
+
+      def register_dir(dir)
+        Dir.entries(dir).each do |file|
+          register_file(File.join(dir, file))
+        end
+      end
+
+      private
+      def firmwares
+        @firmwares ||= Hash.new
+      end
+    end
+
+    def initialize
+      @database = Hash.new
+
+      SourceDir.compact.each do |dir|
+        source(File.join(dir, '.xloginrc'))
+        source(File.join(dir, '_xloginrc'))
+      end
+    end
+
+    def source(db_file)
+      return unless File.exist?(db_file)
+
+      content = IO.read(db_file)
+      instance_eval(content)
+    end
+
+    def set(type, name, uri, opts = {})
+      @database[name] = { type: type, uri: uri, opts: opts }
+    end
+
+    def list
+      @database.map { |nodename, args| args.merge(name: nodename) }
+    end
+
+    def build(item, args = {})
+      item     = item.kind_of?(Hash) ? item : @database[item]
+      item_uri = item[:uri]
+      firmware = Xlogin::FirmwareFactory[item[:type]]
+      raise Xlogin::GeneralError.new("Invalid target - #{nodename}") unless item && item_uri && firmware
+
+      opts = item[:opts] || {}
+      opts = opts.merge(args).reduce({}) { |a, (k, v)| a.merge(k.to_s.downcase.to_sym => v) }
+      firmware.run(item_uri, opts)
+    end
+
+    def method_missing(name, *args, &block)
+      firmware = Xlogin::FirmwareFactory[name]
+      super unless firmware && args.size >= 2
+
+      set(name, *args)
+    end
+
+  end
+end

data/lib/xlogin/firmwares/vyos.rb

@@ -0,0 +1,27 @@
+Xlogin.configure :vyos do |os|
+  os.prompt(/[$#] (?:\e\[K)?\z/n)
+
+  os.bind(:login) do |username, password|
+    waitfor(/login:\s/)    && puts(username)
+    waitfor(/Password:\s/) && puts(password)
+    waitfor
+  end
+
+  os.bind(:config) do
+    begin
+      cmd('show configuration | no-more')
+    ensure
+      cmd('exit')
+    end
+  end
+
+  os.bind(:save) do
+    begin
+      cmd('save')
+    ensure
+      cmd('exit')
+    end
+  end
+end
+
+Xlogin.alias :edgeos, :vyos

data/lib/xlogin/gateway.rb

@@ -0,0 +1,31 @@
+require 'uri'
+require 'net/ssh/gateway'
+
+module Xlogin
+  module Session
+
+    alias_method :original_configure, :configure
+    def configure(**opts)
+      original_configure(**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(@node, @port)
+          @node = '127.0.0.1'
+        end
+      end
+    end
+  end
+
+end

data/lib/xlogin/rake_task.rb

@@ -0,0 +1,184 @@
+require 'rake'
+require 'rake/tasklib'
+require 'readline'
+require 'thread'
+
+module Xlogin
+  class RakeTask < Rake::TaskLib
+
+    class << self
+      include Rake::DSL
+
+      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 Xlogin::GeneralError.new("Duplicate hosts found - #{duplicate.join(', ')}") unless duplicate.empty?
+
+        current_namespace do
+          description = Rake.application.last_description || "Run '#{RakeTask.current_namespace}'"
+
+          desc description
+          task all: names
+
+          names.each do |name|
+            desc "#{description} (#{name})"
+            RakeTask.new(name, &block)
+          end
+        end
+      end
+
+      def mutex
+        @mutex ||= Mutex.new
+      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?
+        end
+
+        path
+      end
+    end
+
+
+    attr_reader   :name
+    attr_accessor :fail_on_error
+    attr_accessor :silent
+    attr_accessor :lockfile
+    attr_accessor :logfile
+    attr_accessor :timeout
+    attr_accessor :uncomment
+
+    def initialize(name, *args)
+      @name          = name
+      @fail_on_error = true
+      @silent        = false
+      @lockfile      = nil
+      @logfile       = nil
+      @timeout       = nil
+      @uncomment     = false
+
+      @session       = nil
+      @taskrunner    = nil
+
+      yield(self) if block_given?
+      define
+    end
+
+    def start(&block)
+      @taskrunner = block
+    end
+
+    def safe_puts(*messages, io: $stdout)
+      RakeTask.mutex.synchronize do
+        messages.flat_map { |message| message.to_s.lines }.each do |line|
+          line.gsub!("\r", "")
+          io.puts (Rake.application.options.always_multitask)? "#{name}\t#{line}" : line
+        end
+      end
+    end
+
+    private
+    def define
+      RakeTask.current_namespace do
+        description = Rake.application.last_description || "Run '#{RakeTask.current_namespace}'"
+
+        desc description
+        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)
+          end
+        else
+          task(name) do
+            run_task
+          end
+        end
+
+        [logfile, lockfile].each do |file|
+          next unless file
+
+          desc 'Remove any temporary products'
+          task 'clean' do
+            rm(file, verbose: true) if File.exist?(file)
+          end
+        end
+      end
+    end
+
+    def run_task
+      loggers = []
+      loggers << $stdout unless silent || Rake.application.options.silent || Rake.application.options.always_multitask
+
+      if logfile
+        mkdir_p(File.dirname(logfile), verbose: Rake.application.options.trace)
+        loggers << logfile if logfile
+      end
+
+      xlogin_opts = Hash.new
+      xlogin_opts[:log]     = loggers unless loggers.empty?
+      xlogin_opts[:timeout] = timeout if timeout
+
+      @session = Xlogin.get(name, xlogin_opts)
+      @session.extend(SessionExt)
+
+      %i( safe_puts fail_on_error ).each do |name|
+        method_proc = method(name)
+        @session.define_singleton_method(name) { |*args| method_proc.call(*args) }
+      end
+
+      @taskrunner.call(@session) if @taskrunner
+    end
+
+    module SessionExt
+      def cmd(*args)
+        super(*args).tap do |message|
+          safe_puts(message, io: $stdout) unless Rake.application.options.silent || !Rake.application.options.always_multitask
+          break yield(message) if block_given?
+        end
+      rescue => e
+        raise e if fail_on_error
+        safe_puts("\n#{e}", io: $stderr)
+        cmd('')
+      end
+
+      def readline(command)
+        prompt = StringIO.new
+        safe_puts(cmd('').lines.last, io: prompt)
+
+        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)
+          # retry thid command
+          readline(command)
+        end
+      end
+    end
+
+  end
+end

data/lib/xlogin/rspec.rb

@@ -0,0 +1,80 @@
+require 'rspec'
+require 'stringio'
+
+require 'xlogin/rspec/context'
+require 'xlogin/rspec/resource'
+
+module Xlogin
+
+  module RSpecResourceHelper
+    def node(name)
+      Resources::NodeResource.new(name)
+    end
+
+    def command(str)
+      Resources::CommandResource.new(str)
+    end
+
+    def backend
+      unless @backend
+        context = Xlogin::Contexts.from_example(self)
+        @backend = context.session if context && context.respond_to?(:session)
+      end
+      @backend
+    end
+  end
+
+  module RSpecHelper
+    def current_context
+      @context
+    end
+
+    def method_missing(name, *args, &block)
+      if current_context.respond_to?(name)
+        current_context.send(name, *args, &block)
+      else
+        super(name, *args, &block)
+      end
+    end
+  end
+
+end
+
+
+include Xlogin::RSpecResourceHelper
+module RSpec
+  Matchers.define :match do |expected|
+    match do |actual|
+      response = actual.to_s.lines.slice(1..-1).join
+      expected =~ response
+    end
+
+    failure_message do |actual|
+      message = StringIO.new
+      message.puts "Expect response to match #{expected.inspect}"
+      message.puts "Result:"
+      message.puts actual.to_s.lines.slice(1..-2).map { |line| " +#{line}" }
+      message.string
+    end
+
+    failure_message_when_negated do |actual|
+      message = StringIO.new
+      message.puts "Expect response not to match #{expected.inspect}"
+      message.puts "Result:"
+      message.puts actual.to_s.lines.slice(1..-2).map { |line| " +#{line}" }
+      message.string
+    end
+  end
+
+  configure do |config|
+    config.include Xlogin::RSpecHelper
+
+    config.before(:all) do
+      @context = Xlogin::Contexts.from_example(self.class)
+    end
+
+    config.before(:each) do
+      @context = Xlogin::Contexts.from_example(RSpec.current_example)
+    end
+  end
+end