cloud-toaster 1.1.5 → 1.1.6

data/lib/toaster/chef/failsafe_resource_parser.rb

@@ -70,6 +70,7 @@ class ::Chef
           super
         rescue Object => ex
           puts "WARN: cannot run instance_eval on recipe: #{ex} - #{ex.backtrace.join("\n")}"
+          puts "WARN: eval string was: #{string}"
         end
       end
       def method_missing(method_symbol, *args, &block)

data/lib/toaster/chef/resource_inspector.rb

@@ -45,7 +45,7 @@ module Toaster
         param = param[0].strip
         param = MarkupUtil.convert_array_to_dot_notation(param)
         if task_or_sourcecode.kind_of?(Task)
-          param = TaskParameter.new(task_or_sourcecode, param)
+          param = TaskParameter.new(:task => task_or_sourcecode, :key => param)
         else
           param = TaskParameter.new(:key => param)
         end

data/lib/toaster/model/automation.rb

@@ -18,11 +18,12 @@ module Toaster
   class Automation < ActiveRecord::Base
 
     belongs_to :user
-    has_many :tasks, nil, {:autosave => true, :dependent => :delete_all}
-    has_many :automation_attributes, nil, {:autosave => true, :dependent => :delete_all}
-    has_many :ignore_properties, nil, {:class_name => IgnoreProperty, :autosave => true, :dependent => :delete_all}
-    has_many :additional_properties, nil, {:class_name => AdditionalProperty, :autosave => true, :dependent => :delete_all}
-    has_many :automation_runs, nil, {:autosave => true, :dependent => :delete_all}
+    has_many :tasks, :autosave => true, :dependent => :destroy
+    has_many :test_suites, :autosave => true, :dependent => :destroy
+    has_many :automation_attributes, :autosave => true, :dependent => :destroy
+    has_many :ignore_properties, :autosave => true, :dependent => :destroy
+    has_many :additional_properties, :autosave => true, :dependent => :destroy
+    has_many :automation_runs, :autosave => true, :dependent => :destroy
 
     #attr_accessor :tasks, :attributes,
     attr_accessor  :chef_run_list, :additional_state_configs, :version
@@ -43,6 +44,19 @@ module Toaster
       return tasks
     end
 
+    # collect the executed state transitions of
+    # all tasks contained in this automation
+    def global_state_transitions()
+      result = Set.new
+      get_globally_executed_tasks().each do |task|
+        result += task.global_state_transitions
+      end
+      return result
+    end
+    def num_global_state_transitions()
+      global_state_transitions().size
+    end
+
     # 
     # return a map AutomationRun -> (list of TaskExecution)
     #
@@ -56,6 +70,11 @@ module Toaster
       return result
     end
 
+    def get_all_test_cases()
+      TestCase.joins(:automation_run => :automation).where(
+        "automations.id = #{self.id}")
+    end
+
     def is_chef?
       "#{language}".casecmp("chef") == 0
     end
@@ -137,12 +156,12 @@ module Toaster
     def get_task(task_id, check_automation_runs=false)
       task_id = task_id.to_s
       tasks.each do |t| 
-        return t if t.id.to_s == task_id || t.uuid.to_s == task_id
+        return t if (t.id.to_s == task_id || t.uuid.to_s == task_id)
       end
       if check_automation_runs
         automation_runs().each do |r|
           r.task_executions().each do |exe|
-            if exe.task && exe.task.uuid.to_s == task_id || exe.task.uuid.to_s == task_id
+            if exe.task && (exe.task.id.to_s == task_id || exe.task.uuid == task_id)
               return exe.task
             end
           end

data/lib/toaster/model/automation_run.rb

@@ -18,8 +18,8 @@ module Toaster
 
     belongs_to :user
     belongs_to :automation
-    has_many :task_executions, nil, {:autosave => true, :dependent => :delete_all}
-    has_many :run_attributes, nil, {:autosave => true, :dependent => :delete_all}
+    has_many :task_executions, :autosave => true, :dependent => :destroy
+    has_many :run_attributes, :autosave => true, :dependent => :destroy
 
     # FIELDS: 
     #  :uuid, :machine_id, :automation, :start_time, 
