cloud-toaster 1.1.2

data/lib/toaster/state/convergence.rb

@@ -0,0 +1,197 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/markup/markup_util"
+require "toaster/state/system_state"
+
+include Toaster
+
+module Toaster
+  class Convergence
+
+    def self.convergence_for_automation(automation, prop_value_percentage_threshold=0.7)
+      conv_props = {}
+      conv_props_list = []
+      TimeStamp.add(nil, "conv_for_auto")
+      # NOTE: our assumption here is that the tasks 
+      # are returned in sequential order..!
+      tasks = automation.get_globally_executed_tasks()
+      tasks.each_with_index do |task,task_index|
+        convergence_for_task(task, prop_value_percentage_threshold).each do |conv_prop|
+          prop_name = conv_prop[0]
+          if conv_props[prop_name] && conv_props[prop_name] != conv_prop
+            #puts "INFO: Overwriting convergent property '#{prop_name}' with new value: #{conv_props[prop_name]} => #{conv_prop}"
+          end
+          conv_props[prop_name] = conv_prop
+        end
+        #conv_props.concat(convergence_for_task(task))
+        conv_props_list = conv_props.values
+        #conflicts = get_prop_conflicts(conv_props_list)
+        #if !conflicts.empty?
+        #  puts "WARN: found conflicting properties in convergence: #{conflicts.inspect}"
+        #end
+      end
+      TimeStamp.add_and_print("compute convergence of automation", nil, "conv_for_auto") { |duration| duration > 15 }
+      return conv_props_list
+    end
+
+    def self.convergence_for_task(task, prop_value_percentage_threshold=0.7)
+      ch = task.global_state_prop_changes.to_a.dup
+      ps = task.global_post_states.to_a.dup
+      # eliminate inserted map entries in post states
+      ps.each do |p|
+        MarkupUtil.eliminate_inserted_map_entries!(p)
+      end
+      # remove ignored properties from post states
+      ignore_props = SystemState.read_ignore_properties()
+      ps.each do |p|
+        SystemState.remove_ignore_props!(p, ignore_props)
+      end
+      # remove ignored properties from state changes
+      SystemState.remove_ignore_props!(ch, ignore_props)
+
+      return convergence_for_prop_changes(ch, ps, prop_value_percentage_threshold)
+    end
+
+    #
+    # Args:
+    #  - prop_changes: Should contain an array of 
+    #       Toaster::StateChange objects.
+    #  - post_states: Total collection of post-states
+    #  - min_percentage: minimum occurrence percentage (over 
+    #       all post-states) required for a property to be 
+    #       considered as convergent.
+    # 
+    def self.convergence_for_prop_changes(prop_changes, 
+        post_states, min_percentage=0.5)
+      candidates = get_convergence_candidates(prop_changes)
+      result = []
+      candidates.each do |prop|
+        property_name = prop[0]
+        value = prop[1]
+        values_equal = get_states_equal(post_states, property_name, value)
+        percentage = values_equal.size.to_f / post_states.size.to_f
+        if percentage >= min_percentage
+          new_val = [property_name, value, percentage, values_equal.size, post_states.size]
+          if !result.include?(new_val)
+            result << new_val
+          end
+        end
+      end
+      return result
+    end
+
+    def self.get_convergence_candidates(prop_changes)
+      cands = Set.new
+      prop_changes.each do |pc|
+        value = pc.action == StateChange::ACTION_DELETE ? nil : 
+                pc.action == StateChange::ACTION_INSERT ? pc.value :
+                pc.action == StateChange::ACTION_MODIFY ? pc.value : nil;
+        cands << [pc.property, value, pc.task_execution.start_time]
+      end
+      return cands
+    end
+
+    def self.get_states_equal(post_states, property_name, value)
+      result = []
+      post_states.each do |ps|
+        value1 = nil
+        error = nil
+        begin
+          value1 = MarkupUtil.get_value_by_path(ps, property_name)
+        rescue => ex
+          error = ex
+        end
+        if !value.nil? && value1.nil?
+          error_text = "#{error}"
+          #puts "Expected value on property evaluation, but got exception: #{error_text[0..200]}..."
+          #puts "Property change: #{property_name}"
+        elsif value.nil? && !value1.nil?
+          # raise "Expected exception on property evaluation, but got value: #{value1}"
+        end
+        if value == value1 || value.eql?(value1)
+          result << ps
+        end
+      end
+      return result
+    end
+
+    #
+    # Args:
+    #   - prop_values: list of Toaster::StateProperty objects
+    #
+    def self.get_prop_conflicts(prop_values)
+      confl = []
+      for i in (0..(prop_values.size - 1))
+        for j in ((i+1)..(prop_values.size - 1))
+          p1_key = prop_values[i][0]
+          p2_key = prop_values[j][0]
+          p1_value = prop_values[i][1]
+          p2_value = prop_values[j][1]
+          if p1_key == p2_key
+            if p1_value != p2_value
+              confl << [p1_key,p1_value,p2_value]
+            end
+          end
+        end
+      end
+      return confl
+    end
+
+    # automation_run --> prop_key --> list of (task_execution,prop_value)
+    def self.execution_traces(automation, property_patterns)
+      tmp = {}
+      task_execs = automation.get_task_execs_by_run
+      # list of property keys
+      prop_keys = Set.new
+      # build tmp result hash
+      task_execs.each do |run,exes|
+        tmp[run] = {}
+        exes.unshift(TaskExecution.new(nil,nil,nil,[],"start"))
+        exes.each_with_index do |exe,idx|
+          if exe.kind_of?(TaskExecution)
+            pre_state = MarkupUtil.clone(exe.state_before) || {}
+            post_state = MarkupUtil.clone(exe.state_after) || {}
+            MarkupUtil.eliminate_inserted_map_entries!(pre_state)
+            MarkupUtil.eliminate_inserted_map_entries!(post_state)
+            pres = SystemState.get_flat_attributes(pre_state)
+            posts = SystemState.get_flat_attributes(post_state)
+            pres.each do |pre,pre_val|
+              if Util.match_any(pre, property_patterns)
+                prop_keys << pre
+                tmp[run][pre] = {} if !tmp[run][pre]
+                prev_exe = exes[idx - 1]
+                tmp[run][pre][prev_exe.uuid] = MarkupUtil.get_value_by_path(pre_state, pre)
+              end
+            end
+            posts.each do |post,post_val|
+              if Util.match_any(post, property_patterns)
+                prop_keys << post
+                tmp[run][post] = {} if !tmp[run][post]
+                tmp[run][post][exe.uuid] = MarkupUtil.get_value_by_path(post_state, post)
+              end
+            end
+          end
+        end
+      end
+      # build result hash
+      result = {}
+      task_execs.each do |run,exes|
+        result[run] = {}
+        prop_keys.each do |prop|
+          result[run][prop] = []
+          exes.each do |exe|
+            uuid = exe.uuid
+            exe = nil if exe.uuid == "start"
+            result[run][prop] << [exe, tmp[run][prop][uuid]]
+          end
+        end
+      end
+      return result
+    end
+
+  end
+end

