omf_ec 6.0.0.pre.3 → 6.0.0.pre.4

data/Rakefile

@@ -4,6 +4,7 @@ require "bundler/gem_tasks"
 task :default => :test
 
 Rake::TestTask.new do |t|
+  t.libs << 'test'
   t.pattern = "test/**/*_spec.rb"
   t.verbose = true
 end

data/bin/omf_ec

@@ -0,0 +1,264 @@
+#!/usr/bin/env ruby
+#
+require 'gli'
+require 'omf_ec'
+$stdout.sync = true
+
+include GLI::App
+include OmfEc
+
+program_desc "Run a command on the testbed(s)"
+version OmfEc::VERSION
+
+desc "Debug mode (printing debug logging messages)"
+switch [:d, :debug]
+
+desc "Debug XMPP traffic mode (include XMPP debug logging messages under debug mode)."
+switch [:x, :xmpp]
+
+desc "XMPP user name"
+arg_name "user"
+flag [:u, :user]
+
+desc "XMPP user password"
+arg_name "password"
+flag [:p, :password]
+
+desc "XMPP server domain"
+arg_name "domain"
+default_value "localhost"
+flag [:s, :server]
+
+desc "Private key file"
+arg_name "key", :optional
+flag [:private_key]
+
+desc "Log file directory"
+arg_name "directory"
+default_value "/tmp"
+flag [:log_file_dir]
+
+config_file(".config/omf_ec.yml")
+
+desc "Execute an experiment script"
+arg_name "path_to_script_file [-- --experiment_property value]"
+command :exec do |c|
+  c.desc "Experiment name"
+  c.arg_name "experiment_name"
+  c.flag [:e, :experiment]
+
+  c.desc "Default OML URI to use for collecting measurements"
+  c.arg_name "uri"
+  c.flag [:oml_uri]
+
+  c.desc "Check script version (you need to define OMF_VERSIONS in your script"
+  c.switch "version_check"
+
+  c.action do |global_options, options, args|
+    help_now! "Missing experiment script" if args[0].nil?
+    help_now! "Experiment script not found" unless File.exist?(args[0])
+
+    # User provided exp properties
+    if args.size > 1
+      exp_properties = args[1..-1]
+
+      exp_properties.in_groups_of(2) do |p|
+        unless p[0] =~ /^--(.+)/ && !p[1].nil?
+          help_now! "Malformatted properties '#{exp_properties.join(' ')}'"
+        else
+          OmfEc.exp.property[$1.to_sym] = p[1].ducktype
+        end
+      end
+    end
+
+    # FIXME this loading script is way too simple
+    load_exp(args[0], global_options, options)
+  end
+end
+
+desc "Load an image onto the nodes"
+command :load do |c|
+  #c.desc "use this testbed configuration in OMF 5 EC config file"
+  #c.arg_name "AGGREGATE"
+  #c.flag [:c, :config], :default_value => "default"
+
+  c.desc "comma-separated list of nodes to image"
+  c.arg_name "TOPOLOGY"
+  c.flag [:t, :topology], :default_value => "system:topo:all"
+
+  c.desc "disk image to load"
+  c.arg_name "IMAGE"
+  c.flag [:i, :image], :default_value => "baseline.ndz"
+
+  c.desc "seconds to wait for the imaging process to complete"
+  c.arg_name "TIMEOUT"
+  c.flag [:o, :timeout], :default_value => "800"
+
+  c.desc "resize the first partition to SIZE GB or to maximum size if SIZE=0 "+
+    "or leave x percent of free space if SIZE=x%"
+  c.arg_name "SIZE"
+  c.flag [:r, :resize]
+
+  c.desc "Path where the resulting Topologies should be saved"
+  c.arg_name "PATH"
+  c.flag [:outpath], :default_value => "/tmp"
+
+  c.desc "Prefix to use for naming the resulting Topologies (default is your experiment ID)"
+  c.arg_name "PREFIX"
+  c.flag [:outprefix]
+
+  c.action do |global_options, options, args|
+    @cmd = "omf-5.4 load -t #{options[:t]} -i #{options[:i]} "
+    @cmd += "-o #{options[:o]} --outpath #{options[:outpath]} "
+    @cmd += "-r #{options[:r]} " if options[:r]
+    @cmd += "--outprefix #{options[:outprefix]} " if options[:outprefix]
+    load_exp(@testbed_exp_path, global_options, options)
+  end
+end
+
+desc "Save an image of a node"
+command :save do |c|
+  #c.desc "use this testbed configuration in OMF 5 EC config file"
+  #c.arg_name "AGGREGATE"
+  #c.flag [:c, :config], :default_value => "default"
+
+  c.desc "node to save from"
+  c.arg_name "NODE"
+  c.flag [:n, :node]
+
+  c.desc "resize the first partition to SIZE GB or to maximum size if SIZE=0 "+
+    "or leave x percent of free space if SIZE=x%"
+  c.arg_name "SIZE"
+  c.flag [:r, :resize]
+
+  c.action do |global_options, options, args|
+    @cmd = "omf-5.4 save "
+    @cmd += "-n #{options[:n]} " if options[:n]
+    @cmd += "-r #{options[:r]} " if options[:r]
+    load_exp(@testbed_exp_path, global_options, options)
+  end
+end
+
+desc "Return the status of the nodes"
+command :stat do |c|
+  c.desc "use this testbed configuration in OMF 5 EC config file"
+  c.arg_name "AGGREGATE"
+  c.flag [:c, :config], :default_value => "default"
+
+  c.desc "comma-separated list of nodes to image"
+  c.arg_name "TOPOLOGY"
+  c.flag [:t, :topology], :default_value => "system:topo:all"
+
+  c.desc "print a summary of the node status for the testbed"
+  c.switch [:s, :summary]
+
+  c.action do |global_options, options, args|
+    @cmd = "omf-5.4 stat -c #{options[:c]} -t #{options[:t]} "
+    @cmd += "-s" if options[:s]
+    load_exp(@testbed_exp_path, global_options, options)
+  end
+end
+
+desc "Power on/off, reset or reboot the nodes"
+command :tell do |c|
+  c.desc "use this testbed configuration in OMF 5 EC config file"
+  c.arg_name "AGGREGATE"
+  c.flag [:c, :config], :default_value => "default"
+
+  c.desc "comma-separated list of nodes to image"
+  c.arg_name "TOPOLOGY"
+  c.flag [:t, :topology], :default_value => "system:topo:all"
+
+  c.desc "
+      'on'              turn node(s) ON -
+      'offs'            turn node(s) OFF (soft) -
+      'offh'            turn node(s) OFF (hard) -
+      'reboot'          reboots node(s) (soft) -
+      'reset'           resets node(s) (hard)"
+  c.arg_name "ACTION"
+  c.flag [:a, :action]
+
+  c.action do |global_options, options, args|
+    @cmd = "omf-5.4 tell -c #{options[:c]} -t #{options[:t]} "
+    @cmd += "-a #{options[:a]} " if options[:a]
+    load_exp(@testbed_exp_path, global_options, options)
+  end
+end
+
+on_error do |exception|
+  true
+end
+
+pre do |global_options, command, options, args|
+  unless global_options[:user] && global_options[:password] && global_options[:server]
+    help_now! "Incomplete options"
+  end
+
+  if global_options[:xmpp]
+    Blather.logger = logger
+  end
+
+  if global_options[:debug]
+    Logging.logger.root.level = :debug
+  else
+    Logging.consolidate 'OmfCommon', 'OmfEc', 'OmfRc'
+  end
+
+  # Import private key
+  if global_options[:private_key]
+    OmfCommon::Key.instance.import(global_options[:private_key])
+  end
+
+  # Check version
+  if options[:check]
+    File.open(args[0], 'r') do |f|
+      f.read.chomp.match(/OMF_VERSIONS\W*=\W*(.*)/)
+      versions = $1
+      unless versions && versions.split(',').include?(OmfCommon::PROTOCOL_VERSION)
+        raise StandardError, "Could not find compatibile protocol version number in your script"
+      end
+    end
+  end
+
+  include OmfEc::DSL
+
+  OmfEc.exp.name = options[:experiment] if options[:experiment]
+  OmfEc.exp.oml_uri = options[:oml_uri] if options[:oml_uri]
+
+  if global_options[:log_file_dir] && File.exist?(global_options[:log_file_dir])
+    Logging.logger.root.add_appenders(
+      Logging.appenders.file(
+        "#{global_options[:log_file_dir]}/#{OmfEc.exp.id}.log",
+        :layout => Logging.layouts.pattern(:date_pattern => '%F %T %z',
+                                           :pattern => '[%d] %-5l %c: %m\n')))
+  end
+
+  @testbed_exp_path = File.join(OmfEc.lib_root, "omf_ec/backward/exp/testbed.rb")
+end
+
+def load_exp(exp_path, global_options = {} , options = {})
+  begin
+    OmfEc.comm.when_ready do
+      logger.info "Connected: #{OmfEc.comm.jid.inspect}"
+      logger.info "Start experiment: #{OmfEc.exp.id}"
+      begin
+        include OmfEc::Backward::DefaultEvents
+        load exp_path
+      rescue => e
+        logger.error e.message
+        logger.error e.backtrace.join("\n")
+      end
+    end
+
+    EM.run do
+      OmfEc.comm.connect(global_options[:user], global_options[:password], global_options[:server])
+      trap(:INT) { Experiment.done }
+      trap(:TERM) { Experiment.done }
+    end
+  rescue => e
+    logger.fatal e.message
+    logger.fatal e.backtrace.join("\n")
+  end
+end
+
+exit run(ARGV)

