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

data/lib/omf_ec/backward/dsl.rb

@@ -22,51 +22,19 @@ module OmfEc
         end
       end
 
-      def defApplication(uri,name,&block)
+      def defApplication(uri, name=nil ,&block)
         # URI parameter was used by previous OMF5 EC, for now we
         # do nothing with it in OMF6
+        name = uri if name.nil?
         def_application(name,&block)
       end
 
       def defGroup(name, *members, &block)
         group = OmfEc::Group.new(name)
-        OmfEc.exp.groups << group
-
-        members.each do |m|
-          m_group = OmfEc.exp.groups.find { |v| v.name == m }
-          if m_group
-            group.members += m_group.members
-          else
-            group.members << m
-          end
-        end
+        OmfEc.experiment.add_group(group)
+        group.add_resource(*members)
 
         block.call(group) if block
-
-        OmfEc.comm.subscribe(group.id, create_if_non_existent: true) do |m|
-          unless m.error?
-            members.each do |m|
-              group.add_resource(m)
-            end
-
-            rg = OmfEc.comm.get_topic(group.id)
-
-            rg.on_message lambda {|m| m.operation == :inform && m.read_content('inform_type') == 'FAILED' && m.context_id.nil? } do |i|
-              warn "RC reports failure: '#{i.read_content("reason")}'"
-            end
-
-            rg.on_message lambda {|m| m.operation == :inform && m.read_content('inform_type') == 'STATUS' && m.context_id.nil? } do |i|
-              r = OmfEc.exp.state.find { |v| v[:uid] == i.read_property(:uid) }
-              unless r.nil?
-                i.each_property do |p|
-                  key = p.attr('key').to_sym
-                  r[key] = i.read_property(key)
-                end
-              end
-              Experiment.instance.process_events
-            end
-          end
-        end
       end
 
       # Wait for some time before issuing more commands

data/lib/omf_ec/backward/exp/testbed.rb

@@ -1,4 +1,4 @@
-comm = OmfEc.comm
+comm = OmfCommon.comm
 
 testbed_topic = comm.get_topic('testbed')
 
@@ -6,11 +6,11 @@ msgs = {
   create: comm.create_message([type: 'application']),
   req_platform: comm.request_message([:platform]),
   conf_path: comm.configure_message([binary_path: @cmd]),
-  run_application: comm.configure_message([state: :run])
+  run_application: comm.configure_message([state: :running])
 }
 
-msgs[:create].on_inform_created do |message|
-  app_topic = comm.get_topic(message.resource_id)
+msgs[:create].on_inform_creation_ok do |message|
+  app_topic = comm.get_topic(message.res_id)
   app_topic.subscribe do
     msgs[:req_platform].publish app_topic.id
     sleep 1
@@ -21,16 +21,16 @@ msgs[:create].on_inform_created do |message|
 
   app_topic.on_message  do |m|
     if m.operation == :inform
-      case m.read_content("inform_type")
+      case m.read_content("itype")
       when 'STATUS'
         if m.read_property("status_type") == 'APP_EVENT'
           after (2) { comm.disconnect } if m.read_property("event") =~ /DONE.(OK|ERROR)/
           puts m.read_property("msg")
         end
       when 'ERROR'
-        logger.error m.read_content('reason') if m.read_content("inform_type") == 'ERROR'
+        logger.error m.read_content('reason') if m.read_content("itype") == 'ERROR'
       when 'WARN'
-        logger.warn m.read_content('reason') if m.read_content("inform_type") == 'WARN'
+        logger.warn m.read_content('reason') if m.read_content("itype") == 'WARN'
       end
     end
   end

data/lib/omf_ec/backward/group.rb

@@ -5,6 +5,10 @@ module OmfEc
     module Group
       # The following are ODEL 5 methods
 
+      def resource_group(type)
+        "#{self.id}_#{type.to_s}"
+      end
+
       # Create an application for the group and start it
       #
       def exec(name)
@@ -14,25 +18,35 @@ module OmfEc
 
         e_name = "#{self.name}_application_#{name}_created_#{e_uid}"
 
