omf_ec 6.0.0.pre.4 → 6.0.0.pre.5

data/bin/omf_ec

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
-#
+
+abort "Please use Ruby 1.9.3 or higher" if RUBY_VERSION < "1.9.3"
+
 require 'gli'
 require 'omf_ec'
 $stdout.sync = true
@@ -13,22 +15,14 @@ version OmfEc::VERSION
 desc "Debug mode (printing debug logging messages)"
 switch [:d, :debug]
 
+desc "URI for communication layer"
+arg_name "URI"
+default_value "xmpp://bob:password@localhost"
+flag [:u, :uri]
+
 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]
@@ -58,21 +52,25 @@ command :exec do |c|
     help_now! "Missing experiment script" if args[0].nil?
     help_now! "Experiment script not found" unless File.exist?(args[0])
 
-    # User provided exp properties
+    # User-provided command line values for Experiment Properties cannot be 
+    # set here as the propertties have not been defined yet by the experiment. 
+    # Thus just pass them to the experiment, which will be responsible
+    # for setting them later
+    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
+          properties[$1.to_sym] = p[1].ducktype
         end
       end
+      OmfEc.experiment.cmdline_properties = properties
     end
 
     # FIXME this loading script is way too simple
-    load_exp(args[0], global_options, options)
+    load_exp(args[0], global_options, options, properties)
   end
 end
 
@@ -175,14 +173,14 @@ command :tell do |c|
       '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.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
+      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|
@@ -190,19 +188,10 @@ on_error do |exception|
 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
+  unless global_options[:uri]
+    help_now! "Incomplete options. Need communication URI"
   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]
@@ -222,38 +211,67 @@ pre do |global_options, command, options, args|
 
   include OmfEc::DSL
 
-  OmfEc.exp.name = options[:experiment] if options[:experiment]
-  OmfEc.exp.oml_uri = options[:oml_uri] if options[:oml_uri]
+  OmfEc.experiment.name = options[:experiment] if options[:experiment]
+  OmfEc.experiment.oml_uri = options[:oml_uri] if options[:oml_uri]
 
+  @testbed_exp_path = File.join(OmfEc.lib_root, "omf_ec/backward/exp/testbed.rb")
+end
+
+def setup_logging(global_options = {})
+  if global_options[:xmpp]
+    require 'blather'
+    Blather.logger = logger
+  end
+
+  unless global_options[:debug]
+    Logging.consolidate 'OmfCommon', 'OmfEc', 'OmfRc'
+  end
+
+  # FIXME this should go to common setup
   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",
+        "#{global_options[:log_file_dir]}/#{OmfEc.experiment.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 = {})
+def load_exp(exp_path, global_options = {} , options = {}, properties = {})
   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
+    opts = {
+      communication: { url: global_options[:uri] },
+      eventloop: { type: :em },
+      logging: {
+        level: global_options[:debug] ? 'debug' : 'info',
+        appenders: {
+          stdout: {
+            date_pattern: '%H:%M:%S',
+            pattern: '%d %-5l %c{2}: %m\n',
+            color_scheme: 'default'
+          }
+        }
+      }
+    }
+
+    OmfCommon.init(:development, opts) do |el|
+      setup_logging(global_options)
+
+      OmfCommon.comm.on_connected do |comm|
+        info "Connected"
+        info "Start experiment: #{OmfEc.experiment.id}"
+
+        begin
+          include OmfEc::Backward::DefaultEvents
+          load exp_path
+        rescue => e
+          error e.message
+          error e.backtrace.join("\n")
+        end
 
-    EM.run do
-      OmfEc.comm.connect(global_options[:user], global_options[:password], global_options[:server])
-      trap(:INT) { Experiment.done }
-      trap(:TERM) { Experiment.done }
+        #comm.on_interrupted { Experiment.done }
+        comm.on_interrupted { comm.disconnect }
+      end
     end
   rescue => e
     logger.fatal e.message

data/example/engine_oedl.rb

