teuton 0.0.1

data/lib/teuton/case_manager/case/dsl/unique.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Case#DSL#unique
+module DSL
+  def unique(key, value)
+    return if value.nil?
+
+    k = (key.to_s + '=' + value.to_s).to_sym
+    @uniques << k
+  end
+end

data/lib/teuton/case_manager/case/main.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative 'dsl/main'
+require_relative 'config'
+require_relative 'close'
+require_relative 'play'
+require_relative 'runner'

data/lib/teuton/case_manager/case/play.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Case class:
+# * play
+# * play_in_parallel
+# * play_in_sequence
+# * fill_report
+# * close_opened_sessions
+class Case
+  def play
+    if skip?
+      verbose "Skipping case <#{@config.get(:tt_members)}>\n"
+      return false
+    end
+    # TODO: Delete old reports???
+    start_time = Time.now
+    play_in_sequence if get(:tt_sequence) == true # Play in sequence
+    play_in_parallel if get(:tt_sequence) != true # Play in parallel
+    fill_report(start_time, Time.now)
+    close_opened_sessions
+  end
+  alias start play
+
+  def close_opened_sessions
+    @sessions.each_value do |s|
+      s.close if s.class == Net::SSH::Connection::Session
+    end
+  end
+
+  private
+
+  def play_in_parallel
+    @groups.each do |t|
+      @action[:groupname] = t[:name]
+      instance_eval(&t[:block])
+    end
+  end
+
+  def play_in_sequence
+    verboseln "Starting case <#{@config.get(:tt_members)}>"
+    @groups.each do |t|
+      verbose "* Processing <#{t[:name]}> "
+      @action[:groupname] = t[:name]
+      instance_eval(&t[:block])
+      verbose "\n"
+    end
+    verboseln "\n"
+  end
+
+  def fill_report(start_time, finish_time)
+    @report.head.merge! @config.global
+    @report.head.merge! @config.local
+    @report.head.merge! @config.running
+    @report.tail[:case_id] = @id
+    @report.tail[:start_time_] = start_time
+    @report.tail[:finish_time] = finish_time
+    @report.tail[:duration] = finish_time - start_time
+  end
+end

data/lib/teuton/case_manager/case/result/ext_array.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# This is an extension of Result class
+class Result
+  def count
+    @alterations << 'count'
+    if @content.class == Array
+      @content = [@content.count]
+      self
+    elsif @content.nil?
+      @content = ['0']
+    else
+      @content = [@content.to_i.to_s]
+    end
+    self
+  end
+
+  def include?(value)
+    @expected = "Include <#{value}> value"
+    @content[0].include?(value)
+  end
+
+  def not_include?(value)
+    @expected = "Not include <#{value}> value"
+    !@content[0].include?(value)
+  end
+
+  def contain?(value)
+    @expected = "Contain <#{value}> value"
+    @content.contain? value
+  end
+
+  def empty
+    @expected = 'Empty!'
+    @content.empty
+  end
+
+  alias count!     count
+  alias length     count
+  alias len        count
+  alias size       count
+  alias empty?     empty
+end

