teuton 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3d55a24ec355421cd07d663355e689bc8edd0d4c80c498510d018a629580eb90
+  data.tar.gz: e640a71a276ce35f26aa4fc6412c836e4405df58a6c08e212f9046639280e486
+SHA512:
+  metadata.gz: 6008a3dbeef623139d4e6cbe73b54755e055756ce643d5bb3b8e46c42ecf1cba349cd3cd88274d8b188a94de89d06a03182269d8783ebfa8b13ad79669bbd865
+  data.tar.gz: 69128f5748c9cef8fa9b13c84c7c134dfb085709ba7c2c43b7d40033f974c2e088d6f28e8cbb67f37bd97ccae6be530bf9779dcc4fd30fec3795b36ca6988dcf

data/bin/teuton

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'teuton'
+Teuton.start(ARGV)

data/lib/teuton/application.rb

@@ -0,0 +1,53 @@
+require 'singleton'
+
+# This Singleton contains application params
+class Application
+  include Singleton
+
+  VERSION = '2.1.0'
+  NAME = 'teuton'
+
+  attr_reader   :letter
+  attr_reader   :running_basedir, :output_basedir
+  attr_reader   :default
+  attr_accessor :options
+  attr_accessor :verbose
+  attr_accessor :global, :ialias
+  attr_accessor :checks, :groups, :uses
+  attr_accessor :hall_of_fame
+  attr_accessor :project_path, :script_path, :config_path, :test_name
+
+  def initialize
+    reset
+  end
+
+  def reset
+    @letter = { good: '.', bad: 'F', error: '?', none: ' ' }
+    @running_basedir = Dir.getwd
+    @output_basedir = 'var'
+    @default = { name: 'teuton', format: :txt, debug: false }
+    @options = { 'lang' => 'en' }
+    @verbose = true
+
+    @global = {}
+    @ialias = {}
+    @checks = {}
+    @groups = []
+    @uses = [] # TODO
+    @hall_of_fame = []
+  end
+
+  def debug
+    @default[:debug]
+  end
+
+  def name
+    @default[:name]
+  end
+
+  def quiet?
+    return true if Application.instance.options['quiet']
+    return true unless Application.instance.verbose
+    false
+  end
+end

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

@@ -0,0 +1,24 @@
+
+require_relative 'package'
+require_relative 'service'
+require_relative 'user'
+
+class Case
+  def package(param)
+    @package = @package || Package.new(self)
+    @package.param = param
+    @package
+  end
+
+  def service(param)
+    @service = @service || Service.new(self)
+    @service.param = param
+    @service
+  end
+
+  def user(param)
+    @user = @user || User.new(self)
+    @user.param = param
+    @user
+  end
+end

data/lib/teuton/case_manager/case/builtin/package.rb

@@ -0,0 +1,20 @@
+
+class Package
+  attr_accessor :param
+
+  def initialize(parent)
+    @parent = parent
+  end
+
+  def installed?
+    @parent.target("Package #{@param} installed?")
+    @parent.run "whereis #{@param}"
+    @parent.expect_one [ 'bin', @param ]
+  end
+
+  def not_installed?
+    @parent.target("Package #{@param} not installed?")
+    @parent.run "whereis #{@param}"
+    @parent.expect_none [ 'bin' , @param ]
+  end
+end

data/lib/teuton/case_manager/case/builtin/service.rb

@@ -0,0 +1,32 @@
+
+class Service
+  attr_accessor :param
+
+  def initialize(parent)
+    @parent = parent
+  end
+
+  def is_running?
+    @parent.target("Service #{@param} is running?")
+    @parent.run "systemctl status #{@param}"
+    @parent.expect_one ['Active:', 'running' ]
+  end
+
+  def is_inactive?
+    @parent.target("Service #{@param} is inactive?")
+    @parent.run "systemctl status #{@param}"
+    @parent.expect_one ['Active:', 'inactive' ]
+  end
+
+  def is_enable?
+    @parent.target("Service #{@param} is enable?")
+    @parent.run "systemctl status #{@param}"
+    @parent.expect_one ['Loaded:', 'enable' ]
+  end
+
+  def is_disable?
+    @parent.target("Service #{@param} is disable?")
+    @parent.run "systemctl status #{@param}"
+    @parent.expect_one ['Loaded:', 'disable' ]
+  end
+end

data/lib/teuton/case_manager/case/builtin/user.rb

