omf_rc_shm 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTM4MTc2MWI2YzI4ZTQ1NTVhYjJkNmY1ZWRjOWM2MWNkMTJhNmI5Yg==
+  data.tar.gz: !binary |-
+    MWNiMDIzYWEzZDlmMmU2M2UzYTZlMjYwZjZjZjkxZGFiN2FmNDk4NQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ODNkZWU1YWEwYzk0NTIxMTJiMjFmZTg0NDY5Y2M0MWM0Mjk0N2U0NWVkOWM3
+    MDYxNmRhNTFkYmZkYmJlYzljM2RjZTQyODk2NWJhYmNhZjJlZGJlZDQ5MmFm
+    OWQ5MThkNGZlNWFhNzNkNjc4ODZhNjllNmFkODU3OTI3YWM1ZjE=
+  data.tar.gz: !binary |-
+    NGVmNjY1ZTcxOTkzMzE1ZWJmZjAxZDgxNzg3YWUyNzljOWM5MDM2YTY2YTVl
+    MjA2YmRiMjQ1NDlhNTEyYjMyNTcxNzIzM2Y4ZGQyMzQzN2VjZTFlYTRjNzEx
+    NjFlMDZjNDIwNWRiMmRkZjU3ODhiNWRiMWQwYTgxNGI0ZTA5ZjQ=

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+**/*tags

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in omf_rc_shm.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jack C Hong
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# OmfRcShm
+
+An extension to OmfRc provides support for structure health monitoring project
+
+## Installation
+
+Install it as:
+
+    $ gem install omf_rc_shm
+
+Setup startup script
+
+    $ install_omf_rc -c -i
+
+Configure OmfRc to load SHM extension, simply modify '/etc/omf_rc/config.yml' to something like this:
+
+    ---
+    :uri: xmpp://<%= "#{Socket.gethostname}-#{Process.pid}" %>:<%= "#{Socket.gethostname}-#{Process.pid}" %>@srv.mytestbed.net
+    :environment: production
+
+    :resources:
+    - :type: shm_node
+      :uid: <%= Socket.gethostname %>
+      :app_definition_file: <path_to_app_definition_file>
+    :add_default_factories: false
+    :factories:
+    - :require: omf_rc_shm
+
+Where app_definition_file for shm_node simply defines the applications it runs using OEDL defApplication syntax.
+
+Example of defApplication:
+
+    defApplication('otr2') do |a|
+      a.schedule = "* 18 * * *"
+      a.binary_path = "/usr/bin/otr2"
+      a.defProperty('udp_local_host', 'IP address of this Destination node', '--udp:local_host', { :type => :string, :dynamic => false })
+      a.defProperty('udp_local_port', 'Receiving Port of this Destination node', '--udp:local_port', { :type => :integer, :dynamic => false })
+      a.defMeasurement('udp_in') do |m|
+        m.defMetric('flow_id',:long)
+        m.defMetric('seq_no',:long)
+        m.defMetric('pkt_length',:long)
+        m.defMetric('dst_host',:string)
+        m.defMetric('dst_port',:long)
+      end
+    end
+
+## Usage
+
+OmfRc with SHM extension should start up automatically during boot.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/config/rc.yml.sample

@@ -0,0 +1,16 @@
+# Use this with standard omf_rc
+---
+:uri: local://local
+:environment: development
+:debug: false
+
+:resources:
+- :type: shm_node
+  :uid: <%= Socket.gethostname %>
+    :app_definition_file: path_to_your_app_definition_file
+
+    :add_default_factories: false # Not loading default type factories
+
+    :factories: # Additional resources which can be created by this RC
+    - :require: omf_rc_shm
+

data/config/test.rb

@@ -0,0 +1,54 @@
+defApplication('otr2') do |a|
+  a.schedule = "* * * * *"
+  a.timeout = 20
+  a.binary_path = "/usr/bin/otr2"
+  a.description = <<TEXT
+      otr is a configurable traffic sink. It contains port to receive
+      packet streams via various transport options, such as TCP and UDP.
+      This version 2 is compatible with OMLv2.
+TEXT
+
+  a.defProperty('udp_local_host', 'IP address of this Destination node', '--udp:local_host', {:type => :string, :dynamic => false})
+  a.defProperty('udp_local_port', 'Receiving Port of this Destination node', '--udp:local_port', {:type => :integer, :dynamic => false})
+  a.defMeasurement('udp_in') do |m|
+    m.defMetric('flow_id',:long)
+    m.defMetric('seq_no',:long)
+    m.defMetric('pkt_length',:long)
+    m.defMetric('dst_host',:string)
+    m.defMetric('dst_port',:long)
+  end
+end
+
+defApplication('otg2') do |a|
+  a.schedule = "* * * * *"
+  a.timeout = 20
+  a.binary_path = "/usr/bin/otg2"
+  a.description = <<TEXT
+      OTG is a configurable traffic generator. It contains generators
+      producing various forms of packet streams and port for sending
+      these packets via various transports, such as TCP and UDP.
+      This version 2 is compatible with OMLv2
+TEXT
+
+  a.defProperty('generator', 'Type of packet generator to use (cbr or expo)', '-g', {:type => :string, :dynamic => false})
+  a.defProperty('udp_broadcast', 'Broadcast', '--udp:broadcast', {:type => :integer, :dynamic => false})
+  a.defProperty('udp_dst_host', 'IP address of the Destination', '--udp:dst_host', {:type => :string, :dynamic => false})
+  a.defProperty('udp_dst_port', 'Destination Port to send to', '--udp:dst_port', {:type => :integer, :dynamic => false})
+  a.defProperty('udp_local_host', 'IP address of this Source node', '--udp:local_host', {:type => :string, :dynamic => false})
+  a.defProperty('udp_local_port', 'Local Port of this source node', '--udp:local_port', {:type => :integer, :dynamic => false})
+  a.defProperty("cbr_size", "Size of packet [bytes]", '--cbr:size', {:dynamic => true, :type => :integer})
+  a.defProperty("cbr_rate", "Data rate of the flow [kbps]", '--cbr:rate', {:dynamic => true, :type => :integer})
+  a.defProperty("exp_size", "Size of packet [bytes]", '--exp:size', {:dynamic => true, :type => :integer})
+  a.defProperty("exp_rate", "Data rate of the flow [kbps]", '--exp:rate', {:dynamic => true, :type => :integer})
+  a.defProperty("exp_ontime", "Average length of burst [msec]", '--exp:ontime', {:dynamic => true, :type => :integer})
+  a.defProperty("exp_offtime", "Average length of idle time [msec]", '--exp:offtime', {:dynamic => true, :type => :integer})
+  a.defMeasurement('udp_out') do |m|
+    m.defMetric('ts',:float)
+    m.defMetric('flow_id',:long)
+    m.defMetric('seq_no',:long)
+    m.defMetric('pkt_length',:long)
+    m.defMetric('dst_host',:string)
+    m.defMetric('dst_port',:long)
+  end
+end
+

data/lib/omf_rc/resource_proxy/scheduled_application.rb

@@ -0,0 +1,522 @@
+# Copyright (c) 2013 National ICT Australia Limited (NICTA).
+# This software may be used and distributed solely under the terms of the MIT license (License).
+# You should find a copy of the License in LICENSE.TXT or at http://opensource.org/licenses/MIT.
+# By downloading or using this software you accept the terms and the liability disclaimer in the License.
+
+# This module defines a Resource Proxy (RP) for an Application.
+# For a detailed usage tutorial see {file:doc/RESOURCE\_PROXY.mkd Resource Proxy tutorial}
+#
+# Utility dependencies: platform_toos, common_tools
+#
+# This Application Proxy has the following properties:
+#
+# - binary_path (String) the path to the binary of this app
+# - state (String) the state of this Application RP
+#   (unscheduled, scheduled)
+# - map_err_to_out (Boolean) if true then map StdErr to StdOut for this
+#   app (default false)
+# - platform (Symbol) the OS platform where this app is scheduled
+# - environment (Hash) the environment variables to set prior to starting
+#   this app. { k1 => v1, ... } will result in "env -i K1=v1 ... "
+#   (with k1 being either a String or a Symbol)
+# - use_oml (Boolean) if true enable OML for this application (default false)
+# - oml_loglevel (Integer) set a specific OML log level (default unset)
+# - oml_logfile (String) set a specific path for OML log file (default unset)
+# - oml_configfile (String) path of the OML config file (optional)
+# - oml (Hash) OML specific properties (optional), this Hash contains the
+#   following keys:
+#       - :available_mps (Array) list of available OML Measurement Points (Hash)
+#       - :collection (Hash) list of required OML Measurement Stream to collect
+#           when this application is scheduled (defined in liboml2.conf manpage)
+#           http://omf.mytestbed.net/doc/oml/html/liboml2.conf.html
+#       - :experiment (String) name of the experiment in which this application
+#           is scheduled
+#       - :id (String) OML id to use for this application when it is scheduled
+# - parameters (Hash) the command line parameters available for this app.
+#   This hash is of the form: { :param1 => attribut1, ... }
+#   with param1 being the id of this parameter for this Proxy and
+#   with attribut1 being another Hash with the following possible
+#   keys and values (all are optional):
+#     :cmd (String) the command line for this parameter
+#     :order (Fixnum) the appearance order on the command line, default FIFO
+#     :dynamic (Boolean) parameter can be dynammically changed, default false
+#     :type (Numeric|String|Boolean) this parameter's type
+#     :default value given by default to this parameter
+#     :value value to set for this parameter
+#     :mandatory (Boolean) this parameter is mandatory, default false
+#
+# Note: this application proxy will merge new Hash values for the properties
+# environment, oml, and parameters properties with the old Hash values.
+#
+# Two examples of valid parameters definition are:
+#
+#     { :host => {:default => 'localhost', :type => 'String',
+#             :mandatory => true, :order => 2},
+#       :port => {:default => 5000, :type => 'Numeric', :cmd => '-p',
+#             :mandatory => true, :order => 1},
+#       :size => {:default => 512, :type => 'Numeric', :cmd => '--pkt-size',
+#             :mandatory => true, :dynamic => true}
+#       :title => {:type => 'String', :mandatory => false}
+#     }
+#
+# and
+#
+#     { :title => {:value => "My First Application"} }
+#
+
+require 'cronedit'
+require 'listen'
+
+module OmfRc::ResourceProxy::ScheduledApplication
+  include OmfRc::ResourceProxyDSL
+  # @!macro extend_dsl
+
+  require 'omf_common/exec_app'
+
+  register_proxy :scheduled_application
+  # @!parse include OmfRc::Util::PlatformTools
+  # @!parse include OmfRc::Util::CommonTools
+  utility :platform_tools
+  utility :common_tools
+
+  MAX_PARAMETER_NUMBER = 1000
+  DEFAULT_MANDATORY_PARAMETER = false
+
+  property :app_id, :default => nil
+  property :description, :default => ''
+  property :binary_path, :default => nil
+  property :platform, :default => nil
+  property :state, :default => :unscheduled
+  property :map_err_to_out, :default => false
+  property :event_sequence, :default => 0
+  property :parameters, :default => Hashie::Mash.new
+  property :environments, :default => Hashie::Mash.new
+  property :use_oml, :default => false
+  property :oml_configfile, :default => nil
+  property :oml, :default => Hashie::Mash.new
+  property :oml_logfile, :default => nil
+  property :oml_loglevel, :default => nil
+  property :schedule, :default => nil
+  property :timeout, :default => 0
+  property :timeout_kill_signal, :default => 'TERM'
+  property :file_change_listener, :default => nil
+  property :file_change_callback, :default => nil
+  property :file_read_offset, :default => {}
+  property :app_log_dir, :default => '/tmp/omf_scheduled_app'
+
+  # @!macro group_hook
+  #
+  # hook :before_ready do |res|
+    # define_method("on_app_event") { |*args| process_event(self, *args) }
+  # end
+
+  hook :before_release do |app|
+    app.configure_state(:unscheduled)
+  end
+
+  # @!macro hook
+  # @!method after_initial_configured
+  hook :after_initial_configured do |res|
+    # if state was set to scheduled from the create we need
+    # to make sure that this happens!
+    if res.property.state.to_s.downcase.to_sym == :scheduled
+      res.property.state = :unscheduled
+      res.switch_to_scheduled
+    end
+  end
+
+  # @!endgroup
+
+  # This method processes an event coming from the application instance, which
+  # was started by this Resource Proxy (RP). It is a callback, which is usually
+  # called by the ExecApp class in OMF
+  #
+  # @param [AbstractResource] res this RP
+  # @param [String] event_type the type of event from the app instance
+  #                 (STARTED, EXIT, STDOUT, STDERR)
+  # @param [String] app_id the id of the app instance
+  # @param [String] msg the message carried by the event
+  def process_event(res, event_type, app_id, msg)
+      logger.info "App Event from '#{app_id}' "+
+                  "(##{res.property.event_sequence}) - "+
+                  "#{event_type}: '#{msg}'"
+      res.property.event_sequence += 1
+      if event_type == 'EXIT'
+        res.property.state = :unscheduled
+        res.inform(:status, {
+                        status_type: 'APP_EVENT',
+                        event: event_type.to_s.upcase,
+                        app: app_id,
+                        exit_code: msg,
+                        msg: msg,
+                        state: res.property.state,
+                        seq: res.property.event_sequence,
+                        uid: res.uid # do we really need this? Should be identical to 'src'
+                      }, :ALL)
+      else
+        res.inform(:status, {
+                      status_type: 'APP_EVENT',
+                      event: event_type.to_s.upcase,
+                      app: app_id,
+                      msg: msg,
+                      seq: res.property.event_sequence,
+                      uid: res.uid
+                    }, :ALL)
+      end
+  end
+
+  # @!macro group_request
+  #
+  # Request the platform property of this Application RP
+  # @see OmfRc::ResourceProxy::Application
+  #
+  # @!macro request
+  # @!method request_platform
+  request :platform do |res|
+    res.property.platform = detect_platform if res.property.platform.nil?
+    res.property.platform.to_s
+  end
+
+  # @!endgroup
+  # @!macro group_configure
+
+  # Configure the environments and oml property of this Application RP
+  # @see OmfRc::ResourceProxy::Application
+  #
+  #
+  # @!macro configure
+  # @!method conifgure_environments
+  # @!method conifgure_oml
+  %w(environments oml).each do |prop|
+    configure(prop) do |res, value|
+      if value.kind_of? Hash
+        res.property[prop] = res.property[prop].merge(value)
+      else
+        res.log_inform_error "Configuration failed for '#{prop}'! "+
+          "Value not passed as Hash (#{value.inspect})"
+      end
+      res.property[prop]
+    end
+  end
+
+  # Configure the parameters property of this Application RP
+  #
+  # @!macro configure
+  # @see OmfRc::ResourceProxy::Application
+  # @!method configure_parameters
+  #
+  configure :parameters do |res, params|
+    if params.kind_of? Hash
+      params.each do |p,v|
+        if v.kind_of? Hash
+          # if this param has no set order, then assign the highest number to it
+          # this will allow sorting the parameters later
+          v[:order] = MAX_PARAMETER_NUMBER if v[:order].nil?
+          # if this param has no set mandatory field, assign it a default one
+          v[:mandatory] = DEFAULT_MANDATORY_PARAMETER if v[:mandatory].nil?
+          new_val = res.property.parameters[p].nil? ? v : res.property.parameters[p].merge(v)
+          # only set this new parameter if it passes the type check
+          if res.pass_type_checking?(new_val)
+            res.property.parameters[p] = new_val
+            #res.dynamic_parameter_update(p,new_val)
+          else
+            res.log_inform_error "Configuration of parameter '#{p}' failed "+
+              "type checking. Defined type is #{new_val[:type]} while assigned "+
+              "value/default are #{new_val[:value].inspect} / "+
+              "#{new_val[:default].inspect}"
+          end
+        else
+          res.log_inform_error "Configuration of parameter '#{p}' failed!"+
+            "Options not passed as Hash (#{v.inspect})"
+        end
+      end
+    else
+      res.log_inform_error "Parameter configuration failed! Parameters not "+
+        "passed as Hash (#{params.inspect})"
+    end
+    res.property.parameters
+  end
+
+  # Configure the state of this Application RP. The valid states are
+  # unscheduled, scheduled, paused. The semantic of each states are:
+  #
+  # - unscheduled: the initial state for an Application RP
+  # - completed: the final state for an application RP. When the application
+  #   has been executed and its execution is finished, it enters this state.
+  #   When the application is completed it cannot change state again
+  #   TODO: maybe in future OMF, we could consider allowing an app to be reset?
+  # - scheduled: upon entering in this state, a new instance of the application is
+  #   started, the Application RP stays in this state until the
+  #   application instance is finished or paused. The Application RP can
+  #   only enter this state from a previous paused or unscheduled state.
+  # - paused: upon entering this state, the currently scheduled instance of this
+  #   application should be paused (it is the responsibility of
+  #   specialised Application Proxy to ensure that! This default
+  #   Application Proxy does nothing to the application instance when
+  #   entering this state). The Application RP can only enter this
+  #   state from a previous scheduled state.
+  #
+  # @param [String] value the state to set this app into
+  # @!macro configure
+  # @!method configure_state
+  configure :state do |res, value|
+    OmfCommon.eventloop.after(0) do
+      case value.to_s.downcase.to_sym
+      when :unscheduled then res.switch_to_unscheduled
+      when :scheduled then res.switch_to_scheduled
+      else
+        res.log_inform_warn "Cannot switch application to unknown state '#{value.to_s}'!"
+      end
+    end
+    res.property.state
+  end
+
+  # @!endgroup
+
+  # @!macro group_work
+
+  # Switch this Application RP into the 'unscheduled' state
+  # (see the description of configure :state)
+  #
+  # @!macro work
+  # @!method switch_to_unscheduled
+  work('switch_to_unscheduled') do |res|
+    if res.property.state == :scheduled
+      info "Removing cron job for #{res.property.app_id} with command #{res.build_command_line}"
+      CronEdit::Crontab.Remove res.property.app_id
+      res.property.file_change_listener.stop
+      res.property.state = :unscheduled
+    end
+  end
+
+  # Switch this Application RP into the 'scheduled' state
+  # (see the description of configure :state)
+  #
+  # @!macro work
+  # @!method switch_to_scheduled
+  work('switch_to_scheduled') do |res|
+    if res.property.state == :unscheduled
+      # start a new instance of this app
+      res.property.app_id = res.hrn.nil? ? res.uid : res.hrn
+      # we need at least a defined binary path to run an app...
+      if res.property.binary_path.nil?
+        res.log_inform_warn "Binary path not set! No Application to run!"
+      elsif res.property.schedule.nil?
+        res.log_inform_warn "No schedule given!"
+      else
+        Dir.mkdir(res.property.app_log_dir) if !Dir.exist?(res.property.app_log_dir)
+        stderr_file = "#{res.property.app_log_dir}/#{res.property.app_id}.err.log"
+        stdout_file = "#{res.property.app_log_dir}/#{res.property.app_id}.out.log"
+        File.delete(stderr_file) if File.exist?(stderr_file)
+        File.delete(stdout_file) if File.exist?(stdout_file)
+        cmd = "#{res.build_command_line} 2>>#{stderr_file} 1>>#{stdout_file} ; echo \"Application '#{res.property.app_id}' exited with code $? \" >>#{stderr_file}"
+        if res.property.timeout > 0
+          cmd = "timeout -s #{res.property.timeout_kill_signal} #{res.property.timeout} #{cmd}"
+        end
+        info "Adding cron job for '#{res.property.app_id}' with schedule '#{res.property.schedule}' and command '#{cmd}'"
+        CronEdit::Crontab.Add res.property.app_id, "#{res.property.schedule} #{cmd}"
+#        ExecApp.new(res.property.app_id,
+#                    res.build_command_line,
+#                    res.property.map_err_to_out) do |event_type, app_id, msg|
+#                      res.process_event(res, event_type, app_id, msg)
+#                    end
+        res.property.file_change_callback = Proc.new do |modified, added, removed|
+          removed.each do |file|
+            res.property.file_read_offset[file]=nil
+          end
+          files = added + modified
+          files.each do |file|
+            if file.include? stderr_file or file.include? stdout_file
+              res.property.file_read_offset[file]=0 if res.property.file_read_offset[file].nil?
+              p res.property.file_read_offset[file]
+              data = IO.read(file,nil,res.property.file_read_offset[file])
+              res.property.file_read_offset[file]+=data.length
+              data.split(/\r?\n/).each do |line|
+                event_type = (file.include? ".err.log") ? "STDERR" : "STDOUT"
+                res.process_event(res, event_type, res.property.app_id, line)
+              end
+            end
+          end
+        end
+        res.property.file_change_listener = Listen.to(res.property.app_log_dir).change(&res.property.file_change_callback)
+        res.property.file_change_listener.start
+        res.property.state = :scheduled
+      end
+    else
+      res.log_inform_warn "Cannot switch to scheduled state as current state is '#{res.property.state}'"
+    end
+  end
+
+  # Check if a configured value or default for a parameter has the same
+  # type as the type defined for that parameter
+  # The checking procedure is as follows:
+  # - first check if a type was set for this parameter, if not then return true
+  #   (thus if no type was defined for this parameter then return true
+  #   regardless of the type of the given value or default)
+  # - second check if a value is given, if so check if it has the same type as
+  #   the defined type, if so then return true, if not then return false.
+  # - third if no value is given but a default is given, then perform the same
+  #   check as above but using the default in-place of the value
+  #
+  # @param [Hash] att the Hash holding the parameter's attributs
+  #
+  # @return [Boolean] true or false
+  # @!macro work
+  work('pass_type_checking?') do |res,att|
+    passed = false
+    unless att[:type].nil?
+      if att[:type] == 'Boolean' # HACK: as Ruby does not have a Boolean type
+        if !att[:default].nil? && !att[:value].nil?
+          passed = true if res.boolean?(att[:default]) && res.boolean?(att[:value])
+        elsif att[:default].nil? && att[:value].nil?
+          passed = true
+        elsif att[:default].nil?
+          passed = true if res.boolean?(att[:value])
+        elsif att[:value].nil?
+          passed = true if res.boolean?(att[:default])
+        end
+      else # Now for all other types...
+        klass = Module.const_get(att[:type].capitalize.to_sym)
+        if !att[:default].nil? && !att[:value].nil?
+          passed = true if att[:default].kind_of?(klass) && att[:value].kind_of?(klass)
+        elsif att[:default].nil? && att[:value].nil?
+          passed = true
+        elsif att[:default].nil?
+          passed = true if att[:value].kind_of?(klass)
+        elsif att[:value].nil?
+          passed = true if att[:default].kind_of?(klass)
+        end
+      end
+    else
+      passed = true
+    end
+    passed
+  end
+
+  # Build the command line, which will be used to start this app.
+  #
+  # This command line will be of the form:
+  # "env -i VAR1=value1 ... application_path parameterA valueA ..."
+  #
+  # The environment variables and the parameters in that command line are
+  # taken respectively from the 'environments' and 'parameters' properties of
+  # this Application Resource Proxy. If the 'use_oml' property is set, then
+  # add to the command line the necessary oml parameters.
+  #
+  # @return [String] the full command line
+  # @!macro work
+  work('build_command_line') do |res|
+    cmd_line = "env -i " # Start with a 'clean' environment
+    res.property.environments.each do |e,v|
+      val = v.kind_of?(String) ? "'#{v}'" : v
+      cmd_line += "#{e.to_s.upcase}=#{val} "
+    end
+    cmd_line += res.property.binary_path + " "
+    # Add command line parameter in their specified order if any
+    sorted_parameters = res.property.parameters.sort_by {|k,v| v[:order] || -1}
+    sorted_parameters.each do |param,att|
+      needed = false
+      needed = att[:mandatory] if res.boolean?(att[:mandatory])
+      # For mandatory parameter without a value, take the default one
+      val = (needed && att[:value].nil?) ? att[:default] : att[:value]
+      # Finally add the parameter if is value/default is not nil
+      unless val.nil?
+        if att[:type] == "Boolean"
+          # for Boolean param, only the command is printed if value==true
+          cmd_line += "#{att[:cmd]} " if val == true
+        else
+          # for all other type of param, we print "cmd value"
+          # with a user-provided prefix/suffix if defined
+          cmd_line += "#{att[:cmd]} "
+          cmd_line += att[:prefix].nil? ? "#{val}" : "#{att[:prefix]}#{val}"
+          cmd_line += att[:suffix].nil? ? " " : "#{att[:suffix]} "
+        end
+      end
+    end
+    # Add OML parameters if required
+    cmd_line = res.build_oml_config(cmd_line) if res.property.use_oml
+    cmd_line
+  end
+
+  # Add the required OML parameter to the command line for this application
+  #
+  # - if the 'oml_configfile' property is set with a filename, then we use that
+  #   file as the OML Configuration file. Thus we add the parameter
+  #   "--oml-config filename" to this application's command line
+  # - if the 'oml' property is set with a Hash holding an OML configuration,
+  #   then we write turn it into OML's XML configuration representation, write
+  #   it to a temporary file, and add the parameter "--oml-config tmpfile" to
+  #   this application's command line. The OML configuration hash is based
+  #   on the liboml2.conf man page, an example of which is:
+  #       <omlc domain="my_experiment" id="my_source_id">
+  #         <collect url="tcp://10.0.0.200">
+  #           <stream mp="radiotap" interval="2">
+  #             <filter field="sig_strength_dBm" />
+  #             <filter field="noise_strength_dBm" />
+  #             <filter field="power" />
+  #           </stream>
+  #           <stream mp="udp" samples="10">
+  #             <filter field="udp_len" />
+  #           </stream>
+  #         </collect>
+  #       </omlc>
+  #
+  # The 'oml_configfile' case takes precedence over the 'oml' case above.
+  #
+  # Regardless of which case is performed, we will always set the
+  # '--oml-log-level' and '--oml-log-file' parameter on the command line if
+  # the corresponsding 'oml_logfile' and 'oml_loglevel' properties are set for
+  # this application resource.
+  #
+  # @param [String] cmd the String to which OML parameters will be added
+  #
+  # @return [String] the resulting command line
+  # @!macro work
+  work('build_oml_config') do |res, cmd|
+    if !res.property.oml_configfile.nil?
+      if File.exist?(res.property.oml_configfile)
+        cmd += "--oml-config #{res.property.oml_configfile} "
+      else
+        res.log_inform_warn "OML enabled but OML config file does not exist"+
+        "(file: '#{res.property.oml_configfile}')"
+      end
+    elsif !res.property.oml.collection.nil?
+      o = res.property.oml
+      ofile = "/tmp/#{res.uid}-#{Time.now.to_i}.xml"
+      of = File.open(ofile,'w')
+      of << "<omlc experiment='#{o.experiment}' id='#{o.id}'>\n"
+      o.collection.each do |c|
+        of << "  <collect url='#{c.url}'>\n"
+        c.streams.each do |m|
+          # samples as precedence over interval
+          s = ''
+          s = "interval='#{m.interval}'" if m.interval
+          s = "samples='#{m.samples}'" if m.samples
+          of << "    <stream mp='#{m.mp}' #{s}>\n"
+          unless m.filters.nil?
+            m.filters.each do |f|
+              line = "      <filter field='#{f.field}' "
+              line += "operation='#{f.operation}' " unless f.operation.nil?
+              line += "rename='#{f.rename}' " unless f.rename.nil?
+              line += "/>\n"
+              of << line
+            end
+          end
+          of << "    </stream>\n"
+        end
+        of << "  </collect>\n"
+      end
+      of << "</omlc>\n"
+      of.close
+      cmd += "--oml-config #{ofile}"
+    else
+      res.log_inform_warn "OML enabled but no OML configuration was given"+
+        "(file: '#{res.property.oml_configfile}' - "+
+        "config: '#{res.property.oml.inspect}')"
+    end
+    cmd += "--oml-log-level #{res.property.oml_loglevel} " unless res.property.oml_loglevel.nil?
+    cmd += "--oml-log-file #{res.property.oml_logfile} " unless res.property.oml_logfile.nil?
+    cmd
+  end
+
+end

data/lib/omf_rc/resource_proxy/shm_node.rb

@@ -0,0 +1,27 @@
+module OmfRc::ResourceProxy::ShmNode
+  include OmfRc::ResourceProxyDSL
+
+  register_proxy :shm_node
+
+  property :app_definition_file
+
+  request :cron_jobs do |node|
+    node.children.find_all { |v| v.type =~ /scheduled_application/ }.map do |v|
+      { name: v.hrn, type: v.type, uid: v.uid }
+    end.sort { |x, y| x[:name] <=> y[:name] }
+  end
+
+  hook :after_initial_configured do |node|
+    OmfRcShm.app.load_definition(node.request_app_definition_file)
+
+    OmfRcShm.app.definitions.each do |d|
+      info "Got definition #{d.inspect}, now schedule them..."
+      app_id = d[0]
+      app_opts = d[1].properties.merge(hrn: app_id, use_oml: true)
+      s_app = OmfRc::ResourceFactory.create(:scheduled_application, app_opts)
+      OmfCommon.el.after(5) do
+        s_app.configure_state(:scheduled)
+      end
+    end
+  end
+end

data/lib/omf_rc_shm/app/definition.rb

@@ -0,0 +1,138 @@
+require 'securerandom'
+
+module OmfRcShm
+class App
+  # Application Definition used in experiment script
+  #
+  # @!attribute name [String] name of the resource
+  class Definition
+
+    # 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 = Hashie::Mash.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] = Hashie::Mash.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] = 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
+      else
+        error "Cannot define Measurement Point for app '#{self.name}'! MP "+
+          "not passed as a Hash ('#{mp.inspect}')"
+      end
+    end
+
+    warn_removed :version
+
+    def path=(arg)
+      @properties[:binary_path] = arg
+      warn_deprecation :path=, :binary_path=
+    end
+
+    def shortDescription=(arg)
+      @properties[:description] = arg
+      warn_deprecation :shortDescription=, :description=
+    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
+
+    # The following are OEDL 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 property to define (mandatory)
+    # @param [String] description description of this property; oml2-scaffold uses this for the help message (popt: descrip)
+    # @param [String] parameter command-line parameter to introduce this property, including dashes if needed (can be nil)
+    # @param [Hash] options list of options associated with this property
+    # @option options [String] :type type of the property: :integer, :string and :boolean are supported; oml2-scaffold extends this with :int and :double (popt: argInfo)
+    # @option options [Boolean] :dynamic true if the property can be changed at run-time
+    # @option options [Fixnum] :order used to order properties when creating the command line
+    #
+    # The OML code-generation tool, oml2-scaffold extends the range of
+    # options supported in the options hash to support generation of
+    # popt(3) command line parsing code. As for the parameters, depending
+    # on the number of dashes (two/one) in parameter, it is used as the
+    # longName/shortName for popt(3), otherwise the former defaults to
+    # name, and the latter defaults to either :mnemonic or nothing.
+    #
+    # @option options [String] :mnemonic one-letter mnemonic for the option (also returned by poptGetNextOpt as val)
+    # @option options [String] :unit unit in which this property is expressed; oml2-scaffold uses this for the help message (popt: argDescrip)
+    # @option options [String] :default default value if argument unspecified (optional; defaults to something sane for the :type)
+    # @option options [String] :var_name name of the C variable for popt(3) to store the property value into (optional; popt: arg; defaults to name, after sanitisation)
+    #
+    # @see http://oml.mytestbed.net/doc/oml/latest/oml2-scaffold.1.html
+    # @see http://linux.die.net/man/3/popt
+    #
+    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
+
+    # Define metrics to measure
+    #
+    # @param [String] name of the metric
+    # @param [Symbol] type of the metric data. For all supporting metric data types, refers to http://oml.mytestbed.net/doc/oml/latest/oml2-scaffold.1.html#_mp_defmetric_name_type
+    # @param [Hash] opts additional options
+    #
+    # @option opts [String] :unit unit of measure of the metric
+    # @option opts [String] :description of the metric
+    # @option opts [Float] :precision precision of the metric value
+    # @option opts [Range] :range value range of the metric
+    #
+    # @example OEDL
+    #   app.defMeasurement("power") do |mp|
+    #     mp.defMetric('power', :double, :unit => "W", :precision => 0.1, :description => 'Power')
+    #   end
+    def defMetric(name,type, opts = {})
+      # the third parameter used to be a description string
+      opts = {:description => opts} if opts.class!=Hash
+      @fields << {:field => name, :type => type}.merge(opts)
+    end
+
+    # XXX: This should be provided by the omf-oml glue.
+    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_rc_shm/app/dsl.rb

@@ -0,0 +1,13 @@
+module OmfRcShm
+class App
+  module DSL
+    def defApplication(uri, name=nil ,&block)
+      name = uri if name.nil?
+      app_def = OmfRcShm::App::Definition.new(name)
+      OmfRcShm.app.definitions[name] = app_def
+      info "Adding new definition #{name}"
+      block.call(app_def) if block
+    end
+  end
+end
+end

data/lib/omf_rc_shm/app.rb

@@ -0,0 +1,21 @@
+require 'omf_rc_shm/app/dsl'
+require 'omf_rc_shm/app/definition'
+require 'singleton'
+
+module OmfRcShm
+  class App
+    include Singleton
+    include OmfRcShm::App::DSL
+
+    attr_accessor :definitions
+
+    def initialize
+      super
+      @definitions ||= Hash.new
+    end
+
+    def load_definition(file_path)
+      eval(File.read(file_path))
+    end
+  end
+end

data/lib/omf_rc_shm/version.rb

@@ -0,0 +1,3 @@
+module OmfRcShm
+  VERSION = "0.0.1"
+end

data/lib/omf_rc_shm.rb

@@ -0,0 +1,12 @@
+require "omf_rc_shm/version"
+require "omf_rc_shm/app"
+
+require "omf_rc/resource_proxy/shm_node"
+require "omf_rc/resource_proxy/scheduled_application"
+
+module OmfRcShm
+  def self.app
+    OmfRcShm::App.instance
+  end
+end
+

data/omf_rc_shm.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'omf_rc_shm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "omf_rc_shm"
+  spec.version       = OmfRcShm::VERSION
+  spec.authors     = ["NICTA"]
+  spec.email       = ["omf-user@lists.nicta.com.au"]
+  spec.summary       = "OMF resource proxy extension for SHM project"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "omf_rc", "~> 6.0.5"
+  spec.add_runtime_dependency "cronedit"
+  spec.add_runtime_dependency "listen"
+end

data/test/scheduled_app_controller.rb

@@ -0,0 +1,15 @@
+# Need omf_rc gem to be required
+#
+require 'omf_rc'
+require 'omf_rc_shm'
+
+# This init method will set up your run time environment,
+# communication, eventloop, logging etc. We will explain that later.
+#
+OmfCommon.init(:development, communication: { url: 'xmpp://norbit.npc.nicta.com.au' }) do
+  OmfCommon.comm.on_connected do |comm|
+    info "Scheduled application controller >> Connected to XMPP server"
+    sched_app = OmfRc::ResourceFactory.create(:scheduled_application, uid: 'my_scheduled_app')
+    comm.on_interrupted { sched_app.disconnect }
+  end
+end

data/test/scheduled_app_tester.rb

@@ -0,0 +1,59 @@
+# Use omf_common communicator directly
+#
+require 'omf_common'
+$stdout.sync = true
+
+def run_test(app)
+  # Set up inform message handler to print inform messages
+  app.on_inform do |m|
+    case m.itype
+    when 'STATUS'
+      if m[:status_type] == 'APP_EVENT'
+        info "APP_EVENT #{m[:event]} from app #{m[:app]} - msg: #{m[:msg]}"
+      end
+    when 'ERROR'
+      error m[:reason]
+    when 'WARN'
+      warn m[:reason]
+    end
+  end
+
+  # Configure the 'binary_path' and 'parameters' properties of the App Proxy
+  app.configure(binary_path: "date",
+                oml_configfile: "/Users/cdw/tempo/omf_rc_shm/README.md",
+#                use_oml: true,
+                schedule: "* * * * *")
+
+  # Start the application 2 seconds later
+  OmfCommon.eventloop.after 1 do
+    app.configure(state: :scheduled)
+  end
+
+  # Stop the application another 10 seconds later
+  OmfCommon.eventloop.after 120 do
+    app.configure(state: :unscheduled)
+  end
+end
+#
+OmfCommon.init(:development, communication: { url: 'xmpp://norbit.npc.nicta.com.au' }) do
+  # Event :on_connected will be triggered when connected to XMPP server
+  #
+  OmfCommon.comm.on_connected do |comm|
+    info "Connected to XMPP"
+
+    comm.subscribe('my_scheduled_app') do |sched_app|
+      unless sched_app.error?
+        run_test(sched_app)
+      else
+        error sched_app.inspect
+      end
+    end
+
+    # Eventloop allows to control the flow, in this case, we disconnect after 5 seconds.
+    #
+    OmfCommon.eventloop.after(300) { comm.disconnect }
+    # If you hit ctrl-c, we will disconnect too.
+    #
+    comm.on_interrupted { comm.disconnect }
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: omf_rc_shm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- NICTA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: omf_rc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 6.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 6.0.5
+- !ruby/object:Gem::Dependency
+  name: cronedit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- omf-user@lists.nicta.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/rc.yml.sample
+- config/test.rb
+- lib/omf_rc/resource_proxy/scheduled_application.rb
+- lib/omf_rc/resource_proxy/shm_node.rb
+- lib/omf_rc_shm.rb
+- lib/omf_rc_shm/app.rb
+- lib/omf_rc_shm/app/definition.rb
+- lib/omf_rc_shm/app/dsl.rb
+- lib/omf_rc_shm/version.rb
+- omf_rc_shm.gemspec
+- test/scheduled_app_controller.rb
+- test/scheduled_app_tester.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.7
+signing_key: 
+specification_version: 4
+summary: OMF resource proxy extension for SHM project
+test_files:
+- test/scheduled_app_controller.rb
+- test/scheduled_app_tester.rb