@@ -86,15 +86,6 @@ module Toaster
       return end_time - start_time
     end
 
-    def self.load(id, automation = nil)
-      id = DB.instance.wrap_db_id(id)
-      preset_fields = {}
-      preset_fields["automation"] = automation if automation
-      runs = find({"_id" => id}, preset_fields)
-      return nil if !runs || runs.empty?
-      return runs[0]
-    end
-
     def self.find(criteria={})
       DB.find_activerecord(AutomationRun, criteria)
     end

data/lib/toaster/model/key_value_pair.rb

@@ -37,7 +37,19 @@ module Toaster
       }
       return result
     end
-    
+
+    def self.flat_attributes_from_hash(hash, clazz=KeyValuePair)
+      result = []
+      return result if !hash
+      SystemState.get_flat_attributes(hash).each do |key,value|
+        result << clazz.new(
+          :key => key,
+          :value => value
+        )
+      end
+      return result
+    end
+
     def to_s
       return "#{self.class}(#{key}=#{value})"
     end

data/lib/toaster/model/task.rb

@@ -14,8 +14,8 @@ require "toaster/chef/resource_inspector"
 module Toaster
   class Task < ActiveRecord::Base
 
-    has_many :task_parameters
-    has_many :task_executions
+    has_many :task_parameters, :autosave => true, :dependent => :destroy
+    has_many :task_executions, :autosave => true, :dependent => :destroy
     belongs_to :automation
 
     attr_accessor :resource_obj
@@ -271,12 +271,12 @@ module Toaster
       params = {
         :resource => resource.to_s,
         :action => action,
-        :sourcecode => sourcecode,
         :sourcefile => sourcefile,
         :sourceline => sourceline
       }
       task = find_by(params)
       if !task
+        params[:sourcecode] = sourcecode
         task = Task.new(params)
       end
       task.resource_obj = resource

data/lib/toaster/model/task_execution.rb

@@ -15,7 +15,7 @@ module Toaster
 
     belongs_to :task
     belongs_to :automation_run
-    has_many :state_changes
+    has_many :state_changes, :autosave => true, :dependent => :destroy
     serialize :state_before, JSON
     serialize :state_after, JSON
 
@@ -68,7 +68,8 @@ module Toaster
     end
 
     def self.load_all_for_automation(auto)
-      return joins(:automation_run).where(:automation_run => {:automation_id => auto.id})
+      return joins(:automation_run).where(
+        :automation_runs => {:automation_id => auto.id})
     end
 
   end

data/lib/toaster/model/task_parameter.rb

@@ -9,14 +9,7 @@ require "toaster/model/key_value_pair"
 module Toaster
   class TaskParameter < KeyValuePair
 
-    @@id_attributes = ["task_id", "key", "value", "type"]
-
-    def initialize(attr_hash)
-      if !attr_hash[:uuid]
-        attr_hash[:uuid] = Util.generate_short_uid()
-      end
-      super(attr_hash)
-    end
+    belongs_to :task
 
     def self.find(criteria={}, preset_fields={})
       criteria["db_type"] = "task_parameter" if !criteria["db_type"]
@@ -30,22 +23,22 @@ module Toaster
       return objs
     end
 
-    def self.load(uuid_or_task, key = nil, value = nil, type = nil, constraints = [])
-      param = TaskParameter.new(nil, nil)
-      hash = {}
-      if !uuid_or_task.kind_of?(Task)
-        uuid = uuid_or_task
-        return nil if !uuid
-        criteria = {"uuid" => uuid, "db_type" => "task_parameter"}
-        hash = DB.instance.find_one(criteria)
-      else
-        task = uuid_or_task
-        param = TaskParameter.new(task, key, value, type, constraints)
-        hash = DB.instance.get_or_insert(param.to_hash(), @@id_attributes)
-      end
-      param = DB.apply_values(param, hash)
-      return param
-    end
+#    def self.load(uuid_or_task, key = nil, value = nil, type = nil, constraints = [])
+#      param = TaskParameter.new(nil, nil)
+#      hash = {}
+#      if !uuid_or_task.kind_of?(Task)
+#        uuid = uuid_or_task
+#        return nil if !uuid
+#        criteria = {"uuid" => uuid, "db_type" => "task_parameter"}
+#        hash = DB.instance.find_one(criteria)
+#      else
+#        task = uuid_or_task
+#        param = TaskParameter.new(task, key, value, type, constraints)
+#        hash = DB.instance.get_or_insert(param.to_hash(), @@id_attributes)
+#      end
+#      param = DB.apply_values(param, hash)
+#      return param
+#    end
 
     def hash
       h = @key.hash

