cloud-toaster 1.1.2

data/lib/toaster/test_manager.rb

@@ -0,0 +1,281 @@
+
+
+#
+# Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+#
+
+require "toaster/state/system_state"
+require "toaster/state/syscall_tracer"
+require "toaster/markup/markup_util"
+require "toaster/model/task"
+require "toaster/model/state_change"
+require "toaster/model/task_execution"
+require "toaster/model/user"
+require "toaster/test/test_runner"
+require "toaster/util/config"
+require "toaster/test/test_suite"
+require "toaster/util/timestamp"
+require "toaster/chef/resource_inspector"
+require "toaster/chef/chef_util"
+
+include Toaster
+
+module Toaster
+  class TestManager
+
+    def initialize(config = {})
+      @states = {}
+      @current_executions = {}
+      @cookbook_paths = config["cookbook_paths"] || []
+      @transfer_state_config = false
+      host = "localhost"
+      TestManager.init_db(config)
+      user = User.find(config["user_id"])
+      User.set_current_user(user)
+      run = AutomationRun.new(
+        :machine_id => Util.get_machine_id(),
+        :user => user)
+      AutomationRun.set_current(run)
+
+      if config["task_execution_timeout"]
+        ChefListener.task_execution_timeout = config["task_execution_timeout"]
+      end
+      if config["task_exec_timeout_repeated"]
+        ChefListener.task_exec_timeout_repeated = config["task_exec_timeout_repeated"] 
+      end
+      if config["rest_timeout"]
+        Chef::Config[:rest_timeout] = config["rest_timeout"] 
+      end
+      if !config["transfer_state_config"].nil?
+        @transfer_state_config = config["transfer_state_config"]
+      end
+
+      # Leave this output line unchanged - it is later extracted and parsed by
+      # test_runner.rb, which needs to be able to determine the automation run ID.
+      # This is a bit hacky, but seemed to be the best/fastest way to solve this.
+      puts "INFO: Current automation run ID: #{AutomationRun.get_current.id}"
+
+      @automation_name = config["automation_name"] || ""
+      @recipes = config["recipes"] || []
+      @skip_tasks = config["skip_tasks"] || []
+      @repeat_tasks = config["repeat_tasks"] || []
+      @repeated_tasks = []
+      @state_change_config = {}
+
+      @state_observer_thread = nil
+    end
+
+    #
+    # Return the number of times a given task should be executed.
+    # The result is usually 1 (default), or 0 (skip task) or 2 (repeat task once)
+    #
+    def num_requested_task_executions(task)
+      return 0 if @skip_tasks.include?(task.uuid)
+      return 2 if @repeat_tasks.include?(task.uuid)
+      return 1
+    end
+
+    def tasks_to_repeat_now(last_executed_task)
+      uuid = last_executed_task.kind_of?(String) ? last_executed_task : last_executed_task.uuid
+      @repeat_tasks.each do |list|
+        if list.kind_of?(Array)
+          if !@repeated_tasks.include?(list)
+            if list[-1] == uuid
+              @repeated_tasks << list
+              return list
+            end
+          end
+        end
+      end
+      return nil
+    end
+
+    #
+    # called by chef_listener BEFORE a chef resource (task) is executed
+    # by Chef's Runner::run_action method.
+    #
+    def before_run_action(task, execution_uuid)
+      # indicate whether or not this task should be started/continued
+      return false if @skip_tasks.include?(task.uuid)
+
+      # clear the old state change config, if needed
+      if !@transfer_state_config
+        @state_change_config = {}
+      end
+
+      # get additional_state_configs from automation
+      automation = AutomationRun.get_current().automation
+      add_automation_specific_state_config(@state_change_config)
+
+      # determine which parameters the task code accesses:
+      task.task_parameters.concat(ResourceInspector.get_accessed_parameters(task))
+      task.save
+
+      if execution_uuid
+        @state_change_config = ResourceInspector.get_config_for_potential_state_changes(
+            task, @cookbook_paths, @state_change_config)
+        state = SystemState.get_system_state(@state_change_config)
+        execution = TaskExecution.new(
+          :task => task, 
+          :state_before => state, 
+          :uuid => execution_uuid)
+        execution.automation_run = AutomationRun.get_current()
+        sourcecode = ChefUtil.runtime_resource_sourcecode(task.resource_obj)
+        sourcecode.strip! if sourcecode
+        if sourcecode != task.sourcecode
+          execution.sourcecode = sourcecode
+        end
+        @current_executions[execution_uuid] = execution
+
+        # use the external ptrace-based program to monitor the Chef execution 
+        # for changes in the file system (implemented via syscall hooks)
+        if !@state_tracer
+          @state_tracer = SyscallTracer.new()
+        end
+        @state_tracer.start
+
+      end
+
+      return true
+    end
+
+    #
+    # called by chef_listener AFTER a chef resource (task) has been executed
+    # by Chef's Runner::run_action method.
+    #
+    def after_run_action(task, execution_uuid, error = nil, script_output = nil)
+      s_before = nil
+      s_after = nil
+      begin
+        if !execution_uuid || !@current_executions[execution_uuid]
+          # "init_chef_listener" is part of a special resource name which 
+          # performs the AOP based instrumentation of the Chef run
+          if !task.resource.to_s.include?("init_chef_listener")
+            puts "WARN: Unable to find previous state for task execution " +
+              "UUID '#{execution_uuid}' in 'after_run_action' " +
+              "(This may be NORMAL within the context of a Chef notification execution). " +
+              "Currently active executions: #{@current_executions.inspect}"
+          end
+          return
+        end
+
+
+        # pause/stop monitoring
+        add_prestate = @state_tracer.dump_execution_prestate
+        add_state_change_config = SystemState.get_statechange_config_from_state(add_prestate)
+        @state_tracer.stop
+
+        # get additional_state_configs from automation
+        add_automation_specific_state_config(@state_change_config)
+
+        @state_change_config = ResourceInspector.get_config_for_potential_state_changes(
+            task, @cookbook_paths, @state_change_config)
+
+        # add additional state change configs from state tracer
+        MarkupUtil.rmerge!(@state_change_config, add_state_change_config, true)
+
+        if @state_change_config.empty?
+          puts "WARN: Empty state change config for task UUID #{task.uuid}:\n#{task.sourcecode}\n------"
+        end
+        state = SystemState.get_system_state(@state_change_config)
+        execution = @current_executions[execution_uuid]
+        @current_executions.delete(execution_uuid)
+
+        # add additional pre-states from state tracer
+        MarkupUtil.rmerge!(execution.state_before, add_prestate, true)
+
+        execution.end_time = TimeStamp.now().to_i
+        execution.output = script_output
+        execution.reduce_and_set_state_after(state)
+        execution.success = error.nil?
+        error = "#{error}\n" + "#{error.backtrace.join("\n")}" if error.respond_to?("backtrace")
+        execution.error_details = error
+
+        # clone the state hashes
+        s_before = MarkupUtil.clone(execution.state_before)
+        s_after = MarkupUtil.clone(execution.state_after)
+
+        #puts "DEBUG: states before/after #{execution}: #{execution.state_before}\n/\n#{execution.state_after}"
+        # compute state changes
+        prop_changes = SystemState.get_state_diff(s_before, s_after)
+        execution.state_changes = prop_changes
+        puts "INFO: Property changes (#{prop_changes.size}): #{prop_changes.inspect}"
+
+        # remove ignored properties (e.g., file modification time etc.)
+        SystemState.remove_ignore_props!(execution.state_before)
+        SystemState.remove_ignore_props!(execution.state_after)
+
+        # mongodb does not allow special chars like "." in the JSON hash
+        MarkupUtil.rectify_keys(execution.state_before)
+        MarkupUtil.rectify_keys(execution.state_after)
+
+        execution = execution.save
+      rescue => ex
+        Util.print_backtrace(ex)
+        puts "INFO: pre-state (original): #{s_before}"
+        puts "INFO: post-state (original): #{s_after}"
+        puts "INFO: pre-state: #{execution.state_before}"
+        puts "INFO: post-state: #{execution.state_after}"
+      end
+    end
+
+    def self.init_db(config)
+      Config.init_db_connection(config)
+    end
+
+    def self.init_test(automation_name, recipes = [], test_id = nil, 
+        prototype="default", destroy_container=true, print_output=false)
+      test_id = test_id || Util.generate_short_uid()
+      suite = TestSuite.find({"uuid" => test_id})
+      return suite if suite && suite.size > 0
+      suite = TestSuite.new(
+        :recipes => recipes,
+        :uuid => test_id,
+        :lxc_prototype => prototype)
+      suite.save
+      automation = TestRunner.ensure_automation_exists_in_db(
+        automation_name, recipes, suite, destroy_container, print_output)
+      if !automation
+        puts "WARN: Could not ensure that automation '#{automation_name}' exists in DB." 
+        return nil
+      end
+      suite.automation = automation
+      suite.save
+      return suite
+    end
+
+    def self.run_tests(test_suite, blocking = true)
+      if !test_suite.kind_of?(TestSuite)
+        test_suite = TestSuite.find({"uuid" => test_suite})
+      end
+      if blocking
+        runner = TestRunner.new(test_suite, nil, false)
+        runner.start_test_suite(blocking)
+        runner.stop
+      else
+        runner = TestRunner.new(test_suite, nil, true)
+        runner.start_test_suite(blocking)
+        runner.start_worker_threads()
+      end
+    end
+
+    private
+
+    def add_automation_specific_state_config(state_change_config, automation=nil)
+      # ensure automation is set
+      automation = AutomationRun.get_current().automation if !automation
+
+      if automation.additional_state_configs &&
+          !automation.additional_state_configs.empty?
+        puts "INFO: Register additional state change configs for automation " + 
+            "'#{automation.uuid}': #{automation.additional_state_configs}"
+        # Make sure we clone the hash, otherwise the values from
+        # state_change_config get propagated into automation.additional_state_configs..!
+        add = MarkupUtil.clone(automation.additional_state_configs)
+        # recursively merge state change configs
+        MarkupUtil.rmerge!(state_change_config, add)
+      end
+    end
+
+  end
+end