@@ -1,51 +1,51 @@
 # 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}" }
+def_property('name', 'garage', 'Name of garage')
 
-defEvent :all_engines_up do |state|
+garage = prop.name
+
+defEvent :engine_created 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.size >= 1
 end
 
-defEvent :rpm_reached do |state|
+defEvent :rpm_reached_4000 do |state|
   state.find_all do |v|
     v[:type] == 'engine' && v[:rpm] && v[:rpm] >= 4000
-  end.size >= prop.num_of_garage
+  end.size >= 1
 end
 
 # Define a group and add garages to it.
-defGroup('many_garages', *garages)
+defGroup('garages', garage)
 
 # :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) %>")
+  group('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
+    onEvent :engine_created do
+      info ">>> Accelerating all engines"
+      g.resources[type: 'engine'][name: 'primary_engine'].throttle = 50
 
       g.resources[type: 'engine'][name: 'primary_engine'].sn
-
-      g.resources[type: 'engine'][name: 'primary_engine'].failure
+      g.resources[type: 'engine'][name: 'primary_engine'].membership
     end
 
-    onEvent :rpm_reached do
-      info "All engines RPM reached 4000"
-      info "Release All engines throttle"
+    onEvent :rpm_reached_4000 do
+      info ">>> Engine RPM reached 4000"
+
+      info ">>> Reduce engine throttle"
       g.resources[type: 'engine'].throttle = 0
 
       after 7.seconds do
-        info "Shutting ALL engines off"
+        info ">>> Release engines"
         g.resources[type: 'engine'].release
 
-        Experiment.done
+        done!
       end
     end
   end

data/example/engine_test.rb

@@ -1,90 +1,68 @@
 # 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
+def create_engine(garage)
+  garage.create(:engine, { sn: 10001 }) do |reply_msg|
+    if reply_msg.success?
+      engine = reply_msg.resource
+
+      engine.on_subscribed do
+        info ">>> Connected to newly created resource #{reply_msg[:res_id]} with serial number #{reply_msg[:sn]}"
+        on_engine_created(engine)
+      end
+
+      after(2) do
+        info ">>> RELEASE engine"
+        garage.release(engine) do |reply_msg|
+          info reply_msg
+        end
+      end
+    else
+      error ">>> Resource creation failed - #{reply_msg[:reason]}"
+    end
+  end
 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
+def on_engine_created(engine)
+  info ">>> SENDING REQUEST"
+  # We can ask for some information about the engine
+  engine.request([:rpm, :max_rpm, :max_power, :provider])
 
-msgs[:create].on_inform_failed do |message|
-  logger.error "Resource creation failed ---"
-  logger.error message.read_content("reason")
-end
+  # Now we will apply 50% throttle to the engine
+  info ">>> SENDING CONFIGURE throttle 50%"
+  engine.configure(throttle: 50)
 
-msgs[:request].on_inform_status do |message|
-  message.each_property do |p|
-    logger.info "#{p.attr('key')} => #{p.content.strip}"
+  # Some time later, we want to reduce the throttle to 0, to avoid blowing up the engine
+  after(5) do
+    info ">>> SENDING CONFIGURE throttle 0%"
+    engine.configure(throttle: 0)
   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}"
+  every(1) do
+    engine.request([:rpm])
   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!
+  # Monitor all status information from the engine
+  engine.on_status do |msg|
+    msg.each_property do |name, value|
+      info "#{name} => #{value}"
+    end
   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
+  engine.on_error do |msg|
+    error msg[:reason]
+  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
+  engine.on_warn do |msg|
+    warn msg[:reason]
   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
+OmfCommon.comm.subscribe('garage') do |garage|
+  unless garage.error?
+    create_engine(garage)
+  else
+    error garage.inspect
+  end
+
+  after(20) { info 'Disconnecting ...'; OmfCommon.comm.disconnect }
 end

data/example/test_exp/test00.rb

@@ -1,12 +1,32 @@
 # We can use communicator to interact with XMPP server
 #
 # Find all top level pubsub nodes
