module DSL

DSL module:

DSL#get and DSL#set

Case class -> DSL module:

Define DSL#log function

DSL module methods: assert, missing_method

Case->DSL#

DSL#target

Case#DSL#unique

Public Instance Methods

expect(input, args = {}) click to toggle source

expect <condition>, :weight => <value>

# File lib/teuton/case_manager/case/dsl/expect.rb, line 41
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
expect2(cond, args = {}) click to toggle source
# File lib/teuton/case_manager/case/dsl/expect.rb, line 51
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 Rainbow(c).yellow.bright
end
expect_any(input) click to toggle source
# File lib/teuton/case_manager/case/dsl/expect.rb, line 31
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_none(input) click to toggle source
# File lib/teuton/case_manager/case/dsl/expect.rb, line 13
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
expect_one(input) click to toggle source
# File lib/teuton/case_manager/case/dsl/expect.rb, line 22
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
get(option) click to toggle source

Read param option from [running, config or global] Hash data

# File lib/teuton/case_manager/case/dsl/getset.rb, line 6
def get(option)
  @config.get(option)
end
gett(option) click to toggle source
# File lib/teuton/case_manager/case/dsl/getset.rb, line 10
def gett(option)
  value = get(option)
  "#{value} (#{option})"
end
goal(desc, args = {})
Alias for: target
goto(host = :localhost, args = {}) click to toggle source

Run command from the host identify as pHostname goto :host1, :execute => “command”

# File lib/teuton/case_manager/case/dsl/goto.rb, line 22
def goto(host = :localhost, args = {})
  @result.reset
  args[:on] = host unless args[:on]
  @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'

  start_time = Time.now
  run_cmd_on(host)
  @action[:duration] = (Time.now - start_time).round(3)
end
Also aliased as: on
log(text = '', type = :info) click to toggle source

Record log message @param text (String) @param type (Symbol) Values :info, :warn or :error

# File lib/teuton/case_manager/case/dsl/log.rb, line 10
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('%<hour>02d:%<min>02d:%<sec>02d',
             { hour: t.hour, min: t.min, sec: t.sec })
  @report.lines << "[#{f}] #{s}: #{text}"
end
Also aliased as: msg
macro(name, input = {}) click to toggle source

Invoke macro @param name (String) Macro name @param input (Hash) Macro params

# File lib/teuton/case_manager/case/dsl/macro.rb, line 10
def macro(name, input = {})
  macros = Application.instance.macros
  unless macros[name]
    log("Macro #{name} not found!", :error)
    return
  end
  input.each_pair { |k, v| set(k, v) }
  errors = []
  macros[name][:args].each do |i|
    errors << i if get(i) == 'NODATA'
  end
  if errors.count > 0
    log("Macro #{name} => required params #{errors.join(',')}",:error)
  else
    instance_eval(&macros[name][:block])
  end
  input.each_pair { |k, v| unset(k) }
end
method_missing(method, args = {}) click to toggle source

If a method call is missing, then:

  • delegate to concept parent.

  • Invoke macro (assert)

# File lib/teuton/case_manager/case/dsl/macro.rb, line 32
def method_missing(method, args = {})
  a = method.to_s
  if a.start_with?('_') && a.end_with?('_')
    return instance_eval("get(:#{a[1, a.size - 2]})")
  end
  return macro a[6, a.size], args if a[0,6]=='macro_'
  macro a, args
end
msg(text = '', type = :info)
Alias for: log
on(host = :localhost, args = {})
Alias for: goto
readme(_text) click to toggle source
# File lib/teuton/case_manager/case/dsl/target.rb, line 5
def readme(_text)
  # Usefull only for "teuton reamde" command action.
end
remote_tempdir() click to toggle source
# File lib/teuton/case_manager/case/dsl/send.rb, line 66
def remote_tempdir
  @remote_tmpdir
end
remote_tempfile() click to toggle source
# File lib/teuton/case_manager/case/dsl/send.rb, line 61
def remote_tempfile
  # puts '[WARN] Using DSL.tempfile'
  @action[:remote_tempfile]
end
run(command, args = {}) click to toggle source

DLS run: It's the same as goto :localhost @param command (String) @param args (Hash)

# File lib/teuton/case_manager/case/dsl/goto.rb, line 13
def run(command, args = {})
  args[:exec] = command.to_s
  host = :localhost
  host = args[:on] if args[:on]
  goto(host, args)
end
send(args = {}) click to toggle source
# File lib/teuton/case_manager/case/dsl/send.rb, line 10
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
set(key, value) click to toggle source
# File lib/teuton/case_manager/case/dsl/getset.rb, line 15
def set(key, value)
  @config.set(key, value)
end
target(desc, args = {}) click to toggle source
# File lib/teuton/case_manager/case/dsl/target.rb, line 9
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
Also aliased as: goal
tempdir() click to toggle source
# File lib/teuton/case_manager/case/dsl/send.rb, line 56
def tempdir
  # puts '[WARN] Using DSL.tempdir'
  @tmpdir
end
tempfile(input = nil) click to toggle source
# File lib/teuton/case_manager/case/dsl/send.rb, line 44
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
unique(key, value) click to toggle source
# File lib/teuton/case_manager/case/dsl/unique.rb, line 5
def unique(key, value)
  return if value.nil?

  k = (key.to_s + '=' + value.to_s).to_sym
  @uniques << k
end
unset(key) click to toggle source
# File lib/teuton/case_manager/case/dsl/getset.rb, line 19
def unset(key)
  @config.unset(key)
end
weight(value = nil) click to toggle source

Set weight value for the action

# File lib/teuton/case_manager/case/dsl/expect.rb, line 71
def weight(value = nil)
  if value.nil?
    @action[:weight]
  elsif value == :default
    @action[:weight] = 1.0
  else
    @action[:weight] = value.to_f
  end
end