+        resource_group_name = "#{self.id}_application"
+
         def_event e_name do |state|
-          state.find_all { |v| v[:hrn] == name }.size >= self.members.uniq.size
+          state.find_all { |v| v[:hrn] == name && v[:membership] && v[:membership].include?(resource_group_name)}.size >= self.members.uniq.size
         end
 
         on_event e_name do
-          resources[type: 'application', name: name].state = :run
+          resources[type: 'application', name: name].state = :running
         end
       end
 
       def startApplications
-        resources[type: 'application'].state = :run
+        if self.app_contexts.empty?
+          warn "No applications defined in group #{self.name}. Nothing to start"
+        else
+          resources[type: 'application'].state = :running
+        end
       end
 
       def stopApplications
-        resources[type: 'application'].state = :stop
+        if self.app_contexts.empty?
+          warn "No applications defined in group #{self.name}. Nothing to stop"
+        else
+          resources[type: 'application'].state = :stopped
+        end
       end
 
       def addApplication(name, &block)
-        app_cxt = OmfEc::Context::AppContext.new(name)
+        app_cxt = OmfEc::Context::AppContext.new(name,self)
         block.call(app_cxt) if block
         self.app_contexts << app_cxt
       end
@@ -49,16 +63,16 @@ module OmfEc
 
       def method_missing(name, *args, &block)
         if name =~ /w(\d+)/
-          net = self.net_ifs.find { |v| v.conf[:hrn] == "wlan#{$1}" }
+          net = self.net_ifs.find { |v| v.conf[:if_name] == "wlan#{$1}" }
           if net.nil?
-            net = OmfEc::Context::NetContext.new(:type => 'wlan', :hrn => "wlan#{$1}", :index => $1)
+            net = OmfEc::Context::NetContext.new(:type => 'wlan', :if_name => "wlan#{$1}", :index => $1)
             self.net_ifs << net
           end
           net
         elsif name =~ /e(\d+)/
-          net = self.net_ifs.find { |v| v.conf[:hrn] == "eth#{$1}" }
+          net = self.net_ifs.find { |v| v.conf[:if_name] == "eth#{$1}" }
           if net.nil?
-            net = OmfEc::Context::NetContext.new(:type => 'net', :hrn => "eth#{$1}", :index => $1)
+            net = OmfEc::Context::NetContext.new(:type => 'net', :if_name => "eth#{$1}", :index => $1)
             self.net_ifs << net
           end
           net

data/lib/omf_ec/context/app_context.rb

@@ -8,44 +8,75 @@ module OmfEc::Context
     # values for each. Thus we need to distinguish these different context
     @@context_count = Hash.new
 
-    def initialize(name)
-      if OmfEc.exp.app_definitions.key?(name)
-        self.app_def = OmfEc.exp.app_definitions[name]
+    def initialize(name, group)
+      if OmfEc.experiment.app_definitions.key?(name)
+        self.app_def = OmfEc.experiment.app_definitions[name]
         self.param_values = Hash.new
         self.oml_collections = Array.new
         @@context_count[name] = 0 unless @@context_count.key?(name)
         id = @@context_count[name]
         @@context_count[name] += 1
         self.name = "#{name}_cxt_#{id}"
+        @group = group
         self
       else
         raise RuntimeError, "Cannot create context for unknwon application '#{name}'"
       end
     end
 
-    def setProperty(key, value)
-      @param_values[key] = value
+    def setProperty(key, property_value)
+      app_def_param = app_def.properties.parameters
+      raise OEDLUnknownProperty.new(key, "Unknown parameter '#{key}' for application "+
+        "definition '#{app_def.name}'") if app_def_param.nil? || !app_def_param.key?(key)
+      if property_value.kind_of?(ExperimentProperty)
+        @param_values[key] = property_value.value
+        # if this app parameter has its dynamic attribute set to true, then
+        # we register a callback block to the ExperimentProperty, which will
+        # be called each time the property changes its value
+        if app_def_param[key][:dynamic]
+          info "Binding dynamic parameter '#{key}' to the property '#{property_value.name}'"
+          property_value.on_change do |new_value|
+            info "Updating dynamic app parameter '#{key}' with value: '#{new_value}'"
+            OmfEc.subscribe_and_monitor(@group.resource_group(:application)) do |topic|
+              p = properties
+              p[:parameters][key.to_sym][:value] = property_value.value
+              topic.configure(p, { guard: { hrn: @name} } )
+            end
+          end
+        end
+      else
+        @param_values[key] = property_value
+      end
       self
     end
 
     # For now this follows v5.4 syntax...
     # We have not yet finalised an OML syntax inside OEDL for v6
     def measure(mp,filters)
