teuton 2.7.3 → 2.9.0

data/lib/teuton/case/dsl/expect_sequence.rb

@@ -0,0 +1,173 @@
+class ExpectSequence
+  attr_reader :result
+  attr_reader :states
+
+  def initialize(lines)
+    @lines = lines
+  end
+
+  def is_valid?(&block)
+    @expected = []
+    @states = [
+      {last_index: -1, steps: [], found: []}
+    ]
+    instance_eval(&block)
+    @result = find_best_state
+    @result[:ok]
+  end
+
+  def expected
+    @expected.join(">")
+  end
+
+  def real
+    # From final result return evaluation progress
+    text = []
+    @result[:steps].each do |step|
+      index = text.size
+      text << if step
+        @expected[index]
+      else
+        "not #{@expected[index]}"
+      end
+    end
+    text.join(">")
+  end
+
+  private
+
+  def find_best_state
+    @states.each do |state|
+      state[:score] = (state[:steps].select { _1 }).size
+      state[:fails] = (state[:steps].select { !_1 }).size
+      state[:ok] = (state[:fails] == 0)
+    end
+    best = @states[0]
+    @states.each { |state| best = state if state[:score] > best[:score] }
+    best
+  end
+
+  def find(value)
+    @expected << "find(#{value})"
+    newstates = []
+    @states.each do |state|
+      last_index = state[:last_index]
+
+      if last_index > (@lines.size - 1)
+        steps = state[:steps].clone
+        steps << false
+        newstates << {
+          last_index: last_index,
+          steps: steps,
+          found: state[:found].clone
+        }
+        next
+      end
+
+      findindexes = get_indexes(value: value, from: last_index)
+      findindexes.each do |findindex|
+        found = state[:found].clone
+        found << findindex
+        steps = state[:steps].clone
+        steps << true
+        newstates << {
+          last_index: findindex,
+          steps: steps,
+          found: found
+        }
+      end
+    end
+    @states = if newstates.size.zero?
+      @states.each { |state| state[:steps] << false }
+    else
+      newstates
+    end
+  end
+
+  def next_to(value)
+    @expected << "next_to(#{value})"
+    newstates = []
+
+    @states.each do |state|
+      last_index = state[:last_index]
+
+      if last_index > (@lines.size - 1)
+        steps = state[:steps].clone
+        steps << false
+        newstates << {
+          last_index: last_index,
+          steps: steps,
+          found: state[:found].clone
+        }
+        next
+      end
+
+      last_index += 1
+      found = state[:found].clone
+      steps = state[:steps].clone
+      line = @lines[last_index]
+      if line.include?(value)
+        found << last_index
+        steps << true
+      else
+        steps << false
+      end
+      newstates << {
+        last_index: last_index,
+        steps: steps,
+        found: found
+      }
+    end
+    @states = if newstates.size.zero?
+      @states.each { |state| state[:steps] << false }
+    else
+      newstates
+    end
+  end
+
+  def ignore(value)
+    @expected << "ignore(#{value})"
+    newstates = []
+    @states.each do |state|
+      last_index = state[:last_index] + value.to_i
+
+      steps = state[:steps].clone
+      steps << !(last_index > (@lines.size - 1))
+
+      newstates << {
+        last_index: last_index,
+        steps: steps,
+        found: state[:found].clone
+      }
+    end
+
+    @states = if newstates.size.zero?
+      @states.each { |state| state[:steps] << false }
+    else
+      newstates
+    end
+  end
+
+  def get_indexes(value:, from:)
+    indexes = []
+
+    @lines.each_with_index do |line, index|
+      next if index < from
+
+      indexes << index if line_include_value?(line: line, value: value)
+    end
+    indexes
+  end
+
+  def line_include_value?(line:, value:)
+    if value.is_a? String
+      return true if line.include? value
+    elsif value.is_a? Regexp
+      return true << index if value.match(line)
+    else
+      puts "[ERROR] expect_sequence #{value.class}"
+      exit 1
+    end
+    false
+  end
+end