-host = "pubsub.#{OmfEc.comm.jid.domain}"
+host = "pubsub.#{OmfCommon.comm.jid.domain}"
 
-OmfEc.comm.discover('items', host, '') do |m|
-  m.items.each { |i| info i.node }
-  info "Found #{m.items.size} items"
+def discover
+  OmfCommon.comm.discover('items', host, '') do |m|
+    m.items.each { |i| info i.node }
+    info "Found #{m.items.size} items"
+  end
 end
 
-done!
 
+def cleanup
+  OmfCommon.comm.affiliations do |a|
+    if a[:owner]
+      info "Found #{a[:owner].size} owned topics"
+      info "Now cleaning up..."
+      a[:owner].each do |t|
+        OmfCommon.comm.delete_topic(t) do |m|
+          debug m
+        end
+      end
+    else
+      info "Found no owned topics"
+    end
+  end
+end
+
+cleanup
+
+done!

data/example/test_exp/test01.rb

@@ -4,19 +4,18 @@
 # 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)
+defGroup('Actor', property.res1)
 
 onEvent(:ALL_UP) do
-  wait 3
+  allGroups.startApplications
+
   info "TEST - allGroups"
   allGroups.exec("/bin/date")
 
-  wait 3
   info "TEST - group"
   group("Actor").exec("/bin/hostname -f")
 
+  allGroups.stopApplications
   Experiment.done
 end

data/example/test_exp/test02.rb

@@ -13,18 +13,15 @@ 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
+
+  after(20) { Experiment.done }
 end

data/example/test_exp/test03.rb

@@ -14,42 +14,29 @@ defProperty('wifi', "g", "wifi type to use")
 defProperty('channel', "6", "wifi channel to use")
 
 defGroup('Sender', property.res1) {|node|
-  node.addApplication("test:app:otg2") {|app|
-    app.setProperty('udp:local_host', '192.168.0.2')
-    app.setProperty('udp:dst_host', '192.168.0.3')
-    app.setProperty('udp:dst_port', 3000)
-    app.measure('udp_out', :interval => 3)
-  }
   node.net.w0.mode = property.mode1
   node.net.w0.type = property.wifi
   node.net.w0.channel = property.channel
   node.net.w0.essid = "testing"
-  node.net.w0.ip = "192.168.0.2"
+  node.net.w0.ip = "192.168.0.10/24"
 }
 
-defGroup('Receiver', property.res2) {|node|
-  node.addApplication("test:app:otr2") {|app|
-    app.setProperty('udp:local_host', '192.168.0.3')
-    app.setProperty('udp:local_port', 3000)
-    app.measure('udp_in', :samples => 3)
-  }
-  node.net.w0.mode = property.mode2
-  node.net.w0.type = property.wifi
-  node.net.w0.channel = property.channel
-  node.net.w0.essid = "testing"
-  node.net.w0.ip = "192.168.0.3"
-}
+#defGroup('Receiver', property.res2) {|node|
+#  node.net.w0.mode = property.mode2
+#  node.net.w0.type = property.wifi
+#  node.net.w0.channel = property.channel
+#  node.net.w0.essid = "testing"
+#  node.net.w0.ip = "192.168.0.20/24"
+#}
 
 onEvent(:ALL_UP_AND_INSTALLED) do |event|
-  wait 10
-  allGroups.startApplications
-  wait 10
   info "TEST - Running ifconfig on Sender"
   group('Sender').exec("/sbin/ifconfig")
-  wait 15
-  info "TEST - Running ifconfig on Receiver"
-  group('Receiver').exec("/sbin/ifconfig")
-  wait 15
-  allGroups.stopApplications
-  Experiment.done
+
+  #info "TEST - Running ifconfig on Receiver"
+  #group('Receiver').exec("/sbin/ifconfig")
+
+  after 30.seconds do
+    Experiment.done
+  end
 end

data/lib/omf_ec/app_definition.rb

