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

data/lib/omf_ec/app_definition.rb

@@ -0,0 +1,57 @@
+require 'securerandom'
+
+module OmfEc
+  # Application Definition used in experiment script
+  #
+  # @!attribute name [String] name of the resource
+  class AppDefinition
+
+    # TODO: eventually this call would mirror all the properties of the App Proxy
+    # right now we just have name, binary_path, parameters
+    attr_accessor :name, :properties 
+
+    # @param [String] name name of the application to define
+    def initialize(name)
+      self.name = name
+      self.properties = Hash.new
+    end
+
+    # Add new parameter(s) to this Application Definition
+    # 
+    # @param [Hash] params a hash with the parameters to add
+    #
+    def define_parameter(params)
+      @properties[:parameters] = Hash.new unless @properties.key?(:parameters) 
+      if params.kind_of? Hash
+        @properties[:parameters].merge!(params)
+      else
+        error "Cannot define parameter for app '#{self.name}'! Parameter "+
+          "not passed as a Hash ('#{params.inspect}')"
+      end 
+    end
+
+    def define_measurement_point(mp)
+      @properties[:oml] = Hash.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
+      else
+        error "Cannot define Measurement Point for app '#{self.name}'! MP "+
+          "not passed as a Hash ('#{mp.inspect}')"
+      end
+    end
+
+    def method_missing(method_name, *args)
+      k = method_name.to_sym
+      return @properties[k] if @properties.key?(k)
+      m = method_name.to_s.match(/(.*?)([=]?)$/)
+      if m[2] == '='
+        @properties[m[1].to_sym] = args.first 
+      else
+        super
+      end
+    end
+
+    include OmfEc::Backward::AppDefinition
+  end
+end

data/lib/omf_ec/backward/app_definition.rb

@@ -0,0 +1,35 @@
+module OmfEc
+  module Backward
+    module AppDefinition
+      # The following are ODEL 5 methods
+
+      # Add a new parameter to this Application Definition
+      # This method is for backward compatibility with previous OEDL 5
+      #
+      # @param [String] name name of the application to define
+      def defProperty(name = :mandatory, description = nil, parameter = nil, options = {})
+        opts = {:description => description, :cmd => parameter}
+        # Map old OMF5 types to OMF6
+        options[:type] = 'Numeric' if options[:type] == :integer
+        options[:type] = 'String' if options[:type] == :string
+        options[:type] = 'Boolean' if options[:type] == :boolean
+        opts = opts.merge(options)
+        define_parameter(Hash[name,opts])
+      end
+
+      def defMetric(name,type)
+        @fields << {:field => name, :type => type}
+      end
+
+      def defMeasurement(name,&block)
+        mp = {:mp => name, :fields => []}
+        @fields = []
+        # call the block with ourserlves to process its 'defMetric' statements
+        block.call(self) if block 
+        @fields.each { |f| mp[:fields] << f }
+        define_measurement_point(mp)
+      end
+
+    end
+  end
+end

data/lib/omf_ec/backward/core_ext/array.rb

@@ -0,0 +1,19 @@
+class Array
+  def startApplications
+    if !self.empty? && self.all? { |v| v.class == OmfEc::Group }
+      self.each { |g| g.startApplications }
+    end
+  end
+
+  def stopApplications
+    if !self.empty? && self.all? { |v| v.class == OmfEc::Group }
+      self.each { |g| g.stopApplications }
+    end
+  end
+
+  def exec(name)
+    if !self.empty? && self.all? { |v| v.class == OmfEc::Group }
+      self.each { |g| g.exec(name) }
+    end
+  end
+end

data/lib/omf_ec/backward/default_events.rb

@@ -0,0 +1,71 @@
+module OmfEc
+  module Backward
+    module DefaultEvents
+
+      class << self
+        def included(base)
+          base.instance_eval do
+
+            def_event :ALL_UP do |state|
+              !all_groups.empty? && all_groups.all? 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
+                plan == actual
+              end
+            end
+
+            on_event :ALL_UP do
+              all_groups do |group|
+                # Deal with brilliant net.w0.ip syntax...
+                group.net_ifs && group.net_ifs.each do |nif|
+                  nif.map_channel_freq
+                  r_type = nif.conf[:type]
+                  r_hrn = nif.conf[:hrn]
+                  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)
+                      }
+                    else
+                      nif.conf.merge(type: r_type).except(:index)
+                    end
+
+                  group.create_resource(r_hrn, 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) }
+              end
+            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
+                actual = state.find_all do |v|
+                  v[:membership] &&
+                    (v[:membership].include?("#{g.id}_wlan") || v[:membership].include?("#{g.id}_net"))
+                end.size
+                plan == actual
+              end
+            end
+
+            def_event :ALL_UP_AND_INSTALLED do |state|
+              !all_groups.empty? && all_groups.all? 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") 
+                end.size
+                plan == actual
+              end
+            end
+
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/omf_ec/backward/dsl.rb