data/lib/toaster/state/convergence.rb

@@ -51,7 +51,7 @@ module Toaster
         SystemState.remove_ignore_props!(p, ignore_props)
       end
       # remove ignored properties from state changes
-      SystemState.remove_ignore_props!(ch, ignore_props)
+      SystemState.remove_ignore_props!(ch, ignore_props.collect { |ip| ip.key } )
 
       return convergence_for_prop_changes(ch, ps, prop_value_percentage_threshold)
     end
@@ -150,7 +150,7 @@ module Toaster
       # build tmp result hash
       task_execs.each do |run,exes|
         tmp[run] = {}
-        exes.unshift(TaskExecution.new(nil,nil,nil,[],"start"))
+        exes.unshift(TaskExecution.new(:uuid => "start"))
         exes.each_with_index do |exe,idx|
           if exe.kind_of?(TaskExecution)
             pre_state = MarkupUtil.clone(exe.state_before) || {}

data/lib/toaster/state/idempotence.rb

@@ -11,8 +11,14 @@ include Toaster
 module Toaster
   class Idempotence
 
-    def initialize(test_suite)
-      @test_suite = test_suite
+    def initialize(test_suite_or_automation)
+      if test_suite_or_automation.kind_of?(Automation)
+        @automation = test_suite_or_automation
+        @test_cases = @automation.get_all_test_cases
+      else
+        @automation = test_suite_or_automation.automation
+        @test_cases = test_suite_or_automation.test_cases
+      end
       @repeated_task_execs = nil
       @non_idempotent_tasks_details = nil
       @non_idempotent_taskseqs_details = nil
@@ -154,7 +160,7 @@ module Toaster
       return @repeated_task_execs if @repeated_task_execs
       result = {}
       tasks = {}
-      @test_suite.test_cases.each do |tc|
+      @test_cases.each do |tc|
         if tc.automation_run
           tc.repeat_task_uuids.each do |rt|
             #puts "#{rt.inspect}"
@@ -165,12 +171,12 @@ module Toaster
             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)
+              tasks[repeated_task] = @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}
-              )
+                  :task_id => tasks[repeated_task].id, 
+                  :automation_run_id => tc.automation_run.id
+              ).to_a
               execs.sort! { |a,b|
                 a.start_time <=> b.start_time
               }

data/lib/toaster/state/system_state.rb

@@ -242,6 +242,7 @@ module Toaster
       end
       #puts "TRACE: ignore_prop_names #{ignore_prop_names}"
       ignore_prop_names.each do |key|
+        key = key.key if key.respond_to?(:key) # get IgnoreProperty.key
         if props_hash.kind_of?(Array)
           props_hash.dup.each do |k|
 

data/lib/toaster/test/test_case.rb

@@ -16,7 +16,7 @@ module Toaster
 
     belongs_to :test_suite
     belongs_to :automation_run
-    has_many :test_attributes, nil, {:autosave => true, :dependent => :delete_all}
+    has_many :test_attributes, :autosave => true, :dependent => :destroy
     serialize :skip_task_uuids, JSON
     serialize :repeat_task_uuids, JSON
 
@@ -46,10 +46,10 @@ module Toaster
     def delete_test_result()
       # delete all task executions
       automation_run.task_executions.each do |exe|
-        exe.delete
+        exe.destroy
       end
       # delete automation run
-      automation_run.delete
+      automation_run.destroy
       # reset properties and save
       automation_run = nil
       start_time = 0