data/lib/toaster/state/idempotence.rb

@@ -0,0 +1,192 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/markup/markup_util"
+
+include Toaster
+
+module Toaster
+  class Idempotence
+
+    def initialize(test_suite)
+      @test_suite = test_suite
+      @repeated_task_execs = nil
+      @non_idempotent_tasks_details = nil
+      @non_idempotent_taskseqs_details = nil
+    end
+
+    def non_idempotent_task_seq(consider_success_of_tasks=false)
+      result = []
+      non_idempotent_taskseqs_details(consider_success_of_tasks).each do |tsk,details|
+        result << tsk
+      end
+      return result
+    end
+
+    def non_idempotent_tasks(consider_success_of_tasks=true)
+      result = []
+      non_idempotent_tasks_details(consider_success_of_tasks).each do |tsk,details|
+        result << tsk
+      end
+      return result
+    end
+
+    # returns:
+    # task_seq -> test_case -> ["execs"] -> [seq_of_task_exections ...]
+    # task_seq -> test_case -> ["changes"] -> seq_of_task_exections -> [state_changes ...]
+    def non_idempotent_taskseqs_details(consider_success_of_tasks=false)
+      return @non_idempotent_taskseqs_details if @non_idempotent_taskseqs_details
+      result = {}
+      repeated_task_executions().each do |tc,task_array_to_execs|
+        task_array_to_execs.each do |task_array,execs|
+
+          task_array = task_array.collect { |t_uuid| Task.find("uuid"=>t_uuid)[0] }
+
+          execs.each_with_index do |exec_seq,idx|
+            pre_state = MarkupUtil.clone(exec_seq[0].state_before)
+            MarkupUtil.eliminate_inserted_map_entries!(pre_state)
+            post_state = SystemState.reconstruct_state_from_execs_seq(exec_seq)
+            #puts "DEBUG: comparing pre-state and reconstructed post-state:\n#{pre_state}\n#{post_state}"
+            state_changes = SystemState.get_state_diff(pre_state, post_state)
+            SystemState.remove_ignore_props!(state_changes)
+
+            if state_changes.empty? && idx == 0
+              # non_state_change_tasks << task_array
+            elsif idx > 0
+              # an idempotent task (sequence) should:
+              # - not yield a state change after first execution
+              # - always yield a success if the first run was successful
+              if !state_changes.empty? || 
+                (consider_success_of_tasks && 
+                  (execs[idx-1][-1].success && !exec_seq[-1].success))
+                # we need to be careful here: for some reason we have seen cases where
+                # rel_start_time is negative (!) which is in fact impossible. Hence, we leave
+                # out those cases until this problem is resolved, to be on the safe side..
+                rel_start_time = exec_seq[0].start_time - tc.automation_run.start_time
+                if rel_start_time >= 0
+                  task_array_uuids = task_array.collect{|tmp| tmp.uuid}
+                  puts "INFO: Non-idempotence detected in repeated " +
+                    "execution of task sequence #{task_array_uuids} in test case #{tc.uuid}:\n--> #{state_changes}"
+                  result[task_array] = {} if !result[task_array]
+                  result[task_array][tc] = {} if !result[task_array][tc]
+                  result[task_array][tc]["execs"] = [] if !result[task_array][tc]["execs"]
+                  result[task_array][tc]["changes"] = {} if !result[task_array][tc]["changes"]
+                  # add first execution sequence, if not yet added 
+                  result[task_array][tc]["execs"] << execs[idx-1] if result[task_array][tc]["execs"].empty?
+                  # add next execution sequence
+                  result[task_array][tc]["execs"] << exec_seq
+                  result[task_array][tc]["changes"][exec_seq] = state_changes
+                else
+                  puts "WARN: Start time of task execution '#{exec_seq[0].uuid}' " +
+                    "(#{exec_seq[0].start_time}) is before automation run start time " +
+                    "(#{tc.automation_run.start_time})!"
+                end
+              end
+            end
+          end
+        end
+      end
+      @non_idempotent_taskseqs_details = result
+      return result
+    end
+
+    # returns:
+    # task -> test_case -> list_of_task_exections
+    def non_idempotent_tasks_details(consider_success_of_tasks=true)
+      return @non_idempotent_tasks_details if @non_idempotent_tasks_details
+      result = {}
+      non_state_change_tasks = Set.new
+      repeated_task_executions().each do |tc,task_array_to_execs|
+        task_array_to_execs.each do |task_array,execs|
+          execs.each_with_index do |exec_sequence,idx|
+            exec_sequence.each_with_index do |exec,task_idx_in_sequence|
+              # get "relevant" state changes (without ignored  
+              # properties such as file modification time etc)
+              state_changes = exec.relevant_state_changes
+              if state_changes.empty? && idx == 0
+                non_state_change_tasks << exec.task
+              elsif idx > 0
+                # an idempotent task should:
+                # - not yield a state change after first execution
+                # - always yield a success if the first run was successful
+                if !state_changes.empty? || 
+                  (consider_success_of_tasks && 
+                    (execs[idx-1][task_idx_in_sequence].success && !exec.success))
+                  # we need to be careful here: for some reason we have seen cases where
+                  # rel_start_time is negative (!) which is in fact impossible. Hence, we leave
+                  # out those cases until this problem is resolved, to be on the safe side..
+                  rel_start_time = exec.start_time - tc.automation_run.start_time
+                  if rel_start_time >= 0
+                    puts "INFO: Non-idempotence: State changes detected in repeated execution of task uuid #{exec.task.uuid} in test case #{tc.uuid}"
+                    result[exec.task] = {} if !result[exec.task]
+                    result[exec.task][tc] = [] if !result[exec.task][tc]
+                    # add first execution, if not yet added 
+                    result[exec.task][tc] << execs[idx-1][task_idx_in_sequence] if result[exec.task][tc].empty?
+                    # add next execution
+                    result[exec.task][tc] << exec
+                  else
+                    puts "WARN: Start time of task execution '#{exec.uuid}' (#{exec.start_time}) is before automation run start time (#{tc.automation_run.start_time})!"
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+      non_state_change_task_uuids = non_state_change_tasks.collect() { |t| t.uuid }
+      puts "DEBUG: No state change detected in first execution of #{non_state_change_tasks.size} tasks:" if !non_state_change_tasks.empty?
+      non_state_change_tasks.each do |task|
+        puts task.name
+#          puts task.sourcecode
+#          puts "--------------"
+      end
+      puts "--------------"
+      @non_idempotent_tasks_details = result
+      return result
+    end
+
+    # returns:
+    # test_case_id --> task_combination --> [task_execution_list ...]
+    def repeated_task_executions()
+      return @repeated_task_execs if @repeated_task_execs
+      result = {}
+      tasks = {}
+      @test_suite.test_cases.each do |tc|
+        if tc.automation_run
+          tc.repeat_task_uuids.each do |rt|
+            #puts "#{rt.inspect}"
+            rt = [rt] if !rt.kind_of?(Array)
+            tc_id = tc #tc.uuid
+            result[tc_id] = {} if !result[tc_id]
+            result[tc_id][rt] = [] if !result[tc_id][rt]
+            rt.each do |repeated_task|
+              #execs = tc.task_executions(repeated_task)
+              #tasks[repeated_task] = Task.find("uuid"=>repeated_task)[0] if !tasks[repeated_task]
+              tasks[repeated_task] = @test_suite.automation.get_task(repeated_task, true)
+              #puts "===> #{tasks[repeated_task]}"
+              execs = TaskExecution.find(
+                  {"task_id"=>tasks[repeated_task].id, "automation_run_id"=>tc.automation_run.id},
+                  {"task" => tasks[repeated_task], "automation_run" => tc.automation_run}
+              )
+              execs.sort! { |a,b|
+                a.start_time <=> b.start_time
+              }
+              execs.each_with_index do |exec,idx|
+                if result[tc_id][rt].size <= idx
+                  result[tc_id][rt] << []
+                end
+                result[tc_id][rt][idx] << exec
+              end
+            end
+          end
+        end
+      end
+      @repeated_task_execs = result
+      return result
+    end
+
+  end
+end