@@ -13,7 +13,7 @@ module OmfEc
     # @param [String] name name of the application to define
     def initialize(name)
       self.name = name
-      self.properties = Hash.new
+      self.properties = Hashie::Mash.new
     end
 
     # Add new parameter(s) to this Application Definition
@@ -21,7 +21,7 @@ module OmfEc
     # @param [Hash] params a hash with the parameters to add
     #
     def define_parameter(params)
-      @properties[:parameters] = Hash.new unless @properties.key?(:parameters) 
+      @properties[:parameters] = Hashie::Mash.new unless @properties.key?(:parameters) 
       if params.kind_of? Hash
         @properties[:parameters].merge!(params)
       else
@@ -31,7 +31,7 @@ module OmfEc
     end
 
     def define_measurement_point(mp)
-      @properties[:oml] = Hash.new unless @properties.key?(:oml)
+      @properties[:oml] = Hashie::Mash.new unless @properties.key?(:oml)
       if mp.kind_of? Hash
         @properties[:oml][:available_mps] = Array.new unless @properties[:oml].key?(:available_mps) 
         @properties[:oml][:available_mps] << mp

data/lib/omf_ec/backward/default_events.rb

@@ -7,11 +7,15 @@ module OmfEc
           base.instance_eval do
 
             def_event :ALL_UP do |state|
-              !all_groups.empty? && all_groups.all? do |g|
+              all_groups? do |g|
                 plan = g.members.uniq.sort
                 actual = state.find_all do |v|
                   v[:membership] && v[:membership].include?(g.id)
                 end.map { |v| v[:uid] }.sort
+
+                debug "Planned: #{g.name}(#{g.id}): #{plan}"
+                debug "Actual: #{g.name}(#{g.id}): #{actual}"
+
                 plan == actual
               end
             end
@@ -22,19 +26,20 @@ module OmfEc
                 group.net_ifs && group.net_ifs.each do |nif|
                   nif.map_channel_freq
                   r_type = nif.conf[:type]
-                  r_hrn = nif.conf[:hrn]
+                  r_if_name = nif.conf[:if_name]
                   r_index = nif.conf[:index]
 
                   conf_to_send =
                     if r_type == 'wlan'
                       { type: r_type,
-                        mode: nif.conf.merge(:phy => "<%= request_wlan_devices[#{r_index}][:name] %>").except(:hrn, :type, :index)
+                        if_name: r_if_name,
+                        mode: nif.conf.merge(:phy => "%#{r_index}%").except(:if_name, :type, :index)
                       }
                     else
                       nif.conf.merge(type: r_type).except(:index)
                     end
 
-                  group.create_resource(r_hrn, conf_to_send)
+                  group.create_resource(r_if_name, conf_to_send)
                 end
                 # Create proxies for each apps that were added to this group
                 group.app_contexts.each { |a| group.create_resource(a.name, a.properties) }
@@ -42,8 +47,8 @@ module OmfEc
             end
 
             def_event :ALL_INTERFACE_UP do |state|
-              !all_groups.empty? && all_groups.all? do |g|
-                plan = g.net_ifs.map { |v| v.conf[:hrn] }.uniq.size * g.members.uniq.size
+              all_groups? do |g|
+                plan = g.net_ifs.map { |v| v.conf[:if_name] }.uniq.size * g.members.uniq.size
                 actual = state.find_all do |v|
                   v[:membership] &&
                     (v[:membership].include?("#{g.id}_wlan") || v[:membership].include?("#{g.id}_net"))
@@ -53,10 +58,10 @@ module OmfEc
             end
 
             def_event :ALL_UP_AND_INSTALLED do |state|
-              !all_groups.empty? && all_groups.all? do |g|
+              all_groups? do |g|
                 plan = g.app_contexts.size * g.members.uniq.size
                 actual = state.find_all do |v|
-                  v[:membership] && v[:membership].include?("#{g.id}_application") 
+                  v[:membership] && v[:membership].include?("#{g.id}_application")
                 end.size
                 plan == actual
               end