-      collection = {:url => OmfEc.exp.oml_uri, :streams => [] }
+      collection = {:url => OmfEc.experiment.oml_uri, :streams => [] }
       stream = { :mp => mp , :filters => [] }.merge(filters)
       collection[:streams] << stream
       @oml_collections << collection
     end
 
     def properties
-      # deep copy the properties from the our app definition
+      # deep copy the properties from the app definition
       original = Marshal.load(Marshal.dump(app_def.properties)) 
+      # now build the properties for this context
+      # - use the properties from app definition as the base
+      # - if this context's param_values has a property which also exists in 
+      #   the app def and if that property has an assigned value, then 
+      #   use that value for the properties of this context
       p = original.merge({:type => 'application'})
-      @param_values.each { |k,v| p[:parameters][k][:value] = v if p[:parameters].key?(k) }
+      @param_values.each do |k,v|
+        if p[:parameters].key?(k)
+          p[:parameters][k][:value] = v.kind_of?(ExperimentProperty) ? v.value : v
+        end
+      end
       if @oml_collections.size > 0
         p[:use_oml] = true
         p[:oml][:id] = @name
-        p[:oml][:experiment] = OmfEc.exp.id
+        p[:oml][:experiment] = OmfEc.experiment.id
         p[:oml][:collection] = @oml_collections      
       end
       p

data/lib/omf_ec/context/group_context.rb

@@ -28,60 +28,31 @@ module OmfEc::Context
     end
 
     def send_message(name, value = nil, &block)
-      send_to = self.group
-      send_to = send_to + "_#{self.guard[:type]}" if self.guard[:type]
-
-      # if release, we need to request resource ids first
-      op_name = self.operation == :release ? "request_message" : "#{self.operation}_message"
-
-      o_m = OmfEc.comm.__send__(op_name, send_to) do |m|
-        m.element(:guard) do |g|
-          self.guard.each_pair do |k, v|
-            g.property(k, v)
-          end
-        end
-
-        unless self.operation == :release
-          m.property(name, value)
-        end
-
-        unless self.operation == :configure
-          m.property(:uid)
-          m.property(:hrn)
-        end
+      if self.guard[:type]
+        topic = self.group.resource_topic(self.guard[:type])
+      else
+        topic = self.group.topic
       end
 
-      o_m.publish send_to
-
-      o_m.on_inform_status do |i|
-        if self.operation == :release
-          uid = i.read_property(:uid)
-          info "Going to release #{uid}"
-          release_m = OmfEc.comm.release_message(self.group) { |m| m.element('resource_id', uid) }
-
-          release_m.publish self.group
-
-          release_m.on_inform_released do |m|
-            info "#{m.resource_id} released"
-            r = OmfEc.exp.state.find { |v| v[:uid] == m.resource_id }
-            r[:released] = true unless r.nil?
-            block.call if block
-            Experiment.instance.process_events
+      case self.operation
+      when :configure
+        topic.configure({ name => value }, { guard: self.guard })
+      when :request
+        topic.request([:uid, :hrn, name], { guard: self.guard })
+      when :release
+        topics_to_release = OmfEc.experiment.state.find_all do |res_state|
+          all_equal(self.guard.keys) do |k|
+            res_state[k] == self.guard[k]
           end
         end
 