@@ -0,0 +1,83 @@
+module OmfEc
+  module Backward
+    module DSL
+      class << self
+        def included(base)
+          v5_style(:defProperty, base)
+          v5_style(:defEvent, base)
+          v5_style(:onEvent, base)
+          v5_style(:allEqual, base)
+          v5_style(:onEvent, base)
+          v5_style(:allGroups, base)
+          v5_style(:allNodes!, base)
+        end
+
+        def v5_style(name, base)
+          new_name = name.to_s.underscore.to_sym
+          unless method_defined? new_name
+            base.class_eval do
+              alias_method name, new_name
+            end
+          end
+        end
+      end
+
+      def defApplication(uri,name,&block)
+        # URI parameter was used by previous OMF5 EC, for now we
+        # do nothing with it in OMF6
+        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
+
+        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
+      #
+      # @param [Fixnum] duration Time to wait in seconds (can be
+      #
+      def wait(duration)
+        info "Request from Experiment Script: Wait for #{duration}s...."
+        warn "Calling 'wait' or 'sleep' will block entire EC event loop. Please try 'after' or 'every'"
+        sleep duration
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+comm = OmfEc.comm
+
+testbed_topic = comm.get_topic('testbed')
+
+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])
+}
+
+msgs[:create].on_inform_created do |message|
+  app_topic = comm.get_topic(message.resource_id)
+  app_topic.subscribe do
+    msgs[:req_platform].publish app_topic.id
+    sleep 1
+    msgs[:conf_path].publish app_topic.id
+    sleep 1
+    msgs[:run_application].publish app_topic.id
+  end
+
+  app_topic.on_message  do |m|
+    if m.operation == :inform
+      case m.read_content("inform_type")
+      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'
+      when 'WARN'
+        logger.warn m.read_content('reason') if m.read_content("inform_type") == 'WARN'
+      end
+    end
+  end
+end
+
+msgs[:req_platform].on_inform_status do |m|
+  m.each_property do |p|
+    logger.info "#{p.attr('key')} => #{p.content.strip}"
+  end
+end
+
+testbed_topic.subscribe do
+  msgs[:create].publish testbed_topic.id
+end

data/lib/omf_ec/backward/group.rb

@@ -0,0 +1,72 @@
+require 'securerandom'
+
+module OmfEc
+  module Backward
+    module Group
+      # The following are ODEL 5 methods
+
+      # Create an application for the group and start it
+      #
+      def exec(name)
+        create_resource(name, type: 'application', binary_path: name)
+
+        e_uid = SecureRandom.uuid
+
+        e_name = "#{self.name}_application_#{name}_created_#{e_uid}"
+
+        def_event e_name do |state|
+          state.find_all { |v| v[:hrn] == name }.size >= self.members.uniq.size
+        end
+
+        on_event e_name do
+          resources[type: 'application', name: name].state = :run
+        end
+      end
+
+      def startApplications
+        resources[type: 'application'].state = :run
+      end
+
+      def stopApplications
+        resources[type: 'application'].state = :stop
+      end
+
+      def addApplication(name, &block)
+        app_cxt = OmfEc::Context::AppContext.new(name)
+        block.call(app_cxt) if block
+        self.app_contexts << app_cxt
+      end
+
+      # @example
+      #   group('actor', 'node1', 'node2') do |g|
+      #     g.net.w0.ip = '0.0.0.0'
+      #     g.net.e0.ip = '0.0.0.1'
+      #   end
+      def net
+        self.net_ifs ||= []
+        self
+      end
+
+      def method_missing(name, *args, &block)
+        if name =~ /w(\d+)/
+          net = self.net_ifs.find { |v| v.conf[:hrn] == "wlan#{$1}" }
+          if net.nil?
+            net = OmfEc::Context::NetContext.new(:type => 'wlan', :hrn => "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}" }
+          if net.nil?
+            net = OmfEc::Context::NetContext.new(:type => 'net', :hrn => "eth#{$1}", :index => $1)
+            self.net_ifs << net
+          end
+          net
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/omf_ec/context/app_context.rb