data/example/engine_oedl.rb

@@ -0,0 +1,52 @@
+# OMF_VERSIONS = 6.0
+#
+# :num_of_garage can be passed in from EC command line
+defProperty('num_of_garage', 1, 'Number of garage to start')
+
+garages = (1..prop.num_of_garage).map { |i| "garage_#{i}" }
+
+defEvent :all_engines_up do |state|
+  # state holds list of resources, and automatically updated once OMF inform messages received.
+  state.find_all do |v|
+    v[:type] == 'engine'
+  end.size >= prop.num_of_garage
+end
+
+defEvent :rpm_reached do |state|
+  state.find_all do |v|
+    v[:type] == 'engine' && v[:rpm] && v[:rpm] >= 4000
+  end.size >= prop.num_of_garage
+end
+
+# Define a group and add garages to it.
+defGroup('many_garages', *garages)
+
+# :ALL_UP is a pre-defined event,
+# triggered when all resources set to be part of groups are available and configured as members of the associated groups.
+onEvent :ALL_UP do
+  group('many_garages') do |g|
+    g.create_resource('primary_engine', type: 'engine', sn: "<%= rand(1000) %>")
+
+    onEvent :all_engines_up do
+      info "Accelerating all engines"
+      g.resources[type: 'engine'][name: 'primary_engine'].throttle = 40
+
+      g.resources[type: 'engine'][name: 'primary_engine'].sn
+
+      g.resources[type: 'engine'][name: 'primary_engine'].failure
+    end
+
+    onEvent :rpm_reached do
+      info "All engines RPM reached 4000"
+      info "Release All engines throttle"
+      g.resources[type: 'engine'].throttle = 0
+
+      after 7.seconds do
+        info "Shutting ALL engines off"
+        g.resources[type: 'engine'].release
+
+        Experiment.done
+      end
+    end
+  end
+end