data/lib/teuton/case/dsl/getset.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# DSL#get and DSL#set
 module DSL
   # Read param option from [running, config or global] Hash data
   def get(option)

data/lib/teuton/case/dsl/host.rb

@@ -0,0 +1,5 @@
+module DSL
+  def get_host(id)
+    Case::Host.new(config).get(id)
+  end
+end

data/lib/teuton/case/dsl/macro.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "../../utils/project"
+require_relative "../../utils/logger"
 
-# DSL module methods: assert, missing_method
 module DSL
   ##
   # Invoke macro
@@ -11,7 +11,9 @@ module DSL
   def macro(name, input = {})
     macros = Project.value[:macros]
     unless macros[name]
-      log("Macro #{name} not found!", :error)
+      msg = "DSL '#{name}' not found!"
+      log(msg, :error)
+      Logger.error("ERROR #{msg}")
       return
     end
     input.each_pair { |k, v| set(k, v) }
@@ -33,9 +35,10 @@ module DSL
   def method_missing(method, args = {})
     a = method.to_s
     if a.start_with?("_")
-      return instance_eval("get(:#{a[1, a.size - 1]})", __FILE__, __LINE__)
+      return instance_eval("get(:#{a[1, a.size]})", __FILE__, __LINE__)
+    elsif a[0, 6] == "macro_"
+      return macro a[6, a.size], args
     end
-    return macro a[6, a.size], args if a[0, 6] == "macro_"
     macro a, args
   end
 

data/lib/teuton/case/dsl/run_script.rb

@@ -0,0 +1,35 @@
+require_relative "../../utils/project"
+require_relative "../../utils/verbose"
+
+module DSL
+  def run_script(script, args = {})
+    items = script.split(" ")
+    if items.size == 1
+      shell = args[:shell] || ((get(:shell) != "NODATA") ? get(:shell) : nil)
+      script = "#{shell} #{script}" if shell
+      script = "#{script} #{args[:args]} " if args[:args]
+    end
+
+    items = script.split(" ")
+    if items.size < 1
+      msg = Rainbow("==> [ERROR] run_script: Incorrect command '#{command}'").red
+      verboseln(msg)
+      return
+    end
+
+    host = get_host(args[:on])
+    if host.protocol == "local"
+      items[1] = File.join(Project.value[:project_path], items[1])
+      command = items.join(" ")
+      run(command, args)
+    elsif host.protocol == "ssh"
+      upload items[1], to: host.id
+      items[1] = File.basename(items[1])
+      command = items.join(" ")
+      run(command, args)
+    else
+      msg = Rainbow("==> [ERROR] run_script: Incorrect protocol(#{host.protocol})").red
+      verboseln(msg)
+    end
+  end
+end

data/lib/teuton/case/dsl/send.rb

@@ -21,8 +21,8 @@ module DSL
     localfilepath = File.join(@report.output_dir, filename)
     filename = args[:prefix].to_s + filename if args[:prefix]
 
-    remotefilepath = if args[:remote_dir]
-      File.join(args[:remote_dir], filename)
+    remotefilepath = if args[:dir]
+      File.join(args[:dir], filename)
     else
       File.join(".", filename)
     end
@@ -32,7 +32,7 @@ module DSL
       Net::SFTP.start(ip, username, password: password, port: port) do |sftp|
         sftp.upload!(localfilepath, remotefilepath)
       end
-      msg = Rainbow("==> File '#{remotefilepath}' of '#{get(:tt_members)}' has been copied").green
+      msg = Rainbow("==> Case #{get(:tt_members)}: report (#{remotefilepath}) copy to (#{ip})").green
       verboseln(msg)
     rescue
       msg = Rainbow("==> [FAIL] #{get(:tt_members)}: 'scp #{localfilepath}' to #{remotefilepath}").red

data/lib/teuton/case/dsl/upload.rb

