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

data/lib/omf_ec/dsl.rb

@@ -0,0 +1,159 @@
+require 'active_support/core_ext'
+require 'eventmachine'
+
+module OmfEc
+  # DSL methods to be used for OEDL scripts
+  module DSL
+    # 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)
+    end
+
+    # Use EM periodic timer to execute after certain time
+    #
+    # @example do something every 2 seconds
+    #
+    #   every 2.seconds { 'do something' }
+    def every(time, &block)
+      OmfEc.comm.add_periodic_timer(time, block)
+    end
+
+    def def_application(name,&block)
+      app_def = OmfEc::AppDefinition.new(name)
+      OmfEc.exp.app_definitions[name] = app_def
+      block.call(app_def) if block
+    end
+
+    # Define a group, create a pubsub topic for the group
+    #
+    # @param [String] name name of the group
+    #
+    # @example add resource 'a' to group 'bob'
+    #   def_group('bob') do |g|
+    #     g.add_resource('a')
+    #   end
+    #
+    # @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
+    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}
+      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
+    end
+
+    alias_method :all_nodes!, :all_groups
+
+    # Exit the experiment
+    #
+    # @see OmfEc::Experiment.done
+    def done!
+      OmfEc::Experiment.done
+    end
+
+    alias_method :done, :done!
+
+    # Define an experiment property which can be used to bind
+    # to application and other properties. Changing an experiment
+    # property should also change the bound properties, or trigger
+    # commands to change them.
+    #
+    # @param name of property
+    # @param default_value for this property
+    # @param description short text description of this property
+    #
+    def def_property(name, default_value, description = nil)
+      OmfEc.exp.property[name] ||= default_value
+    end
+
+    # Return the context for setting experiment wide properties
+    def property
+      OmfEc.exp.property
+    end
+
+    alias_method :prop, :property
+
+    # Check if all elements in array equal the value provided
+    #
+    def all_equal(array, value = nil, &block)
+      if array.empty?
+        false
+      else
+        if value
+          array.all? { |v| v.to_s == value.to_s }
+        else
+          array.all?(&block)
+        end
+      end
+    end
+
+    # Check if any elements in array equals the value provided
+    #
+    def one_equal(array, value)
+      array.any? ? false : array.all? { |v| v.to_s == value.to_s }
+    end
+
+    # 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
+    end
+
+    # Define an event callback
+    def on_event(name, consume_event = true, &callback)
+      event = OmfEc.exp.events.find { |v| v[:name] == name }
+      if event.nil?
+        raise RuntimeError, "Event '#{name}' not defined"
+      else
+        event[:callbacks] ||= []
+        event[:callbacks] << callback
+        event[:consume_event] = consume_event
+      end
+    end
+
+    include OmfEc::Backward::DSL
+  end
+end

data/lib/omf_ec/experiment.rb

@@ -0,0 +1,71 @@
+require 'hashie'
+require 'singleton'
+
+module OmfEc
+  # Experiment class to hold relevant state information
+  #
+  class Experiment
+    include Singleton
+
+    attr_accessor :property,:state, :comm, :groups, :events, :name, :app_definitions, :sub_groups, :oml_uri
+
+    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 ||= []
+    end
+
+    # Unique experiment id
+    def id
+      @name.nil? ? @id : "#{@name}-#{@id}"
+    end
+
+    # 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)
+            info "Event triggered: '#{event[:name]}'"
+            self.events.delete(event) if event[:consume_event]
+
+            # Last in first serve callbacks
+            event[:callbacks].reverse.each do |callback|
+              callback.call
+            end
+          end
+        end
+      end
+    end
+
+    # Purely for backward compatibility
+    class << self
+      # Disconnect communicator, try to delete any XMPP affiliations
+      def done
+        info "Exit in up to 20 seconds..."
+
+        OmfEc.comm.add_timer(10) do
+          info "Release applications and network interfaces"
+
+          allGroups do |g|
+            g.resources[type: 'application'].release
+            g.resources[type: 'net'].release unless g.net_ifs.find_all { |v| v.conf[:type] == 'net' }.empty?
+            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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omf_ec/group.rb