data/example/engine_test.rb

@@ -0,0 +1,90 @@
+# OMF_VERSIONS = 6.0
+
+@comm = OmfEc.comm
+
+# @comm is default communicator defined in script runner
+#
+garage_id = "garage_1"
+garage_topic = @comm.get_topic(garage_id)
+
+garage_topic.on_message lambda {|m| m.operation == :inform && m.read_content('inform_type') == 'FAILED' } do |message|
+  logger.error message
+end
+
+msgs = {
+  create: @comm.create_message([type: 'mp4']),
+  request: @comm.request_message([:max_rpm, {:provider => {country: 'japan'}}, :max_power]),
+  request_rpm: @comm.request_message([:rpm]),
+  increase_throttle: @comm.configure_message([throttle: 50]),
+  reduce_throttle: @comm.configure_message([throttle: 0]),
+  test_error_handling: @comm.request_message([:error]),
+}
+
+msgs[:test_error_handling].on_inform_failed do |message|
+  logger.error message.read_content("reason")
+end
+
+msgs[:create].on_inform_failed do |message|
+  logger.error "Resource creation failed ---"
+  logger.error message.read_content("reason")
+end
+
+msgs[:request].on_inform_status do |message|
+  message.each_property do |p|
+    logger.info "#{p.attr('key')} => #{p.content.strip}"
+  end
+end
+
+msgs[:request].on_inform_failed do |message|
+  logger.error message.read_content("reason")
+end
+
+msgs[:request_rpm].on_inform_status do |message|
+  message.each_property do |p|
+    logger.info "#{p.attr('key')} => #{p.content.strip}"
+  end
+end
+
+# Triggered when new messages published to the topics I subscribed to
+msgs[:create].on_inform_created do |message|
+  engine_topic = @comm.get_topic(message.resource_id)
+  engine_id = engine_topic.id
+
+  msgs[:release] ||= @comm.release_message { |m| m.element('resource_id', engine_id) }
+
+  msgs[:release].on_inform_released  do |message|
+    logger.info "Engine (#{message.resource_id}) turned off (resource released)"
+    done!
+  end
+
+  logger.info "Engine #{engine_id} ready for testing"
+
+  engine_topic.subscribe do
+    # Now subscribed to engine topic, we can ask for some information about the engine
+    msgs[:request].publish engine_id
+
+    # We will check engine's RPM
+    msgs[:request_rpm].publish engine_id
+
+    # Now we will apply 50% throttle to the engine
+    msgs[:increase_throttle].publish engine_id
+
+    @comm.add_timer(5) do
+      # Some time later, we want to reduce the throttle to 0, to avoid blowing up the engine
+      msgs[:reduce_throttle].publish engine_id
+
+      # Testing error handling
+      msgs[:test_error_handling].publish engine_id
+    end
+
+    # 10 seconds later, we will 'release' this engine, i.e. shut it down
+    @comm.add_timer(10) do
+      msgs[:release].publish garage_id
+    end
+  end
+end
+
+garage_topic.subscribe do
+  # If subscribed, we publish a 'create' message, 'create' a new engine for testing
+  msgs[:create].publish garage_topic.id
+end