data/lib/toaster/toaster_app_service.rb

@@ -0,0 +1,141 @@
+
+$LOAD_PATH << File.join(File.expand_path(File.dirname(__FILE__)), "..")
+
+require 'rubygems'
+require 'toaster/util/config'
+require 'toaster/util/docker'
+
+include Toaster
+
+$service_port = 8385 if !$service_port
+
+puts "INFO: Configuring service."
+
+# global initializations
+require "toaster/test/test_runner"
+$test_runners = {}
+
+class MyThreadOut
+  def write(out)
+    local_out = Thread.current[:stdout]
+    if local_out then
+      local_out.write out 
+    else
+      STDOUT.write out
+    end
+  end
+  def flush()
+    local_out = Thread.current[:stdout]
+    if local_out then
+      local_out.flush
+    else
+      STDOUT.flush
+    end
+  end
+  def method_missing(name, *args, &block)
+    local_out = Thread.current[:stdout]
+    if local_out then
+      local_out.send(name, *args, &block)
+    else
+      STDOUT.send(name, *args, &block)
+    end
+  end
+end
+$stdout = MyThreadOut.new
+
+## capture stdout using thread-local variable
+require 'stringio'
+module Kernel
+  def capture_stdout(&block)
+    out = StringIO.new
+    Thread.start do
+      begin
+        Thread.current[:stdout] = out
+        block.call
+      ensure
+        Thread.current[:stdout] = STDOUT
+      end
+    end.join
+    return out.string
+  end
+end
+##
+
+def execute(cmd, silent=false)
+	puts "Executing command: #{cmd}" if !silent
+	output = `#{cmd}`
+	retval = $?
+	puts "return code: #{retval}, output: \n#{output}" if !silent
+	return retval
+end
+
+# Start the actual server and create RPC bindings
+
+require "xmlrpc/server"
+require "toaster/api"
+class ToasterAppService < XMLRPC::Server
+  def initialize(*args)
+    super(*args)
+    @app = Toaster::ToasterApp.new
+    @methods = ["chefsolo", "clean", "download", "exec", "lxc", 
+      "proto", "runchef", "runtest", "runtests", "testinit", "time"
+    ]
+    @methods.each do |method|
+      add_handler(method) { |*args|
+        exception = nil
+        out = capture_stdout do
+          begin
+            @app.send(method, *args)
+          rescue Object => ex
+            exception = ex
+          end
+        end
+        if exception
+          puts "#{exception} - #{exception.backtrace.join("\n")}"
+          puts "stdout: #{out}"
+          puts "-----"
+          raise exception
+        end
+        out
+      }
+    end
+  end
+  def start()
+    serve()
+  end
+  
+  def self.service_started?()
+    output = `ps aux | grep -v "ps aux" | grep ruby | grep toaster_app_service`
+    return output.strip != ""
+  end
+  
+  def self.start_service()
+    if !service_started?()
+      dir = File.expand_path(File.dirname(__FILE__))
+      Util.write("/tmp/toaster.service.loop.sh",
+        "#!/bin/bash\n " +
+        "cd #{dir}\n " +
+        "while [ 1 ]; do\n " +
+        "ruby toaster_app_service.rb do_start_service -v\n " +
+        "done",
+      true)
+      `chmod +x /tmp/toaster.service.loop.sh`
+      cmd = "cd #{dir} && screen -m -d bash /tmp/toaster.service.loop.sh"
+      puts "INFO: Starting test service in the background (using screen), using port #{$service_port}."
+      `#{cmd}`
+    else
+      puts "INFO: Another test service instance is already running on this host."
+    end
+  end
+end
+
+
+if ARGV.include?("do_start_service")
+  puts "Starting service on port #{$service_port}"
+  Toaster::Config.init_db_connection()
+  server = ToasterAppService.new($service_port, "0.0.0.0")
+#  client = ToasterApp.new()
+# client.runtest("2285f8539f6c48873")
+#  client.runtests("88056bebc7e384cac")
+  server.start
+end

