teuton 2.8.0 → 2.9.1

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/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

data/lib/teuton/check/{builtin.rb → dsl/builtin.rb}

@@ -16,9 +16,7 @@ class Builtin
   end
 end
 
-# Laboratory
-# * service
-class Laboratory
+module CheckDSL
   def service(param)
     log "BUILTIN service(#{param})"
     @builtin ||= Builtin.new(self)

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

@@ -0,0 +1,90 @@
+require_relative "expect_sequence"
+
+module CheckDSL
+  def expect(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter       #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect      #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_exit(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      expect_exit #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_fail
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      expect_fail"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_first(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter        #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_first #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_last(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter        #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_last #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_none(cond = nil, args = {})
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter       #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_none #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_nothing
+    expect_none nil, {}
+  end
+
+  def expect_ok
+    expect_exit 0
+  end
+
+  def expect_one(cond)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    Logger.info "      alter       #{result.alterations}" unless result.alterations.empty?
+    Logger.info "      expect_one  #{cond} (#{cond.class})"
+    Logger.info ""
+    @target_begin = false
+  end
+
+  def expect_sequence(&block)
+    unless @target_begin
+      Logger.warn "WARN  'expect' with no previous 'target'"
+    end
+    seq = CheckDSL::ExpectSequence.new
+    seq.is_valid?(&block)
+    Logger.info "      expect_sequence #{seq.expected}"
+    Logger.info ""
+    @target_begin = false
+  end
+end

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

@@ -0,0 +1,29 @@
+module CheckDSL
+  class ExpectSequence
+    def initialize
+      @expected = []
+    end
+
+    def is_valid?(&block)
+      instance_eval(&block)
+    end
+
+    def expected
+      @expected.join(">")
+    end
+
+    private
+
+    def find(value)
+      @expected << "find(#{value})"
+    end
+
+    def next_to(value)
+      @expected << "next_to(#{value})"
+    end
+
+    def ignore(value)
+      @expected << "ignore(#{value})"
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module CheckDSL
+  def get(varname)
+    data = @stats[:gets]
+    data[varname] = data[varname] ? (data[varname] + 1) : 1
+    "get(#{varname})"
+  end
+
+  def gett(option)
+    get(option)
+  end
+
+  def set(key, value)
+    key = ":" + key.to_s if key.instance_of? Symbol
+    value = ":" + value.to_s if value.instance_of? Symbol
+
+    @stats[:sets] << "#{key}=#{value}"
+    Logger.info "      set(#{key},#{value})"
+  end
+
+  def unset(key)
+    Logger.info "      unset(#{key})"
+  end
+end

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

@@ -0,0 +1,35 @@
+module CheckDSL
+  def run(command, args = {})
+    args[:exec] = command
+    host = :localhost
+    host = args[:on] if args[:on]
+    goto(host, args)
+  end
+
+  def run_script(command, args = {})
+    host = :localhost
+    host = args[:on] if args[:on]
+    filename = command.split[1]
+    upload filename, to: host
+    run command, args
+  end
+
+  def goto(host = :localhost, args = {})
+    result.reset
+    @stats[:hosts][host] = @stats[:hosts][host] ? (@stats[:hosts][host] + 1) : 1
+    Logger.info "      run         '#{args[:exec]}' on #{host}"
+  end
+
+  def upload(filename, args = {})
+    host = args[:to]
+    args.delete(:to)
+    custom = if args == {}
+      ""
+    else
+      values = args.map { "#{_1}=#{_2}" }
+      "and #{values.join(",")}"
+    end
+    @stats[:uploads] << filename
+    Logger.info "      upload      '#{filename}' to #{host} #{custom}"
+  end
+end

data/lib/teuton/check/main.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../utils/project"
+
+def use(filename)
+  filename += ".rb"
+  rbfiles = File.join(Project.value[:project_path], "**", filename)
+  files = Dir.glob(rbfiles)
+  use = []
+  files.sort.each { |f| use << f if f.include?(filename) }
+  require_relative use[0]
+  Project.value[:uses] << use[0]
+end
+
+def group(name, &block)
+  Project.value[:groups] << {name: name, block: block}
+end
+alias task group
+
+def define_macro(name, *args, &block)
+  Project.value[:macros][name] = {args: args, block: block}
+end
+alias def_macro define_macro
+alias defmacro define_macro
+
+def start(&block)
+  # Don't do nothing. We are checking test not running it
+end
+alias play start