-        r = OmfEc.exp.state.find { |v| v[:uid] == i.read_property(:uid) }
-        unless r.nil?
-          i.each_property do |p|
-            p_key = p.attr('key').to_sym
-            r[p_key] = i.read_property(p_key)
+        topics_to_release.each do |res_state|
+          OmfEc.subscribe_and_monitor(res_state.uid) do |child_topic|
+            OmfEc.subscribe_and_monitor(self.group.id) do |group_topic|
+              group_topic.release(child_topic) if child_topic
+            end
           end
         end
-        Experiment.instance.process_events
-      end
-
-      o_m.on_inform_failed do |i|
-        warn "RC reports failure: '#{i.read_content("reason")}'"
       end
     end
   end

data/lib/omf_ec/context/net_context.rb

@@ -27,7 +27,7 @@ module OmfEc::Context
                    else
                      net_prop
                    end
-        self.conf.merge!(net_prop => args[0])
+        self.conf.merge!(net_prop => args[0].to_s)
       else
         super
       end
@@ -35,10 +35,10 @@ module OmfEc::Context
 
     def map_channel_freq
       if self.conf[:channel] && self.conf[:frequency].nil?
-        self.conf[:frequency] = FREQUENCY[self.conf[:channel].to_i]
+        self.conf[:frequency] = FREQUENCY[self.conf[:channel].to_s.to_i]
       end
       if self.conf[:channel].nil? && self.conf[:frequency]
-        self.conf[:channel] = FREQUENCY.keys.find { |k| FREQUENCY[k] == self.conf[:frequency].to_i }
+        self.conf[:channel] = FREQUENCY.keys.find { |k| FREQUENCY[k] == self.conf[:frequency].to_sto_i }
       end
       self
     end

data/lib/omf_ec/dsl.rb

@@ -4,13 +4,49 @@ require 'eventmachine'
 module OmfEc
   # DSL methods to be used for OEDL scripts
   module DSL
+
+    # Define OEDL-specific exceptions. These are the Exceptions that might be
+    # raised when the OMF EC is processing an OEDL experiment scripts
+    #
+    # The base exception is OEDLException
+    class OEDLException < Exception; end
+
+    class OEDLArgumentException < OEDLException
+      attr_reader :cmd, :arg
+      def initialize(cmd, arg, msg = nil)
+        @cmd = cmd
+        @arg = arg
+        msg ||= "Illegal value for argument '#{arg}' in command '#{cmd}'"
+        super(msg)
+      end
+    end
+
+    class OEDLCommandException < OEDLException
+      attr_reader :cmd
+      def initialize(cmd, msg = nil)
+        @cmd = cmd
+        msg ||= "Illegal command '#{cmd}' unsupported by OEDL"
+        super(msg)
+      end
+    end
+
+    class OEDLUnknownProperty < OEDLException
+      attr_reader :cmd
+      def initialize(name, msg = nil)
+        @name = name
+        msg ||= "Unknown property '#{name}', not previously defined in your OEDL experiment"
+        super(msg)
+      end
+    end
+
+
     # Use EM timer to execute after certain time
     #
     # @example do something after 2 seconds
     #
     #   after 2.seconds { 'do something' }
     def after(time, &block)
-      OmfEc.comm.add_timer(time, block)
+      OmfCommon.eventloop.after(time, &block)
     end
 
     # Use EM periodic timer to execute after certain time
@@ -19,12 +55,12 @@ module OmfEc
     #
     #   every 2.seconds { 'do something' }
     def every(time, &block)
-      OmfEc.comm.add_periodic_timer(time, block)
+      OmfCommon.eventloop.every(time, &block)
     end
 
     def def_application(name,&block)
       app_def = OmfEc::AppDefinition.new(name)
-      OmfEc.exp.app_definitions[name] = app_def
+      OmfEc.experiment.app_definitions[name] = app_def
       block.call(app_def) if block
     end
 
@@ -39,47 +75,29 @@ module OmfEc
     #
     # @see OmfEc::Backward::DSL#defGroup
     def def_group(name, &block)