@@ -0,0 +1,20 @@
+
+class User
+  attr_accessor :param
+
+  def initialize(parent)
+    @parent = parent
+  end
+
+  def exists?
+    @parent.target("User #{@param} exists?")
+    @parent.run "id #{@param}"
+    @parent.expect_one @param
+  end
+
+  def is_member_of?(groupname)
+    @parent.target("User #{@param} is member of #{groupname}?")
+    @parent.run "id #{@param}"
+    @parent.expect_one [@param, groupname]
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../../application'
+require_relative '../../report/report'
+require_relative '../utils'
+require_relative 'main'
+require_relative 'result/result'
+require_relative 'builtin/main'
+
+# TODO: split Case class into several classes:
+# * Case, Action?, Session?, RunCommand class
+
+# Case class
+# * initialize
+# * export
+# * filename
+# * grade
+# * members
+# * skip
+# * show
+# * read_filename ???
+class Case
+  include DSL
+  include Utils
+
+  attr_accessor :result
+  attr_accessor :action # TODO: why not reader only???
+  attr_reader :id, :config, :uniques, :conn_status
+  @@id = 1
+
+  def initialize(config)
+    app = Application.instance
+    @config = Case::Config.new(local: config, global: app.global)
+    @groups = app.groups
+
+    @id = @@id
+    @@id += 1
+
+    # Define Case Report
+    @report = Report.new(@id)
+    @report.output_dir = File.join('var', @config.global[:tt_testname])
+    ensure_dir @report.output_dir
+
+    # Default configuration
+    @skip = false
+    @skip = get(:tt_skip) unless get(:tt_skip) == 'NODATA'
+    unless app.options['case'].nil?
+      @skip = true
+      @skip = false if app.options['case'].include? @id
+    end
+
+    @conn_status = {}
+    @tmpdir = File.join('var', @config.get(:tt_testname), 'tmp', @id.to_s)
+    # ensure_dir @tmpdir # REVISE: When we will need this? Samba?
+    @remote_tmpdir = File.join('/', 'tmp')
+
+    @unique_values = {}
+    @result = Result.new
+
+    @debug = Application.instance.debug
+    @verbose = Application.instance.verbose
+
+    @action_counter = 0
+    @action = { id: 0,
+                weight: 1.0,
+                description: 'No description!',
+                groupname: nil }
+    @uniques = []
+    @sessions = {} # Store opened sessions for this case
+    tempfile :default
+  end
+
+  def export(format)
+    return if skip?
+    @report.export format
+  end
+
+  def filename
+    @report.filename #+ '.' + @report.format.to_s
+  end
+
+  def grade
+    return 0.0 if skip
+    @report.tail[:grade]
+  end
+
+  def members
+    return '-' if skip
+    @report.head[:tt_members] || 'noname'
+  end
+
+  def skip
+    @skip
+  end
+  alias skip? skip
+
+  def show
+    @report.show
+  end
+
+  private
+
+  def read_filename(filename)
+    begin
+      file = File.open(filename, 'r')
+      item = file.readlines
+      file.close
+      item.map! { |i| i.sub(/\n/, '') }
+      return item
+    rescue StandardError
+      return []
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Class Case#close
+class Case
+  def close(uniques)
+    fails = 0
+    @uniques.each do |key|
+      next unless uniques[key].include?(id) && uniques[key].count > 1
+
+      fails += 1
+      log_unique_message(key, uniques[key])
+    end
+    @report.tail[:unique_fault] = fails
+    @report.close
+  end
+
+  private
+
+  def log_unique_message(key, value)
+    log('UNIQUE:', :error)
+    begin
+      log("   ├── Value     => #{key}", :error)
+      log("   └── Conflicts => #{value}", :error)
+    rescue StandardError => e
+      log(key, :error)
+      log(e.to_s, :error)
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../application'
+
+# Class Case::Config
+# * get
+# * set
+# * unset
+# * missing_method
+class Case
+  # This class manage configuration for only one case
+  class Config
+    attr_reader :ialias, :global, :local, :running
+
+    def initialize(args)
+      @ialias  = args[:alias] || Application.instance.ialias.clone
+      @global  = args[:global] || Application.instance.global.clone
+      @local   = args[:local]  || {}
+      @running = {}
+
+      # Set defaults values
+      @local[:tt_skip] = @local[:tt_skip] || false
+    end
+
+    # Read param Option from [running, config or global] Hash data
+    def get(option, level = 0)
+      return 'NODATA' if level > 3
+
+      return @running[option] if @running[option]
+
+      return @local[option] if @local[option]
+
+      return @global[option] if @global[option]
+
+      search_alias option, level + 1
+    end
+
+    def set(key, value)
+      @running[key] = value
+    end
+
+    def unset(key)
+      @running.delete(key)
+    end
+
+    private
+
+    def search_alias(key, level)
+      return search_array_alias(@ialias[key],level) if @ialias[key].class == Array
+
+      return get(@ialias[key]) if [Integer, String, Symbol].include? @ialias[key].class
+
+      words = key.to_s.split('_')
+      return 'NODATA' if words.size < 2
+
+      return 'NODATA' unless %w[ip hostname username password].include? words[1]
+
+      key2 = @ialias[words[0].to_sym]
+      return 'NODATA' unless key2
+
+      get("#{key2}_#{words[1]}".to_sym, level)
+    end
+
+    def search_array_alias(keys,level)
+      values = []
+      keys.each do |k|
+        if k.class == Symbol
+          values << get(k, level + 1)
+        else
+          values << k
+        end
+      end
+      values.join('')
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require_relative '../../../application'
+
+# DSL#call
+module DSL
+  def check(name, input = {})
+    checks = Application.instance.checks
+    unless checks[name]
+      log("Check #{name} not found!", :error)
+      return
+    end
+    input.each_pair { |k, v| set(k, v) }
+    errors = []
+    checks[name][:args].each do |i|
+      errors << i if get(i) == 'NODATA'
+    end
+    if errors.count > 0
+      log("Check #{name} => required params #{errors.join(',')}",:error)
+    else
+      instance_eval(&checks[name][:block])
+    end
+    input.each_pair { |k, v| unset(k) }
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# DSL#request, DSL#target2
+module DSL
+  def request(text)
+    raise "Deprecated request #{text}"
+    # do nothing by now
+  end
+
+  def command(p_command, args = {})
+    @action[:command] = p_command
+    tempfile(args[:tempfile]) if args[:tempfile]
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# DSL module:
+# * expect_none
+# * expect_one
+# * expect_any
+# * expect
+# * expect2
+# * weight
+module DSL
+  def expect_none(input)
+    if input.class == Array
+      input.each { |i| result.find(i) }
+    else
+      result.find(input)
+    end
+    expect2 result.count.eq(0)
+  end
+
+  def expect_one(input)
+    if input.class == Array
+      input.each { |i| result.find(i) }
+    else
+      result.find(input)
+    end
+    expect2 result.count.eq(1)
+  end
+
+  def expect_any(input)
+    if input.class == Array
+      input.each { |i| result.find(i) }
+    else
+      result.find(input)
+    end
+    expect2 result.count.gt(0)
+  end
+
+  # expect <condition>, :weight => <value>
+  def expect(input, args = {})
+    if input.class == TrueClass || input.class == FalseClass
+      expect2(input, args)
+    elsif input.class == String || input.class == Regexp || input.class == Array
+      expect_any input
+    else
+      puts "[ERROR] expect #{input} (#{input.class})"
+    end
+  end
+
+  def expect2(cond, args = {})
+    @action_counter += 1
+    @action[:id] = @action_counter
+    @action[:check] = cond
+    @action[:result] = @result.value
+
+    @action[:alterations] = @result.alterations
+    @action[:expected] = @result.expected
+    @action[:expected] = args[:expected] if args[:expected]
+
+    @report.lines << @action.clone
+    weight(1.0)
+
+    app = Application.instance
+    c = app.letter[:bad]
+    c = app.letter[:good] if cond
+    verbose c
+  end
+
+  # Set weight value for the action
+  def weight(value = nil)
+    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_manager/case/dsl/getset.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# DSL#get and DSL#set
+module DSL
+  # Read param option from [running, config or global] Hash data
+  def get(option)
+    @config.get(option)
+  end
+
+  def gett(option)
+    value = get(option)
+    "#{value} (#{option})"
+  end
+
+  def set(key, value)
+    @config.set(key, value)
+  end
+
+  def unset(key)
+    @config.unset(key)
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../runner'
+
+# Case->DSL#goto
+module DSL
+  # Run command from the host identify as pHostname
+  # goto :host1, :execute => "command"
+  def goto(host = :localhost, args = {})
+    @result.reset
+    @action[:command] = args[:execute] if args[:execute]
+    @action[:command] = args[:exec] if args[:exec]
+    tempfile(args[:tempfile]) if args[:tempfile]
+    @action[:encoding] = args[:encoding] || 'UTF-8'
+
+    protocol = @config.get("#{host}_protocol".to_sym)
+    ip = @config.get("#{host}_ip".to_sym)
+    start_time = Time.now
+    if (protocol == 'NODATA' || protocol.nil?) &&
+       (host.to_s == 'localhost' || host.to_s.include?('127.0.0.') || ip.include?('127.0.0.'))
+      run_local_cmd
+    elsif ip == 'NODATA'
+      log("#{host} IP not found!", :error)
+    else
+      run_remote_cmd host
+    end
+    @action[:duration] = (Time.now - start_time).round(3)
+  end
+  alias on goto
+
+  def run(command, args = {})
+    args[:exec] = command.to_s
+    goto(:localhost, args)
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# DSL#log
+module DSL
+  def log(text = '', type = :info)
+    s = ''
+    s = Rainbow('WARN!').color(:yellow) if type == :warn
+    s = Rainbow('ERROR').bg(:red) if type == :error
+    t = Time.now
+    f = format('%02d:%02d:%02d', t.hour, t.min, t.sec)
+    @report.lines << "[#{f}] #{s}: #{text}"
+  end
+  alias msg log
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'check'
+require_relative 'expect'
+require_relative 'getset'
+require_relative 'goto'
+require_relative 'log'
+require_relative 'missing'
+require_relative 'send'
+require_relative 'target'
+require_relative 'unique'

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# DSL#missing_method
+module DSL
+  # If a method call is missing, then delegate to concept parent.
+  def method_missing(method, args = {})
+    a = method.to_s
+    return instance_eval("get(:#{a[0, a.size - 1]})") if a[a.size - 1] == '?'
+    return check a[6, a.size], args if a[0,6]=='check_'
+    check a, args
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Case->DSL#
+# * send
+# * tempfile
+# * tempdir
+# * remote_tempdir
+# * remote_tempfile
+module DSL
+  def send(args = {})
+    return if skip?
+
+    return unless args[:copy_to]
+
+    host = args[:copy_to].to_s
+    return unless @conn_status[host].nil?
+
+    ip = get((host + '_ip').to_sym)
+    username = get((host + '_username').to_sym).to_s
+    password = get((host + '_password').to_sym).to_s
+
+    filename = @report.filename + '.' + @report.format.to_s
+    localfilepath = File.join(@report.output_dir, filename)
+    filename = args[:prefix].to_s + filename if args[:prefix]
+
+    if args[:remote_dir]
+      remotefilepath = File.join(args[:remote_dir], filename)
+    else
+      # remotefilepath = File.join(remote_tempdir, filename)
+      remotefilepath = File.join('.', filename)
+    end
+
+    # Upload a file or directory to the remote host
+    begin
+      Net::SFTP.start(ip, username, password: password) do |sftp|
+        sftp.upload!(localfilepath, remotefilepath)
+      end
+      verboseln("=> [ OK  ] #{(get(:tt_members)[0,15]).ljust(16)} : #{remotefilepath}")
+    rescue
+      verboseln("=> [ERROR] #{(get(:tt_members)[0,15]).ljust(16)} : scp #{localfilepath} => #{remotefilepath}")
+    end
+  end
+
+  def tempfile(input = nil)
+    return @action[:tempfile] if input.nil?
+
+    name = input
+    name = 'teuton.tmp' if input == :default
+
+    @action[:tempfile] = File.join(@tmpdir, name)
+    @action[:remote_tempfile] = File.join(@remote_tmpdir, name)
+
+    @action[:tempfile]
+  end
+
+  def tempdir
+    # puts '[WARN] Using DSL.tempdir'
+    @tmpdir
+  end
+
+  def remote_tempfile
+    # puts '[WARN] Using DSL.tempfile'
+    @action[:remote_tempfile]
+  end
+
+  def remote_tempdir
+    @remote_tmpdir
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# DSL#target
+module DSL
+  def readme(_text)
+    # Usefull for "teuton reamde" action.
+  end
+
+  def target(desc, args = {})
+    @action[:description] = desc.to_s
+    @action[:asset] = args[:asset].to_s if args[:asset]
+    w = args[:weight] || 1.0
+    weight(w)
+  end
+  alias goal target
+end