@@ -0,0 +1,158 @@
+require 'securerandom'
+
+module OmfEc
+  # Group instance used in experiment script
+  #
+  # @!attribute name [String] name of the resource
+  # @!attribute id [String] pubsub topic id of the resource
+  # @!attribute net_ifs [Array] network interfaces defined to be added to group
+  # @!attribute members [Array] holding members to be added to group
+  # @!attribute apps [Array] holding applications to be added to group
+  class Group
+    attr_accessor :name, :id, :net_ifs, :members, :app_contexts
+
+    # @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 = {})
+      @opts = {unique: true}.merge!(opts)
+      self.name = name
+      self.id = @opts[:unique] ? SecureRandom.uuid : self.name
+      # Add empty holders for members, network interfaces, and apps
+      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
+
+              # 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
+
+              c = OmfEc.comm.configure_message(self.id) do |m|
+                m.property(:membership, self.id)
+              end
+
+              c.publish name
+
+              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
+
+              c.on_inform_failed do |i|
+                warn "RC reports failure: '#{i.read_content("reason")}'"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Create a set of new resources and add them to the group
+    #
+    # @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")}'"
+        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
+
+          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
+        end
+      end
+    end
+
+    # @return [OmfEc::Context::GroupContext]
+    def resources
+      OmfEc::Context::GroupContext.new(group: self.id)
+    end
+
+    include OmfEc::Backward::Group
+  end
+end

data/lib/omf_ec/version.rb

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

data/lib/omf_ec.rb

@@ -1,5 +1,38 @@
+require "omf_common"
+require 'omf_ec/backward/dsl'
+require 'omf_ec/backward/group'
+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"
+require "omf_ec/group"
+require "omf_ec/app_definition"
+require "omf_ec/context"
+require "omf_ec/dsl"
 
 module OmfEc
-  # Your code goes here...
+  class << self
+    # Experiment instance
+    #
+    # @return [OmfEc::Experiment]
+    def experiment
+      Experiment.instance
+    end
+
+    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
+  end
 end

data/omf_ec.gemspec

@@ -15,12 +15,11 @@ Gem::Specification.new do |s|
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  #s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.executables   = ["omf_pre"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
   # 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.0.0.pre"
+  s.add_runtime_dependency "gli", "~> 2.4.1"
 end

data/test/omf_ec/context_spec.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'omf_ec/context'
+
+describe OmfEc::Context do
+  before do
+    @context = OmfEc::Context::GroupContext.new(group: 'universe')
+  end
+
+  describe "when initialised with options" do
+    it "must be able to respond to random group operation method" do
+      skip
+    end
+
+    it "must be able to construct guards" do
+      g = @context[name: 'bob'][type: 'engine', group: 'universe'].guard
+      g.must_equal({ name: 'bob', type: 'engine', group: 'universe' })
+    end
+  end
+end

data/test/omf_ec/group_spec.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+require 'omf_ec/group'
+
+describe OmfEc::Group do
+  describe "when initialised" do
+    it "must be generate unique id if :unique option is on" do
+      OmfEc::Group.new('bob').id.wont_equal 'bob'
+    end
+
+    it "must use name as id if :unique option is off" do
+      OmfEc::Group.new('bob', unique: false).id.must_equal 'bob'
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+SimpleCov.start { add_filter "/test" }
+
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/pride'
+
+require 'omf_ec'
+
+# Default fixture directory
+FIXTURE_DIR = "#{File.dirname(__FILE__)}/fixture"
+
+# Shut up all the loggers
+Logging.logger.root.clear_appenders
+
+# Reading fixture file
+def fixture(name)
+  File.read("#{FIXTURE_DIR}/#{name.to_s}")
+end