-      group = OmfEc::Group.new(name)
-      OmfEc.exp.groups << group
-
-      OmfEc.comm.subscribe(group.id, create_if_non_existent: true) do |m|
-        unless m.error?
-          block.call group if block
-
-          rg = OmfEc.comm.get_topic(group.id)
-
-          rg.on_message lambda {|m| m.operation == :inform && m.read_content('inform_type') == 'FAILED' && m.context_id.nil? } do |i|
-            warn "RC reports failure: '#{i.read_content("reason")}'"
-          end
-
-          rg.on_message lambda {|m| m.operation == :inform && m.read_content('inform_type') == 'STATUS' && m.context_id.nil? } do |i|
-            r = OmfEc.exp.state.find { |v| v[:uid] == i.read_property(:uid) }
-            unless r.nil?
-              i.each_property do |p|
-                key = p.attr('key').to_sym
-                r[key] = i.read_property(key)
-              end
-            end
-            Experiment.instance.process_events
-          end
-        end
-      end
+      group = OmfEc::Group.new(name, &block)
+      OmfEc.experiment.add_group(group)
+      group
     end
 
     # Get a group instance
     #
     # @param [String] name name of the group
     def group(name, &block)
-      group = OmfEc.exp.groups.find {|v| v.name == name}
+      group = OmfEc.experiment.group(name)
+      raise RuntimeError, "Group #{name} not found" if group.nil?
+
       block.call(group) if block
       group
     end
 
     # Iterator for all defined groups
     def all_groups(&block)
-      OmfEc.exp.groups.each do |g|
-        block.call(g) if block
-      end
+      OmfEc.experiment.each_group(&block)
+    end
+
+    def all_groups?(&block)
+      OmfEc.experiment.all_groups?(&block)
     end
 
     alias_method :all_nodes!, :all_groups
@@ -103,12 +121,12 @@ module OmfEc
     # @param description short text description of this property
     #
     def def_property(name, default_value, description = nil)
-      OmfEc.exp.property[name] ||= default_value
+      OmfEc.experiment.add_property(name, default_value, description)
     end
 
     # Return the context for setting experiment wide properties
     def property
-      OmfEc.exp.property
+      return OmfEc.experiment.property
     end
 
     alias_method :prop, :property
@@ -135,16 +153,13 @@ module OmfEc
 
     # Define an event
     def def_event(name, &trigger)
-      if OmfEc.exp.events.find { |v| v[:name] == name }
-        raise RuntimeError, "Event '#{name}' has been defined"
-      else
-        OmfEc.exp.events << { name: name, trigger: trigger }
-      end
+      raise ArgumentError, 'Need a trigger callback' if trigger.nil?
+      OmfEc.experiment.add_event(name, trigger)
     end
 
     # Define an event callback
     def on_event(name, consume_event = true, &callback)
-      event = OmfEc.exp.events.find { |v| v[:name] == name }
+      event = OmfEc.experiment.event(name)
       if event.nil?
         raise RuntimeError, "Event '#{name}' not defined"
       else

data/lib/omf_ec/experiment.rb

@@ -1,5 +1,6 @@
 require 'hashie'
 require 'singleton'
+require 'monitor'
 
 module OmfEc
   # Experiment class to hold relevant state information
@@ -7,17 +8,112 @@ module OmfEc
   class Experiment
     include Singleton
 
-    attr_accessor :property,:state, :comm, :groups, :events, :name, :app_definitions, :sub_groups, :oml_uri
+    include MonitorMixin
+
+    attr_accessor :name, :oml_uri, :app_definitions, :property, :cmdline_properties
+    attr_reader :groups, :sub_groups, :state
 
     def initialize
       @id = Time.now.utc.iso8601