@@ -59,7 +59,7 @@ module Toaster
 
     def create_chef_node_attrs()
       attrs = {
-        "toaster_testing" => {
+        "toaster" => {
           # set task IDs which are to be skipped during the test execution
           "skip_tasks" => skip_task_uuids.dup,
           # set task IDs which are to be repeated during the test execution
@@ -143,11 +143,16 @@ module Toaster
       return automation_run ? automation_run.success : nil
     end
 
+    # force loading of associations from DB
+    def load_associations
+      hash() # loads all
+    end
+
     def hash()
       h = 0
       h += skip_task_uuids.hash
       h += repeat_task_uuids.hash
-      h += test_suite.uuid.hash
+      h += test_suite.uuid.hash if test_suite
       h += test_attributes ? test_attributes.hash : 0
       return h
     end

data/lib/toaster/test/test_runner.rb

@@ -23,14 +23,17 @@ module Toaster
     @delay_between_tests = 6 # wait some seconds before starting next test
     @semaphore = Mutex.new
     @signal = ConditionVariable.new
+    @singleton = nil
 
     class << self
-      attr_accessor :last_start_time, :delay_between_tests, :semaphore, :signal
+      attr_accessor :last_start_time, :delay_between_tests, :semaphore, :signal, :singleton
     end
 
-    def initialize(test_suite=nil, max_threads_active=nil, terminate_when_queue_empty=true)
-      @test_suite = test_suite
-      @max_threads_active = max_threads_active ? max_threads_active : 5
+    private
+
+    # private constructor
+    def initialize(max_threads_active=nil, terminate_when_queue_empty=false)
+      @max_threads_active = max_threads_active ? max_threads_active : Config.get("testing.max_threads")
       @active_threads = []
       @terminate_when_queue_empty = terminate_when_queue_empty
       @request_queue = Queue.new
@@ -39,102 +42,19 @@ module Toaster
       @received_requests = []
       @handled_requests = []
       if !terminate_when_queue_empty
-        start_worker_threads()
+        start()
       end
     end
 
+    public
+
     def start()
       start_worker_threads()
     end
-    def start_worker_threads()
-      current_num = 0
-      @local_semaphore.synchronize do
-        current_num = @active_threads.size
-      end
-      puts "DEBUG: currently active worker threads: #{current_num} of #{@max_threads_active}"
-      ((current_num)..(@max_threads_active-1)).each do 
-        t = Thread.start {
-          running = true
-          while running
-            begin
-              test_case = nil
-              @local_semaphore.synchronize do
-                # terminate if no more requests are queued
-                if @request_queue.empty? && @terminate_when_queue_empty
-                  # do NOT add this check --> leads to busy wait loop!
-                  #if @handled_requests.size >= @received_requests.size
-                    running = false
-                  #end
-                end
-                if running
-                  test_case = @request_queue.pop()
-                  @received_requests << test_case
-                end
-              end
-              if test_case
-                begin
-                  automation_run = TestRunner.execute_test(test_case)
-                  @result_map.put(test_case, automation_run)
-                rescue Object => ex
-                  err = "WARN: exception when running test case: #{ex}\n#{ex.backtrace.join("\n")}"
-                  puts err
-                  @result_map.put(test_case, err)
-                end
-                @local_semaphore.synchronize do
-                  @handled_requests << test_case
-                end
-              end
-            rescue Exception => ex
-              puts "WARN: exception in test runner thread: #{ex}\n#{ex.backtrace.join("\n")}"
-              @result_map.put(test_case, nil)
-            end
-          end
-          @local_semaphore.synchronize do
-            @active_threads.delete(self)
-          end
-        }
-        @active_threads << t
-      end
-    end
 
     def stop()
       stop_threads()
     end
-    def stop_threads()
-      @active_threads.dup.each do |t|
-        t.terminate()
-        @active_threads.delete(t)
-      end
-    end
-
-    def start_test_suite(blocking=true)
-
-      start_worker_threads()
-
-      @test_generator = TestGenerator.new(@test_suite) if @test_suite && !@test_generator
-
-      @test_suite.save()
-
-      # generate tests
-      execute_tests(@test_generator.gen_all_tests())
-
-      @test_suite.save()
-
-    end
-
-    def wait_until_finished(test_cases)
-      test_cases = [test_cases] if !test_cases.kind_of?(Array)
-      test_cases.dup.each do |t|
-        # this operation will block until a results becomes available..
-        @result_map.get(t)
-      end
-    end
-
-    def self.schedule_tests(test_suite, test_case_uuids)
-      runner = TestRunner.new(test_suite)
-      runner.schedule_tests(test_suite, test_case_uuids)
-      runner.start_worker_threads()
-    end
 
     def schedule_tests(test_suite, test_case_uuids)
       test_cases = []
@@ -149,26 +69,6 @@ module Toaster
       end
     end
 
-    def self.ensure_automation_exists_in_db(automation_name,
-      recipes, test_suite, destroy_container=true, print_output=false)
-
-      chef_node_name = ChefUtil.extract_node_name(automation_name)
-      # prepare run list (add toaster::testing recipe definitions)
-      actual_run_list = ChefUtil.prepare_run_list(chef_node_name, recipes)
-      reduced_run_list = ChefUtil.get_reduced_run_list(actual_run_list)
-      automation = Automation.find_by_cookbook_and_runlist(automation_name, reduced_run_list)
-      return automation if !automation.nil?
-
-      # if we don't have a matching automation in the DB yet, execute an initial run..
-      c = TestCase.new(test_suite)
-      test_suite.test_cases << c
-      puts "INFO: Executing initial automation run; test case '#{c.uuid}'"
-      automation_run = execute_test(c, destroy_container, print_output)
-      puts "DEBUG: Finished execution of initial automation run; test case '#{c.uuid}': #{automation_run}"
-      return nil if !automation_run
-      return automation_run.automation
-    end
-
     def schedule_test_case(test_case)
       execute_test_case(test_case, false)
     end
@@ -182,15 +82,42 @@ module Toaster
         @request_queue.push(test)
       end
 
-      # start worker threads (if they are not already running..)
-      start_worker_threads()
-
       if do_wait_until_finished
         puts "INFO: Waiting until #{test_cases.size} test cases are finished."
         wait_until_finished(test_cases)
       end
     end
 
+    # singleton pattern
+    def self.instance
+      self.semaphore.synchronize do
+        if !self.singleton
+          self.singleton = TestRunner.new()
+        end
+      end
+      return singleton
+    end
+
+    def self.ensure_automation_exists_in_db(automation_name,
+      recipes, test_suite, destroy_container=true, print_output=false)
+    
+      chef_node_name = ChefUtil.extract_node_name(automation_name)
+      # prepare run list (add toaster::testing recipe definitions)
+      actual_run_list = ChefUtil.prepare_run_list(chef_node_name, recipes)
+      reduced_run_list = ChefUtil.get_reduced_run_list(actual_run_list)
+      automation = Automation.find_by_cookbook_and_runlist(automation_name, reduced_run_list)
+      return automation if !automation.nil?
+    
+      # if we don't have a matching automation in the DB yet, execute an initial run..
+      c = TestCase.new(test_suite)
+      test_suite.test_cases << c
+      puts "INFO: Executing initial automation run; test case '#{c.uuid}'"
+      automation_run = execute_test(c, destroy_container, print_output)
+      puts "DEBUG: Finished execution of initial automation run; test case '#{c.uuid}': #{automation_run}"
+      return nil if !automation_run
+      return automation_run.automation
+    end
+
     #
     # execute the provided test case
     #
@@ -207,7 +134,7 @@ module Toaster
         test_id = test_suite.uuid
         recipes = automation.recipes
       end
-
+    
       sleep_time = 0
       self.semaphore.synchronize do
         time = TimeStamp.now()
@@ -217,12 +144,12 @@ module Toaster
         end
         self.last_start_time = time + sleep_time
       end
-
+    
       # sleep a bit, and then this test is ready to go...
       sleep(sleep_time)
       time_now = TimeStamp.now()
       test_case.start_time = time_now
-
+    
       # start test case execution
       automation_run = nil
       error_output = nil
@@ -241,10 +168,11 @@ module Toaster
           else
             raise "Unknown automation language/type: '#{automation.language}'"
           end
-
+    
+          automation_run.success = true
           test_case.test_suite().test_cases << test_case if !test_case.test_suite().test_cases().include?(test_case)
           test_case.automation_run = automation_run
-
+    
           num_attempts = 0
         rescue Object => ex
           error_output = ex
@@ -253,7 +181,7 @@ module Toaster
           puts "#{ex.backtrace.join("\n")}"
         end
       end
-
+    
       if !automation_run
         machine_id = Util.get_machine_id()
         automation = test_case.test_suite.automation
@@ -271,23 +199,38 @@ module Toaster
         automation_run.save
         test_case.automation_run = automation_run
       end
-
+    
       test_case.end_time = TimeStamp.now().to_i
       test_case.save
-
+    
       return automation_run
     end
 
     private
 
+    def stop_threads()
+      @active_threads.dup.each do |t|
+        t.terminate()
+        @active_threads.delete(t)
+      end
+    end
+
+    # apply some necessary preparations to the test container
     def self.prepare_test_container(lxc)
-      # apply some necessary preparations to the test container
-      
+
       # copy config file from host into container
       config_file_host = "#{Dir.home}/.toaster"
       config_file_cont = "#{lxc['rootdir']}/root/.toaster"
       `cp '#{config_file_host}' '#{config_file_cont}'`
 
+      # set DB host for container
+      if Toaster::Config.get("db.host_from_container")
+        config_hash = JSON.parse(File.read(config_file_cont).strip)
+        config_hash["db"] = {} if !config_hash["db"]
+        config_hash["db"]["host"] = Toaster::Config.get("db.host_from_container")
+        Util.write(config_file_cont, MarkupUtil.to_json(config_hash), true)
+      end
+
       # TODO: should we always re-install the toaster gem?
       #`ssh #{lxc["ip"]} "gem install --no-ri --no-rdoc cloud-toaster 2>&1"`
 
@@ -357,7 +300,9 @@ module Toaster
         end
 
         if automation_run_id
-          automation_run = AutomationRun.load(automation_run_id)
+          automation_run = AutomationRun.find(automation_run_id)
+          automation_run.success = true
+          automation_run.save
           if test_id
             if !automation_run.automation
               #automation_run.automation = Automation.load(automation_run.automation_id)
@@ -396,5 +341,67 @@ module Toaster
       return automation_run
     end
 
+    def start_worker_threads()
+      current_num = 0
+      @local_semaphore.synchronize do
+        current_num = @active_threads.size
+      end
+      #puts "DEBUG: currently active worker threads: #{current_num} of #{@max_threads_active}"
+      ((current_num)..(@max_threads_active-1)).each do 
+        t = Thread.start {
+          running = true
+          while running
+            begin
+              test_case = nil
+              @local_semaphore.synchronize do
+                # terminate if no more requests are queued
+                if @request_queue.empty? && @terminate_when_queue_empty
+                  # do NOT add this check --> leads to busy wait loop!
+                  #if @handled_requests.size >= @received_requests.size
+                    running = false
+                  #end
+                end
+                if running
+                  test_case = @request_queue.pop()
+                  @received_requests << test_case
+                end
+              end
+              if test_case
+                begin
+                  # do this to load all fields and avoid activeRecord error 
+                  # "could not obtain a database connection within X seconds""
+                  test_case.load_associations()
+                  # now execute the test case
+                  automation_run = TestRunner.execute_test(test_case)
+                  @result_map.put(test_case, automation_run)
+                rescue Object => ex
+                  err = "WARN: exception when running test case: #{ex}\n#{ex.backtrace.join("\n")}"
+                  puts err
+                  @result_map.put(test_case, err)
+                end
+                @local_semaphore.synchronize do
+                  @handled_requests << test_case
+                end
+              end
+            rescue Exception => ex
+              puts "WARN: exception in test runner thread: #{ex}\n#{ex.backtrace.join("\n")}"
+              @result_map.put(test_case, nil)
+            end
+          end
+          @local_semaphore.synchronize do
+            @active_threads.delete(self)
+          end
+        }
+        @active_threads << t
+      end
+    end
+
+    def wait_until_finished(test_cases)
+      test_cases = [test_cases] if !test_cases.kind_of?(Array)
+      test_cases.dup.each do |t|
+        # this operation will block until a results becomes available..
+        @result_map.get(t)
+      end
+    end
   end
 end