data/lib/teuton/case_manager/case/result/ext_compare.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# This is an extension of Result class
+class Result
+  def eq(input)
+    @expected = input
+
+    case input.class.to_s
+    when 'Fixnum'
+      value = @content[0].to_i
+      puts '[WARN] Fixnum class is deprecated!'
+      puts '       Upgrade your Ruby version.'
+    when 'Float'
+      value = @content[0].to_f
+    when 'Integer'
+      value = @content[0].to_i
+    when 'String'
+      value = @content[0].to_s
+    else
+      value = @content[0]
+    end
+    value == input
+  end
+  alias eq?        eq
+  alias equal      eq
+  alias equal?     eq
+  alias is_equal?  eq
+
+  def neq(external)
+    @expected = "Not equal to #{external}"
+
+    case external.class.to_s
+    when 'Fixnum'
+      internal = @content[0].to_i
+      puts '[WARN] Fixnum class is deprecated!'
+      puts '       Upgrade your Ruby version.'
+    when 'Float'
+      internal = @content[0].to_f
+    when 'Integer'
+      internal = @content[0].to_i
+    else
+      internal = @content[0]
+    end
+    internal != external
+  end
+  alias neq?       neq
+  alias not_equal  neq
+  alias not_equal? neq
+
+  def ge(input)
+    @expected = "Greater or equal to #{input}"
+    return false if @content.nil? || @content[0].nil?
+
+    value = @content[0]
+    case input.class.to_s
+    when 'Fixnum'
+      value = @content[0].to_i
+      puts '[WARN] Fixnum class is deprecated!'
+      puts '       Upgrade your Ruby version.'
+    when 'Float'
+      value = @content[0].to_f
+    when 'Integer'
+      value = @content[0].to_i
+    end
+    value >= input
+  end
+  alias greater_or_equal  ge
+  alias greater_or_equal? ge
+
+  def gt(input)
+    @expected = "Greater than #{input}"
+    return false if @content.nil? || @content[0].nil?
+
+    value = @content[0]
+    case input.class.to_s
+    when 'Fixnum'
+      value = @content[0].to_i
+      puts '[WARN] Fixnum class is deprecated!'
+      puts '       Upgrade your Ruby version.'
+    when 'Float'
+      value = @content[0].to_f
+    when 'Integer'
+      value = @content[0].to_i
+    end
+    value > input
+  end
+  alias greater          gt
+  alias greater_than     gt
+
+  def le(input)
+    @expected = "Lesser or equal to #{input}"
+
+    return false if @content.nil? || @content[0].nil?
+
+    value = @content[0]
+    case input.class.to_s
+    when 'Fixnum'
+      value = @content[0].to_i
+      puts '[WARN] Fixnum class is deprecated!'
+      puts '       Upgrade your Ruby version.'
+    when 'Float'
+      value = @content[0].to_f
+    when 'Integer'
+      value = @content[0].to_i
+    end
+    value <= input
+  end
+  alias lesser_or_equal  le
+  alias lesser_or_equal? le
+
+  def lt(input)
+    @expected = "Lesser than #{input}"
+    return false if @content.nil? || @content[0].nil?
+
+    value = @content[0]
+    case input.class.to_s
+    when 'Fixnum'
+      value = @content[0].to_i
+      puts '[WARN] Fixnum class is deprecated!'
+      puts '       Upgrade your Ruby version.'
+    when 'Float'
+      value = @content[0].to_f
+    when 'Integer'
+      value = @content[0].to_i
+    end
+    value < input
+  end
+  alias lesser  lt
+  alias smaller lt
+  alias lesser_than lt
+
+  # Return 'true' if the parameter value is near to the target value.
+  # To get this we consider a 10% desviation or less, as an acceptable result.
+  def near_to?(input)
+    @expected = "Is near to #{input}"
+    return false if @content.nil?
+
+    target = @content[0].to_f
+    desv   = (target * 10.0) / 100.0
+    return true if (target - input.to_f).abs.to_f <= desv
+
+    false
+  end
+  alias near_to near_to?
+  alias near? near_to?
+  alias near near_to?
+end

data/lib/teuton/case_manager/case/result/ext_filter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# This is an extension of Result class
+class Result
+  # TODO: Error line 102 undefined include? method for 0 Fixnum...
+  def find(filter)
+    @alterations << "find(#{filter})"
+    case filter.class.to_s
+    when 'Array'
+      find_when_array(filter)
+    when 'String' || 'Integer'
+      @content.select! { |i| i.include?(filter.to_s) }
+    when 'Regexp'
+      @content.select! { |i| filter.match(i) }
+    end
+    self
+  end
+  alias grep   find
+  alias grep!  find
+  alias find!  find
+
+  def not_find(p_filter)
+    @alterations << "not_find(#{p_filter})"
+    return self if @content.size.zero?
+
+    @content.reject! { |i| i.include?(p_filter) }
+    self
+  end
+  alias grep_v not_find
+
+  def since(filter)
+    @alterations << "since(#{filter})"
+    return self if @content.size.zero?
+
+    if filter.class == String
+      flag = false
+      @content.select! do |i|
+        flag = true if i.include?(filter.to_s)
+        flag
+      end
+    end
+    self
+  end
+
+  def until(filter)
+    @alterations << "until(#{filter})"
+    return self if @content.size.zero?
+
+    if filter.class == String
+      flag = true
+      @content.select! do |i|
+        flag = false if i.include?(filter.to_s)
+        flag
+      end
+    end
+    self
+  end
+
+  private
+
+  def find_when_array(filter)
+    @content.select! do |line|
+      flag = false
+      filter.each { |i| flag ||= line.include?(i) }
+      flag
+    end
+  end
+end