data/lib/toaster/util/blocking_map.rb

@@ -0,0 +1,80 @@
+
+
+module Toaster
+
+  #
+  # Simple implementation of a map with thread-safe blocking operations:
+  # - put(key, value): put a value to the map
+  # - get(key): get a value from the map, do not remove value
+  # - take(key): get a value from the map, remove value afterwards
+  #
+  # Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+  #
+  class BlockingMap
+
+    def initialize()
+      @hash = {}
+      @semaphore = Mutex.new
+      @signal = ConditionVariable.new
+    end
+
+    #
+    # Put a value to the map, notifying waiting threads of new value
+    #
+    def put(key, value)
+      @semaphore.synchronize do
+        @hash[key] = value
+        @signal.signal
+      end
+    end
+
+    #
+    # Get a value from the map. Blocks until a value with the given key becomes available.
+    #
+    def get(key)
+      return do_get(key, false)
+    end
+
+    #
+    # Get a value from the map. Blocks until a value with the given key becomes available.
+    # This operation emoves the value from the map.
+    #
+    def take(key)
+      return do_get(key, true)
+    end
+
+    private
+
+    def do_get(key, delete = false)
+      error_count = 0
+      while true
+        begin
+          @semaphore.synchronize do
+            # try to get immediately
+            if @hash.include?(key)
+              value = @hash[key]
+              @hash.delete(key) if delete
+              return value
+            end
+            # wait until new value has been added
+            @signal.wait(@semaphore)
+            # try to get again
+            if @hash.include?(key)
+              value = @hash[key]
+              @hash.delete(key) if delete
+              return value
+            end
+          end
+        rescue Exception => ex
+          puts "WARN: #{ex}\n#{ex.backtrace.join("\n")}"
+          error_count += 1
+          if error_count >= 5
+            raise "Tried 5 times to get value from Toaster::BlockingMap, giving up..."
+          end
+          sleep(1)
+        end
+      end
+    end
+
+  end
+end