@@ -0,0 +1,54 @@
+module OmfEc::Context
+  class AppContext
+    attr_accessor :name, :app_def, :param_values, :oml_collections
+
+    # Keep track of contexts for each app, i.e. multiple contexts can share
+    # the same app def. This happens for example when a group can have the 
+    # same applications added to it many times, but with different parameter 
+    # 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]
+        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}"
+        self
+      else
+        raise RuntimeError, "Cannot create context for unknwon application '#{name}'"
+      end
+    end
+
+    def setProperty(key, value)
+      @param_values[key] = value
+      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 => [] }
+      stream = { :mp => mp , :filters => [] }.merge(filters)
+      collection[:streams] << stream
+      @oml_collections << collection
+    end
+
+    def properties
+      # deep copy the properties from the our app definition
+      original = Marshal.load(Marshal.dump(app_def.properties)) 
+      p = original.merge({:type => 'application'})
+      @param_values.each { |k,v| p[:parameters][k][:value] = v if p[:parameters].key?(k) }
+      if @oml_collections.size > 0
+        p[:use_oml] = true
+        p[:oml][:id] = @name
+        p[:oml][:experiment] = OmfEc.exp.id
+        p[:oml][:collection] = @oml_collections      
+      end
+      p
+    end    
+  end
+end

data/lib/omf_ec/context/def_app_context.rb

@@ -0,0 +1,6 @@
+module OmfEc::Context
+  class DefAppContext
+    attr_accessor :conf
+  end
+end
+

data/lib/omf_ec/context/group_context.rb

@@ -0,0 +1,88 @@
+module OmfEc::Context
+  class GroupContext
+    attr_accessor :group
+    attr_accessor :guard
+    attr_accessor :operation
+
+    def initialize(opts)
+      self.group = opts.delete(:group)
+      self.guard = opts
+      self
+    end
+
+    def [](opts = {})
+      self.guard.merge!(opts)
+      self
+    end
+
+    def method_missing(name, *args, &block)
+      if name =~ /(.+)=/
+        self.operation = :configure
+        name = $1
+      elsif name =~ /release/
+        self.operation = :release
+      else
+        self.operation = :request
+      end
+      send_message(name, *args, &block)
+    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
+      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
+          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)
+          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
+end

data/lib/omf_ec/context/net_context.rb

@@ -0,0 +1,46 @@
+module OmfEc::Context
+  class NetContext
+    # Wifi frequency channel matching
+    FREQUENCY= {
+      1 => 2412, 2 => 2417, 3 => 2422, 4 => 2427, 5 => 2432, 6 => 2437,
+      7 => 2442, 8 => 2447, 9 => 2452, 10 => 2457, 11 => 2462, 12 => 2467,
+      13 => 2472, 14 => 2484, 36 => 5180, 40 => 5200, 44 => 5220, 48 => 5240,
+      52 => 5260, 56 => 5280, 60 => 5300, 64 => 5320, 100 => 5500, 104 => 5520,
+      108 => 5540, 112 => 5560, 116 => 5580, 120 => 5600, 124 => 5620, 128 => 5640,
+      132 => 5660, 136 => 5680, 140 => 5700, 149 => 5745, 153 => 5765, 157 => 5785,
+      161 => 5805, 165 => 5825
+    }
+
+    attr_accessor :conf
+
+    def initialize(opts)
+      self.conf = opts
+      self
+    end
+
+    def method_missing(name, *args, &block)
+      if name =~ /(.+)=/
+        net_prop = $1.to_sym
+        net_prop = case net_prop
+                   when :type then :hw_mode
+                   when :ip then :ip_addr
+                   else
+                     net_prop
+                   end
+        self.conf.merge!(net_prop => args[0])
+      else
+        super
+      end
+    end
+
+    def map_channel_freq
+      if self.conf[:channel] && self.conf[:frequency].nil?
+        self.conf[:frequency] = FREQUENCY[self.conf[:channel].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 }
+      end
+      self
+    end
+  end
+end

data/lib/omf_ec/context.rb

@@ -0,0 +1,10 @@
+require 'omf_ec/context/group_context'
+require 'omf_ec/context/net_context'
+require 'omf_ec/context/app_context'
+require 'omf_ec/context/def_app_context'
+
+module OmfEc
+  module Context
+  end
+end
+