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

data/lib/omf_ec/experiment_property.rb

@@ -0,0 +1,222 @@
+require 'hashie'
+require 'singleton'
+
+module OmfEc
+  #
+  # This class defines an Experiment Property, and also holds all of the
+  # Experiment Properties defined for a given experiment.
+  # Most of this implementation is re-used from OMF 5.4
+  #
+  class ExperimentProperty
+
+    # Contains all the experiment properties
+    @@properties = Hashie::Mash.new
+    
+    # Holds all observers on any Experiment Property creation
+    @@creation_observers = []
+
+    #
+    # Returns a given property
+    # - name =nameof the property to return
+    #
+    # [Return] a property
+    #
+    def self.[](name)
+      p = @@properties[name.to_s.to_sym]
+      if p.nil?
+        raise OEDLCommandException.new(name, 
+          "Unknown experiment property '#{name}'\n\tKnown properties are "+
+          "'#{ExperimentProperty.names.join(', ')}'")
+      end  
+      return p
+    end
+
+    def self.[]=(name, val)
+      p = ExperimentProperty[name.to_sym]
+      p.set(val)
+    end
+
+    def self.length; @@properties.length end
+
+    # Minitest needs to be able to turn this Class into a string, this is
+    # normally done through the default 'method_missing' of the Classe
+    # but we redefined that... so to run minitest we need to explicitly
+    # define 'to_str' for this Class
+    def self.to_str; "ExperimentProperty" end
+
+    #
+    # Handles missing method, allows to access an existing Experiment
+    # Property with the syntax 'propcontext.propname'
+    #
+    def self.method_missing(name, args = nil)
+      name = name.to_s
+      if setter = (name[-1] == ?=)
+        name.chop!
+      end
+      p = ExperimentProperty[name.to_sym]
+      if setter
+        p.set(args)
+      else
+        return p
+      end
+    end
+  
+    # Iterate over all Experiment Properties. The block
+    # will be called with the respective property as single
+    # argument
+    #
+    # - sort_names = if 'true' sort the properties (default: true)
+    # - &block = the block of commands to call
+    #
+    def self.each(sort_names = false, &block)
+      names = @@properties.keys
+      names = names.sort_by {|sym| sym.to_s} if (sort_names)
+      names.each { |n| block.call(@@properties[n]) }
+    end
+
+    # Return an existing Experiment Property, or create a new one
+    #
+    # - name = name of the property to create/return
+    # - value = value to assign to this property
+    # - description = short string description for this property
+    #
+    # [Return] an Experiment Property
+    #
+    def self.create(name, value = nil, description = nil)
+      name = name.to_s
+      # http://stackoverflow.com/questions/4378670/what-is-a-ruby-regex-to-match-a-function-name
+      if /[@$"]/ =~ name.to_sym.inspect
+        raise OEDLCommandException.new("ExperimentProperty.create", 
+          "Cannot create property '#{name}', its name is not a valid Ruby name")
+      end
+      p = nil
+      name = name.to_sym
+      if (p = @@properties[name]) != nil
+        p.set(value) if value != nil
+        p.description = description if description != nil
+      else
+        p = ExperimentProperty.new(name, value, description)
+        @@properties[name] = p
+        # Let the observers know that we created a new property
+        @@creation_observers.each { |proc| proc.call(:create, p) }
+      end
+      return p
+    end
+
+    #
+    # Return the names of the all defined Experiment Properties
+    #
+    # [Return] an Array with the names of all defined Experiment Properties
+    #
+    def self.names() return @@properties.keys end
+
+    # Add an observer for any creation of a new Experiment Property
+    #
+    # - proc = block to execute when a new Experiment Property is created
+    #
+    def self.add_observer(&proc) @@creation_observers << proc end
+
+    attr_reader :name, :value, :id
+    attr_accessor :description
+
+    private :initialize
+
+    #
+    # Create a new Experiment Property
+    #
+    # - name = name of the property to create/return
+    # - value = value to assign to this property
+    # - description = short string description for this property
+    #
+    def initialize(name, value = nil, description = nil)
+      @name = name.to_s
+      @description = description
+      @change_observers = Array.new
+      set(value)
+    end
+
+    # 
+    # Add a block of command to the list of actions to do 
+    # when this property is being changed
+    #
+    # - &block =  the block of command to add
+    #
+    def on_change (&block)
+      debug "Somebody bound to me" 
+      @change_observers << block
+    end
+
+    #
+    # Update the value of this Experiment Property
+    #
+    # - value = new value for this property
+    #
+    def set(value)
+      @value = value
+      info "#{name} = #{value.inspect} (#{value.class})"
+      @change_observers.each { |proc| proc.call(value) }
+    end
+
+    # Implicit conversion to String (required for + operator)
+    def to_str() @value.to_s end
+
+    # Explicit conversion to String
+    alias_method :to_s, :to_str
+
+    # Division operator for Integer and Float properties
+    def /(right)
+      if @value.kind_of?(Integer) || @value.kind_of?(Float)
+        return (@value / right)
+      else
+        raise OEDLCommandException.new("/", "Illegal operation, "+
+          "the value of Experiment Property '#{@name}' is not numerical "+
+          "(current value is of type #{value.class})")
+      end
+    end
+
+    # Multiplication operator for Integer and Float properties
+    def *(right)
+      if @value.kind_of?(Integer) || @value.kind_of?(Float)
+        return (@value * right)
+      else
+        raise OEDLCommandException.new("*", "Illegal operation, "+
+          "the value of Experiment Property '#{@name}' is not numerical "+
+          "(current value is of type #{value.class})")
+      end
+    end
+
+    # Substraction operator for Integer and Float properties
+    def -(right)
+      if @value.kind_of?(Integer) || @value.kind_of?(Float)
+        return (@value - right)
+      else
+        raise OEDLCommandException.new("-", "Illegal operation, "+
+          "the value of Experiment Property '#{@name}' is not numerical "+
+          "(current value is of type #{value.class})")
+      end
+    end
+
+    # Addition operator for Integer, Float, and String properties
+    def +(right)
+      if @value.kind_of?(Integer) || @value.kind_of?(Float) || @value.kind_of?(String) 
+        return (@value + right)
+      else
+        raise OEDLCommandException.new("+", "Illegal operation, "+
+          "The value of Experiment Property '#{@name}' does not support addition "+
+          "(current value is of type #{value.class})")
+      end
+    end
+
+    # Explicit Coercion for Integer, Float, and String properties
+    # (allow property to be on the right-hand of an operator such as +)
+    def coerce(other)
+      if @value.kind_of?(Integer) || @value.kind_of?(Float) || @value.kind_of?(String) 
+        return other, @value
+      else
+        raise OEDLCommandException.new("coercion", "Illegal operation, "+
+          "The value of Experiment Property '#{@name}' cannot be coerced to allow "+
+          " the requested operation (current value is of type #{value.class})")
+      end
+    end    
+  end
+end

data/lib/omf_ec/group.rb

@@ -1,4 +1,5 @@
 require 'securerandom'
+require 'monitor'
 
 module OmfEc
   # Group instance used in experiment script
@@ -9,12 +10,15 @@ module OmfEc
   # @!attribute members [Array] holding members to be added to group
   # @!attribute apps [Array] holding applications to be added to group
   class Group
+    include MonitorMixin
+
     attr_accessor :name, :id, :net_ifs, :members, :app_contexts
+    attr_reader :topic
 
     # @param [String] name name of the group
     # @param [Hash] opts
     # @option opts [Boolean] :unique Should the group be unique or not, default is true
-    def initialize(name, opts = {})
+    def initialize(name, opts = {}, &block)
       @opts = {unique: true}.merge!(opts)
       self.name = name
       self.id = @opts[:unique] ? SecureRandom.uuid : self.name
@@ -22,57 +26,45 @@ module OmfEc
       self.net_ifs = []
       self.members = []
       self.app_contexts = []
-    end
-
-    # Add existing resources to the group
-    #
-    # Resources to be added could be a list of resources, groups, or the mixture of both.
-    def add_resource(*names)
-      names.each do |name|
-        # resource to add is a group
-        if OmfEc.exp.groups.any? { |v| v.name == name }
-          self.add_resource(*group(name).members.uniq)
-        else
-          OmfEc.comm.subscribe(name) do |m|
-            unless m.error?
-              # resource with uid: name is available
-              unless OmfEc.exp.state.any? { |v| v[:uid] == name }
-                OmfEc.exp.state << { uid: name }
-              end
-
-              r = OmfEc.comm.get_topic(name)
 
-              r.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
+      @resource_topics = {}
 
-              # Receive failed inform message
-              r.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
+      OmfEc.subscribe_and_monitor(id, self, &block)
+      super()
+    end
 
-              c = OmfEc.comm.configure_message(self.id) do |m|
-                m.property(:membership, self.id)
-              end
+    def associate_topic(topic)
+      self.synchronize do
+        @topic = topic
+      end
+    end
 
-              c.publish name
+    def associate_resource_topic(name, res_topic)
+      self.synchronize do
+        @resource_topics[name] = res_topic
+      end
+    end
 
-              c.on_inform_status do |i|
-                r = OmfEc.exp.state.find { |v| v[:uid] == name }
-                r[:membership] = i.read_property(:membership)
-                Experiment.instance.process_events
-              end
+    def resource_topic(name)
+      @resource_topics[name]
+    end
 
-              c.on_inform_failed do |i|
-                warn "RC reports failure: '#{i.read_content("reason")}'"
-              end
+    # Add existing resources to the group
+    #
+    # Resources to be added could be a list of resources, groups, or the mixture of both.
+    def add_resource(*names)
+      self.synchronize do
+        # Recording membership first, used for ALL_UP event
+        names.each do |name|
+          g = OmfEc.experiment.group(name)
+          if g # resource to add is a group
+            @members += g.members
+            self.add_resource(*g.members.uniq)
+          else
+            @members << name.to_s
+            OmfEc.subscribe_and_monitor(name) do |res|
+              info "Config #{name} to join #{self.name}"
+              res.configure(membership: self.id)
             end
           end
         end
@@ -84,73 +76,31 @@ module OmfEc
     # @param [String] name
     # @param [Hash] opts to be used to create new resources
     def create_resource(name, opts, &block)
-
-      # Make a deep copy of opts in case it contains structures of structures
-      begin
-        opts = Marshal.load ( Marshal.dump(opts.merge(hrn: name)))
-      rescue Exception => e
-        raise "#{e.message} - Could not deep copy opts: '#{opts.inspect}'"
-      end
-
-      # Naming convention of child resource group
-      resource_group_name = "#{self.id}_#{opts[:type]}"
-
-
-      unless OmfEc.exp.sub_groups.include?(resource_group_name)
-        OmfEc.exp.sub_groups << resource_group_name
-
-        rg = OmfEc.comm.get_topic(resource_group_name)
-        # Receive  status inform message
-        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?
-            if i.read_property("status_type") == 'APP_EVENT'
-              info "APP_EVENT #{i.read_property('event')} "+
-                "from app #{i.read_property("app")} - msg: #{i.read_property("msg")}"
-            end
-            i.each_property do |p|
-              r[p.attr('key').to_sym] = p.content.ducktype
-            end
-          end
-          Experiment.instance.process_events
-        end
-
-        # Receive failed inform message
-        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")}'"
+      self.synchronize do
+        raise ArgumentError, "Option :type is required for creating resource" if opts[:type].nil?
+
+        # Make a deep copy of opts in case it contains structures of structures
+        begin
+          opts = Marshal.load ( Marshal.dump(opts.merge(hrn: name)))
+        rescue Exception => e
+          raise "#{e.message} - Could not deep copy opts: '#{opts.inspect}'"
         end
-      end
-
-      # We create another group topic for new resouce
-      OmfEc.comm.subscribe(resource_group_name, create_if_non_existent: true) do |m|
-        unless m.error?
 
-          c = OmfEc.comm.create_message(self.id) do |m|
-            m.property(:membership, resource_group_name)
-            opts.each_pair do |k, v|
-              m.property(k, v)
-            end
-          end
+        # Naming convention of child resource group
+        resource_group_name = "#{self.id}_#{opts[:type].to_s}"
 
-          c.publish self.id
-
-          c.on_inform_created do |i|
-            info "#{opts[:type]} #{i.resource_id} created"
-            OmfEc.exp.state << { uid: i.resource_id, type: opts[:type], hrn: name, membership: [resource_group_name]}
-            block.call if block
-            Experiment.instance.process_events
-          end
-
-          c.on_inform_failed do |i|
-            warn "RC reports failure: '#{i.read_content("reason")}'"
-          end
+        OmfEc.subscribe_and_monitor(resource_group_name) do |res_group|
+          associate_resource_topic(opts[:type].to_s, res_group)
+          # Send create message to group
+          r_type = opts.delete(:type)
+          @topic.create(r_type, opts.merge(membership: resource_group_name))
         end
       end
     end
 
     # @return [OmfEc::Context::GroupContext]
     def resources
-      OmfEc::Context::GroupContext.new(group: self.id)
+      OmfEc::Context::GroupContext.new(group: self)
     end
 
     include OmfEc::Backward::Group

data/lib/omf_ec/version.rb

@@ -1,3 +1,3 @@
 module OmfEc
-  VERSION = "6.0.0.pre.4"
+  VERSION = "6.0.0.pre.5"
 end

data/lib/omf_ec.rb

@@ -5,6 +5,7 @@ require 'omf_ec/backward/app_definition'
 require 'omf_ec/backward/default_events'
 require 'omf_ec/backward/core_ext/array'
 require "omf_ec/version"
+require "omf_ec/experiment_property"
 require "omf_ec/experiment"
 require "omf_ec/group"
 require "omf_ec/app_definition"
@@ -22,17 +23,68 @@ module OmfEc
 
     alias_method :exp, :experiment
 
-    # Experiment's communicator instance
-    # @return [OmfCommon::Comm]
-    def communicator
-      Experiment.instance.comm
-    end
-
     # Full path of lib directory
     def lib_root
       File.expand_path("../..", "#{__FILE__}/lib")
     end
 
-    alias_method :comm, :communicator
+    def register_default_callback(topic)
+      topic.on_creation_failed do |msg|
+        warn "RC reports creation.failed: '#{msg[:reason]}'"
+        debug msg
+      end
+
+      topic.on_error do |msg|
+        warn "RC reports error: '#{msg[:reason]}'"
+        debug msg
+      end
+
+      topic.on_warn do |msg|
+        warn "RC reports warning: '#{msg[:reason]}'"
+        debug msg
+      end
+
+      topic.on_creation_ok do |msg|
+        debug "Received CREATION.OK via #{topic.id}"
+        info "Resource #{msg[:res_id]} created"
+
+        OmfEc.experiment.add_or_update_resource_state(msg[:uid], msg.properties)
+
+        OmfEc.experiment.process_events
+      end
+
+      topic.on_status do |msg|
+        props = []
+        msg.each_property { |k, v| props << "#{k}: #{v}" }
+        debug "#{topic.id} >> inform: #{props.join(", ")}"
+
+        if msg[:status_type] == 'APP_EVENT'
+          info "APP_EVENT #{msg[:event]} from app #{msg[:app]} - msg: #{msg[:msg]}"
+        end
+
+        OmfEc.experiment.add_or_update_resource_state(msg[:uid], msg.properties)
+        OmfEc.experiment.process_events
+      end
+    end
+
+    #TODO: Could we find a better name for this method?
+    def subscribe_and_monitor(topic_id, context_obj = nil, &block)
+      topic = OmfCommon::Comm::Topic[topic_id]
+      if topic.nil?
+        OmfCommon.comm.subscribe(topic_id) do |topic|
+          if topic.error?
+            error "Failed to subscribe #{topic_id}"
+          else
+            info "Subscribed to #{topic_id}"
+            context_obj.associate_topic(topic) if context_obj
+            block.call(context_obj || topic) if block
+            register_default_callback(topic)
+          end
+        end
+      else
+        context_obj.associate_topic(topic) if context_obj
+        block.call(context_obj || topic) if block
+      end
+    end
   end
 end

data/omf_ec.gemspec

@@ -7,9 +7,11 @@ Gem::Specification.new do |s|
   s.version     = OmfEc::VERSION
   s.authors     = ["NICTA"]
   s.email       = ["omf-user@lists.nicta.com.au"]
-  s.homepage    = "https://www.mytestbed.net"
+  s.homepage    = "http://omf.mytestbed.net"
   s.summary     = %q{OMF experiment controller}
   s.description = %q{Experiment controller of OMF, a generic framework for controlling and managing networking testbeds.}
+  s.required_ruby_version = '>= 1.9.3'
+  s.license = 'MIT'  
 
   s.rubyforge_project = "omf_ec"
 
@@ -21,5 +23,5 @@ Gem::Specification.new do |s|
   # specify any dependencies here; for example:
   s.add_development_dependency "minitest", "~> 3.2"
   s.add_runtime_dependency "omf_common", "~> 6.0.0.pre"
-  s.add_runtime_dependency "gli", "~> 2.4.1"
+  s.add_runtime_dependency "gli", "~> 2.5.3"
 end

data/test/omf_ec/dsl_spec.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+require 'omf_ec/dsl'
+
+describe OmfEc::DSL do
+  describe "when included" do
+
+    include OmfEc::DSL
+
+    it "must respond to after and every" do
+      respond_to?(:after).must_equal true
+      respond_to?(:every).must_equal true
+    end
+
+    it "must respond to def_property" do
+      @exp = MiniTest::Mock.new
+      @exp.expect(:add_property, true, [String, Object, String])
+
+      OmfEc.stub :experiment, @exp do
+        def_property('name', 'default', 'testing')
+      end
+    end
+
+    it "must respond to def_application" do
+      block = proc { 1 }
+      def_application('bob', &block).must_equal 1
+      OmfEc.experiment.app_definitions.key?('bob').must_equal true
+    end
+
+    it "must respond to def_group" do
+      block = proc { 1 }
+      OmfEc.stub :subscribe_and_monitor, true do
+        def_group('bob', &block).must_be_kind_of OmfEc::Group
+      end
+    end
+
+    it "must respond to all_groups iterator" do
+      block = proc { 1 }
+      all_groups(&block)
+    end
+
+    it "must respond to all_groups?" do
+      OmfEc.stub :subscribe_and_monitor, true do
+        OmfEc.experiment.stub :groups, [] do
+          all_groups? { true }.must_equal false
+        end
+        def_group('bob')
+        all_groups? { |g| g.name == 'bob' }.must_equal true
+      end
+    end
+  end
+
+end
+

data/test/omf_ec/experiment_property_spec.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+require 'omf_ec/experiment_property'
+require 'omf_ec/dsl'
+include OmfEc::DSL
+
+describe OmfEc::ExperimentProperty do
+
+  describe "when a new ExperimentProperty is created" do
+    it "must raise an error if it is given an invalid name" do
+      created_properties = 0
+      # Test only a few common invalid name patterns
+      %w(12 a=b a/b 1a .a a.b a?b a!b !a ?a #a $a @a %a).each do |name|
+        begin
+          OmfEc::ExperimentProperty.create(name)
+          created_properties = created_properties + 1
+        rescue Exception => ex
+          ex.must_be_kind_of OEDLCommandException
+        end
+      end
+      created_properties.must_equal 0
+    end
+
+    it "must not create a new property if one already exist with the same name" do
+      size_before = OmfEc::ExperimentProperty.length
+      OmfEc::ExperimentProperty.create('bar','a')
+      OmfEc::ExperimentProperty[:bar].value.must_equal 'a'
+      OmfEc::ExperimentProperty.create('bar','b')
+      OmfEc::ExperimentProperty[:bar].value.must_equal 'b'
+      OmfEc::ExperimentProperty.length.must_equal (size_before + 1)
+    end
+
+    it "must return a properly set ExperimentProperty object" do
+      size_before = OmfEc::ExperimentProperty.length
+      OmfEc::ExperimentProperty.create('foo', 1, 'abc')
+      OmfEc::ExperimentProperty[:foo].name.must_equal 'foo'
+      OmfEc::ExperimentProperty[:foo].value.must_equal 1
+      OmfEc::ExperimentProperty[:foo].description.must_equal 'abc'
+      OmfEc::ExperimentProperty.length.must_equal (size_before + 1)
+    end
+
+    it "must inform all of its observers when its value changes" do
+      value = 2
+      foobar = OmfEc::ExperimentProperty.create('foobar',1)
+      foobar.on_change { |v| v.must_equal value } 
+      foobar.on_change { |v| (v*2).must_equal value*2 }
+      OmfEc::ExperimentProperty[:foobar] = value
+      OmfEc::ExperimentProperty[:foobar].value.must_equal value
+    end
+  end
+
+  describe "when a the Class ExperimentProperty is creating a new property" do
+    it "must inform all of its observers" do
+      size_before = OmfEc::ExperimentProperty.length
+      OmfEc::ExperimentProperty.add_observer do |c,p|
+        p.name.must_equal 'barfoo'
+        p.value.must_equal 123
+        p.description.must_equal 'abc'
+      end
+      OmfEc::ExperimentProperty.create('barfoo', 123, 'abc')
+      OmfEc::ExperimentProperty.length.must_equal (size_before + 1)
+    end
+  end
+
+  describe "when an operation involves an ExperimentProperty" do
+    it "must return the expected result" do
+      OmfEc::ExperimentProperty[:foo] = 2
+      (OmfEc::ExperimentProperty[:foo] + 1).must_equal 3
+      (1 + OmfEc::ExperimentProperty[:foo]).must_equal 3
+      (OmfEc::ExperimentProperty[:foo] - 1).must_equal 1
+      (1 - OmfEc::ExperimentProperty[:foo]).must_equal -1
+      (OmfEc::ExperimentProperty[:foo] * 2).must_equal 4      
+      (2 * OmfEc::ExperimentProperty[:foo]).must_equal 4
+      (OmfEc::ExperimentProperty[:foo] / 1).must_equal 2      
+      (2 / OmfEc::ExperimentProperty[:foo]).must_equal 1
+      OmfEc::ExperimentProperty[:bar] = 'a'
+      (OmfEc::ExperimentProperty[:bar] + "b").must_equal 'ab'     
+      ('b' + OmfEc::ExperimentProperty[:bar]).must_equal 'ba'    
+    end
+  end
+
+end