data/lib/toaster/util/combinatorial.rb

@@ -0,0 +1,58 @@
+
+
+include Toaster
+
+module Toaster
+
+  #
+  # Utility methods for combinatorial test design.
+  #
+  # Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+  #
+  class Combinatorial
+
+    def self.combine(list, length=nil, successive=false, results=Set.new, current=[])
+      length = list.size if !length
+      if current.size == length
+        results << current
+        return results
+      end
+      return results if list.empty?
+      next_item = list[0]
+      list_new = list[1..-1]
+      cur_new = current.dup
+      cur_new << next_item
+      combine(list_new, length, successive, results, cur_new)
+      if current.empty? || !successive
+        cur_new1 = current.dup
+        combine(list_new, length, successive, results, cur_new1)
+      end
+      return results
+    end
+
+    def self.skip(list, length=nil, successive=false, results=Set.new, current=[], original_size=nil, skipped_so_far=0)
+      length = 0 if !length
+      original_size = list.size if !original_size
+      if current.size == original_size - length
+        results << current
+        return results
+      end
+      return results if list.empty?
+      next_item = list[0]
+      list_new = list[1..-1]
+      cur_new = current.dup
+      skip(list_new, length, successive, results, cur_new, original_size, skipped_so_far+1)
+      if skipped_so_far == 0 || !successive || skipped_so_far >= length
+        cur_new1 = current.dup
+        cur_new1 << next_item
+        skip(list_new, length, successive, results, cur_new1, original_size, skipped_so_far)
+      end
+      return results
+    end
+
+    private
+
+    def initialize
+    end
+  end
+end