@@ -0,0 +1,42 @@
+require_relative "../../utils/project"
+require_relative "../../utils/verbose"
+
+module DSL
+  def upload(localfilter, args = {})
+    abslocalfilter = if File.absolute_path? localfilter
+      localfilter
+    else
+      File.join(Project.value[:project_path], localfilter)
+    end
+
+    Dir.glob(abslocalfilter).each do |abslocalpath|
+      upload_one(abslocalpath, args)
+    end
+  end
+
+  def upload_one(localpath, args = {})
+    if args[:to].nil?
+      Logger.err("ERROR upload requires to: XXX")
+      exit 1
+    end
+
+    host = get_host(args[:to])
+    if host.protocol == "ssh"
+      begin
+        localfile = File.basename(localpath)
+        remotepath = args[:remotedir] ? File.join(args[:remotedir], localfile) : localfile
+        Net::SFTP.start(
+          host.ip, host.username, password: host.password, port: host.port
+        ) { |sftp| sftp.upload!(localpath, remotepath) }
+        verbose(Rainbow("u").green)
+      rescue => e
+        log("Upload #{localfile} to #{host.ip}:#{remotepath}", :warn)
+        log(e.to_s, :warn)
+        verbose(Rainbow("!").green)
+      end
+    elsif host.protocol != "local"
+      msg = Rainbow("==> [ERROR] upload: Incorrect protocol(#{host.protocol})").red
+      verboseln(msg)
+    end
+  end
+end

data/lib/teuton/case/dsl/weight.rb

@@ -0,0 +1,12 @@
+module DSL
+  def weight(value = nil)
+    # Set weight value for the action
+    if value.nil?
+      @action[:weight]
+    elsif value == :default
+      @action[:weight] = 1.0
+    else
+      @action[:weight] = value.to_f
+    end
+  end
+end

data/lib/teuton/case/execute/execute_ssh.rb

@@ -35,7 +35,7 @@ class ExecuteSSH < ExecuteBase
       end
     end
 
-    text = ""
+    text = "TEUTON_NODATA"
     exitcode = 0
     begin
       if sessions[hostname].nil?
@@ -49,25 +49,29 @@ class ExecuteSSH < ExecuteBase
           non_interactive: true
         )
       end
-      text = if sessions[hostname].instance_of? Net::SSH::Connection::Session
-        sessions[hostname].exec!(action[:command])
+      if sessions[hostname].instance_of? Net::SSH::Connection::Session
+        text = sessions[hostname].exec!(action[:command])
+        exitcode = text.exitstatus
       else
-        "SSH: NO CONNECTION!"
+        text = "TEUTON_ERROR_SSH_NO_CONNECTION"
+        exitcode = -1
       end
-      exitcode = text.exitstatus
     rescue Errno::EHOSTUNREACH
       sessions[hostname] = :nosession
       conn_status[hostname] = :host_unreachable
+      text = "TEUTON_ERROR_SSH_HOST_UNREACHABLE"
       exitcode = -1
       log("Host #{ip} unreachable!", :error)
     rescue Net::SSH::AuthenticationFailed
       sessions[hostname] = :nosession
       conn_status[hostname] = :error_authentication_failed
+      text = "TEUTON_ERROR_SSH_AUTH_FAILED"
       exitcode = -1
       log("SSH::AuthenticationFailed!", :error)
     rescue Net::SSH::HostKeyMismatch
       sessions[hostname] = :nosession
       conn_status[hostname] = :host_key_mismatch