data/lib/toaster/state/ptrace_util.rb

@@ -0,0 +1,48 @@
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/state/transition_edge"
+require "toaster/markup/markup_util"
+
+include Toaster
+
+module Toaster
+
+  class PtraceUtil
+
+    WORD_SIZE = 8
+
+    def self.read_string(ptrace_target, addr)
+      str = ""
+      do_continue = true
+      iter = 0
+      while do_continue
+        v = ptrace_target.text.peek(addr + (WORD_SIZE * iter))
+        (0..7).each do |shift_bytes|
+          shift = 8 * shift_bytes
+          byte = (v >> shift) & 0xFF
+          if byte == 0
+            #puts "END OF STRING!!"
+            do_continue = false
+            break
+          end
+          str += byte.chr
+        end
+        iter += 1
+      end
+      return str
+    end
+
+    def self.get_filename_for_fd(pid, fd)
+      path = "/proc/#{pid}/fd/#{fd}"
+      begin
+        return File.readlink(path)
+      rescue
+        return nil
+      end
+    end
+
+  end
+end

data/lib/toaster/state/state_node.rb

@@ -0,0 +1,105 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/state/transition_edge"
+require "toaster/markup/markup_util"
+
+include Toaster
+
+module Toaster
+
+  class StateNode
+    attr_reader :properties, :incoming, :outgoing
+    attr_accessor :preceding_task, :succeeding_task
+
+    def initialize(properties = {})
+      @properties = properties
+      @incoming = Set.new
+      @outgoing = Set.new
+      @preceding_task = nil
+      @succeeding_task = nil
+      @reachable_nodes = nil
+    end
+
+    # determine whether the state properties of this node are a 
+    # subset of (or equal to) the properties of the given state
+    def subset_of?(state, ignore_properties=[])
+      @properties.each do |prop,val|
+        if !ignore_properties.include?(prop)
+          val1 = MarkupUtil.get_value_by_path(state, prop, true)
+          contained = (val1 == val || val1.eql?(val))
+          if !contained
+            #puts "property '#{prop}'='#{val}' is not contained in state hash with #{state.size} properties"
+            #puts "property '#{prop}'='#{val}' is not contained in #{state.inspect}"
+          else
+            #puts "'#{prop}'='#{val}' IS contained in state"
+          end
+          return false if !contained
+        end
+      end
+      return true
+    end
+
+    def conflicts_with?(node, ignore_properties=[])
+      return !subset_of?(node.properties, ignore_properties) && 
+              !node.subset_of?(properties, ignore_properties)
+    end
+
+    def state_merge(additional_new_state)
+      @properties.merge(additional_new_state)
+    end
+
+    def satisfies_poststate(post)
+      post.each do |key,value|
+        if @properties[key] != value
+          return false
+        end
+      end
+      return true
+    end
+
+    def self.state_merge(old_node, additional_new_state)
+      return old_node.state_merge(additional_new_state)
+    end
+
+    def reachable?(node, check_cycles=true)
+      return node_reachable?(node, check_cycles)
+    end
+
+    def node_reachable?(node, check_cycles=true, nodes_visited=Set.new)
+      return reachable_nodes().include?(node)
+    end
+
+    def reachable_nodes()
+      return @reachable_nodes if @reachable_nodes
+      @reachable_nodes = get_reachable_nodes()
+      return @reachable_nodes
+    end
+
+    def get_reachable_nodes(nodes_so_far=Set.new)
+      stack = [self]
+      while !stack.empty?
+        node = stack.delete_at(0)
+        if !nodes_so_far.include?(node)
+          nodes_so_far << node
+          node.outgoing.each do |edge|
+            next_node = edge.node_to
+            stack << next_node
+            #next_node.get_reachable_nodes(nodes_so_far)
+          end
+        end
+      end
+      return nodes_so_far
+    end
+
+  end
+
+  class StateNodeInitial < StateNode
+  end
+  class StateNodeFinal < StateNode
+  end
+
+end

data/lib/toaster/state/state_transition.rb

@@ -0,0 +1,38 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+include Toaster
+
+module Toaster
+
+  class StateTransition
+
+    attr_accessor :pre_state, :parameters, :post_state
+
+    def initialize(pre_state={}, parameters={}, post_state={})
+      @pre_state = pre_state
+      @parameters = parameters
+      @post_state = post_state
+    end
+
+    def eql?(obj)
+      return false if !obj.kind_of?(StateTransition)
+      return obj.pre_state.eql?(@pre_state) && 
+              obj.parameters.eql?(@parameters) && 
+              obj.post_state.eql?(@post_state)
+    end
+
+    def ==(obj)
+      return eql?(obj)
+    end
+
+    def hash()
+      return @pre_state.hash + @parameters.hash + @post_state.hash
+    end
+
+  end
+
+end