data/example/test_exp/test00.rb

@@ -0,0 +1,12 @@
+# We can use communicator to interact with XMPP server
+#
+# Find all top level pubsub nodes
+host = "pubsub.#{OmfEc.comm.jid.domain}"
+
+OmfEc.comm.discover('items', host, '') do |m|
+  m.items.each { |i| info i.node }
+  info "Found #{m.items.size} items"
+end
+
+done!
+

data/example/test_exp/test01.rb

@@ -0,0 +1,22 @@
+#
+# Test 1
+#
+# Testing one node in one group running one exec command for an already installed app
+#
+defProperty('res1', "unconfigured-node-1", "ID of a node")
+defProperty('res2', "unconfigured-node-2", "ID of a node")
+
+defGroup('Actor', property.res1, property.res2)
+defGroup('Bob', property.res1, property.res2)
+
+onEvent(:ALL_UP) do
+  wait 3
+  info "TEST - allGroups"
+  allGroups.exec("/bin/date")
+
+  wait 3
+  info "TEST - group"
+  group("Actor").exec("/bin/hostname -f")
+
+  Experiment.done
+end

data/example/test_exp/test02.rb

@@ -0,0 +1,30 @@
+#
+# Test 2
+#
+# Testing 2 nodes in multiple groups running exec commandis for already installed apps
+#
+
+defProperty('res1', "node1", "ID of a node")
+defProperty('res2', "node2", "ID of a node")
+
+defGroup('Alice', property.res1)
+defGroup('Bob', property.res2)
+defGroup('Couple', property.res1, property.res2)
+defGroup('GroupOfGroup', "Alice", "Bob")
+
+onEvent(:ALL_UP) do
+  wait 5
+  info "-------------"
+  info "TEST - Group of 2 (res1,res2)"
+  group("Couple").exec("/bin/hostname")
+  wait 5
+  info "---------------------"
+  info "TEST - Group of Group ( (res1) and (res2) )"
+  group("GroupOfGroup").exec("/bin/hostname")
+  wait 5
+  info "---------------"
+  info "TEST - allGroup"
+  allGroups.exec("/bin/hostname")
+  wait 5
+  Experiment.done
+end

data/{exp_repo/test/exp → example/test_exp}/test03.rb

@@ -45,51 +45,11 @@ onEvent(:ALL_UP_AND_INSTALLED) do |event|
   allGroups.startApplications
   wait 10
   info "TEST - Running ifconfig on Sender"