+      text = "TEUTON_ERROR_SSH_HOST_KEY"
       exitcode = -1
       log("SSH::HostKeyMismatch!", :error)
       log("* The destination server's fingerprint is not matching " \
@@ -78,13 +82,13 @@ class ExecuteSSH < ExecuteBase
     rescue => e
       sessions[hostname] = :nosession
       conn_status[hostname] = :error
+      text = "TEUTON_ERROR_SSH"
       exitcode = -1
       log("[#{e.class}] SSH on <#{username}@#{ip}>" \
           " exec: #{action[:command]}", :error)
     end
-    output = encode_and_split(action[:encoding], text)
     result.exitcode = exitcode
-    result.content = output
+    result.content = encode_and_split(action[:encoding], text)
     result.content.compact!
   end
 end

data/lib/teuton/case/host.rb

@@ -0,0 +1,68 @@
+class Case
+  class Host
+    attr_reader :id
+    attr_reader :ip
+    attr_reader :username
+    attr_reader :password
+    attr_reader :port
+    attr_reader :protocol
+    attr_reader :route
+
+    def initialize(config)
+      @config = config
+    end
+
+    def get(id = nil)
+      if id.nil?
+        init_default
+      else
+        init(id)
+      end
+      self
+    end
+
+    def to_s
+      data = {
+        id: id,
+        ip: ip, username: username, password: password,
+        port: port, protocol: protocol, route: route
+      }
+      data.to_s
+    end
+
+    private
+
+    def init(id)
+      @id = id.to_sym
+      @ip = @config.get("#{@id}_ip".to_sym).to_s
+      @username = @config.get("#{@id}_username".to_sym).to_s
+      @password = @config.get("#{@id}_password".to_sym).to_s
+
+      @protocol = @config.get("#{@id}_protocol".to_sym).to_s.downcase
+      if @protocol == "nodata"
+        @protocol = if @ip == "localhost" || @ip.start_with?("127.0.0.")
+          "local"
+        else
+          "ssh"
+        end
+      end
+
+      @port = @config.get("#{@id}_port".to_sym).to_i
+      if @port.zero?
+        default = {"local" => 0, "ssh" => 22, "telnet" => 23}
+        @port = default[@protocol]
+      end
+      @route = @config.get("#{@id}_route".to_sym)
+    end
+
+    def init_default
+      @id = :default
+      @ip = "localhost"
+      @username = "NODATA"
+      @password = "NODATA"
+      @protocol = "local"
+      @port = 0
+      @route = "NODATA"
+    end
+  end
+end

data/lib/teuton/case/play.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 class Case
-  # Case class: play
-  # TODO: Encapsulate code into PlayManager class
-  # * play_in_parallel, play_in_sequence, fill_report, close_opened_sessions
   # READ: sessions, config, groups, action, report
   # TODO: groups from Project or from Case???
   def play
@@ -18,19 +15,18 @@ class Case
   end
   alias_method :start, :play
 
+  private
+
   def close_opened_sessions
     @sessions.each_value do |s|
       s.close if s.instance_of? Net::SSH::Connection::Session
     end
   end
 
-  private
-
   def play_groups_in_sequence
     verboseln "\n=> Starting case [#{@config.get(:tt_members)}]" if get(:tt_sequence) == true
     @groups.each do |t|
       @action[:groupname] = t[:name]
-      # TODO: @parent(case).instance_eval(&t[:block])
       instance_eval(&t[:block])
     end
   end

data/lib/teuton/{utils → case}/result/ext_array.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# This is an extension of Result class
 class Result
   def count
     @alterations << "count"

data/lib/teuton/{utils → case}/result/ext_compare.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# Extension of Result class
 class Result
   def eq(input)
     # Return true when content is equal than input

data/lib/teuton/{utils → case}/result/ext_filter.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-# Result class extension
 class Result
-  # TODO: Error line 102 undefined include? method for 0 Fixnum...
   def find(filter)
     @alterations << "find(#{filter})"
     case filter.class.to_s

data/lib/teuton/{utils → case}/result/result.rb

@@ -4,15 +4,6 @@ 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 :exitcode
@@ -22,6 +13,16 @@ class Result
     reset
   end
 
+  def reset
+    @content_backup = []
+    @content = []
+    @exitcode = -1
+
+    # @value = nil
+    @expected = nil
+    @alterations = []
+  end
+
   def alterations
     if @alterations.is_a? String
       @alterations
@@ -49,15 +50,6 @@ class Result
     @expected.to_s
   end
 
-  def reset
-    @content_backup = []
-    @content = []
-    @exitcode = -1
-    @value = nil
-    @expected = nil
-    @alterations = []
-  end
-
   def ok?
     @exitcode.zero?
   end
@@ -65,10 +57,10 @@ class Result
   def restore
     temp = @content_backup.clone
     reset
-    @content_backup = temp
-    @content = temp.clone
+    # @content_backup = temp
+    # @content = temp.clone
+    self.content = (temp)
   end
-  alias_method :restore!, :restore
 
   def value
     @content[0]

data/lib/teuton/check/checker.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../case/dsl/macro"
+require_relative "../case/result/result"
+require_relative "../utils/project"
+require_relative "../utils/logger"
+require_relative "dsl/all"
+require_relative "show"
+
+class Checker
+  include DSL # Include case/DSL/macro functions only
+  include CheckDSL
+
+  attr_reader :result
+
+  def initialize(script_path, config_path)
+    @path = {}
+    @path[:script] = script_path
+    @path[:dirname] = File.dirname(script_path)
+    @path[:filename] = File.basename(script_path, ".rb")
+    @path[:config] = config_path
+    reset
+  end
+
+  def reset
+    @result = Result.new
+    @targetid = 0
+    @stats = {
+      groups: 0,
+      targets: 0,
+      logs: 0,
+      readmes: 0,
+      uniques: 0,
+      hosts: {},
+      gets: {},
+      sets: [],
+      uploads: []
+    }
+    @target_begin = nil
+  end
+
+  def show
+    Logger.verbose = true
+    process_content
+    cs = ShowCheck.new(stats: @stats, path: @path)
+    cs.show_stats
+    cs.revise_config_content
+  end
+
+  def show_onlyconfig
+    Logger.verbose = false
+    process_content
+    Logger.verbose = true
+    cs = ShowCheck.new(stats: @stats, path: @path)
+    cs.suggest_config_content
+  end
+
+  private
+
+  def process_content
+    groups = Project.value[:groups]
+    option = Project.value[:options]
+
+    Logger.info ""
+    if Project.value[:uses].size.positive?
+      Logger.info Terminal::Table.new { |st| st.add_row ["USE: external libraries"] }
+      Project.value[:uses].each_with_index { Logger.info "      #{_2 + 1}. #{_1}" }
+    end
+    groups.each do |t|
+      @stats[:groups] += 1
+      unless option[:panel]
+        msg = "GROUP: #{t[:name]}"
+        my_screen_table = Terminal::Table.new { |st| st.add_row [msg] }
+        Logger.info my_screen_table
+      end
+      instance_eval(&t[:block])
+    end
+    if @target_begin
+      Logger.warn "WARN  Last 'target' requires 'expect'\n"
+    end
+  end
+end

data/lib/teuton/check/dsl/all.rb

@@ -0,0 +1,37 @@
+require_relative "builtin"
+require_relative "expect"
+require_relative "getset"
+require_relative "run"
+
+module CheckDSL
+  def log(text = "", type = :info)
+    @stats[:logs] += 1
+    prefix = (type == :info) ? "" : "#{type.to_s.upcase}: "
+    Logger.info "      log         #{prefix}" + text.to_s
+  end
+
+  def readme(text)
+    @stats[:readmes] += 1
+    Logger.info "      readme      #{text}"
+  end
+
+  def target(desc, args = {})
+    if @target_begin
+      Logger.warn "WARN  Previous 'target' requires 'expect'"
+    end
+    @target_begin = true
+    @stats[:targets] += 1
+    @targetid += 1
+    weight = args[:weight] ? args[:weight].to_f : 1.0
+    Logger.info format("(%03<targetid>d) target      %<desc>s", targetid: @targetid, desc: desc)
+    Logger.info "      weight      #{weight}"
+  end
+  alias_method :goal, :target
+
+  def unique(key, _value)
+    @stats[:uniques] += 1
+
+    Logger.info "      unique      value for <#{key}>"
+    Logger.info ""
+  end
+end