data/lib/toaster/util/config.rb

@@ -0,0 +1,103 @@
+
+####################################################
+# (c) Waldemar Hummer (hummer@infosys.tuwien.ac.at)
+####################################################
+
+require 'json'
+require 'toaster/markup/markup_util'
+
+module Toaster
+    
+  #
+  # Author: Waldemar Hummer (hummer@dsg.tuwien.ac.at)
+  #
+
+  class Config
+
+    class << self
+      attr_accessor :values
+    end
+
+    @values = {}
+
+    def self.set(key,value, v=values)
+      parts = key.split(".")
+      last_key = parts.pop # remove last key from array
+      parts.each do |p|
+        if !v[p]
+          v[p] = {}
+        end
+        v = v[p]
+      end
+      v[last_key] = value
+    end
+    def self.get(key, v=values)
+      parts = key.split(".")
+      last_key = parts.pop # remove last key from array
+      parts.each do |p|
+        if !v[p]
+          v[p] = {}
+        end
+        v = v[p]
+      end
+      v[last_key]
+    end
+
+    def self.init_db_connection(config=nil)
+      require "toaster/util/util"
+      if !config || !config["mysql"]
+        config = {
+          "db_type" => "mysql", 
+          'mysql' => Config.get('db')
+        }
+      end
+      if config["db_type"] == "mysql" && config["mysql"]
+
+        require "active_record"
+        ActiveRecord::Base.establish_connection(
+          :adapter => 'mysql2',
+          :host => "#{config["mysql"]["host"]}".empty? ? get("db.host") : config["mysql"]["host"],
+          :database => "#{config["mysql"]["database"]}".empty? ? get("db.database") : config["mysql"]["database"],
+          :username => "#{config["mysql"]["username"]}".empty? ? get("db.username") : config["mysql"]["username"],
+          :password => "#{config["mysql"]["password"]}".empty? ? get("db.password") : config["mysql"]["password"]
+        )
+      else
+        puts "WARN: Incorrect database connection configuration"
+      end
+    end
+
+    private
+
+    def self.read_files() 
+      found = false
+      (1..4).each do |num_dirs|
+        config_dir = File.join(File.dirname(__FILE__), Array.new(num_dirs, "..").join("/"))
+        #puts "DEBUG: Searching for config in directory #{config_dir}"
+        file = File.expand_path(File.join(config_dir, "config.json"))
+        if File.exist?(file)
+          found = true
+          if ARGV.include?("-v")
+            puts "DEBUG: Reading configuration values from file '#{file}'"
+          end
+          MarkupUtil.rmerge!(@values, JSON.parse(File.read(file)))
+        end
+      end
+      if !found
+        puts "WARN: No configuration file 'config.json' found."
+      end
+      file = File.expand_path(File.join(Dir.home, ".toaster"))
+      if File.exist?(file)
+        if ARGV.include?("-v")
+          puts "DEBUG: Reading configuration values from file '#{file}'"
+        end
+        MarkupUtil.rmerge!(@values, JSON.parse(File.read(file)))
+      end
+      if ARGV.include?("-v")
+        puts "DEBUG: Configuration hash: '#{@values}'"
+      end
+    end
+
+    read_files()
+
+  end
+end