data/lib/teuton/case_manager/case/result/result.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'ext_array'
+require_relative 'ext_compare'
+require_relative 'ext_filter'
+
+# This object contains data returned by remote/local execution
+# * initialize
+# * alterations
+# * content
+# * debug
+# * ok?
+# * reset
+# * restore
+# * value
+class Result
+  attr_reader :content
+  attr_accessor :exitstatus
+
+  def initialize
+    reset
+  end
+
+  def alterations
+    @alterations.join(' & ')
+  end
+
+  def content=(content)
+    @content_backup = content.clone
+    @content = content.clone
+  end
+
+  def reset
+    @content_backup = []
+    @content        = []
+    @exitstatus     = nil
+    @value          = nil
+    @expected       = nil
+    @alterations    = []
+  end
+
+  def debug
+    print "\n" + '*' * 20
+    print " [DEBUG] count=#{@content.count} "
+    puts '*' * 20
+    @content.each_with_index do |item, index|
+      puts format('%2d: %s', index, item)
+    end
+    puts '*' * 57
+  end
+
+  def expected
+    @expected.to_s
+  end
+
+  def ok?
+    return false if @exitstatus.nil?
+
+    @exitstatus.zero?
+  end
+
+  def restore
+    temp = @content_backup.clone
+    reset
+    @content_backup = temp
+    @content        = temp.clone
+  end
+  alias restore! restore
+
+  def value
+    @content[0]
+  end
+end

data/lib/teuton/case_manager/case/runner.rb

