Module: DSL

Included in:
Case
Defined in:
lib/teuton/case_manager/case/dsl/log.rb,
lib/teuton/case_manager/case/dsl/goto.rb,
lib/teuton/case_manager/case/dsl/send.rb,
lib/teuton/case_manager/case/dsl/macro.rb,
lib/teuton/case_manager/case/dsl/expect.rb,
lib/teuton/case_manager/case/dsl/getset.rb,
lib/teuton/case_manager/case/dsl/target.rb,
lib/teuton/case_manager/case/dsl/unique.rb

Overview

DSL#target

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, args = {}) ⇒ Object

If a method call is missing, then:

  • delegate to concept parent.

  • Invoke macro (assert)



33
34
35
36
37
38
39
40
 
# File 'lib/teuton/case_manager/case/dsl/macro.rb', line 33

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]})", __FILE__, __LINE__)
  end
  return macro a[6, a.size], args if a[0, 6] == "macro_"
  macro a, args
end

Instance Method Details

#expect(input, args = {}) ⇒ Object

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



7
8
9
10
11
12
13
14
15
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 7

def expect(input, args = {})
  if input.instance_of?(TrueClass) || input.instance_of?(FalseClass)
    expect2(input, args)
  elsif input.instance_of?(String) || input.instance_of?(Regexp) || input.instance_of?(Array)
    expect_any input
  else
    puts "[TypeError] expect #{input} (#{input.class})"
  end
end

#expect2(cond, args = {}) ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 17

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.colorize(:green)
end

#expect_any(input, args = {}) ⇒ Object 



36
37
38
39
40
41
42
43
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 36

def expect_any(input, args = {})
  if input.instance_of? Array
    input.each { |i| result.find(i) }
  else
    result.find(input)
  end
  expect2 result.count.gt(0), args
end

#expect_first(input, args = {}) ⇒ Object 



45
46
47
48
49
50
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 45

def expect_first(input, args = {})
  @result.first
  output = input
  output = args[:expected] if args[:expected]
  expect2 input, expected: output
end

#expect_last(input, args = {}) ⇒ Object 



52
53
54
55
56
57
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 52

def expect_last(input, args = {})
  @result.last
  output = input
  output = args[:expected] if args[:expected]
  expect2 input, expected: output
end

#expect_none(input, args = {}) ⇒ Object 



59
60
61
62
63
64
65
66
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 59

def expect_none(input, args = {})
  if input.instance_of? Array
    input.each { |i| result.find(i) }
  else
    result.find(input)
  end
  expect2 result.count.eq(0), args
end

#expect_one(input, args = {}) ⇒ Object 



68
69
70
71
72
73
74
75
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 68

def expect_one(input, args = {})
  if input.instance_of? Array
    input.each { |i| result.find(i) }
  else
    result.find(input)
  end
  expect2 result.count.eq(1), args
end

#get(option) ⇒ Object

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



6
7
8
 
# File 'lib/teuton/case_manager/case/dsl/getset.rb', line 6

def get(option)
  @config.get(option)
end

#gett(option) ⇒ Object 



10
11
12
13
 
# File 'lib/teuton/case_manager/case/dsl/getset.rb', line 10

def gett(option)
  value = get(option)
  "#{value} (#{option})"
end

#goto(host = :localhost, args = {}) ⇒ Object Also known as: on

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



22
23
24
25
26
27
28
29
30
31
32
33
 
# 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].to_s if args[:execute]
  @action[:command] = args[:exec].to_s 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

#log(text = "", type = :info) ⇒ Object Also known as: msg

Record log message

Parameters:

  • text (String) (defaults to: "")
  • type (Symbol) (defaults to: :info) —

    Values :info, :warn or :error



10
11
12
13
14
15
16
17
 
# 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

#macro(name, input = {}) ⇒ Object

Invoke macro

Parameters:

  • name (String) —

    Macro name

  • input (Hash) (defaults to: {}) —

    Macro params



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/teuton/case_manager/case/dsl/macro.rb', line 11

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

#readme(_text) ⇒ Object 



5
6
7
 
# File 'lib/teuton/case_manager/case/dsl/target.rb', line 5

def readme(_text)
  # Usefull only for "teuton reamde" command action.
end

#remote_tempdir ⇒ Object 



66
67
68
 
# File 'lib/teuton/case_manager/case/dsl/send.rb', line 66

def remote_tempdir
  @remote_tmpdir
end

#remote_tempfile ⇒ Object 



62
63
64
 
# File 'lib/teuton/case_manager/case/dsl/send.rb', line 62

def remote_tempfile
  @action[:remote_tempfile]
end

#respond_to_missing?(method) ⇒ Boolean

Returns:

  • (Boolean) 


42
43
44
 
# File 'lib/teuton/case_manager/case/dsl/macro.rb', line 42

def respond_to_missing?(method, *)
  true
end

#run(command, args = {}) ⇒ Object

DLS run: It's the same as goto :localhost

Parameters:

  • command (String)
  • args (Hash) (defaults to: {}) 


13
14
15
16
17
18
 
# 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 = {}) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# 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
  port = get((host + "_port").to_sym).to_i
  port = 22 if port.zero?

  filename = "#{@report.filename}.#{@report.format}"
  filename = "#{@report.filename}.txt" if @report.format == :colored_text
  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)
  else
    File.join(".", filename)
  end

  # Upload a file or directory to the remote host
  begin
    Net::SFTP.start(ip, username, password: password, port: port) 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) ⇒ Object 



15
16
17
 
# File 'lib/teuton/case_manager/case/dsl/getset.rb', line 15

def set(key, value)
  @config.set(key, value)
end

#target(desc, args = {}) ⇒ Object Also known as: goal 



9
10
11
12
13
14
 
# 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

#tempdir ⇒ Object 



58
59
60
 
# File 'lib/teuton/case_manager/case/dsl/send.rb', line 58

def tempdir
  @tmpdir
end

#tempfile(input = nil) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/teuton/case_manager/case/dsl/send.rb', line 46

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) ⇒ Object 



4
5
6
7
8
 
# File 'lib/teuton/case_manager/case/dsl/unique.rb', line 4

def unique(key, value)
  return if value.nil?

  @uniques << "#{key}=#{value}".to_sym
end

#unset(key) ⇒ Object 



19
20
21
 
# File 'lib/teuton/case_manager/case/dsl/getset.rb', line 19

def unset(key)
  @config.unset(key)
end

#weight(value = nil) ⇒ Object

Set weight value for the action



78
79
80
81
82
83
84
85
86
 
# File 'lib/teuton/case_manager/case/dsl/expect.rb', line 78

def weight(value = nil)
  if value.nil?
    @action[:weight]
  elsif value == :default
    @action[:weight] = 1.0
  else
    @action[:weight] = value.to_f
  end
end