-  group('Sender').exec("ifconfig")
+  group('Sender').exec("/sbin/ifconfig")
   wait 15
   info "TEST - Running ifconfig on Receiver"
-  group('Receiver').exec("ifconfig")
+  group('Receiver').exec("/sbin/ifconfig")
   wait 15
   allGroups.stopApplications
   Experiment.done
 end
-
-
-#
-# Checking the Execution
-# Here you do whatever is required to check that the above experiment went well
-# Then return true if you decided that it did, or false otherwise
-#
-# Experiment log file is at: property.logpath
-# Also you may want to look at system:exp:testlib
-#
-
-def check_outcome
-
-  # Test 03 is successfull if all of the following are true:
-  # 1) each resource reports that all its wireless property were configured OK
-  # 2) the applications (OTG,OTR,execs) started and finished properly
-  # file has a message from the AgentCommands module containing "DONE.OK"
-  # 3) a SQ3 database is produced with some entries in the OTG and OTR tables
-  logfile = "#{property.logpath}/#{Experiment.ID}.log"
-  lines = IO.readlines("#{logfile}")
-  # 1)
-  match1 = lines.grep(/CONFIGURED\.OK/)
-  r1 = (match1.length >= 10) ? true : false
-  # 2) 
-  match1 = lines.grep(/APP_EVENT\ STARTED/)
-  r2 = (match1.length == 4) ? true : false
-  match1 = lines.grep(/APP_EVENT DONE\.OK/)
-  match2 = match1.grep(/AgentCommands/)
-  r3 = (match2.length == 4) ? true : false
-  # 3)
-  cnt1 = cnt2 = 0
-  ms('udp_out').project(:oml_ts_server).each { |x| cnt1 =+1 }
-  ms('udp_in').project(:oml_ts_server).each { |x| cnt2 =+1 }
-  r4 = (cnt1 >= 1) ? true : false
-  r5 = (cnt2 >= 1) ? true : false
-
-  puts "Check Outcome [r1:#{r1} - r2:#{r2} - r3:#{r3} - r4:#{r4} - r5:#{r5}]"
-  return true if r1 && r2 && r3 && r4 && r5
-  return false
-end

data/{exp_repo/test/exp → example/test_exp}/test04.rb

@@ -79,7 +79,7 @@ def check_outcome
   # 1)
   match1 = lines.grep(/CONFIGURED\.OK/)
   r1 = (match1.length >= 10) ? true : false
-  # 2) 
+  # 2)
   match1 = lines.grep(/APP_EVENT\ STARTED/)
   r2 = (match1.length == 2) ? true : false
   match1 = lines.grep(/APP_EVENT DONE\.OK/)
@@ -93,7 +93,7 @@ def check_outcome
   r5 = (cnt2 >= 1) ? true : false
   # 4)
   max = PKTSIZE
-  ms('udp_in').project(:pkt_length_max).each do |r| 
+  ms('udp_in').project(:pkt_length_max).each do |r|
     value = r.tuple
     max = value[0]
   end

data/{exp_repo/test/exp → example/test_exp}/test05.rb