@@ -0,0 +1,134 @@
+
+require 'net/ssh'
+require 'net/sftp'
+require 'net/telnet'
+
+# Class Case
+# * run_local_cmd
+# * run_remote_cmd
+# * run_remote_cmd_ssh
+# * run_remote_cmd_telnet
+class Case
+
+  private
+
+  def run_local_cmd()
+    @action[:conn_type] = :local
+    i = my_execute( @action[:command], @action[:encoding] )
+    @result.exitstatus = i[:exitstatus]
+    @result.content = i[:content]
+  end
+
+  def run_remote_cmd(input_hostname)
+    hostname = input_hostname.to_s
+    i = (hostname + '_protocol').to_sym
+    protocol = @config.get(i) if @config.get(i)
+    protocol = :ssh if protocol.nil? || protocol == 'NODATA'
+    protocol = protocol.to_sym
+    case protocol
+    when :ssh
+      run_remote_cmd_ssh(input_hostname)
+    when :telnet
+      run_remote_cmd_telnet(input_hostname)
+    else
+      log("Protocol #{protocol} unknown! Use ssh or telnet.", :error)
+    end
+  end
+
+  def run_remote_cmd_ssh(input_hostname)
+    @action[:conn_type] = :ssh
+    hostname = input_hostname.to_s
+    ip = @config.get((hostname + '_ip').to_sym)
+    username = @config.get((hostname + '_username').to_sym).to_s
+    password = @config.get((hostname + '_password').to_sym).to_s
+    text = ''
+    begin
+      if @sessions[hostname].nil?
+        @sessions[hostname] = Net::SSH.start(ip,
+                                             username,
+                                             password: password,
+                                             keepalive: true,
+                                             timeout: 30,
+                                             non_interactive: true)
+      end
+      if @sessions[hostname].class == Net::SSH::Connection::Session
+        text = @sessions[hostname].exec!(@action[:command].to_s)
+      end
+    rescue Errno::EHOSTUNREACH
+      @sessions[hostname] = :nosession
+      @conn_status[hostname] = :host_unreachable
+      verbose Application.instance.letter[:error]
+      log("Host #{ip} unreachable!", :error)
+    rescue Net::SSH::AuthenticationFailed
+      @sessions[hostname] = :nosession
+      @conn_status[hostname] = :error_authentication_failed
+      verbose Application.instance.letter[:error]
+      log('SSH::AuthenticationFailed!', :error)
+    rescue Net::SSH::HostKeyMismatch
+      @sessions[hostname] = :nosession
+      @conn_status[hostname] = :host_key_mismatch
+      verbose Application.instance.letter[:error]
+      log('SSH::HostKeyMismatch!', :error)
+      log("* The destination server's fingerprint is not matching " \
+          'what is in your local known_hosts file.', :error)
+      log('* Remove the existing entry in your local known_hosts file', :error)
+      log("* Try this => ssh-keygen -f '/home/USERNAME/.ssh/known_hosts' " \
+          "-R #{ip}", :error)
+    rescue StandardError => e
+      @sessions[hostname] = :nosession
+      @conn_status[hostname] = :error
+      verbose Application.instance.letter[:error]
+      log("[#{e.class}] SSH on <#{username}@#{ip}>" \
+          " exec: #{@action[:command]}", :error)
+    end
+    output = encode_and_split(@action[:encoding], text)
+    @result.content = output
+    @result.content.compact!
+  end
+
+  def run_remote_cmd_telnet(input_hostname)
+    @action[:conn_type] = :telnet
+    app = Application.instance
+    hostname = input_hostname.to_s
+    ip = @config.get((hostname + '_ip').to_sym)
+    username = @config.get((hostname + '_username').to_sym).to_s
+    password = @config.get((hostname + '_password').to_sym).to_s
+    text = ''
+    begin
+      if @sessions[hostname].nil? || @sessions[hostname] == :ok
+        h = Net::Telnet.new( 'Host' => ip,
+                             'Timeout' => 30,
+                             'Prompt' => /login|teuton|[$%#>]/ )
+#                            'Prompt' => Regexp.new(username[1, 40]))
+#                            'Prompt' => /[$%#>] \z/n)
+        h.login(username, password)
+        text = ''
+        h.cmd(@action[:command]) { |i| text << i }
+        h.close
+        @sessions[hostname] = :ok
+      end
+    rescue Net::OpenTimeout
+      @sessions[hostname] = :nosession
+      @conn_status[hostname] = :open_timeout
+      verbose Application.instance.letter[:error]
+      log(" ExceptionType=<Net::OpenTimeout> doing <telnet #{ip}>", :error)
+      log(' └── Revise host IP!', :warn)
+    rescue Net::ReadTimeout
+      @sessions[hostname] = :nosession
+      @conn_status[hostname] = :read_timeout
+      verbose Application.instance.letter[:error]
+      log(" ExceptionType=<Net::ReadTimeout> doing <telnet #{ip}>", :error)
+    rescue StandardError => e
+      @sessions[hostname] = :nosession
+      @conn_status[hostname] = :error
+      verbose Application.instance.letter[:error]
+      log(" ExceptionType=<#{e.class}> doing telnet on <#{username}@#{ip}>" \
+          " exec: #{@action[:command]}", :error)
+      log(" └── username=<#{username}>, password=<#{password}>," \
+          " ip=<#{ip}>, HOSTID=<#{hostname}>", :warn)
+    end
+    output = encode_and_split(@action[:encoding], text)
+    @result.content = output
+    @result.content.compact!
+  end
+end

data/lib/teuton/case_manager/case_manager.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require_relative '../application'
+require_relative '../report/report'
+require_relative '../project/configfile_reader'
+require_relative 'case/case'
+require_relative 'export_manager'
+require_relative 'main'
+require_relative 'utils'
+
+# This class does all the job
+# Organize the hole job, sending orders to others classes
+# * initialize
+# * play
+# Split into several files:
+# * case_manager/check_cases
+# * case_manager/export
+# * case_manager/hall_of_fame
+# * case_manager/report
+# * case_manager/show
+class CaseManager
+  include Singleton
+  include Utils
+
+  def initialize
+    @cases = []
+    @report = Report.new(0)
+    @report.filename = 'resume'
+  end
+
+  def play(&block)
+    check_cases!
+    instance_eval(&block)
+    # Run export if user pass option command "--export=json"
+    i = Application.instance.options['export']
+    export(format: i.to_sym) unless i.nil?
+    # Accept "configfile" param REVISE There exists?
+    i = Application.instance.options['configfile']
+    export(format: i.to_sym) unless i.nil?
+  end
+
+  def export(args = {})
+    if args.class != Hash
+      puts "[ERROR] CaseManager#export: Argument = <#{args}>, " \
+           "class = #{args.class}"
+      puts '        Usage: export :format => :colored_text'
+      raise '[ERROR] CaseManager#export: Argument error!'
+    end
+    ExportManager.run(@report, @cases, args)
+    preserve_files if args[:preserve] == true
+  end
+
+  def preserve_files
+    app = Application.instance
+    t = Time.now
+    subdir = "#{t.year}#{format('%02d',t.month)}#{format('%02d',t.day)}-" \
+             "#{format('%02d',t.hour)}#{format('%02d',t.min)}" \
+             "#{format('%02d',t.sec)}"
+    logdir = File.join(app.output_basedir, app.global[:tt_testname], subdir)
+    srcdir = File.join(app.output_basedir, app.global[:tt_testname])
+    puts "[INFO] Preserving files => #{logdir}"
+    FileUtils.mkdir(logdir)
+    Dir.glob('var/learn-08-preserve/**.*').each do |file|
+      FileUtils.cp(file, logdir)
+    end
+  end
+
+  def send(args = {})
+    threads = []
+    puts ''
+    puts "[INFO] Sending files...#{args.to_s}"
+    @cases.each { |c| threads << Thread.new { c.send(args) } }
+    threads.each(&:join)
+  end
+end

data/lib/teuton/case_manager/check_cases.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# CaseManager#check_cases!
+class CaseManager
+  private
+
+  def check_cases!
+    app = Application.instance
+
+    # Load configurations from config file
+    configdata = ConfigFileReader.read(app.config_path)
+    app.ialias = configdata[:alias]
+    app.global = configdata[:global]
+    app.global[:tt_testname] = app.global[:tt_testname] || app.test_name
+    app.global[:tt_sequence] = false if app.global[:tt_sequence].nil?
+
+    # Create out dir
+    outdir = app.global[:tt_outdir] ||
+             File.join('var', app.global[:tt_testname])
+    ensure_dir outdir
+    @report.output_dir = outdir
+
+    # Fill report head
+    open_main_report(app.config_path)
+
+    # create cases and run
+    configdata[:cases].each { |config| @cases << Case.new(config) }
+    start_time = run_all_cases # run cases
+
+    uniques = collect_uniques_for_all_cases
+    close_reports_for_all_cases(uniques)
+    close_main_report(start_time)
+  end
+
+  def run_all_cases
+    start_time = Time.now
+    if Application.instance.global[:tt_sequence]
+      verboseln "[INFO] Running in sequence (#{start_time})"
+      # Run every case in sequence
+      @cases.each(&:play)
+    else
+      verboseln "[INFO] Running in parallel (#{start_time})"
+      threads = []
+      # Run all cases in parallel
+      @cases.each { |c| threads << Thread.new { c.play } }
+      threads.each(&:join)
+    end
+    start_time
+  end
+
+  def collect_uniques_for_all_cases
+    uniques = {} # Collect "unique" values from all cases
+    @cases.each do |c|
+      c.uniques.each do |key|
+        if uniques[key].nil?
+          uniques[key] = [c.id]
+        else
+          uniques[key] << c.id
+        end
+      end
+    end
+    uniques
+  end
+
+  def close_reports_for_all_cases(uniques)
+    threads = []
+    @cases.each { |c| threads << Thread.new { c.close uniques } }
+    threads.each(&:join)
+
+    # Build Hall of Fame
+    build_hall_of_fame
+  end
+end