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?("_")
    return instance_eval("get(:#{a[1, a.size - 1]})", __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>



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

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 Rainbow("[TypeError] expect #{input} (#{input.class})").red
  end
end

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



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

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

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



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

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 



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

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 



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

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 



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

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 



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

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



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

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 



68
69
70
 
# File 'lib/teuton/case_manager/case/dsl/send.rb', line 68

def remote_tempdir
  @remote_tmpdir
end

#remote_tempfile ⇒ Object 



64
65
66
 
# File 'lib/teuton/case_manager/case/dsl/send.rb', line 64

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
45
46
 
# 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
    msg = Rainbow("[ OK  ] #{(get(:tt_members)[0, 15]).ljust(16)} : #{remotefilepath}").green
    verboseln(msg)
  rescue
    msg = Rainbow("[ERROR] #{(get(:tt_members)[0, 15]).ljust(16)} : scp #{localfilepath} => #{remotefilepath}").red
    verboseln(msg)
  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 



60
61
62
 
# File 'lib/teuton/case_manager/case/dsl/send.rb', line 60

def tempdir
  @tmpdir
end

#tempfile(input = nil) ⇒ Object 



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

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



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

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