@@ -33,7 +33,7 @@ defGroup('Actor', property.res1) {|n|
     app.setProperty('arg2', 'DEF') # Displays "--arg2 DEF"
     app.setProperty('arg3', property.pboolean) # Displays "-b"
     app.setProperty('arg4', true) # Displays "--arg4"
-    app.setProperty('arg5', false) # Displays nothing 
+    app.setProperty('arg5', false) # Displays nothing
     app.setProperty('arg6', property.pinteger) # Displays "-i 123" in second position!
     app.setProperty('arg7', 456) # Displays "--arg7 456"
     app.setProperty('arg8', "ZZZ") # Displays "ZZZ"
@@ -61,8 +61,8 @@ end
 def check_outcome
 
   # Test 03 is successfull if all of the following are true:
-  # 1) the tarball is installed OK AND the application runs OK 
-  # 2) the application outputs the correct payload from the tarball 
+  # 1) the tarball is installed OK AND the application runs OK
+  # 2) the application outputs the correct payload from the tarball
   # 3) the application accepts and outputs the correct arguments
   logfile = "#{property.logpath}/#{Experiment.ID}.log"
   lines = IO.readlines("#{logfile}")
@@ -80,7 +80,7 @@ def check_outcome
   match2 = match1.grep(/AgentCommands/)
   r4 = (match2.length == 1) ? true : false
 
-  puts "Check Outcome [r1:#{r1} - r2:#{r2} - r3:#{r3} - r4:#{r4}]" 
+  puts "Check Outcome [r1:#{r1} - r2:#{r2} - r3:#{r3} - r4:#{r4}]"
   return true if r1 && r2 && r3 && r4
   return false
 

data/{exp_repo/test/exp → example/test_exp}/test06.rb

@@ -18,8 +18,8 @@ defApplication('nmapURI', 'nmap') { |app|
 
 defGroup('Actor', property.res1) {|n|
   n.addApplication("nmapURI") {|app|
-    app.setProperty('target', "127.0.0.1") 
-    app.setProperty('port', '101-200') 
+    app.setProperty('target', "127.0.0.1")
+    app.setProperty('port', '101-200')
   }
 }
 
@@ -49,19 +49,19 @@ def check_outcome
   # Test 06 is successfull if:
   # 1) the application nmap has been unpacked on the resource
   # AND
-  # 2) for the Actor group, the log file has a message from the AgentCommands 
+  # 2) for the Actor group, the log file has a message from the AgentCommands
   #    module containing "DONE.OK" for the install of the app, and for the app
   #    execution
 
-  # Test 06 is successfull if for each of the 2 exec commands above, the log 
+  # Test 06 is successfull if for each of the 2 exec commands above, the log
   # file has a message from the AgentCommands module containing "DONE.OK"
   logfile = "#{property.logpath}/#{Experiment.ID}.log"
   lines = IO.readlines("#{logfile}")
-  # 1) 
+  # 1)
   match1 = lines.grep(/Unpacking\ nmap/)
   match2 = match1.grep(/AgentCommands/)
   result1 = (match2.length == 1) ? true : false
-  # 2) 
+  # 2)
   match1 = lines.grep(/DONE\.OK/)
   match2 = match1.grep(/AgentCommands/)
   result2 = (match2.length >= 2) ? true : false

data/example/test_exp/test07.rb

@@ -0,0 +1,65 @@
+#
+# Test 7
+#
+# Testing one node in one group running two instance of the same app, 
+# previously defined with defApplication
+#
+# NOTE: in this example, while the defApp contains measurement point (MP) 
+# definitions, these are not collected/enabled in the addApp using this 
+# defined app. This is because here we simply use ping, which does not 
+# have OML MPs... thus enabling these MPs will result in a command line 
+# error when trying to run ping.
+#
+
+defProperty('res1', "unconfigured-node-1", "ID of a node")
+
+defApplication('ping','ping') do |app|
+  app.description = 'Simple App Def for Ping'
+  app.binary_path = '/bin/ping'
+  
+  # OMF 5.4 SYNTAX
+  #
+  app.defProperty('target', "my target", nil, {:type => :string, :default => 'localhost'})
+  app.defProperty('count', "my count", "-c", {:type => :integer, :default => 2, :order => 1})
+
+  app.defMeasurement('ping_delay') do |m|
+    m.defMetric('sequence', 'Fixnum')
+    m.defMetric('destination', 'String')
+    m.defMetric('rtt', 'Fixnum')
+  end
+
+  app.defMeasurement('ping_loss') do |m|
+    m.defMetric('destination', 'String')
+    m.defMetric('probe_count', 'Fixnum')
+    m.defMetric('loss', 'Fixnum')
+  end
+  
+  # OMF 6 SYNTAX
+  #
+  # app.define_parameter(
+  #   :target => {:type => 'String', :default => 'localhost'},
+  #   :count => {:type => 'Numeric', :cmd => '-c', :default => 2, :order => 1}
+  # )
+end
+
+defGroup('Actor', property.res1) do |g|
+  g.addApplication("ping") do |app|
+    app.setProperty('target', 'www.google.com')
+    app.setProperty('count', 1)
+    #app.measure('ping_delay', :interval => 3)
+  end
+  g.addApplication("ping") do |app|
+    app.setProperty('target', 'www.nicta.com.au')
+    app.setProperty('count', 2)
+    #app.measure('ping_loss', :samples => 10)
+  end
+
+end
+
+onEvent(:ALL_UP_AND_INSTALLED) do |event|
+  info "TEST - group"
+  group("Actor").startApplications
+  after 1.seconds do
+    Experiment.done
+  end
+end