-      self.property ||= Hashie::Mash.new
-      self.comm ||= OmfCommon::Comm.new(:xmpp)
-      self.state ||= []
-      self.groups ||= []
-      self.events ||= []
-      self.app_definitions ||= Hash.new
-      self.sub_groups ||= []
+      @state ||= [] #TODO: we need to keep history of all the events and not ovewrite them
+      @groups ||= []
+      @events ||= []
+      @app_definitions ||= Hash.new
+      @sub_groups ||= []
+      @cmdline_properties ||= Hash.new
+      super
+    end
+
+    def property
+      return ExperimentProperty
+    end
+
+    def add_property(name, value = nil, description = nil)
+      override_value = @cmdline_properties[name.to_s.to_sym]
+      value = override_value unless override_value.nil?
+      ExperimentProperty.create(name, value, description)
+    end
+
+    def resource_state(id)
+      @state.find { |v| v[:uid].to_s == id.to_s }
+    end
+
+    alias_method :resource, :resource_state
+
+    def resource_by_hrn(hrn)
+      @state.find { |v| v[:hrn].to_s == hrn.to_s }
+    end
+
+    def add_or_update_resource_state(name, opts = {})
+      self.synchronize do
+        res = resource_state(name)
+        if res
+          opts.each do |key, value|
+            if value.class == Array
+              # Merge array values
+              res[key] ||= []
+              res[key] += value
+              res[key].uniq!
+            elsif value.kind_of? Hash
+              # Merge hash values
+              res[key] ||= {}
+              res[key].merge(value)
+            else
+              # Overwrite otherwise
+              res[key] = value
+            end
+          end
+        else
+          info "Newly discovered resource >> #{opts[:uid]}"
+          @state << Hashie::Mash.new({ uid: name }.merge(opts))
+        end
+      end
+    end
+
+    alias_method :add_resource, :add_or_update_resource_state
+
+    def sub_group(name)
+      @sub_groups.find { |v| v == name }
+    end
+
+    def add_sub_group(name)
+      self.synchronize do
+        @sub_groups << name unless @sub_groups.include?(name)
+      end
+    end
+
+    def group(name)
+      groups.find { |v| v.name == name }
+    end
+
+    def add_group(group)
+      self.synchronize do
+        raise ArgumentError, "Expect Group object, got #{group.inspect}" unless group.kind_of? OmfEc::Group
+        @groups << group unless group(group.name)
+      end
+    end
+
+    def each_group(&block)
+      if block
+        groups.each { |g| block.call(g) }
+      else
+        groups
+      end
+    end
+
+    def all_groups?(&block)
+      !groups.empty? && groups.all? { |g| block ? block.call(g) : g }
+    end
+
+    def event(name)
+      @events.find { |v| v[:name] == name }
+    end
+
+    def add_event(name, trigger)
+      self.synchronize do
+        raise RuntimeError, "Event '#{name}' has been defined" if event(name)
+        @events << { name: name, trigger: trigger }
+      end
     end
 
     # Unique experiment id
@@ -27,11 +123,11 @@ module OmfEc
 
     # Parsing user defined events, checking conditions against internal state, and execute callbacks if triggered
     def process_events
-      EM.next_tick do
-        self.events.find_all { |v| v[:callbacks] && !v[:callbacks].empty? }.each do |event|
-          if event[:trigger].call(self.state)
+      self.synchronize do
+        @events.find_all { |v| v[:callbacks] && !v[:callbacks].empty? }.each do |event|
+          if event[:trigger].call(@state)
             info "Event triggered: '#{event[:name]}'"
-            self.events.delete(event) if event[:consume_event]
+            @events.delete(event) if event[:consume_event]
 
             # Last in first serve callbacks
             event[:callbacks].reverse.each do |callback|
@@ -46,9 +142,9 @@ module OmfEc
     class << self
       # Disconnect communicator, try to delete any XMPP affiliations
       def done
-        info "Exit in up to 20 seconds..."
+        info "Exit in up to 15 seconds..."
 
-        OmfEc.comm.add_timer(10) do
+        OmfCommon.eventloop.after(10) do
           info "Release applications and network interfaces"
 
           allGroups do |g|
@@ -57,12 +153,8 @@ module OmfEc
             g.resources[type: 'wlan'].release unless g.net_ifs.find_all { |v| v.conf[:type] == 'wlan' }.empty?
           end
 
-          OmfEc.comm.add_timer(5) do
-            OmfEc.comm.disconnect(delete_affiliations: true)
-
-            OmfEc.comm.add_timer(5) do
-              OmfEc.comm.disconnect
-            end
+          OmfCommon.eventloop.after(5) do
+            OmfCommon.comm.disconnect
           end
         end
       end