Class: AuditBenchmark

Inherits:
Object
  • Object
show all
Defined in:
lib/audit/lib/benchmark/audit_benchmark.rb

Direct Known Subclasses

YamlBenchmark

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#item_repository ⇒ Object (readonly)

Returns the value of attribute item_repository.



7
8
9
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 7

def item_repository
  @item_repository
end

Instance Method Details

#automatic_dependencies ⇒ Object 



127
128
129
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 127

def automatic_dependencies()
  return dependencies() - rules()
end

#dependencies ⇒ Object 



123
124
125
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 123

def dependencies()
  return (rules().map {|x| x.dependencies }.flatten()).uniq
end

#duration ⇒ Object

def checks()

  checks = []
  not_traversed = @children.dup

  while !not_traversed.empty? do
    item = not_traversed.shift

    if (item.class == Group) then
      item.children.each do |child|
        not_traversed << child unless not_traversed.include? child
      end
    elsif item.class == Check then
      checks << item
      item.dependencies.each do |dep|
        not_traversed << dep unless not_traversed.include? dep
      end
    end
  end

  return checks
end



153
154
155
156
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 153

def duration()
  #execution_order().flatten().each().inject(0) {|result, element| result + element.duration}
  execution_order().flatten().inject(0) {|result, element| result + element.duration}
end

#element(name) ⇒ Object 



99
100
101
102
103
104
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 99

def element(name)
	@elements = {} unless @elements
	@elements[name] = element_impl(name) unless @elements[name]
	
	return @elements[name]
end

#execution_order ⇒ Object 



9
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 9

def execution_order()
	# resolve dependencies between checks based on the depends-tag of the checks.
	# In a first pass, all dependencies are discovered iteratively popping checks
	# from a queue of checks with unresolved dependencies, pushing them onto a resolved
	# queue and pushing the check's dependencies onto the unresolved queue if they
	# are not yet in the resolved or unresolved queue. Also, the reversed dependencies
	# (which check is needed by which) are stored for the second pass.
	#
	# In a second pass, starting from checks which do not depend on any other checks,
	# all checks are labelled with the dependency level they're in. Checks without dependencies
	# have dependency level 0, checks which rely on checks from level 0 have level 1,
	# and so on. This is not the optimal solution for the problem ... but I have forgot why,
	# so figure this out yourself.
	#
	# You might wonder why I don't do dependency tracking with the Imports and Exports
	# declarations: If there are two scripts which provide a variable (alternatives),
	# it is very easy to write a mediating script, which chooses one of the provider scripts,
	# and then can be depended on, but it is very hard to do the resolution based on 
	# imports and exports. So imagine this like the linker, which uses library/object
	# names to include dependencies, but still checks that all symbols are resolved
	# correctly (TODO: Add a check that all Imports are satisfied by Exports)
	
	#find all dependencies
	items = @children.dup
	
	unresolved = []
	while not items.empty?
		item = items.shift
		if item.class == Group
			item.children.each do|x| 
				items << x unless items.include? x or unresolved.include? x
			end
		elsif item.class == Check
			unresolved << item
		end
	end

	resolved = []
	dependency_root = []
	reversed_dependencies = {}
	iterations = 0
	
	while !unresolved.empty? and iterations < @item_repository.length
		cur = unresolved.shift
		
		dependency_root.push(cur) if cur.dependencies.empty? and not dependency_root.include? cur
		
		cur.dependencies.each do|dep|
			unresolved.push dep unless unresolved.include? dep or resolved.include? dep
			reversed_dependencies[dep] = [] if reversed_dependencies[dep].nil?
			reversed_dependencies[dep] << cur
		end
	end
	
	untagged = []
	tagged = []
	
	dependency_root.each {|x| untagged.push(x)}
	untagged.push(:NEXT_LEVEL)
	
	level = 0
	while untagged.length > 1
		cur = untagged.shift
		
		if cur == :NEXT_LEVEL then
			level = level + 1
			untagged.push(:NEXT_LEVEL)
			next
		end
		
		tag = tagged.select {|x| x[:check] == cur}
		if tag.empty? then
			tagged << {:level => level, :check => cur}  
		else 
			raise "multiple tags for check #{cur.id} found" if tag.length != 1
			
			tag[0][:level] = level
		end
		
		unless reversed_dependencies[cur].nil? then
			reversed_dependencies[cur].each {|x| untagged.push(x)}
		end
	end
	
	retval = []
	(0 .. level).each {|i| retval.push(tagged.select {|x| x[:level] == i}.map {|x| x[:check]})}
	
	return retval
end

#rules ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 106

def rules()
  untraversed = @children.dup
  rules = []

  while untraversed.length > 0
    item = untraversed.shift

    if item.kind_of? Group then
      untraversed = untraversed + item.children
    elsif item.kind_of? Check then
      rules << item
    end
  end

  return rules.uniq
end

#to_hash ⇒ Object 



158
159
160
161
162
163
164
165
166
 
# File 'lib/audit/lib/benchmark/audit_benchmark.rb', line 158

def to_hash()
  return {
    :type => :BENCHMARK,
    :id => @id,
    :name => @name,
    :description => @description,
    :children => Lazy.new(Lazy.new(@children, :reject) {|x| !x.in_report?}, :map) {|child| Lazy.new(child, :to_hash)}
  }
end